@orbinum/sdk 0.4.2 → 0.5.0

package/dist/index.d.mts

@@ -1,8 +1,10 @@
 import * as polkadot_api from 'polkadot-api';
-import { PolkadotClient, TxFinalizedPayload, PolkadotSigner } from 'polkadot-api';
+import { PolkadotClient, TxFinalizedPayload, PolkadotSigner, TxOptions } from 'polkadot-api';
 export { PolkadotSigner, getSs58AddressInfo } from 'polkadot-api';
 import { getDynamicBuilder } from '@polkadot-api/metadata-builders';
 import { getExtrinsicDecoder } from '@polkadot-api/tx-utils';
+import { ArtifactProvider, ProofResult, DisclosureProofOutput } from '@orbinum/proof-generator';
+export { ArtifactProvider, CircuitType, DisclosureMask as DisclosureFlags, DisclosureProofOutput, ProofResult, WebArtifactProvider, generateDisclosureProof } from '@orbinum/proof-generator';
 export { AccountId, Blake2256, Keccak256, Storage, u128, u64 } from '@polkadot-api/substrate-bindings';
 export { base58 } from '@scure/base';
 export { getPolkadotSigner } from 'polkadot-api/signer';
@@ -179,6 +181,12 @@ declare class SubstrateClient {
      * Events: TxSigned → TxBroadcasted → TxBestBlocksState → TxFinalized
      */
     submitAndWatch(signedHex: string): ReturnType<PolkadotClient['submitAndWatch']>;
+    /**
+     * Submits a bare (unsigned) extrinsic hex and waits for finalization.
+     * Used for gasless private_transfer and unshield transactions.
+     * The bare tx hex is produced by `tx.getBareTx()` from polkadot-api.
+     */
+    submitUnsignedAndWatch(bareTxHex: string): Promise<TxFinalizedPayload>;
     /**
      * Convenience: wrap raw call bytes and sign+submit in one step.
      */
@@ -213,13 +221,16 @@ declare class SubstrateClient {
  */
 declare class EvmClient {
     private readonly rpcUrl;
+    /** @param rpcUrl - HTTP URL of the EVM JSON-RPC endpoint (e.g. `"http://localhost:9933"`). */
     constructor(rpcUrl: string);
     /**
-     * Performs a single JSON-RPC call.
+     * Performs a single JSON-RPC call and returns the typed result.
+     * Throws on HTTP errors, RPC-level errors, or a `null` result.
      */
     request<T>(method: string, params?: unknown[]): Promise<T>;
     /**
      * Performs multiple JSON-RPC calls in a single HTTP request (batch).
+     * Results are returned in the same order as `calls`, as a typed tuple.
      */
     batchRequest<T extends unknown[]>(calls: Array<{
         method: string;
@@ -235,100 +246,166 @@ declare class EvmClient {
     getTransactionCount(address: string): Promise<number>;
     /** Returns the current gas price in wei. */
     getGasPrice(): Promise<bigint>;
-    /**
-     * Submits a signed raw transaction. Returns the transaction hash.
-     */
+    /** Submits a signed raw transaction. Returns the transaction hash. */
     sendRawTransaction(signedHex: string): Promise<string>;
-    /**
-     * Executes a read-only call without creating a transaction.
-     */
+    /** Executes a read-only call without creating a transaction. Returns the raw ABI-encoded response. */
     call(to: string, data: string, from?: string): Promise<string>;
-    /**
-     * Estimates the gas for a transaction.
-     */
+    /** Estimates the gas required for a transaction. Returns the estimate in wei as a `bigint`. */
     estimateGas(params: {
         from?: string;
         to: string;
         data?: string;
         value?: string;
     }): Promise<bigint>;
+    /** Returns a transaction receipt by hash, or `null` if the transaction has not been mined yet. */
+    getTransactionReceipt(txHash: string): Promise<Record<string, unknown> | null>;
     /**
-     * Returns a transaction receipt by hash, or null if not yet mined.
+     * Polls `eth_getTransactionReceipt` until the transaction is included in a block.
+     *
+     * @param txHash - The transaction hash to wait for.
+     * @param intervalMs - Polling interval in milliseconds (default: 500).
+     * @param timeoutMs - Maximum time to wait in milliseconds (default: 60_000).
+     * @returns The transaction receipt once mined.
+     * @throws If the transaction is not mined within `timeoutMs` or if it reverted (`status == 0x0`).
      */
-    getTransactionReceipt(txHash: string): Promise<Record<string, unknown> | null>;
+    waitForReceipt(txHash: string, intervalMs?: number, timeoutMs?: number): Promise<Record<string, unknown>>;
 }
 
 /** Enriched EVM transaction model for explorer UIs. */
 interface EvmTransaction {
+    /** 0x-prefixed transaction hash. */
     hash: string;
+    /** Block number in which the transaction was included. */
     blockNumber: number;
+    /** 0x-prefixed hash of the containing block. Only present when fetched with block context. */
     blockHash?: string;
+    /** Sender address (checksummed or lowercase hex). */
     from: string;
+    /** Recipient address, or `null` for contract-creation transactions. */
     to: string | null;
+    /** Native token value transferred, as a 0x-prefixed hex string (wei). */
     value: string;
+    /** Gas actually consumed by the transaction, as a decimal string. */
     gasUsed: string;
+    /** Gas price in wei, as a decimal string. */
     gasPrice: string;
+    /** Sender nonce at the time of submission. */
     nonce: number;
+    /** ABI-encoded call data (0x-prefixed hex). `'0x'` for plain transfers. */
     input: string;
+    /** `1` for success, `0` for revert. */
     status: number;
+    /** Deployed contract address for contract-creation transactions; `null` otherwise. */
     contractAddress: string | null;
+    /** Unix timestamp (seconds) of the containing block, or `null` if unavailable. */
     timestamp: number | null;
 }
+/** A single EVM event log entry. */
 interface EvmLog {
+    /** Address of the contract that emitted the log. */
     address: string;
+    /** Indexed event topics; `topics[0]` is the event signature hash. */
     topics: string[];
+    /** ABI-encoded non-indexed event data (0x-prefixed hex). */
     data: string;
+    /** Block number in which the log was emitted. */
     blockNumber: number;
+    /** Hash of the transaction that emitted the log. */
     transactionHash: string;
+    /** Position of this log within the block. */
     logIndex: number;
 }
+/** Aggregated on-chain information about an EVM address. */
 interface EvmAddressInfo {
+    /** The queried address (as provided, not normalised). */
     address: string;
+    /** `true` when the address has deployed bytecode. */
     isContract: boolean;
+    /** Native token balance as a 0x-prefixed hex string (wei). */
     balance: string;
+    /** Current transaction count (nonce). */
     nonce: number;
+    /** Deployed bytecode size in bytes (`0` for EOAs). */
     codeSize: number;
+    /** Deployed bytecode (truncated to 100 bytes + ellipsis for display). `'0x'` for EOAs. */
     code: string;
+    /** Up to 50 most recent logs emitted by or received by this address. */
     recentLogs: EvmLog[];
 }
+/** EVM block header with transaction hashes (not full tx objects). */
 interface EvmBlock {
+    /** 0x-prefixed block hash. */
     hash: string;
+    /** Block number. */
     number: number;
+    /** Unix timestamp (seconds) from the block header. */
     timestamp: number;
+    /** Ordered list of transaction hashes included in the block. */
     transactions: string[];
+    /** Actual gas consumed by all transactions, as a decimal string. */
     gasUsed: string;
+    /** Block gas limit, as a decimal string. */
     gasLimit: string;
+    /** Address of the block author / fee recipient. */
     miner: string;
+    /** 0x-prefixed hash of the parent block. */
     parentHash: string;
 }
+/** Lightweight transaction summary used in address and block listing views. */
 interface EvmTxSummary {
+    /** 0x-prefixed transaction hash. */
     hash: string;
+    /** Block number in which the transaction was included. */
     blockNumber: number;
+    /** Unix timestamp (seconds) of the containing block, or `null` if unavailable. */
     timestamp: number | null;
+    /** Sender address. */
     from: string;
+    /** Recipient address, or `null` for contract-creation transactions. */
     to: string | null;
+    /** Native token value transferred, as a 0x-prefixed hex string (wei). */
     value: string;
+    /** ABI-encoded call data (0x-prefixed hex). */
     input: string;
+    /** Gas actually consumed by the transaction. */
     gasUsed: number;
+    /** Gas price in wei, as a 0x-prefixed hex string. */
     gasPrice: string;
+    /** `true` when the transaction succeeded (receipt status `0x1`). */
     status: boolean;
+    /** `true` when the transaction created a new contract (`to` is `null`). */
     isContractCreation: boolean;
+    /** Deployed contract address for contract-creation transactions; `null` otherwise. */
     contractAddress: string | null;
 }
+/** ERC-20 token metadata fetched via ABI calls (`name`, `symbol`, `decimals`, `totalSupply`). */
 interface TokenInfo {
+    /** Checksummed contract address (lowercased as returned by the node). */
     address: string;
+    /** Token name (decoded from ABI). Empty string when unavailable. */
     name: string;
+    /** Token symbol (decoded from ABI). Empty string when unavailable. */
     symbol: string;
+    /** Number of decimal places. Defaults to `18` when not readable from the contract. */
     decimals: number;
+    /** Total supply as a 0x-prefixed hex string. */
     totalSupply: string;
+    /** `true` when the contract exposes a non-zero `totalSupply`, `symbol`, and `decimals`. */
     isErc20: boolean;
 }
+/** A single ERC-20 `Transfer` event decoded from an EVM log. */
 interface TokenTransfer {
+    /** Hash of the transaction that emitted the transfer event. */
     transactionHash: string;
+    /** Block number in which the transfer was included. */
     blockNumber: number;
+    /** Sender address (decoded from `topics[1]`). */
     from: string;
+    /** Recipient address (decoded from `topics[2]`). */
     to: string;
+    /** Transferred amount as a 0x-prefixed hex string (raw `data` field). */
     value: string;
+    /** Position of the log within the block. */
     logIndex: number;
 }
 
@@ -338,25 +415,60 @@ interface TokenTransfer {
  */
 declare class EvmExplorer {
     private readonly evm;
+    /** @param evm - Underlying `EvmClient` used for all RPC calls. */
     constructor(evm: EvmClient);
+    /** Returns the `count` most recent blocks in descending order (latest first). */
     getLatestBlocks(count?: number): Promise<EvmBlock[]>;
+    /** Returns a single block by number or hash, or `null` if not found. */
     getBlock(hashOrNumber: string | number): Promise<EvmBlock | null>;
+    /** Returns all transactions in a block (with receipts), or `[]` if the block is not found. */
     getBlockTransactions(hashOrNumber: string | number): Promise<EvmTransaction[]>;
+    /** Returns a single transaction with its receipt, or `null` if not found. */
     getTransaction(hash: string): Promise<EvmTransaction | null>;
+    /**
+     * Returns lightweight summaries of all transactions sent from or to `address`
+     * within the last `maxBlocks` blocks, sorted by block number descending.
+     */
     getTransactionsByAddress(address: string, maxBlocks?: number): Promise<EvmTxSummary[]>;
+    /**
+     * Returns aggregated on-chain data for an EVM address: balance, nonce,
+     * bytecode (truncated), and up to 50 recent logs from the last 5 000 blocks.
+     */
     getAddressInfo(address: string): Promise<EvmAddressInfo>;
+    /** Returns the native token balance of `address`, formatted as a decimal string (no symbol). */
     getBalance(address: string): Promise<string>;
+    /** Returns the current transaction count (nonce) for `address`, or `0` on error. */
     getNonce(address: string): Promise<number>;
+    /** Returns `true` when `address` has non-empty deployed bytecode. */
     getIsContract(address: string): Promise<boolean>;
+    /**
+     * Fetches ERC-20 metadata for a token contract via ABI calls.
+     * Returns `null` when the address does not look like an ERC-20 token.
+     */
     getTokenInfo(address: string): Promise<TokenInfo | null>;
+    /**
+     * Returns ERC-20 `Transfer` events for `address` from the last 5 000 blocks.
+     * When `holderAddress` is provided, restricts results to transfers sent or received by that address.
+     */
     getTokenTransfers(address: string, holderAddress?: string): Promise<TokenTransfer[]>;
+    /** Returns the raw ERC-20 balance of `holderAddress` for the token at `tokenAddress` (0x-prefixed hex). */
     getTokenBalance(tokenAddress: string, holderAddress: string): Promise<string>;
+    /** Maps a raw RPC block object to the public `EvmBlock` shape. */
     private parseBlock;
+    /** Maps a raw RPC transaction + optional receipt to the public `EvmTransaction` shape. */
     private parseTx;
+    /**
+     * Fetches a raw block by number or hash. Accepts a plain integer, a decimal string,
+     * or a 0x-prefixed hash. Returns `null` on any RPC error.
+     */
     private fetchBlock;
+    /** Executes a read-only `eth_call` and returns the raw hex result, or `null` on error. */
     private ethCall;
+    /** Decodes an ABI-encoded `string` return value from a raw 0x-prefixed hex string. */
     private static decodeAbiString;
+    /** Decodes an ABI-encoded `uint256` return value to a `bigint`. */
     private static decodeAbiUint;
+    /** Converts a 0x-prefixed hex number to its decimal string representation. Returns `'0'` on parse error. */
     private static hexToDecimalStr;
 }
 
@@ -398,18 +510,12 @@ interface SpentNullifier {
     txType: 'unshield' | 'private_transfer';
     timestampMs: number | null;
 }
-/** A private transfer event stored by the indexer. */
-interface PrivateTransfer {
-    /** "{blockNumber}-{extrinsicIndex}" */
-    id: string;
+/** Temporal metadata for a private transfer. No graph data (inputs ↔ outputs) exposed. */
+interface PrivateTransferTimestamp {
     blockNumber: number;
     extrinsicIndex: number | null;
-    /** JSON-encoded array of nullifier hex strings. */
-    inputNullifiersJson: string;
-    /** JSON-encoded array of commitment hex strings. */
-    outputCommitmentsJson: string;
-    /** JSON-encoded array of leaf index numbers. */
-    leafIndicesJson: string;
+    /** Blake2-256 hash of the raw extrinsic, 0x-prefixed. Null if the extrinsic was not decoded. */
+    hash: string | null;
     timestampMs: number | null;
 }
 /** An unshield event stored by the indexer. */
@@ -418,6 +524,8 @@ interface Unshield {
     id: string;
     blockNumber: number;
     extrinsicIndex: number | null;
+    /** Blake2-256 hash of the raw extrinsic, 0x-prefixed. Null if the extrinsic was not decoded. */
+    hash: string | null;
     nullifierHex: string;
     /** Asset ID as decimal string. */
     assetId: string;
@@ -525,7 +633,24 @@ type ShieldedAddressEvent = ({
     kind: 'unshield';
 } & Unshield) | ({
     kind: 'transfer';
-} & PrivateTransfer);
+} & PrivateTransferTimestamp);
+/**
+ * Lightweight hint returned by the stealth scan endpoint.
+ * Contains only the fields required for a wallet to:
+ *   1. Compute ECDH shared secret: ephPkHex × ivsk
+ *   2. Attempt ChaCha20-Poly1305 decryption of encryptedMemo
+ * Ordered ascending by leafIndex for incremental cursor compatibility.
+ */
+interface StealthScanHint {
+    leafIndex: number;
+    commitmentHex: string;
+    /** Asset ID as decimal string (e.g. "0"). */
+    assetId: string;
+    /** Ephemeral public key (last 32 bytes of encrypted_memo), 0x-prefixed. null if memo absent. */
+    ephPkHex: string | null;
+    /** Full 168-byte encrypted memo (0x-prefixed hex). null if not present. */
+    encryptedMemo: string | null;
+}
 
 /**
  * HTTP client for the Orbinum indexer REST API.
@@ -539,6 +664,7 @@ declare class IndexerClient {
     constructor(config: IndexerClientConfig);
     private _fetchResponse;
     private get;
+    private post;
     private getOrNull;
     private buildQuery;
     /** Returns the total count of shielded commitments. */
@@ -551,6 +677,18 @@ declare class IndexerClient {
     }): Promise<PaginatedResult<ShieldedCommitment>>;
     /** Returns a single commitment by its hex string, or null if not found. */
     getCommitmentByHex(hex: string): Promise<ShieldedCommitment | null>;
+    /**
+     * Returns a paginated list of stealth scan hints ordered ascending by leafIndex.
+     * Each hint contains only the fields required for ECDH triage and decryption:
+     * leafIndex, commitmentHex, assetId, ephPkHex, encryptedMemo.
+     *
+     * Use `sinceLeafIndex` for incremental scans (cursor = last seen leafIndex + 1).
+     */
+    getScanHints(params?: {
+        page?: number;
+        limit?: number;
+        sinceLeafIndex?: number;
+    }): Promise<PaginatedResult<StealthScanHint>>;
     /** Returns a paginated list of spent nullifiers. */
     getNullifiers(params?: {
         page?: number;
@@ -558,11 +696,26 @@ declare class IndexerClient {
     }): Promise<PaginatedResult<SpentNullifier>>;
     /** Returns the spent/unspent status of a nullifier. */
     getNullifierStatus(hex: string): Promise<NullifierStatusResult>;
-    /** Returns a paginated list of private transfer events. */
-    getTransfers(params?: {
-        page?: number;
-        limit?: number;
-    }): Promise<PaginatedResult<PrivateTransfer>>;
+    /**
+     * Batch-checks which of the given nullifiers are spent.
+     * Returns only the nullifiers that exist in the spent set.
+     * Accepts up to 100 nullifiers (0x-prefixed hex).
+     */
+    getNullifiersBatch(nullifiers: string[]): Promise<SpentNullifier[]>;
+    /**
+     * Returns temporal metadata for private transfers that spent any of the given nullifiers.
+     * Only blockNumber, extrinsicIndex, timestampMs, and hash are returned — no cross-link
+     * between inputs and outputs to prevent graph reconstruction.
+     * Accepts up to 50 nullifiers (0x-prefixed hex).
+     */
+    getTransfersByNullifiers(nullifiers: string[]): Promise<PrivateTransferTimestamp[]>;
+    /**
+     * Returns temporal metadata for private transfers that produced any of the given commitments.
+     * Only blockNumber, extrinsicIndex, timestampMs, and hash are returned — no cross-link
+     * between outputs and inputs to prevent graph reconstruction.
+     * Accepts up to 50 commitments (0x-prefixed hex).
+     */
+    getTransfersByCommitments(commitments: string[]): Promise<PrivateTransferTimestamp[]>;
     /** Returns a paginated list of unshield events. */
     getUnshields(params?: {
         page?: number;
@@ -601,6 +754,14 @@ declare class IndexerClient {
         page?: number;
         limit?: number;
     }): Promise<PaginatedResult<ShieldedCommitment>>;
+    /**
+     * Returns a paginated list of unshield events where the given address is the recipient.
+     * Accepts a 0x-prefixed EVM address or an SS58 Substrate address.
+     */
+    getAddressUnshields(address: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<Unshield>>;
     /**
      * Returns a paginated list of all shielded activity (commitments, unshields,
      * private transfers) associated with the given address.
@@ -616,26 +777,35 @@ declare class IndexerClient {
     isHealthy(): Promise<boolean>;
 }
 
+/** Configuration passed to `OrbinumClient.connect()`. */
 type OrbinumClientConfig = {
-    /** WebSocket URL of the Orbinum node (e.g. "ws://localhost:9944") */
+    /** WebSocket URL of the Orbinum Substrate node (e.g. `"ws://localhost:9944"`). */
     substrateWs: string;
-    /** HTTP URL of the EVM JSON-RPC endpoint (e.g. "http://localhost:9933") */
+    /** HTTP URL of the EVM JSON-RPC endpoint (e.g. `"http://localhost:9933"`). Omit to disable EVM support. */
     evmRpc?: string;
-    /** Base URL of the Orbinum indexer REST API (e.g. "https://indexer.orbinum.io") */
+    /** Base URL of the Orbinum indexer REST API (e.g. `"https://indexer.orbinum.io"`). Omit to disable indexer support. */
     indexerUrl?: string;
-    /** Connection timeout in ms. Default: 15_000 */
+    /** Timeout for the initial WebSocket handshake in milliseconds. Default: `15_000`. */
     connectTimeoutMs?: number;
 };
+/** Result returned by extrinsic-submitting methods (shield, unshield, transfer, …). */
 type TxResult = {
+    /** 0x-prefixed hash of the submitted extrinsic. */
     txHash: string;
+    /** 0x-prefixed hash of the block that included the extrinsic. */
     blockHash: string;
+    /** Number of the block that included the extrinsic. */
     blockNumber: number;
-    /** Whether the extrinsic succeeded (no ExtrinsicFailed event). */
+    /** `true` when the extrinsic succeeded (no `ExtrinsicFailed` event emitted). */
     ok: boolean;
-    /** Dispatch error type string when ok = false. */
+    /** Dispatch error type string. Only present when `ok` is `false`. */
     error?: string;
 };
 
+/** Opciones de transacción compatibles con el UnsafeApi de PAPI (sin asset tipado). */
+type UnsafeTxOptions = TxOptions<void, Record<string, unknown>>;
+declare function toTxResult(payload: TxFinalizedPayload): TxResult;
+
 type MerkleTreeInfo = {
     root: string;
     treeSize: number;
@@ -651,14 +821,16 @@ type DecryptedMemo = {
     ownerPk: bigint;
     blinding: bigint;
     assetId: bigint;
+    /** Counterparty BabyJubJub Ax coordinate. Zero for shield/unshield notes. */
+    counterpartyPk: bigint;
 };
 type ShieldParams = {
     assetId: number;
     amount: bigint;
     /** 0x-prefixed 32-byte commitment hex */
     commitment: string;
-    /** Optional encrypted memo bytes. Auto-generates a dummy memo if absent. */
-    encryptedMemo?: Uint8Array;
+    /** Encrypted memo bytes (168 bytes). Required — notes without valid memos are irrecoverable. */
+    encryptedMemo: Uint8Array;
 };
 type UnshieldParams = {
     /** ZK proof bytes */
@@ -668,9 +840,24 @@ type UnshieldParams = {
     /** 0x-prefixed nullifier hex */
     nullifier: string;
     assetId: number;
+    /** Net amount recipient receives (planck) */
     amount: bigint;
     /** SS58 or 0x-prefixed 32-byte address */
     recipientAddress: string;
+    /** Gasless fee in planck (default 0n; note_value == amount + fee + changeValue in circuit) */
+    fee?: bigint;
+    /**
+     * 0x-prefixed 32-byte change note commitment hex.
+     * Pass the value returned by generateUnshieldProof().changeCommitment (converted to hex).
+     * Omit or use all-zero hex for total unshield (no change note).
+     */
+    changeCommitment?: string;
+    /**
+     * Encrypted memo for the change note (176 bytes).
+     * Required for partial unshield so the change note can be recovered via blockchain scan.
+     * Omit for total unshield.
+     */
+    changeEncryptedMemo?: Uint8Array;
 };
 type PrivateTransferInput = {
     /** 0x-prefixed nullifier hex */
@@ -681,7 +868,8 @@ type PrivateTransferInput = {
 type PrivateTransferOutput = {
     /** 0x-prefixed commitment hex */
     commitment: string;
-    encryptedMemo?: Uint8Array;
+    /** Encrypted memo bytes (168 bytes). Required — notes without valid memos are irrecoverable. */
+    encryptedMemo: Uint8Array;
 };
 type PrivateTransferParams = {
     inputs: PrivateTransferInput[];
@@ -690,6 +878,11 @@ type PrivateTransferParams = {
     proof: Uint8Array;
     /** 0x-prefixed merkle root hex */
     merkleRoot: string;
+    /** Asset ID being transferred (public input of the proof) */
+    assetId: number;
+    /** Gasless fee in planck (default 0n; input_sum == output_sum + fee in circuit).
+     *  The fee is paid to the block author (validator) by the pallet runtime. */
+    fee?: bigint;
 };
 /** Input params for NoteBuilder.build(). All fields except value have defaults. */
 type NoteInput = {
@@ -704,11 +897,20 @@ type NoteInput = {
     /** Secret spending key used to derive the nullifier. Default 0n. */
     spendingKey?: bigint;
     /**
-     * 32-byte recipient viewing key used to encrypt the memo (ChaCha20-Poly1305).
-     * When provided, NoteBuilder.build() will auto-generate the 104-byte encrypted memo.
+     * 32-byte LE-encoded packed BJJ viewing public key of the recipient (from their privacy address).
+     * When provided, NoteBuilder.build() will auto-generate the 168-byte ECDH-encrypted memo.
      * Omit to skip memo generation (use buildMemo() separately if needed).
      */
-    viewingKey?: Uint8Array;
+    viewingPublicKey?: Uint8Array;
+    /**
+     * BabyJubJub Ax coordinate of the recipient (from their privacy address).
+     * Required together with viewingPublicKey to enable stealth address derivation:
+     * the commitment will use stealthOwnerPk instead of ownerPk, making each
+     * transaction unlinkable even when the same privacy address is reused.
+     */
+    recipientOwnerPk?: bigint;
+    /** Counterparty BabyJubJub Ax coordinate. Zero for shield/unshield notes. Default 0n. */
+    counterpartyPk?: bigint;
 };
 /**
  * Computed ZK note (commitment + nullifier). Built entirely off-chain.
@@ -735,15 +937,12 @@ type ZkNote = {
     /** 0x-prefixed 32-byte little-endian hex nullifier. */
     nullifierHex: string;
     /**
-     * 104-byte encrypted memo (ChaCha20-Poly1305) as number[] for SCALE encoding.
-     * Always populated: uses a dummy memo when no viewingKey is provided.
+     * 168-byte encrypted memo (ChaCha20-Poly1305 ECDH) as number[] for SCALE encoding.
+     * Always populated: uses a dummy memo when no viewingPublicKey is provided.
      */
     memo: number[];
-};
-/** Result of buildAndShield: the submitted tx and the note to keep safe. */
-type ShieldResult = {
-    txResult: TxResult;
-    note: ZkNote;
+    /** Counterparty BabyJubJub Ax coordinate. Zero for shield/unshield notes. */
+    counterpartyPk: bigint;
 };
 /** Parameters for a single item in a shield_batch extrinsic. */
 type ShieldBatchItem = {
@@ -751,144 +950,542 @@ type ShieldBatchItem = {
     amount: bigint;
     /** 0x-prefixed 32-byte commitment hex */
     commitment: string;
-    /** Optional encrypted memo bytes. Auto-generates a dummy memo if absent. */
-    encryptedMemo?: Uint8Array;
+    /** Encrypted memo bytes (168 bytes). Required — notes without valid memos are irrecoverable. */
+    encryptedMemo: Uint8Array;
 };
 /** Parameters for shieldedPool.shieldBatch — deposits up to 20 notes in one extrinsic. */
 type ShieldBatchParams = {
     items: ShieldBatchItem[];
 };
-
 /**
- * High-level module for Orbinum shielded-pool operations.
+ * Parameters for shieldedPool.claimShieldedFees —
+ * claims accrued relay fees into the shielded pool.
  *
- * Transactions are built via polkadot-api's UnsafeApi (metadata-driven),
- * which means the Orbinum node must be reachable on first use.
- * Signing is delegated to a PolkadotSigner (see polkadot-api/signer).
- *
- * Parameter order matches the Orbinum runtime extrinsics exactly.
+ * The relayer must supply a ZK disclosure proof that binds the commitment to the
+ * exact amount and asset_id, preventing fee inflation attacks.
  */
-declare class ShieldedPoolModule {
-    private readonly substrate;
-    constructor(substrate: SubstrateClient);
-    /**
-     * Deposits tokens into the shielded pool.
-     * Extrinsic: shieldedPool.shield(assetId, amount, commitment, encryptedMemo)
-     */
-    shield(params: ShieldParams, signer: PolkadotSigner): Promise<TxResult>;
-    /**
-     * Build a ZkNote locally and submit shieldedPool.shield in one call.
-     *
-     * Returns both the on-chain result and the note — **save the note locally**,
-     * it cannot be recovered after the fact.
-     *
-     * @param params.value       Amount in planck (required).
-     * @param params.assetId     Asset ID — default 0 (native ORB-Privacy).
-     * @param params.ownerPk     BabyJubJub Ax (default 0n).
-     * @param params.blinding    Random blinding scalar (default BigInt(Date.now())).
-     * @param params.spendingKey Secret spending key (default 0n).
-     */
-    buildAndShield(params: {
-        value: bigint;
-        assetId?: number;
-        ownerPk?: bigint;
-        blinding?: bigint;
-        spendingKey?: bigint;
-    }, signer: PolkadotSigner): Promise<ShieldResult>;
-    /**
-     * Withdraws tokens from the shielded pool to a public address.
-     * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient)
-     */
-    unshield(params: UnshieldParams, signer: PolkadotSigner): Promise<TxResult>;
-    /**
-     * Performs a private (shielded) transfer between two notes.
-     * Extrinsic: shieldedPool.privateTransfer(inputs, outputs, proof, merkleRoot)
-     */
-    privateTransfer(params: PrivateTransferParams, signer: PolkadotSigner): Promise<TxResult>;
-    /**
-     * Deposits multiple notes into the shielded pool in a single extrinsic.
-     * Extrinsic: shieldedPool.shieldBatch(operations) — max 20 items.
-     */
-    shieldBatch(params: ShieldBatchParams, signer: PolkadotSigner): Promise<TxResult>;
-}
+type ClaimShieldedFeesParams = {
+    /** 0x-prefixed 32-byte commitment hex (Poseidon of value, assetId, ownerPk, blinding) */
+    commitment: string;
+    /** Amount to claim in planck (must match the circuit's public input) */
+    amount: bigint;
+    /** Asset ID being claimed */
+    assetId: number;
+    /** 128-byte Groth16 proof bytes */
+    proof: Uint8Array;
+    /** 76-byte public signals buffer (commitment || amount_u64_le || assetId_u32_le || owner_hash) */
+    publicSignals: Uint8Array;
+    /** Encrypted memo bytes (168 bytes). Required — notes without valid memos are irrecoverable. */
+    encryptedMemo: Uint8Array;
+};
 
 /**
- * Signature verification scheme for cross-chain links.
- * Mirrors `SignatureScheme` in pallet-account-mapping.
+ * TypeScript types for pallet-shielded-pool extrinsics and supporting structures.
+ *
+ * Conventions:
+ *   - Fixed/bounded byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Balances (u128)            → `bigint`
+ *   - AccountId                  → `string`    (SS58 or 0x-prefixed 64-char hex)
+ *   - Block numbers              → `number`
+ *   - Optional fields            → `T | null`
  */
-declare const SignatureScheme: {
-    readonly Eip191: "Eip191";
-    readonly Ed25519: "Ed25519";
+/**
+ * 32-byte SCALE-encoded value (commitment, nullifier, Merkle root, etc.).
+ * Stored as little-endian Poseidon field elements on-chain.
+ */
+type Bytes32 = number[];
+/**
+ * 176-byte encrypted memo (ChaCha20-Poly1305 ECDH).
+ * Layout: nonce(12) || ciphertext(132) || tag(16) || ephPk(32) = 176 bytes.
+ */
+type Bytes176 = number[];
+/**
+ * Disclosure public signals — exactly 256 bytes (ECDH Baby Jubjub layout):
+ *   commitment[0..32] | auditor_pk_x[32..64] | auditor_pk_y[64..96]
+ *   | epk_x[96..128] | epk_y[128..160] | enc_value[160..192]
+ *   | enc_asset_id[192..224] | enc_owner_hash[224..256]
+ */
+type DisclosurePublicSignals = number[];
+/**
+ * ECDH-encrypted note fields stored on-chain after a successful disclosure.
+ * Maps to `EncryptedDisclosureSignals` in Rust.
+ */
+type EncryptedDisclosureSignals = {
+    /** Ephemeral public key x-coordinate (Baby Jubjub), 32 bytes LE. */
+    epkX: number[];
+    /** Ephemeral public key y-coordinate (Baby Jubjub), 32 bytes LE. */
+    epkY: number[];
+    /** Encrypted note value (field element LE). 0 if not disclosed. */
+    encValue: number[];
+    /** Encrypted asset ID (field element LE). 0 if not disclosed. */
+    encAssetId: number[];
+    /** Encrypted Poseidon(owner_pubkey) (field element LE). 0 if not disclosed. */
+    encOwnerHash: number[];
 };
-type SignatureScheme = (typeof SignatureScheme)[keyof typeof SignatureScheme];
-/** A verified public link to an external chain wallet. */
-type ChainLink = {
-    chainId: number;
-    address: string;
+/**
+ * Bitmap of which note fields the auditor requires to be disclosed.
+ * Maps to `DisclosureFieldMask` in Rust.
+ */
+type DisclosureFieldMask = {
+    /** Must disclose the note value (amount in planck). */
+    value: boolean;
+    /** Must disclose the asset ID. */
+    assetId: boolean;
+    /** Must disclose Poseidon(owner_pubkey). */
+    owner: boolean;
 };
-/** A private link: only the Poseidon commitment is stored on-chain. */
-type PrivateLink = {
-    chainId: number;
-    commitment: string;
+/**
+ * A single auditor entry in an audit policy.
+ * Maps to `Auditor<AccountId>` in Rust.
+ */
+type Auditor = {
+    /** SS58 or 0x-prefixed AccountId of the authorized auditor. */
+    account: string;
 };
-/** Public profile metadata set by the account owner. */
-type AccountMetadata = {
-    displayName: string | null;
-    bio: string | null;
-    avatar: string | null;
+/**
+ * A condition that must be satisfied before disclosure is permitted.
+ * Maps to `DisclosureCondition` in Rust. Max 10 conditions per policy.
+ * Evaluation is OR — a single satisfied condition is enough.
+ */
+type DisclosureCondition = {
+    type: 'Always';
+} | {
+    type: 'TimeDelay';
+    afterBlock: number;
+} | {
+    type: 'AmountThreshold';
+    minAmount: bigint;
 };
-/** Identity info by alias: owner, optional EVM address, link count. */
-type AliasInfo = {
-    /** 0x-prefixed 32-byte AccountId32 hex. */
-    owner: string;
-    /** Normalized EVM address (0x + 40 hex chars), or null. */
-    evmAddress: string | null;
-    chainLinksCount: number;
+/**
+ * A single entry in a batch disclosure proof submission.
+ * Maps to `BatchDisclosureSubmission<AccountId>` in Rust.
+ */
+type BatchDisclosureSubmission = {
+    /** 32-byte commitment (LE). */
+    commitment: Bytes32;
+    /** Groth16 proof bytes — max 256 bytes. */
+    proof: number[];
+    /** 76-byte public signals: commitment(32) | value(8) | asset_id(4) | owner_hash(32). */
+    publicSignals: DisclosurePublicSignals;
+    /** Optional auditor AccountId. Null = voluntary disclosure. */
+    auditor: string | null;
 };
 /**
- * Full identity for an alias: owner, EVM address, all public chain links, metadata.
- * Returned by `accountMapping_getFullIdentity` (alias-based lookup).
+ * A single shield operation for use in `shield_batch`.
  */
-type AliasFullIdentity = {
-    owner: string;
-    evmAddress: string | null;
-    chainLinks: ChainLink[];
-    metadata: AccountMetadata | null;
+type ShieldOperation = {
+    assetId: number;
+    amount: bigint;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo bytes — exactly 104 bytes. */
+    encryptedMemo: number[];
 };
-/** Sale listing info for an alias on the marketplace. */
-type ListingInfo = {
-    price: bigint;
-    /** True if sale is private (whitelist-only). */
-    private: boolean;
-    whitelistCount: number;
+/**
+ * Call index 0 — `shield` (Signed origin)
+ * Deposits a public token amount into the shielded pool.
+ */
+type ShieldArgs = {
+    assetId: number;
+    amount: bigint;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo — exactly 104 bytes. */
+    encryptedMemo: number[];
 };
-/** An alias actively listed for sale with its full info. */
-type AccountListing = {
-    alias: string;
-    listing: ListingInfo;
+/**
+ * Call index 12 — `shield_batch` (Signed origin)
+ * Deposits multiple notes in a single extrinsic — max 20 operations.
+ */
+type ShieldBatchArgs = {
+    operations: ShieldOperation[];
 };
-/** A supported chain and its signature verification scheme. */
-type SupportedChain = {
-    chainId: number;
-    scheme: SignatureScheme;
+/** Input note consumed by a private transfer (SCALE wire format). */
+type RawTransferInput = {
+    /** 32-byte Poseidon nullifier (LE). */
+    nullifier: Bytes32;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
 };
-/** Parameters for adding a verified public chain link. */
-type AddChainLinkParams = {
-    /** External chain ID. Use SLIP0044_NAMESPACE | coinType for SLIP-0044 chains. */
-    chainId: number;
-    /** The external address bytes (e.g. 20 bytes for EVM, 32 for Solana). */
-    address: Uint8Array;
-    /** Signature over the caller's AccountId32 (64 bytes for Ed25519, 65 for EIP-191). */
-    signature: Uint8Array;
+/** Output note created by a private transfer (SCALE wire format). */
+type RawTransferOutput = {
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo — exactly 104 bytes. */
+    memo: number[];
 };
-/** Parameters for updating public profile metadata. */
-type SetMetadataParams = {
-    displayName?: string | null;
-    bio?: string | null;
-    avatar?: string | null;
+/**
+ * Call index 1 — `private_transfer` (Unsigned/gasless origin)
+ * Transfers value between notes without revealing sender, recipient or amount.
+ * Fee is embedded in the ZK proof: input_sum == output_sum + fee.
+ * The fee is paid to the block author (validator) by the pallet runtime.
+ */
+type PrivateTransferArgs = {
+    /** Groth16 proof bytes — max 512 bytes. */
+    proof: number[];
+    /** 32-byte Merkle root (LE). */
+    merkleRoot: Bytes32;
+    nullifiers: RawTransferInput[];
+    outputs: RawTransferOutput[];
+    encryptedMemos: number[][];
+    /** Asset ID being transferred (public input of the proof). */
+    assetId: number;
+    /** Gasless fee in planck. Paid to the block author (validator). */
+    fee: bigint;
 };
-/** Parameters for listing an alias on the marketplace. */
-type PutOnSaleParams = {
+/**
+ * Call index 2 — `unshield` (Unsigned/gasless origin)
+ * Withdraws a note from the pool to a public account.
+ * Fee is embedded in the ZK proof: note_value == amount + fee + changeValue.
+ */
+type UnshieldArgs = {
+    /** Groth16 proof bytes — max 512 bytes. */
+    proof: number[];
+    /** 32-byte Merkle root (LE). */
+    merkleRoot: Bytes32;
+    /** 32-byte nullifier of the spent note (LE). */
+    nullifier: Bytes32;
+    assetId: number;
+    /** Net amount recipient receives (planck). */
+    amount: bigint;
+    /** SS58 or 0x-prefixed AccountId of the recipient. */
+    recipient: string;
+    /** Gasless fee in planck. */
+    fee: bigint;
+    /**
+     * 32-byte change note commitment (LE). All zeros for total unshield.
+     * Must equal NoteCommitment(changeValue, assetId, changeOwnerPk, changeBlinding)
+     * when changeValue > 0 — enforced by the ZK circuit.
+     */
+    changeCommitment: Bytes32;
+    /**
+     * Encrypted memo for the change note (176 bytes, empty for total unshield).
+     * Enables note recovery via blockchain scan for partial unshield.
+     */
+    changeEncryptedMemo?: Bytes176;
+};
+/**
+ * Call index 4 — `set_audit_policy` (Signed origin)
+ * Registers or replaces the caller's audit policy for selective disclosure.
+ */
+type SetAuditPolicyArgs = {
+    /** Up to 10 authorized auditors. */
+    auditors: Auditor[];
+    /** Up to 10 disclosure conditions. */
+    conditions: DisclosureCondition[];
+    /** Minimum blocks between disclosures to the same auditor. Null = no limit. */
+    maxFrequency: number | null;
+    /** Block after which the policy expires. Null = no expiry. */
+    validUntil: number | null;
+};
+/**
+ * Call index 5 — `request_disclosure` (Signed origin)
+ * Auditor requests selective disclosure from a target account for a specific commitment.
+ */
+type RequestDisclosureArgs = {
+    /** AccountId of the disclosure target. */
+    target: string;
+    /** 32-byte commitment the auditor wants disclosed (LE). */
+    commitment: number[];
+    /** Which note fields must be revealed. */
+    requiredFields: DisclosureFieldMask;
+    /** Human-readable request reason — max 256 bytes UTF-8. */
+    reason: string;
+    /** Auditor's Baby Jubjub public key x-coordinate (32 bytes LE). */
+    auditorBjjPkX: number[];
+    /** Auditor's Baby Jubjub public key y-coordinate (32 bytes LE). */
+    auditorBjjPkY: number[];
+};
+/**
+ * Call index 6 — `disclose` (Signed origin)
+ * Submit a Groth16 disclosure proof for a commitment.
+ */
+type DiscloseArgs = {
+    /** 32-byte note commitment to disclose (LE). */
+    commitment: Bytes32;
+    /** Groth16 proof bytes — max 128 bytes. */
+    proofBytes: number[];
+    /**
+     * 256-byte public signals (ECDH Baby Jubjub layout):
+     *   commitment[0..32] | auditor_pk_x[32..64] | auditor_pk_y[64..96]
+     *   | epk_x[96..128] | epk_y[128..160] | enc_value[160..192]
+     *   | enc_asset_id[192..224] | enc_owner_hash[224..256]
+     * Use `buildDisclosurePublicSignals()` to construct this.
+     */
+    publicSignals: DisclosurePublicSignals;
+    /** Auditor AccountId — required (must match the DisclosureRequest). */
+    auditor: string;
+};
+/**
+ * Call index 7 — `reject_disclosure` (Signed origin)
+ * Disclosure target rejects a pending request from an auditor for a specific commitment.
+ */
+type RejectDisclosureArgs = {
+    /** AccountId of the auditor whose request is rejected. */
+    auditor: string;
+    /** 32-byte commitment of the request being rejected (LE). */
+    commitment: number[];
+    /** Rejection reason — max 256 bytes UTF-8. */
+    reason: string;
+};
+/**
+ * Call index 13 — `batch_submit_disclosure_proofs` (Signed origin)
+ * Submit up to 10 disclosure proofs in one extrinsic.
+ */
+type BatchSubmitDisclosureProofsArgs = {
+    submissions: BatchDisclosureSubmission[];
+};
+/**
+ * Call index 9 — `register_asset` (Root origin)
+ * Registers a new asset in the shielded pool registry.
+ */
+type RegisterAssetArgs = {
+    /** Asset name — max 64 bytes UTF-8. */
+    name: string;
+    /** Asset ticker symbol, e.g. "USDT" — max 16 bytes UTF-8. */
+    symbol: string;
+    /** Token decimal precision (e.g. 18 for ORB, 6 for USDT). */
+    decimals: number;
+    /** 20-byte EVM contract address for ERC-20 assets. Null = native asset. */
+    contractAddress: number[] | null;
+};
+/**
+ * Call index 10 — `verify_asset` (Root origin)
+ * Marks a registered asset as verified, enabling shielding.
+ */
+type VerifyAssetArgs = {
+    assetId: number;
+};
+/**
+ * Call index 11 — `unverify_asset` (Root origin)
+ * Removes the verified status from an asset, disabling new shield operations.
+ */
+type UnverifyAssetArgs = {
+    assetId: number;
+};
+/**
+ * Call index 14 — `prune_expired_request` (Signed origin)
+ * Cleans up a disclosure request that has passed its expiration block.
+ */
+type PruneExpiredRequestArgs = {
+    /** AccountId of the disclosure target. */
+    target: string;
+    /** AccountId of the auditor. */
+    auditor: string;
+    /** 32-byte commitment of the expired request (LE). */
+    commitment: number[];
+};
+/**
+ * Call index 15 — `revoke_disclosure_record` (Signed origin)
+ * Allows the note owner to revoke a previously submitted disclosure record.
+ */
+type RevokeDisclosureRecordArgs = {
+    /** 32-byte commitment whose disclosure record should be revoked (LE). */
+    commitment: Bytes32;
+};
+/** All pallet-shielded-pool calls as a discriminated union. */
+type ShieldedPoolCall = {
+    type: 'shield';
+    args: ShieldArgs;
+} | {
+    type: 'shieldBatch';
+    args: ShieldBatchArgs;
+} | {
+    type: 'privateTransfer';
+    args: PrivateTransferArgs;
+} | {
+    type: 'unshield';
+    args: UnshieldArgs;
+} | {
+    type: 'setAuditPolicy';
+    args: SetAuditPolicyArgs;
+} | {
+    type: 'requestDisclosure';
+    args: RequestDisclosureArgs;
+} | {
+    type: 'disclose';
+    args: DiscloseArgs;
+} | {
+    type: 'rejectDisclosure';
+    args: RejectDisclosureArgs;
+} | {
+    type: 'batchSubmitDisclosureProofs';
+    args: BatchSubmitDisclosureProofsArgs;
+} | {
+    type: 'registerAsset';
+    args: RegisterAssetArgs;
+} | {
+    type: 'verifyAsset';
+    args: VerifyAssetArgs;
+} | {
+    type: 'unverifyAsset';
+    args: UnverifyAssetArgs;
+} | {
+    type: 'pruneExpiredRequest';
+    args: PruneExpiredRequestArgs;
+} | {
+    type: 'revokeDisclosureRecord';
+    args: RevokeDisclosureRecordArgs;
+};
+
+/**
+ * High-level module for Orbinum shielded-pool operations.
+ *
+ * Transactions are built via polkadot-api's UnsafeApi (metadata-driven),
+ * which means the Orbinum node must be reachable on first use.
+ * Signing is delegated to a PolkadotSigner (see polkadot-api/signer).
+ *
+ * Parameter order matches the Orbinum runtime extrinsics exactly.
+ */
+declare class ShieldedPoolModule {
+    private readonly substrate;
+    constructor(substrate: SubstrateClient);
+    /**
+     * Deposits tokens into the shielded pool.
+     * Extrinsic: shieldedPool.shield(assetId, amount, commitment, encryptedMemo)
+     *
+     * Shield is always a signed (public) transaction — the caller's address
+     * appears on-chain as the depositor.
+     */
+    shield(params: ShieldParams, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Withdraws tokens from the shielded pool to a public address.
+     * Submits as an UNSIGNED (gasless) transaction — fee is embedded in the ZK proof.
+     * Pass a `signer` to fall back to signed submission (e.g. for testing).
+     * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient, fee)
+     */
+    unshield(params: UnshieldParams, signer?: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Performs a private (shielded) transfer between two notes.
+     * Submits as an UNSIGNED (gasless) transaction — fee is embedded in the ZK proof.
+     * Pass a `signer` to fall back to signed submission (e.g. for testing).
+     * Extrinsic: shieldedPool.privateTransfer(proof, merkleRoot, nullifiers, commitments, memos, assetId, fee)
+     */
+    privateTransfer(params: PrivateTransferParams, signer?: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Deposits multiple notes into the shielded pool in a single extrinsic.
+     * Extrinsic: shieldedPool.shieldBatch(operations) — max 20 items.
+     */
+    shieldBatch(params: ShieldBatchParams, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Claims accrued relay fees into the shielded pool.
+     * This is a SIGNED transaction — the relayer must sign it with their wallet.
+     * Before calling this, generate a ZK disclosure proof with generateFeeClaimProof().
+     *
+     * Extrinsic: shieldedPool.claim_shielded_fees(commitment, amount, asset_id, memo, proof, public_signals)
+     */
+    claimShieldedFees(params: ClaimShieldedFeesParams, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Requests a selective disclosure from a target account for a specific commitment.
+     * The auditor's Baby Jubjub public key is included so the note owner knows
+     * which key to encrypt to when generating the proof.
+     * Extrinsic: shieldedPool.request_disclosure(target, commitment, required_fields,
+     *                                             reason, auditor_bjj_pk_x, auditor_bjj_pk_y)
+     */
+    requestDisclosure(params: RequestDisclosureArgs, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Submits a Groth16 ZK disclosure proof for a note commitment.
+     * The proof reveals the selected fields (value, asset_id, owner_hash) on-chain.
+     * Use generateDisclosureProof() + buildDisclosurePublicSignals() before calling this.
+     * Extrinsic: shieldedPool.disclose(commitment, proof_bytes, public_signals, auditor)
+     */
+    disclose(params: DiscloseArgs, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Rejects a pending disclosure request from an auditor for a specific commitment.
+     * Extrinsic: shieldedPool.reject_disclosure(auditor, commitment, reason)
+     */
+    rejectDisclosure(params: RejectDisclosureArgs, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Cleans up a disclosure request that has passed its expiration block.
+     * Permissionless — any account can prune expired requests.
+     * Extrinsic: shieldedPool.prune_expired_request(target, auditor, commitment)
+     */
+    pruneExpiredRequest(params: PruneExpiredRequestArgs, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+    /**
+     * Revokes a previously submitted voluntary disclosure record.
+     * Only applies to self-disclosures (auditor = None). Auditor-requested records are permanent.
+     * Extrinsic: shieldedPool.revoke_disclosure_record(commitment)
+     */
+    revokeDisclosureRecord(params: RevokeDisclosureRecordArgs, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
+}
+
+/**
+ * Signature verification scheme for cross-chain links.
+ * Mirrors `SignatureScheme` in pallet-account-mapping.
+ */
+declare const SignatureScheme: {
+    readonly Eip191: "Eip191";
+    readonly Ed25519: "Ed25519";
+};
+type SignatureScheme = (typeof SignatureScheme)[keyof typeof SignatureScheme];
+/** A verified public link to an external chain wallet. */
+type ChainLink = {
+    chainId: number;
+    address: string;
+};
+/** A private link: only the Poseidon commitment is stored on-chain. */
+type PrivateLink = {
+    chainId: number;
+    commitment: string;
+};
+/** Public profile metadata set by the account owner. */
+type AccountMetadata = {
+    displayName: string | null;
+    bio: string | null;
+    avatar: string | null;
+};
+/** Identity info by alias: owner, optional EVM address, link count. */
+type AliasInfo = {
+    /** 0x-prefixed 32-byte AccountId32 hex. */
+    owner: string;
+    /** Normalized EVM address (0x + 40 hex chars), or null. */
+    evmAddress: string | null;
+    chainLinksCount: number;
+};
+/**
+ * Full identity for an alias: owner, EVM address, all public chain links, metadata.
+ * Returned by `accountMapping_getFullIdentity` (alias-based lookup).
+ */
+type AliasFullIdentity = {
+    owner: string;
+    evmAddress: string | null;
+    chainLinks: ChainLink[];
+    metadata: AccountMetadata | null;
+};
+/** Sale listing info for an alias on the marketplace. */
+type ListingInfo = {
+    price: bigint;
+    /** True if sale is private (whitelist-only). */
+    private: boolean;
+    whitelistCount: number;
+};
+/** An alias actively listed for sale with its full info. */
+type AccountListing = {
+    alias: string;
+    listing: ListingInfo;
+};
+/** A supported chain and its signature verification scheme. */
+type SupportedChain = {
+    chainId: number;
+    scheme: SignatureScheme;
+};
+/** Parameters for adding a verified public chain link. */
+type AddChainLinkParams = {
+    /** External chain ID. Use SLIP0044_NAMESPACE | coinType for SLIP-0044 chains. */
+    chainId: number;
+    /** The external address bytes (e.g. 20 bytes for EVM, 32 for Solana). */
+    address: Uint8Array;
+    /** Signature over the caller's AccountId32 (64 bytes for Ed25519, 65 for EIP-191). */
+    signature: Uint8Array;
+};
+/** Parameters for updating public profile metadata. */
+type SetMetadataParams = {
+    displayName?: string | null;
+    bio?: string | null;
+    avatar?: string | null;
+};
+/** Parameters for listing an alias on the marketplace. */
+type PutOnSaleParams = {
     price: bigint;
     /** If true the sale becomes OTC (whitelist required). */
     isPrivate: boolean;
@@ -1064,7 +1661,6 @@ type RpcV2MerkleProof = {
     leafIndex: number;
     treeDepth: number;
 };
-/** Prueba Merkle enriquecida con el `root` actual del árbol. Devuelta por `getMerkleProofByCommitment`. */
 type PrivacyMerkleProof = RpcV2MerkleProof & {
     root: string;
 };
@@ -1074,13 +1670,12 @@ type RpcV2NullifierStatus = {
 };
 type RpcV2PoolAssetBalance = {
     assetId: number;
-    /** Balance serializado como string decimal para preservar `u128`. */
     balance: string;
 };
 type RpcV2PoolStats = {
     merkleRoot: string;
     commitmentCount: number;
-    /** Total pool balance serializado como string decimal para preservar `u128`. */
+    nullifierCount: number;
     totalBalance: string;
     assetBalances: RpcV2PoolAssetBalance[];
     treeDepth: number;
@@ -1098,7 +1693,11 @@ declare class PrivacyModule {
     getMerkleProof(leafIndex: number | string): Promise<RpcV2MerkleProof>;
     /**
      * Returns the Merkle inclusion proof for a given commitment hex,
-     * bundled with the current Merkle root.
+     * bundled with the Merkle root.
+     *
+     * Uses `privacy_getMerkleProofByCommitment` which resolves root and proof
+     * under the **same block hash**, guaranteeing that the returned path is
+     * consistent with the returned root.
      */
     getMerkleProofByCommitment(commitmentHex: string): Promise<PrivacyMerkleProof>;
     /** Returns the spend status of a nullifier. */
@@ -1154,6 +1753,43 @@ declare class ZkVerifierModule {
     getCircuitVersionInfo(circuitId: number): Promise<ZkVerifierCircuitVersionInfo | null>;
 }
 
+/**
+ * Status info for a registered relayer account.
+ */
+interface RelayerInfo {
+    /** Whether the account is a registered relayer. */
+    isRelayer: boolean;
+    /** The registered EVM address (0x-prefixed), or null if not registered. */
+    evmAddress: string | null;
+}
+/**
+ * Typed client for `relayer_*` JSON-RPC endpoints.
+ *
+ * Exposes read-only queries for relayer registry and pending fee data.
+ */
+declare class RelayerStatusModule {
+    private readonly substrate;
+    constructor(substrate: SubstrateClient);
+    /**
+     * Returns true if the given SS58 address is a registered relayer.
+     */
+    isRelayer(ss58Address: string): Promise<boolean>;
+    /**
+     * Returns the pending fees (in planck) for the given account and asset.
+     * The node returns the value as a decimal string to avoid u128 overflow.
+     */
+    pendingFees(ss58Address: string, assetId: number): Promise<bigint>;
+    /**
+     * Returns the registered EVM address (0x-prefixed) for the given account,
+     * or null if the account is not a registered relayer.
+     */
+    registeredEvmAddress(ss58Address: string): Promise<string | null>;
+    /**
+     * Convenience method: returns relayer registry info for an account.
+     */
+    getRelayerInfo(ss58Address: string): Promise<RelayerInfo>;
+}
+
 /** EVM transaction request passed to an `EvmSigner` callback. */
 type EvmTxRequest = {
     to: string;
@@ -1175,27 +1811,70 @@ interface KnownPrecompileInfo {
     /** Map from 4-byte hex selector (no 0x prefix) to function signature. */
     functions: Record<string, string>;
 }
-
 /**
- * Converts a Uint8Array or number[] to a 0x-prefixed lowercase hex string.
- */
-declare function toHex(bytes: Uint8Array | number[]): string;
-/**
- * Decodes a hex string (with or without 0x prefix) to Uint8Array.
+ * Parameters for `requestDisclosure`.
+ *
+ * The EVM caller of this transaction is treated as the **auditor** on-chain.
  */
-declare function fromHex(hex: string): Uint8Array;
+type RequestDisclosureParams = {
+    /** AccountId32 of the note owner (target), as a 0x-prefixed 64-hex-char string. */
+    target: string;
+    /** Note commitment, as a 0x-prefixed 64-hex-char string. */
+    commitment: string;
+    /** Whether to request disclosure of the note value. */
+    disclosedValue: boolean;
+    /** Whether to request disclosure of the asset ID. */
+    disclosedAssetId: boolean;
+    /** Whether to request disclosure of the note owner hash. */
+    disclosedOwner: boolean;
+    /** Human-readable reason (UTF-8, max 256 bytes). */
+    reason: string;
+    /** Auditor's Baby Jubjub public key X coordinate (32 bytes). */
+    auditorBjjPkX: Uint8Array;
+    /** Auditor's Baby Jubjub public key Y coordinate (32 bytes). */
+    auditorBjjPkY: Uint8Array;
+};
 /**
- * Ensures a hex string has the 0x prefix.
+ * Parameters for `disclose`.
+ *
+ * The EVM caller of this transaction is treated as the **note owner** on-chain.
  */
-declare function ensureHexPrefix(hex: string): string;
+type DiscloseParams = {
+    /** Note commitment, as a 0x-prefixed 64-hex-char string. */
+    commitment: string;
+    /** 128-byte serialised Groth16 proof. */
+    proofBytes: Uint8Array;
+    /** 256-byte ECDH-encrypted disclosure signals from the circuit. */
+    publicSignals: Uint8Array;
+    /** AccountId32 of the auditor, as a 0x-prefixed 64-hex-char string. */
+    auditor: string;
+};
 /**
- * Converts a 0x-prefixed hex string (as returned by JSON-RPC) to a number.
+ * Parameters for `rejectDisclosure`.
+ *
+ * The EVM caller of this transaction is treated as the **target** (note owner) on-chain.
  */
-declare function hexToNumber(hex: string): number;
+type RejectDisclosureParams = {
+    /** AccountId32 of the auditor who sent the request, as a 0x-prefixed 64-hex-char string. */
+    auditor: string;
+    /** Note commitment, as a 0x-prefixed 64-hex-char string. */
+    commitment: string;
+    /** Human-readable rejection reason (UTF-8, max 256 bytes). */
+    reason: string;
+};
 /**
- * Converts a 0x-prefixed hex string (as returned by JSON-RPC) to a bigint.
+ * Parameters for `pruneExpiredRequest`.
+ *
+ * Permissionless: any EVM caller can prune an expired disclosure request.
  */
-declare function hexToBigint(hex: string): bigint;
+type PruneExpiredRequestParams = {
+    /** AccountId32 of the note owner, as a 0x-prefixed 64-hex-char string. */
+    target: string;
+    /** AccountId32 of the auditor, as a 0x-prefixed 64-hex-char string. */
+    auditor: string;
+    /** Note commitment, as a 0x-prefixed 64-hex-char string. */
+    commitment: string;
+};
 
 /**
  * Bindings for the `ShieldedPoolPrecompile` at address `0x...0801`.
@@ -1218,22 +1897,27 @@ declare class ShieldedPoolPrecompile {
     private readonly addr;
     constructor(evm: EvmClient);
     /**
-     * Returns the ABI-encoded calldata for `shield(uint32, uint256, bytes32, bytes)`.
-     * Useful when you need to inspect or batch the calldata before sending.
+     * Returns the ABI-encoded calldata for `shield(uint32, bytes32, bytes)`.
+     * The token amount must be sent as `msg.value` (the `value` field of the EVM
+     * transaction) — this is what MetaMask and other wallets display to the user.
      */
     buildShieldCalldata(params: ShieldParams): string;
     /**
-     * Deposits tokens into the shielded pool from an EVM transaction.
+     * Deposits tokens into the shielded pool from a payable EVM transaction.
      *
-     * The EVM caller's address is deterministically mapped to a Substrate
-     * AccountId32 (`H160 ++ [0x00; 12]`). The pool deducts from that account.
+     * The token amount is sent as `msg.value` so EVM wallets (MetaMask, etc.) display
+     * the correct amount on the confirmation screen. The precompile dispatches
+     * `shieldedPool.shield` with its own address as origin, so the funds flow:
+     *   caller → precompile (via msg.value, handled by EVM)
+     *   precompile → pool (via pallet transfer)
+     * This avoids double-deduction while keeping the displayed amount accurate.
      *
      * Extrinsic: `shieldedPool.shield(assetId, amount, commitment, encryptedMemo)`
      */
     shield(params: ShieldParams, signer: EvmSigner): Promise<string>;
     /**
      * Returns the ABI-encoded calldata for
-     * `privateTransfer(bytes, bytes32, bytes32[], bytes32[], bytes[])`.
+     * `privateTransfer(bytes, bytes32, bytes32[], bytes32[], bytes[], uint32, uint256)`.
      */
     buildPrivateTransferCalldata(params: PrivateTransferParams): string;
     /**
@@ -1260,20 +1944,82 @@ declare class ShieldedPoolPrecompile {
      *
      * Extrinsic: `shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient)`
      */
-    unshield(params: UnshieldParams, signer: EvmSigner): Promise<string>;
+    unshield(params: UnshieldParams, signer: EvmSigner): Promise<string>;
+    /**
+     * Estimates the EVM gas for a `shield` call without submitting.
+     * Requires `from` to be set to the actual sender address.
+     */
+    estimateShieldGas(params: ShieldParams, from: string): Promise<bigint>;
+    /**
+     * Estimates the EVM gas for a `privateTransfer` call.
+     */
+    estimatePrivateTransferGas(params: PrivateTransferParams, from: string): Promise<bigint>;
+    /**
+     * Estimates the EVM gas for an `unshield` call.
+     */
+    estimateUnshieldGas(params: UnshieldParams, from: string): Promise<bigint>;
+    /**
+     * Returns the ABI-encoded calldata for
+     * `requestDisclosure(bytes32,bytes32,bool,bool,bool,bytes,bytes32,bytes32)`.
+     *
+     * The **EVM caller** of the resulting transaction is treated as the **auditor**
+     * on-chain. No explicit auditor argument is needed.
+     */
+    buildRequestDisclosureCalldata(params: RequestDisclosureParams): string;
+    /**
+     * Requests selective disclosure of a specific commitment.
+     *
+     * The EVM caller is recorded as the auditor on-chain. The note owner can
+     * respond with `disclose()` or reject with `rejectDisclosure()`.
+     *
+     * Extrinsic: `shieldedPool.requestDisclosure(target, commitment, requiredFields, reason, bjjPkX, bjjPkY)`
+     */
+    requestDisclosure(params: RequestDisclosureParams, signer: EvmSigner): Promise<string>;
+    /**
+     * Returns the ABI-encoded calldata for `disclose(bytes32,bytes,bytes,bytes32)`.
+     *
+     * The **EVM caller** is treated as the **note owner** on-chain.
+     * `params.proofBytes` must be exactly 128 bytes; `params.publicSignals` exactly 256 bytes.
+     */
+    buildDiscloseCalldata(params: DiscloseParams): string;
+    /**
+     * Submits a selective disclosure proof for a commitment.
+     *
+     * The EVM caller is treated as the note owner on-chain. The Groth16 proof is
+     * verified by the runtime; on success the encrypted signals are stored for
+     * the auditor to decrypt off-chain.
+     *
+     * Extrinsic: `shieldedPool.disclose(commitment, proofBytes, publicSignals, auditor)`
+     */
+    disclose(params: DiscloseParams, signer: EvmSigner): Promise<string>;
+    /**
+     * Returns the ABI-encoded calldata for `rejectDisclosure(bytes32,bytes32,bytes)`.
+     *
+     * The **EVM caller** is treated as the **target** (note owner) on-chain.
+     */
+    buildRejectDisclosureCalldata(params: RejectDisclosureParams): string;
     /**
-     * Estimates the EVM gas for a `shield` call without submitting.
-     * Requires `from` to be set to the actual sender address.
+     * Rejects a pending disclosure request.
+     *
+     * The EVM caller is treated as the note owner (target) on-chain.
+     *
+     * Extrinsic: `shieldedPool.rejectDisclosure(auditor, commitment, reason)`
      */
-    estimateShieldGas(params: ShieldParams, from: string): Promise<bigint>;
+    rejectDisclosure(params: RejectDisclosureParams, signer: EvmSigner): Promise<string>;
     /**
-     * Estimates the EVM gas for a `privateTransfer` call.
+     * Returns the ABI-encoded calldata for `pruneExpiredRequest(bytes32,bytes32,bytes32)`.
+     *
+     * Permissionless: any EVM caller can prune an expired request.
      */
-    estimatePrivateTransferGas(params: PrivateTransferParams, from: string): Promise<bigint>;
+    buildPruneExpiredRequestCalldata(params: PruneExpiredRequestParams): string;
     /**
-     * Estimates the EVM gas for an `unshield` call.
+     * Removes an expired disclosure request from storage.
+     *
+     * Permissionless: any EVM account can call this once `expires_at` has passed.
+     *
+     * Extrinsic: `shieldedPool.pruneExpiredRequest(target, auditor, commitment)`
      */
-    estimateUnshieldGas(params: UnshieldParams, from: string): Promise<bigint>;
+    pruneExpiredRequest(params: PruneExpiredRequestParams, signer: EvmSigner): Promise<string>;
 }
 
 /**
@@ -1527,65 +2273,85 @@ declare class CryptoPrecompiles {
  * ```
  */
 declare class OrbinumClient {
-    /** Raw access to the Substrate WebSocket connection and RPC. */
+    /** Raw Substrate WebSocket connection — use for custom RPC calls or low-level access. */
     readonly substrate: SubstrateClient;
-    /** Raw access to the EVM HTTP JSON-RPC endpoint (if configured). */
+    /** Raw EVM HTTP JSON-RPC client. `null` when `evmRpc` is not configured. */
     readonly evm: EvmClient | null;
     /**
-     * High-level EVM block and transaction explorer (if `evmRpc` is configured).
+     * High-level EVM block and transaction explorer.
      * Provides enriched queries for blocks, transactions, addresses, and token transfers.
+     * `null` when `evmRpc` is not configured.
      */
     readonly evmExplorer: EvmExplorer | null;
     /**
-     * HTTP client for the Orbinum indexer REST API (if `indexerUrl` is configured).
+     * HTTP client for the Orbinum indexer REST API.
      * Provides paginated access to indexed blocks, extrinsics, shielded events, and nullifiers.
+     * `null` when `indexerUrl` is not configured.
      */
     readonly indexer: IndexerClient | null;
-    /** Shielded-pool operations: shield, unshield, privateTransfer, and merkle queries. */
+    /** Shielded-pool extrinsics and Merkle tree queries (`shield`, `unshield`, `privateTransfer`, …). */
     readonly shieldedPool: ShieldedPoolModule;
-    /** Account mapping: aliases, chain links, metadata, marketplace, and identity extrinsics. */
+    /** Account-mapping extrinsics: aliases, chain links, metadata, marketplace, and identity. */
     readonly accountMapping: AccountMappingModule;
-    /** Typed access to Orbinum `privacy_*` RPC endpoints. */
+    /** Typed access to `privacy_*` custom RPC endpoints. */
     readonly privacy: PrivacyModule;
-    /** Typed access to zkVerifier_* RPC endpoints. */
+    /** Typed access to `zkVerifier_*` custom RPC endpoints. */
     readonly zkVerifier: ZkVerifierModule;
+    /** Typed access to `relayer_*` RPC endpoints (registry lookup and pending fee queries). */
+    readonly relayerStatus: RelayerStatusModule;
     /**
-     * EVM precompiles: shielded pool + account mapping callable from an EVM wallet.
-     * Only available when `evmRpc` is configured. Methods throw if `evm` is null.
+     * Precompile modules for interacting with Orbinum contracts from an EVM wallet.
+     * `null` when `evmRpc` is not configured. Methods on each sub-module throw if `evm` is `null`.
      */
     readonly precompiles: {
-        /** `ShieldedPoolPrecompile` (0x0801): shield/unshield/transfer via EVM wallet. */
+        /** `ShieldedPoolPrecompile` at `0x0801`: shield / unshield / transfer via EVM wallet. */
         shieldedPool: ShieldedPoolPrecompile;
-        /** `AccountMappingPrecompile` (0x0800): identity management via EVM wallet. */
+        /** `AccountMappingPrecompile` at `0x0800`: identity management via EVM wallet. */
         accountMapping: AccountMappingPrecompile;
-        /** Cryptographic precompiles: ECRecover, Keccak-256, Curve25519. */
+        /** Built-in cryptographic precompiles: ECRecover, Keccak-256, Curve25519. */
         crypto: CryptoPrecompiles;
     } | null;
+    /** @internal Use `OrbinumClient.connect()` to obtain an instance. */
     private constructor();
     /**
-     * Connects to an Orbinum node and returns a ready-to-use `OrbinumClient`.
-     * Throws if the Substrate node is unreachable within `connectTimeoutMs`.
+     * Creates and connects an `OrbinumClient` from the given configuration.
+     *
+     * Establishes the Substrate WebSocket connection and, if configured, instantiates
+     * the EVM and indexer clients. Throws if the node is unreachable within `connectTimeoutMs`.
      */
     static connect(config: OrbinumClientConfig): Promise<OrbinumClient>;
-    /** Closes the WebSocket connection to the Substrate node. */
+    /** Closes the underlying Substrate WebSocket connection and releases all resources. */
     destroy(): void;
 }
 
+/** Lifecycle state of the provider's underlying `OrbinumClient` connection. */
 type ConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+/** Payload emitted to every `StatusListener` on each status transition. */
 type StatusChangeEvent = {
+    /** The new connection status. */
     status: ConnectionStatus;
+    /** Human-readable error description. Only present on `'disconnected'` transitions. */
     error?: string;
 };
+/** Callback invoked whenever the provider's `ConnectionStatus` changes. */
 type StatusListener = (event: StatusChangeEvent) => void;
+/** Configuration for `OrbinumClientProvider`. Extends `OrbinumClientConfig` with reconnection and heartbeat tuning. */
 interface ClientProviderConfig {
+    /** WebSocket URL of the Orbinum Substrate node (e.g. `"ws://localhost:9944"`). */
     substrateWs: string;
+    /** HTTP URL of the EVM JSON-RPC endpoint (e.g. `"http://localhost:9933"`). Omit to disable EVM support. */
     evmRpc?: string;
-    /** Base URL of the Orbinum indexer REST API (e.g. "https://indexer.orbinum.io") */
+    /** Base URL of the Orbinum indexer REST API (e.g. `"https://indexer.orbinum.io"`). Omit to disable indexer support. */
     indexerUrl?: string;
+    /** Timeout for the initial WebSocket handshake in milliseconds. Default: `8_000`. */
     connectTimeoutMs?: number;
+    /** Interval between heartbeat probes in milliseconds. Default: `5_000`. */
     heartbeatIntervalMs?: number;
+    /** Maximum time to wait for a heartbeat response before treating the node as unreachable. Default: `4_000`. */
     heartbeatTimeoutMs?: number;
+    /** Initial reconnect delay in milliseconds (doubles on each failure). Default: `3_000`. */
     reconnectBaseMs?: number;
+    /** Maximum reconnect delay cap in milliseconds. Default: `30_000`. */
     reconnectMaxMs?: number;
 }
 /**
@@ -1621,24 +2387,78 @@ declare class OrbinumClientProvider {
     private _reconnectTimer;
     private _reconnectAttempt;
     private _listeners;
+    /** Creates a new provider with the given configuration. Does not connect automatically — call `connect()` to initiate. */
     constructor(config: ClientProviderConfig);
+    /** Current connection status. Reflects the last state set by the provider internals. */
     get status(): ConnectionStatus;
+    /** Updates internal status and notifies all registered listeners. Swallows listener exceptions to avoid cascading failures. */
     private setStatus;
+    /**
+     * Registers a listener that is called on every status transition.
+     * Returns an unsubscribe function — call it to stop receiving events.
+     */
     onStatusChange(listener: StatusListener): () => void;
+    /**
+     * Initiates the first connection attempt. No-op if the provider is not in `'idle'` state.
+     * Call this once after constructing the provider.
+     */
     connect(): void;
+    /**
+     * Tears down the active client and any pending reconnect timers,
+     * then resets the provider back to `'idle'` so `connect()` can be called again.
+     */
     reset(): void;
+    /** Transitions to `'connecting'`, kicks off `attemptConnect`, and schedules a reconnect if it fails. */
     private startConnectAttempt;
+    /**
+     * Performs a single connection attempt race against `connectTimeoutMs`.
+     * On success: stores the client, starts the heartbeat, and returns it.
+     * On failure: destroys any orphaned client and transitions to `'disconnected'`.
+     */
     private attemptConnect;
+    /** Starts the periodic heartbeat loop. Replaces any existing timer. */
     private startHeartbeat;
+    /** Clears the heartbeat interval timer if active. */
     private stopHeartbeat;
+    /**
+     * Sends a `system_health` RPC ping and waits up to `heartbeatTimeoutMs`.
+     * Returns `true` if the node responds in time, `false` otherwise.
+     */
     private probe;
+    /**
+     * Schedules the next connection attempt using exponential backoff
+     * (capped at `reconnectMaxMs`), then transitions to `'reconnecting'`.
+     */
     private scheduleReconnect;
+    /** Clears any pending reconnect timer without triggering a new attempt. */
     private cancelReconnect;
+    /** Stops the heartbeat, destroys the active client, and clears all in-progress promises. */
     private teardownClient;
+    /**
+     * Returns the active `OrbinumClient`, or awaits the in-progress connection attempt.
+     * Throws if the provider is `'idle'`, `'disconnected'`, or `'reconnecting'`.
+     */
     getOrbinumClient(): Promise<OrbinumClient>;
+    /**
+     * Same as `getOrbinumClient()` but returns `null` instead of throwing.
+     * Useful in contexts where a missing client is an acceptable no-op.
+     */
     tryGetOrbinumClient(): Promise<OrbinumClient | null>;
+    /**
+     * Sends a single Substrate JSON-RPC request and returns the typed result.
+     * Waits for the client to be ready before dispatching.
+     */
     rpcSend<T>(method: string, params?: unknown[]): Promise<T>;
+    /**
+     * Sends a single EVM JSON-RPC request and returns the typed result.
+     * Throws if `evmRpc` was not configured.
+     */
     evmRpc<T>(method: string, params?: unknown[]): Promise<T>;
+    /**
+     * Sends multiple EVM JSON-RPC calls as a single batch request.
+     * Returns a tuple of typed results in the same order as `calls`.
+     * Throws if `evmRpc` was not configured.
+     */
     evmRpcBatch<T extends unknown[]>(calls: Array<{
         method: string;
         params?: unknown[];
@@ -1655,31 +2475,44 @@ declare class OrbinumClientProvider {
  *   nullifier  = Poseidon(commitment, spendingKey)
  *
  * Memo scheme (EncryptedMemo — native TypeScript, no WASM):
- *   ChaCha20-Poly1305 with key = SHA256(recipientVk || commitment || domain)
- *   Result: nonce(12) || ciphertext(76 + 16 MAC) = 104 bytes
+ *   ChaCha20-Poly1305 with ECDH ephemeral key — SHA256(sharedSecret || commitment || domain)
+ *   Result: nonce(12) || ciphertext(108 + 16 MAC) || ephPk(32) = 168 bytes
+ *
+ * Stealth scheme (when viewingPublicKey + recipientOwnerPk are both provided):
+ *   ephSk is generated once and shared between the ECDH memo and the stealth Pk derivation.
+ *   The commitment uses stealthOwnerPk instead of the recipient's global ownerPk, making
+ *   each transfer unlinkable even when the same privacy address is reused.
+ *   stealthOwnerPk = stealthScalar × Base8 + ownerPkPoint
+ *   stealthScalar  = HKDF(sharedSecret, salt=ownerPk_LE, info="orbinum-stealth-v1") % suborder
  */
 declare class NoteBuilder {
     /**
      * Build a ZkNote from the given inputs.
      *
-     * @param input.value       Amount in planck (required).
-     * @param input.assetId     Asset ID — default 0n (native ORB-Privacy).
-     * @param input.ownerPk     BabyJubJub Ax — default 0n.
-     * @param input.blinding    Random scalar — defaults to BigInt(Date.now()).
-     * @param input.spendingKey Secret key for nullifier — default 0n.
+     * @param input.value            Amount in planck (required).
+     * @param input.assetId          Asset ID — default 0n (native ORB-Privacy).
+     * @param input.ownerPk          Sender's or recipient's global BabyJubJub Ax — default 0n.
+     * @param input.blinding         Random scalar — defaults to BigInt(Date.now()).
+     * @param input.spendingKey      Secret key for nullifier — default 0n.
+     * @param input.viewingPublicKey Recipient's 32-byte LE packed BJJ ivk. Triggers memo encryption.
+     * @param input.recipientOwnerPk Recipient's global ownerPk. Required with viewingPublicKey
+     *                               to enable stealth address derivation. Without it, the
+     *                               commitment uses ownerPk directly (no stealth).
      */
     static build(input: NoteInput): Promise<ZkNote>;
     /**
-     * Build the 104-byte encrypted memo for a note.
+     * Build the 168-byte ECDH-encrypted memo for a note.
      *
      * Pure TypeScript implementation — no WASM dependency.
-     * Uses ChaCha20-Poly1305 with SHA-256 key derivation.
+     * Uses ChaCha20-Poly1305 with ECDH key agreement (BabyJubJub ephemeral keypair).
      *
-     * @param note         The ZkNote whose fields populate the plaintext.
-     * @param recipientVk  32-byte recipient viewing key.
-     *                     Pass `new Uint8Array(32)` (default) for a public/dummy memo.
+     * @param note                    The ZkNote whose fields populate the plaintext.
+     * @param recipientIvkPacked      32-byte LE packed BJJ viewing public key of the recipient.
+     *                                Pass `new Uint8Array(32)` (default) for a public/dummy memo.
+     * @param counterpartyPk          32-byte counterparty BabyJubJub Ax.
+     *                                Pass `new Uint8Array(32)` (default) for no counterparty.
      */
-    static buildMemo(note: ZkNote, recipientVk?: Uint8Array): Uint8Array;
+    static buildMemo(note: ZkNote, recipientIvkPacked?: Uint8Array, counterpartyPk?: Uint8Array): Uint8Array;
 }
 
 /**
@@ -1687,52 +2520,91 @@ declare class NoteBuilder {
  *
  * Mirrors primitives/encrypted-memo in the node repository; no WASM required.
  *
- * Layout (104 bytes):
- *   nonce(12) || ciphertext(76 + 16 MAC) = 104
+ * Layout (176 bytes, ECDH):
+ *   nonce(12) || ciphertext+MAC(132) || ephPk_packed(32) = 176
+ *
+ * Plaintext layout (116 bytes):
+ *   value_lo(8 LE) || value_hi(8 LE) || owner_pk(32) || blinding(32) || asset_id(4 LE) || counterparty_pk(32)
  *
- * Plaintext layout (76 bytes):
- *   value(8 LE) || owner_pk(32) || blinding(32) || asset_id(4 LE)
+ * value is stored as a 128-bit LE unsigned integer (two uint64 words), supporting
+ * amounts up to ~3.4 × 10^38 planck — well above any realistic token supply.
  *
- * Key derivation:
- *   key = SHA256(viewing_key || commitment || "orbinum-note-encryption-v1")
+ * v2 key derivation (ECDH):
+ *   ephSk        = random scalar in [1, BABYJUB_SUBORDER)
+ *   ephPk        = mulPointEscalar(Base8, ephSk)
+ *   sharedPoint  = mulPointEscalar(recipientIvk, ephSk)  ← or mulPointEscalar(ephPk, ivsk)
+ *   sharedSecret = bigintTo32Le(sharedPoint[0])          ← Ax coordinate, 32 bytes LE
+ *   key          = SHA256(sharedSecret || commitment || "orbinum-note-encryption-v1")
  *
  * Cipher: ChaCha20-Poly1305 (IETF, 96-bit nonce)
  */
 
+/** Memo size: nonce(12) + ciphertext+MAC(132) + ephPk(32) = 176 */
+declare const ENCRYPTED_MEMO_SIZE: number;
 declare const EncryptedMemo: {
     /**
-     * Build and encrypt a memo for a note.
+     * Build and encrypt a memo for a note using ECDH (v2, 168 bytes).
      *
-     * @param value       Note value in planck.
-     * @param ownerPk     32-byte owner public key (little-endian).
-     * @param blinding    32-byte blinding scalar (little-endian).
-     * @param assetId     Asset identifier.
-     * @param commitment  32-byte commitment bytes (little-endian).
-     * @param recipientVk 32-byte recipient viewing key — pass `new Uint8Array(32)`
-     *                    for a publicly-readable (dummy) memo.
-     * @returns 104-byte encrypted memo (nonce || ciphertext).
+     * @param value              Note value in planck.
+     * @param ownerPk            32-byte owner public key (LE).
+     * @param blinding           32-byte blinding scalar (LE).
+     * @param assetId            Asset identifier.
+     * @param commitment         32-byte commitment bytes (LE).
+     * @param recipientIvkPacked 32-byte LE-encoded packed BJJ viewing public key
+     *                           (from PrivacyKeyManager.getViewingPublicKeyPacked() or
+     *                           decoded from a privacy address).
+     *                           Pass `new Uint8Array(32)` (all zeros) for a publicly-readable memo.
+     * @param counterpartyPk     32-byte counterparty BJJ Ax. Default: all zeros.
+     * @returns 168-byte encrypted memo: nonce(12) || ciphertext+MAC(124) || ephPk(32).
      */
-    encrypt(value: bigint, ownerPk: Uint8Array, blinding: Uint8Array, assetId: number, commitment: Uint8Array, recipientVk: Uint8Array): Uint8Array;
+    encrypt(value: bigint, ownerPk: Uint8Array, blinding: Uint8Array, assetId: number, commitment: Uint8Array, recipientIvkPacked: Uint8Array, counterpartyPk?: Uint8Array, ephSkOverride?: Uint8Array): Uint8Array;
     /**
-     * Returns a 104-byte public memo with a zero recipient viewing key.
-     * The memo is still readable by anyone who holds the viewing key (zeros).
+     * Returns a 168-byte public memo encrypted with a zero viewing key.
+     * Decryptable by anyone with `decrypt(memo, commitment, new Uint8Array(32))`.
+     * Convenience alias for `encrypt(..., new Uint8Array(32))`.
      */
     encryptPublic(value: bigint, ownerPk: Uint8Array, blinding: Uint8Array, assetId: number, commitment: Uint8Array): Uint8Array;
     /**
-     * Returns a 104-byte zeroed dummy memo (no information, always valid on-chain).
+     * Returns a 168-byte zeroed dummy memo (no information, always valid on-chain).
      */
     dummy(): Uint8Array;
     /**
-     * Decrypt an on-chain EncryptedMemo.
+     * Validates that `bytes` is a properly-sized encrypted memo.
+     * Throws an Error if the length is not ENCRYPTED_MEMO_SIZE (168 bytes).
+     *
+     * Call this at system boundaries (extrinsic builders, precompile encoders)
+     * to catch malformed memos before they reach the chain and fail on-chain.
+     *
+     * @param bytes   The memo bytes to validate.
+     * @param context Optional context string included in the error (e.g. 'shield', 'output[0]').
+     */
+    validate(bytes: Uint8Array, context?: string): void;
+    /**
+     * Decrypt an on-chain EncryptedMemo using the recipient's viewing secret key.
+     * Returns null if decryption fails — wrong key, bad MAC, or malformed memo.
+     * Never throws; safe for scan loops.
+     *
+     * @param memoBytes        168-byte encrypted memo.
+     * @param commitment       32-byte note commitment (LE).
+     * @param viewingSecretKey 32-byte HKDF viewing secret key from deriveViewingSecretKey().
+     */
+    decrypt(memoBytes: Uint8Array, commitment: Uint8Array, viewingSecretKey: Uint8Array): DecryptedMemo | null;
+    /**
+     * Extract the ECDH shared secret from an encrypted memo using the recipient's viewing secret key.
      *
-     * Returns `null` if decryption fails — wrong key, bad MAC, or malformed memo.
+     * Used by NoteDecryptor to obtain the shared secret needed for stealth address derivation
+     * without re-running the full decrypt path. Safe to call on any 168-byte memo.
+     *
+     * Returns `new Uint8Array(32)` (all zeros) for public/dummy memos (zero ephPk).
+     * Returns `null` if the memo is malformed or the ephPk is not a valid BJJ point.
      * Never throws; safe for scan loops.
      *
-     * @param memoBytes   104-byte encrypted memo.
-     * @param commitment  32-byte note commitment (little-endian).
-     * @param recipientVk 32-byte recipient viewing key.
+     * @param memoBytes        168-byte encrypted memo.
+     * @param viewingSecretKey 32-byte HKDF viewing secret key from deriveViewingSecretKey().
      */
-    decrypt(memoBytes: Uint8Array, commitment: Uint8Array, recipientVk: Uint8Array): DecryptedMemo | null;
+    extractSharedSecret(memoBytes: Uint8Array, viewingSecretKey: Uint8Array): Uint8Array | null;
+    /** @internal */
+    _decrypt(memoBytes: Uint8Array, commitment: Uint8Array, viewingSecretKey: Uint8Array): DecryptedMemo | null;
 };
 
 /**
@@ -1751,18 +2623,218 @@ declare const EncryptedMemo: {
  */
 
 /**
- * Attempt to decrypt an on-chain commitment using a viewing key.
+ * Computes the nullifier for a note.
+ *   nullifier = Poseidon2(commitment, spendingKey)
+ *
+ * spendingKey must already be in [1, BABYJUB_SUBORDER) as returned by
+ * deriveSpendingKeyFromSignature.
+ */
+declare function computeNullifier(commitment: bigint, spendingKey: bigint): bigint;
+/**
+ * Attempt to decrypt an on-chain commitment using the recipient's viewing secret key.
  *
  * Returns a fully populated ZkNote if the memo decrypts correctly and the
  * recomputed commitment matches the on-chain value.
  * Returns null when the note does not belong to this viewer (wrong key, no memo,
  * or commitment mismatch).
  *
- * @param commitment  On-chain commitment record from the indexer.
- * @param viewingKey  32-byte viewing key (from deriveViewingKey).
- * @param spendingKey Spending key bigint (for nullifier computation).
+ * @param commitment       On-chain commitment record from the indexer.
+ * @param viewingSecretKey 32-byte viewing secret key (from deriveViewingSecretKey / getViewingSecretKey).
+ * @param spendingKey      Spending key bigint (for nullifier computation).
+ * @param ownOwnerPk       The viewer's global BabyJubJub Ax (ownerPk). Required for stealth detection.
+ *                         Pass 0n to disable stealth detection (legacy/own-note-only scanning).
+ */
+declare function tryDecryptNote(commitment: ScanCommitment, viewingSecretKey: Uint8Array, spendingKey: bigint, ownOwnerPk?: bigint): ZkNote | null;
+/**
+ * Like tryDecryptNote but also returns a human-readable reason for failure.
+ * Useful for debugging scan issues (wrong key, corrupted memo, commitment mismatch).
+ */
+declare function tryDecryptNoteVerbose(commitment: ScanCommitment, viewingSecretKey: Uint8Array, spendingKey: bigint, ownOwnerPk?: bigint): {
+    note: ZkNote | null;
+    reason?: string;
+};
+
+/** A single input note for a private transfer. */
+interface TransferInputNote {
+    nullifier: bigint;
+    /** Note value (planck). */
+    value: bigint;
+    assetId: bigint;
+    ownerPk: bigint;
+    blinding: bigint;
+    spendingKey: bigint;
+    /** Sibling hashes (0x-prefixed, 32-byte LE). */
+    pathSiblings: string[];
+    leafIndex: number;
+}
+/** A single output note for a private transfer. */
+interface TransferOutputNote {
+    /** Commitment as bigint. */
+    commitment: bigint;
+    value: bigint;
+    assetId: bigint;
+    ownerPk: bigint;
+    blinding: bigint;
+}
+/**
+ * Inputs required to generate a PrivateTransfer proof.
+ * Supports exactly 2 inputs and 2 recipient outputs (circuit constraint).
+ * The fee is paid to the block author (validator) by the pallet runtime.
+ */
+interface PrivateTransferProofInputs {
+    merkleRoot: string;
+    inputs: [TransferInputNote, TransferInputNote];
+    outputs: [TransferOutputNote, TransferOutputNote];
+    /** Gasless fee in planck (default 0n). Must satisfy: input_sum == output_sum + fee */
+    fee?: bigint;
+}
+/**
+ * Generate a Groth16 proof for a PrivateTransfer operation.
+ */
+declare function generateTransferProof(params: PrivateTransferProofInputs, options?: {
+    provider?: ArtifactProvider;
+    verbose?: boolean;
+}): Promise<ProofResult>;
+
+/**
+ * Selects up to 2 unspent notes that together cover `needed` planck.
+ *
+ * Priority:
+ *   1. A single note whose value >= needed  →  [note, null]  (second input will be a dummy)
+ *   2. The smallest pair whose sum >= needed →  [noteA, noteB]
+ *   3. No combination covers needed          →  null  (consolidation via merge required)
+ *
+ * Only unspent notes with value > 0 are considered.
+ */
+declare function selectNotes(notes: ZkNote[], needed: bigint): [ZkNote, ZkNote | null] | null;
+/**
+ * Builds a dummy `TransferInputNote` for use as the second input in a single-note transfer.
+ *
+ * The modified transfer circuit exempts inputs with `value == 0` from Merkle membership,
+ * nullifier derivation, and EdDSA signature checks (Constraints 1–3 are conditional on
+ * `is_dummy[i].out == 0`). Constraint 9 forces the public nullifier to 0 for dummy inputs.
+ *
+ * Security: `IsZero` is a deterministic R1CS gadget — a prover cannot make it return 1
+ * for a non-zero `input_values[i]` without breaking the constraint system.
+ *
+ * @param assetId - Must equal the real input note's assetId (circuit Constraint 7).
+ */
+declare function buildDummyTransferInput(assetId: bigint): TransferInputNote;
+
+/**
+ * Selective disclosure helpers for the Orbinum shielded pool (ECDH Baby Jubjub protocol).
+ *
+ * ## Public signals layout (256 bytes on-chain)
+ * ```
+ *  [0..32]   commitment      — Poseidon4(value, asset_id, owner_pk, blinding) LE
+ *  [32..64]  auditor_pk_x   — Baby Jubjub pk_A.x LE
+ *  [64..96]  auditor_pk_y   — Baby Jubjub pk_A.y LE
+ *  [96..128] epk_x          — r·G x-coordinate LE
+ *  [128..160] epk_y         — r·G y-coordinate LE
+ *  [160..192] enc_value     — masked_value + k0
+ *  [192..224] enc_asset_id  — masked_asset_id + k1
+ *  [224..256] enc_owner_hash — masked_owner_hash + k2
+ * ```
+ *
+ * The runtime verifies the Groth16 proof against the ciphertext.
+ * It never decrypts. Decryption is off-chain with the auditor's BJJ sk.
+ */
+
+/**
+ * Derives a Baby Jubjub keypair deterministically from a Substrate signing key.
+ *
+ * ```
+ * bjj_sk = Poseidon(substrate_signing_key)   // one-way; does not expose the substrate key
+ * bjj_pk = bjj_sk · G                         // Baby Jubjub base point
+ * ```
+ *
+ * The `bjj_pk` is registered in `DisclosureRequest` on-chain so the note owner
+ * knows which key to encrypt to.
+ *
+ * @param substrateSigningKey - Raw 32-byte Substrate signing key (sr25519 or ed25519).
+ * @returns `{ sk, pkX, pkY }` — Baby Jubjub secret scalar and public key coordinates.
+ */
+declare function deriveBabyJubjubKeypair(substrateSigningKey: Uint8Array): {
+    sk: bigint;
+    pkX: bigint;
+    pkY: bigint;
+};
+/**
+ * Packs the 8 public signals into the 256-byte buffer for the `disclose` extrinsic.
+ *
+ * Layout:
+ * ```
+ *  [0..32]   commitment      — 32-byte LE (0x-hex string)
+ *  [32..64]  auditor_pk_x   — 32-byte LE bigint
+ *  [64..96]  auditor_pk_y   — 32-byte LE bigint
+ *  [96..128] epk_x          — from proofOutput.encryptedData.epkX
+ *  [128..160] epk_y         — from proofOutput.encryptedData.epkY
+ *  [160..192] enc_value     — from proofOutput.encryptedData.encValue
+ *  [192..224] enc_asset_id  — from proofOutput.encryptedData.encAssetId
+ *  [224..256] enc_owner_hash — from proofOutput.encryptedData.encOwnerHash
+ * ```
+ *
+ * @param commitment   - 0x-prefixed 32-byte hex commitment.
+ * @param auditorPkX   - Auditor's Baby Jubjub pk x-coordinate (bigint LE).
+ * @param auditorPkY   - Auditor's Baby Jubjub pk y-coordinate (bigint LE).
+ * @param proofOutput  - Output of `generateDisclosureProof`.
+ * @returns `number[]` — 256 bytes, SCALE-compatible.
+ */
+declare function buildDisclosurePublicSignals(commitment: string, auditorPkX: bigint, auditorPkY: bigint, proofOutput: DisclosureProofOutput): number[];
+/**
+ * Decrypts encrypted disclosure signals using the auditor's Baby Jubjub secret key.
+ *
+ * ```
+ * shared = sk_A · epk              (ECDH — Baby Jubjub scalar mult)
+ * k_i = Poseidon(shared.x, shared.y, i)
+ * plaintext_i = (enc_i - k_i + BN254_R) % BN254_R
+ * ```
+ *
+ * Only the intended auditor (holder of `auditorBjjSk`) can decrypt.
+ * This runs entirely off-chain — the runtime never sees or derives `sk`.
+ *
+ * @param auditorBjjSk - Auditor's Baby Jubjub secret scalar (from `deriveBabyJubjubKeypair`).
+ * @param enc          - Encrypted signals from `DisclosureRecord.signals` (as bigints).
+ * @returns `{ value, assetId, ownerHash }` — decrypted field elements.
+ *   If a field was not disclosed, its ciphertext is `k_i` and the plaintext decrypts to `0`.
+ */
+declare function decryptDisclosureSignals(auditorBjjSk: bigint, enc: {
+    epkX: bigint;
+    epkY: bigint;
+    encValue: bigint;
+    encAssetId: bigint;
+    encOwnerHash: bigint;
+}): {
+    value: bigint;
+    assetId: bigint;
+    ownerHash: bigint;
+};
+
+/**
+ * BN254 (alt_bn128) scalar field prime.
+ *
+ * Used as the modulus for Poseidon blinding factors: blinding ∈ [1, BN254_R).
+ * A random 32-byte value reduced mod BN254_R gives a uniform blinding factor.
  */
-declare function tryDecryptNote(commitment: ScanCommitment, viewingKey: Uint8Array, spendingKey: bigint): ZkNote | null;
+declare const BN254_R = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+/**
+ * Baby JubJub prime subgroup order.
+ *
+ * Spending keys (circuit scalars) MUST be in [1, BABYJUB_SUBORDER).
+ * circomlib's BabyPbk uses Num2Bits(253) which asserts sk < 2^253.
+ * BABYJUB_SUBORDER < 2^252 < 2^253 satisfies both the curve arithmetic
+ * requirement and the circuit constraint.
+ */
+declare const BABYJUB_SUBORDER = 2736030358979909402780800718157159386076813972158567259200215660948447373041n;
+
+/**
+ * Generate a cryptographically random Poseidon blinding factor.
+ *
+ * Produces a uniform random value in [1, BN254_R) by reading 32 random bytes
+ * and reducing mod BN254_R. The zero case is mapped to 1 to guarantee the
+ * blinding factor is never zero.
+ */
+declare function randomBlinding(): bigint;
 
 /**
  * PrivacyKeys
@@ -1770,40 +2842,83 @@ declare function tryDecryptNote(commitment: ScanCommitment, viewingKey: Uint8Arr
  * Pure cryptographic derivation functions for the Orbinum shielded pool identity.
  * These are protocol-level operations — independent of storage, UI, or session.
  *
- * Derivation scheme:
- *   viewingKey = HKDF-SHA256(ikm=spendingKey_bytes, info="orbinum-ivk-v1") → 32 bytes
- *   ownerPk    = BabyJubJub Ax from (spendingKey * Base8)                  → bigint
+ * Derivation scheme (ECDH viewing key — v2):
+ *   viewingSecretKey (ivsk) = HKDF-SHA256(ikm=spendingKey_bytes, info="orbinum-ivk-v1") → 32 bytes
+ *   ivsk_scalar             = BigInt(ivsk_BE) % BABYJUB_SUBORDER  (clamped to [1, ∞))
+ *   viewingPublicKey (ivk)  = BJJ_mul(Base8, ivsk_scalar)  →  packPoint([Ax, Ay])  → 32-byte bigint stored LE
+ *   ownerPk                 = BabyJubJub Ax from (spendingKey * Base8)  → bigint
  *
  * Spending key derivation (from wallet signature):
- *   message    = "orbinum-spending-key-v1\n${chainId}\n${address.toLowerCase()}"
- *   skBytes    = HKDF-SHA256(ikm=sig_bytes, salt=empty, info="orbinum-sk-v1:${chainId}:${address}")
- *   spendingKey = BigInt(skBytes_as_big_endian) % BN254_R  (if 0 → 1)
+ *   message     = "orbinum-spending-key-v1\n${chainId}\n${address.toLowerCase()}"
+ *   skBytes     = HKDF-SHA256(ikm=sig_bytes, salt=empty, info="orbinum-sk-v1:${chainId}:${address}")
+ *   spendingKey = BigInt(skBytes_as_big_endian) % BABYJUB_SUBORDER  (if 0 → 1)
  *
- * The viewingKey is the symmetric key used by EncryptedMemo (ChaCha20-Poly1305).
- * The ownerPk (x-coordinate) is included in note commitments.
+ * IMPORTANT: must reduce mod BABYJUB_SUBORDER (not BN254_R). circomlib's BabyPbk uses
+ * Num2Bits(253) which asserts spending_key < 2^253. BABYJUB_SUBORDER < 2^252 satisfies
+ * this. BN254_R ≈ 2^254.8 does not — ~34% of values would exceed 2^253 at runtime.
  */
 /**
  * Returns the message string the user must sign with their wallet to derive
  * a deterministic Orbinum spending key.
  */
 declare function deriveSpendingKeyMessage(chainId: number, address: string): string;
+/**
+ * Derives the 32-byte master key bytes from a wallet signature.
+ *
+ * masterBytes = HKDF-SHA256(ikm=sigBytes, salt=empty, info="orbinum-sk-v1:{chainId}:{address}")
+ *
+ * These bytes are the stable root for ALL derived keys:
+ *   - spendingKey (circuit scalar) = BigInt(masterBytes) % BABYJUB_SUBORDER
+ *   - viewingSecretKey              = HKDF(bigintTo32Le(spendingKey), info="orbinum-ivk-v1")
+ *   - vaultKey                     = HKDF(masterBytes, info="orbinum-vault-key-v1")
+ *
+ * Separating masterBytes from the circuit scalar means the viewingSecretKey and
+ * vault key are STABLE across any future change to the modulus — they never
+ * depend on which prime field the circuit uses.
+ */
+declare function deriveMasterKeyBytes(signatureHex: string, chainId: number, address: string): Promise<Uint8Array>;
 /**
  * Derives an Orbinum spending key from a wallet signature.
  *
  * Uses HKDF-SHA256(ikm=sigBytes, salt=empty, info="orbinum-sk-v1:{chainId}:{address}")
- * and reduces the resulting 32-byte value modulo BN254_R.
+ * and reduces the resulting 32-byte value modulo BABYJUB_SUBORDER.
+ *
+ * IMPORTANT: viewingSecretKey and vaultKey must be derived from masterBytes (via
+ * deriveMasterKeyBytes), NOT from this spending key scalar. This ensures those
+ * keys remain stable if the circuit's modulus ever changes again.
  *
  * @param signatureHex  0x-prefixed or bare hex of the wallet signature.
  * @param chainId       Chain ID used when building the signing message.
  * @param address       Signer address (EVM or SS58) used in the signing message.
- * @returns bigint in [1, BN254_R)
+ * @returns bigint in [1, BABYJUB_SUBORDER)
  */
 declare function deriveSpendingKeyFromSignature(signatureHex: string, chainId: number, address: string): Promise<bigint>;
 /**
- * Derive a 32-byte viewing key from a spending key.
- *   viewingKey = HKDF-SHA256(ikm=spendingKey_bytes, info="orbinum-ivk-v1")
+ * Derive a 32-byte viewing secret key (ivsk) from the spending key.
+ *   ivsk = HKDF-SHA256(ikm=bigintTo32Le(spendingKey), info="orbinum-ivk-v1")
+ *
+ * The ivsk is intentionally derived from the already-reduced spending key scalar
+ * (not from masterBytes) so that it stays bound to the specific key identity
+ * loaded in this session. The spendingKey must already be in [1, BABYJUB_SUBORDER).
+ *
+ * SECURITY: This is a symmetric secret — never embed it in a shareable address.
+ * Use deriveViewingPublicKey() to obtain the public component for sharing.
+ */
+declare function deriveViewingSecretKey(spendingKey: bigint): Uint8Array;
+/**
+ * Derive the packed BabyJubJub viewing public key (ivk) from ivsk bytes.
+ *
+ *   ivsk_scalar = BigInt(ivsk_bytes_BE) % BABYJUB_SUBORDER  (clamped to [1, ∞))
+ *   ivk_point   = mulPointEscalar(Base8, ivsk_scalar)       → [Ax, Ay]
+ *   result      = bigintTo32Le(packPoint([Ax, Ay]))          → 32-byte Uint8Array (LE)
+ *
+ * The packed bigint is stored in little-endian so it is consistent with the
+ * rest of the SDK's 32-byte scalar encoding (bigintTo32Le / bytesToBigintLE).
+ *
+ * @param ivsk 32-byte HKDF output from deriveViewingSecretKey().
+ * @returns 32-byte LE-encoded packed BJJ point (goes in the privacy address).
  */
-declare function deriveViewingKey(spendingKey: bigint): Uint8Array;
+declare function deriveViewingPublicKey(ivsk: Uint8Array): Uint8Array;
 /**
  * Derive the BabyJubJub Ax (x-coordinate of the public key) from a spending key.
  *   ownerPk = (spendingKey * BabyJubJub.Base8)[0]
@@ -1820,58 +2935,111 @@ declare function deriveOwnerPk(spendingKey: bigint): bigint;
  *
  * Create one instance per user session:
  *   const pkm = new PrivacyKeyManager();
- *   await pkm.load(spendingKey);
+ *   await pkm.load(spendingKey, masterBytes);
  *
  * The caller (application layer) is responsible for key persistence and session
  * caching. Each instance holds independent state — safe for multi-wallet use.
  *
- * Derivation scheme:
- *   spendingKey (bigint, BN254 scalar)
- *     └── viewingKey   = HKDF-SHA256(spendingKey_bytes, info="orbinum-ivk-v1")  → 32 bytes
- *     └── ownerPk      = BabyJubJub Ax from (spendingKey * Base8)               → bigint
+ * Derivation scheme (from wallet signature):
+ *   sig → HKDF → masterBytes (32 bytes, stable root for all derived keys)
+ *     ├── spendingKey       = BigInt(masterBytes) % BABYJUB_SUBORDER  (circuit scalar)
+ *     ├── viewingSecretKey  = HKDF(bigintTo32Le(spendingKey), info="orbinum-ivk-v1")  ← NEVER shared
+ *     ├── viewingPublicKey  = packPoint(BJJ_mul(Base8, ivsk_scalar))  ← embedded in privacy address
+ *     ├── ownerPk           = BabyJubJub Ax from (spendingKey × Base8)
+ *     └── vaultKey          = HKDF(masterBytes, info="orbinum-vault-key-v1")  ← stable
+ *
+ * Cache format: "mk:0x{masterBytes_hex}" — storing masterBytes (not the sk scalar)
+ * ensures the vault key remains stable if the circuit modulus ever changes.
  */
 declare class PrivacyKeyManager {
     private _state;
     /**
-     * Load a spending key into the in-memory session.
-     * Derives viewingKey and ownerPk immediately.
+     * Load a spending key and its corresponding master bytes into the in-memory session.
+     * Derives viewingSecretKey, viewingPublicKeyPacked, and ownerPk immediately.
      * Replaces any previously loaded key.
+     *
+     * @param spendingKey  Circuit scalar: BigInt(masterBytes) % BABYJUB_SUBORDER, clamped to [1, ∞).
+     * @param masterBytes  Raw 32-byte HKDF output before modular reduction. Used to derive
+     *                     the stable vault key (HKDF(masterBytes, info="orbinum-vault-key-v1")).
      */
-    load(spendingKey: bigint): Promise<void>;
+    load(spendingKey: bigint, masterBytes: Uint8Array): Promise<void>;
     /** Clear all key material from memory. Call on vault lock / sign-out. */
     clear(): void;
     /** Returns true if a spending key has been loaded. */
     isLoaded(): boolean;
     /** Returns the spending key. Throws if not loaded. */
     getSpendingKey(): bigint;
-    /** Returns the 32-byte viewing key. Throws if not loaded. */
-    getViewingKey(): Uint8Array;
+    /**
+     * Returns the 32-byte viewing secret key (ivsk).
+     * Used internally for decrypting received notes during rescan.
+     * SECURITY: never expose this in addresses or network requests.
+     * Throws if not loaded.
+     */
+    getViewingSecretKey(): Uint8Array;
+    /**
+     * Returns the 32-byte LE-encoded packed BJJ viewing public key (ivk).
+     * This is the component embedded in the privacy address and passed to senders
+     * so they can encrypt memos only the recipient can decrypt.
+     * Throws if not loaded.
+     */
+    getViewingPublicKeyPacked(): Uint8Array;
     /** Returns the BabyJubJub owner public key (x-coordinate). Throws if not loaded. */
     getOwnerPk(): bigint;
     /** Returns the spending key as a 32-byte little-endian Uint8Array. Throws if not loaded. */
     getSpendingKeyBytes(): Uint8Array;
-    /** Exports the spending key as a 0x-prefixed 64-char hex string. Throws if not loaded. */
+    /**
+     * Returns the 32-byte master key bytes (pre-modulus HKDF output).
+     * Used to derive the stable vault AES key. Throws if not loaded.
+     */
+    getMasterBytes(): Uint8Array;
+    /**
+     * Exports the master key bytes as a "mk:0x{hex}" string.
+     * Storing masterBytes (not the sk scalar) ensures the vault key and
+     * rescan can always be reconstructed regardless of any future modulus change.
+     * Throws if not loaded.
+     */
     exportHex(): string;
     /**
-     * Load a spending key from a 0x-prefixed or bare hex string.
-     * Validates the key is in the valid range [1, BN254_R).
+     * Exports a shareable privacy address encoding the owner public key and
+     * viewing PUBLIC key of the currently loaded identity.
+     *
+     * Format: `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`
+     *
+     * The recipient uses this address so the sender can:
+     *  1. Embed `ownerPk` in the note commitment (Poseidon4 input).
+     *  2. Encrypt the memo via ECDH with the recipient's `viewingPublicKey`.
+     *
+     * SECURITY: Only the viewing PUBLIC key is embedded — the viewing secret key
+     * (used for decryption) is never exported. Holders of this address cannot
+     * decrypt the recipient's notes.
+     *
+     * Throws if no key is loaded.
+     */
+    encodePrivacyAddress(): string;
+    /**
+     * Decode a privacy address of the form `orbpriv1:{ownerPk_hex}:{viewingPublicKey_hex}`.
+     * Returns `{ ownerPkHex, viewingPublicKeyHex }` on success, or `null` if the input
+     * does not match the expected format.
+     */
+    static decodePrivacyAddress(address: string): {
+        ownerPkHex: string;
+        viewingPublicKeyHex: string;
+    } | null;
+    /**
+     * Load keys from a cached "mk:0x{masterBytes_hex}" string produced by exportHex().
+     * Throws if the format is invalid or masterBytes length is not 32 bytes.
      */
     importFromHex(hex: string): Promise<void>;
 }
 
 /**
- * VaultCrypto
+ * VaultJson
  *
- * WebCrypto-based encryption utilities for protecting Orbinum vault data.
- * Works in browser and Node.js 18+ (both expose the WebCrypto API as `crypto`).
- * Pure functions — no state, no side effects.
- *
- * Key derivation: HKDF-SHA-256(ikm=spendingKeyBytes, salt=empty, info="orbinum-vault-key-v1")
- * Cipher: AES-GCM 256
+ * BigInt-safe JSON helpers for Orbinum vault payloads.
  *
- * BigInt serialisation uses `{ __bigint: "<decimal string>" }` so plain
- * `JSON.stringify` never receives a bigint. Use `vaultReplacer` / `vaultReviver`
- * for all vault payloads.
+ * BigInt values are serialised as `{ __bigint: "<decimal string>" }` so that
+ * `JSON.stringify` never receives a native bigint (which it cannot handle).
+ * Use `vaultReplacer` / `vaultReviver` for every vault read/write operation.
  */
 /**
  * `JSON.stringify` replacer that serialises bigint values as
@@ -1883,30 +3051,239 @@ declare function vaultReplacer(_key: string, value: unknown): unknown;
  * back into native bigint values.
  */
 declare function vaultReviver(_key: string, value: unknown): unknown;
+
+/**
+ * VaultCrypto
+ *
+ * WebCrypto-based encryption utilities for protecting Orbinum vault data.
+ * Works in browser and Node.js 18+ (both expose the WebCrypto API as `crypto`).
+ * Pure functions — no state, no side effects.
+ *
+ * Key derivation: HKDF-SHA-256(ikm=masterBytes, salt=empty, info="orbinum-vault-key-v1")
+ * Cipher: AES-GCM 256
+ */
 /**
- * Derives an AES-GCM-256 CryptoKey from spending key bytes using HKDF-SHA-256.
- * The spending key carries ≥256 bits of entropy so no salt / iteration
- * stretching is required.
+ * Derives an AES-GCM-256 CryptoKey from master key bytes using HKDF-SHA-256.
+ *
+ * IMPORTANT: pass masterBytes from deriveMasterKeyBytes(), NOT bigintTo32Le(spendingKey).
+ * The vault key must be stable across circuit field changes — it depends only on
+ * the wallet signature, never on the modulus used to reduce the circuit scalar.
  *
- * @param spendingKeyBytes 32-byte spending key (little-endian bigint representation).
+ * @param masterBytes 32-byte pre-modulus key material from deriveMasterKeyBytes().
  */
-declare function deriveVaultKey(spendingKeyBytes: Uint8Array): Promise<CryptoKey>;
+declare function deriveVaultKey(masterBytes: Uint8Array): Promise<CryptoKey>;
 /**
  * Serialises `payload` to JSON (bigint-safe) and encrypts it with AES-GCM.
  * Returns base64-encoded `iv` and `ciphertext`.
  */
-declare function encryptJson(key: CryptoKey, payload: unknown): Promise<{
-    iv: string;
-    ciphertext: string;
-}>;
+declare function encryptJson(key: CryptoKey, payload: unknown): Promise<{
+    iv: string;
+    ciphertext: string;
+}>;
+/**
+ * Decrypts AES-GCM ciphertext and parses the JSON payload (bigint-safe).
+ * Throws `DOMException` on authentication failure (wrong key or corrupted data).
+ */
+declare function decryptJson(key: CryptoKey, iv: string, ciphertext: string): Promise<unknown>;
+
+/**
+ * Vault protocol types.
+ *
+ * These types define the storage contract for vault note records.
+ * Any backend (IndexedDB, SQLite, remote…) must produce/consume this shape
+ * so that encryptNote / decryptNoteRecord work without modification.
+ */
+/** A single encrypted note record as stored in the vault backend. */
+interface EncryptedNoteRecord {
+    /** Primary key — note commitmentHex */
+    commitmentHex: string;
+    /** AES-GCM IV for this record — base64 */
+    iv: string;
+    /** AES-GCM ciphertext of the full ZkNote JSON — base64 */
+    ciphertext: string;
+    /** Unencrypted nullifierHex for quick spent-check without unlocking */
+    nullifierHex: string;
+    /** Unencrypted assetId (string form of bigint) for filtering */
+    assetId: string;
+    /** Whether the note has already been spent/nullified on-chain. */
+    spent?: boolean;
+    /** When the app marked the note as spent locally, if known. */
+    spentAt?: number | null;
+    updatedAt: number;
+}
+/** Partial update applied to a note's spent status without re-encrypting the full payload. */
+interface NoteStatusUpdate {
+    spent?: boolean;
+    spentAt?: number | null;
+}
+
+/**
+ * Vault protocol errors.
+ */
+/** Thrown when a vault operation is attempted while the vault is locked. */
+declare class VaultLockedError extends Error {
+    constructor(message?: string);
+}
+
+/**
+ * noteOps
+ *
+ * Pure protocol-level operations on vault notes.
+ * No Zustand, no IndexedDB — pure data transformations.
+ */
+
+/**
+ * Merges a NoteStatusUpdate into a ZkNote, applying defaults for missing fields.
+ * Returns a new note object — does not mutate the original.
+ */
+declare function applyNoteStatus(note: ZkNote, status?: NoteStatusUpdate): ZkNote;
+/**
+ * Encrypts a ZkNote into an EncryptedNoteRecord using AES-GCM.
+ * The commitmentHex, nullifierHex, and assetId are stored in plaintext
+ * for efficient filtering without requiring vault unlock.
+ */
+declare function encryptNote(key: CryptoKey, note: ZkNote): Promise<EncryptedNoteRecord>;
+/**
+ * Decrypts an EncryptedNoteRecord back into a ZkNote using AES-GCM.
+ * Applies the record's spent/spentAt metadata onto the decrypted note.
+ * Throws DOMException on authentication failure (wrong key or corrupted data).
+ */
+declare function decryptNoteRecord(key: CryptoKey, rec: EncryptedNoteRecord): Promise<ZkNote>;
+
+/**
+ * Inputs required to generate an Unshield proof.
+ *
+ * All BigInt values must be BN254 scalar field elements.
+ * All hex strings must be 0x-prefixed 32-byte little-endian values (as
+ * returned by the node RPC).
+ */
+interface UnshieldProofInputs {
+    /** Merkle root (0x-prefixed, 32-byte LE). */
+    merkleRoot: string;
+    /** Nullifier as bigint. */
+    nullifier: bigint;
+    /** Net withdrawal amount (recipient receives this, planck). */
+    amount: bigint;
+    /** Asset ID. */
+    assetId: bigint;
+    /**
+     * Recipient encoded as a BN254 field element.
+     * For Substrate addresses: Poseidon(le32(accountId32)).
+     */
+    recipient: bigint;
+    /** Note blinding factor. */
+    blinding: bigint;
+    /** Spending key used to derive the nullifier. */
+    spendingKey: bigint;
+    /** Sibling hashes (0x-prefixed, 32-byte LE), one per tree level. */
+    pathSiblings: string[];
+    /** Leaf index of the commitment in the Merkle tree. */
+    leafIndex: number;
+    /** Gasless fee in planck (default 0n). note_value == amount + fee + changeValue in circuit. */
+    fee?: bigint;
+    /**
+     * Value of the change note in planck (default 0n = total unshield).
+     * Must satisfy: note_value == amount + fee + changeValue.
+     */
+    changeValue?: bigint;
+    /**
+     * Blinding scalar for the change note commitment.
+     * Auto-generated with CSPRNG when changeValue > 0n and not provided.
+     */
+    changeBlinding?: bigint;
+    /**
+     * BabyJubJub Ax coordinate of the change note owner (default: derived from spendingKey,
+     * i.e. the change stays with the same owner).
+     */
+    changeOwnerPubkey?: bigint;
+}
+/**
+ * Result of `generateUnshieldProof`.
+ *
+ * Extends `ProofResult` with the change note commitment, value, blinding, and owner pubkey
+ * so the caller can pass them directly to the `unshield` extrinsic and generate the
+ * encrypted memo for change note recovery.
+ */
+interface UnshieldProofResult extends ProofResult {
+    /** Poseidon4(changeValue, assetId, changeOwnerPubkey, changeBlinding). 0n for total unshield. */
+    changeCommitment: bigint;
+    /** Change value used (mirrors inputs.changeValue ?? 0n). */
+    changeValue: bigint;
+    /** Blinding factor for the change note (0n for total unshield). */
+    changeBlinding: bigint;
+    /** Owner pubkey for the change note (derived from spendingKey if not provided). */
+    changeOwnerPubkey: bigint;
+}
+/**
+ * Generate a Groth16 proof for an Unshield operation.
+ *
+ * @param inputs - All private and public inputs for the unshield circuit.
+ * @param options.provider - Override the artifact provider (default: CDN).
+ * @param options.verbose - Log proof generation steps to console.
+ */
+declare function generateUnshieldProof(inputs: UnshieldProofInputs, options?: {
+    provider?: ArtifactProvider;
+    verbose?: boolean;
+}): Promise<UnshieldProofResult>;
+
+/**
+ * Inputs required to generate a fee-claim proof.
+ *
+ * The proof demonstrates that the caller knows the preimage of `commitment`,
+ * specifically that `commitment = Poseidon4(amount, assetId, ownerPubkey, blinding)`.
+ * Both `amount` and `assetId` are revealed as public signals so the pallet can
+ * verify consistency with the extrinsic arguments.
+ */
+interface FeeClaimProofInputs {
+    /** Fee amount to claim in planck (must fit in u64). */
+    amount: bigint;
+    /** Asset ID of the fee note. */
+    assetId: bigint;
+    /** Owner public key (BabyJubJub Ax component). */
+    ownerPubkey: bigint;
+    /** Note blinding factor. */
+    blinding: bigint;
+    /** Note commitment as bigint (Poseidon4(amount, assetId, ownerPubkey, blinding)). */
+    commitment: bigint;
+}
+/**
+ * Proof output ready to submit with `claim_shielded_fees`.
+ */
+interface FeeClaimProofOutput {
+    /** 128-byte compressed Groth16 proof as 0x-prefixed hex. */
+    proof: string;
+    /**
+     * Compact 76-byte public signals as `number[]` (SCALE-compatible).
+     *
+     * Layout: commitment[0..32] | value[32..40] | asset_id[40..44] | owner_hash[44..76]
+     *
+     * Pass directly as the `public_signals` argument of `claim_shielded_fees`.
+     */
+    publicSignals: number[];
+}
+/**
+ * Generate a Groth16 fee-claim proof using the disclosure circuit.
+ *
+ * The resulting proof convinces the pallet that:
+ *   1. The caller knows (amount, assetId, ownerPubkey, blinding) such that
+ *      `commitment = Poseidon4(amount, assetId, ownerPubkey, blinding)`.
+ *   2. The revealed `amount` and `assetId` match what will be submitted
+ *      on-chain, preventing inflation attacks.
+ *
+ * @param inputs - Note preimage and commitment.
+ * @param options.provider - Override the artifact provider (default: CDN).
+ * @param options.verbose  - Log proof generation steps to console.
+ */
 /**
- * Decrypts AES-GCM ciphertext and parses the JSON payload (bigint-safe).
- * Throws `DOMException` on authentication failure (wrong key or corrupted data).
+ * @deprecated Tech debt — `fees.rs` uses the OLD 76-byte plaintext disclosure layout,
+ * but the disclosure circuit now uses ECDH encryption (256-byte layout).
+ * This function compiles but the resulting proof WILL BE REJECTED by the pallet.
+ * See `frame/shielded-pool/src/operations/fees.rs` comment for resolution options A/B/C.
  */
-declare function decryptJson(key: CryptoKey, iv: string, ciphertext: string): Promise<unknown>;
-
-declare function toBase64(buf: ArrayBuffer | Uint8Array): string;
-declare function fromBase64(b64: string): Uint8Array;
+declare function generateFeeClaimProof(inputs: FeeClaimProofInputs, options?: {
+    provider?: ArtifactProvider;
+    verbose?: boolean;
+}): Promise<FeeClaimProofOutput>;
 
 /**
  * Contract addresses and function selectors for all Orbinum EVM precompiles.
@@ -1986,14 +3363,21 @@ type ShieldedEvent = {
     leafIndex: number;
 };
 /**
- * Emitted by `private_transfer()`.
- * Rust variant: `PrivateTransfer { nullifiers, commitments, encrypted_memos, leaf_indices }`
- * Max 2 inputs / 2 outputs.
+ * Emitted by `private_transfer()` when input nullifiers are spent.
+ * Rust variant: `NullifiersSpent { nullifiers }`
+ * Emitted independently of CommitmentsInserted to prevent graph correlation.
  */
-type PrivateTransferEvent = {
-    /** Input nullifiers — max 2. 0x-prefixed 32-byte hex each. */
+type NullifiersSpentEvent = {
+    /** Input nullifiers consumed — max 2. 0x-prefixed 32-byte hex each. */
     nullifiers: string[];
-    /** Output commitments — max 2. 0x-prefixed 32-byte hex each. */
+};
+/**
+ * Emitted by `private_transfer()` when output commitments are inserted.
+ * Rust variant: `CommitmentsInserted { commitments, encrypted_memos, leaf_indices }`
+ * Emitted independently of NullifiersSpent to prevent graph correlation.
+ */
+type CommitmentsInsertedEvent = {
+    /** Output commitments created — max 2. 0x-prefixed 32-byte hex each. */
     commitments: string[];
     /** Encrypted memos for each output — max 2. */
     encryptedMemos: string[];
@@ -2002,7 +3386,7 @@ type PrivateTransferEvent = {
 };
 /**
  * Emitted by `unshield()` when a note is withdrawn to the public chain.
- * Rust variant: `Unshielded { nullifier, amount, recipient }`
+ * Rust variant: `Unshielded { nullifier, amount, recipient, change_commitment }`
  */
 type UnshieldedEvent = {
     /** 0x-prefixed 32-byte Poseidon nullifier (LE). */
@@ -2010,6 +3394,11 @@ type UnshieldedEvent = {
     amount: bigint;
     /** SS58 AccountId of the recipient. */
     recipient: string;
+    /**
+     * 0x-prefixed 32-byte change note commitment (LE), or null for total unshield.
+     * When present, the commitment has been inserted into the Merkle tree.
+     */
+    changeCommitment: string | null;
 };
 /**
  * Emitted after every Merkle tree update (shield / transfer / unshield).
@@ -2115,8 +3504,11 @@ type ShieldedPoolEvent = {
     type: 'Shielded';
     data: ShieldedEvent;
 } | {
-    type: 'PrivateTransfer';
-    data: PrivateTransferEvent;
+    type: 'NullifiersSpent';
+    data: NullifiersSpentEvent;
+} | {
+    type: 'CommitmentsInserted';
+    data: CommitmentsInsertedEvent;
 } | {
     type: 'Unshielded';
     data: UnshieldedEvent;
@@ -2501,588 +3893,306 @@ type RevealPrivateLinkArgs = {
     signature: number[];
 };
 /**
- * Call index 17 — `dispatch_as_private_link` (Signed origin, relayer)
- * Dispatches a RuntimeCall on behalf of an account identified only by a private
- * link commitment. A Groth16 ZK proof (PRIVATE_LINK circuit) authorises the
- * dispatch without revealing the external address.
- */
-type DispatchAsPrivateLinkArgs = {
-    /** AccountId on whose behalf to dispatch. */
-    owner: string;
-    /** 32-byte commitment identifying the private link (LE). */
-    commitment: number[];
-    /** Groth16 proof bytes (PRIVATE_LINK circuit). */
-    zkProof: number[];
-    /** SCALE-encoded RuntimeCall to dispatch. */
-    call: number[];
-};
-/** All pallet-account-mapping calls as a discriminated union. */
-type AccountMappingCall = {
-    type: 'mapAccount';
-} | {
-    type: 'unmapAccount';
-} | {
-    type: 'registerAlias';
-    args: RegisterAliasArgs;
-} | {
-    type: 'releaseAlias';
-} | {
-    type: 'transferAlias';
-    args: TransferAliasArgs;
-} | {
-    type: 'putAliasOnSale';
-    args: PutAliasOnSaleArgs;
-} | {
-    type: 'cancelSale';
-} | {
-    type: 'buyAlias';
-    args: BuyAliasArgs;
-} | {
-    type: 'addChainLink';
-    args: AddChainLinkArgs;
-} | {
-    type: 'removeChainLink';
-    args: RemoveChainLinkArgs;
-} | {
-    type: 'setAccountMetadata';
-    args: SetAccountMetadataArgs;
-} | {
-    type: 'addSupportedChain';
-    args: AddSupportedChainArgs;
-} | {
-    type: 'removeSupportedChain';
-    args: RemoveSupportedChainArgs;
-} | {
-    type: 'dispatchAsLinkedAccount';
-    args: DispatchAsLinkedAccountArgs;
-} | {
-    type: 'registerPrivateLink';
-    args: RegisterPrivateLinkArgs;
-} | {
-    type: 'removePrivateLink';
-    args: RemovePrivateLinkArgs;
-} | {
-    type: 'revealPrivateLink';
-    args: RevealPrivateLinkArgs;
-} | {
-    type: 'dispatchAsPrivateLink';
-    args: DispatchAsPrivateLinkArgs;
-};
-
-/**
- * TypeScript types for events emitted by pallet-account-mapping.
- *
- * Conventions:
- *   - AccountId     → `string`  (SS58)
- *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
- *   - AliasOf<T>    → `string`  (bounded string, max configurable)
- *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
- *   - ExternalAddr  → `string`  (chain-specific address string)
- *   - BalanceOf<T>  → `bigint`
- *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
- *   - SignatureScheme → imported from pallet-extrinsics
- */
-
-/**
- * Emitted when a Substrate account is mapped to an Ethereum address.
- * Rust variant: `AccountMapped { account, address }`
- */
-type AccountMappedEvent = {
-    account: string;
-    /** 0x-prefixed 20-byte Ethereum address. */
-    address: string;
-};
-/**
- * Emitted when an existing account mapping is removed.
- * Rust variant: `AccountUnmapped { account, address }`
- */
-type AccountUnmappedEvent = {
-    account: string;
-    /** 0x-prefixed 20-byte Ethereum address. */
-    address: string;
-};
-/**
- * Emitted by `register_alias()` when a new alias is claimed.
- * Rust variant: `AliasRegistered { account, alias, evm_address }`
- */
-type AliasRegisteredEvent = {
-    account: string;
-    alias: string;
-    /** Optional EVM address linked at registration time. */
-    evmAddress: string | null;
-};
-/**
- * Emitted when an alias is released (burned / expired).
- * Rust variant: `AliasReleased { account, alias }`
- */
-type AliasReleasedEvent = {
-    account: string;
-    alias: string;
-};
-/**
- * Emitted by `transfer_alias()` when ownership changes hands.
- * Rust variant: `AliasTransferred { from, to, alias }`
- */
-type AliasTransferredEvent = {
-    from: string;
-    to: string;
-    alias: string;
-};
-/**
- * Emitted by `put_alias_on_sale()` when an alias is listed on the marketplace.
- * Rust variant: `AliasListedForSale { seller, alias, price, private }`
- */
-type AliasListedForSaleEvent = {
-    seller: string;
-    alias: string;
-    price: bigint;
-    /** Whether the listing is private (whitelist-only). */
-    private: boolean;
-};
-/**
- * Emitted when an alias listing is cancelled before a sale.
- * Rust variant: `AliasSaleCancelled { seller, alias }`
- */
-type AliasSaleCancelledEvent = {
-    seller: string;
-    alias: string;
-};
-/**
- * Emitted by `buy_alias()` when an alias is purchased.
- * Rust variant: `AliasSold { seller, buyer, alias, price }`
- */
-type AliasSoldEvent = {
-    seller: string;
-    buyer: string;
-    alias: string;
-    price: bigint;
-};
-/**
- * Emitted by `add_chain_link()` when an external address is linked.
- * Rust variant: `ChainLinkAdded { account, chain_id, address }`
- */
-type ChainLinkAddedEvent = {
-    account: string;
-    /** SLIP-0044 coin-type identifying the external chain. */
-    chainId: number;
-    /** Chain-specific address string. */
-    address: string;
-};
-/**
- * Emitted by `remove_chain_link()` when an external address link is removed.
- * Rust variant: `ChainLinkRemoved { account, chain_id }`
- */
-type ChainLinkRemovedEvent = {
-    account: string;
-    chainId: number;
-};
-/**
- * Emitted by `set_account_metadata()` when an account's metadata is updated.
- * Rust variant: `MetadataUpdated { account }`
- */
-type MetadataUpdatedEvent = {
-    account: string;
-};
-/**
- * Emitted by `add_supported_chain()` (governance) when a new chain type is whitelisted.
- * Rust variant: `SupportedChainAdded { chain_id, scheme }`
- */
-type SupportedChainAddedEvent = {
-    chainId: number;
-    scheme: SignatureScheme;
-};
-/**
- * Emitted by `remove_supported_chain()` (governance) when a chain type is removed.
- * Rust variant: `SupportedChainRemoved { chain_id }`
- */
-type SupportedChainRemovedEvent = {
-    chainId: number;
-};
-/**
- * Emitted after a successful `dispatch_as_linked_account()` call.
- * Rust variant: `ProxyCallExecuted { owner, chain_id, address }`
- */
-type ProxyCallExecutedEvent = {
-    owner: string;
-    chainId: number;
-    address: string;
-};
-/**
- * Emitted by `register_private_link()` when a private (commitment-based) chain link is added.
- * Rust variant: `PrivateChainLinkAdded { account, chain_id, commitment }`
- */
-type PrivateChainLinkAddedEvent = {
-    account: string;
-    chainId: number;
-    /** 0x-prefixed 32-byte Poseidon commitment of the private link. */
-    commitment: string;
-};
-/**
- * Emitted by `remove_private_link()` when a private chain link is removed.
- * Rust variant: `PrivateChainLinkRemoved { account, chain_id, commitment }`
- */
-type PrivateChainLinkRemovedEvent = {
-    account: string;
-    chainId: number;
-    /** 0x-prefixed 32-byte commitment. */
-    commitment: string;
-};
-/**
- * Emitted by `reveal_private_link()` when a private link is publicly revealed.
- * Rust variant: `PrivateChainLinkRevealed { account, chain_id, address }`
- */
-type PrivateChainLinkRevealedEvent = {
-    account: string;
-    chainId: number;
-    /** The now-revealed external address. */
-    address: string;
-};
-/**
- * Emitted after a successful `dispatch_as_private_link()` call.
- * Rust variant: `PrivateLinkDispatchExecuted { owner, commitment }`
+ * Call index 17 — `dispatch_as_private_link` (Signed origin, relayer)
+ * Dispatches a RuntimeCall on behalf of an account identified only by a private
+ * link commitment. A Groth16 ZK proof (PRIVATE_LINK circuit) authorises the
+ * dispatch without revealing the external address.
  */
-type PrivateLinkDispatchExecutedEvent = {
+type DispatchAsPrivateLinkArgs = {
+    /** AccountId on whose behalf to dispatch. */
     owner: string;
-    /** 0x-prefixed 32-byte commitment of the private link used. */
-    commitment: string;
+    /** 32-byte commitment identifying the private link (LE). */
+    commitment: number[];
+    /** Groth16 proof bytes (PRIVATE_LINK circuit). */
+    zkProof: number[];
+    /** SCALE-encoded RuntimeCall to dispatch. */
+    call: number[];
 };
-/** All events emitted by pallet-account-mapping as a discriminated union. */
-type AccountMappingEvent = {
-    type: 'AccountMapped';
-    data: AccountMappedEvent;
+/** All pallet-account-mapping calls as a discriminated union. */
+type AccountMappingCall = {
+    type: 'mapAccount';
 } | {
-    type: 'AccountUnmapped';
-    data: AccountUnmappedEvent;
+    type: 'unmapAccount';
 } | {
-    type: 'AliasRegistered';
-    data: AliasRegisteredEvent;
+    type: 'registerAlias';
+    args: RegisterAliasArgs;
 } | {
-    type: 'AliasReleased';
-    data: AliasReleasedEvent;
+    type: 'releaseAlias';
 } | {
-    type: 'AliasTransferred';
-    data: AliasTransferredEvent;
+    type: 'transferAlias';
+    args: TransferAliasArgs;
 } | {
-    type: 'AliasListedForSale';
-    data: AliasListedForSaleEvent;
+    type: 'putAliasOnSale';
+    args: PutAliasOnSaleArgs;
 } | {
-    type: 'AliasSaleCancelled';
-    data: AliasSaleCancelledEvent;
+    type: 'cancelSale';
 } | {
-    type: 'AliasSold';
-    data: AliasSoldEvent;
+    type: 'buyAlias';
+    args: BuyAliasArgs;
 } | {
-    type: 'ChainLinkAdded';
-    data: ChainLinkAddedEvent;
+    type: 'addChainLink';
+    args: AddChainLinkArgs;
 } | {
-    type: 'ChainLinkRemoved';
-    data: ChainLinkRemovedEvent;
+    type: 'removeChainLink';
+    args: RemoveChainLinkArgs;
 } | {
-    type: 'MetadataUpdated';
-    data: MetadataUpdatedEvent;
+    type: 'setAccountMetadata';
+    args: SetAccountMetadataArgs;
 } | {
-    type: 'SupportedChainAdded';
-    data: SupportedChainAddedEvent;
+    type: 'addSupportedChain';
+    args: AddSupportedChainArgs;
 } | {
-    type: 'SupportedChainRemoved';
-    data: SupportedChainRemovedEvent;
+    type: 'removeSupportedChain';
+    args: RemoveSupportedChainArgs;
 } | {
-    type: 'ProxyCallExecuted';
-    data: ProxyCallExecutedEvent;
+    type: 'dispatchAsLinkedAccount';
+    args: DispatchAsLinkedAccountArgs;
 } | {
-    type: 'PrivateChainLinkAdded';
-    data: PrivateChainLinkAddedEvent;
+    type: 'registerPrivateLink';
+    args: RegisterPrivateLinkArgs;
 } | {
-    type: 'PrivateChainLinkRemoved';
-    data: PrivateChainLinkRemovedEvent;
+    type: 'removePrivateLink';
+    args: RemovePrivateLinkArgs;
 } | {
-    type: 'PrivateChainLinkRevealed';
-    data: PrivateChainLinkRevealedEvent;
+    type: 'revealPrivateLink';
+    args: RevealPrivateLinkArgs;
 } | {
-    type: 'PrivateLinkDispatchExecuted';
-    data: PrivateLinkDispatchExecutedEvent;
+    type: 'dispatchAsPrivateLink';
+    args: DispatchAsPrivateLinkArgs;
 };
 
 /**
- * TypeScript types for pallet-shielded-pool extrinsics and supporting structures.
+ * TypeScript types for events emitted by pallet-account-mapping.
  *
  * Conventions:
- *   - Fixed/bounded byte arrays  → `number[]`  (SCALE-compatible)
- *   - Balances (u128)            → `bigint`
- *   - AccountId                  → `string`    (SS58 or 0x-prefixed 64-char hex)
- *   - Block numbers              → `number`
- *   - Optional fields            → `T | null`
- */
-/**
- * 32-byte SCALE-encoded value (commitment, nullifier, Merkle root, etc.).
- * Stored as little-endian Poseidon field elements on-chain.
- */
-type Bytes32 = number[];
-/**
- * Structured disclosure public signals — exactly 76 bytes:
- *   commitment[0..32] | revealed_value[32..40] | revealed_asset_id[40..44] | owner_hash[44..76]
+ *   - AccountId     → `string`  (SS58)
+ *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
+ *   - AliasOf<T>    → `string`  (bounded string, max configurable)
+ *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
+ *   - ExternalAddr  → `string`  (chain-specific address string)
+ *   - BalanceOf<T>  → `bigint`
+ *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
+ *   - SignatureScheme → imported from pallet-extrinsics
  */
-type DisclosurePublicSignals = number[];
+
 /**
- * A single auditor entry in an audit policy.
- * Maps to `Auditor<AccountId>` in Rust.
+ * Emitted when a Substrate account is mapped to an Ethereum address.
+ * Rust variant: `AccountMapped { account, address }`
  */
-type Auditor = {
-    /** SS58 or 0x-prefixed AccountId of the authorized auditor. */
+type AccountMappedEvent = {
     account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
 };
 /**
- * A condition that must be satisfied before disclosure is permitted.
- * Maps to `DisclosureCondition` in Rust. Max 10 conditions per policy.
+ * Emitted when an existing account mapping is removed.
+ * Rust variant: `AccountUnmapped { account, address }`
  */
-type DisclosureCondition = {
-    type: 'MinValue';
-    value: bigint;
-} | {
-    type: 'MaxValue';
-    value: bigint;
-} | {
-    type: 'AssetId';
-    assetId: number;
-} | {
-    type: 'RecipientIs';
-    recipient: string;
-} | {
-    type: 'Custom';
-    encoded: number[];
+type AccountUnmappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
 };
 /**
- * A single entry in a batch disclosure proof submission.
- * Maps to `BatchDisclosureSubmission<AccountId>` in Rust.
+ * Emitted by `register_alias()` when a new alias is claimed.
+ * Rust variant: `AliasRegistered { account, alias, evm_address }`
  */
-type BatchDisclosureSubmission = {
-    /** 32-byte commitment (LE). */
-    commitment: Bytes32;
-    /** Groth16 proof bytes — max 256 bytes. */
-    proof: number[];
-    /** 76-byte public signals: commitment(32) | value(8) | asset_id(4) | owner_hash(32). */
-    publicSignals: DisclosurePublicSignals;
-    /** Optional auditor AccountId. Null = voluntary disclosure. */
-    auditor: string | null;
+type AliasRegisteredEvent = {
+    account: string;
+    alias: string;
+    /** Optional EVM address linked at registration time. */
+    evmAddress: string | null;
 };
 /**
- * A single shield operation for use in `shield_batch`.
+ * Emitted when an alias is released (burned / expired).
+ * Rust variant: `AliasReleased { account, alias }`
  */
-type ShieldOperation = {
-    assetId: number;
-    amount: bigint;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo bytes — exactly 104 bytes. */
-    encryptedMemo: number[];
+type AliasReleasedEvent = {
+    account: string;
+    alias: string;
 };
 /**
- * Call index 0 — `shield` (Signed origin)
- * Deposits a public token amount into the shielded pool.
+ * Emitted by `transfer_alias()` when ownership changes hands.
+ * Rust variant: `AliasTransferred { from, to, alias }`
  */
-type ShieldArgs = {
-    assetId: number;
-    amount: bigint;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo — exactly 104 bytes. */
-    encryptedMemo: number[];
+type AliasTransferredEvent = {
+    from: string;
+    to: string;
+    alias: string;
 };
 /**
- * Call index 12 — `shield_batch` (Signed origin)
- * Deposits multiple notes in a single extrinsic — max 20 operations.
+ * Emitted by `put_alias_on_sale()` when an alias is listed on the marketplace.
+ * Rust variant: `AliasListedForSale { seller, alias, price, private }`
  */
-type ShieldBatchArgs = {
-    operations: ShieldOperation[];
-};
-/** Input note consumed by a private transfer (SCALE wire format). */
-type RawTransferInput = {
-    /** 32-byte Poseidon nullifier (LE). */
-    nullifier: Bytes32;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-};
-/** Output note created by a private transfer (SCALE wire format). */
-type RawTransferOutput = {
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo — exactly 104 bytes. */
-    memo: number[];
+type AliasListedForSaleEvent = {
+    seller: string;
+    alias: string;
+    price: bigint;
+    /** Whether the listing is private (whitelist-only). */
+    private: boolean;
 };
 /**
- * Call index 1 — `private_transfer` (Signed origin)
- * Transfers value between notes without revealing sender, recipient or amount.
- * Accepts 1–2 inputs and 1–2 outputs; total input value must equal total output value.
+ * Emitted when an alias listing is cancelled before a sale.
+ * Rust variant: `AliasSaleCancelled { seller, alias }`
  */
-type PrivateTransferArgs = {
-    /** Groth16 proof bytes — max 512 bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: Bytes32;
-    nullifiers: RawTransferInput[];
-    outputs: RawTransferOutput[];
-    encryptedMemos: number[][];
+type AliasSaleCancelledEvent = {
+    seller: string;
+    alias: string;
 };
 /**
- * Call index 2 — `unshield` (Signed origin)
- * Withdraws a note from the pool to a public account.
+ * Emitted by `buy_alias()` when an alias is purchased.
+ * Rust variant: `AliasSold { seller, buyer, alias, price }`
  */
-type UnshieldArgs = {
-    /** Groth16 proof bytes — max 512 bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: Bytes32;
-    /** 32-byte nullifier of the spent note (LE). */
-    nullifier: Bytes32;
-    assetId: number;
-    amount: bigint;
-    /** SS58 or 0x-prefixed AccountId of the recipient. */
-    recipient: string;
+type AliasSoldEvent = {
+    seller: string;
+    buyer: string;
+    alias: string;
+    price: bigint;
 };
 /**
- * Call index 4 — `set_audit_policy` (Signed origin)
- * Registers or replaces the caller's audit policy for selective disclosure.
- */
-type SetAuditPolicyArgs = {
-    /** Up to 10 authorized auditors. */
-    auditors: Auditor[];
-    /** Up to 10 disclosure conditions. */
-    conditions: DisclosureCondition[];
-    /** Minimum blocks between disclosures to the same auditor. Null = no limit. */
-    maxFrequency: number | null;
-    /** Block after which the policy expires. Null = no expiry. */
-    validUntil: number | null;
+ * Emitted by `add_chain_link()` when an external address is linked.
+ * Rust variant: `ChainLinkAdded { account, chain_id, address }`
+ */
+type ChainLinkAddedEvent = {
+    account: string;
+    /** SLIP-0044 coin-type identifying the external chain. */
+    chainId: number;
+    /** Chain-specific address string. */
+    address: string;
 };
 /**
- * Call index 5 — `request_disclosure` (Signed origin)
- * Auditor requests selective disclosure from a target account.
+ * Emitted by `remove_chain_link()` when an external address link is removed.
+ * Rust variant: `ChainLinkRemoved { account, chain_id }`
  */
-type RequestDisclosureArgs = {
-    /** AccountId of the disclosure target. */
-    target: string;
-    /** Human-readable request reason — max 256 bytes UTF-8. */
-    reason: string;
+type ChainLinkRemovedEvent = {
+    account: string;
+    chainId: number;
 };
 /**
- * Call index 6 — `disclose` (Signed origin)
- * Submit a Groth16 disclosure proof for a commitment.
+ * Emitted by `set_account_metadata()` when an account's metadata is updated.
+ * Rust variant: `MetadataUpdated { account }`
  */
-type DiscloseArgs = {
-    /** 32-byte note commitment to disclose (LE). */
-    commitment: Bytes32;
-    /** Groth16 proof bytes — max 256 bytes. */
-    proofBytes: number[];
-    /** 76-byte public signals: commitment(32) | value(8) | asset_id(4) | owner_hash(32). */
-    publicSignals: DisclosurePublicSignals;
-    /** Target auditor AccountId. Null = voluntary public disclosure. */
-    auditor: string | null;
+type MetadataUpdatedEvent = {
+    account: string;
 };
 /**
- * Call index 7 — `reject_disclosure` (Signed origin)
- * Disclosure target rejects a pending request from an auditor.
+ * Emitted by `add_supported_chain()` (governance) when a new chain type is whitelisted.
+ * Rust variant: `SupportedChainAdded { chain_id, scheme }`
  */
-type RejectDisclosureArgs = {
-    /** AccountId of the auditor whose request is rejected. */
-    auditor: string;
-    /** Rejection reason — max 256 bytes UTF-8. */
-    reason: string;
+type SupportedChainAddedEvent = {
+    chainId: number;
+    scheme: SignatureScheme;
 };
 /**
- * Call index 13 — `batch_submit_disclosure_proofs` (Signed origin)
- * Submit up to 10 disclosure proofs in one extrinsic.
+ * Emitted by `remove_supported_chain()` (governance) when a chain type is removed.
+ * Rust variant: `SupportedChainRemoved { chain_id }`
  */
-type BatchSubmitDisclosureProofsArgs = {
-    submissions: BatchDisclosureSubmission[];
+type SupportedChainRemovedEvent = {
+    chainId: number;
 };
 /**
- * Call index 9 — `register_asset` (Root origin)
- * Registers a new asset in the shielded pool registry.
+ * Emitted after a successful `dispatch_as_linked_account()` call.
+ * Rust variant: `ProxyCallExecuted { owner, chain_id, address }`
  */
-type RegisterAssetArgs = {
-    /** Asset name — max 64 bytes UTF-8. */
-    name: string;
-    /** Asset ticker symbol, e.g. "USDT" — max 16 bytes UTF-8. */
-    symbol: string;
-    /** Token decimal precision (e.g. 18 for ORB, 6 for USDT). */
-    decimals: number;
-    /** 20-byte EVM contract address for ERC-20 assets. Null = native asset. */
-    contractAddress: number[] | null;
+type ProxyCallExecutedEvent = {
+    owner: string;
+    chainId: number;
+    address: string;
 };
 /**
- * Call index 10 — `verify_asset` (Root origin)
- * Marks a registered asset as verified, enabling shielding.
+ * Emitted by `register_private_link()` when a private (commitment-based) chain link is added.
+ * Rust variant: `PrivateChainLinkAdded { account, chain_id, commitment }`
  */
-type VerifyAssetArgs = {
-    assetId: number;
+type PrivateChainLinkAddedEvent = {
+    account: string;
+    chainId: number;
+    /** 0x-prefixed 32-byte Poseidon commitment of the private link. */
+    commitment: string;
 };
 /**
- * Call index 11 — `unverify_asset` (Root origin)
- * Removes the verified status from an asset, disabling new shield operations.
+ * Emitted by `remove_private_link()` when a private chain link is removed.
+ * Rust variant: `PrivateChainLinkRemoved { account, chain_id, commitment }`
  */
-type UnverifyAssetArgs = {
-    assetId: number;
+type PrivateChainLinkRemovedEvent = {
+    account: string;
+    chainId: number;
+    /** 0x-prefixed 32-byte commitment. */
+    commitment: string;
 };
 /**
- * Call index 14 — `prune_expired_request` (Signed origin)
- * Cleans up a disclosure request that has passed its expiration block.
+ * Emitted by `reveal_private_link()` when a private link is publicly revealed.
+ * Rust variant: `PrivateChainLinkRevealed { account, chain_id, address }`
  */
-type PruneExpiredRequestArgs = {
-    /** AccountId of the disclosure target. */
-    target: string;
-    /** AccountId of the auditor. */
-    auditor: string;
+type PrivateChainLinkRevealedEvent = {
+    account: string;
+    chainId: number;
+    /** The now-revealed external address. */
+    address: string;
 };
 /**
- * Call index 15 — `revoke_disclosure_record` (Signed origin)
- * Allows the note owner to revoke a previously submitted disclosure record.
+ * Emitted after a successful `dispatch_as_private_link()` call.
+ * Rust variant: `PrivateLinkDispatchExecuted { owner, commitment }`
  */
-type RevokeDisclosureRecordArgs = {
-    /** 32-byte commitment whose disclosure record should be revoked (LE). */
-    commitment: Bytes32;
+type PrivateLinkDispatchExecutedEvent = {
+    owner: string;
+    /** 0x-prefixed 32-byte commitment of the private link used. */
+    commitment: string;
 };
-/** All pallet-shielded-pool calls as a discriminated union. */
-type ShieldedPoolCall = {
-    type: 'shield';
-    args: ShieldArgs;
+/** All events emitted by pallet-account-mapping as a discriminated union. */
+type AccountMappingEvent = {
+    type: 'AccountMapped';
+    data: AccountMappedEvent;
 } | {
-    type: 'shieldBatch';
-    args: ShieldBatchArgs;
+    type: 'AccountUnmapped';
+    data: AccountUnmappedEvent;
 } | {
-    type: 'privateTransfer';
-    args: PrivateTransferArgs;
+    type: 'AliasRegistered';
+    data: AliasRegisteredEvent;
 } | {
-    type: 'unshield';
-    args: UnshieldArgs;
+    type: 'AliasReleased';
+    data: AliasReleasedEvent;
 } | {
-    type: 'setAuditPolicy';
-    args: SetAuditPolicyArgs;
+    type: 'AliasTransferred';
+    data: AliasTransferredEvent;
 } | {
-    type: 'requestDisclosure';
-    args: RequestDisclosureArgs;
+    type: 'AliasListedForSale';
+    data: AliasListedForSaleEvent;
 } | {
-    type: 'disclose';
-    args: DiscloseArgs;
+    type: 'AliasSaleCancelled';
+    data: AliasSaleCancelledEvent;
 } | {
-    type: 'rejectDisclosure';
-    args: RejectDisclosureArgs;
+    type: 'AliasSold';
+    data: AliasSoldEvent;
 } | {
-    type: 'batchSubmitDisclosureProofs';
-    args: BatchSubmitDisclosureProofsArgs;
+    type: 'ChainLinkAdded';
+    data: ChainLinkAddedEvent;
 } | {
-    type: 'registerAsset';
-    args: RegisterAssetArgs;
+    type: 'ChainLinkRemoved';
+    data: ChainLinkRemovedEvent;
 } | {
-    type: 'verifyAsset';
-    args: VerifyAssetArgs;
+    type: 'MetadataUpdated';
+    data: MetadataUpdatedEvent;
 } | {
-    type: 'unverifyAsset';
-    args: UnverifyAssetArgs;
+    type: 'SupportedChainAdded';
+    data: SupportedChainAddedEvent;
 } | {
-    type: 'pruneExpiredRequest';
-    args: PruneExpiredRequestArgs;
+    type: 'SupportedChainRemoved';
+    data: SupportedChainRemovedEvent;
 } | {
-    type: 'revokeDisclosureRecord';
-    args: RevokeDisclosureRecordArgs;
+    type: 'ProxyCallExecuted';
+    data: ProxyCallExecutedEvent;
+} | {
+    type: 'PrivateChainLinkAdded';
+    data: PrivateChainLinkAddedEvent;
+} | {
+    type: 'PrivateChainLinkRemoved';
+    data: PrivateChainLinkRemovedEvent;
+} | {
+    type: 'PrivateChainLinkRevealed';
+    data: PrivateChainLinkRevealedEvent;
+} | {
+    type: 'PrivateLinkDispatchExecuted';
+    data: PrivateLinkDispatchExecutedEvent;
 };
 
 /**
@@ -3138,7 +4248,73 @@ declare function truncateMiddle(str: string, start: number, end: number): string
 /** Shorten a hash for compact inline display. */
 declare function shortHash(h: string, start?: number, end?: number): string;
 
-declare function toTxResult(payload: TxFinalizedPayload): TxResult;
+/**
+ * Converts a Uint8Array or number[] to a 0x-prefixed lowercase hex string.
+ */
+declare function toHex(bytes: Uint8Array | number[]): string;
+/**
+ * Decodes a hex string (with or without 0x prefix) to Uint8Array.
+ */
+declare function fromHex(hex: string): Uint8Array;
+/**
+ * Ensures a hex string has the 0x prefix.
+ */
+declare function ensureHexPrefix(hex: string): string;
+/**
+ * Converts a 0x-prefixed hex string (as returned by JSON-RPC) to a number.
+ */
+declare function hexToNumber(hex: string): number;
+/**
+ * Converts a 0x-prefixed hex string (as returned by JSON-RPC) to a bigint.
+ */
+declare function hexToBigint(hex: string): bigint;
+
+declare function toBase64(buf: ArrayBuffer | Uint8Array): string;
+declare function fromBase64(b64: string): Uint8Array;
+
+/**
+ * Derive the stealth owner public key (Ax) for a recipient note.
+ *
+ *   stealthScalar = HKDF(sharedSecret, salt=ownerPk_LE, info="orbinum-stealth-v1") % suborder
+ *   stealthPoint  = stealthScalar × Base8 + ownerPkPoint
+ *   return stealthPoint[0]  (Ax coordinate)
+ *
+ * The sender calls this with sharedSecret from ECDH (EncryptedMemo.encrypt side).
+ * The recipient calls this with sharedSecret from EncryptedMemo.extractSharedSecret.
+ *
+ * @param sharedSecret   32-byte LE Ax of the ECDH shared point.
+ * @param ownerPkBigint  Recipient's global ownerPk (BJJ Ax as bigint).
+ * @param ownerPkPoint   Recipient's global BJJ point [Ax, Ay]. Must match ownerPkBigint.
+ * @returns Stealth owner public key (Ax bigint). Used as ownerPk in the note commitment.
+ */
+declare function deriveStealthOwnerPk(sharedSecret: Uint8Array, ownerPkBigint: bigint, ownerPkPoint: [bigint, bigint]): bigint;
+/**
+ * Derive the stealth spending key for a received note.
+ *
+ *   stealthScalar = HKDF(sharedSecret, salt=ownerPk_LE, info="orbinum-stealth-v1") % suborder
+ *   stealthSk     = (stealthScalar + spendingKey) % BABYJUB_SUBORDER  (|| 1n)
+ *
+ * Security property: BabyPbk(stealthSk).Ax == deriveStealthOwnerPk(sharedSecret, ownerPkBigint, ownerPkPoint)
+ * This means the ZK circuit validates ownership correctly without modification.
+ *
+ * @param sharedSecret  32-byte LE Ax of the ECDH shared point.
+ * @param ownerPkBigint Recipient's global ownerPk (BJJ Ax as bigint) — used as HKDF salt.
+ * @param spendingKey   Recipient's global spending key scalar.
+ * @returns Stealth spending key — use as ZkNote.spendingKey for received notes.
+ */
+declare function deriveStealthSk(sharedSecret: Uint8Array, ownerPkBigint: bigint, spendingKey: bigint): bigint;
+
+/**
+ * Recover the BabyJubJub [Ax, Ay] point from an Ax coordinate.
+ *
+ * Uses the standard twisted Edwards curve equation: a*x² + y² = 1 + d*x²*y²
+ * with a=168700, d=168696 (same as @zk-kit/baby-jubjub). Solving for y²:
+ *   y² = (1 - a*x²) / (1 - d*x²)  mod P
+ *
+ * The square root is computed via Tonelli-Shanks (required since P ≡ 1 mod 4).
+ * Returns the point with the canonical (smaller) y, or null if Ax is not on the curve.
+ */
+declare function recoverOwnerPkPoint(ax: bigint): [bigint, bigint] | null;
 
 /**
  * Serialises a bigint as a 32-byte little-endian Uint8Array.
@@ -3321,38 +4497,30 @@ interface DecodedUnshieldArgs {
     amount: string;
     recipient: string;
 }
-interface DecodedSetAuditPolicyArgs {
-    auditors: string[];
-    conditions: unknown;
-    max_frequency: number;
-}
 interface DecodedRequestDisclosureArgs {
     target: string;
-    reason: string;
-    evidence?: string;
-}
-interface DecodedApproveDisclosureArgs {
-    auditor: string;
     commitment: string;
-    proof: string;
-    public_signals: string[];
-    extra_data: unknown;
+    required_fields: {
+        value: boolean;
+        asset_id: boolean;
+        owner: boolean;
+    };
+    reason: string;
+    auditor_bjj_pk_x: string;
+    auditor_bjj_pk_y: string;
 }
 interface DecodedRejectDisclosureArgs {
     auditor: string;
+    commitment: string;
     reason: string;
 }
 interface DecodedSubmitDisclosureArgs {
     commitment: string;
-    proof: string;
-    public_signals: string[];
-    partial_data: unknown;
+    proof_bytes: string;
+    /** 256-byte ECDH public signals (hex). */
+    public_signals: string;
     auditor: string;
 }
-interface DecodedBatchSubmitDisclosureArgs {
-    count: number;
-    submissions: DecodedSubmitDisclosureArgs[];
-}
 interface DecodedTransferArgs {
     dest: string;
     value: string;
@@ -3435,8 +4603,10 @@ interface ShieldedEventData {
     memo: string;
     index: number;
 }
-interface PrivateTransferEventData {
+interface NullifiersSpentEventData {
     nullifiers: string[];
+}
+interface CommitmentsInsertedEventData {
     commitments: string[];
     memos: string[];
     indices: number[];
@@ -3451,25 +4621,22 @@ interface MerkleRootUpdatedData {
     new_root: string;
     size: number;
 }
-interface AuditPolicySetData {
-    who: string;
-    auditors: string[];
-    version: number;
-}
 interface DisclosureRequestedData {
-    requestor: string;
     target: string;
-    commitment: string;
-    reason?: string;
-}
-interface DisclosureApprovedData {
-    who: string;
-    commitment: string;
     auditor: string;
+    commitment: string;
+    required_fields: {
+        value: boolean;
+        asset_id: boolean;
+        owner: boolean;
+    };
+    auditor_bjj_pk_x: string;
+    auditor_bjj_pk_y: string;
 }
 interface DisclosureRejectedData {
-    who: string;
+    target: string;
     auditor: string;
+    commitment: string;
     reason: string;
 }
 interface DisclosureSubmittedData {
@@ -3483,13 +4650,6 @@ interface DisclosureVerifiedData {
     commitment: string;
     verified: boolean;
 }
-interface AuditTrailRecordedData {
-    account: string;
-    auditor: string;
-    commitment: string;
-    trail_hash: string;
-    trail_id: string;
-}
 interface TransferEventData {
     from: string;
     to: string;
@@ -3560,4 +4720,4 @@ interface ExtrinsicFailedData {
     dispatch_info: DispatchInfo;
 }
 
-export { type AccountListing, type AccountMappedData, type AccountMappedEvent, type AccountMappingCall, type AccountMappingEvent, AccountMappingModule, AccountMappingPrecompile, type AccountMetadata, type AccountUnmappedEvent, type ActiveVersionSetEvent, type AddChainLinkArgs, type AddChainLinkParams, type AddSupportedChainArgs, type AliasFullIdentity, type AliasInfo, type AliasListedForSaleEvent, type AliasOnSaleData, type AliasRegisteredData, type AliasRegisteredEvent, type AliasReleasedEvent, type AliasSaleCancelledEvent, type AliasSoldData, type AliasSoldEvent, type AliasTransferredData, type AliasTransferredEvent, type AssetRegisteredEvent, type AssetUnverifiedEvent, type AssetVerifiedEvent, type AuditPolicySetData, type AuditPolicySetEvent, type AuditTrailRecordedData, type Auditor, type BatchDisclosureSubmission, type BatchRegisterVerificationKeysArgs, type BatchSubmitDisclosureProofsArgs, type BatchVerificationKeysRegisteredEvent, type BlockInfo, type BuyAliasArgs, type Bytes32, type ChainInfo, type ChainLink, type ChainLinkAddedEvent, type ChainLinkRemovedEvent, CircuitId, CircuitId as CircuitIdType, type ClientProviderConfig, type ConnectionStatus, CryptoPrecompiles, type DecodedAddChainLinkArgs, type DecodedApproveDisclosureArgs, type DecodedBatchArgs, type DecodedBatchSubmitDisclosureArgs, type DecodedDispatchAsPrivateLinkArgs, type DecodedEthereumTransactArgs, type DecodedEvmCallArgs, type DecodedPrecompile, type DecodedPrivateTransferArgs, type DecodedPutAliasForSaleArgs, type DecodedRegisterAliasArgs, type DecodedRejectDisclosureArgs, type DecodedRemarkArgs, type DecodedRequestDisclosureArgs, type DecodedRevealPrivateLinkArgs, type DecodedSetAccountMetadataArgs, type DecodedSetAuditPolicyArgs, type DecodedShieldArgs, type DecodedShieldBatchArgs, type DecodedShieldBatchOperation, type DecodedSubmitDisclosureArgs, type DecodedSudoArgs, type DecodedTransferAllArgs, type DecodedTransferArgs, type DecodedTransferKeepAliveArgs, type DecodedUnshieldArgs, type DecryptedMemo, type DiscloseArgs, type DisclosedEvent, type DisclosureApprovedData, type DisclosureCondition, type DisclosurePublicSignals, type DisclosureRecordRevokedEvent, type DisclosureRejectedData, type DisclosureRejectedEvent, type DisclosureRequestExpiredEvent, type DisclosureRequestedData, type DisclosureRequestedEvent, type DisclosureSubmittedData, type DisclosureVerifiedData, type DispatchAsLinkedAccountArgs, type DispatchAsLinkedParams, type DispatchAsPrivateLinkArgs, type DispatchError, type DispatchInfo, type DynamicBuilder, EncryptedMemo, type EndowedEventData, type EthereumExecutedData, type EventData, type EventPhase, type EventRecord, type EvmAddressInfo, type EvmBlock, EvmClient, type EvmExecutedData, type EvmExitReason, EvmExplorer, type EvmLog, type EvmSigner, type EvmTransaction, type EvmTxRequest, type EvmTxSummary, type ExtrinsicDecoder, type ExtrinsicFailedData, type ExtrinsicSuccessData, type FormatOptions, type IndexedBlock, type IndexedEvmTx, type IndexedExtrinsic, IndexerClient, type IndexerClientConfig, type IndexerStats, KNOWN_PRECOMPILES, type KnownPrecompileInfo, type ListingInfo, type MerkleRoot, type MerkleRootUpdatedData, type MerkleRootUpdatedEvent, type MerkleTreeInfo, type MetadataUpdatedEvent, NoteBuilder, type NoteInput, type NullifierStatusResult, OrbinumClient, type OrbinumClientConfig, OrbinumClientProvider, PRECOMPILE_ADDR, type PaginatedResult, PrivacyKeyManager, type PrivacyMerkleProof, PrivacyModule, type PrivateChainLinkAddedEvent, type PrivateChainLinkRemovedEvent, type PrivateChainLinkRevealedEvent, type PrivateLink, type PrivateLinkDispatchExecutedEvent, type PrivateTransfer, type PrivateTransferArgs, type PrivateTransferEvent, type PrivateTransferEventData, type PrivateTransferInput, type PrivateTransferOutput, type PrivateTransferParams, type ProofVerificationFailedEvent, type ProofVerifiedEvent, type ProxyCallExecutedEvent, type PruneExpiredRequestArgs, type PutAliasOnSaleArgs, type PutOnSaleParams, type RawBlock, type RawBlockHeader, type RawTransferInput, type RawTransferOutput, type RegisterAliasArgs, type RegisterAssetArgs, type RegisterPrivateLinkArgs, type RegisterVerificationKeyArgs, type RejectDisclosureArgs, type RemoveChainLinkArgs, type RemovePrivateLinkArgs, type RemoveSupportedChainArgs, type RemoveVerificationKeyArgs, type RequestDisclosureArgs, type ReservedEventData, type ResolvedAlias, type RevealPrivateLinkArgs, type RevokeDisclosureRecordArgs, type RpcV2MerkleProof, type RpcV2NullifierStatus, type RpcV2PoolAssetBalance, type RpcV2PoolStats, SLIP0044_NAMESPACE, type ScanCommitment, type SetAccountMetadataArgs, type SetActiveVersionArgs, type SetAuditPolicyArgs, type SetMetadataParams, type ShieldArgs, type ShieldBatchArgs, type ShieldBatchItem, type ShieldBatchParams, type ShieldOperation, type ShieldParams, type ShieldResult, type ShieldedAddressEvent, type ShieldedCommitment, type ShieldedEvent, type ShieldedEventData, type ShieldedPoolCall, type ShieldedPoolEvent, ShieldedPoolModule, ShieldedPoolPrecompile, SignatureScheme, type SpentNullifier, type StatusChangeEvent, type StatusListener, SubstrateClient, type SupportedChain, type SupportedChainAddedEvent, type SupportedChainRemovedEvent, type SystemHealth, type TokenInfo, type TokenTransfer, type TransferAliasArgs, type TransferEventData, type TxResult, type Unshield, type UnshieldArgs, type UnshieldParams, type UnshieldedEvent, type UnshieldedEventData, type UnverifyAssetArgs, type VerificationKeyRegisteredEvent, type VerificationKeyRemovedEvent, type VerifyAssetArgs, type VerifyProofArgs, type VkEntry, type ZkNote, type ZkVerifierCall, type ZkVerifierCircuitVersionInfo, type ZkVerifierEvent, type ZkVerifierHistoricalVersion, ZkVerifierModule, type ZkVerifierVersionStats, type ZkVerifierVkHash, accountIdHexToSs58, addressToAccountIdHex, bigintTo32Be, bigintTo32Le, bigintTo32LeArr, bytesToBigintLE, computePathIndices, decodePrecompileCalldata, decryptJson, deriveOwnerPk, deriveSpendingKeyFromSignature, deriveSpendingKeyMessage, deriveVaultKey, deriveViewingKey, encryptJson, ensureHexPrefix, evmAddressToAccountId, evmToImplicitSubstrate, evmToMappedAccountHex, evmToSubstrate, formatBalance, formatORB, fromBase64, fromHex, getPrecompileLabel, hexToBigint, hexToNumber, implicitSubstrateToEvm, isEvmAddress, isImplicitEvmAccount, isSs58, isSubstrateAddress, isUnifiedAddress, leHexToBigint, mapExtrinsicArgs, mapZkEventData, normalizeEvmAddress, shortHash, substrateSs58ToAccountIdHex, substrateToEvm, toBase64, toHex, toTxResult, truncateMiddle, tryDecryptNote, vaultReplacer, vaultReviver };
+export { type AccountListing, type AccountMappedData, type AccountMappedEvent, type AccountMappingCall, type AccountMappingEvent, AccountMappingModule, AccountMappingPrecompile, type AccountMetadata, type AccountUnmappedEvent, type ActiveVersionSetEvent, type AddChainLinkArgs, type AddChainLinkParams, type AddSupportedChainArgs, type AliasFullIdentity, type AliasInfo, type AliasListedForSaleEvent, type AliasOnSaleData, type AliasRegisteredData, type AliasRegisteredEvent, type AliasReleasedEvent, type AliasSaleCancelledEvent, type AliasSoldData, type AliasSoldEvent, type AliasTransferredData, type AliasTransferredEvent, type AssetRegisteredEvent, type AssetUnverifiedEvent, type AssetVerifiedEvent, type AuditPolicySetEvent, type Auditor, BABYJUB_SUBORDER, BN254_R, type BatchRegisterVerificationKeysArgs, type BatchVerificationKeysRegisteredEvent, type BlockInfo, type BuyAliasArgs, type Bytes32, type ChainInfo, type ChainLink, type ChainLinkAddedEvent, type ChainLinkRemovedEvent, CircuitId, CircuitId as CircuitIdType, type ClaimShieldedFeesParams, type ClientProviderConfig, type CommitmentsInsertedEvent, type CommitmentsInsertedEventData, type ConnectionStatus, CryptoPrecompiles, type DecodedAddChainLinkArgs, type DecodedBatchArgs, type DecodedDispatchAsPrivateLinkArgs, type DecodedEthereumTransactArgs, type DecodedEvmCallArgs, type DecodedPrecompile, type DecodedPrivateTransferArgs, type DecodedPutAliasForSaleArgs, type DecodedRegisterAliasArgs, type DecodedRejectDisclosureArgs, type DecodedRemarkArgs, type DecodedRequestDisclosureArgs, type DecodedRevealPrivateLinkArgs, type DecodedSetAccountMetadataArgs, type DecodedShieldArgs, type DecodedShieldBatchArgs, type DecodedShieldBatchOperation, type DecodedSubmitDisclosureArgs, type DecodedSudoArgs, type DecodedTransferAllArgs, type DecodedTransferArgs, type DecodedTransferKeepAliveArgs, type DecodedUnshieldArgs, type DecryptedMemo, type DiscloseArgs, type DiscloseParams, type DisclosedEvent, type DisclosureCondition, type DisclosureFieldMask, type DisclosurePublicSignals, type DisclosureRecordRevokedEvent, type DisclosureRejectedData, type DisclosureRejectedEvent, type DisclosureRequestExpiredEvent, type DisclosureRequestedData, type DisclosureRequestedEvent, type DisclosureSubmittedData, type DisclosureVerifiedData, type DispatchAsLinkedAccountArgs, type DispatchAsLinkedParams, type DispatchAsPrivateLinkArgs, type DispatchError, type DispatchInfo, type DynamicBuilder, ENCRYPTED_MEMO_SIZE, type EncryptedDisclosureSignals, EncryptedMemo, type EncryptedNoteRecord, type EndowedEventData, type EthereumExecutedData, type EventData, type EventPhase, type EventRecord, type EvmAddressInfo, type EvmBlock, EvmClient, type EvmExecutedData, type EvmExitReason, EvmExplorer, type EvmLog, type EvmSigner, type EvmTransaction, type EvmTxRequest, type EvmTxSummary, type ExtrinsicDecoder, type ExtrinsicFailedData, type ExtrinsicSuccessData, type FeeClaimProofInputs, type FormatOptions, type IndexedBlock, type IndexedEvmTx, type IndexedExtrinsic, IndexerClient, type IndexerClientConfig, type IndexerStats, KNOWN_PRECOMPILES, type KnownPrecompileInfo, type ListingInfo, type MerkleRoot, type MerkleRootUpdatedData, type MerkleRootUpdatedEvent, type MerkleTreeInfo, type MetadataUpdatedEvent, NoteBuilder, type NoteInput, type NoteStatusUpdate, type NullifierStatusResult, type NullifiersSpentEvent, type NullifiersSpentEventData, OrbinumClient, type OrbinumClientConfig, OrbinumClientProvider, PRECOMPILE_ADDR, type PaginatedResult, PrivacyKeyManager, type PrivacyMerkleProof, PrivacyModule, type PrivateChainLinkAddedEvent, type PrivateChainLinkRemovedEvent, type PrivateChainLinkRevealedEvent, type PrivateLink, type PrivateLinkDispatchExecutedEvent, type PrivateTransferArgs, type PrivateTransferInput, type PrivateTransferOutput, type PrivateTransferParams, type PrivateTransferProofInputs, type PrivateTransferTimestamp, type ProofVerificationFailedEvent, type ProofVerifiedEvent, type ProxyCallExecutedEvent, type PruneExpiredRequestArgs, type PruneExpiredRequestParams, type PutAliasOnSaleArgs, type PutOnSaleParams, type RawBlock, type RawBlockHeader, type RawTransferInput, type RawTransferOutput, type RegisterAliasArgs, type RegisterAssetArgs, type RegisterPrivateLinkArgs, type RegisterVerificationKeyArgs, type RejectDisclosureArgs, type RejectDisclosureParams, type RelayerInfo, RelayerStatusModule, type RemoveChainLinkArgs, type RemovePrivateLinkArgs, type RemoveSupportedChainArgs, type RemoveVerificationKeyArgs, type RequestDisclosureArgs, type RequestDisclosureParams, type ReservedEventData, type ResolvedAlias, type RevealPrivateLinkArgs, type RevokeDisclosureRecordArgs, type RpcV2MerkleProof, type RpcV2NullifierStatus, type RpcV2PoolAssetBalance, type RpcV2PoolStats, SLIP0044_NAMESPACE, type ScanCommitment, type SetAccountMetadataArgs, type SetActiveVersionArgs, type SetMetadataParams, type ShieldArgs, type ShieldBatchArgs, type ShieldBatchItem, type ShieldBatchParams, type ShieldOperation, type ShieldParams, type ShieldedAddressEvent, type ShieldedCommitment, type ShieldedEvent, type ShieldedEventData, type ShieldedPoolCall, type ShieldedPoolEvent, ShieldedPoolModule, ShieldedPoolPrecompile, SignatureScheme, type SpentNullifier, type StatusChangeEvent, type StatusListener, type StealthScanHint, SubstrateClient, type SupportedChain, type SupportedChainAddedEvent, type SupportedChainRemovedEvent, type SystemHealth, type TokenInfo, type TokenTransfer, type TransferAliasArgs, type TransferEventData, type TransferInputNote, type TransferOutputNote, type TxResult, type UnsafeTxOptions, type Unshield, type UnshieldArgs, type UnshieldParams, type UnshieldProofInputs, type UnshieldedEvent, type UnshieldedEventData, type UnverifyAssetArgs, VaultLockedError, type VerificationKeyRegisteredEvent, type VerificationKeyRemovedEvent, type VerifyAssetArgs, type VerifyProofArgs, type VkEntry, type ZkNote, type ZkVerifierCall, type ZkVerifierCircuitVersionInfo, type ZkVerifierEvent, type ZkVerifierHistoricalVersion, ZkVerifierModule, type ZkVerifierVersionStats, type ZkVerifierVkHash, accountIdHexToSs58, addressToAccountIdHex, applyNoteStatus, bigintTo32Be, bigintTo32Le, bigintTo32LeArr, buildDisclosurePublicSignals, buildDummyTransferInput, bytesToBigintLE, computeNullifier, computePathIndices, decodePrecompileCalldata, decryptDisclosureSignals, decryptJson, decryptNoteRecord, deriveBabyJubjubKeypair, deriveMasterKeyBytes, deriveOwnerPk, deriveSpendingKeyFromSignature, deriveSpendingKeyMessage, deriveStealthOwnerPk, deriveStealthSk, deriveVaultKey, deriveViewingPublicKey, deriveViewingSecretKey, encryptJson, encryptNote, ensureHexPrefix, evmAddressToAccountId, evmToImplicitSubstrate, evmToMappedAccountHex, evmToSubstrate, formatBalance, formatORB, fromBase64, fromHex, generateFeeClaimProof, generateTransferProof, generateUnshieldProof, getPrecompileLabel, hexToBigint, hexToNumber, implicitSubstrateToEvm, isEvmAddress, isImplicitEvmAccount, isSs58, isSubstrateAddress, isUnifiedAddress, leHexToBigint, mapExtrinsicArgs, mapZkEventData, normalizeEvmAddress, randomBlinding, recoverOwnerPkPoint, selectNotes, shortHash, substrateSs58ToAccountIdHex, substrateToEvm, toBase64, toHex, toTxResult, truncateMiddle, tryDecryptNote, tryDecryptNoteVerbose, vaultReplacer, vaultReviver };