Starknet

Starknet support is live on Starknet Sepolia (testnet). Native scanning, stealth sends, sweeps, and PSR proof verification work end to end today; the cross-chain UAB relay, ONS mirroring, and reference-app UI for Starknet are still in progress. See the integration design.

Opaque runs on Starknet as a third chain alongside Ethereum and Solana. The viewing and spending keys are chain-neutral, so one wallet’s inbox spans all three chains — you scan Starknet with the same keys you use for the others.

How custody works

A Starknet stealth address is the counterfactual account address of a pinned StealthAccount class (OpenZeppelin’s audited EthAccountComponent) whose sole signer is the one-time secp256k1 key P_stealth. The sender computes this address from the recipient’s meta-address and the announcement — no interaction — and only the recipient can reconstruct the matching private key to spend. The account does not need to be deployed to receive funds: an ERC-20 balance is state in the token contract, so tokens wait at the counterfactual address until the recipient deploys the account and sweeps. The Opaque-assigned chain id for Starknet is 0x534e (“SN”); it is distinct from the Wormhole ids used for Ethereum (2) and Solana (1).

Scan

import { OpaqueClient } from "@opaquecash/opaque";

const client = await OpaqueClient.create({
  chainId: 11155111,
  rpcUrl: "https://ethereum-sepolia.publicnode.com",
  walletSignature,     // chain-neutral key derivation
  ethereumAddress,
  starknet: {},         // defaults to the bundled Sepolia deployment
});

// Unified, cross-chain inbox — one call, all three chains.
const inbox = await client.scan({ chains: ["ethereum", "solana", "starknet"] });
// Each output is tagged { chain: "starknet", chainId: 0x534e, source: "native" }

Scanning is wallet-free (viewing key only). Read balances with getBalancesForOutputs, which reads STRK via balance_of and works for undeployed accounts:

const balances = await client.getBalancesForOutputs(inbox);

Send

buildStarknetStealthSend returns the unsigned calls to broadcast from a Starknet wallet: an ERC-20 transfer to the stealth address, then the announce. Signing and broadcasting stay with the app’s Starknet wallet (as on Solana), so no Starknet signer is needed in the client config.

const send = await client.buildStarknetStealthSend({
  recipient,                       // meta-address, registry address, or name
  amount: 1_000_000_000_000_000n,  // 0.001 STRK (defaults to STRK)
});

// Broadcast send.calls (transfer + announce) as one multicall with your wallet
// (e.g. starknet.js Account.execute, get/argent/braavos).

Sweep

The recipient reconstructs the one-time key that owns the stealth account and receives the deploy_account parameters plus the transfer-out call. Broadcasting uses an Eth signer (secp256k1); the account funds its own deploy fee from its balance.

import { Account, EthSigner, RpcProvider } from "starknet"; // v10+ for RPC 0.10

const s = client.buildStarknetSweep({ output, destination, amount });

const provider = new RpcProvider({ nodeUrl });
const account = new Account({
  provider,
  address: s.address,
  signer: new EthSigner("0x" + Buffer.from(s.signerPrivateKey).toString("hex")),
});

await account.deployAccount({
  classHash: s.classHash,
  constructorCalldata: s.constructorCalldata.map(String),
  addressSalt: "0x" + s.salt.toString(16),
  contractAddress: s.address,
});                              // paid from the stealth account's own balance
await account.execute(s.transferCall);

Because the account funds its own deploy_account fee (the secp256k1 validation is L2-gas-heavy), the balance must exceed that fee — a dust payment cannot be swept without a paymaster/relayer. This account-abstraction friction is inherent to Starknet’s contract-account model.

Programmable Stealth Reputation

The full PSR stack runs on Starknet: a Garaga-generated Groth16-BN254 verifier and the OpaqueReputationVerifierV2 wrapper (admin roots, nullifier set, schema-liveness binding) are deployed on Sepolia, verifying proofs from the same trusted setup as Ethereum and Solana. See Deployments for addresses and PSR for the model.

Credential-gated actions

PsrGate is the reference consumer: an allowlist an actor may enter only by proving, in zero knowledge, a valid attestation under a required schema, with the proof’s nullifier consumed once so the same credential cannot enter the same scope twice. It is the general form of “is this actor eligible?” — the gate a STRK20 anonymizer or DeFi action points at so only credentialed stealth identities transact, without revealing who they are.

// Verifies the proof, requires attestation_id == required_schema, consumes the
// nullifier, and records the entry. Panics on an invalid or replayed proof.
gate.enter(full_proof_with_hints);
gate.has_entered(scope);   // -> true for the entered external_nullifier

Get started

Concepts

Guides

SDK reference

Protocol

How custody works

Scan

Send

Sweep

Programmable Stealth Reputation

Credential-gated actions

​How custody works

​Scan

​Send

​Sweep

​Programmable Stealth Reputation

​Credential-gated actions

How custody works

Scan

Send

Sweep

Programmable Stealth Reputation

Credential-gated actions