@opaquecash/opaque 0.1.1 → 0.2.0

package/dist/client.d.ts

@@ -1,10 +1,16 @@
-import { type Account, type Address, type Chain, type Hex, type Transport, type WalletClient } from "viem";
-import { buildActionScope, externalNullifierFromScope, type ProofData } from "@opaquecash/psr-core";
+import { type Account, type Address, type Chain, type EIP1193Provider, type Hex, type PublicClient, type Transport, type WalletClient } from "viem";
+import { Keypair, PublicKey, Transaction, type TransactionInstruction } from "@solana/web3.js";
+import { type SolanaAdapterConfig, type OnsClaimStatus } from "@opaquecash/stealth-chain-solana";
+import type { Announcement } from "@opaquecash/adapter";
+import { buildActionScope, externalNullifierFromScope, type AttestationV2, type FieldDef, type ProofData, type SchemaV2 } from "@opaquecash/psr-core";
 import type { DiscoveredTrait } from "@opaquecash/psr-core";
 import { type VerifyReputationArgs } from "@opaquecash/psr-chain";
 import { type ArtifactPaths, type ProofProgressCallback } from "@opaquecash/psr-prover";
 import { type TrackedToken } from "@opaquecash/stealth-balance";
+import type { AnnounceWithRelayRequest, UabIndexerAnnouncement } from "@opaquecash/uab";
 import { type OpaqueChainDeployment } from "./chains.js";
+import { type ResolvedRecipient } from "./resolve.js";
+import { type UnifiedSigner } from "./signer.js";
 import type { IndexerAnnouncement, OwnedStealthOutput, TokenBalanceSummary } from "./types/indexer.js";
 /**
  * Configuration for {@link OpaqueClient.create}.
@@ -24,8 +30,13 @@ export interface OpaqueClientConfig {
      * you still pass the same address to your wallet when sending txs).
      */
     ethereumAddress: Address;
