mintid-verifier-sdk

The MintID Verifier SDK (import name verifier_core): the single verifying core of MintID, for the relying party's own verifier. It validates a holder's presentation against the challenge it answers, either in your own process (embedded) or behind a thin HTTP service you deploy yourself next to your backend (service mode, which the TypeScript client and the MCP server talk to). The Rust proof engine is compiled in at a pinned version, so a supported install cannot end up with a substituted engine.

Where it fits

MintID is a network for verifiable, human-backed identity. Accepted issuers verify people and issue the credentials; the chain publishes their status roots, their bonds and the registries; each verifier decides on its own service. MintID itself issues nothing, certifies nothing and verifies nobody.

The verifier is your own service, and the decision is yours: nothing else validates a presentation, and pointing a client at somebody else's verifier service would delegate the decision itself. Installing the SDK does not make you a verifier: your verifier is registered on the chain, with its exact origins and its request-signing keys, before any presentation can be accepted (see becoming a verifier).

What the SDK enforces, as constants and closed types rather than settings: every acceptance condition runs in full and in order on every presentation; a presentation lives 10 seconds; chain reads are proven or they do not count; and the only thing kept is a minimal decision record, into which proof bytes, claim values and personal data do not fit.

Install

pip install mintid-verifier-sdk   # Python 3.12 or later, no runtime dependencies

Where no wheel matches your platform, pip builds it from the source distribution, which needs a Rust toolchain. Version 0.5.1, published from the main repository, https://gitlab.com/mintid/mintid (verifier-core).

New in 0.2. Request signers for the service: every challenge is signed with your registered request key, held in AWS KMS (extra [kms]) or a software seed file for local stacks (extra [software-signer]); holders refuse unsigned challenges from this release of the holder library on, so a service that signs nothing is for a devnet only (--insecure-unsigned-challenges). Every decision record names its evidence, the deciding condition and its vocabulary (SPEC-1 v3.2, R18); reason codes are unchanged. The engine pin is proof-core 0.4.0 (its verifying surface is unchanged from 0.3.0).

New in 0.4. The agent profile v2 (verifier contract 1.7.0, ADR-0025): a challenge may ask for profile: agent_v2, whose claim policy is an agent_v1 one plus at most one age_over entry, proven on the agent's principal age floor. Identity and agent_v1 challenges and decisions are unchanged. The engine pin is proof-core 0.5.0.

New in 0.5. The requester side of the agent-to-agent handshake (HandshakeClient) lives in mintid-agent (mintid_agent.handshake): verifier_core.a2a.HandshakeClient resolves to the same class when mintid-agent is installed, and raises an ImportError naming the package when it is not. The gate (HandshakeGate) is unchanged and needs nothing more. Verification results are unchanged; the engine pin stays proof-core 0.5.0.

New in 0.5.1. Faster checks, the same results: the engine's range-proof generators are built once per process and its Bulletproofs library is vendored with plain scalar multiplication in the prover (the verifying surface is unchanged); a presentation is checked in about 60 % of the time. The engine pin stays proof-core 0.5.0.

Example

from verifier_core.build import build_info
from verifier_core.presentation import validate_presentation

print(build_info())  # the pins of this artifact: engine, conformance suite, …

decision = validate_presentation(
    request,            # PresentationRequest — the signed challenge you issued
    envelope,           # PresentationEnvelope — the holder's response
    chain=chain,        # ChainReader        — proven on-chain reads
    nonces=nonces,      # NonceStore         — durable, exactly-once consumption
    proofs=proofs,      # ProofVerifier      — the anonymous-proof engine port
    decisions=log,      # DecisionLog        — the minimal decision sink
    now_unix=now,       # int                — your disciplined clock
)
decision.accepted      # bool
decision.reason_code   # closed vocabulary; a rejection is a decision, not an exception

You supply infrastructure (chain access, a nonce store, a decision log, a clock), never policy.

Status

The engine is built and in production. An independent audit of its implementation is scheduled as a milestone; its findings will be published, and it gates nothing.

Where to test

On the public testnet and its KYC sandbox, and only there: check the status line of its page first. Nothing issued on it carries weight. The single-node production chain is not for third parties and is never a place to test; the local stack of the main repository runs the same flows on your machine.

Links

• Documentation: https://gitlab.com/mintid/mintid/-/blob/main/docs/sdk/02-python-sdk.md (service mode: https://gitlab.com/mintid/mintid/-/blob/main/docs/sdk/03-service-mode.md)
• Source: https://gitlab.com/mintid/mintid (verifier-core), where issues and merge requests go
• Public testnet: https://gitlab.com/mintid/mintid/-/blob/main/docs/sdk/17-sandbox-and-testnet.md
• Security: report a vulnerability privately to security@mintid.net, never in a public issue; policy: https://gitlab.com/mintid/mintid/-/blob/main/SECURITY.md
• Website: https://mintid.net

Licence

Apache License 2.0. Author: Marc Molas.