@orbinum/sdk 0.4.2 → 0.6.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 } from '@orbinum/proof-generator';
+export { ArtifactProvider, CircuitType, ProofResult, WebArtifactProvider } 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;
 }
 
@@ -384,6 +496,8 @@ interface ShieldedCommitment {
     leafIndex: number;
     /** Asset ID as decimal string (e.g. "0"). */
     assetId: string;
+    /** Origin of the commitment: direct shield, output of private transfer, or change from unshield. */
+    source: 'shield' | 'transfer' | 'unshield';
     /** SS58 or 0x-prefixed depositor address, null if not tracked. */
     sender: string | null;
     /** 0x-prefixed encrypted memo hex, null if not present. */
@@ -398,18 +512,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 +526,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;
@@ -509,11 +619,56 @@ interface IndexerStats {
         merkleRoot: string | null;
         treeSize: number | null;
     };
+    relayers: {
+        active: number;
+    };
     zkVerifier: {
         total: number;
         successful: number;
     };
 }
+/** A registered relayer stored by the indexer. */
+interface Relayer {
+    evmAddress: string;
+    account: string;
+    active: boolean;
+    registeredAtBlock: number;
+    unregisteredAtBlock: number | null;
+    timestampMs: number | null;
+}
+/** A relay fee accumulation or consumption event stored by the indexer. */
+interface RelayFeeEvent {
+    id: number;
+    relayer: string;
+    assetId: string;
+    /** Amount as decimal string (bigint-safe). */
+    amount: string;
+    eventType: 'accumulated' | 'consumed';
+    blockNumber: number;
+    timestampMs: number | null;
+}
+/** Aggregated relay fee balance per asset for a given relayer. */
+interface RelayFeeSummaryEntry {
+    assetId: string;
+    /** Total accumulated (bigint string). */
+    accumulated: string;
+    /** Total consumed (bigint string). */
+    consumed: string;
+    /** pending = accumulated − consumed (bigint string). */
+    pending: string;
+}
+/** A registered asset stored by the indexer. */
+interface RegisteredAsset {
+    assetId: string;
+    name: string | null;
+    symbol: string | null;
+    decimals: number | null;
+    contractAddress: string | null;
+    /** Whether the asset is verified by the protocol. */
+    verified: boolean;
+    registeredAtBlock: number;
+    timestampMs: number | null;
+}
 /**
  * A single shielded activity event tied to an address.
  * The `kind` discriminant identifies whether it is a shield (commitment),
@@ -525,7 +680,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 +711,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 +724,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 +743,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 +801,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.
@@ -610,32 +818,65 @@ declare class IndexerClient {
         page?: number;
         limit?: number;
     }): Promise<PaginatedResult<ShieldedAddressEvent>>;
+    /** Returns a paginated list of relayers. Filter by active status with `active`. */
+    getRelayers(params?: {
+        page?: number;
+        limit?: number;
+        active?: boolean;
+    }): Promise<PaginatedResult<Relayer>>;
+    /** Returns a single relayer by EVM address, or null if not found. */
+    getRelayer(evmAddress: string): Promise<Relayer | null>;
+    /** Returns a paginated list of relay fee events. */
+    getRelayFees(params?: {
+        page?: number;
+        limit?: number;
+        relayer?: string;
+        type?: 'accumulated' | 'consumed';
+    }): Promise<PaginatedResult<RelayFeeEvent>>;
+    /** Returns aggregated relay fee balances per asset for a given relayer account. */
+    getRelayFeesSummary(relayer: string): Promise<RelayFeeSummaryEntry[]>;
+    /** Returns a paginated list of assets registered via register_asset. */
+    getRegisteredAssets(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<RegisteredAsset>>;
+    /** Returns a single registered asset by its ID, or null if not found. */
+    getRegisteredAsset(assetId: string): Promise<RegisteredAsset | null>;
     /** Returns aggregated indexer statistics. */
     getStats(): Promise<IndexerStats>;
     /** Returns true if the indexer health endpoint responds OK. */
     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 +892,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 +911,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 +939,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 +949,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 +968,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 +1008,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,13 +1021,34 @@ 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[];
 };