-    /** Dynamic import URL for wasm-pack `cryptography.js`. */
-    wasmModuleSpecifier: string;
+    /**
+     * Dynamic import URL for wasm-pack `cryptography.js`. Required for scanning, sweeping, trait
+     * discovery, key reconstruction, and proof generation. **Optional** when you only use the PSR
+     * admin API (schema/attestation management uses pure-JS DKSAP, no WASM); omitting it and then
+     * calling a WASM-backed method throws a clear error.
+     */
+    wasmModuleSpecifier?: string;
     /**
      * Extra ERC-20s (and native) to aggregate. Merged with chain defaults; native uses
      * {@link NATIVE_TOKEN_ADDRESS}.
@@ -36,8 +47,230 @@ export interface OpaqueClientConfig {
         stealthMetaAddressRegistry: Address;
         stealthAddressAnnouncer: Address;
         opaqueReputationVerifier: Address;
+        uabSender: Address;
+        uabReceiver: Address;
+        wormholeCore: Address;
     }>;
+    /**
+     * Solana access for the unified {@link OpaqueClient.scan} inbox. Optional: only needed when
+     * `scan({ chains })` includes `"solana"`. Pass a `connection`, `rpcUrl`, or `cluster`
+     * (defaults to devnet). The viewing/spending keys are chain-neutral — no Solana identity required.
+     */
+    solana?: SolanaAdapterConfig;
+    /**
+     * EIP-1193 provider (e.g. `window.ethereum` or a wallet bridge) used to SIGN Ethereum PSR
+     * writes (`createSchema`, `issueAttestation`, …). Reads never need it. Transactions are signed
+     * by {@link ethereumAddress}; omit it for read-only / Solana-only usage.
+     */
+    ethereumProvider?: EIP1193Provider;
+    /**
+     * Pre-built viem `WalletClient` for Ethereum PSR writes (e.g. a backend issuer signing with a
+     * `privateKeyToAccount`). Takes precedence over {@link ethereumProvider}; the account it carries
+     * signs, so it should match {@link ethereumAddress}.
+     */
+    ethereumWalletClient?: WalletClient;
+    /**
+     * Solana wallet used to SIGN Solana PSR writes. `publicKey` is the issuer/authority; pass a
+     * `@solana/web3.js` `PublicKey` or a base58 string. `signTransaction` matches the wallet-adapter
+     * signature. Required only for Solana PSR writes.
+     */
+    solanaWallet?: {
+        publicKey: PublicKey | string;
+        signTransaction: (transaction: Transaction) => Promise<Transaction>;
+    };
+    /**
+     * ENS read access for {@link OpaqueClient.resolveRecipient} of `*.eth` names
+     * (CSAP §2.9 `com.opaque.meta` text record). Pass an ENS-capable viem `PublicClient`
+     * (mainnet or Sepolia — the scan RPC usually is not), or inject a custom `getText`
+     * reader (tests, alternative resolvers). Optional: only `*.eth` resolution needs it.
+     */
+    ens?: {
+        client?: PublicClient;
+        getText?: (name: string, key: string) => Promise<string | null>;
+    };
+    /**
+     * IPFS access for {@link OpaqueClient.resolveRecipient} of `ipfs://` DID documents.
+     * Defaults to public gateways over `globalThis.fetch`; inject `fetch` to mock or to
+     * route through a local node / Helia gateway.
+     */
+    ipfs?: {
+        gateways?: readonly string[];
+        fetch?: typeof fetch;
+    };
+    /**
+     * ONS (Opaque Name Service, spec/ONS.md) overrides for `*.opq.eth`-style names.
+     * Defaults come from `@opaquecash/deployments` for {@link chainId} (testnet parent:
+     * `opqtest.eth`). Resolution tries the Solana mirror PDA first (needs {@link solana}),
+     * then falls back to the canonical OpaqueNameRegistry over {@link rpcUrl}.
+     */
+    ons?: {
+        /** Parent name in force (lowercase, e.g. `"opq.eth"`). */
+        parentName?: string;
+        /** Canonical OpaqueNameRegistry address (ENSIP-10 wildcard resolver). */
+        registry?: Address;
+        /** `ons-mirror` program id (base58) on the configured Solana cluster. */
+        mirrorProgram?: string;
+    };
+    /**
+     * SNS read access for `.sol` recipients (CSAP §2.9 TXT record). Defaults to the
+     * bundled Records V2 TXT reader over the {@link solana} connection; inject
+     * `getRecord` to mock or to use a custom record key/source.
+     */
+    sns?: {
+        getRecord?: (domain: string, key: string) => Promise<string | null>;
+    };
+}
+/** Chains the PSR admin API ({@link OpaqueClient.createSchema} etc.) targets. */
+export type PsrChain = OpaqueScanChain;
+/** Future block (Ethereum) / slot (Solana) for a schema or attestation expiry. */
+export interface PsrExpiryInput {
+    /** Absolute Ethereum block number or Solana slot. Takes precedence over {@link dateTime}. */
+    slotOrBlock?: number;
+    /** ISO datetime; converted to a block (~12s/block) or slot (~400ms/slot) at call time. */
+    dateTime?: string;
+}
+/** Parameters for {@link OpaqueClient.createSchema}. */
+export interface CreateSchemaParams {
+    /** Human-readable schema name (part of the `schemaId` preimage). */
+    name: string;
+    /** ABI-style string (`"bool passed, u64 score"`) or {@link FieldDef}s — normalized internally. */
+    fieldDefinitions: string | FieldDef[];
+    /** Whether issued attestations can be revoked (immutable after creation). */
+    revocable: boolean;
+    /** Optional resolver: EVM address or Solana program pubkey. Omit for none. */
+    resolver?: string;
+    /** Optional schema expiry. */
+    schemaExpiry?: PsrExpiryInput;
+}
+/** Parameters for {@link OpaqueClient.issueAttestation}. */
+export interface IssueAttestationParams {
+    /** Target schema id (`0x`-hex bytes32). */
+    schemaId: string;
+    /** 66-byte meta-address, 20-byte stealth address, or 32-byte `stealth_address_hash` (hex). */
+    recipient: string;
+    /** Field values keyed by field name — must match the schema's `fieldDefinitions`. */
+    fieldValues: Record<string, string>;
+    /** Optional attestation expiry. */
+    expiration?: PsrExpiryInput;
+    /** Optional reference uid (chained credential). */
+    refUid?: string;
+    /**
+     * Publish a discovery announcement after issuance. Defaults to `true` when `recipient` is a
+     * meta-address (only then is an ephemeral key available). No-op for raw-hash recipients.
+     */
+    announce?: boolean;
+}
+/** Result of a PSR write that only returns a transaction id. */
+export interface PsrTxResult {
+    /** EVM `0x` tx hash or Solana base58 signature. */
+    txHash: string;
+}
+/** Result of {@link OpaqueClient.createSchema}. */
+export interface CreateSchemaResult extends PsrTxResult {
+    /** Derived `schemaId` (`0x`-hex bytes32). */
+    schemaId: string;
+}
+/** Result of {@link OpaqueClient.issueAttestation}. */
+export interface IssueAttestationResult extends PsrTxResult {
+    /** Attestation uid (`0x`-hex bytes32). */
+    uid: string;
+    /** The 32-byte `stealth_address_hash` the attestation is bound to (`0x`-hex). */
+    stealthAddressHash: string;
 }
