Search

Search projects, tokens and protocols 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
    $1.93 K12.3%
    across 1 assets and 1 buckets
  • TVL
    $1.93 K12.3%
  • Assets tracked
    1
  • Buckets tracked
    1
  • Deposits 7D
    650.0%
  • Deposits 30D
    52
  • Deposits Total
    106

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

  • Tracked on
    Ethereum logo
  • Attributes
    ZKAny amount
  • Reference app
    OA Chatclosed source, most private of 3 checked
  • 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 the budget tier of your chosen model. 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

    OA Chat is a hosted browser app with local build instructions. It fetches the whole note tree and proves in the browser. It relays inference and chain reads 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 source, including Google and passkey sign-in, analytics and a looser verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. check.

    Providers and verifier

    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. OA Chat pins only the verifier’s address, so the check only holds when the user verifies it personally. When the verifier cannot be reached, the hosted app still accepts a key signed by OA’s station and shows “Key not verified”.

    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.

    • OA ChatReference

      The ratings assume this app, since 2026-10-12 · Closed source, build 99da543, checked 2026-10-22

    • zkapi-clientdLeaks more

      Sends the note id to the operator's indexer before each request, so the operator can tie requests to their deposit by timing.

      Fix: Fetch the whole note tree, as OA Chat does, instead of one note's path. · Source

    • openzk.appLeaks more

      Sends request proofs and withdrawals through OpenZK's own server, so OpenZK also sees each request's time and budget.

      Fix: Send zkAPI calls straight to Open Anonymity's servers, so only the operator sees them, as in OA Chat. · Source (checked 2026-10-27)

    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, and no third party sees both a deposit and a request. The deposit reaches the wallet’s RPC, or the app’s public RPC when the user funds an address the app shows. The 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. carries the app’s inference and chain reads by default and sees their timing. 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, and the hosted app reports feature use to Fathom.

    Advice: Use the app in Tor Browser, and send the deposit through a public RPC over Tor.

    Compared with a public observer
    InsideLinkat risk
    Privileged insider
    Exposed

    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 tier but not its note, and too few active notes cover a top-tier budget to hide among. The candidates are the active notes whose balance covers the request’s budget tier, which follows the chosen model’s price. The provider can read prompts and responses and link requests under one key.

    Compared with a public observer
    InsideRecipientexposedAmountexposedLinkexposed
    Future adversary
    Private

    Note leaves and nullifiers are Poseidon hashes and nothing encrypted is written onchain, so there is nothing to decrypt. Whoever breaks elliptic-curve cryptography opens only the balance commitment that a published dispute carries.

    Inside, the same as for a public observer.

    Asset
    Deposits 7D
    Deposits 30D
    Deposits Total
    Value Locked
    ETHETH
    6
    $193.81
    52
    $1.96 K
    106
    $3.36 K
    $1.93 K
    Total
    6
    $193.81
    52
    $1.96 K
    106
    $3.36 K
    $1.93 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 trusted 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 if

    1. the note secret or the latest signed balance is lost.
    2. a note expires before withdrawal.

    Funds can be frozen if

    1. 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 ties a request to its deposit, since few active notes cover a top-tier budget (see privileged insider).
    2. prompts identify the user to OpenRouter or the model provider (see privileged insider).
    3. the operator keeps request transcripts and indexer logs, which later tie requests to deposits (see privileged insider).

    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 deployments1
    Used in
    zkAPI logo
    zkAPI

    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 %
    49since 30 Sep 2026
    TVS & changes (1Y)
    Battle-tested exposure
    $177.26·years
    Critical changes / year
    0across 3 contracts
    Exit window

    Discovery updates

    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.