+/**
+ * Parameters for shieldedPool.claimShieldedFees —
+ * claims accrued relay fees into the shielded pool.
+ *
+ * The relayer must supply a ZK value proof that binds the commitment to the
+ * exact amount and asset_id, preventing fee inflation attacks.
+ */
+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;
+};
 
 /**
  * High-level module for Orbinum shielded-pool operations.
@@ -774,42 +1065,38 @@ declare class ShieldedPoolModule {
     /**
      * 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>;
+     * 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.
-     * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient)
+     * 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): Promise<TxResult>;
+    unshield(params: UnshieldParams, signer?: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
     /**
      * Performs a private (shielded) transfer between two notes.
-     * Extrinsic: shieldedPool.privateTransfer(inputs, outputs, proof, merkleRoot)
+     * 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): Promise<TxResult>;
+    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): Promise<TxResult>;
+    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 value proof with generateFeeClaimProof() (not yet implemented).
+     *
+     * Extrinsic: shieldedPool.claim_shielded_fees(commitment, amount, asset_id, memo, proof, public_signals)
+     */
+    claimShieldedFees(params: ClaimShieldedFeesParams, signer: PolkadotSigner, txOptions?: UnsafeTxOptions): Promise<TxResult>;
 }
 
 /**
@@ -1064,7 +1351,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 +1360,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 +1383,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 +1443,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;
@@ -1176,27 +1502,6 @@ interface KnownPrecompileInfo {
     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.
- */
-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;
-
 /**
  * Bindings for the `ShieldedPoolPrecompile` at address `0x...0801`.
  *
@@ -1218,22 +1523,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;
     /**
@@ -1274,6 +1584,43 @@ declare class ShieldedPoolPrecompile {
      * Estimates the EVM gas for an `unshield` call.
      */
     estimateUnshieldGas(params: UnshieldParams, from: string): Promise<bigint>;
+    /**
+     * Returns the ABI-encoded calldata for
+     * `claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)`.
+     *
+     * ABI layout (params after selector):
+     * - `commitment`    — bytes32 (fixed)
+     * - `amount`        — uint256 (fixed)
+     * - `asset_id`      — uint32  (fixed, right-aligned)
+     * - `memo`          — bytes   (dynamic)
+     * - `proof`         — bytes   (dynamic, 128 bytes Groth16)
+     * - `publicSignals` — bytes   (dynamic, 76 bytes)
+     *
+     * The validator identity is derived from `msg.sender` in the precompile —
+     * do NOT include it in the calldata.
+     */
+    buildClaimShieldedFeesCalldata(params: ClaimShieldedFeesParams): string;
+    /**
+     * Claims accumulated relay fees as a private shielded note.
+     *
+     * This extrinsic is for **validators/relayers** who have accrued fees in
+     * `pallet-relayer` and want to receive them privately inside the shielded pool
+     * instead of as a public balance credit.
+     *
+     * The ZK `value_proof` binds `commitment` to `(amount, assetId, ownerPk, blinding)`
+     * so the runtime can verify the note encodes exactly the claimed fee amount,
+     * preventing a malicious relayer from inflating the withdrawal.
+     *
+     * The `msg.sender` EVM address is used as the validator identity; it must match
+     * the address that has pending relay fees in `pallet-relayer`.
+     *
+     * Extrinsic: `shieldedPool.claim_shielded_fees(commitment, amount, assetId, memo, proof, publicSignals)`
+     */
+    claimShieldedFees(params: ClaimShieldedFeesParams, signer: EvmSigner): Promise<string>;
+    /**
+     * Estimates the EVM gas for a `claimShieldedFees` call.
+     */
+    estimateClaimShieldedFeesGas(params: ClaimShieldedFeesParams, from: string): Promise<bigint>;
 }
 
 /**
@@ -1527,65 +1874,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 +1988,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 +2076,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 +2121,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,127 +2224,399 @@ 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, viewingKey: Uint8Array, spendingKey: bigint): ZkNote | null;
+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;
+};
 
 /**
- * PrivacyKeys
+ * NoteDisclosure
  *
- * Pure cryptographic derivation functions for the Orbinum shielded pool identity.
- * These are protocol-level operations — independent of storage, UI, or session.
+ * Utilities for creating and decoding single-note disclosure keys.
+ * A disclosure key is a compact, shareable string encoding the plaintext
+ * preimage of one specific note commitment. Anyone with the key can verify
+ * the note's value and asset — without gaining any spending capability.
  *
- * Derivation scheme:
- *   viewingKey = HKDF-SHA256(ikm=spendingKey_bytes, info="orbinum-ivk-v1") → 32 bytes
- *   ownerPk    = BabyJubJub Ax from (spendingKey * Base8)                  → bigint
+ * Format: "orbdisc:<base64url(JSON)>"
  *
- * 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)
+ * Revealed by the key:
+ *   - value, assetId, ownerPk (BJJ Ax — not linked to EVM address), blinding
+ *   - commitment (cryptographically verified via Poseidon4)
  *
- * The viewingKey is the symmetric key used by EncryptedMemo (ChaCha20-Poly1305).
- * The ownerPk (x-coordinate) is included in note commitments.
+ * NOT revealed by the key:
+ *   - spendingKey, nullifier, viewingSecretKey
+ *   - any other note belonging to the same user
+ *
+ * Security: the commitment verification in decodeNoteDisclosureKey is a
+ * cryptographic proof-of-knowledge of the preimage. A forged key (mismatched
+ * preimage) will fail verification and return null.
  */
