@orbinum/sdk 0.3.0 → 0.4.1

package/dist/index.d.ts

@@ -1,9 +1,82 @@
 import * as polkadot_api from 'polkadot-api';
 import { PolkadotClient, TxFinalizedPayload, PolkadotSigner } from 'polkadot-api';
-export { PolkadotSigner } from 'polkadot-api';
+export { PolkadotSigner, getSs58AddressInfo } from 'polkadot-api';
+import { getDynamicBuilder } from '@polkadot-api/metadata-builders';
+import { getExtrinsicDecoder } from '@polkadot-api/tx-utils';
+export { AccountId, Blake2256, Keccak256, Storage, u128, u64 } from '@polkadot-api/substrate-bindings';
+export { base58 } from '@scure/base';
 export { getPolkadotSigner } from 'polkadot-api/signer';
-export { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
+export { SignPayload, SignRaw, connectInjectedExtension, getInjectedExtensions, getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
 
+type ChainInfo = {
+    name: string;
+    version: string;
+    ss58Prefix: number;
+    symbol: string;
+    decimals: number;
+};
+type SystemHealth = {
+    peers: number;
+    isSyncing: boolean;
+    shouldHavePeers: boolean;
+};
+interface EventPhase {
+    isApplyExtrinsic: boolean;
+    asApplyExtrinsic: {
+        eq(n: number): boolean;
+        toString(): string;
+        toNumber(): number;
+    };
+}
+interface EventData extends ArrayLike<{
+    toString(): string;
+    toJSON(): unknown;
+    toHuman(): unknown;
+}> {
+    toJSON(): unknown;
+    toHuman(): unknown;
+}
+interface EventRecord {
+    phase: EventPhase;
+    event: {
+        section: string;
+        method: string;
+        data: EventData;
+    };
+}
+/** Raw block header as returned by the chain_getBlock JSON-RPC call. */
+interface RawBlockHeader {
+    parentHash: string;
+    /** Hex-encoded block number, e.g. "0x1a2b". */
+    number: string;
+    stateRoot: string;
+    extrinsicsRoot: string;
+    digest: {
+        logs: string[];
+    };
+}
+/** Raw block body returned by chain_getBlock. */
+interface RawBlock {
+    header: RawBlockHeader;
+    /** SCALE-encoded extrinsics as 0x-hex strings. */
+    extrinsics: string[];
+}
+/**
+ * Enriched block info returned by `SubstrateClient.getBlock()`.
+ * Timestamp is extracted from `Timestamp.Now` storage (with a fallback via `timestamp.set` arg).
+ * Author is decoded from PreRuntime digest logs using the chain's SS58 prefix.
+ */
+interface BlockInfo {
+    header: RawBlockHeader;
+    extrinsics: string[];
+    /** Unix timestamp in milliseconds, or null if not determinable. */
+    timestampMs: number | null;
+    /** SS58-encoded block author, or null if not present in digest logs. */
+    author: string | null;
+}
+
+type DynamicBuilder = ReturnType<typeof getDynamicBuilder>;
+type ExtrinsicDecoder = ReturnType<typeof getExtrinsicDecoder>;
 /**
  * Thin wrapper over polkadot-api (PAPI) that provides:
  * - Raw JSON-RPC calls (custom Orbinum RPCs)
@@ -13,6 +86,8 @@ export { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
 declare class SubstrateClient {
     private readonly _papi;
     private constructor();
+    private _dynamicBuilder;
+    private _extDecoder;
     /**
      * Connects to the Orbinum node via WebSocket.
      * Throws if the node does not respond within `timeoutMs`.
@@ -23,11 +98,55 @@ declare class SubstrateClient {
      * (shieldedPool_*, accountMapping_*, privacy_*, etc.).
      */
     request<T>(method: string, params?: unknown[]): Promise<T>;
+    /**
+     * Returns basic chain information from the node.
+     * Combines `system_name`, `system_chain`, `system_properties`, and `state_getRuntimeVersion`.
+     */
+    getChainInfo(): Promise<ChainInfo>;
+    /**
+     * Returns the node's peer count and sync status.
+     */
+    getHealth(): Promise<SystemHealth>;
+    /**
+     * Returns the node's software version string.
+     */
+    getNodeVersion(): Promise<string>;
+    /**
+     * Returns the genesis hash hex.
+     */
+    getGenesisHash(): Promise<string>;
+    /**
+     * Returns the block hash for a given block number.
+     * Returns null when the block does not exist or has been pruned.
+     */
+    getBlockHash(blockNumber: number): Promise<string | null>;
+    /**
+     * Fetches a block by hash or number, enriched with timestamp and block author.
+     *
+     * Uses `chain_getBlock` (works for all non-pruned blocks, unlike PAPI chainHead
+     * which only pins recent blocks). Timestamp is read from `Timestamp.Now` storage
+     * with a fallback via the `timestamp.set` extrinsic argument. Author is decoded
+     * from PreRuntime digest logs using the chain's SS58 prefix.
+     *
+     * @param hashOrNumber - A `0x`-prefixed block hash or a block number (number or decimal string).
+     * @returns `BlockInfo` or `null` if the block is not found.
+     */
+    getBlock(hashOrNumber: string | number): Promise<BlockInfo | null>;
     /**
      * Returns the underlying PolkadotClient instance.
-     * Use for block subscriptions (`blocks$`), raw metadata access, and advanced SCALE operations.
+     * Use for raw metadata access and advanced SCALE operations.
      */
     get polkadotClient(): PolkadotClient;
+    /**
+     * Observable that emits a new entry each time a best-block is reported by the node.
+     * Delegates to PAPI's `blocks$`.
+     */
+    get blocks$(): PolkadotClient['blocks$'];
+    /**
+     * Returns the block header for a given tag or block hash.
+     * Delegates to PAPI's `getBlockHeader`.
+     */
+    getBlockHeader(...args: Parameters<PolkadotClient['getBlockHeader']>): ReturnType<PolkadotClient['getBlockHeader']>;
     /**
      * Returns the PAPI UnsafeApi for dynamic, metadata-driven transaction building.
      * The first access triggers a metadata fetch from the node.
@@ -66,6 +185,26 @@ declare class SubstrateClient {
     signAndSubmit(callData: Uint8Array, signer: PolkadotSigner): Promise<TxFinalizedPayload>;
     /** Closes the WebSocket connection. */
     destroy(): void;
+    /**
+     * Fetches and decodes all events for a given block hash.
+     * Queries `System.Events` storage via SCALE codec built from on-chain metadata.
+     *
+     * @param blockHash - The `0x`-prefixed block hash string.
+     * @returns Array of `EventRecord` or `null` if unavailable.
+     */
+    queryBlockEvents(blockHash: string): Promise<EventRecord[] | null>;
+    getDynamicBuilder(): Promise<ReturnType<typeof getDynamicBuilder>>;
+    getExtrinsicDecoder(): Promise<ExtrinsicDecoder>;
+    private static _buildDataProxy;
+    /**
+     * Extracts the block author (validator/collator) from raw digest log hex strings.
+     * Looks for a PreRuntime log (tag byte = 6) and decodes the first 32 bytes of the
+     * SCALE-compact payload as an SS58 address using the given prefix.
+     *
+     * Can be used standalone with raw logs from `chain_getBlock` responses.
+     */
+    static extractAuthorFromLogs(logs: string[], ss58Prefix: number): string | null;
+    private static _toEventRecords;
 }
 
 /**
@@ -119,11 +258,371 @@ declare class EvmClient {
     getTransactionReceipt(txHash: string): Promise<Record<string, unknown> | null>;
 }
 
+/** Enriched EVM transaction model for explorer UIs. */
+interface EvmTransaction {
+    hash: string;
+    blockNumber: number;
+    blockHash?: string;
+    from: string;
+    to: string | null;
+    value: string;
+    gasUsed: string;
+    gasPrice: string;
+    nonce: number;
+    input: string;
+    status: number;
+    contractAddress: string | null;
+    timestamp: number | null;
+}
+interface EvmLog {
+    address: string;
+    topics: string[];
+    data: string;
+    blockNumber: number;
+    transactionHash: string;
+    logIndex: number;
+}
+interface EvmAddressInfo {
+    address: string;
+    isContract: boolean;
+    balance: string;
+    nonce: number;
+    codeSize: number;
+    code: string;
+    recentLogs: EvmLog[];
+}
+interface EvmBlock {
+    hash: string;
+    number: number;
+    timestamp: number;
+    transactions: string[];
+    gasUsed: string;
+    gasLimit: string;
+    miner: string;
+    parentHash: string;
+}
+interface EvmTxSummary {
+    hash: string;
+    blockNumber: number;
+    timestamp: number | null;
+    from: string;
+    to: string | null;
+    value: string;
+    input: string;
+    gasUsed: number;
+    gasPrice: string;
+    status: boolean;
+    isContractCreation: boolean;
+    contractAddress: string | null;
+}
+interface TokenInfo {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: string;
+    isErc20: boolean;
+}
+interface TokenTransfer {
+    transactionHash: string;
+    blockNumber: number;
+    from: string;
+    to: string;
+    value: string;
+    logIndex: number;
+}
+
+/**
+ * High-level EVM read-model explorer built on top of EvmClient.
+ * Provides typed block/tx/address/token methods for explorer applications.
+ */
+declare class EvmExplorer {
+    private readonly evm;
+    constructor(evm: EvmClient);
+    getLatestBlocks(count?: number): Promise<EvmBlock[]>;
+    getBlock(hashOrNumber: string | number): Promise<EvmBlock | null>;
+    getBlockTransactions(hashOrNumber: string | number): Promise<EvmTransaction[]>;
+    getTransaction(hash: string): Promise<EvmTransaction | null>;
+    getTransactionsByAddress(address: string, maxBlocks?: number): Promise<EvmTxSummary[]>;
+    getAddressInfo(address: string): Promise<EvmAddressInfo>;
+    getBalance(address: string): Promise<string>;
+    getNonce(address: string): Promise<number>;
+    getIsContract(address: string): Promise<boolean>;
+    getTokenInfo(address: string): Promise<TokenInfo | null>;
+    getTokenTransfers(address: string, holderAddress?: string): Promise<TokenTransfer[]>;
+    getTokenBalance(tokenAddress: string, holderAddress: string): Promise<string>;
+    private parseBlock;
+    private parseTx;
+    private fetchBlock;
+    private ethCall;
+    private static decodeAbiString;
+    private static decodeAbiUint;
+    private static hexToDecimalStr;
+}
+
+/** Configuration for IndexerClient. */
+interface IndexerClientConfig {
+    /** Base URL of the indexer REST API (no trailing slash). */
+    baseUrl: string;
+    /** Request timeout in ms. Default: 10_000. */
+    timeoutMs?: number;
+}
+/** Generic paginated result returned by list endpoints. */
+interface PaginatedResult<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+    };
+}
+/** A shielded commitment (shield event) stored by the indexer. */
+interface ShieldedCommitment {
+    commitmentHex: string;
+    blockNumber: number;
+    extrinsicIndex: number | null;
+    leafIndex: number;
+    /** Asset ID as decimal string (e.g. "0"). */
+    assetId: string;
+    /** SS58 or 0x-prefixed depositor address, null if not tracked. */
+    sender: string | null;
+    /** 0x-prefixed encrypted memo hex, null if not present. */
+    encryptedMemo: string | null;
+    timestampMs: number | null;
+}
+/** A spent nullifier stored by the indexer. */
+interface SpentNullifier {
+    nullifierHex: string;
+    blockNumber: number;
+    extrinsicIndex: number | null;
+    txType: 'unshield' | 'private_transfer';
+    timestampMs: number | null;
+}
+/** A private transfer event stored by the indexer. */
+interface PrivateTransfer {
+    /** "{blockNumber}-{extrinsicIndex}" */
+    id: string;
+    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;
+    timestampMs: number | null;
+}
+/** An unshield event stored by the indexer. */
+interface Unshield {
+    /** "{blockNumber}-{extrinsicIndex}" */
+    id: string;
+    blockNumber: number;
+    extrinsicIndex: number | null;
+    nullifierHex: string;
+    /** Asset ID as decimal string. */
+    assetId: string;
+    /** Amount as decimal string (bigint-safe). */
+    amount: string;
+    recipient: string;
+    timestampMs: number | null;
+}
+/** A Merkle root checkpoint stored by the indexer. */
+interface MerkleRoot {
+    id: number;
+    rootHex: string;
+    blockNumber: number;
+    oldRootHex: string | null;
+    treeSize: number;
+    timestampMs: number | null;
+}
+/** Response from the nullifier status endpoint. */
+interface NullifierStatusResult {
+    nullifier: string;
+    spent: boolean;
+    txType?: 'unshield' | 'private_transfer';
+    blockNumber?: number;
+}
+/** A substrate extrinsic row returned by the address indexer endpoint. */
+interface IndexedExtrinsic {
+    id: string;
+    blockNumber: number;
+    index: number;
+    hash: string | null;
+    section: string;
+    method: string;
+    signer: string | null;
+    success: boolean;
+    feePaid: string | null;
+    eventsJson: string;
+    argsJson: string;
+    timestampMs: number | null;
+}
+/** An indexed EVM transaction returned by explorer endpoints. */
+interface IndexedEvmTx {
+    hash: string;
+    blockNumber: number;
+    fromAddress: string | null;
+    toAddress: string | null;
+    value: string;
+    gasUsed: number | null;
+    gasPrice: string | null;
+    status: number | null;
+    inputData: string | null;
+    nonce: number | null;
+    transactionIndex: number | null;
+    timestampMs: number | null;
+    evmBlockHash: string | null;
+}
+/** An indexed block returned by the blocks endpoint. */
+interface IndexedBlock {
+    number: number;
+    hash: string;
+    parentHash: string;
+    timestampMs: number | null;
+    author: string | null;
+    extrinsicCount: number;
+    evmTxCount: number;
+    evmHash: string | null;
+    evmParentHash?: string | null;
+    evmMiner?: string | null;
+    evmGasUsed?: string | null;
+    evmGasLimit?: string | null;
+    evmBaseFeePerGas?: string | null;
+}
+/** Aggregated statistics returned by the /stats endpoint. */
+interface IndexerStats {
+    blocks: {
+        indexed: number;
+        latest: number | null;
+        latestHash: string | null;
+        latestTimestampMs: number | null;
+    };
+    extrinsics: {
+        total: number;
+    };
+    evm: {
+        transactions: number;
+    };
+    shielded: {
+        commitments: number;
+        spentNullifiers: number;
+        merkleRoot: string | null;
+        treeSize: number | null;
+    };
+    zkVerifier: {
+        total: number;
+        successful: number;
+    };
+}
+/**
+ * A single shielded activity event tied to an address.
+ * The `kind` discriminant identifies whether it is a shield (commitment),
+ * unshield, or private transfer event.
+ */
+type ShieldedAddressEvent = ({
+    kind: 'commitment';
+} & ShieldedCommitment) | ({
+    kind: 'unshield';
+} & Unshield) | ({
+    kind: 'transfer';
+} & PrivateTransfer);
+
+/**
+ * HTTP client for the Orbinum indexer REST API.
+ *
+ * All methods throw on network errors.
+ * Methods returning a single entity return `null` when the server responds 404.
+ */
+declare class IndexerClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(config: IndexerClientConfig);
+    private _fetchResponse;
+    private get;
+    private getOrNull;
+    private buildQuery;
+    /** Returns the total count of shielded commitments. */
+    getCommitmentsCount(): Promise<number>;
+    /** Returns a paginated list of shielded commitments. */
+    getCommitments(params?: {
+        page?: number;
+        limit?: number;
+        sinceLeafIndex?: number;
+    }): 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 spent nullifiers. */
+    getNullifiers(params?: {
+        page?: number;
+        limit?: number;
+    }): 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>>;
+    /** Returns a paginated list of unshield events. */
+    getUnshields(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<Unshield>>;
+    /** Returns a paginated list of Merkle root checkpoints. */
+    getMerkleRoots(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<MerkleRoot>>;
+    /** Returns the latest Merkle root, or null if none exists. */
+    getLatestMerkleRoot(): Promise<MerkleRoot | null>;
+    /** Returns a paginated list of extrinsics signed by the given address. */
+    getAddressExtrinsics(address: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<IndexedExtrinsic>>;
+    /** Returns a paginated list of EVM transactions filtered by address and/or block number. */
+    getEvmTransactions(params?: {
+        page?: number;
+        limit?: number;
+        address?: string;
+        blockNumber?: number;
+    }): Promise<PaginatedResult<IndexedEvmTx>>;
+    /** Returns a single EVM transaction by hash, or null if not found. */
+    getEvmTransactionByHash(hash: string): Promise<IndexedEvmTx | null>;
+    /** Returns a paginated list of indexed blocks. */
+    getBlocks(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<IndexedBlock>>;
+    /** Returns a single block by number or hash, or null if not found. */
+    getBlock(numberOrHash: string | number): Promise<IndexedBlock | null>;
+    /** Returns a paginated list of shielded commitments initiated by an address. */
+    getAddressCommitments(address: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<ShieldedCommitment>>;
+    /**
+     * Returns a paginated list of all shielded activity (commitments, unshields,
+     * private transfers) associated with the given address.
+     * Each item is tagged with a `kind` discriminant.
+     */
+    getAddressShieldedActivity(address: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResult<ShieldedAddressEvent>>;
+    /** Returns aggregated indexer statistics. */
+    getStats(): Promise<IndexerStats>;
+    /** Returns true if the indexer health endpoint responds OK. */
+    isHealthy(): Promise<boolean>;
+}
+
 type OrbinumClientConfig = {
     /** WebSocket URL of the Orbinum node (e.g. "ws://localhost:9944") */
     substrateWs: string;
     /** HTTP URL of the EVM JSON-RPC endpoint (e.g. "http://localhost:9933") */
     evmRpc?: string;
+    /** Base URL of the Orbinum indexer REST API (e.g. "https://indexer.orbinum.io") */
+    indexerUrl?: string;
     /** Connection timeout in ms. Default: 15_000 */
     connectTimeoutMs?: number;
 };
@@ -136,32 +635,22 @@ type TxResult = {
     /** Dispatch error type string when ok = false. */
     error?: string;
 };
+
 type MerkleTreeInfo = {
     root: string;
     treeSize: number;
     depth: number;
 };
-/** Aggregate shielded pool statistics (merkle tree + total locked balance). */
-type PoolStats = {
-    merkleRoot: string;
-    commitmentCount: number;
-    /** Total native balance locked in the pool (u128 as decimal string). */
-    totalBalance: string;
-    treeDepth: number;
-};
-type MerkleProof = {
-    root: string;
+type ScanCommitment = {
+    commitmentHex: string;
     leafIndex: number;
-    siblings: string[];
-};
-type CommitmentMerkleProof = MerkleProof;
-type NullifierStatus = {
-    nullifier: string;
-    isSpent: boolean;
+    encryptedMemo: string | null;
 };
-type PoolBalance = {
-    assetId: number;
-    balance: bigint;
+type DecryptedMemo = {
+    value: bigint;
+    ownerPk: bigint;
+    blinding: bigint;
+    assetId: bigint;
 };
 type ShieldParams = {
     assetId: number;
@@ -183,20 +672,20 @@ type UnshieldParams = {
     /** SS58 or 0x-prefixed 32-byte address */
     recipientAddress: string;
 };
-type TransferInput = {
+type PrivateTransferInput = {
     /** 0x-prefixed nullifier hex */
     nullifier: string;
     /** 0x-prefixed commitment hex */
     commitment: string;
 };
-type TransferOutput = {
+type PrivateTransferOutput = {
     /** 0x-prefixed commitment hex */
     commitment: string;
     encryptedMemo?: Uint8Array;
 };
 type PrivateTransferParams = {
-    inputs: TransferInput[];
-    outputs: TransferOutput[];
+    inputs: PrivateTransferInput[];
+    outputs: PrivateTransferOutput[];
     /** ZK proof bytes */
     proof: Uint8Array;
     /** 0x-prefixed merkle root hex */
@@ -256,21 +745,82 @@ type ShieldResult = {
     txResult: TxResult;
     note: ZkNote;
 };
-type ChainInfo = {
-    name: string;
-    version: string;
-    ss58Prefix: number;
+/** Parameters for a single item in a shield_batch extrinsic. */
+type ShieldBatchItem = {
+    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;
 };
-type FullIdentityInfo = {
-    substrateAddress: string | null;
-    evmAddress: string | null;
-    alias: string | null;
+/** Parameters for shieldedPool.shieldBatch — deposits up to 20 notes in one extrinsic. */
+type ShieldBatchParams = {
+    items: ShieldBatchItem[];
 };
+
+/**
+ * High-level module for Orbinum shielded-pool operations.
+ *
+ * Transactions are built via polkadot-api's UnsafeApi (metadata-driven),
+ * which means the Orbinum node must be reachable on first use.
+ * Signing is delegated to a PolkadotSigner (see polkadot-api/signer).
+ *
+ * Parameter order matches the Orbinum runtime extrinsics exactly.
+ */
+declare class ShieldedPoolModule {
+    private readonly substrate;
+    constructor(substrate: SubstrateClient);
+    /**
+     * Deposits tokens into the shielded pool.
+     * Extrinsic: shieldedPool.shield(assetId, amount, commitment, encryptedMemo)
+     */
+    shield(params: ShieldParams, signer: PolkadotSigner): Promise<TxResult>;
+    /**
+     * Build a ZkNote locally and submit shieldedPool.shield in one call.
+     *
+     * Returns both the on-chain result and the note — **save the note locally**,
+     * it cannot be recovered after the fact.
+     *
+     * @param params.value       Amount in planck (required).
+     * @param params.assetId     Asset ID — default 0 (native ORB-Privacy).
+     * @param params.ownerPk     BabyJubJub Ax (default 0n).
+     * @param params.blinding    Random blinding scalar (default BigInt(Date.now())).
+     * @param params.spendingKey Secret spending key (default 0n).
+     */
+    buildAndShield(params: {
+        value: bigint;
+        assetId?: number;
+        ownerPk?: bigint;
+        blinding?: bigint;
+        spendingKey?: bigint;
+    }, signer: PolkadotSigner): Promise<ShieldResult>;
+    /**
+     * Withdraws tokens from the shielded pool to a public address.
+     * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient)
+     */
+    unshield(params: UnshieldParams, signer: PolkadotSigner): Promise<TxResult>;
+    /**
+     * Performs a private (shielded) transfer between two notes.
+     * Extrinsic: shieldedPool.privateTransfer(inputs, outputs, proof, merkleRoot)
+     */
+    privateTransfer(params: PrivateTransferParams, signer: PolkadotSigner): Promise<TxResult>;
+    /**
+     * Deposits multiple notes into the shielded pool in a single extrinsic.
+     * Extrinsic: shieldedPool.shieldBatch(operations) — max 20 items.
+     */
+    shieldBatch(params: ShieldBatchParams, signer: PolkadotSigner): Promise<TxResult>;
+}
+
 /**
  * Signature verification scheme for cross-chain links.
  * Mirrors `SignatureScheme` in pallet-account-mapping.
  */
-type SignatureScheme$1 = 'Eip191' | 'Ed25519';
+declare const SignatureScheme: {
+    readonly Eip191: "Eip191";
+    readonly Ed25519: "Ed25519";
+};
+type SignatureScheme = (typeof SignatureScheme)[keyof typeof SignatureScheme];
 /** A verified public link to an external chain wallet. */
 type ChainLink = {
     chainId: number;
@@ -320,159 +870,9 @@ type AccountListing = {
 /** A supported chain and its signature verification scheme. */
 type SupportedChain = {
     chainId: number;
-    scheme: SignatureScheme$1;
-};
-/**
- * Bitmask to convert a SLIP-0044 coin type into an Orbinum ChainId.
- * Example: `SLIP0044_NAMESPACE | 501` = Solana.
- */
-declare const SLIP0044_NAMESPACE = 2147483648;
-
-/**
- * Queries the Orbinum shielded-pool Merkle tree via custom RPC methods.
- */
-declare class MerkleModule {
-    private readonly substrate;
-    constructor(substrate: SubstrateClient);
-    /**
-     * Returns the current Merkle tree state: root, number of leaves, and depth.
-     */
-    getTreeInfo(): Promise<MerkleTreeInfo>;
-    /**
-     * Returns the Merkle inclusion proof for a leaf at `leafIndex`.
-     */
-    getProof(leafIndex: number): Promise<MerkleProof>;
-    /**
-     * Returns the Merkle inclusion proof for a given commitment (0x-prefixed hex).
-     * Searches the tree for the commitment and returns its proof.
-     */
-    getProofByCommitment(commitmentHex: string): Promise<MerkleProof>;
-    /**
-     * Returns the current Merkle root without fetching the full tree info.
-     */
-    getRoot(): Promise<string>;
-    /**
-     * Returns an array of commitment leaves from index `from` to `to` (inclusive).
-     * Defaults to returning all leaves.
-     */
-    getLeaves(from?: number, to?: number): Promise<string[]>;
-}
-
-/**
- * High-level module for Orbinum shielded-pool operations.
- *
- * Transactions are built via polkadot-api's UnsafeApi (metadata-driven),
- * which means the Orbinum node must be reachable on first use.
- * Signing is delegated to a PolkadotSigner (see polkadot-api/signer).
- *
- * Parameter order matches the Orbinum runtime extrinsics exactly.
- */
-declare class ShieldedPoolModule {
-    private readonly substrate;
-    readonly merkle: MerkleModule;
-    constructor(substrate: SubstrateClient, merkle: MerkleModule);
-    /**
-     * Deposits tokens into the shielded pool.
-     * Extrinsic: shieldedPool.shield(assetId, amount, commitment, encryptedMemo)
-     */
-    shield(params: ShieldParams, signer: PolkadotSigner): Promise<TxResult>;
-    /**
-     * Build a ZkNote locally and submit shieldedPool.shield in one call.
-     *
-     * Returns both the on-chain result and the note — **save the note locally**,
-     * it cannot be recovered after the fact.
-     *
-     * @param params.value       Amount in planck (required).
-     * @param params.assetId     Asset ID — default 0 (native ORB-Privacy).
-     * @param params.ownerPk     BabyJubJub Ax (default 0n).
-     * @param params.blinding    Random blinding scalar (default BigInt(Date.now())).
-     * @param params.spendingKey Secret spending key (default 0n).
-     */
-    buildAndShield(params: {
-        value: bigint;
-        assetId?: number;
-        ownerPk?: bigint;
-        blinding?: bigint;
-        spendingKey?: bigint;
-    }, signer: PolkadotSigner): Promise<ShieldResult>;
-    /**
-     * Withdraws tokens from the shielded pool to a public address.
-     * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient)
-     */
-    unshield(params: UnshieldParams, signer: PolkadotSigner): Promise<TxResult>;
-    /**
-     * Performs a private (shielded) transfer between two notes.
-     * Extrinsic: shieldedPool.privateTransfer(inputs, outputs, proof, merkleRoot)
-     */
-    privateTransfer(params: PrivateTransferParams, signer: PolkadotSigner): Promise<TxResult>;
-    /** Returns whether a nullifier has already been spent. */
-    isNullifierSpent(nullifierHex: string): Promise<boolean>;
-    /** Returns the full nullifier status object. */
-    getNullifierStatus(nullifierHex: string): Promise<NullifierStatus>;
-    /** Returns the total locked balance in the pool for a given asset. */
-    getPoolBalance(assetId: number): Promise<PoolBalance>;
-    /**
-     * Returns Merkle tree info and pool balance for a given asset in a single call.
-     * Convenience wrapper used by both `app` and `privacy-explorer`.
-     */
-    getPoolStats(assetId?: number): Promise<{
-        merkle: MerkleTreeInfo;
-        balance: PoolBalance;
-    }>;
-}
-
-type RawSystemHealth = {
-    peers: number;
-    isSyncing: boolean;
-    shouldHavePeers: boolean;
+    scheme: SignatureScheme;
 };
-/**
- * Provides general chain queries: node info, account mapping, address resolution.
- */
-declare class ChainModule {
-    private readonly substrate;
-    private readonly evm;
-    constructor(substrate: SubstrateClient, evm: EvmClient | null);
-    /**
-     * Returns basic chain information from the node.
-     */
-    getChainInfo(): Promise<ChainInfo>;
-    /**
-     * Returns the node's peer count and sync status.
-     */
-    getHealth(): Promise<RawSystemHealth>;
-    /**
-     * Returns the node's software version string.
-     */
-    getNodeVersion(): Promise<string>;
-    /**
-     * Returns the genesis hash hex.
-     */
-    getGenesisHash(): Promise<string>;
-    /**
-     * Resolves the full identity (Substrate + EVM addresses, alias) for an account.
-     * Accepts an EVM address (0x...) or a Substrate account hex (0x...32bytes).
-     */
-    getFullIdentity(address: string): Promise<FullIdentityInfo | null>;
-    /**
-     * Returns the mapped Substrate account hex for a given EVM address, or null.
-     */
-    getMappedAccountByEvm(evmAddress: string): Promise<string | null>;
-    /**
-     * Returns the alias registered for a Substrate account, or null.
-     */
-    getAliasOf(accountHex: string): Promise<string | null>;
-    /**
-     * Returns estimated EVM chain ID from the EVM RPC endpoint. Requires evmRpc
-     * to have been provided in `OrbinumClientConfig`.
-     */
-    getEvmChainId(): Promise<number>;
-    /**
-     * Returns the current EVM block number.
-     */
-    getEvmBlockNumber(): Promise<number>;
-}
-
+/** Parameters for adding a verified public chain link. */
 type AddChainLinkParams = {
     /** External chain ID. Use SLIP0044_NAMESPACE | coinType for SLIP-0044 chains. */
     chainId: number;
@@ -481,16 +881,19 @@ type AddChainLinkParams = {
     /** Signature over the caller's AccountId32 (64 bytes for Ed25519, 65 for EIP-191). */
     signature: Uint8Array;
 };
+/** Parameters for updating public profile metadata. */
 type SetMetadataParams = {
     displayName?: string | null;
     bio?: string | null;
     avatar?: string | null;
 };
+/** Parameters for listing an alias on the marketplace. */
 type PutOnSaleParams = {
     price: bigint;
     /** If true the sale becomes OTC (whitelist required). */
     isPrivate: boolean;
 };
+/** Parameters for dispatching a call authenticated by a linked external account. */
 type DispatchAsLinkedParams = {
     /** Owner AccountId32 hex (0x-prefixed 64 chars). */
     owner: string;
@@ -501,6 +904,12 @@ type DispatchAsLinkedParams = {
     /** Encoded call bytes (SCALE). */
     callData: Uint8Array;
 };
+/**
+ * Bitmask to convert a SLIP-0044 coin type into an Orbinum ChainId.
+ * Example: `SLIP0044_NAMESPACE | 501` = Solana.
+ */
+declare const SLIP0044_NAMESPACE = 2147483648;
+
 /**
  * Module for Orbinum pallet-account-mapping:
  * - Query on-chain identity data (aliases, chain links, metadata, marketplace)
@@ -650,18 +1059,100 @@ declare class AccountMappingModule {
     dispatchAsLinkedAccount(params: DispatchAsLinkedParams, signer: PolkadotSigner): Promise<TxResult>;
 }
 
+type RpcV2MerkleProof = {
+    path: string[];
+    leafIndex: number;
+    treeDepth: number;
+};
+/** Prueba Merkle enriquecida con el `root` actual del árbol. Devuelta por `getMerkleProofByCommitment`. */
+type PrivacyMerkleProof = RpcV2MerkleProof & {
+    root: string;
+};
+type RpcV2NullifierStatus = {
+    nullifier: string;
+    isSpent: boolean;
+};
+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`. */
+    totalBalance: string;
+    assetBalances: RpcV2PoolAssetBalance[];
+    treeDepth: number;
+};
+
 /**
- * Converts a Uint8Array or number[] to a 0x-prefixed lowercase hex string.
+ * Typed client for the Orbinum `rpc-v2` endpoints under the `privacy_*` namespace.
  */
-declare function toHex(bytes: Uint8Array | number[]): string;
+declare class PrivacyModule {
+    private readonly substrate;
+    constructor(substrate: SubstrateClient);
+    /** Returns the current Merkle tree root. */
+    getMerkleRoot(): Promise<string>;
+    /** Returns the Merkle proof for the given leaf index or commitment hex. */
+    getMerkleProof(leafIndex: number | string): Promise<RpcV2MerkleProof>;
+    /**
+     * Returns the Merkle inclusion proof for a given commitment hex,
+     * bundled with the current Merkle root.
+     */
+    getMerkleProofByCommitment(commitmentHex: string): Promise<PrivacyMerkleProof>;
+    /** Returns the spend status of a nullifier. */
+    getNullifierStatus(nullifier: string): Promise<RpcV2NullifierStatus>;
+    /** Returns aggregated statistics for the shielded pool from `rpc-v2`. */
+    getPoolStats(): Promise<RpcV2PoolStats>;
+}
+
+/** Public (camelCase) types for `zkVerifier_*` RPC responses. */
+type ZkVerifierVkHash = {
+    version: number;
+    vkHash: string;
+    /** On-chain verification statistics for this version (if available). */
+    stats?: ZkVerifierVersionStats;
+};
+/** Proof verification counts for a specific circuit version. */
+type ZkVerifierVersionStats = {
+    /** Total proof verification attempts. */
+    total: number;
+    /** Successful verifications. */
+    successful: number;
+    /** Failed verifications. */
+    failed: number;
+};
 /**
- * Decodes a hex string (with or without 0x prefix) to Uint8Array.
+ * A version whose VK was removed from storage but whose stats record survived.
+ * The key data is gone; only the usage record remains.
  */
-declare function fromHex(hex: string): Uint8Array;
+type ZkVerifierHistoricalVersion = {
+    version: number;
+    stats: ZkVerifierVersionStats;
+};
+type ZkVerifierCircuitVersionInfo = {
+    circuitId: number;
+    activeVersion: number;
+    /** Proof system (e.g. 'Groth16'). */
+    proofSystem: string;
+    supportedVersions: number[];
+    vkHashes: ZkVerifierVkHash[];
+    /** Versions removed from storage that still have stats records. */
+    historicalVersions: ZkVerifierHistoricalVersion[];
+};
+
 /**
- * Ensures a hex string has the 0x prefix.
+ * Typed client for `zkVerifier_*` JSON-RPC endpoints.
  */
-declare function ensureHexPrefix(hex: string): string;
+declare class ZkVerifierModule {
+    private readonly substrate;
+    constructor(substrate: SubstrateClient);
+    /** Returns basic version info for all registered circuits. */
+    getAllCircuitVersions(): Promise<ZkVerifierCircuitVersionInfo[]>;
+    /** Returns version info for a specific circuit, or null if not found. */
+    getCircuitVersionInfo(circuitId: number): Promise<ZkVerifierCircuitVersionInfo | null>;
+}
 
 /** EVM transaction request passed to an `EvmSigner` callback. */
 type EvmTxRequest = {
@@ -669,14 +1160,43 @@ type EvmTxRequest = {
     data: string;
     value?: bigint;
 };
+/** Callback that signs and submits an EVM transaction, returning the tx hash. */
+type EvmSigner = (tx: EvmTxRequest) => Promise<string>;
+type ResolvedAlias = {
+    /** AccountId32 hex of the alias owner (as 0x-prefixed 20-byte EVM address). */
+    owner: string;
+    /** EVM address of the owner, or null if unset. */
+    evmAddress: string | null;
+};
+/** Metadata for a known precompile: display name and function selector map. */
+interface KnownPrecompileInfo {
+    /** Human-readable name, e.g. "ShieldedPool". */
+    name: string;
+    /** Map from 4-byte hex selector (no 0x prefix) to function signature. */
+    functions: Record<string, string>;
+}
+
 /**
- * Callback that signs and submits an EVM transaction, returning the tx hash.
- *
- * MetaMask: `(tx) => window.ethereum.request({ method: 'eth_sendTransaction', params: [{ ...tx, from: account }] })`
- * ethers:   `(tx) => (await signer.sendTransaction({ to: tx.to, data: tx.data })).hash`
- * viem:     `(tx) => walletClient.sendTransaction({ to: tx.to, data: tx.data })`
+ * Converts a Uint8Array or number[] to a 0x-prefixed lowercase hex string.
  */
-type EvmSigner = (tx: EvmTxRequest) => Promise<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`.
  *
@@ -756,12 +1276,6 @@ declare class ShieldedPoolPrecompile {
     estimateUnshieldGas(params: UnshieldParams, from: string): Promise<bigint>;
 }
 
-type ResolvedAlias = {
-    /** AccountId32 hex of the alias owner (as 0x-prefixed 20-byte EVM address). */
-    owner: string;
-    /** EVM address of the owner, or null if unset. */
-    evmAddress: string | null;
-};
 /**
  * EVM bindings for `AccountMappingPrecompile` at address `0x...0800`.
  *
@@ -890,10 +1404,25 @@ declare class AccountMappingPrecompile {
     /**
      * Updates the signer's public profile metadata.
      * Pass `null` for any field to leave it unchanged.
-     *
-     * Extrinsic: `accountMapping.setAccountMetadata(displayName, bio, avatar)`
-     */
-    setAccountMetadata(displayName: string | null, bio: string | null, avatar: string | null, signer: EvmSigner): Promise<string>;
+    }
+        displayName: string | null,
+        bio: string | null,
+        avatar: string | null,
+        signer: EvmSigner
+    ): Promise<string> {
+        const enc = (v: string | null): Uint8Array =>
+            v != null ? new TextEncoder().encode(v) : new Uint8Array(0);
+        const data = encodeHex(
+            AM_SEL.SET_ACCOUNT_METADATA,
+            { type: 'bytes', value: enc(displayName) },
+            { type: 'bytes', value: enc(bio) },
+            { type: 'bytes', value: enc(avatar) }
+        );
+        return signer({ to: this.addr, data });
+    }
+
+    // ─── Calldata builders (for custom signing / batching) ─────────────────────
+
     /** Returns the raw ABI-encoded calldata for `registerAlias`. */
     buildRegisterAliasCalldata(alias: string): string;
     /** Returns the raw ABI-encoded calldata for `mapAccount`. */
@@ -983,9 +1512,9 @@ declare class CryptoPrecompiles {
  *   evmRpc: 'http://localhost:9933',
  * });
  *
- * // Query Merkle tree
- * const info = await client.shieldedPool.merkle.getTreeInfo();
- * console.log('root:', info.root, 'nodes:', info.treeSize);
+ * // Query Merkle tree stats
+ * const stats = await client.privacy.getPoolStats();
+ * console.log('root:', stats.merkleRoot, 'leaves:', stats.commitmentCount);
  *
  * // Shield tokens (with a PolkadotSigner)
  * const result = await client.shieldedPool.shield(
@@ -1002,12 +1531,24 @@ declare class OrbinumClient {
     readonly substrate: SubstrateClient;
     /** Raw access to the EVM HTTP JSON-RPC endpoint (if configured). */
     readonly evm: EvmClient | null;
+    /**
+     * High-level EVM block and transaction explorer (if `evmRpc` is configured).
+     * Provides enriched queries for blocks, transactions, addresses, and token transfers.
+     */
+    readonly evmExplorer: EvmExplorer | null;
+    /**
+     * HTTP client for the Orbinum indexer REST API (if `indexerUrl` is configured).
+     * Provides paginated access to indexed blocks, extrinsics, shielded events, and nullifiers.
+     */
+    readonly indexer: IndexerClient | null;
     /** Shielded-pool operations: shield, unshield, privateTransfer, and merkle queries. */
     readonly shieldedPool: ShieldedPoolModule;
-    /** General chain queries: node info, identity resolution. */
-    readonly chain: ChainModule;
     /** Account mapping: aliases, chain links, metadata, marketplace, and identity extrinsics. */
     readonly accountMapping: AccountMappingModule;
+    /** Typed access to Orbinum `privacy_*` RPC endpoints. */
+    readonly privacy: PrivacyModule;
+    /** Typed access to zkVerifier_* RPC endpoints. */
+    readonly zkVerifier: ZkVerifierModule;
     /**
      * EVM precompiles: shielded pool + account mapping callable from an EVM wallet.
      * Only available when `evmRpc` is configured. Methods throw if `evm` is null.
@@ -1026,14 +1567,84 @@ declare class OrbinumClient {
      * Throws if the Substrate node is unreachable within `connectTimeoutMs`.
      */
     static connect(config: OrbinumClientConfig): Promise<OrbinumClient>;
-    /**
-     * Convenience getter for the Merkle module (shortcut for `shieldedPool.merkle`).
-     */
-    get merkle(): MerkleModule;
     /** Closes the WebSocket connection to the Substrate node. */
     destroy(): void;
 }
 
+type ConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+type StatusChangeEvent = {
+    status: ConnectionStatus;
+    error?: string;
+};
+type StatusListener = (event: StatusChangeEvent) => void;
+interface ClientProviderConfig {
+    substrateWs: string;
+    evmRpc?: string;
+    /** Base URL of the Orbinum indexer REST API (e.g. "https://indexer.orbinum.io") */
+    indexerUrl?: string;
+    connectTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
+    heartbeatTimeoutMs?: number;
+    reconnectBaseMs?: number;
+    reconnectMaxMs?: number;
+}
+/**
+ * Manages the lifecycle of an `OrbinumClient` with heartbeat monitoring,
+ * exponential-backoff reconnection, and status event emission.
+ *
+ * Instantiate one per application and use as a singleton.
+ *
+ * @example
+ * ```ts
+ * import { OrbinumClientProvider } from '@orbinum/sdk';
+ *
+ * const provider = new OrbinumClientProvider({
+ *   substrateWs: 'ws://localhost:9944',
+ *   evmRpc: 'http://localhost:9944',
+ * });
+ * provider.connect();
+ *
+ * const client = await provider.getOrbinumClient();
+ * ```
+ */
+declare class OrbinumClientProvider {
+    private readonly config;
+    private readonly connectTimeoutMs;
+    private readonly heartbeatIntervalMs;
+    private readonly heartbeatTimeoutMs;
+    private readonly reconnectBaseMs;
+    private readonly reconnectMaxMs;
+    private _status;
+    private _orbinumClient;
+    private _connectingPromise;
+    private _heartbeatTimer;
+    private _reconnectTimer;
+    private _reconnectAttempt;
+    private _listeners;
+    constructor(config: ClientProviderConfig);
+    get status(): ConnectionStatus;
+    private setStatus;
+    onStatusChange(listener: StatusListener): () => void;
+    connect(): void;
+    reset(): void;
+    private startConnectAttempt;
+    private attemptConnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private probe;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private teardownClient;
+    getOrbinumClient(): Promise<OrbinumClient>;
+    tryGetOrbinumClient(): Promise<OrbinumClient | null>;
+    rpcSend<T>(method: string, params?: unknown[]): Promise<T>;
+    evmRpc<T>(method: string, params?: unknown[]): Promise<T>;
+    evmRpcBatch<T extends unknown[]>(calls: Array<{
+        method: string;
+        params?: unknown[];
+    }>): Promise<T>;
+}
+
 /**
  * Builds ZK notes (commitment + nullifier) and encrypted memos locally.
  *
@@ -1087,13 +1698,7 @@ declare class NoteBuilder {
  *
  * Cipher: ChaCha20-Poly1305 (IETF, 96-bit nonce)
  */
-/** Fields recovered from a successfully decrypted EncryptedMemo. */
-type DecryptedMemo = {
-    value: bigint;
-    ownerPk: bigint;
-    blinding: bigint;
-    assetId: bigint;
-};
+
 declare const EncryptedMemo: {
     /**
      * Build and encrypt a memo for a note.
@@ -1145,12 +1750,6 @@ declare const EncryptedMemo: {
  *   nullifier  = Poseidon2(commitment, spendingKey)
  */
 
-/** A single commitment record as returned by the indexer. */
-interface ScanCommitment {
-    commitmentHex: string;
-    leafIndex: number;
-    encryptedMemo: string | null;
-}
 /**
  * Attempt to decrypt an on-chain commitment using a viewing key.
  *
@@ -1219,16 +1818,20 @@ declare function deriveOwnerPk(spendingKey: bigint): bigint;
  * In-memory manager for the user's Orbinum shielded-pool identity.
  * Protocol-level module — no UI, no localStorage, no sessionStorage dependencies.
  *
- * Call `PrivacyKeyManager.load(spendingKey)` after deriving the key from a wallet
- * signature (see `deriveSpendingKeyFromSignature`).  The caller (application layer)
- * is responsible for key persistence and session caching.
+ * Create one instance per user session:
+ *   const pkm = new PrivacyKeyManager();
+ *   await pkm.load(spendingKey);
+ *
+ * The caller (application layer) is responsible for key persistence and session
+ * caching. Each instance holds independent state — safe for multi-wallet use.
  *
  * Derivation scheme:
  *   spendingKey (bigint, BN254 scalar)
  *     └── viewingKey   = HKDF-SHA256(spendingKey_bytes, info="orbinum-ivk-v1")  → 32 bytes
  *     └── ownerPk      = BabyJubJub Ax from (spendingKey * Base8)               → bigint
  */
-declare const PrivacyKeyManager: {
+declare class PrivacyKeyManager {
+    private _state;
     /**
      * Load a spending key into the in-memory session.
      * Derives viewingKey and ownerPk immediately.
@@ -1254,7 +1857,7 @@ declare const PrivacyKeyManager: {
      * Validates the key is in the valid range [1, BN254_R).
      */
     importFromHex(hex: string): Promise<void>;
-};
+}
 
 /**
  * VaultCrypto
@@ -1302,12 +1905,16 @@ 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;
+
 /**
  * Contract addresses and function selectors for all Orbinum EVM precompiles.
  *
  * Selectors are verified against the Rust source in frame/evm/precompile and
  * computed as `bytes4(keccak256("<functionName>(<argTypes>)"))`.
  */
+
 /** All precompile contract addresses. */
 declare const PRECOMPILE_ADDR: {
     readonly EC_RECOVER: "0x0000000000000000000000000000000000000001";
@@ -1322,13 +1929,6 @@ declare const PRECOMPILE_ADDR: {
     readonly ACCOUNT_MAPPING: "0x0000000000000000000000000000000000000800";
     readonly SHIELDED_POOL: "0x0000000000000000000000000000000000000801";
 };
-/** Metadata for a known precompile: display name and function selector map. */
-interface KnownPrecompileInfo {
-    /** Human-readable name, e.g. "ShieldedPool". */
-    name: string;
-    /** Map from 4-byte hex selector (no 0x prefix) to function signature. */
-    functions: Record<string, string>;
-}
 /**
  * Registry of all known Orbinum EVM precompiles, keyed by lowercase address.
  * Covers Ethereum standard (EIP), Frontier non-standard, and Orbinum custom precompiles.
@@ -1341,155 +1941,23 @@ declare const KNOWN_PRECOMPILES: Record<string, KnownPrecompileInfo>;
 declare function getPrecompileLabel(address: string | null | undefined): string | null;
 
 /**
- * Options for {@link formatBalance}.
- */
-interface FormatOptions {
-    /** On-chain token decimals. Defaults to `18`. */
-    decimals?: number;
-    /** Token symbol appended to the output. Defaults to `'ORB'`. */
-    symbol?: string;
-    /** Whether to append the symbol. Defaults to `true`. */
-    showSymbol?: boolean;
-    /** Maximum number of decimal digits shown in output. Defaults to `6`. */
-    precision?: number;
-}
-/**
- * Formats a raw on-chain token amount to a human-readable string.
- *
- * Handles the following input forms:
- * - `bigint` — raw planck/wei amount.
- * - `string` — decimal integer, hex (`0x`-prefixed), or already-formatted decimal.
- * - `number` — interpreted as a plain integer.
- * - `null` / `undefined` — treated as zero.
- *
- * Does NOT depend on `ethers`. Uses pure BigInt arithmetic.
- *
- * @example
- * formatBalance('1000000000000000000') // '1 ORB'
- * formatBalance(500000000000000000n, { precision: 2 }) // '0.50 ORB'
- * formatBalance('0x0de0b6b3a7640000', { showSymbol: false }) // '1'
- * formatBalance(null) // '0 ORB'
- */
-declare function formatBalance(raw: string | bigint | number | null | undefined, options?: FormatOptions | number): string;
-/**
- * Convenience wrapper for formatting ORB amounts with 18 decimals.
- *
- * @param raw       Raw planck amount (string, bigint, number, or null).
- * @param precision Max decimal digits shown. Defaults to `6`.
- *
- * @example
- * formatORB('1000000000000000000') // '1 ORB'
- * formatORB(500000000000000000n, 2) // '0.50 ORB'
- */
-declare function formatORB(raw: string | bigint | number | null | undefined, precision?: number): string;
-
-/**
- * Serialises a bigint as a 32-byte little-endian Uint8Array.
- */
-declare function bigintTo32Le(n: bigint): Uint8Array;
-/**
- * Deserialises a Uint8Array as a little-endian unsigned bigint.
- */
-declare function bytesToBigintLE(bytes: Uint8Array): bigint;
-/**
- * Serialises a bigint as a 32-byte big-endian Uint8Array.
- */
-declare function bigintTo32Be(n: bigint): Uint8Array;
-/**
- * Serialises a bigint as a 32-element little-endian number[].
- * Useful when building SCALE-encoded arguments via polkadot-api.
- */
-declare function bigintTo32LeArr(n: bigint): number[];
-/**
- * Computes the Merkle path direction bits for a leaf at `leafIndex`
- * in a binary Merkle tree of `depth` levels.
- * bit 0 = bottom level (leaf), bit depth-1 = top level (root sibling).
- */
-declare function computePathIndices(leafIndex: number, depth: number): number[];
-/**
- * Decodes a little-endian hex string (0x-prefixed or bare) to a bigint.
- * Equivalent to `bytesToBigintLE(fromHex(hex))`.
- */
-declare function leHexToBigint(hex: string): bigint;
-
-/**
- * Normalises an EVM address to lowercase with 0x prefix.
- */
-declare function normalizeEvmAddress(addr: string): string;
-/**
- * Returns true if the string looks like an SS58 encoded address
- * (not a 0x-prefixed hex).
- */
-declare function isSs58(addr: string): boolean;
-/**
- * Returns true if the string looks like a 20-byte EVM address.
- */
-declare function isEvmAddress(addr: string): boolean;
-/**
- * Pads a 20-byte EVM address to a 32-byte account ID (H256)
- * by prepending 12 zero bytes (Ethereum-compatible mapping).
- */
-declare function evmAddressToAccountId(evmAddr: string): Uint8Array;
-/**
- * Derives the implicit Substrate AccountId32 for an EVM address using the
- * EeSuffixAddressMapping rule: AccountId32 = H160 ++ [0x00; 12].
- *
- * This is the same rule applied by pallet-account-mapping's fallback when
- * there is no explicit `map_account` entry. Returns 0x-prefixed 64-char hex.
- *
- * @param evmAddr  0x-prefixed 20-byte EVM address.
- */
-declare function evmToImplicitSubstrate(evmAddr: string): string;
-/**
- * Returns true if the given AccountId32 hex was derived from an EVM address
- * via the EeSuffixAddressMapping (last 12 bytes are zero).
+ * Decodes calldata for known Orbinum EVM precompiles.
  *
- * @param accountHex  0x-prefixed 64-char AccountId32 hex.
+ * Returns raw decoded values (bigint amounts, hex strings for bytes32).
+ * Callers are responsible for display formatting.
  */
-declare function isImplicitEvmAccount(accountHex: string): boolean;
+type DecodedPrecompile = {
+    fnSig: string;
+    args: Record<string, unknown>;
+};
 /**
- * Extracts the EVM address (H160) from an implicit Substrate AccountId32
- * created by EeSuffixAddressMapping.  Throws if the account is not EVM-derived.
+ * Decodes EVM calldata for a known Orbinum precompile.
  *
- * @param accountHex  0x-prefixed 64-char AccountId32 hex.
- */
-declare function implicitSubstrateToEvm(accountHex: string): string;
-/**
- * Returns true if `addr` is a valid SS58 substrate address (not EVM).
- */
-declare function isSubstrateAddress(addr: string): boolean;
-/**
- * Returns true if `addr` is a Substrate SS58 address derived from an EVM H160
- * via the EeSuffixAddressMapping rule (last 12 bytes of AccountId are zero).
- */
-declare function isUnifiedAddress(addr: string): boolean;
-/**
- * Converts a unified (EVM-derived) Substrate SS58 address to its EVM H160.
- * Returns null for native Substrate accounts or invalid input.
- */
-declare function substrateToEvm(addr: string): string | null;
-/**
- * Converts an EVM H160 address to its Substrate SS58 equivalent
- * using the EeSuffixAddressMapping rule: AccountId32 = H160 ++ [0x00; 12].
- * Returns null on invalid input.
- */
-declare function evmToSubstrate(addr: string): string | null;
-/**
- * Converts a 32-byte AccountId hex (0x-prefixed or bare) to its SS58 string.
- * Returns null on invalid input.
- */
-declare function accountIdHexToSs58(hex: string): string | null;
-/**
- * Converts a Substrate SS58 address to its AccountId32 as a 0x-prefixed 64-char hex.
- * Returns null on invalid input.
- */
-declare function substrateSs58ToAccountIdHex(addr: string): string | null;
-/**
- * Universal converter: given any raw address string (SS58, 0x-prefixed 64-char
- * AccountId hex, or EVM H160), returns the AccountId32 hex (0x-prefixed).
- * Returns null on unrecognised input.
+ * @param address - The precompile contract address (0x-prefixed).
+ * @param input   - The transaction input data (0x-prefixed hex).
+ * @returns Decoded `{ fnSig, args }` with raw values, or `null` if unknown.
  */
-declare function addressToAccountIdHex(addr: string): string | null;
+declare function decodePrecompileCalldata(address: string, input: string): DecodedPrecompile | null;
 
 /**
  * TypeScript types for events emitted by pallet-shielded-pool.
@@ -1685,418 +2153,207 @@ type ShieldedPoolEvent = {
 };
 
 /**
- * TypeScript types for pallet-shielded-pool extrinsics and supporting structures.
+ * TypeScript types for pallet-zk-verifier extrinsics.
  *
  * Conventions:
- *   - Fixed/bounded byte arrays  → `number[]`  (SCALE-compatible)
- *   - Balances (u128)            → `bigint`
- *   - AccountId                  → `string`    (SS58 or 0x-prefixed 64-char hex)
- *   - Block numbers              → `number`
- *   - Optional fields            → `T | null`
+ *   - Byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Versions     → `number`    (u32)
  */
 /**
- * 32-byte SCALE-encoded value (commitment, nullifier, Merkle root, etc.).
- * Stored as little-endian Poseidon field elements on-chain.
+ * On-chain circuit identifier (u32 newtype on-chain).
+ * Use the {@link CircuitId} constant object for named values.
  */
-type Bytes32 = number[];
+type CircuitId = (typeof CircuitId)[keyof typeof CircuitId];
 /**
- * Structured disclosure public signals — exactly 76 bytes:
- *   commitment[0..32] | revealed_value[32..40] | revealed_asset_id[40..44] | owner_hash[44..76]
+ * Named constants for all supported ZK circuits.
+ *
+ * | Name         | Value | Circuit                         |
+ * |--------------|-------|---------------------------------|
+ * | Transfer     | 1     | 2-in-2-out private transfer     |
+ * | Unshield     | 2     | Withdrawal from the pool        |
+ * | Disclosure   | 3     | Selective disclosure            |
+ * | PrivateLink  | 4     | Private chain-link proof        |
  */
-type DisclosurePublicSignals = number[];
+declare const CircuitId: {
+    readonly Transfer: 1;
+    readonly Unshield: 2;
+    readonly Disclosure: 3;
+    readonly PrivateLink: 4;
+};
 /**
- * A single auditor entry in an audit policy.
- * Maps to `Auditor<AccountId>` in Rust.
+ * A single verification key registration entry used in batch operations.
+ * Maps to `VkEntry` in Rust.
  */
-type Auditor = {
-    /** SS58 or 0x-prefixed AccountId of the authorized auditor. */
-    account: string;
+type VkEntry = {
+    circuitId: CircuitId;
+    /** Circuit version number (u32 on-chain). Versions are independent per circuit. */
+    version: number;
+    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
+    verificationKey: number[];
 };
 /**
- * A condition that must be satisfied before disclosure is permitted.
- * Maps to `DisclosureCondition` in Rust. Max 10 conditions per policy.
+ * Call index 0 — `register_verification_key` (Root origin)
+ * Registers a Groth16 verification key for a specific circuit and version.
  */
-type DisclosureCondition = {
-    type: 'MinValue';
-    value: bigint;
-} | {
-    type: 'MaxValue';
-    value: bigint;
-} | {
-    type: 'AssetId';
-    assetId: number;
-} | {
-    type: 'RecipientIs';
-    recipient: string;
-} | {
-    type: 'Custom';
-    encoded: number[];
+type RegisterVerificationKeyArgs = {
+    circuitId: CircuitId;
+    /** Version to associate with this key. */
+    version: number;
+    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
+    verificationKey: number[];
 };
 /**
- * A single entry in a batch disclosure proof submission.
- * Maps to `BatchDisclosureSubmission<AccountId>` in Rust.
+ * Call index 1 — `set_active_version` (Root origin)
+ * Designates a specific version as the active one used for proof verification.
  */
-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 SetActiveVersionArgs = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * A single shield operation for use in `shield_batch`.
+ * Call index 2 — `remove_verification_key` (Root origin)
+ * Removes a registered verification key.
+ * The currently active version cannot be removed.
  */
-type ShieldOperation = {
-    assetId: number;
-    amount: bigint;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo bytes — exactly 104 bytes. */
-    encryptedMemo: number[];
+type RemoveVerificationKeyArgs = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 0 — `shield` (Signed origin)
- * Deposits a public token amount into the shielded pool.
+ * Call index 3 — `verify_proof` (Signed origin)
+ * Verifies a single Groth16 proof on-chain for the specified circuit.
+ * Uses the circuit's currently active verification key version.
  */
-type ShieldArgs = {
-    assetId: number;
-    amount: bigint;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo — exactly 104 bytes. */
-    encryptedMemo: number[];
+type VerifyProofArgs = {
+    circuitId: CircuitId;
+    /** Groth16 proof bytes. */
+    proof: number[];
+    /**
+     * Public inputs as a list of 32-byte field elements (LE).
+     * 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]
+     * - PrivateLink: [commitment, call_hash_fe]
+     */
+    publicInputs: number[][];
 };
 /**
- * Call index 12 — `shield_batch` (Signed origin)
- * Deposits multiple notes in a single extrinsic — max 20 operations.
+ * Call index 4 — `batch_register_verification_keys` (Root origin)
+ * Registers up to 10 verification keys in one extrinsic.
+ * Useful for initial chain setup or coordinated upgrades.
  */
-type ShieldBatchArgs = {
-    operations: ShieldOperation[];
-};
-/** Input note consumed by a private transfer. */
-type PrivateTransferInput = {
-    /** 32-byte Poseidon nullifier (LE). */
-    nullifier: Bytes32;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
+type BatchRegisterVerificationKeysArgs = {
+    /** Up to 10 VK entries. */
+    entries: VkEntry[];
 };
-/** Output note created by a private transfer. */
-type PrivateTransferOutput = {
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: Bytes32;
-    /** Encrypted memo — exactly 104 bytes. */
-    memo: number[];
+/** All pallet-zk-verifier calls as a discriminated union. */
+type ZkVerifierCall = {
+    type: 'registerVerificationKey';
+    args: RegisterVerificationKeyArgs;
+} | {
+    type: 'setActiveVersion';
+    args: SetActiveVersionArgs;
+} | {
+    type: 'removeVerificationKey';
+    args: RemoveVerificationKeyArgs;
+} | {
+    type: 'verifyProof';
+    args: VerifyProofArgs;
+} | {
+    type: 'batchRegisterVerificationKeys';
+    args: BatchRegisterVerificationKeysArgs;
 };
+
 /**
- * Call index 1 — `private_transfer` (Signed origin)
- * Transfers value between notes without revealing sender, recipient or amount.
- * Accepts 1–2 inputs and 1–2 outputs; total input value must equal total output value.
+ * TypeScript types for events emitted by pallet-zk-verifier.
+ *
+ * Conventions:
+ *   - CircuitId  → imported from pallet-extrinsics (u32 newtype)
+ *   - version    → `number` (u32)
+ *   - count      → `number` (u32)
  */
-type PrivateTransferArgs = {
-    /** Groth16 proof bytes — max 512 bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: Bytes32;
-    nullifiers: PrivateTransferInput[];
-    outputs: PrivateTransferOutput[];
-    encryptedMemos: number[][];
-};
+
 /**
- * Call index 2 — `unshield` (Signed origin)
- * Withdraws a note from the pool to a public account.
+ * Emitted by `register_verification_key()` when a new VK is stored.
+ * Rust variant: `VerificationKeyRegistered { circuit_id, version }`
  */
-type UnshieldArgs = {
-    /** Groth16 proof bytes — max 512 bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: Bytes32;
-    /** 32-byte nullifier of the spent note (LE). */
-    nullifier: Bytes32;
-    assetId: number;
-    amount: bigint;
-    /** SS58 or 0x-prefixed AccountId of the recipient. */
-    recipient: string;
+type VerificationKeyRegisteredEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 4 — `set_audit_policy` (Signed origin)
- * Registers or replaces the caller's audit policy for selective disclosure.
+ * Emitted by `set_active_version()` when the active VK version changes.
+ * Rust variant: `ActiveVersionSet { circuit_id, version }`
  */
-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;
+type ActiveVersionSetEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 5 — `request_disclosure` (Signed origin)
- * Auditor requests selective disclosure from a target account.
+ * Emitted by `remove_verification_key()` when a VK is deleted.
+ * Rust variant: `VerificationKeyRemoved { circuit_id, version }`
  */
-type RequestDisclosureArgs = {
-    /** AccountId of the disclosure target. */
-    target: string;
-    /** Human-readable request reason — max 256 bytes UTF-8. */
-    reason: string;
+type VerificationKeyRemovedEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 6 — `disclose` (Signed origin)
- * Submit a Groth16 disclosure proof for a commitment.
+ * Emitted by `verify_proof()` when a ZK proof is successfully verified.
+ * Rust variant: `ProofVerified { circuit_id, version }`
  */
-type DiscloseArgs = {
-    /** 32-byte note commitment to disclose (LE). */
-    commitment: Bytes32;
-    /** Groth16 proof bytes — max 256 bytes. */
-    proofBytes: number[];
-    /** 76-byte public signals: commitment(32) | value(8) | asset_id(4) | owner_hash(32). */
-    publicSignals: DisclosurePublicSignals;
-    /** Target auditor AccountId. Null = voluntary public disclosure. */
-    auditor: string | null;
+type ProofVerifiedEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 7 — `reject_disclosure` (Signed origin)
- * Disclosure target rejects a pending request from an auditor.
+ * Emitted by `verify_proof()` when ZK proof verification fails.
+ * Rust variant: `ProofVerificationFailed { circuit_id, version }`
  */
-type RejectDisclosureArgs = {
-    /** AccountId of the auditor whose request is rejected. */
-    auditor: string;
-    /** Rejection reason — max 256 bytes UTF-8. */
-    reason: string;
+type ProofVerificationFailedEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
 /**
- * Call index 13 — `batch_submit_disclosure_proofs` (Signed origin)
- * Submit up to 10 disclosure proofs in one extrinsic.
+ * Emitted by `batch_register_verification_keys()` on success.
+ * Rust variant: `BatchVerificationKeysRegistered { count }`
  */
-type BatchSubmitDisclosureProofsArgs = {
-    submissions: BatchDisclosureSubmission[];
+type BatchVerificationKeysRegisteredEvent = {
+    /** Number of VK entries registered in the batch. */
+    count: number;
 };
-/**
- * Call index 9 — `register_asset` (Root origin)
- * Registers a new asset in the shielded pool registry.
- */
-type RegisterAssetArgs = {
-    /** Asset name — max 64 bytes UTF-8. */
-    name: string;
-    /** Asset ticker symbol, e.g. "USDT" — max 16 bytes UTF-8. */
-    symbol: string;
-    /** Token decimal precision (e.g. 18 for ORB, 6 for USDT). */
-    decimals: number;
-    /** 20-byte EVM contract address for ERC-20 assets. Null = native asset. */
-    contractAddress: number[] | null;
+/** All events emitted by pallet-zk-verifier as a discriminated union. */
+type ZkVerifierEvent = {
+    type: 'VerificationKeyRegistered';
+    data: VerificationKeyRegisteredEvent;
+} | {
+    type: 'ActiveVersionSet';
+    data: ActiveVersionSetEvent;
+} | {
+    type: 'VerificationKeyRemoved';
+    data: VerificationKeyRemovedEvent;
+} | {
+    type: 'ProofVerified';
+    data: ProofVerifiedEvent;
+} | {
+    type: 'ProofVerificationFailed';
+    data: ProofVerificationFailedEvent;
+} | {
+    type: 'BatchVerificationKeysRegistered';
+    data: BatchVerificationKeysRegisteredEvent;
 };
+
 /**
- * Call index 10 — `verify_asset` (Root origin)
- * Marks a registered asset as verified, enabling shielding.
+ * TypeScript types for pallet-account-mapping extrinsics.
+ *
+ * Conventions:
+ *   - Byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Balances     → `bigint`
+ *   - AccountId    → `string`    (SS58 or 0x-prefixed 64-char hex)
+ *   - ChainId      → `number`    (u32, typically a SLIP-0044 coin type)
+ *   - Optional     → `T | null`
  */
-type VerifyAssetArgs = {
-    assetId: number;
-};
-/**
- * Call index 11 — `unverify_asset` (Root origin)
- * Removes the verified status from an asset, disabling new shield operations.
- */
-type UnverifyAssetArgs = {
-    assetId: number;
-};
-/**
- * Call index 14 — `prune_expired_request` (Signed origin)
- * Cleans up a disclosure request that has passed its expiration block.
- */
-type PruneExpiredRequestArgs = {
-    /** AccountId of the disclosure target. */
-    target: string;
-    /** AccountId of the auditor. */
-    auditor: string;
-};
-/**
- * Call index 15 — `revoke_disclosure_record` (Signed origin)
- * Allows the note owner to revoke a previously submitted disclosure record.
- */
-type RevokeDisclosureRecordArgs = {
-    /** 32-byte commitment whose disclosure record should be revoked (LE). */
-    commitment: Bytes32;
-};
-/** All pallet-shielded-pool calls as a discriminated union. */
-type ShieldedPoolCall = {
-    type: 'shield';
-    args: ShieldArgs;
-} | {
-    type: 'shieldBatch';
-    args: ShieldBatchArgs;
-} | {
-    type: 'privateTransfer';
-    args: PrivateTransferArgs;
-} | {
-    type: 'unshield';
-    args: UnshieldArgs;
-} | {
-    type: 'setAuditPolicy';
-    args: SetAuditPolicyArgs;
-} | {
-    type: 'requestDisclosure';
-    args: RequestDisclosureArgs;
-} | {
-    type: 'disclose';
-    args: DiscloseArgs;
-} | {
-    type: 'rejectDisclosure';
-    args: RejectDisclosureArgs;
-} | {
-    type: 'batchSubmitDisclosureProofs';
-    args: BatchSubmitDisclosureProofsArgs;
-} | {
-    type: 'registerAsset';
-    args: RegisterAssetArgs;
-} | {
-    type: 'verifyAsset';
-    args: VerifyAssetArgs;
-} | {
-    type: 'unverifyAsset';
-    args: UnverifyAssetArgs;
-} | {
-    type: 'pruneExpiredRequest';
-    args: PruneExpiredRequestArgs;
-} | {
-    type: 'revokeDisclosureRecord';
-    args: RevokeDisclosureRecordArgs;
-};
-
-/**
- * TypeScript types for pallet-zk-verifier extrinsics.
- *
- * Conventions:
- *   - Byte arrays  → `number[]`  (SCALE-compatible)
- *   - Versions     → `number`    (u32)
- */
-/**
- * On-chain circuit identifier (u32 newtype on-chain).
- * Use the {@link CircuitId} constant object for named values.
- */
-type CircuitId = (typeof CircuitId)[keyof typeof CircuitId];
-/**
- * Named constants for all supported ZK circuits.
- *
- * | Name         | Value | Circuit                         |
- * |--------------|-------|---------------------------------|
- * | Transfer     | 1     | 2-in-2-out private transfer     |
- * | Unshield     | 2     | Withdrawal from the pool        |
- * | Disclosure   | 3     | Selective disclosure            |
- * | PrivateLink  | 4     | Private chain-link proof        |
- */
-declare const CircuitId: {
-    readonly Transfer: 1;
-    readonly Unshield: 2;
-    readonly Disclosure: 3;
-    readonly PrivateLink: 4;
-};
-/**
- * A single verification key registration entry used in batch operations.
- * Maps to `VkEntry` in Rust.
- */
-type VkEntry = {
-    circuitId: CircuitId;
-    /** Circuit version number (u32 on-chain). Versions are independent per circuit. */
-    version: number;
-    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
-    verificationKey: number[];
-};
-/**
- * Call index 0 — `register_verification_key` (Root origin)
- * Registers a Groth16 verification key for a specific circuit and version.
- */
-type RegisterVerificationKeyArgs = {
-    circuitId: CircuitId;
-    /** Version to associate with this key. */
-    version: number;
-    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
-    verificationKey: number[];
-};
-/**
- * Call index 1 — `set_active_version` (Root origin)
- * Designates a specific version as the active one used for proof verification.
- */
-type SetActiveVersionArgs = {
-    circuitId: CircuitId;
-    version: number;
-};
-/**
- * Call index 2 — `remove_verification_key` (Root origin)
- * Removes a registered verification key.
- * The currently active version cannot be removed.
- */
-type RemoveVerificationKeyArgs = {
-    circuitId: CircuitId;
-    version: number;
-};
-/**
- * Call index 3 — `verify_proof` (Signed origin)
- * Verifies a single Groth16 proof on-chain for the specified circuit.
- * Uses the circuit's currently active verification key version.
- */
-type VerifyProofArgs = {
-    circuitId: CircuitId;
-    /** Groth16 proof bytes. */
-    proof: number[];
-    /**
-     * Public inputs as a list of 32-byte field elements (LE).
-     * 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]
-     * - PrivateLink: [commitment, call_hash_fe]
-     */
-    publicInputs: number[][];
-};
-/**
- * Call index 4 — `batch_register_verification_keys` (Root origin)
- * Registers up to 10 verification keys in one extrinsic.
- * Useful for initial chain setup or coordinated upgrades.
- */
-type BatchRegisterVerificationKeysArgs = {
-    /** Up to 10 VK entries. */
-    entries: VkEntry[];
-};
-/** All pallet-zk-verifier calls as a discriminated union. */
-type ZkVerifierCall = {
-    type: 'registerVerificationKey';
-    args: RegisterVerificationKeyArgs;
-} | {
-    type: 'setActiveVersion';
-    args: SetActiveVersionArgs;
-} | {
-    type: 'removeVerificationKey';
-    args: RemoveVerificationKeyArgs;
-} | {
-    type: 'verifyProof';
-    args: VerifyProofArgs;
-} | {
-    type: 'batchRegisterVerificationKeys';
-    args: BatchRegisterVerificationKeysArgs;
-};
 
-/**
- * TypeScript types for pallet-account-mapping extrinsics.
- *
- * Conventions:
- *   - Byte arrays  → `number[]`  (SCALE-compatible)
- *   - Balances     → `bigint`
- *   - AccountId    → `string`    (SS58 or 0x-prefixed 64-char hex)
- *   - ChainId      → `number`    (u32, typically a SLIP-0044 coin type)
- *   - Optional     → `T | null`
- */
-/**
- * External chain signature scheme.
- * Maps to `SignatureScheme` enum in pallet-account-mapping.
- *
- * - `Eip191`  — Ethereum personal_sign (EIP-191 prefix)
- * - `Ed25519` — Raw Ed25519 signature (Solana, Polkadot, etc.)
- */
-type SignatureScheme = 'Eip191' | 'Ed25519';
 /**
  * Call index 2 — `register_alias` (Signed origin)
  * Registers a human-readable identity alias for the caller's Substrate account.
@@ -2313,132 +2570,54 @@ type AccountMappingCall = {
 };
 
 /**
- * TypeScript types for events emitted by pallet-zk-verifier.
+ * TypeScript types for events emitted by pallet-account-mapping.
  *
  * Conventions:
- *   - CircuitId  → imported from pallet-extrinsics (u32 newtype)
- *   - version    → `number` (u32)
- *   - count      → `number` (u32)
+ *   - AccountId     → `string`  (SS58)
+ *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
+ *   - AliasOf<T>    → `string`  (bounded string, max configurable)
+ *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
+ *   - ExternalAddr  → `string`  (chain-specific address string)
+ *   - BalanceOf<T>  → `bigint`
+ *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
+ *   - SignatureScheme → imported from pallet-extrinsics
  */
 
 /**
- * Emitted by `register_verification_key()` when a new VK is stored.
- * Rust variant: `VerificationKeyRegistered { circuit_id, version }`
+ * Emitted when a Substrate account is mapped to an Ethereum address.
+ * Rust variant: `AccountMapped { account, address }`
  */
-type VerificationKeyRegisteredEvent = {
-    circuitId: CircuitId;
-    version: number;
+type AccountMappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
 };
 /**
- * Emitted by `set_active_version()` when the active VK version changes.
- * Rust variant: `ActiveVersionSet { circuit_id, version }`
+ * Emitted when an existing account mapping is removed.
+ * Rust variant: `AccountUnmapped { account, address }`
  */
-type ActiveVersionSetEvent = {
-    circuitId: CircuitId;
-    version: number;
+type AccountUnmappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
 };
 /**
- * Emitted by `remove_verification_key()` when a VK is deleted.
- * Rust variant: `VerificationKeyRemoved { circuit_id, version }`
+ * Emitted by `register_alias()` when a new alias is claimed.
+ * Rust variant: `AliasRegistered { account, alias, evm_address }`
  */
-type VerificationKeyRemovedEvent = {
-    circuitId: CircuitId;
-    version: number;
+type AliasRegisteredEvent = {
+    account: string;
+    alias: string;
+    /** Optional EVM address linked at registration time. */
+    evmAddress: string | null;
 };
 /**
- * Emitted by `verify_proof()` when a ZK proof is successfully verified.
- * Rust variant: `ProofVerified { circuit_id, version }`
+ * Emitted when an alias is released (burned / expired).
+ * Rust variant: `AliasReleased { account, alias }`
  */
-type ProofVerifiedEvent = {
-    circuitId: CircuitId;
-    version: number;
-};
-/**
- * Emitted by `verify_proof()` when ZK proof verification fails.
- * Rust variant: `ProofVerificationFailed { circuit_id, version }`
- */
-type ProofVerificationFailedEvent = {
-    circuitId: CircuitId;
-    version: number;
-};
-/**
- * Emitted by `batch_register_verification_keys()` on success.
- * Rust variant: `BatchVerificationKeysRegistered { count }`
- */
-type BatchVerificationKeysRegisteredEvent = {
-    /** Number of VK entries registered in the batch. */
-    count: number;
-};
-/** All events emitted by pallet-zk-verifier as a discriminated union. */
-type ZkVerifierEvent = {
-    type: 'VerificationKeyRegistered';
-    data: VerificationKeyRegisteredEvent;
-} | {
-    type: 'ActiveVersionSet';
-    data: ActiveVersionSetEvent;
-} | {
-    type: 'VerificationKeyRemoved';
-    data: VerificationKeyRemovedEvent;
-} | {
-    type: 'ProofVerified';
-    data: ProofVerifiedEvent;
-} | {
-    type: 'ProofVerificationFailed';
-    data: ProofVerificationFailedEvent;
-} | {
-    type: 'BatchVerificationKeysRegistered';
-    data: BatchVerificationKeysRegisteredEvent;
-};
-
-/**
- * TypeScript types for events emitted by pallet-account-mapping.
- *
- * Conventions:
- *   - AccountId     → `string`  (SS58)
- *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
- *   - AliasOf<T>    → `string`  (bounded string, max configurable)
- *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
- *   - ExternalAddr  → `string`  (chain-specific address string)
- *   - BalanceOf<T>  → `bigint`
- *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
- *   - SignatureScheme → imported from pallet-extrinsics
- */
-
-/**
- * Emitted when a Substrate account is mapped to an Ethereum address.
- * Rust variant: `AccountMapped { account, address }`
- */
-type AccountMappedEvent = {
-    account: string;
-    /** 0x-prefixed 20-byte Ethereum address. */
-    address: string;
-};
-/**
- * Emitted when an existing account mapping is removed.
- * Rust variant: `AccountUnmapped { account, address }`
- */
-type AccountUnmappedEvent = {
-    account: string;
-    /** 0x-prefixed 20-byte Ethereum address. */
-    address: string;
-};
-/**
- * Emitted by `register_alias()` when a new alias is claimed.
- * Rust variant: `AliasRegistered { account, alias, evm_address }`
- */
-type AliasRegisteredEvent = {
-    account: string;
-    alias: string;
-    /** Optional EVM address linked at registration time. */
-    evmAddress: string | null;
-};
-/**
- * Emitted when an alias is released (burned / expired).
- * Rust variant: `AliasReleased { account, alias }`
- */
-type AliasReleasedEvent = {
-    account: string;
-    alias: string;
+type AliasReleasedEvent = {
+    account: string;
+    alias: string;
 };
 /**
  * Emitted by `transfer_alias()` when ownership changes hands.
@@ -2624,135 +2803,761 @@ type AccountMappingEvent = {
     data: PrivateLinkDispatchExecutedEvent;
 };
 
-/** Configuration for IndexerClient. */
-interface IndexerClientConfig {
-    /** Base URL of the indexer REST API (no trailing slash). */
-    baseUrl: string;
-    /** Request timeout in ms. Default: 10_000. */
-    timeoutMs?: number;
-}
-/** Generic paginated result returned by list endpoints. */
-interface PaginatedResult<T> {
-    data: T[];
-    pagination: {
-        page: number;
-        limit: number;
-        total: number;
-    };
-}
-/** A shielded commitment (shield event) stored by the indexer. */
-interface ShieldedCommitment {
-    commitmentHex: string;
-    blockNumber: number;
-    extrinsicIndex: number | null;
-    leafIndex: number;
-    /** Asset ID as decimal string (e.g. "0"). */
-    assetId: string;
-    /** SS58 or 0x-prefixed depositor address, null if not tracked. */
-    sender: string | null;
-    /** 0x-prefixed encrypted memo hex, null if not present. */
-    encryptedMemo: string | null;
-    timestampMs: number | null;
-}
-/** A spent nullifier stored by the indexer. */
-interface SpentNullifier {
-    nullifierHex: string;
-    blockNumber: number;
-    extrinsicIndex: number | null;
-    txType: 'unshield' | 'private_transfer';
-    timestampMs: number | null;
-}
-/** A private transfer event stored by the indexer. */
-interface PrivateTransfer {
-    /** "{blockNumber}-{extrinsicIndex}" */
-    id: string;
-    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;
-    timestampMs: number | null;
-}
-/** An unshield event stored by the indexer. */
-interface Unshield {
-    /** "{blockNumber}-{extrinsicIndex}" */
-    id: string;
-    blockNumber: number;
-    extrinsicIndex: number | null;
-    nullifierHex: string;
-    /** Asset ID as decimal string. */
-    assetId: string;
-    /** Amount as decimal string (bigint-safe). */
-    amount: string;
-    recipient: string;
-    timestampMs: number | null;
-}
-/** A Merkle root checkpoint stored by the indexer. */
-interface MerkleRoot {
-    id: number;
-    rootHex: string;
-    blockNumber: number;
-    oldRootHex: string | null;
-    treeSize: number;
-    timestampMs: number | null;
-}
-/** Response from the nullifier status endpoint. */
-interface NullifierStatusResult {
-    nullifier: string;
-    spent: boolean;
-    txType?: 'unshield' | 'private_transfer';
-    blockNumber?: number;
-}
 /**
- * HTTP client for the Orbinum indexer REST API.
+ * TypeScript types for pallet-shielded-pool extrinsics and supporting structures.
  *
- * All methods throw on network errors.
- * Methods returning a single entity return `null` when the server responds 404.
+ * Conventions:
+ *   - Fixed/bounded byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Balances (u128)            → `bigint`
+ *   - AccountId                  → `string`    (SS58 or 0x-prefixed 64-char hex)
+ *   - Block numbers              → `number`
+ *   - Optional fields            → `T | null`
  */
-declare class IndexerClient {
-    private readonly baseUrl;
-    private readonly timeoutMs;
-    constructor(config: IndexerClientConfig);
-    private get;
-    private getOrNull;
-    private buildQuery;
-    /** Returns the total count of shielded commitments. */
-    getCommitmentsCount(): Promise<number>;
-    /** Returns a paginated list of shielded commitments. */
-    getCommitments(params?: {
-        page?: number;
-        limit?: number;
-        sinceLeafIndex?: number;
-    }): 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 spent nullifiers. */
-    getNullifiers(params?: {
-        page?: number;
-        limit?: number;
-    }): 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>>;
-    /** Returns a paginated list of unshield events. */
-    getUnshields(params?: {
-        page?: number;
-        limit?: number;
-    }): Promise<PaginatedResult<Unshield>>;
-    /** Returns a paginated list of Merkle root checkpoints. */
-    getMerkleRoots(params?: {
-        page?: number;
-        limit?: number;
-    }): Promise<PaginatedResult<MerkleRoot>>;
-    /** Returns the latest Merkle root, or null if none exists. */
-    getLatestMerkleRoot(): Promise<MerkleRoot | null>;
+/**
+ * 32-byte SCALE-encoded value (commitment, nullifier, Merkle root, etc.).
+ * Stored as little-endian Poseidon field elements on-chain.
+ */
+type Bytes32 = number[];
+/**
+ * Structured disclosure public signals — exactly 76 bytes:
+ *   commitment[0..32] | revealed_value[32..40] | revealed_asset_id[40..44] | owner_hash[44..76]
+ */
+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;
+};
+/**
+ * A single shield operation for use in `shield_batch`.
+ */
+type ShieldOperation = {
+    assetId: number;
+    amount: bigint;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo bytes — exactly 104 bytes. */
+    encryptedMemo: number[];
+};
+/**
+ * Call index 0 — `shield` (Signed origin)
+ * Deposits a public token amount into the shielded pool.
+ */
+type ShieldArgs = {
+    assetId: number;
+    amount: bigint;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo — exactly 104 bytes. */
+    encryptedMemo: number[];
+};
+/**
+ * Call index 12 — `shield_batch` (Signed origin)
+ * Deposits multiple notes in a single extrinsic — max 20 operations.
+ */
+type ShieldBatchArgs = {
+    operations: ShieldOperation[];
+};
+/** Input note consumed by a private transfer (SCALE wire format). */
+type RawTransferInput = {
+    /** 32-byte Poseidon nullifier (LE). */
+    nullifier: Bytes32;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+};
+/** Output note created by a private transfer (SCALE wire format). */
+type RawTransferOutput = {
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+    /** Encrypted memo — exactly 104 bytes. */
+    memo: number[];
+};
+/**
+ * Call index 1 — `private_transfer` (Signed origin)
+ * Transfers value between notes without revealing sender, recipient or amount.
+ * Accepts 1–2 inputs and 1–2 outputs; total input value must equal total output value.
+ */
+type PrivateTransferArgs = {
+    /** Groth16 proof bytes — max 512 bytes. */
+    proof: number[];
+    /** 32-byte Merkle root (LE). */
+    merkleRoot: Bytes32;
+    nullifiers: RawTransferInput[];
+    outputs: RawTransferOutput[];
+    encryptedMemos: number[][];
+};
+/**
+ * Call index 2 — `unshield` (Signed origin)
+ * Withdraws a note from the pool to a public account.
+ */
+type UnshieldArgs = {
+    /** Groth16 proof bytes — max 512 bytes. */
+    proof: number[];
+    /** 32-byte Merkle root (LE). */
+    merkleRoot: Bytes32;
+    /** 32-byte nullifier of the spent note (LE). */
+    nullifier: Bytes32;
+    assetId: number;
+    amount: bigint;
+    /** SS58 or 0x-prefixed AccountId of the recipient. */
+    recipient: string;
+};
+/**
+ * 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[];
+};
+/**
+ * Call index 9 — `register_asset` (Root origin)
+ * Registers a new asset in the shielded pool registry.
+ */
+type RegisterAssetArgs = {
+    /** Asset name — max 64 bytes UTF-8. */
+    name: string;
+    /** Asset ticker symbol, e.g. "USDT" — max 16 bytes UTF-8. */
+    symbol: string;
+    /** Token decimal precision (e.g. 18 for ORB, 6 for USDT). */
+    decimals: number;
+    /** 20-byte EVM contract address for ERC-20 assets. Null = native asset. */
+    contractAddress: number[] | null;
+};
+/**
+ * Call index 10 — `verify_asset` (Root origin)
+ * Marks a registered asset as verified, enabling shielding.
+ */
+type VerifyAssetArgs = {
+    assetId: number;
+};
+/**
+ * Call index 11 — `unverify_asset` (Root origin)
+ * Removes the verified status from an asset, disabling new shield operations.
+ */
+type UnverifyAssetArgs = {
+    assetId: number;
+};
+/**
+ * Call index 14 — `prune_expired_request` (Signed origin)
+ * Cleans up a disclosure request that has passed its expiration block.
+ */
+type PruneExpiredRequestArgs = {
+    /** AccountId of the disclosure target. */
+    target: string;
+    /** AccountId of the auditor. */
+    auditor: string;
+};
+/**
+ * Call index 15 — `revoke_disclosure_record` (Signed origin)
+ * Allows the note owner to revoke a previously submitted disclosure record.
+ */
+type RevokeDisclosureRecordArgs = {
+    /** 32-byte commitment whose disclosure record should be revoked (LE). */
+    commitment: Bytes32;
+};
+/** All pallet-shielded-pool calls as a discriminated union. */
+type ShieldedPoolCall = {
+    type: 'shield';
+    args: ShieldArgs;
+} | {
+    type: 'shieldBatch';
+    args: ShieldBatchArgs;
+} | {
+    type: 'privateTransfer';
+    args: PrivateTransferArgs;
+} | {
+    type: 'unshield';
+    args: UnshieldArgs;
+} | {
+    type: 'setAuditPolicy';
+    args: SetAuditPolicyArgs;
+} | {
+    type: 'requestDisclosure';
+    args: RequestDisclosureArgs;
+} | {
+    type: 'disclose';
+    args: DiscloseArgs;
+} | {
+    type: 'rejectDisclosure';
+    args: RejectDisclosureArgs;
+} | {
+    type: 'batchSubmitDisclosureProofs';
+    args: BatchSubmitDisclosureProofsArgs;
+} | {
+    type: 'registerAsset';
+    args: RegisterAssetArgs;
+} | {
+    type: 'verifyAsset';
+    args: VerifyAssetArgs;
+} | {
+    type: 'unverifyAsset';
+    args: UnverifyAssetArgs;
+} | {
+    type: 'pruneExpiredRequest';
+    args: PruneExpiredRequestArgs;
+} | {
+    type: 'revokeDisclosureRecord';
+    args: RevokeDisclosureRecordArgs;
+};
+
+/**
+ * Options for {@link formatBalance}.
+ */
+interface FormatOptions {
+    /** On-chain token decimals. Defaults to `18`. */
+    decimals?: number;
+    /** Token symbol appended to the output. Defaults to `'ORB'`. */
+    symbol?: string;
+    /** Whether to append the symbol. Defaults to `true`. */
+    showSymbol?: boolean;
+    /** Maximum number of decimal digits shown in output. Defaults to `6`. */
+    precision?: number;
+}
+/**
+ * Formats a raw on-chain token amount to a human-readable string.
+ *
+ * Handles the following input forms:
+ * - `bigint` — raw planck/wei amount.
+ * - `string` — canonical decimal integer, canonical hex (`0x`/`0X`-prefixed), or canonical decimal.
+ * - `number` — converted via `String(number)` and accepted only if it matches one of the
+ *   supported canonical numeric formats.
+ * - `null` / `undefined` — treated as zero.
+ *
+ * Rejected string formats return zero instead of being coerced. This includes grouped values
+ * such as `1,000`, scientific notation such as `1e18`, underscored numbers, and explicit plus
+ * signs such as `+1`.
+ *
+ * Does NOT depend on `ethers`. Uses pure BigInt arithmetic.
+ *
+ * @example
+ * formatBalance('1000000000000000000') // '1 ORB'
+ * formatBalance(500000000000000000n, { precision: 2 }) // '0.50 ORB'
+ * formatBalance('0x0de0b6b3a7640000', { showSymbol: false }) // '1'
+ * formatBalance(null) // '0 ORB'
+ */
+declare function formatBalance(raw: string | bigint | number | null | undefined, options?: FormatOptions | number): string;
+/**
+ * Convenience wrapper for formatting ORB amounts with 18 decimals.
+ *
+ * @param raw       Raw planck amount (string, bigint, number, or null).
+ * @param precision Max decimal digits shown. Defaults to `6`.
+ *
+ * @example
+ * formatORB('1000000000000000000') // '1 ORB'
+ * formatORB(500000000000000000n, 2) // '0.50 ORB'
+ */
+declare function formatORB(raw: string | bigint | number | null | undefined, precision?: number): string;
+
+/** Truncate a string in the middle with an ellipsis. */
+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;
+
+/**
+ * Serialises a bigint as a 32-byte little-endian Uint8Array.
+ */
+declare function bigintTo32Le(n: bigint): Uint8Array;
+/**
+ * Deserialises a Uint8Array as a little-endian unsigned bigint.
+ */
+declare function bytesToBigintLE(bytes: Uint8Array): bigint;
+/**
+ * Serialises a bigint as a 32-byte big-endian Uint8Array.
+ */
+declare function bigintTo32Be(n: bigint): Uint8Array;
+/**
+ * Serialises a bigint as a 32-element little-endian number[].
+ * Useful when building SCALE-encoded arguments via polkadot-api.
+ */
+declare function bigintTo32LeArr(n: bigint): number[];
+/**
+ * Computes the Merkle path direction bits for a leaf at `leafIndex`
+ * in a binary Merkle tree of `depth` levels.
+ * bit 0 = bottom level (leaf), bit depth-1 = top level (root sibling).
+ */
+declare function computePathIndices(leafIndex: number, depth: number): number[];
+/**
+ * Decodes a little-endian hex string (0x-prefixed or bare) to a bigint.
+ * Equivalent to `bytesToBigintLE(fromHex(hex))`.
+ */
+declare function leHexToBigint(hex: string): bigint;
+
+/**
+ * Normalises an EVM address to lowercase with 0x prefix.
+ */
+declare function normalizeEvmAddress(addr: string): string;
+/**
+ * Returns true if the string looks like an SS58 encoded address
+ * (not a 0x-prefixed hex).
+ */
+declare function isSs58(addr: string): boolean;
+/**
+ * Returns true if the string looks like a 20-byte EVM address.
+ */
+declare function isEvmAddress(addr: string): boolean;
+/**
+ * Pads a 20-byte EVM address to a 32-byte account ID (H256)
+ * by prepending 12 zero bytes (Ethereum-compatible mapping).
+ */
+declare function evmAddressToAccountId(evmAddr: string): Uint8Array;
+/**
+ * Derives the implicit Substrate AccountId32 for an EVM address using the
+ * EeSuffixAddressMapping rule: AccountId32 = H160 ++ [0x00; 12].
+ *
+ * This is the same rule applied by pallet-account-mapping's fallback when
+ * there is no explicit `map_account` entry. Returns 0x-prefixed 64-char hex.
+ *
+ * @param evmAddr  0x-prefixed 20-byte EVM address.
+ */
+declare function evmToImplicitSubstrate(evmAddr: string): string;
+/**
+ * Converts an EVM H160 address to the 32-byte AccountId32 hex used by
+ * pallet-account-mapping (EeSuffixAddressMapping: H160 ++ [0x00; 12]).
+ * Returns null for invalid or non-EVM input.
+ *
+ * @param address  0x-prefixed EVM H160 address (or bare 40-char hex).
+ */
+declare function evmToMappedAccountHex(address: string): string | null;
+/**
+ * Returns true if the given AccountId32 hex was derived from an EVM address
+ * via the EeSuffixAddressMapping (last 12 bytes are zero).
+ *
+ * @param accountHex  0x-prefixed 64-char AccountId32 hex.
+ */
+declare function isImplicitEvmAccount(accountHex: string): boolean;
+/**
+ * Extracts the EVM address (H160) from an implicit Substrate AccountId32
+ * created by EeSuffixAddressMapping.  Throws if the account is not EVM-derived.
+ *
+ * @param accountHex  0x-prefixed 64-char AccountId32 hex.
+ */
+declare function implicitSubstrateToEvm(accountHex: string): string;
+/**
+ * Returns true if `addr` is a valid SS58 substrate address (not EVM).
+ */
+declare function isSubstrateAddress(addr: string): boolean;
+/**
+ * Returns true if `addr` is a Substrate SS58 address derived from an EVM H160
+ * via the EeSuffixAddressMapping rule (last 12 bytes of AccountId are zero).
+ */
+declare function isUnifiedAddress(addr: string): boolean;
+/**
+ * Converts a unified (EVM-derived) Substrate SS58 address to its EVM H160.
+ * Returns null for native Substrate accounts or invalid input.
+ */
+declare function substrateToEvm(addr: string): string | null;
+/**
+ * Converts an EVM H160 address to its Substrate SS58 equivalent
+ * using the EeSuffixAddressMapping rule: AccountId32 = H160 ++ [0x00; 12].
+ * Returns null on invalid input.
+ */
+declare function evmToSubstrate(addr: string): string | null;
+/**
+ * Converts a 32-byte AccountId hex (0x-prefixed or bare) to its SS58 string.
+ * Returns null on invalid input.
+ */
+declare function accountIdHexToSs58(hex: string): string | null;
+/**
+ * Converts a Substrate SS58 address to its AccountId32 as a 0x-prefixed 64-char hex.
+ * Returns null on invalid input.
+ */
+declare function substrateSs58ToAccountIdHex(addr: string): string | null;
+/**
+ * Universal converter: given any raw address string (SS58, 0x-prefixed 64-char
+ * AccountId hex, or EVM H160), returns the AccountId32 hex (0x-prefixed).
+ * Returns null on unrecognised input.
+ */
+declare function addressToAccountIdHex(addr: string): string | null;
+
+/**
+ * Utilities for decoding on-chain extrinsic arguments and event data.
+ *
+ * Substrate/PAPI nodes return positional arg keys (`arg0`, `arg1`, …) when
+ * metadata-based decoding is unavailable. These helpers map those positions
+ * to human-readable semantic names for all Orbinum pallets.
+ */
+/**
+ * Maps raw extrinsic args (which may use positional keys like `arg0`, `arg1`)
+ * to semantic field names for a given pallet section/method.
+ *
+ * @param section - Pallet name (e.g. `'shieldedPool'`).
+ * @param method  - Call name (e.g. `'shield'`).
+ * @param args    - Raw args object from the node.
+ * @returns Remapped args with semantic keys, or the original object if unknown.
+ */
+declare function mapExtrinsicArgs(section: string, method: string, args: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Maps raw event data fields (which may use positional keys) to semantic names
+ * for shielded-pool, account-mapping, zk-verifier, evm, ethereum and system events.
+ *
+ * @param method - Event name (e.g. `'shielded'`, `'aliasRegistered'`).
+ * @param data   - Raw event data fields.
+ * @returns Remapped data with semantic keys, or the original object if unknown.
+ */
+declare function mapZkEventData(method: string, data: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Decoded extrinsic arg shapes — "explorer/read path".
+ *
+ * These interfaces mirror on-chain arg shapes as they appear after JSON
+ * decoding (snake_case keys, string amounts).  They are intentionally
+ * different from the call-builder types in shielded-pool/types/pallet-extrinsics.ts
+ * which use camelCase and bigint/Bytes32 for SCALE construction.
+ */
+interface DecodedShieldArgs {
+    asset_id: number | string;
+    amount: string;
+    commitment: string;
+    encrypted_memo: string;
+}
+interface DecodedShieldBatchOperation {
+    asset_id: number | string;
+    amount: string;
+    commitment: string;
+    encrypted_memo: string;
+}
+interface DecodedShieldBatchArgs {
+    operations: DecodedShieldBatchOperation[];
+}
+interface DecodedPrivateTransferArgs {
+    proof: string;
+    merkle_root: string;
+    nullifiers: string[];
+    commitments: string[];
+    encrypted_memos: string[];
+}
+interface DecodedUnshieldArgs {
+    proof: string;
+    merkle_root: string;
+    nullifier: string;
+    asset_id: number | string;
+    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;
+}
+type DecodedTransferKeepAliveArgs = DecodedTransferArgs;
+interface DecodedTransferAllArgs {
+    dest: string;
+    keep_alive: boolean;
+}
+interface DecodedBatchArgs {
+    calls: unknown[];
+}
+interface DecodedSudoArgs {
+    call: unknown;
+}
+interface DecodedRemarkArgs {
+    remark: string;
+}
+interface DecodedRegisterAliasArgs {
+    alias: string;
+}
+interface DecodedPutAliasForSaleArgs {
+    asking_price: string;
+    sale_type: string;
+    whitelist_count?: number;
+}
+interface DecodedSetAccountMetadataArgs {
+    display_name: string;
+    bio: string;
+    avatar: string;
+}
+interface DecodedAddChainLinkArgs {
+    chain_id: number | string;
+    target_address: string;
+    signature: string;
+}
+interface DecodedRevealPrivateLinkArgs {
+    commitment: string;
+    address: string;
+    blinding: string;
+    signature: string;
+}
+interface DecodedDispatchAsPrivateLinkArgs {
+    owner: string;
+    commitment: string;
+    zk_proof: string;
+    inner_call: string;
+}
+interface DecodedEthereumTransactArgs {
+    tx_type: string;
+    chain_id?: number;
+    nonce?: number;
+    gas_limit?: number;
+    to: string;
+    value?: string;
+    input: string;
+}
+interface DecodedEvmCallArgs {
+    source: string;
+    target: string;
+    input: string;
+    value: string;
+    gas_limit: number;
+}
+
+/**
+ * Decoded pallet event data shapes — "explorer/read path".
+ *
+ * These interfaces represent the JSON-decoded form of on-chain events as
+ * they are received via RPC or indexer.  They cover all pallets relevant
+ * to the Orbinum explorer: shielded-pool, balances, system, ethereum, evm,
+ * and account-mapping.
+ *
+ * Note: EventRecord itself is exported from @orbinum/sdk via substrate/types.
+ */
+interface ShieldedEventData {
+    sender: string;
+    amount: string | null;
+    commitment: string;
+    memo: string;
+    index: number;
+}
+interface PrivateTransferEventData {
+    nullifiers: string[];
+    commitments: string[];
+    memos: string[];
+    indices: number[];
+}
+interface UnshieldedEventData {
+    nullifier: string;
+    amount: string | null;
+    recipient: string;
+}
+interface MerkleRootUpdatedData {
+    old_root: string;
+    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;
+    amount: string;
+}
+interface EndowedEventData {
+    account: string;
+    free_balance: string;
+}
+interface ReservedEventData {
+    account: string;
+    amount: string;
+}
+interface AliasRegisteredData {
+    who: string;
+    alias: string;
+}
+interface AliasTransferredData {
+    from: string;
+    to: string;
+    alias: string;
+}
+interface AliasOnSaleData {
+    alias: string;
+    price: string;
+}
+interface AliasSoldData {
+    from: string;
+    to: string;
+    alias: string;
+    price: string;
+}
+interface AccountMappedData {
+    account: string;
+    address: string;
+}
+/** EVM exit reason — either a named variant or a plain string. */
+type EvmExitReason = string | Record<string, unknown>;
+interface EvmExecutedData {
+    from: string;
+    to: string;
+    tx_hash: string;
+    exit_reason: EvmExitReason;
+}
+interface EthereumExecutedData {
+    from: string;
+    to: string;
+    tx_hash: string;
+    exit_reason: EvmExitReason;
+}
+interface DispatchInfo {
+    weight: Record<string, unknown>;
+    class: string;
+    pays_fee: string;
+}
+interface DispatchError {
+    module?: {
+        index: number;
+        error: number;
+    };
+    [variant: string]: unknown;
+}
+interface ExtrinsicSuccessData {
+    dispatch_info: DispatchInfo;
+}
+interface ExtrinsicFailedData {
+    dispatch_error: DispatchError;
+    dispatch_info: DispatchInfo;
 }
 
-export { type AccountListing, 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 AliasRegisteredEvent, type AliasReleasedEvent, type AliasSaleCancelledEvent, type AliasSoldEvent, type AliasTransferredEvent, type AssetRegisteredEvent, type AssetUnverifiedEvent, type AssetVerifiedEvent, type AuditPolicySetEvent, type Auditor, type BatchDisclosureSubmission, type BatchRegisterVerificationKeysArgs, type BatchSubmitDisclosureProofsArgs, type BatchVerificationKeysRegisteredEvent, type BuyAliasArgs, type Bytes32, type ChainInfo, type ChainLink, type ChainLinkAddedEvent, type ChainLinkRemovedEvent, ChainModule, CircuitId, CircuitId as CircuitIdType, type CommitmentMerkleProof, CryptoPrecompiles, type DecryptedMemo, type DiscloseArgs, type DisclosedEvent, type DisclosureCondition, type DisclosurePublicSignals, type DisclosureRecordRevokedEvent, type DisclosureRejectedEvent, type DisclosureRequestExpiredEvent, type DisclosureRequestedEvent, type DispatchAsLinkedAccountArgs, type DispatchAsLinkedParams, type DispatchAsPrivateLinkArgs, EncryptedMemo, EvmClient, type EvmSigner, type EvmTxRequest, type FormatOptions, type FullIdentityInfo, IndexerClient, type IndexerClientConfig, KNOWN_PRECOMPILES, type KnownPrecompileInfo, type ListingInfo, MerkleModule, type MerkleProof, type MerkleRoot, type MerkleRootUpdatedEvent, type MerkleTreeInfo, type MetadataUpdatedEvent, NoteBuilder, type NoteInput, type NullifierStatus, type NullifierStatusResult, OrbinumClient, type OrbinumClientConfig, PRECOMPILE_ADDR, type PaginatedResult, type PoolBalance, type PoolStats, PrivacyKeyManager, type PrivateChainLinkAddedEvent, type PrivateChainLinkRemovedEvent, type PrivateChainLinkRevealedEvent, type PrivateLink, type PrivateLinkDispatchExecutedEvent, type PrivateTransfer, type PrivateTransferArgs, type PrivateTransferEvent, type PrivateTransferInput, type PrivateTransferOutput, type PrivateTransferParams, type ProofVerificationFailedEvent, type ProofVerifiedEvent, type ProxyCallExecutedEvent, type PruneExpiredRequestArgs, type PutAliasOnSaleArgs, type PutOnSaleParams, type RegisterAliasArgs, type RegisterAssetArgs, type RegisterPrivateLinkArgs, type RegisterVerificationKeyArgs, type RejectDisclosureArgs, type RemoveChainLinkArgs, type RemovePrivateLinkArgs, type RemoveSupportedChainArgs, type RemoveVerificationKeyArgs, type RequestDisclosureArgs, type ResolvedAlias, type RevealPrivateLinkArgs, type RevokeDisclosureRecordArgs, SLIP0044_NAMESPACE, type ScanCommitment, type SetAccountMetadataArgs, type SetActiveVersionArgs, type SetAuditPolicyArgs, type SetMetadataParams, type ShieldArgs, type ShieldBatchArgs, type ShieldOperation, type ShieldParams, type ShieldResult, type ShieldedCommitment, type ShieldedEvent, type ShieldedPoolCall, type ShieldedPoolEvent, ShieldedPoolModule, ShieldedPoolPrecompile, type SignatureScheme$1 as SignatureScheme, type SpentNullifier, SubstrateClient, type SupportedChain, type SupportedChainAddedEvent, type SupportedChainRemovedEvent, type TransferAliasArgs, type TransferInput, type TransferOutput, type TxResult, type Unshield, type UnshieldArgs, type UnshieldParams, type UnshieldedEvent, type UnverifyAssetArgs, type VerificationKeyRegisteredEvent, type VerificationKeyRemovedEvent, type VerifyAssetArgs, type VerifyProofArgs, type VkEntry, type ZkNote, type ZkVerifierCall, type ZkVerifierEvent, accountIdHexToSs58, addressToAccountIdHex, bigintTo32Be, bigintTo32Le, bigintTo32LeArr, bytesToBigintLE, computePathIndices, decryptJson, deriveOwnerPk, deriveSpendingKeyFromSignature, deriveSpendingKeyMessage, deriveVaultKey, deriveViewingKey, encryptJson, ensureHexPrefix, evmAddressToAccountId, evmToImplicitSubstrate, evmToSubstrate, formatBalance, formatORB, fromHex, getPrecompileLabel, implicitSubstrateToEvm, isEvmAddress, isImplicitEvmAccount, isSs58, isSubstrateAddress, isUnifiedAddress, leHexToBigint, normalizeEvmAddress, substrateSs58ToAccountIdHex, substrateToEvm, toHex, tryDecryptNote, vaultReplacer, vaultReviver };
+export { type AccountListing, type AccountMappedData, type AccountMappedEvent, type AccountMappingCall, type AccountMappingEvent, AccountMappingModule, AccountMappingPrecompile, type AccountMetadata, type AccountUnmappedEvent, type ActiveVersionSetEvent, type AddChainLinkArgs, type AddChainLinkParams, type AddSupportedChainArgs, type AliasFullIdentity, type AliasInfo, type AliasListedForSaleEvent, type AliasOnSaleData, type AliasRegisteredData, type AliasRegisteredEvent, type AliasReleasedEvent, type AliasSaleCancelledEvent, type AliasSoldData, type AliasSoldEvent, type AliasTransferredData, type AliasTransferredEvent, type AssetRegisteredEvent, type AssetUnverifiedEvent, type AssetVerifiedEvent, type 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 };