+/** Chains the unified {@link OpaqueClient.scan} can read. */
+export type OpaqueScanChain = "ethereum" | "solana";
+/** One owned stealth output from the unified inbox, tagged with its source chain. */
+export interface UnifiedOwnedOutput extends OwnedStealthOutput {
+    /** Source chain of this output. */
+    chain: OpaqueScanChain;
+    /** Wormhole chain id of the source (Ethereum = 2, Solana = 1). */
+    chainId: number;
+    /**
+     * How the announcement was discovered: `"native"` (the chain's own announcer) or `"uab"`
+     * (relayed cross-chain over Wormhole and re-emitted by the UABReceiver).
+     */
+    source: "native" | "uab";
+}
+/** Parameters for {@link OpaqueClient.sendStealthPayment}. */
+export interface SendStealthPaymentParams {
+    /** Chain to send on. */
+    chain: OpaqueScanChain;
+    /**
+     * Recipient: a 66-byte meta-address hex (used directly), a Solana base58 pubkey, or an
+     * Ethereum `0x` address — the latter two are resolved through the chain's registry.
+     */
+    recipient: string;
+    /** Amount in base units: lamports (Solana) or wei (Ethereum native). */
+    amount: bigint;
+    /** SPL mint / ERC-20 address; omit for native. Token sends are not yet supported (native only). */
+    token?: string;
+    /** Publish the discovery announcement (default `true`). */
+    announce?: boolean;
+    /** Also relay the announcement cross-chain over Wormhole (default `false`). */
+    relay?: boolean;
+    /** Solana Wormhole nonce (`batch_id`) when `relay` is set. */
+    batchId?: number;
+    /**
+     * Anonymity-set utility (guide §17): decouple send time from announce time. When set,
+     * the value transfer is submitted immediately but the announcement is submitted only
+     * after this many milliseconds, breaking the timing correlation between the two.
+     * The result's `announcePromise` resolves to the announce tx id — await (or attach a
+     * handler to) it, or the delayed announce dies with your process.
+     */
+    delayAnnouncement?: number;
+}
+/** Result of {@link OpaqueClient.sendStealthPayment}. */
+export interface SendStealthPaymentResult {
+    chain: OpaqueScanChain;
+    /** Transfer tx id (Solana bundles the announce in the same tx unless delayed). */
+    txHash: string;
+    /** Separate announce tx id (Ethereum submits transfer + announce as two txs). */
+    announceTxHash?: string;
+    /**
+     * Pending announce tx id when `delayAnnouncement` was set: resolves after the delay
+     * elapses and the announcement confirms. Undefined for immediate announcements.
+     */
+    announcePromise?: Promise<string>;
+    /** EVM-style 20-byte scanner address the recipient will detect. */
+    stealthAddress: Address;
+    /** Solana destination account (base58) the funds were sent to. */
+    destination?: string;
+    /** 33-byte compressed ephemeral public key (hex). */
+    ephemeralPublicKey: Hex;
+    /** Resolved 66-byte recipient meta-address. */
+    metaAddressHex: Hex;
+}
+/** Native balance of one owned stealth output, resolved per chain. */
+export interface OutputBalance {
+    chain: OpaqueScanChain;
+    /** EVM-style 20-byte scanner address the announcement was matched on. */
+    stealthAddress: string;
+    /**
+     * Account actually holding the funds: the same address on Ethereum, or the derived Solana
+     * stealth account (base58) on Solana.
+     */
+    address: string;
+    /** Native balance in base units (wei on Ethereum, lamports on Solana). */
+    nativeRaw: bigint;
+}
+/** A cross-chain `announceWithRelay` built for Ethereum (submit `{to,data,value}` via wallet). */
+export interface EvmAnnounceWithRelayResult {
+    chain: "ethereum";
+    to: Address;
+    data: Hex;
+    /** Wormhole message fee (wei) to send as `value`. */
+    value: bigint;
+    chainId: number;
+}
+/** A cross-chain `announce_with_relay` built for Solana (sign with the wallet + extra signers). */
+export interface SolanaAnnounceWithRelayResult {
+    chain: "solana";
+    instructions: TransactionInstruction[];
+    /** Extra signers (the fresh Wormhole message keypair) that must co-sign with the wallet. */
+    signers: Keypair[];
+}
+/** Discriminated result of {@link OpaqueClient.buildAnnounceWithRelay}. */
+export type AnnounceWithRelayResult = EvmAnnounceWithRelayResult | SolanaAnnounceWithRelayResult;
 /**
  * Result of preparing a stealth send (ephemeral material + announce fields).
  */
@@ -51,12 +284,25 @@ export interface PrepareStealthSendResult {
     ephemeralPrivateKey: Uint8Array;
     /** Metadata bytes for `announce` (view tag byte; extend with WASM for PSR). */
     metadata: Uint8Array;
+    /**
+     * Uncompressed (65-byte) stealth public-key point. Needed to derive the Solana destination
+     * account (`deriveStealthSolanaAddress`); not required for the EVM `announce`.
+     */
+    stealthPubKey: Uint8Array;
 }
 /**
  * Result of {@link OpaqueClient.prepareGhostReceive} — same shape as {@link PrepareStealthSendResult},
  * keyed to your own meta-address for receive-without-prior-announcement flows.
  */
 export type PrepareGhostReceiveResult = PrepareStealthSendResult;
+/**
+ * One decoy announcement from {@link OpaqueClient.generateDummyAnnouncements}: a valid
+ * DKSAP derivation against a throwaway meta-address (included for inspection; its
+ * private keys are already gone).
+ */
+export type DummyAnnouncement = PrepareStealthSendResult & {
+    metaAddressHex: Hex;
+};
 /**
  * Calldata-ready request for `StealthAddressAnnouncer.announce` (developer submits via wallet).
  */