+
 /**
- * Returns the message string the user must sign with their wallet to derive
- * a deterministic Orbinum spending key.
+ * Decoded and cryptographically verified contents of a note disclosure key.
+ *
+ * The `commitment` field is guaranteed to equal Poseidon4(value, assetId, ownerPk, blinding)
+ * — this is verified by decodeNoteDisclosureKey before returning.
  */
-declare function deriveSpendingKeyMessage(chainId: number, address: string): string;
+interface NoteDisclosure {
+    /** Poseidon4(value, assetId, ownerPk, blinding) — matches the on-chain commitment. */
+    commitment: bigint;
+    /** Note value in the smallest unit (e.g. attoORB). */
+    value: bigint;
+    /** Asset ID as registered in the shielded pool. */
+    assetId: bigint;
+    /** BabyJubJub Ax coordinate of the note owner (not directly linkable to an EVM address). */
+    ownerPk: bigint;
+    /** Random blinding scalar chosen at note creation. */
+    blinding: bigint;
+}
 /**
- * Derives an Orbinum spending key from a wallet signature.
+ * Encodes a single ZkNote's plaintext preimage into a shareable disclosure key.
  *
- * Uses HKDF-SHA256(ikm=sigBytes, salt=empty, info="orbinum-sk-v1:{chainId}:{address}")
- * and reduces the resulting 32-byte value modulo BN254_R.
+ * The key does NOT include the spendingKey or nullifier. It is safe to share
+ * with any party that should be able to verify the note's value and asset
+ * without being able to spend it.
  *
- * @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)
+ * @param note  A fully populated ZkNote (as returned by the vault / rescan).
+ * @returns     A "orbdisc:…" string suitable for copy-paste or QR encoding.
  */
-declare function deriveSpendingKeyFromSignature(signatureHex: string, chainId: number, address: string): Promise<bigint>;
+declare function createNoteDisclosureKey(note: ZkNote): string;
+/**
+ * Decodes and cryptographically verifies a note disclosure key.
+ *
+ * Verification: recomputes Poseidon4(value, assetId, ownerPk, blinding) and
+ * asserts it equals the embedded commitment. This ensures the preimage is
+ * consistent and cannot be tampered with.
+ *
+ * @param key  A "orbdisc:…" string produced by createNoteDisclosureKey.
+ * @returns    The verified NoteDisclosure, or null if the key is malformed,
+ *             has an unknown version, or fails Poseidon4 verification.
+ */
+declare function decodeNoteDisclosureKey(key: string): NoteDisclosure | null;
+
+/** 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;
+}
 /**
- * Derive a 32-byte viewing key from a spending key.
- *   viewingKey = HKDF-SHA256(ikm=spendingKey_bytes, info="orbinum-ivk-v1")
+ * 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.
  */
