Search

Search for projects by name or address

Privacy

The vault owner can blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. withdrawals until deposits expire and become sweepable to the treasury. The proofs rely on a single-party trusted setupGeneration of a piece of data that must then be used for some cryptographic protocol to run. Generating this data requires some secret information. The "trust" comes from the fact the secret must be destroyed after the ceremony, otherwise cryptographic properties of the protocol could be broken. Once the data is generated, and the secrets are forgotten, no further participation from the creators of the ceremony is required. There are two types of trusted setups for SNARKs: (i) trusted setup per circuit where it is generated from scratch for each circuit, (ii) trusted universal setup per proving system where it can be used for several circuits..

About

Anonymous access to AI models, prepaid with ETH, that hides which deposit pays for which request.


  • Total Value Locked
    $2.24 K31.5%
    across 1 assets and 1 buckets
  • TVL
    $2.24 K31.5%
  • Assets tracked
    1
  • Buckets tracked
    1
  • Deposits 7D
    1381.9%
  • Deposits 30D
    85
  • Deposits Total
    85

  • Privacy
    Link privacy
  • Trusted setup
  • Exit window
  • Reproducibility

  • Tracked on
  • Attributes
    ZKAny amount
  • Public observerChain analystNetwork observerPrivileged insiderFuture adversary

    About

    Anonymous access to AI models, prepaid with ETH, that hides which deposit pays for which request.

    zkAPI lets the user prepay AI usage with ETH and chat without revealing which deposit pays for which request. Deposits and withdrawals are public, and the model provider can read the user’s prompts.

    Users trust Open Anonymity, which runs the service and owns the vault, and the inference providers behind OpenRouter. The operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. approves withdrawals and sees each request’s time and budget. The owner can pause the vault, and expired deposits fall to its treasury. The user can leave without the operator through a 1 day escape, as long as their note has not expired.

    Architecture

    Open Anonymity verifies request proofs before issuing API keys. Its signing keys are fixed in the vault. A new key requires proof that the user’s balance covers a budget of at least 0.00005 ETH.

    The user’s app keeps the exact balance locally. The operator receives a commitment to the user’s deposit. Initially, the balance equals the deposit.

    The commitment is homomorphic: the operator can subtract a known charge without reading the balance. It signs the updated commitment. The local app checks the subtraction and signature, then stores the updated state.

    The operator also runs the indexer and a challenger that disputes escapes from outdated balances.

    Flow

    1. Deposit ETH from your wallet. The vault records its amount and an expiry about 1 month later.
    2. Request access. The app proves an active note covers your chosen budget. The operator returns a short-lived OpenRouter key.
    3. Chat. Send prompts to OpenRouter with that key.
    4. Settle. The operator bills the key’s usage.
    5. Withdraw. A cooperative close needs the operator’s clearance. The vault publishes the note id and remaining balance. It returns the remainder to your chosen address and pays usage to the treasury.

    Keys

    Losing the note secret and latest signed balance that are saved by the app loses the funds.

    App

    The ratings assume OA Chat, a hosted browser app with public source and local build instructions. It fetches the whole note tree and proves in the browser. It relays inference through a proxy at refraction.networkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. by default, with a fallback to direct connections. The hosted build runs code beyond the public main branch, including analytics. zkapi-clientd is a local daemon with an OpenAI-compatible API. It asks the operator’s indexer for the user’s note path and reuses keys across requests, both of which can harm privacy.

    Providers and verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover.

    OpenRouter and the model provider can read prompts and responses and link requests under one key. Open Anonymity holds the OpenRouter accounts. A verifier running in an attestable Azure confidential container checks that OA’s account has provider logging disabled. Its build reproduces from source and matches the attested measurement, see the verification steps. Both clients pin only the verifier’s address, so the check only holds when the user verifies it personally.

    Exits

    Escape. Without a cooperative close, the user starts an escape with their latest signed balance and finalizes it after 1 day. The operator can cancel it with a request proof for that balance, which publishes that request’s link. While the owner pauses the vault, no one can start an escape, but one already started still finalizes.

    Compliance

    The vault has no onchain screening. The operator can refuse keys or clearance.

    Fees

    Usage is billed in USD and converted to ETH through a Chainlink feed, with no fee on top of the provider’s price. The unused balance returns at withdrawal.

    What the protocol promises: Hides which deposit pays for which API request. Deposits and withdrawals are public, and the provider can read prompts.

    Ethereum is public by default. Each protocol is rated on its main privacy promise, like hiding who paid, who received, how much, or which deposit became which withdrawal. Against each adversary, the colour says whether it holds for a careful user with the app's own settings: green yes, yellow only with significant extra work, red no. Fields marked at risk stay private only under the condition in their note.

    Public observerChain analystNetwork observerPrivileged insiderFuture adversary
    Public observer
    Private

    Requests stay offchain, so nothing onchain ties a request to the deposit that pays for it. A deposit publishes the funder, amount, note id and expiry. Closing the note publishes the payout address and the remaining balance, so each note’s total spend is public.

    InsideSenderexposedRecipientexposedAmountat riskAssetexposedLinkprivate
    Chain analyst
    Private

    Authorizations never reach the chain, so correlating public data adds nothing to the note record.

    Inside, the same as for a public observer.

    Network observer
    Private

    The app works in Tor Browser, the daemon has a Tor setting with a kill switch, and no third party sees both a deposit and a request. The RPC serving the user’s wallet sees the deposit, while requests go to the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. and the provider. The app sends inference through a relay at refraction.networkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. by default, which sees its timing. The hosted app reports feature use to Fathom, a cookieless analytics service.

    Advice: Use the app in Tor Browser, or the daemon with its Tor setting, and send the deposit through a public RPC over Tor.

    Compared with a public observer
    InsideLinkat risk
    Privileged insider
    At risk

    The operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. sees each request’s time and budget but not its note, so the candidates are all active notes, a small set. The daemon reveals the note id to the operator’s indexer before each request. An escape dispute lets the operator publish one request’s link onchain. The provider can read prompts and responses and link requests under one key.

    Advice: Use the browser app rather than the daemon, and wait a day or more between depositing and the user's first request. Run an inspected local build of the client instead of the hosted frontend.

    Compared with a public observer
    InsideRecipientexposedAmountexposedLinkat risk
    Future adversary
    At risk

    Onchain data stays hashed, but retained operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. transcripts and indexer logs would tie requests to deposits. Note leaves and nullifiers are Poseidon hashes. Whoever breaks elliptic-curve cryptography opens only the balance commitment that a published dispute carries.

    Advice: Assume the operator and provider keep what the user sends.

    Compared with a public observer
    InsideAmountat riskLinkat risk
    Asset
    Deposits 7D
    Deposits 30D
    Deposits Total
    Value Locked
    ETHETH
    13
    $1.07 K
    85
    $3.03 K
    85
    $3.03 K
    $2.24 K
    Total
    13
    $1.07 K
    85
    $3.03 K
    85
    $3.03 K
    $2.24 K

    Funds can be stolen if

    1. the owner pauses withdrawals until notes expire and anyone sweeps them to its treasury.
    2. the single-party setup secrets or a circuitA program written for the purpose of being proven within a proving system. A circuit is a mathematical representation of the computation to be executed, arithmetic circuits and zkVM execution trace are examples of circuits. Circuits can be written in different languages, ranging from low-level to high-level. flaw allow forged withdrawal proofs.
    3. malicious wallet code reads the note secret.

    Funds can be lost or frozen if

    1. the note secret or the latest signed balance is lost.
    2. a note expires before withdrawal.
    3. the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. withholds a signed balance and cancels the escape with the request it received.

    Privacy can be lost if

    1. the operator matches a deposit to its requests by timing, which few active notes make easy (see privileged insider).
    2. a daemon user reveals the note id to the operator’s indexer before each request (see privileged insider).
    3. prompts identify the user to OpenRouter or the model provider (see privileged insider).
    4. the operator keeps request transcripts and indexer logs, which later tie requests to deposits (see future adversary).

    The vault, verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover., signing keys and exit parameters are immutable. The owner EOA can set the treasury, pause deposits, cooperative closes and the start of escapes, and transfer or renounce ownership, all without delay. Pending escapes still finalize during a pause. An instant pause with a subsequent sweep after expiry would steal all funds whose escape was not started before the pause.

    The operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades.’s services, the hosted app and the daemon releases are controlled by Open Anonymity and can change without notice.

    zkapi-v2-note-bound-v1 single-party setup

    Arkworks

    Detailed description

    The request and withdrawal Groth16A zk-SNARK proving system introduced by Groth in 2016 that proves arithmetic circuits and requires a separate trusted setup for each circuit. It allows extremely efficient proof verification. keys were generated by one party. There was no multi-party ceremony. Security requires that this party erased the setup secrets, otherwise it can forge withdrawal proofs. Matching public artifacts cannot prove erasure. Setup implementation, provenance.

    Verifier
    Verification
    Used in
    Known deployments
    zkapi note-bound request and withdrawal verifier
    zkAPI logo

    Verifier ID:0xd31acf861825869e6a84b6b0025cb6940077f5981a10e73d2e4e8e5d7417c853

    Known deployments

    Deployment #1

    Used in:
    zkAPI logo

    Verification steps

    Contracts and proof artifacts

    Reviewed ethereum/zkapi revision, whose vault, adapter and circuits match the deployment revision reported by the production manifest. Compile with the checked-in configuration: solc 0.8.28, optimizer 200, viaIR and Prague.

    git clone https://github.com/ethereum/zkapi.git
    cd zkapi
    git checkout 045b444ea1b52538d1b40273c7cb6ed09468a052
    cd demo/contracts
    forge build --skip test --build-info
    cast tx 0xf753fd93c7e672f7b851f261f600e06930e502bdfd73be29ce8a065643df6985 --json --rpc-url "$ZKAPI_RESEARCH_RPC_URL" > vault-tx.json
    cast tx 0x45f2f5259476afd5f64a6a62a36c9012c3a26efcdd35b048a7fac5ae1ba43780 --json --rpc-url "$ZKAPI_RESEARCH_RPC_URL" > verifier-tx.json
    

    The adapter creation bytecodeGenerally, an instruction set designed for efficient execution by a software interpreter or a virtual machine. Unlike human-readable source code, bytecode is expressed numerically. Within the context of rollups, often related to the concept of compatibility: whether the bytecode of programs on the rollup are capable of being run as-is on Ethereum as well, and vice versa. matches exactly, including metadata. The vault matches after linking the discovered Poseidon address. Decode its ten constructor arguments from the remaining transaction input. Sources are verified on Etherscan: vault, adapter, Poseidon.

    The deployed verification-key coordinates and public inputs match the published setup artifacts, and the proving-key hashes match the SDK and production pins. A single-party setup with fresh randomness yields different keys each time, so matching artifacts show that the deployed keys are the published ones. Only the setup party knows whether its secrets were erased.

    Frontend and local clientSometimes labelled interchangeably as a “node”, they are tasked with processing transactions and managing the blockchains's state. They run the computations for each transaction according to the rollup's virtual machine and protocol rules. If comparing to Ethereum clients, these would be execution clients such as Geth, as opposed to consensus clients.

    The browser frontend and the local API daemon have public source and build instructions. Both still depend on the operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades.’s authorization and inference services.

    VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. enclave

    The mainnet verifier is verifier-production-20260917.openanonymity.ai, pinned in the hosted app’s browser config. It runs in an Azure confidential container on AMD SEV-SNP and serves a hardware attestation. Its source, OpenAnonymity/oa-verifier, is pinned to commit 4299cfa by the production rollout.

    curl -sS "https://verifier-production-20260917.openanonymity.ai/attestation?nonce=$(date +%s)" > attestation.json
    # 1. the JWT in .token is signed by Azure Attestation (.verify_at), its x-ms-sevsnpvm-hostdata equals sha256 of the decoded .policy
    # 2. the policy lists one dm-verity layer hash for the verifier container
    git clone https://github.com/OpenAnonymity/oa-verifier && cd oa-verifier
    git checkout 4299cfa136c90550737dd46c89dba586c213159b
    nix build .#container && docker load < result
    # 3. push oa-verifier:latest to a local registry, then
    go install github.com/Microsoft/hcsshim/cmd/[email protected]
    dmverity-vhd roothash -i localhost:5000/oa-verifier:latest
    

    The rebuilt image matches the published ghcr.io/openanonymity/oa-verifier@sha256:60f9892b… in nix store path, config and layer, and its layer root hashA fixed-length fingerprint of variable-size input, produced by a hash function. equals the attested policy. Pushing through a different docker version changes the compressed manifest digest, while the measured layer hash stays. The attestation also binds the TLS key of the live endpoint. Both clients pin only the verifier’s address, so repeat the check when it matters.

    Ossification

    Contracts our research team classifies as critical form the project's critical perimeter. Its clock starts at the ossification genesis, and every critical change resets it (changes within 24 hours count as one). The ossification score is the share of recorded code-bug exploits whose exploited code was younger than this perimeter is today. Battle-tested exposure is the value secured, summed over that unchanged period.

    Ossification %
    37since 2026 Sep 30
    TVS & changes (1Y)
    Battle-tested exposure
    $52.47·years
    Critical changes / year
    0across 2 contracts
    Exit window

    Discovery updates

    2026 October 07, 11:41 UTC
    3changes

    Initial discovery of the active native ETH vault, its Groth16 proof adapter and linked Poseidon library. All three contracts were verified from public source. The owner can pause new exits and change the treasury.

    Initial discovery

    + Status: CREATED
    contract ZkApiVault (eth:0x4386FDbdA35D995beB3BF8625118Ec5982ec81fe) [zkapi/ZkApiVault]
    +++ description: Escrows ETH for anonymous API authorizations as publicly numbered notes. A Groth16 proof closes a note with operator clearance, or starts a delayed escape that any request proof with the same nullifier cancels. Closing reveals the note id, payout address and remaining balance and sends the used part to the treasury. Anyone can sweep an expired note entirely to the treasury, also while paused.
    + Status: CREATED
    contract Groth16ProofAdapter (eth:0x8e92013Dd7cc86f75b539DBD3814B2e603e0F9C1) [zkapi/Groth16ProofAdapter]
    +++ description: BN254 Groth16 verifier containing the request and withdrawal verification keys for zkapi-v2-note-bound-v1. Request proofs hide the note identity, exact balance and state signature. Withdrawal proofs expose the note id, destination, final balance and nullifier. The published circuit-specific keys were generated in a single-party setup. Retained setup secrets can allow forged proofs.
    + Status: CREATED
    contract Bn254Poseidon (eth:0xc6B55e86668d8c446B3D81273AAb9CBb20F28c7f) [zkapi/Bn254Poseidon]
    +++ description: Linked Poseidon hash library used by the vault for active-note leaves and Merkle updates. Its BN254 parameters must agree with the request and withdrawal circuits.
    A dashboard to explore contracts and permissions
    Go to Disco
    Disco UI Banner

    Ethereum

    Actors:

    • Can interact with ZkApiVault
      • pause and unpause deposits, cooperative withdrawals and new escape withdrawals, and change the treasury receiving consumed balances and expired notes. Pausing can prevent users from exiting before their notes become sweepable
    A dashboard to explore contracts and permissions
    Go to Disco
    Disco UI Banner

    Ethereum

    ZkApiVault0x4386…81fe

    Escrows ETH for anonymous API authorizations as publicly numbered notes. A Groth16A zk-SNARK proving system introduced by Groth in 2016 that proves arithmetic circuits and requires a separate trusted setup for each circuit. It allows extremely efficient proof verification. proof closes a note with operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades. clearance, or starts a delayed escape that any request proof with the same nullifier cancels. Closing reveals the note id, payout address and remaining balance and sends the used part to the treasury. Anyone can sweep an expired note entirely to the treasury, also while paused.

    • Roles:
      • owner: EOA 1
    Groth16ProofAdapter0x8e92…F9C1

    BN254 Groth16A zk-SNARK proving system introduced by Groth in 2016 that proves arithmetic circuits and requires a separate trusted setup for each circuit. It allows extremely efficient proof verification. verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. containing the request and withdrawal verification keys for zkapi-v2-note-bound-v1. Request proofs hide the note identity, exact balance and state signature. Withdrawal proofs expose the note id, destination, final balance and nullifier. The published circuitA program written for the purpose of being proven within a proving system. A circuit is a mathematical representation of the computation to be executed, arithmetic circuits and zkVM execution trace are examples of circuits. Circuits can be written in different languages, ranging from low-level to high-level.-specific keys were generated in a single-party setup. Retained setup secrets can allow forged proofs.

    Bn254Poseidon0xc6B5…8c7f

    Linked Poseidon hashA fixed-length fingerprint of variable-size input, produced by a hash function. library used by the vault for active-note leaves and Merkle updates. Its BN254 parameters must agree with the request and withdrawal circuits.