@@ -80,6 +326,15 @@ export interface RegisterMetaAddressTransactionRequest {
     chainId: number;
     metaAddressHex: Hex;
 }
+/** Result of {@link OpaqueClient.registerMetaAddress}. */
+export interface RegisterMetaAddressResult {
+    /** Chain the meta-address was registered on. */
+    chain: OpaqueScanChain;
+    /** EVM `0x` tx hash or Solana base58 signature. */
+    txHash: string;
+    /** The 66-byte meta-address that was registered. */
+    metaAddressHex: Hex;
+}
 /**
  * Result of {@link OpaqueClient.resolveRecipientMetaAddress}: registry lookup for a normal EOA.
  */
@@ -110,11 +365,29 @@ export declare class OpaqueClient {
     private readonly metaAddressHex;
     private readonly publicClient;
     private readonly wasm;
+    private evmAdapter?;
+    private solanaAdapter?;
+    private evmWalletClientCache?;
+    private solanaWalletCache?;
     private constructor();
     /**
      * Construct a client: loads WASM, derives keys from `walletSignature`, wires RPC + addresses.
      */
     static create(config: OpaqueClientConfig): Promise<OpaqueClient>;
+    /**
+     * Construct a client from wallet(s) in the {@link UnifiedSigner} shape — the
+     * one-adapter entry point for integrators (Phase 2.5). Pass at most one wallet per
+     * chain; the FIRST wallet is prompted for the {@link SETUP_MESSAGE} setup signature
+     * (HKDF entropy) unless a cached `walletSignature` is supplied. Each wallet is also
+     * wired as that chain's write signer (`ethereumProvider`/`ethereumWalletClient`,
+     * `solanaWallet`), so PSR writes and sends work without further config.
+     */
+    static fromWallet(params: Omit<OpaqueClientConfig, "walletSignature" | "ethereumAddress" | "ethereumProvider" | "ethereumWalletClient" | "solanaWallet"> & {
+        /** One wallet (or one per chain) in unified shape. */
+        wallets: UnifiedSigner | UnifiedSigner[];
+        /** Cached setup signature; skips the wallet prompt when present. */
+        walletSignature?: Hex;
+    }): Promise<OpaqueClient>;
     /** Chain id from configuration. */
     getChainId(): number;
     /** Connected Ethereum address (from config). */
@@ -137,14 +410,129 @@ export declare class OpaqueClient {
      * @param recipientAddress - Normal Ethereum address of the intended recipient.
      */
     resolveRecipientMetaAddress(recipientAddress: Address): Promise<ResolveRecipientMetaResult>;
+    /**
+     * Resolve ANY supported recipient identity to its 66-byte meta-address (CSAP §2.9):
+     *
+     * | Input | Path |
+     * |-------|------|
+     * | 66-byte meta-address (optionally `st:opq:`-prefixed) | validated and passed through |
+     * | `0x…` 20-byte EVM address | ERC-6538 `StealthMetaAddressRegistry` |
+     * | Solana base58 pubkey | `stealth-registry` PDA (needs {@link OpaqueClientConfig.solana}) |
+     * | `ipfs://…` / bare CID | DID document fetch via gateways (configure {@link OpaqueClientConfig.ipfs}) |
+     * | ONS name (`alice.opq.eth`) | Solana mirror PDA first, canonical OpaqueNameRegistry fallback (spec/ONS.md) |
+     * | other `*.eth` | ENS `com.opaque.meta` text record (needs {@link OpaqueClientConfig.ens}) |
+     * | `*.sol` | SNS Records V2 TXT record (needs {@link OpaqueClientConfig.solana} or `sns.getRecord`) |
+     *
+     * Every path point-validates both 33-byte halves before returning. Throws with a
+     * path-specific message when the identity is unregistered, unset, or malformed.
+     */
+    resolveRecipient(input: string): Promise<ResolvedRecipient>;
+    /**
+     * Resolve an Opaque Name Service name (`alice.opq.eth`; `alice.opqtest.eth` on
+     * testnet) to its meta-address (spec/ONS.md §7). Tries the Solana mirror PDA first
+     * (one account read, no Ethereum RPC — needs {@link OpaqueClientConfig.solana});
+     * falls back to the canonical OpaqueNameRegistry (ENSIP-10) over the scan RPC.
+     * Both paths point-validate the 33-byte halves. Mirror records lag the canonical
+     * record by Wormhole latency (eventually consistent, canonical-chain-wins).
+     */
+    resolveOpaqueMetaAddress(name: string): Promise<Hex>;
+    /** ONS resolution: mirror-PDA-first, canonical-registry fallback. */
+    private resolveOnsName;
+    /** The ONS parent name in force (config override, else bundled deployment), if any. */
+    private onsParentName;
+    /** The `.sol` record reader: injected, else the bundled Records V2 TXT reader. */
+    private snsGetRecord;
+    /** Build the {@link ResolveTransports} from config (ENS reader + IPFS gateways). */
+    private resolveTransports;
     /**
      * Encode `registerKeys` for the user's meta-address (they submit with `ethereumAddress`).
      */
     buildRegisterMetaAddressTransaction(): RegisterMetaAddressTransactionRequest;
+    /**
+     * Register THIS wallet's 66-byte meta-address on-chain so others can resolve it, dispatching on
+     * `chain`. Submits the transaction with the configured signer (`ethereumWalletClient` /
+     * `ethereumProvider` for Ethereum, `solanaWallet` for Solana) and returns the tx id. For a
+     * calldata-only request you submit yourself, see {@link buildRegisterMetaAddressTransaction}
+     * (Ethereum) or `SolanaAdapter.buildRegisterKeysInstruction`.
+     */
+    registerMetaAddress(chain: OpaqueScanChain): Promise<RegisterMetaAddressResult>;
+    /**
+     * Whether THIS wallet's meta-address is already registered on `chain` (Ethereum reads its
+     * configured `ethereumAddress`; Solana reads the `solanaWallet` pubkey).
+     */
+    isMetaAddressRegistered(chain: OpaqueScanChain): Promise<boolean>;
+    /**
+     * Register `label`.<parent> for THIS wallet's meta-address on the canonical
+     * OpaqueNameRegistry (Ethereum; spec/ONS.md §4.1). Immediately authoritative;
+     * the Solana mirror follows after Wormhole relay. Submits with the configured
+     * Ethereum signer and returns the tx hash.
+     */
+    registerOpaqueName(label: string): Promise<Hex>;
+    /**
+     * Claim `label`.<parent> from Solana (spec/ONS.md §4.2). Creates a PROVISIONAL
+     * claim and publishes it to the canonical registry via Wormhole; it becomes
+     * authoritative only when the registry confirms (mirror record appears), and it
+     * loses to any concurrent direct Ethereum registration. Track with
+     * {@link getOpaqueNameStatus}; surface `pending` in UI (never as owned).
+     */
+    claimOpaqueName(label: string): Promise<{
+        signature: string;
+        name: string;
+    }>;
+    /**
+     * Reconciliation state of an ONS name's Solana-originated claim
+     * (`none`/`pending`/`confirmed`/`lost`/`expired`; spec/ONS.md §6), plus the
+     * mirror record when one exists. Two Solana account reads.
+     */
+    getOpaqueNameStatus(name: string): Promise<OnsClaimStatus>;
+    /**
+     * Close a finished provisional claim (confirmed / lost / expired) and refund its
+     * rent to the claimer. Permissionless; submits with the configured Solana wallet.
+     */
+    reconcileOpaqueName(name: string): Promise<string>;
+    /** The ONS parent name in force, or throw with setup guidance. */
+    private requireOnsParentName;
+    private requireOnsRegistry;
+    private onsMirrorProgram;
+    private onsRegistrationProgram;
+    /** Split this wallet's meta-address (CSAP V‖S) into its 33-byte halves. */
+    private ownMetaAddressHalves;
     /**
      * Derive a one-time stealth address for sending to a recipient meta-address.
      */
     prepareStealthSend(recipientMetaAddressHex: Hex): PrepareStealthSendResult;
+    /**
+     * High-level send: resolve the recipient, derive a one-time stealth destination, transfer the
+     * native asset, and publish the discovery announcement — in one call, dispatching on `chain`.
+     *
+     * Solana bundles the transfer and `announce` (or `announce_with_relay` when `relay` is set) into a
+     * single transaction and returns its signature. Ethereum submits the value transfer first, then
+     * the announce, returning both tx hashes. Token (SPL/ERC-20) sends are not yet supported.
+     * Requires the chain's signer (`solanaWallet` / `ethereumWalletClient` or `ethereumProvider`).
+     */
+    sendStealthPayment(params: SendStealthPaymentParams): Promise<SendStealthPaymentResult>;
+    /**
+     * Resolve a {@link SendStealthPaymentParams.recipient} to a 66-byte meta-address.
+     * Delegates to {@link resolveRecipient}, so sends accept every supported identity
+     * form (meta-address, registry address/pubkey, `ipfs://` DID, `*.eth`) on any chain —
+     * meta-addresses are chain-neutral.
+     */
+    private resolveSendRecipientMeta;
+    /**
+     * Anonymity-set utility (guide §17): mint `n` decoy announcements. Each one is a fully
+     * valid DKSAP announcement to a freshly generated THROWAWAY meta-address whose private
+     * keys are discarded — on-chain it is indistinguishable from a real payment
+     * announcement (valid curve points, correctly derived view tag), but nobody will ever
+     * match or spend it. Submit them (e.g. via {@link buildDummyAnnouncementTransactions})
+     * interleaved with real sends to grow every recipient's anonymity set.
+     */
+    generateDummyAnnouncements(n: number): DummyAnnouncement[];
+    /**
+     * Convenience over {@link generateDummyAnnouncements}: `n` ready-to-submit `announce`
+     * calldata requests for this chain's announcer. Broadcast them from any account —
+     * announcements carry no value and any caller may announce.
+     */
+    buildDummyAnnouncementTransactions(n: number): AnnounceTransactionRequest[];
     /**
      * Manual “ghost” receive: derive a one-time stealth address for **this** wallet’s meta-address
      * without any on-chain announcement yet. Cryptographically this is {@link prepareStealthSend}
@@ -163,10 +551,113 @@ export declare class OpaqueClient {
      * Build calldata for `announce` so the developer can prompt the user to broadcast.
      */
     buildAnnounceTransactionRequest(send: PrepareStealthSendResult): AnnounceTransactionRequest;
+    /** Resolve UAB addresses for this chain (config override takes precedence over the known deployment). */
+    private uabAddresses;
+    /**
+     * Build a `{to,data,value}` request for a CROSS-CHAIN announce (`announceWithRelay`): it emits the
+     * local announcement AND publishes the 96-byte payload through Wormhole. `value` is the Wormhole
+     * message fee. Pass the same {@link PrepareStealthSendResult} you'd use for a native announce.
+     */
+    buildAnnounceWithRelayRequest(send: PrepareStealthSendResult, opts?: {
+        consistencyLevel?: number;
+    }): Promise<AnnounceWithRelayRequest & {
+        chainId: number;
+    }>;
+    /**
+     * Build a CROSS-CHAIN announce for either chain, dispatching on `chain`. Emits the local
+     * announcement AND relays the 96-byte payload over Wormhole. Ethereum returns a `{to,data,value}`
+     * request (`value` is the Wormhole fee); Solana returns `instructions` + extra `signers` (the
+     * fresh Wormhole message keypair) — both must co-sign with the wallet. Pass the same
+     * {@link PrepareStealthSendResult} you'd use for a native announce.
+     *
+     * EVM honours `consistencyLevel`; Solana honours `batchId` (Wormhole nonce) and `wormholeFee`
+     * (auto-fetched from the core bridge when omitted; 0 on devnet).
+     */
+    buildAnnounceWithRelay(chain: OpaqueScanChain, send: PrepareStealthSendResult, opts?: {
+        consistencyLevel?: number;
+        batchId?: number;
+        wormholeFee?: bigint;
+    }): Promise<AnnounceWithRelayResult>;
+    /**
+     * Read inbound CROSS-CHAIN announcements (from the UABReceiver) as indexer-shaped rows, ready to
+     * pass into {@link filterOwnedAnnouncements} alongside native rows.
+     */
+    fetchCrossChainAnnouncements(opts?: {
+        fromBlock?: bigint;
+        toBlock?: bigint | "latest";
+    }): Promise<UabIndexerAnnouncement[]>;
+    /** Discover stealth outputs owned by this user that arrived via the cross-chain UAB. */
+    scanCrossChain(opts?: {
+        fromBlock?: bigint;
+        toBlock?: bigint | "latest";
+    }): Promise<OwnedStealthOutput[]>;
     /**
      * Filter indexer announcements down to outputs owned by this user (WASM scan).
      */
     filterOwnedAnnouncements(rows: IndexerAnnouncement[]): Promise<OwnedStealthOutput[]>;
+    /**
+     * Scan one or more chains for stealth outputs owned by this wallet and return a single,
+     * merged inbox. Each chain's native announcements are fetched through its {@link ChainAdapter}
+     * and run through the same WASM view-tag + DKSAP filter ({@link filterOwnedAnnouncements}), so
+     * detection is identical across chains. Outputs are tagged with their source `chain` / `chainId`.
+     *
+     * `"ethereum"` reuses this client's viem client + configured announcer/registry. `"solana"`
+     * requires {@link OpaqueClientConfig.solana} (connection / rpcUrl / cluster; defaults to devnet).
+     * The viewing/spending keys are chain-neutral, so one wallet's inbox spans both chains.
+     */
+    scan(opts: {
+        chains: OpaqueScanChain[];
+        /** Lower-bound cursor: EVM block number (Solana scans the most recent signatures). */
+        fromBlock?: bigint;
+        /** Upper-bound EVM block; omit for the chain tip. */
+        toBlock?: bigint;
+        /** Max Solana signatures to scan (adapter default when omitted). */
+        solanaLimit?: number;
+        /**
+         * Also merge cross-chain (UAB) announcements, tagged `source: "uab"`: on Ethereum, events
+         * re-emitted by the EVM UABReceiver; on Solana, `CrossChainAnnouncement` events from the
+         * `uab-receiver` program (merged by the adapter). Defaults to `true` wherever a UAB
+         * deployment is configured; set `false` to skip, or `true` to force on the EVM side
+         * (throws if UAB is unconfigured there).
+         */
+        includeCrossChain?: boolean;
+    }): Promise<UnifiedOwnedOutput[]>;
+    /**
+     * Fetch ALL native announcements on `chain` as indexer-shaped rows — unfiltered, with their
+     * full on-chain `metadata`. This is the raw input for the metadata-aware scanners:
+     * {@link discoverTraits} / {@link getReputationTraitsFromAnnouncements} (PSR attestation
+     * markers) and {@link filterOwnedAnnouncements}. Unlike {@link scan}, nothing is dropped, so
+     * callers can decode announcement metadata that ownership filtering would discard.
+     *
+     * Note: cross-chain (UAB) announcements are NOT included — the 96-byte Wormhole payload only
+     * carries a 24-byte metadata tail, which cannot hold the 130-byte V2 attestation metadata.
+     * For trait discovery, fetch rows natively on each chain instead.
+     */
+    fetchAnnouncementRows(chain: OpaqueScanChain, opts?: {
+        /** Lower-bound cursor: EVM block number (Solana scans the most recent signatures). */
+        fromBlock?: bigint;
+        /** Upper-bound EVM block; omit for the chain tip. */
+        toBlock?: bigint;
+        /** Max Solana signatures to scan (adapter default when omitted). */
+        solanaLimit?: number;
+    }): Promise<IndexerAnnouncement[]>;
+    /** Lazily build and cache the {@link ChainAdapter} for a chain. */
+    private getAdapter;
+    /** Lazily build and cache the concrete {@link SolanaAdapter}. */
+    private getSolanaAdapter;
+    /**
+     * Sweep the full native balance of an owned stealth output to `destination`, signed by the
+     * reconstructed one-time key (the on-chain `from` is the stealth address itself). Works for
+     * Ethereum (ETH) and Solana (SOL); `"solana"` requires {@link OpaqueClientConfig.solana}.
+     */
+    sweep(params: {
+        output: Pick<OwnedStealthOutput, "ephemeralPublicKey">;
+        chain: OpaqueScanChain;
+        destination: string;
+    }): Promise<{
+        chain: OpaqueScanChain;
+        tx: string;
+    }>;
     /**
      * Reconstruct the 32-byte secp256k1 private key that controls `output`’s one-time stealth address.
      * Uses the same WASM path as the on-chain scanner (`reconstruct_signing_key_wasm`).
@@ -186,6 +677,13 @@ export declare class OpaqueClient {
      * Owned outputs + balances summed per tracked token (uses `rpcUrl` from config).
      */
     getBalancesFromAnnouncements(rows: IndexerAnnouncement[]): Promise<TokenBalanceSummary[]>;
+    /**
+     * Native balance per owned stealth output across chains. Ethereum reads the stealth address
+     * directly; Solana reconstructs the one-time key (WASM), derives the Solana stealth account, and
+     * reads its lamports. Pass the {@link UnifiedOwnedOutput}s from {@link scan}. SPL/ERC-20 token
+     * sums for the EVM tracked-token set live in {@link getBalancesFromAnnouncements}.
+     */
+    getBalancesForOutputs(outputs: UnifiedOwnedOutput[]): Promise<OutputBalance[]>;
     /**
      * PSR: map owned attestation markers to {@link DiscoveredTrait} list.
      */
@@ -208,7 +706,58 @@ export declare class OpaqueClient {
      */
     buildAssignReputationTransaction(recipientMetaAddressHex: Hex, attestationId: bigint): AnnounceTransactionRequest;
     /**
-     * JSON array string for {@link generateReputationProof} when passing `attestationsJson` (WASM Merkle witness).
+     * Register a new schema (attestation class + issuance rules). Returns the tx id and derived
+     * `schemaId`. `fieldDefinitions` accepts an ABI string or {@link FieldDef}s.
+     */
+    createSchema(chain: PsrChain, params: CreateSchemaParams): Promise<CreateSchemaResult>;
+    /** Schemas where this client's wallet is the authority OR an authorized delegate. */
+    getMySchemas(chain: PsrChain): Promise<SchemaV2[]>;
+    /** Authority-only, irreversible: deprecate a schema (blocks new attestations). */
+    deprecateSchema(chain: PsrChain, schemaId: string): Promise<PsrTxResult>;
+    /** Authority-only: authorize `delegate` to issue under `schemaId`. */
+    addSchemaDelegate(chain: PsrChain, schemaId: string, delegate: string): Promise<PsrTxResult>;
+    /** Authority-only: revoke a delegate's issuance rights under `schemaId`. */
+    removeSchemaDelegate(chain: PsrChain, schemaId: string, delegate: string): Promise<PsrTxResult>;
+    /** Attestations issued by this client's wallet. */
+    getMyIssuedAttestations(chain: PsrChain): Promise<AttestationV2[]>;
+    /**
+     * Issue a schema-bound attestation against a stealth identity. Resolves the recipient to a
+     * `stealth_address_hash`, encodes the field values per the schema, submits `attest`, and
+     * (when the recipient is a meta-address and `announce` is not `false`) publishes a discovery
+     * announcement so the recipient's scanner can find the trait. Verifies the wallet is an
+     * authorized issuer first.
+     */
+    issueAttestation(chain: PsrChain, params: IssueAttestationParams): Promise<IssueAttestationResult>;
+    /** EIP-1193 provider or a clear error. */
+    private requireEthereumProvider;
+    /** Viem chain for the configured chain id (bundled Sepolia, else a minimal definition). */
+    private viemChain;
+    /** Lazily build the signing wallet client for Ethereum PSR writes. */
+    private evmWalletClient;
+    private evmWriteClients;
+    /** Solana signer (normalized) or a clear error. */
+    private requireSolanaWallet;
+    /**
+     * Sign + send + confirm a Solana transaction built from `ixs`. Any `extraSigners` (e.g. the
+     * Wormhole message keypair for `announce_with_relay`) partial-sign before the wallet signs as
+     * fee payer.
+     */
+    private sendSolanaTx;
+    /**
+     * Resolve a recipient to a 32-byte `stealth_address_hash` (and, for a meta-address, the
+     * ephemeral material needed to announce). Matches the frontends: 66-byte meta-address → DKSAP →
+     * `keccak256(stealthAddress)`; 20-byte stealth address → `keccak256(address)`; 32-byte → as-is.
+     */
+    private resolveStealthAddressHash;
+    /** Resolve a {@link PsrExpiryInput} to an absolute Ethereum block (0 = no expiry). */
+    private resolveEvmExpiryBlock;
+    /** Resolve a {@link PsrExpiryInput} to an absolute Solana slot (0 = no expiry). */
+    private resolveSolanaExpirySlot;
+    /** Find a Solana schema by `schemaId` (PSR schemas have no id-indexed PDA across authorities). */
+    private fetchSolanaSchemaById;
+    /**
+     * JSON array string in the Rust scanner's announcement format (general scanner interop;
+     * no longer consumed by {@link generateReputationProof}, which builds V2 witnesses directly).
      */
     announcementsJsonForReputationWitness(rows: IndexerAnnouncement[]): string;
     /**
@@ -216,15 +765,20 @@ export declare class OpaqueClient {
      */
     getStealthSignerPrivateKeyForReputationTrait(trait: DiscoveredTrait): Uint8Array;
     /**
-     * Groth16 proof bundle for `OpaqueReputationVerifier` (requires `snarkjs`).
-     * When `artifacts` is omitted, wasm/zkey are loaded from the default hosted paths on opaque.cash
-     * (same as the Opaque frontend `/circuits/...` assets).
+     * V2 Groth16 proof bundle for the reputation verifiers (requires `snarkjs`).
+     * When `artifacts` is omitted, the V2 wasm/zkey are loaded from the default hosted paths on
+     * opaque.cash (same as the Opaque frontend `/circuits/v2/...` assets).
+     *
+     * Public signals: `[merkle_root, attestation_id, external_nullifier, nullifier_hash]`;
+     * `ProofData.nullifier` carries `nullifier_hash`.
      */
     generateReputationProof(params: {
         trait: DiscoveredTrait;
         stealthPrivKeyBytes: Uint8Array;
         externalNullifier: string;
-        attestationsJson?: string;
+        issuerPkX?: string | bigint;
+        traitDataHash?: string | bigint;
+        nonce?: string | bigint;
         artifacts?: ArtifactPaths;
         onProgress?: ProofProgressCallback;
     }): Promise<ProofData>;
@@ -242,8 +796,13 @@ export declare class OpaqueClient {
     verifyReputationProofView(args: VerifyReputationArgs): Promise<boolean>;
     /** Simulate `verifyReputation` for gas / revert checks. */
     simulateReputationVerification<TTransport extends Transport, TChain extends Chain, TAccount extends Account | undefined>(wallet: WalletClient<TTransport, TChain, TAccount>, args: VerifyReputationArgs): Promise<void>;
-    /** Broadcast `verifyReputation` (consumes nullifier when successful). */
-    submitReputationVerification<TTransport extends Transport, TChain extends Chain, TAccount extends Account | undefined>(wallet: WalletClient<TTransport, TChain, TAccount>, args: VerifyReputationArgs): Promise<Hex>;
+    /**
+     * Broadcast a reputation proof to the verifier, dispatching on `chain` (consumes the nullifier on
+     * success). Uses the configured signer for each chain — `ethereumWalletClient` / `ethereumProvider`
+     * for Ethereum, `solanaWallet` for Solana. The same {@link VerifyReputationArgs} feeds both:
+     * `proofData` (from {@link generateReputationProof}), `merkleRoot`, and `externalNullifier`.
+     */
+    submitReputationVerification(chain: OpaqueScanChain, args: VerifyReputationArgs): Promise<PsrTxResult>;
     private getReputationVerifierAddress;
     /**
      * Deterministic scope string for reputation actions (`chainId:module:actionId`).
@@ -264,4 +823,11 @@ export declare class OpaqueClient {
      */
     static chainDeployment(chainId: number): OpaqueChainDeployment | undefined;
 }
+/**
+ * Map a chain-neutral {@link Announcement} (from any {@link ChainAdapter}) into the
+ * {@link IndexerAnnouncement} row shape consumed by {@link OpaqueClient.filterOwnedAnnouncements}.
+ * `txHash` passes through verbatim (an EVM `0x` hash or a Solana base58 signature); `cursor`
+ * (EVM block / Solana slot) becomes `blockNumber`.
+ */
+export declare function announcementToIndexerRow(a: Announcement): IndexerAnnouncement;
 //# sourceMappingURL=client.d.ts.map