-declare function deriveViewingKey(spendingKey: bigint): Uint8Array;
+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;
+}
 /**
- * Derive the BabyJubJub Ax (x-coordinate of the public key) from a spending key.
- *   ownerPk = (spendingKey * BabyJubJub.Base8)[0]
- *
- * Returns 0n if BabyJubJub computation fails (e.g. invalid scalar).
+ * Generate a Groth16 proof for a PrivateTransfer operation.
  */
-declare function deriveOwnerPk(spendingKey: bigint): bigint;
+declare function generateTransferProof(params: PrivateTransferProofInputs, options?: {
+    provider?: ArtifactProvider;
+    verbose?: boolean;
+}): Promise<ProofResult>;
 
 /**
- * PrivacyKeyManager
+ * Selects up to 2 unspent notes that together cover `needed` planck.
  *
- * In-memory manager for the user's Orbinum shielded-pool identity.
- * Protocol-level module — no UI, no localStorage, no sessionStorage dependencies.
+ * 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)
  *
- * Create one instance per user session:
- *   const pkm = new PrivacyKeyManager();
- *   await pkm.load(spendingKey);
+ * 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 caller (application layer) is responsible for key persistence and session
- * caching. Each instance holds independent state — safe for multi-wallet use.
+ * 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.
  *
- * Derivation scheme:
- *   spendingKey (bigint, BN254 scalar)
- *     └── viewingKey   = HKDF-SHA256(spendingKey_bytes, info="orbinum-ivk-v1")  → 32 bytes
- *     └── ownerPk      = BabyJubJub Ax from (spendingKey * Base8)               → bigint
+ * @param assetId - Must equal the real input note's assetId (circuit Constraint 7).
  */
-declare class PrivacyKeyManager {
-    private _state;
+declare function buildDummyTransferInput(assetId: bigint): TransferInputNote;
+
+/**
+ * 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 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
+ *
+ * Pure cryptographic derivation functions for the Orbinum shielded pool identity.
+ * These are protocol-level operations — independent of storage, UI, or session.
+ *
+ * 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) % BABYJUB_SUBORDER  (if 0 → 1)
+ *
+ * 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 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, BABYJUB_SUBORDER)
+ */
+declare function deriveSpendingKeyFromSignature(signatureHex: string, chainId: number, address: string): Promise<bigint>;
+/**
+ * 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 deriveViewingPublicKey(ivsk: Uint8Array): Uint8Array;
+/**
+ * Derive the BabyJubJub Ax (x-coordinate of the public key) from a spending key.
+ *   ownerPk = (spendingKey * BabyJubJub.Base8)[0]
+ *
+ * Returns 0n if BabyJubJub computation fails (e.g. invalid scalar).
+ */
+declare function deriveOwnerPk(spendingKey: bigint): bigint;
+
+/**
+ * PrivacyKeyManager
+ *
+ * In-memory manager for the user's Orbinum shielded-pool identity.
+ * Protocol-level module — no UI, no localStorage, no sessionStorage dependencies.
+ *
+ * Create one instance per user session:
+ *   const pkm = new PrivacyKeyManager();
+ *   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 (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,14 +2628,27 @@ declare function vaultReplacer(_key: string, value: unknown): unknown;
  * back into native bigint values.
  */
 declare function vaultReviver(_key: string, value: unknown): unknown;
+
 /**
- * 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.
+ * 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 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`.
@@ -1905,8 +2663,198 @@ declare function encryptJson(key: CryptoKey, payload: unknown): Promise<{
  */
 declare function decryptJson(key: CryptoKey, iv: string, ciphertext: string): Promise<unknown>;
 
-declare function toBase64(buf: ArrayBuffer | Uint8Array): string;
-declare function fromBase64(b64: string): Uint8Array;
+/**
+ * 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 value_proof 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.
+ */
+declare function generateFeeClaimProof(inputs: FeeClaimProofInputs, options?: {
+    provider?: ArtifactProvider;
+    verbose?: boolean;
+}): Promise<FeeClaimProofOutput>;
 
 /**
  * Contract addresses and function selectors for all Orbinum EVM precompiles.
@@ -1986,14 +2934,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 +2957,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 +2965,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).
@@ -2023,72 +2983,6 @@ type MerkleRootUpdatedEvent = {
     /** Total number of leaves after the update. */
     treeSize: number;
 };
