aimarket-zk

aimarket-zk

Documentation

---

Zero-knowledge proofs for private AI capability invocation. Consumer proves "I sent valid input matching the schema" without revealing the input. Provider proves "I executed correctly" without revealing model weights or computation trace. Neither party sees the other's private data.

When to Use

• Consumer sends proprietary business data — wants proof it was processed correctly, but doesn't want provider to see it
• Provider runs proprietary model — wants to prove correct execution without revealing weights
• Regulatory compliance — prove invocation happened correctly without disclosing contents
• Double-spend protection — ZK nullifiers prevent replay attacks on paid invocations

Installation

pip install aimarket-zk

Or from a checkout of the monorepo:

pip install -e plugins/aimarket-zk

Proving backend: the plugin loads and registers its routes with no backend configured, and the /zk/* endpoints then refuse with an explanation rather than the plugin vanishing from the catalogue. Set AIMARKET_ZK_SIMULATED=1 for the development simulation — it is not real zero-knowledge and the hub says so at every call.

Example

from aimarket_hub.signing import Signer
from aimarket_zk.zk_proofs import ZKProver

signer = Signer()
prover = ZKProver(signer)

schema = {"type": "object", "properties": {"text": {"type": "string"}}}
secret_input = {"text": "confidential merger terms between CorpA and CorpB"}

# Consumer: prove input is valid without revealing it
input_proof = prover.prove_input("legal.review@v1", schema, secret_input)
print(f"Input commitment: {input_proof.input_commitment[:16]}...")
# Provider sees only the hash — not "confidential merger terms"

# Provider: verify input proof → execute → prove output
import hashlib, json
schema_hash = hashlib.sha256(json.dumps(schema, sort_keys=True).encode()).hexdigest()
verification = prover.verify_input_proof(input_proof, schema_hash, "legal.review@v1",
                                         signer.public_key_b64)
print(f"Input proof valid: {verification['valid']}")  # True
print(f"Privacy: {verification['reason']}")  # "input is valid without being revealed"

# Full private invoke cycle (input + output proofs)
def executor(pid, cid, inp):
    return {"risk_assessment": "low", "issues_found": 0}

result = prover.private_invoke_flow(
    "legal.review@v1", "prod-legal",
    schema, secret_input, executor
)
print(f"Success: {result['success']}")
print(f"Privacy: {result['privacy_guarantees']}")
# {"input_hidden": true, "execution_trace_hidden": true,
#  "double_spend_protected": true, "zk_scheme": "Groth16 (simulated)"}

ZK Scheme

Reference implementation uses simulated Groth16 for development. Production: circom circuits compiled to bn254 curve via bellman/gnark. The interface is identical — swap the prover backend and proofs become cryptographically sound.

License

MIT · Maintained by AI-Factory