Disclosure and consent
Being able to construct a proof is not permission to disclose one. Nokto separates the two into distinct operations: Grant, which is the only thing that creates permission, and Disclose, which requires it.
Grant
A holder permits one verifier one predicate answer, time-bounded and revocable. Nothing else in the protocol creates this permission — no partner, platform, or admin can issue a grant covering a holder other than the holder themselves, because the grant is issued over the caller's own derived identity and never takes a principal as a parameter.
A grant's id is derived from everything it authorizes — the principal, the verifier, the predicate, and the exact predicate arguments. That has a direct consequence: a grant can never be widened after it is issued. Changing any argument — including ones that are easy to overlook, like a threshold — yields a different id, which does not exist as a grant. Without binding the exact arguments, permission to prove "income over $1,000" would silently also permit "income over $1,000,000", which is a materially different disclosure the holder never agreed to.
A grant is also bounded in time and revocable at any moment. Revocation is final for that exact scope: a holder who changes their mind issues a new grant with different parameters, a visibly different permission, rather than reinstating the one they withdrew. Expiry is checked against block time, never against a time value supplied by the prover — a caller-supplied "now" would let a holder, or anyone who obtained their witness data, quietly reuse a grant that had already lapsed.
Disclose
A verifier receives a ZK proof that a predicate holds, and learns nothing else. Every disclosure circuit checks an active grant before doing anything else — consent is checked first, because being able to build the proof was never the question.
Disclosure writes nothing to the ledger. An earlier design inserted a hash of the disclosed predicate's arguments as an on-chain record; that turned out to be a linkable public trail on its own, since thresholds are low-entropy and a verifier already knows which principals it deals with — anyone could grind the hash and confirm "this principal proved income above X," which is exactly the fact the proof exists to keep private. Audit trails belong to whoever needs them, off-chain.
Because nothing is written on-chain, freshness has to come from somewhere else: the verifier issues a fresh challenge for each request, and the challenge is bound into the proof, separately from the grant. A verifier checks the challenge and the addressed-to-verifier claim as two of several distinct comparisons against what it actually asked for — see Verifying a disclosure for the full list and the order they run in.
See Predicates for what a disclosure proof actually asserts, and Write a verifier for building the verifier side of this exchange.