-/**
- * Emitted by `set_audit_policy()` when an account sets or updates its audit policy.
- * Rust variant: `AuditPolicySet { account, version }`
- */
-type AuditPolicySetEvent = {
-    /** SS58 AccountId of the policy owner. */
-    account: string;
-    /** Policy version number (monotonically increasing). */
-    version: number;
-};
-/**
- * Emitted by `disclose()` when a note is disclosed.
- * Rust variant: `Disclosed { who, commitment, auditor }`
- */
-type DisclosedEvent = {
-    /** SS58 AccountId of the discloser. */
-    who: string;
-    /** 0x-prefixed 32-byte commitment of the disclosed note. */
-    commitment: string;
-    /** SS58 AccountId of the auditor, or null for voluntary disclosure. */
-    auditor: string | null;
-};
-/**
- * Emitted by `request_disclosure()` when an auditor requests a note disclosure.
- * Rust variant: `DisclosureRequested { target, auditor, reason }`
- */
-type DisclosureRequestedEvent = {
-    /** SS58 AccountId of the note owner (disclosure target). */
-    target: string;
-    /** SS58 AccountId of the requesting auditor. */
-    auditor: string;
-    /** Reason string (max 256 bytes, UTF-8). */
-    reason: string;
-};
-/**
- * Emitted by `reject_disclosure()` when a note owner rejects a disclosure request.
- * Rust variant: `DisclosureRejected { target, auditor, reason }`
- */
-type DisclosureRejectedEvent = {
-    /** SS58 AccountId of the note owner. */
-    target: string;
-    /** SS58 AccountId of the auditor whose request was rejected. */
-    auditor: string;
-    /** Rejection reason string (max 256 bytes, UTF-8). */
-    reason: string;
-};
-/**
- * Emitted when a pending disclosure request expires (on_finalize pruning).
- * Rust variant: `DisclosureRequestExpired { target, auditor }`
- */
-type DisclosureRequestExpiredEvent = {
-    /** SS58 AccountId of the note owner. */
-    target: string;
-    /** SS58 AccountId of the auditor. */
-    auditor: string;
-};
-/**
- * Emitted by `revoke_disclosure_record()` when an account revokes a previous disclosure.
- * Rust variant: `DisclosureRecordRevoked { who, commitment }`
- */
-type DisclosureRecordRevokedEvent = {
-    /** SS58 AccountId of the note owner. */
-    who: string;
-    /** 0x-prefixed 32-byte commitment of the revoked note. */
-    commitment: string;
-};
 /**
  * Emitted by `register_asset()` when a new asset is registered in the pool.
  * Rust variant: `AssetRegistered { asset_id }`
@@ -2115,32 +3009,17 @@ type ShieldedPoolEvent = {
     type: 'Shielded';
     data: ShieldedEvent;
 } | {
-    type: 'PrivateTransfer';
-    data: PrivateTransferEvent;
+    type: 'NullifiersSpent';
+    data: NullifiersSpentEvent;
+} | {
+    type: 'CommitmentsInserted';
+    data: CommitmentsInsertedEvent;
 } | {
     type: 'Unshielded';
     data: UnshieldedEvent;
 } | {
     type: 'MerkleRootUpdated';
     data: MerkleRootUpdatedEvent;
-} | {
-    type: 'AuditPolicySet';
-    data: AuditPolicySetEvent;
-} | {
-    type: 'Disclosed';
-    data: DisclosedEvent;
-} | {
-    type: 'DisclosureRequested';
-    data: DisclosureRequestedEvent;
-} | {
-    type: 'DisclosureRejected';
-    data: DisclosureRejectedEvent;
-} | {
-    type: 'DisclosureRequestExpired';
-    data: DisclosureRequestExpiredEvent;
-} | {
-    type: 'DisclosureRecordRevoked';
-    data: DisclosureRecordRevokedEvent;
 } | {
     type: 'AssetRegistered';
     data: AssetRegisteredEvent;
@@ -2171,14 +3050,14 @@ type CircuitId = (typeof CircuitId)[keyof typeof CircuitId];
  * |--------------|-------|---------------------------------|
  * | Transfer     | 1     | 2-in-2-out private transfer     |
  * | Unshield     | 2     | Withdrawal from the pool        |
- * | Disclosure   | 3     | Selective disclosure            |
- * | PrivateLink  | 4     | Private chain-link proof        |
+ * | ValueProof   | 4     | Note value binding (fee-claim)  |
+ * | PrivateLink  | 5     | Private chain-link proof        |
  */
 declare const CircuitId: {
     readonly Transfer: 1;
     readonly Unshield: 2;
-    readonly Disclosure: 3;
-    readonly PrivateLink: 4;
+    readonly ValueProof: 4;
+    readonly PrivateLink: 5;
 };
 /**
  * A single verification key registration entry used in batch operations.
@@ -2233,7 +3112,7 @@ type VerifyProofArgs = {
      * Number and meaning of inputs depends on the circuit:
      * - Transfer:    [merkle_root, nullifier_0, nullifier_1, commitment_0, commitment_1]
      * - Unshield:    [merkle_root, nullifier, amount_fe, recipient_hash, asset_id_fe]
-     * - Disclosure:  [commitment, revealed_value_fe, revealed_asset_id_fe, owner_hash]
+     * - ValueProof:  [commitment, value, asset_id, owner_hash]
      * - PrivateLink: [commitment, call_hash_fe]
      */
     publicInputs: number[][];
