@ocash/sdk 0.1.0

package/dist/index-DgLBElAG.d.ts

@@ -0,0 +1,1692 @@
+import { Address, PublicClient } from 'viem';
+
+type OperationStatus = 'created' | 'submitted' | 'confirmed' | 'failed';
+type OperationType = 'deposit' | 'transfer' | 'withdraw' | (string & {});
+type Hex$1 = `0x${string}`;
+type ListOperationsQuery = {
+    limit?: number;
+    offset?: number;
+    chainId?: number;
+    tokenId?: string;
+    type?: OperationType | OperationType[];
+    status?: OperationStatus | OperationStatus[];
+    sort?: 'desc' | 'asc';
+};
+type DepositOperationDetail = {
+    token: string;
+    amount: string;
+    protocolFee?: string;
+    depositRelayerFee?: string;
+    inputCommitments?: Hex$1[];
+    outputCommitments?: Hex$1[];
+};
+type TransferOperationDetail = {
+    token: string;
+    amount: string;
+    fee?: string;
+    relayerFeeTotal?: string;
+    protocolFeeTotal?: string;
+    mergeCount?: number;
+    feeCount?: number;
+    to: Hex$1;
+    inputCommitments?: Hex$1[];
+    outputCommitments?: Hex$1[];
+};
+type WithdrawOperationDetail = {
+    token: string;
+    amount: string;
+    burnAmount?: string;
+    protocolFee?: string;
+    relayerFee?: string;
+    relayerFeeTotal?: string;
+    protocolFeeTotal?: string;
+    mergeCount?: number;
+    feeCount?: number;
+    recipient: Hex$1;
+    inputCommitments?: Hex$1[];
+    outputCommitments?: Hex$1[];
+};
+type BuiltinOperationDetailByType = {
+    deposit: DepositOperationDetail;
+    transfer: TransferOperationDetail;
+    withdraw: WithdrawOperationDetail;
+};
+type OperationDetailFor<TType extends OperationType> = TType extends keyof BuiltinOperationDetailByType ? BuiltinOperationDetailByType[TType] : Record<string, unknown>;
+type StoredOperation<TDetail = Record<string, unknown>> = {
+    id: string;
+    type: OperationType;
+    createdAt: number;
+    chainId?: number;
+    tokenId?: string;
+    status: OperationStatus;
+    requestUrl?: string;
+    relayerTxHash?: `0x${string}`;
+    txHash?: `0x${string}`;
+    detail?: TDetail;
+    error?: string;
+};
+type OperationCreateInput<TType extends OperationType = OperationType> = Omit<StoredOperation<OperationDetailFor<TType>>, 'id' | 'createdAt' | 'status'> & Partial<Pick<StoredOperation<OperationDetailFor<TType>>, 'createdAt' | 'id' | 'status'>> & {
+    type: TType;
+};
+type DepositOperation = Omit<StoredOperation<DepositOperationDetail>, 'type'> & {
+    type: 'deposit';
+    detail?: DepositOperationDetail;
+};
+type TransferOperation = Omit<StoredOperation<TransferOperationDetail>, 'type'> & {
+    type: 'transfer';
+    detail?: TransferOperationDetail;
+};
+type WithdrawOperation = Omit<StoredOperation<WithdrawOperationDetail>, 'type'> & {
+    type: 'withdraw';
+    detail?: WithdrawOperationDetail;
+};
+
+type Hex = `0x${string}`;
+type BigintLikeString = string;
+type TransactionReceipt = Awaited<ReturnType<PublicClient['waitForTransactionReceipt']>>;
+type SdkErrorCode = 'CONFIG' | 'ASSETS' | 'STORAGE' | 'SYNC' | 'CRYPTO' | 'MERKLE' | 'WITNESS' | 'PROOF' | 'RELAYER';
+interface TokenMetadata {
+    id: string;
+    symbol: string;
+    decimals: number;
+    wrappedErc20: Address;
+    viewerPk: [string, string];
+    freezerPk: [string, string];
+    depositFeeBps?: number;
+    withdrawFeeBps?: number;
+    transferMaxAmount?: bigint | string;
+    withdrawMaxAmount?: bigint | string;
+}
+interface ChainConfigInput {
+    chainId: number;
+    rpcUrl?: string;
+    entryUrl?: string;
+    ocashContractAddress?: Address;
+    relayerUrl?: string;
+    merkleProofUrl?: string;
+    tokens?: TokenMetadata[];
+    /**
+     * Legacy fields: kept for compatibility with existing code/tests.
+     * Prefer `ocashContractAddress`.
+     */
+    contract?: Address;
+}
+interface RelayerFeeEntry {
+    token_address: Hex;
+    fee: bigint;
+}
+interface RelayerFeeConfigure {
+    valid_time: number;
+    transfer: Record<string, RelayerFeeEntry>;
+    withdraw: Record<string, RelayerFeeEntry>;
+}
+interface RelayerConfig {
+    config: {
+        contract_address: Address;
+        chain_id: number;
+        name: string;
+        relayer_address: Address;
+        img_url?: string;
+        submit_timeout?: number;
+    };
+    fee_configure: RelayerFeeConfigure;
+    fetched_at?: number;
+}
+interface MemoWorkerConfig {
+    workerUrl?: string;
+    concurrency?: number;
+    type?: 'classic' | 'module';
+}
+type AssetOverrideEntry = string | string[];
+interface AssetsOverride {
+    [filename: string]: AssetOverrideEntry;
+}
+interface OCashSdkConfig {
+    chains: ChainConfigInput[];
+    assetsOverride?: AssetsOverride;
+    memoWorker?: MemoWorkerConfig;
+    cacheDir?: string;
+    runtime?: 'auto' | 'browser' | 'node' | 'hybrid';
+    storage?: StorageAdapter;
+    merkle?: {
+        /**
+         * `remote`: always use `chain.merkleProofUrl`.
+         * `local`: always use locally built merkle (requires feeding all leaves).
+         * `hybrid`: prefer local, fallback to remote if missing.
+         */
+        mode?: 'remote' | 'local' | 'hybrid';
+        /**
+         * Merkle depth used by the on-chain tree (defaults to 32).
+         */
+        treeDepth?: number;
+    };
+    sync?: {
+        pageSize?: number;
+        pollMs?: number;
+        requestTimeoutMs?: number;
+        /**
+         * Optional network retry policy for sync requests (Entry/Merkle).
+         * Defaults to no retries.
+         */
+        retry?: {
+            attempts?: number;
+            baseDelayMs?: number;
+            maxDelayMs?: number;
+        };
+    };
+    onEvent?: (event: SdkEvent) => void;
+}
+interface SdkErrorPayload {
+    code: SdkErrorCode;
+    message: string;
+    detail?: unknown;
+    cause?: unknown;
+}
+type SdkEvent = {
+    type: 'core:ready';
+    payload: {
+        assetsVersion: string;
+        durationMs: number;
+    };
+} | {
+    type: 'core:progress';
+    payload: {
+        stage: 'fetch' | 'compile' | 'init';
+        loaded: number;
+        total?: number;
+    };
+} | {
+    type: 'sync:start';
+    payload: {
+        chainId: number;
+        source: 'entry' | 'rpc' | 'subgraph';
+    };
+} | {
+    type: 'sync:progress';
+    payload: {
+        chainId: number;
+        resource: 'memo' | 'nullifier' | 'merkle';
+        downloaded: number;
+        total?: number;
+    };
+} | {
+    type: 'sync:done';
+    payload: {
+        chainId: number;
+        cursor: SyncCursor;
+    };
+} | {
+    type: 'debug';
+    payload: {
+        scope: string;
+        message: string;
+        detail?: unknown;
+    };
+} | {
+    type: 'operations:update';
+    payload: {
+        action: 'create' | 'update';
+        operationId?: string;
+        patch?: Partial<StoredOperation>;
+        operation?: StoredOperation;
+    };
+}
+/**
+ * UTXO state changed due to memo/nullifier sync.
+ *
+ * `added` is the number of (unique) UTXOs upserted in this batch after local validation/decryption;
+ * it is not guaranteed to equal "newly discovered" rows (may include updates/duplicates).
+ */
+ | {
+    type: 'wallet:utxo:update';
+    payload: {
+        chainId: number;
+        added: number;
+        spent: number;
+        frozen: number;
+    };
+} | {
+    type: 'assets:update';
+    payload: {
+        chainId: number;
+        kind: 'token' | 'pool' | 'relayer';
+    };
+} | {
+    type: 'zkp:start';
+    payload: {
+        circuit: 'transfer' | 'withdraw';
+    };
+} | {
+    type: 'zkp:done';
+    payload: {
+        circuit: 'transfer' | 'withdraw';
+        costMs: number;
+    };
+} | {
+    type: 'error';
+    payload: SdkErrorPayload;
+};
+interface CommitmentData {
+    asset_id: bigint;
+    asset_amount: bigint;
+    user_pk: {
+        user_address: [bigint, bigint];
+    };
+    blinding_factor: bigint;
+    is_frozen: boolean;
+}
+interface MemoDecryptRequest {
+    memo: Hex;
+    secretKey: bigint;
+    metadata?: Record<string, unknown>;
+}
+interface MemoDecryptResult {
+    memo: Hex;
+    record: CommitmentData | null;
+    metadata?: Record<string, unknown>;
+    error?: {
+        message: string;
+    };
+}
+interface AccMemberWitness {
+    /**
+     * Circuits witness format (matches `circuits/pkg/core/policies/witness_json.go`):
+     * - `root`: merkle root
+     * - `path`: merkle proof path (leaf at index 0, then sibling nodes)
+     * - `index`: leaf index
+     */
+    root: Hex | BigintLikeString;
+    path: Array<Hex | BigintLikeString>;
+    index: number;
+}
+interface InputSecret {
+    owner_keypair: {
+        user_pk: {
+            user_address: [bigint, bigint];
+            aead_encryption_key?: Hex;
+        };
+        user_sk: {
+            /**
+             * Witness payloads can be either raw bigint values (from local key derivation)
+             * or decimal strings (from wasm/json bridges).
+             */
+            address_sk: bigint | BigintLikeString;
+            aead_decryption_key?: Hex;
+        };
+    };
+    ro: CommitmentData;
+    acc_member_witness: AccMemberWitness;
+}
+interface FrPointJson {
+    X: bigint;
+    Y: bigint;
+}
+interface ViewerPkJson {
+    EncryptionKey: {
+        Key: FrPointJson;
+    };
+}
+interface FreezerPkJson {
+    Point: FrPointJson;
+}
+interface TransferWitnessInput {
+    asset_id: string;
+    asset_token_id: string;
+    asset_policy: {
+        viewer_pk: ViewerPkJson;
+        freezer_pk: FreezerPkJson;
+    };
+    input_secrets: InputSecret[];
+    array: Hex[];
+    fee: bigint;
+    max_amount: bigint;
+    output_record_openings: CommitmentData[];
+    viewing_memo_randomness?: Uint8Array | number[];
+    proof_binding?: string;
+}
+interface WithdrawWitnessInput {
+    asset_id: string;
+    asset_token_id: string;
+    asset_policy: {
+        viewer_pk: ViewerPkJson;
+        freezer_pk: FreezerPkJson;
+    };
+    input_secret: InputSecret;
+    output_record_opening: CommitmentData;
+    array: Hex[];
+    amount: bigint;
+    relayer_fee: bigint;
+    gas_drop_value: bigint;
+    viewing_memo_randomness?: Uint8Array | number[];
+    proof_binding?: string;
+}
+interface WitnessBuildResult {
+    witness: TransferWitnessInput | WithdrawWitnessInput | Record<string, any>;
+    array_hash_index?: number;
+    merkle_root_index?: number;
+    relayer?: string;
+    extra_data?: WitnessExtraData;
+    relayer_fee?: bigint;
+    gas_drop_value?: bigint;
+    array_hash_digest?: Hex;
+    witness_type?: 'transfer' | 'withdraw';
+    warnings?: string[];
+}
+interface WitnessContext {
+    array_hash_index?: number;
+    merkle_root_index?: number;
+    relayer?: string;
+    extra_data?: WitnessExtraData;
+    relayer_fee?: bigint;
+    gas_drop_value?: bigint;
+    array_hash_digest?: Hex;
+    recipient?: Address;
+    withdraw_amount?: bigint;
+}
+interface ProofResult {
+    proof: [string, string, string, string, string, string, string, string];
+    flatten_input: string[];
+    public_input?: Record<string, any>;
+    array_hash_index?: number;
+    merkle_root_index?: number;
+    relayer?: string;
+    recipient?: Address;
+    withdraw_amount?: bigint;
+    extra_data?: WitnessExtraData;
+    relayer_fee?: bigint;
+    gas_drop_value?: bigint;
+    array_hash_digest?: Hex;
+    gnark_output?: unknown;
+    witness_json?: Record<string, any>;
+    err?: {
+        message: string;
+        stack?: string;
+    } | null;
+    warnings?: string[];
+}
+type TransferExtraData = readonly [Hex, Hex, Hex];
+type WithdrawExtraData = Hex;
+type WitnessExtraData = TransferExtraData | WithdrawExtraData;
+interface ProofBridge {
+    init(): Promise<void>;
+    initTransfer(): Promise<void>;
+    initWithdraw(): Promise<void>;
+    proveTransfer(witness: string): Promise<string>;
+    proveWithdraw(witness: string): Promise<string>;
+    createMemo(ro: CommitmentData): Hex;
+    decryptMemo(secretKey: bigint, memo: Hex): CommitmentData | null;
+    commitment(ro: CommitmentData, format?: 'hex' | 'bigint'): Hex | bigint;
+    nullifier(secretKey: bigint, commitment: Hex, freezerPk?: [bigint, bigint]): Hex;
+    createDummyRecordOpening(): Promise<CommitmentData>;
+    createDummyInputSecret(): Promise<InputSecret>;
+}
+interface CommitmentFn {
+    (ro: CommitmentData, format: 'hex'): Hex;
+    (ro: CommitmentData, format: 'bigint'): bigint;
+    (ro: CommitmentData, format?: undefined): Hex;
+}
+interface SyncCursor {
+    memo: number;
+    nullifier: number;
+    /**
+     * Merkle cursor is the merkle root index (batch cursor), derived from memo sync (total elements).
+     * The root index typically advances only after a full batch (e.g. 32 leaves), so it will not equal `memo`.
+     */
+    merkle: number;
+}
+interface SyncChainStatus {
+    memo: {
+        status: 'idle' | 'syncing' | 'synced' | 'error';
+        downloaded: number;
+        total?: number;
+        errorMessage?: string;
+    };
+    nullifier: {
+        status: 'idle' | 'syncing' | 'synced' | 'error';
+        downloaded: number;
+        total?: number;
+        errorMessage?: string;
+    };
+    merkle: {
+        status: 'idle' | 'syncing' | 'synced' | 'error';
+        cursor: number;
+        errorMessage?: string;
+    };
+}
+type ListUtxosQuery = {
+    /** Filter by chain id. */
+    chainId?: number;
+    /** Filter by shielded asset id (pool id). */
+    assetId?: string;
+    /** Include spent UTXOs (default: false). */
+    includeSpent?: boolean;
+    /** Include frozen UTXOs (default: false). */
+    includeFrozen?: boolean;
+    /** Filter by spent flag (overrides includeSpent when set). */
+    spent?: boolean;
+    /** Filter by frozen flag (overrides includeFrozen when set). */
+    frozen?: boolean;
+    /** Result pagination offset (default: 0). */
+    offset?: number;
+    /** Result pagination limit (default: no limit). */
+    limit?: number;
+    /** Order by field (default: mkIndex). */
+    orderBy?: 'mkIndex' | 'createdAt';
+    /** Order direction (default: asc). */
+    order?: 'asc' | 'desc';
+};
+type EntryMemoRecord = {
+    /** Chain id (scoped). */
+    chainId: number;
+    /** Entry cid (memo index). */
+    cid: number;
+    /** Commitment of the leaf. */
+    commitment: Hex;
+    /** Encrypted memo payload. */
+    memo: Hex;
+    /** EntryService memo transparency flag. */
+    isTransparent?: boolean;
+    /** Optional transparent asset id override (hex). */
+    assetId?: Hex | null;
+    /** Optional transparent amount override (hex). */
+    amount?: Hex | null;
+    /** Optional transparent partial hash. */
+    partialHash?: Hex | null;
+    /** Optional transaction hash. */
+    txHash?: Hex | null;
+    /** Optional created_at from EntryService. */
+    createdAt?: number | null;
+};
+type EntryNullifierRecord = {
+    /** Chain id (scoped). */
+    chainId: number;
+    /**
+     * Nullifier index in EntryService ordering (stable for pagination).
+     * This is derived from `list_by_block` pagination offsets.
+     */
+    nid: number;
+    /** Nullifier value. */
+    nullifier: Hex;
+    /** Optional created_at from EntryService. */
+    createdAt?: number | null;
+};
+type ListEntryMemosQuery = {
+    chainId: number;
+    /** Start cid (inclusive). Defaults to 0. */
+    offset?: number;
+    /** Max rows to return. */
+    limit?: number;
+    /** Order by field (default: cid). */
+    orderBy?: 'cid' | 'createdAt';
+    /** Order direction (default: asc). */
+    order?: 'asc' | 'desc';
+    /** Filter by cid range (inclusive). */
+    cidFrom?: number;
+    /** Filter by cid range (inclusive). */
+    cidTo?: number;
+    /** Filter by createdAt range (inclusive, epoch). */
+    createdAtFrom?: number;
+    /** Filter by createdAt range (inclusive, epoch). */
+    createdAtTo?: number;
+};
+type ListEntryNullifiersQuery = {
+    chainId: number;
+    /** nid offset (defaults to 0). */
+    offset?: number;
+    /** Max rows to return. */
+    limit?: number;
+    /** Order by field (default: nid). */
+    orderBy?: 'nid' | 'createdAt';
+    /** Order direction (default: asc). */
+    order?: 'asc' | 'desc';
+    /** Filter by nid range (inclusive). */
+    nidFrom?: number;
+    /** Filter by nid range (inclusive). */
+    nidTo?: number;
+    /** Filter by createdAt range (inclusive, epoch). */
+    createdAtFrom?: number;
+    /** Filter by createdAt range (inclusive, epoch). */
+    createdAtTo?: number;
+};
+type ListEntryMemosResult = {
+    total: number;
+    rows: EntryMemoRecord[];
+};
+type ListEntryNullifiersResult = {
+    total: number;
+    rows: EntryNullifierRecord[];
+};
+type ListUtxosResult = {
+    total: number;
+    rows: UtxoRecord[];
+};
+type MerkleTreeState = {
+    /** Chain id (scoped). */
+    chainId: number;
+    /** Current tree root (for the merged/main tree). */
+    root: Hex;
+    /**
+     * Total elements that have been merged into the main tree.
+     * This matches `totalElementsInTree(contract.totalElements, tempArraySize)`.
+     */
+    totalElements: number;
+    /** Last updated timestamp (ms). */
+    lastUpdated: number;
+};
+type MerkleLeafRecord = {
+    chainId: number;
+    cid: number;
+    commitment: Hex;
+};
+type MerkleNodeRecord = {
+    chainId: number;
+    /**
+     * Node id.
+     * - Normal node: `${level}-${position}`
+     * - Frontier node: `frontier-${level}`
+     */
+    id: string;
+    level: number;
+    position: number;
+    hash: Hex;
+};
+interface StorageAdapter {
+    /**
+     * Initialize adapter state, optionally scoping storage by wallet id.
+     * Implementations should clear any cached state when `walletId` changes.
+     */
+    init?(options?: {
+        walletId?: string;
+    }): Promise<void> | void;
+    /** Close connections / flush pending writes. */
+    close?(): Promise<void> | void;
+    /** Read the last synced cursor for a chain. */
+    getSyncCursor(chainId: number): Promise<SyncCursor | undefined>;
+    /** Persist the current sync cursor for a chain. */
+    setSyncCursor(chainId: number, cursor: SyncCursor): Promise<void>;
+    /**
+     * Insert or update UTXO records by `(chainId, commitment)`.
+     * Implementations should preserve `isSpent` when upserting the same UTXO.
+     */
+    upsertUtxos(utxos: UtxoRecord[]): Promise<void>;
+    /**
+     * List UTXOs with optional filters and pagination.
+     * Pagination is applied after filtering.
+     */
+    listUtxos(query?: ListUtxosQuery): Promise<ListUtxosResult>;
+    /**
+     * Mark matching UTXOs as spent by nullifier.
+     * @returns number of updated records.
+     */
+    markSpent(input: {
+        chainId: number;
+        nullifiers: Hex[];
+    }): Promise<number>;
+    /**
+     * Create a local operation record (e.g. deposit/transfer/withdraw).
+     * Implementations should generate `id`, `createdAt`, and default `status` if missing.
+     */
+    createOperation<TType extends OperationType>(input: OperationCreateInput<TType>): StoredOperation<OperationDetailFor<TType>> & {
+        type: TType;
+    };
+    /** Update an existing operation record by id (best-effort). */
+    updateOperation(id: string, patch: Partial<StoredOperation>): void;
+    /** List operations with optional query (`limit`/`offset`/filters). */
+    listOperations(input?: number | ListOperationsQuery): StoredOperation[];
+    /**
+     * Optional governance helpers for long-lived apps.
+     * Implementations may persist changes best-effort.
+     */
+    deleteOperation?(id: string): Promise<boolean> | boolean;
+    clearOperations?(): Promise<void> | void;
+    pruneOperations?(options?: {
+        max?: number;
+    }): Promise<number> | number;
+    /**
+     * Optional merkle leaf persistence for `MerkleEngine` local/hybrid modes.
+     * Leaves are expected to be contiguous and cid-ordered (starting at 0).
+     * Implementations may store them best-effort.
+     */
+    getMerkleLeaves?(chainId: number): Promise<Array<{
+        cid: number;
+        commitment: Hex;
+    }> | undefined>;
+    appendMerkleLeaves?(chainId: number, leaves: Array<{
+        cid: number;
+        commitment: Hex;
+    }>): Promise<void>;
+    clearMerkleLeaves?(chainId: number): Promise<void>;
+    /**
+     * Optional Merkle DB: leaf lookup by cid (fast path for proof generation).
+     */
+    getMerkleLeaf?(chainId: number, cid: number): Promise<MerkleLeafRecord | undefined>;
+    /**
+     * Optional Merkle DB: node lookup by id (fast path for proof generation and incremental updates).
+     */
+    getMerkleNode?(chainId: number, id: string): Promise<MerkleNodeRecord | undefined>;
+    upsertMerkleNodes?(chainId: number, nodes: MerkleNodeRecord[]): Promise<void>;
+    clearMerkleNodes?(chainId: number): Promise<void>;
+    /**
+     * Optional entry memo persistence (raw EntryService payloads).
+     * Useful for debugging, rebuilds, and app-like local caches.
+     */
+    upsertEntryMemos?(memos: EntryMemoRecord[]): Promise<number> | number;
+    listEntryMemos?(query: ListEntryMemosQuery): Promise<ListEntryMemosResult>;
+    clearEntryMemos?(chainId: number): Promise<void> | void;
+    /**
+     * Optional entry nullifier persistence (raw EntryService payloads).
+     * Useful for debugging and app-like local caches.
+     */
+    upsertEntryNullifiers?(nullifiers: EntryNullifierRecord[]): Promise<number> | number;
+    listEntryNullifiers?(query: ListEntryNullifiersQuery): Promise<ListEntryNullifiersResult>;
+    clearEntryNullifiers?(chainId: number): Promise<void> | void;
+    /**
+     * Optional merkle tree state persistence (merged/main-tree only).
+     * This mirrors the client/app `MerkleDexie.trees` metadata.
+     */
+    getMerkleTree?(chainId: number): Promise<MerkleTreeState | undefined>;
+    setMerkleTree?(chainId: number, tree: MerkleTreeState): Promise<void>;
+    clearMerkleTree?(chainId: number): Promise<void>;
+}
+interface CoreApi {
+    ready: (onProgress?: (value: number) => void) => Promise<void>;
+    reset: () => void;
+    on: (type: SdkEvent['type'], handler: (event: SdkEvent) => void) => void;
+    off: (type: SdkEvent['type'], handler: (event: SdkEvent) => void) => void;
+}
+interface CryptoApi {
+    commitment: CommitmentFn;
+    nullifier: (secretKey: bigint, commitment: Hex, freezerPk?: [bigint, bigint]) => Hex;
+    createRecordOpening: (input: {
+        asset_id: bigint | number | string;
+        asset_amount: bigint | number | string;
+        user_pk: {
+            user_address: [bigint | number | string, bigint | number | string];
+        };
+        blinding_factor?: bigint | number | string;
+        is_frozen?: boolean;
+    }) => CommitmentData;
+    poolId: (tokenAddress: Hex | bigint | number | string, viewerPk: [bigint, bigint], freezerPk: [bigint, bigint]) => bigint;
+    viewingRandomness: () => Uint8Array;
+    memo: {
+        createMemo: (ro: CommitmentData) => Hex;
+        memoNonce: (ephemeralPublicKey: [bigint, bigint], userPublicKey: [bigint, bigint]) => Uint8Array;
+        decryptMemo: (secretKey: bigint, memo: Hex) => CommitmentData | null;
+        decryptBatch: (requests: MemoDecryptRequest[]) => Promise<MemoDecryptResult[]>;
+    };
+    dummy: {
+        createRecordOpening: () => Promise<CommitmentData>;
+        createInputSecret: () => Promise<InputSecret>;
+    };
+    utils: {
+        calcDepositFee: (amount: bigint, feeBps?: number) => bigint;
+        randomBytes32: () => Uint8Array;
+        randomBytes32Bigint: (isScalar?: boolean) => bigint;
+        serializeBigInt: <T>(value: T) => string;
+    };
+}
+interface KeysApi {
+    deriveKeyPair: (seed: string, nonce?: string) => UserKeyPair;
+    getSecretKeyBySeed: (seed: string, nonce?: string) => UserSecretKey;
+    getPublicKeyBySeed: (seed: string, nonce?: string) => UserPublicKey;
+    userPkToAddress: (userPk: {
+        user_address: [bigint | string, bigint | string];
+    }) => Hex;
+    addressToUserPk: (address: Hex) => {
+        user_address: [bigint, bigint];
+    };
+}
+interface AssetsApi {
+    getChains: () => ChainConfigInput[];
+    getChain: (chainId: number) => ChainConfigInput;
+    getTokens: (chainId: number) => TokenMetadata[];
+    getPoolInfo: (chainId: number, tokenId: string) => TokenMetadata | undefined;
+    getAllowanceTarget: (chainId: number) => Address;
+    appendTokens: (chainId: number, tokens: TokenMetadata[]) => void;
+    loadFromUrl: (url: string) => Promise<void>;
+    getRelayerConfig: (chainId: number) => RelayerConfig | undefined;
+    syncRelayerConfig: (chainId: number) => Promise<RelayerConfig>;
+    syncAllRelayerConfigs: () => Promise<void>;
+}
+interface StorageApi {
+    getAdapter: () => StorageAdapter;
+}
+interface SyncApi {
+    start(options?: {
+        chainIds?: number[];
+        pollMs?: number;
+    }): Promise<void>;
+    stop(): void;
+    syncOnce(options?: {
+        chainIds?: number[];
+        resources?: Array<'memo' | 'nullifier' | 'merkle'>;
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+        pageSize?: number;
+        continueOnError?: boolean;
+    }): Promise<void>;
+    getStatus(): Record<number, SyncChainStatus>;
+}
+interface RemoteMerkleProofResponse {
+    proof: Array<{
+        path: Array<Hex | BigintLikeString>;
+        leaf_index: string | number;
+    }>;
+    merkle_root: Hex | BigintLikeString;
+    latest_cid: number;
+}
+interface MerkleApi {
+    currentMerkleRootIndex: (totalElements: number, tempArraySize?: number) => number;
+    /**
+     * Get Merkle proofs by cid with local-first fallback behavior.
+     *
+     * Notes (mirrors client/app behavior):
+     * - First try to build proofs locally (if enabled and available).
+     * - If local proof is missing for some cids, check whether those cids are still in the on-chain buffer
+     *   (i.e. not yet merged into the main tree); such cids do not require remote proof fetching.
+     * - Otherwise, fetch missing proofs from the remote proof service.
+     */
+    getProofByCids: (input: {
+        chainId: number;
+        cids: number[];
+        totalElements: bigint;
+    }) => Promise<RemoteMerkleProofResponse>;
+    /** Convenience wrapper for single cid. */
+    getProofByCid: (input: {
+        chainId: number;
+        cid: number;
+        totalElements: bigint;
+    }) => Promise<RemoteMerkleProofResponse>;
+    /**
+     * Optional helper for building a local Merkle tree from contiguous Entry memo pages.
+     * When supported by the implementation, callers may feed memo batches to enable local proof generation.
+     */
+    ingestEntryMemos?: (chainId: number, memos: Array<{
+        cid: number | null;
+        commitment: Hex | string | bigint;
+    }>) => Promise<void> | void;
+    buildAccMemberWitnesses: (input: {
+        remote: RemoteMerkleProofResponse;
+        utxos: Array<{
+            commitment: Hex;
+            mkIndex: number;
+        }>;
+        arrayHash: bigint;
+        totalElements: bigint;
+    }) => AccMemberWitness[];
+    buildInputSecretsFromUtxos: (input: {
+        remote: RemoteMerkleProofResponse;
+        utxos: Array<{
+            commitment: Hex;
+            memo?: Hex;
+            mkIndex: number;
+        }>;
+        ownerKeyPair: UserKeyPair;
+        arrayHash: bigint;
+        totalElements: bigint;
+        /**
+         * Transfer circuit uses fixed `maxInputs=3`. When provided, the implementation pads the returned
+         * list with dummy input secrets to reach this length (and errors if utxos exceed it).
+         */
+        maxInputs?: number;
+    }) => Promise<InputSecret[]>;
+}
+interface WalletSessionInput {
+    seed: string | Uint8Array;
+    accountNonce?: number;
+}
+interface UtxoRecord {
+    chainId: number;
+    assetId: string;
+    amount: bigint;
+    commitment: Hex;
+    nullifier: Hex;
+    mkIndex: number;
+    isFrozen: boolean;
+    isSpent: boolean;
+    memo?: Hex;
+    createdAt?: number;
+}
+interface WalletApi {
+    open(session: WalletSessionInput): Promise<void>;
+    close(): Promise<void>;
+    getUtxos(query?: ListUtxosQuery): Promise<ListUtxosResult>;
+    getBalance(query?: {
+        chainId?: number;
+        assetId?: string;
+    }): Promise<bigint>;
+    markSpent(input: {
+        chainId: number;
+        nullifiers: Hex[];
+    }): Promise<void>;
+}
+type PlannerEstimateTransferResult = {
+    action: 'transfer';
+    chainId: number;
+    assetId: string;
+    sendAmount: bigint;
+    relayerFee: bigint;
+    required: bigint;
+    selectedInputs: UtxoRecord[];
+    selectedSum: bigint;
+    ok: boolean;
+    okWithMerge: boolean;
+    feeSummary: PlannerFeeSummary;
+    maxSummary: PlannerFeeSummary;
+    constraints: {
+        maxInputs: number;
+    };
+};
+type PlannerEstimateWithdrawResult = {
+    action: 'withdraw';
+    chainId: number;
+    assetId: string;
+    requestedAmount: bigint;
+    relayerFee: bigint;
+    protocolFee: bigint;
+    burnAmount: bigint;
+    selectedInput: UtxoRecord | null;
+    ok: boolean;
+    okWithMerge: boolean;
+    feeSummary: PlannerFeeSummary;
+    maxSummary: PlannerFeeSummary;
+    constraints: {
+        requiresSingleInput: true;
+    };
+};
+type PlannerEstimateResult = PlannerEstimateTransferResult | PlannerEstimateWithdrawResult;
+type PlannerFeeSummary = {
+    mergeCount: number;
+    feeCount: number;
+    relayerFeeTotal: bigint;
+    protocolFeeTotal: bigint;
+    totalInput: bigint;
+    outputAmount: bigint;
+    cost: bigint;
+    inputCount: number;
+};
+type PlannerMaxEstimateResult = {
+    action: 'transfer' | 'withdraw';
+    chainId: number;
+    assetId: string;
+    ok: boolean;
+    maxSummary: PlannerFeeSummary;
+};
+type TransferPlan = {
+    action: 'transfer';
+    chainId: number;
+    assetId: string;
+    token: TokenMetadata;
+    requestedAmount: bigint;
+    sendAmount: bigint;
+    to: Hex;
+    relayer: Address;
+    relayerUrl?: string;
+    relayerFee: bigint;
+    required: bigint;
+    okWithMerge: boolean;
+    feeSummary: PlannerFeeSummary;
+    maxSummary: PlannerFeeSummary;
+    selectedInputs: UtxoRecord[];
+    selectedSum: bigint;
+    outputs: readonly [CommitmentData, CommitmentData, CommitmentData];
+    extraData: readonly [Hex, Hex, Hex];
+    proofBinding: string;
+};
+type TransferMergePlan = {
+    action: 'transfer-merge';
+    chainId: number;
+    assetId: string;
+    requestedAmount: bigint;
+    sendAmount: bigint;
+    to: Hex;
+    relayer: Address;
+    relayerUrl?: string;
+    relayerFee: bigint;
+    required: bigint;
+    okWithMerge: boolean;
+    feeSummary: PlannerFeeSummary;
+    maxSummary: PlannerFeeSummary;
+    mergePlan: TransferPlan;
+};
+type WithdrawPlan = {
+    action: 'withdraw';
+    chainId: number;
+    assetId: string;
+    token: TokenMetadata;
+    requestedAmount: bigint;
+    relayer: Address;
+    relayerUrl?: string;
+    relayerFee: bigint;
+    protocolFee: bigint;
+    burnAmount: bigint;
+    gasDropValue: bigint;
+    okWithMerge: boolean;
+    feeSummary: PlannerFeeSummary;
+    maxSummary: PlannerFeeSummary;
+    selectedInput: UtxoRecord;
+    outputRecordOpening: CommitmentData;
+    extraData: Hex;
+    proofBinding: string;
+    recipient: Hex;
+};
+type PlannerPlanResult = TransferPlan | TransferMergePlan | WithdrawPlan;
+interface PlannerApi {
+    estimate(input: {
+        chainId: number;
+        assetId: string;
+        action: 'transfer' | 'withdraw';
+        amount: bigint;
+        payIncludesFee?: boolean;
+    }): Promise<PlannerEstimateResult>;
+    estimateMax(input: {
+        chainId: number;
+        assetId: string;
+        action: 'transfer' | 'withdraw';
+        payIncludesFee?: boolean;
+    }): Promise<PlannerMaxEstimateResult>;
+    plan(input: Record<string, unknown>): Promise<PlannerPlanResult>;
+}
+interface ZkpApi {
+    createWitnessTransfer: (input: TransferWitnessInput, context?: WitnessContext) => Promise<WitnessBuildResult>;
+    createWitnessWithdraw: (input: WithdrawWitnessInput, context?: WitnessContext) => Promise<WitnessBuildResult>;
+    proveTransfer: (witness: TransferWitnessInput | string, context?: WitnessContext) => Promise<ProofResult>;
+    proveWithdraw: (witness: WithdrawWitnessInput | string, context?: WitnessContext) => Promise<ProofResult>;
+}
+interface RelayerRequest {
+    kind: 'relayer';
+    method: 'POST';
+    path: string;
+    body: Record<string, unknown>;
+}
+interface TxBuilderApi {
+    buildTransferCalldata: (input: {
+        chainId: number;
+        proof: ProofResult;
+    }) => Promise<RelayerRequest>;
+    buildWithdrawCalldata: (input: {
+        chainId: number;
+        proof: ProofResult;
+    }) => Promise<RelayerRequest>;
+}
+interface OpsApi {
+    prepareTransfer(input: {
+        chainId: number;
+        assetId: string;
+        amount: bigint;
+        to: Hex;
+        ownerKeyPair: UserKeyPair;
+        publicClient: PublicClient;
+        relayerUrl?: string;
+        autoMerge?: boolean;
+    }): Promise<{
+        kind: 'transfer';
+        plan: TransferPlan;
+        witness: TransferWitnessInput;
+        proof: ProofResult;
+        request: RelayerRequest;
+        meta: {
+            arrayHashIndex: number;
+            merkleRootIndex: number;
+            relayer: Address;
+        };
+    } | {
+        kind: 'merge';
+        plan: TransferMergePlan;
+        merge: {
+            plan: TransferPlan;
+            witness: TransferWitnessInput;
+            proof: ProofResult;
+            request: RelayerRequest;
+            meta: {
+                arrayHashIndex: number;
+                merkleRootIndex: number;
+                relayer: Address;
+            };
+        };
+        nextInput: {
+            chainId: number;
+            assetId: string;
+            amount: bigint;
+            to: Hex;
+            relayerUrl?: string;
+            autoMerge?: boolean;
+        };
+    }>;
+    prepareWithdraw(input: {
+        chainId: number;
+        assetId: string;
+        amount: bigint;
+        recipient: Address;
+        ownerKeyPair: UserKeyPair;
+        publicClient: PublicClient;
+        gasDropValue?: bigint;
+        relayerUrl?: string;
+    }): Promise<{
+        plan: WithdrawPlan;
+        witness: WithdrawWitnessInput;
+        proof: ProofResult;
+        request: RelayerRequest;
+        meta: {
+            arrayHashIndex: number;
+            merkleRootIndex: number;
+            relayer: Address;
+        };
+    }>;
+    prepareDeposit(input: {
+        chainId: number;
+        assetId: string;
+        amount: bigint;
+        ownerPublicKey: UserPublicKey;
+        account: Address;
+        publicClient: PublicClient;
+    }): Promise<{
+        chainId: number;
+        assetId: string;
+        amount: bigint;
+        token: TokenMetadata;
+        recordOpening: CommitmentData;
+        memo: Hex;
+        protocolFee: bigint;
+        payAmount: bigint;
+        depositRelayerFee: bigint;
+        value: bigint;
+        approveNeeded: boolean;
+        approveRequest?: {
+            chainId: number;
+            address: Address;
+            abi: any;
+            functionName: 'approve';
+            args: [Address, bigint];
+        };
+        depositRequest: {
+            chainId: number;
+            address: Address;
+            abi: any;
+            functionName: 'deposit';
+            args: [bigint, bigint, [bigint, bigint], bigint, Hex];
+            value: bigint;
+        };
+    }>;
+    submitDeposit(input: {
+        prepared: Awaited<ReturnType<OpsApi['prepareDeposit']>>;
+        walletClient: {
+            writeContract: (request: {
+                address: Address;
+                abi: any;
+                functionName: string;
+                args: any;
+                value?: bigint;
+                chainId?: number;
+            }) => Promise<Hex>;
+        };
+        publicClient: PublicClient;
+        autoApprove?: boolean;
+        confirmations?: number;
+        operationId?: string;
+    }): Promise<{
+        txHash: Hex;
+        approveTxHash?: Hex;
+        receipt?: TransactionReceipt;
+        operationId?: string;
+    }>;
+    waitRelayerTxHash(input: {
+        relayerUrl: string;
+        relayerTxHash: Hex;
+        timeoutMs?: number;
+        intervalMs?: number;
+        signal?: AbortSignal;
+        operationId?: string;
+        requestUrl?: string;
+    }): Promise<Hex>;
+    waitForTransactionReceipt(input: {
+        publicClient: PublicClient;
+        txHash: Hex;
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+        confirmations?: number;
+        operationId?: string;
+    }): Promise<TransactionReceipt>;
+    submitRelayerRequest<T = unknown>(input: {
+        prepared: {
+            plan: TransferPlan | WithdrawPlan;
+            request: RelayerRequest;
+            kind?: 'transfer' | 'merge';
+        };
+        relayerUrl?: string;
+        signal?: AbortSignal;
+        operationId?: string;
+        operation?: OperationCreateInput;
+        publicClient?: PublicClient;
+        relayerTimeoutMs?: number;
+        relayerIntervalMs?: number;
+        receiptTimeoutMs?: number;
+        receiptPollIntervalMs?: number;
+        confirmations?: number;
+    }): Promise<{
+        result: T;
+        operationId?: string;
+        updateOperation: (patch: Partial<StoredOperation>) => void;
+        waitRelayerTxHash: Promise<Hex>;
+        transactionReceipt?: Promise<TransactionReceipt>;
+    }>;
+}
+interface OCashSdk {
+    core: CoreApi;
+    crypto: CryptoApi;
+    keys: KeysApi;
+    assets: AssetsApi;
+    storage: StorageApi;
+    sync: SyncApi;
+    merkle: MerkleApi;
+    wallet: WalletApi;
+    planner: PlannerApi;
+    zkp: ZkpApi;
+    tx: TxBuilderApi;
+    ops: OpsApi;
+}
+interface UserPublicKey {
+    user_pk: {
+        user_address: [bigint, bigint];
+    };
+}
+interface UserSecretKey extends UserPublicKey {
+    user_sk: {
+        address_sk: bigint;
+    };
+}
+interface UserKeyPair extends UserSecretKey {
+}
+
+declare const defaultAssetsOverride: AssetsOverride;
+
+declare class MemoKit {
+    static createMemo(ro: CommitmentData): `0x${string}`;
+    static decryptMemo(secretKey: bigint, encoded: `0x${string}`): CommitmentData | null;
+    static decodeMemoForOwner(input: {
+        secretKey: bigint;
+        memo: Hex;
+        expectedAddress?: Hex | null;
+        isTransparent?: boolean;
+    }): CommitmentData | null;
+    static memoNonce(ephemeralPublicKey: [bigint, bigint], userPublicKey: [bigint, bigint]): Uint8Array;
+}
+
+declare class CryptoToolkit {
+    static commitment(record: CommitmentData, format: 'hex'): Hex;
+    static commitment(record: CommitmentData, format: 'bigint'): bigint;
+    static nullifier(secretKey: bigint, commitment: `0x${string}`, freezerPk?: [bigint, bigint]): `0x${string}`;
+    static createRecordOpening(input: {
+        asset_id: bigint | number | string;
+        asset_amount: bigint | number | string;
+        user_pk: {
+            user_address: [bigint | number | string, bigint | number | string];
+        };
+        blinding_factor?: bigint | number | string;
+        is_frozen?: boolean;
+    }): CommitmentData;
+    static viewingRandomness(): Uint8Array;
+    static poolId(tokenAddress: Hex | bigint | number | string, viewerPk: [bigint, bigint], freezerPk: [bigint, bigint]): bigint;
+}
+
+declare class KeyManager {
+    static deriveKeyPair(seed: string, nonce?: string): UserKeyPair;
+    static getPublicKeyBySeed(seed: string, nonce?: string): UserPublicKey;
+    static getSecretKeyBySeed(seed: string, nonce?: string): UserSecretKey;
+    static userPkToAddress(userPk: {
+        user_address: [bigint | string, bigint | string];
+    }): Hex;
+    static addressToUserPk(address: Hex): {
+        user_address: [bigint, bigint];
+    };
+}
+
+declare class LedgerInfo {
+    private readonly chains;
+    private readonly relayerManager;
+    constructor(initialChains?: ChainConfigInput[]);
+    private upsertChain;
+    getChains(): ChainConfigInput[];
+    getChain(chainId: number): ChainConfigInput;
+    getTokens(chainId: number): TokenMetadata[];
+    getPoolInfo(chainId: number, tokenId: string): TokenMetadata | undefined;
+    getAllowanceTarget(chainId: number): Address;
+    appendTokens(chainId: number, tokens: TokenMetadata[]): void;
+    loadFromUrl(url: string): Promise<void>;
+    getRelayerConfig(chainId: number): RelayerConfig | undefined;
+    syncRelayerConfig(chainId: number): Promise<RelayerConfig>;
+    syncAllRelayerConfigs(): Promise<void>;
+}
+
+/**
+ * Normalize token metadata from app-style or sdk-style shapes.
+ *
+ * Supported legacy fields (app):
+ * - `wrapped_erc20` (instead of `wrappedErc20`)
+ * - `viewerPK` / `freezerPK` (instead of `viewerPk` / `freezerPk`)
+ * - `depositFeeBPS` / `withdrawFeeBPS` (instead of `depositFeeBps` / `withdrawFeeBps`)
+ */
+declare const normalizeTokenMetadata: (input: unknown) => TokenMetadata;
+
+declare function assertTokenMetadata(value: unknown, name?: string): asserts value is TokenMetadata;
+declare function assertTokenList(value: unknown, name?: string): asserts value is TokenMetadata[];
+declare function assertChainConfigInput(value: unknown, name?: string): asserts value is ChainConfigInput;
+
+declare function fetchPoolTokensFromContract(input: {
+    publicClient: PublicClient;
+    chainId: number;
+    contractAddress: Address;
+    maxPools?: number;
+    includeErc20Metadata?: boolean;
+}): Promise<TokenMetadata[]>;
+
+declare class DummyFactory {
+    private readonly bridge;
+    constructor(bridge: ProofBridge);
+    createRecordOpening(): Promise<CommitmentData>;
+    createInputSecret(): Promise<InputSecret>;
+}
+
+declare const Utils: {
+    calcDepositFee: (amount: bigint, feeBps?: number) => bigint;
+    randomBytes32: () => Uint8Array<ArrayBufferLike>;
+    randomBytes32Bigint: (isBabyJubScalar?: boolean) => bigint;
+    serializeBigInt: <T>(value: T) => string;
+};
+
+declare const BABYJUBJUB_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+declare function calcTransferProofBinding(input: {
+    relayer: string;
+    extraData: TransferExtraData;
+}): bigint;
+declare function calcWithdrawProofBinding(input: {
+    recipient: string;
+    amount: bigint;
+    relayer: string;
+    relayerFee: bigint;
+    gasDropValue: bigint;
+    extraData: Hex;
+}): bigint;
+
+declare const App_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "depositRelayerFee";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "poolIds";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getPoolInfo";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "depositFeeBPS";
+            readonly type: "uint16";
+        }, {
+            readonly name: "withdrawFeeBPS";
+            readonly type: "uint16";
+        }, {
+            readonly name: "accumulatedFee";
+            readonly type: "uint128";
+        }, {
+            readonly name: "viewerPK";
+            readonly type: "uint256[2]";
+        }, {
+            readonly name: "freezerPK";
+            readonly type: "uint256[2]";
+        }, {
+            readonly name: "transferMaxAmount";
+            readonly type: "uint128";
+        }, {
+            readonly name: "withdrawMaxAmount";
+            readonly type: "uint128";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "deposit";
+    readonly inputs: readonly [{
+        readonly name: "poolId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint128";
+    }, {
+        readonly name: "userPK";
+        readonly type: "uint256[2]";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "getArray";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "digest";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "merkleTreeRoot";
+        readonly type: "uint256";
+    }, {
+        readonly name: "currentArrayHash";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalElements";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "merkleRoots";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "ArrayMergedToTree";
+    readonly inputs: readonly [{
+        readonly name: "batchIndex";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "newRoot";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }];
+    readonly anonymous: false;
+}];
+
+declare const ERC20_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "name";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "allowance";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}];
+
+declare class MemoryStore implements StorageAdapter {
+    private walletId;
+    private readonly cursors;
+    private readonly utxos;
+    private operations;
+    private readonly merkleLeavesByChain;
+    private readonly merkleTreesByChain;
+    private readonly merkleNodesByChain;
+    private readonly entryMemosByChain;
+    private readonly entryNullifiersByChain;
+    private readonly maxOperations;
+    constructor(options?: {
+        maxOperations?: number;
+    });
+    init(options?: {
+        walletId?: string;
+    }): void;
+    close(): void;
+    private enforceMaxOperations;
+    getSyncCursor(chainId: number): Promise<SyncCursor | undefined>;
+    setSyncCursor(chainId: number, cursor: SyncCursor): Promise<void>;
+    upsertUtxos(utxos: UtxoRecord[]): Promise<void>;
+    listUtxos(query?: ListUtxosQuery): Promise<{
+        total: number;
+        rows: UtxoRecord[];
+    }>;
+    markSpent(input: {
+        chainId: number;
+        nullifiers: Hex[];
+    }): Promise<number>;
+    getMerkleLeaves(chainId: number): Promise<Array<{
+        cid: number;
+        commitment: Hex;
+    }> | undefined>;
+    appendMerkleLeaves(chainId: number, leaves: Array<{
+        cid: number;
+        commitment: Hex;
+    }>): Promise<void>;
+    clearMerkleLeaves(chainId: number): Promise<void>;
+    getMerkleLeaf(chainId: number, cid: number): Promise<MerkleLeafRecord | undefined>;
+    getMerkleNode(chainId: number, id: string): Promise<MerkleNodeRecord | undefined>;
+    upsertMerkleNodes(chainId: number, nodes: MerkleNodeRecord[]): Promise<void>;
+    clearMerkleNodes(chainId: number): Promise<void>;
+    getMerkleTree(chainId: number): Promise<MerkleTreeState | undefined>;
+    setMerkleTree(chainId: number, tree: MerkleTreeState): Promise<void>;
+    clearMerkleTree(chainId: number): Promise<void>;
+    upsertEntryMemos(memos: EntryMemoRecord[]): Promise<number>;
+    listEntryMemos(query: ListEntryMemosQuery): Promise<{
+        total: number;
+        rows: EntryMemoRecord[];
+    }>;
+    clearEntryMemos(chainId: number): Promise<void>;
+    upsertEntryNullifiers(nullifiers: EntryNullifierRecord[]): Promise<number>;
+    listEntryNullifiers(query: ListEntryNullifiersQuery): Promise<{
+        total: number;
+        rows: EntryNullifierRecord[];
+    }>;
+    clearEntryNullifiers(chainId: number): Promise<void>;
+    createOperation<TType extends OperationType>(input: Omit<StoredOperation<OperationDetailFor<TType>>, 'id' | 'createdAt' | 'status'> & Partial<Pick<StoredOperation<OperationDetailFor<TType>>, 'createdAt' | 'id' | 'status'>> & {
+        type: TType;
+    }): StoredOperation<OperationDetailFor<TType>> & {
+        type: TType;
+    };
+    updateOperation(id: string, patch: Partial<StoredOperation>): void;
+    deleteOperation(id: string): boolean;
+    clearOperations(): void;
+    pruneOperations(options?: {
+        max?: number;
+    }): number;
+    listOperations(input?: number | ListOperationsQuery): StoredOperation[];
+}
+
+type KeyValueStoreOptions = {
+    client: KeyValueClient;
+    keyPrefix?: string;
+    maxOperations?: number;
+};
+declare class KeyValueStore implements StorageAdapter {
+    private readonly options;
+    private walletId;
+    private readonly cursors;
+    private readonly utxos;
+    private operations;
+    private merkleLeaves;
+    private merkleTrees;
+    private merkleNodes;
+    private entryMemos;
+    private entryNullifiers;
+    private saveChain;
+    private readonly maxOperations;
+    constructor(options: KeyValueStoreOptions);
+    init(options?: {
+        walletId?: string;
+    }): Promise<void>;
+    close(): Promise<void>;
+    private stateKey;
+    private load;
+    private save;
+    getMerkleNode(chainId: number, id: string): Promise<MerkleNodeRecord | undefined>;
+    upsertMerkleNodes(chainId: number, nodes: MerkleNodeRecord[]): Promise<void>;
+    clearMerkleNodes(chainId: number): Promise<void>;
+    getMerkleTree(chainId: number): Promise<MerkleTreeState | undefined>;
+    setMerkleTree(chainId: number, tree: MerkleTreeState): Promise<void>;
+    clearMerkleTree(chainId: number): Promise<void>;
+    upsertEntryMemos(memos: EntryMemoRecord[]): Promise<number>;
+    listEntryMemos(query: ListEntryMemosQuery): Promise<{
+        total: number;
+        rows: EntryMemoRecord[];
+    }>;
+    clearEntryMemos(chainId: number): Promise<void>;
+    upsertEntryNullifiers(nullifiers: EntryNullifierRecord[]): Promise<number>;
+    listEntryNullifiers(query: ListEntryNullifiersQuery): Promise<{
+        total: number;
+        rows: EntryNullifierRecord[];
+    }>;
+    clearEntryNullifiers(chainId: number): Promise<void>;
+    getMerkleLeaves(chainId: number): Promise<Array<{
+        cid: number;
+        commitment: Hex;
+    }> | undefined>;
+    getMerkleLeaf(chainId: number, cid: number): Promise<{
+        chainId: number;
+        cid: number;
+        commitment: `0x${string}`;
+    } | undefined>;
+    appendMerkleLeaves(chainId: number, leaves: Array<{
+        cid: number;
+        commitment: Hex;
+    }>): Promise<void>;
+    clearMerkleLeaves(chainId: number): Promise<void>;
+    getSyncCursor(chainId: number): Promise<SyncCursor | undefined>;
+    setSyncCursor(chainId: number, cursor: SyncCursor): Promise<void>;
+    upsertUtxos(utxos: UtxoRecord[]): Promise<void>;
+    listUtxos(query?: ListUtxosQuery): Promise<{
+        total: number;
+        rows: UtxoRecord[];
+    }>;
+    markSpent(input: {
+        chainId: number;
+        nullifiers: Hex[];
+    }): Promise<number>;
+    createOperation<TType extends OperationType>(input: Omit<StoredOperation<OperationDetailFor<TType>>, 'id' | 'createdAt' | 'status'> & Partial<Pick<StoredOperation<OperationDetailFor<TType>>, 'createdAt' | 'id' | 'status'>> & {
+        type: TType;
+    }): StoredOperation<OperationDetailFor<TType>> & {
+        type: TType;
+    };
+    updateOperation(id: string, patch: Partial<StoredOperation>): void;
+    deleteOperation(id: string): boolean;
+    clearOperations(): void;
+    pruneOperations(options?: {
+        max?: number;
+    }): number;
+    listOperations(input?: number | ListOperationsQuery): StoredOperation[];
+}
+type RedisStoreOptions = KeyValueStoreOptions;
+declare class RedisStore extends KeyValueStore {
+    constructor(options: RedisStoreOptions);
+}
+type SqliteStoreOptions = KeyValueStoreOptions;
+declare class SqliteStore extends KeyValueStore {
+    constructor(options: SqliteStoreOptions);
+}
+interface KeyValueClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    del?(key: string): Promise<void>;
+}
+
+declare const createSdk: (config: OCashSdkConfig) => OCashSdk;
+declare const OcashSdk: {
+    readonly createSdk: (config: OCashSdkConfig) => OCashSdk;
+    readonly MemoKit: typeof MemoKit;
+    readonly CryptoToolkit: typeof CryptoToolkit;
+    readonly KeyManager: typeof KeyManager;
+    readonly LedgerInfo: typeof LedgerInfo;
+    readonly DummyFactory: typeof DummyFactory;
+    readonly Utils: {
+        calcDepositFee: (amount: bigint, feeBps?: number) => bigint;
+        randomBytes32: () => Uint8Array<ArrayBufferLike>;
+        randomBytes32Bigint: (isBabyJubScalar?: boolean) => bigint;
+        serializeBigInt: <T>(value: T) => string;
+    };
+    readonly MemoryStore: typeof MemoryStore;
+};
+
+export { type TransferWitnessInput as $, App_ABI as A, BABYJUBJUB_SCALAR_FIELD as B, type ChainConfigInput as C, type DepositOperation as D, type EntryMemoRecord as E, type OpsApi as F, type PlannerEstimateWithdrawResult as G, type Hex as H, type ProofResult as I, type RedisStoreOptions as J, KeyManager as K, type ListEntryMemosQuery as L, type MerkleNodeRecord as M, type RelayerRequest as N, type OperationType as O, type PlannerEstimateTransferResult as P, type SdkEvent as Q, RedisStore as R, type StorageAdapter as S, SqliteStore as T, type UtxoRecord as U, type SqliteStoreOptions as V, type SyncChainStatus as W, type TokenMetadata as X, type TransactionReceipt as Y, type TransferOperation as Z, type TransferOperationDetail as _, type MerkleTreeState as a, Utils as a0, type WalletSessionInput as a1, type WithdrawOperation as a2, type WithdrawOperationDetail as a3, type WithdrawWitnessInput as a4, type WitnessBuildResult as a5, type WitnessContext as a6, assertChainConfigInput as a7, assertTokenList as a8, assertTokenMetadata as a9, calcTransferProofBinding as aa, calcWithdrawProofBinding as ab, createSdk as ac, OcashSdk as ad, defaultAssetsOverride as ae, fetchPoolTokensFromContract as af, normalizeTokenMetadata as ag, type EntryNullifierRecord as b, type ListEntryNullifiersQuery as c, type SyncCursor as d, type ListUtxosQuery as e, type StoredOperation as f, type OperationDetailFor as g, type ListOperationsQuery as h, type AssetOverrideEntry as i, type AssetsOverride as j, type CommitmentData as k, CryptoToolkit as l, type DepositOperationDetail as m, DummyFactory as n, ERC20_ABI as o, type KeyValueClient as p, KeyValueStore as q, type KeyValueStoreOptions as r, LedgerInfo as s, MemoKit as t, MemoryStore as u, type MerkleLeafRecord as v, type OCashSdk as w, type OCashSdkConfig as x, type OperationCreateInput as y, type OperationStatus as z };