@@ -2819,52 +3698,10 @@ type AccountMappingEvent = {
  */
 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]
+ * 176-byte encrypted memo (ChaCha20-Poly1305 ECDH).
+ * Layout: nonce(12) || ciphertext(132) || tag(16) || ephPk(32) = 176 bytes.
  */
-type DisclosurePublicSignals = number[];
-/**
- * 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;
-};
-/**
- * A condition that must be satisfied before disclosure is permitted.
- * Maps to `DisclosureCondition` in Rust. Max 10 conditions per policy.
- */
-type DisclosureCondition = {
-    type: 'MinValue';
-    value: bigint;
-} | {
-    type: 'MaxValue';
-    value: bigint;
-} | {
-    type: 'AssetId';
-    assetId: number;
-} | {
-    type: 'RecipientIs';
-    recipient: string;
-} | {
-    type: 'Custom';
-    encoded: 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;
-};
+type Bytes176 = number[];
 /**
  * A single shield operation for use in `shield_batch`.
  */
@@ -2910,9 +3747,10 @@ type RawTransferOutput = {
     memo: number[];
 };
 /**
- * Call index 1 — `private_transfer` (Signed origin)
+ * Call index 1 — `private_transfer` (Unsigned/gasless 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.
+ * 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. */
@@ -2922,10 +3760,15 @@ type PrivateTransferArgs = {
     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;
 };
 /**
- * Call index 2 — `unshield` (Signed origin)
+ * 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. */
@@ -2935,64 +3778,23 @@ type UnshieldArgs = {
     /** 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;
-};
-/**
- * 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.
- */
-type RequestDisclosureArgs = {
-    /** AccountId of the disclosure target. */
-    target: string;
-    /** Human-readable request reason — max 256 bytes UTF-8. */
-    reason: string;
-};
-/**
- * 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 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;
-};
-/**
- * Call index 7 — `reject_disclosure` (Signed origin)
- * Disclosure target rejects a pending request from an auditor.
- */
-type RejectDisclosureArgs = {
-    /** AccountId of the auditor whose request is rejected. */
-    auditor: string;
-    /** 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[];
+    /** 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 9 — `register_asset` (Root origin)
@@ -3022,24 +3824,6 @@ type VerifyAssetArgs = {
 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;
-};
-/**
- * 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';
@@ -3053,21 +3837,6 @@ type ShieldedPoolCall = {
 } | {
     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;
@@ -3077,12 +3846,6 @@ type ShieldedPoolCall = {
 } | {
     type: 'unverifyAsset';
     args: UnverifyAssetArgs;
-} | {
-    type: 'pruneExpiredRequest';
-    args: PruneExpiredRequestArgs;
-} | {
-    type: 'revokeDisclosureRecord';
-    args: RevokeDisclosureRecordArgs;
 };
 
 /**
@@ -3138,7 +3901,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 +4150,6 @@ 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;
-}
-interface DecodedRejectDisclosureArgs {
-    auditor: string;
-    reason: string;
-}
-interface DecodedSubmitDisclosureArgs {
-    commitment: string;
-    proof: string;
-    public_signals: string[];
-    partial_data: unknown;
-    auditor: string;
-}
-interface DecodedBatchSubmitDisclosureArgs {
-    count: number;
-    submissions: DecodedSubmitDisclosureArgs[];
-}
 interface DecodedTransferArgs {
     dest: string;
     value: string;
@@ -3435,8 +4232,10 @@ interface ShieldedEventData {
     memo: string;
     index: number;
 }
-interface PrivateTransferEventData {
+interface NullifiersSpentEventData {
     nullifiers: string[];
+}
+interface CommitmentsInsertedEventData {
     commitments: string[];
     memos: string[];
     indices: number[];
@@ -3451,45 +4250,6 @@ 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;
-}
-interface DisclosureRejectedData {
-    who: string;
-    auditor: string;
-    reason: string;
-}
-interface DisclosureSubmittedData {
-    who: string;
-    commitment: string;
-    proof_size: number;
-    auditor: string;
-}
-interface DisclosureVerifiedData {
-    who: string;
-    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 +4320,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, 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 DecodedRemarkArgs, type DecodedRevealPrivateLinkArgs, type DecodedSetAccountMetadataArgs, type DecodedShieldArgs, type DecodedShieldBatchArgs, type DecodedShieldBatchOperation, type DecodedSudoArgs, type DecodedTransferAllArgs, type DecodedTransferArgs, type DecodedTransferKeepAliveArgs, type DecodedUnshieldArgs, type DecryptedMemo, type DispatchAsLinkedAccountArgs, type DispatchAsLinkedParams, type DispatchAsPrivateLinkArgs, type DispatchError, type DispatchInfo, type DynamicBuilder, ENCRYPTED_MEMO_SIZE, 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 NoteDisclosure, 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 PutAliasOnSaleArgs, type PutOnSaleParams, type RawBlock, type RawBlockHeader, type RawTransferInput, type RawTransferOutput, type RegisterAliasArgs, type RegisterAssetArgs, type RegisterPrivateLinkArgs, type RegisterVerificationKeyArgs, type RegisteredAsset, type RelayFeeEvent, type RelayFeeSummaryEntry, type Relayer, type RelayerInfo, RelayerStatusModule, type RemoveChainLinkArgs, type RemovePrivateLinkArgs, type RemoveSupportedChainArgs, type RemoveVerificationKeyArgs, type ReservedEventData, type ResolvedAlias, type RevealPrivateLinkArgs, 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, buildDummyTransferInput, bytesToBigintLE, computeNullifier, computePathIndices, createNoteDisclosureKey, decodeNoteDisclosureKey, decodePrecompileCalldata, decryptJson, decryptNoteRecord, 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 };