@orbinum/sdk 0.2.0 → 0.4.0

package/dist/index.d.mts

@@ -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';
 
+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;
-};
-type PoolBalance = {
-    assetId: number;
-    balance: bigint;
+    encryptedMemo: string | null;
+};
+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 = '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;
@@ -322,157 +872,7 @@ type SupportedChain = {
     chainId: number;
     scheme: SignatureScheme;
 };
-/**
- * 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;
-};
-/**
- * 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,351 +1941,1623 @@ declare const KNOWN_PRECOMPILES: Record<string, KnownPrecompileInfo>;
 declare function getPrecompileLabel(address: string | null | undefined): string | null;
 
 /**
- * Serialises a bigint as a 32-byte little-endian Uint8Array.
+ * Decodes calldata for known Orbinum EVM precompiles.
+ *
+ * Returns raw decoded values (bigint amounts, hex strings for bytes32).
+ * Callers are responsible for display formatting.
  */
-declare function bigintTo32Le(n: bigint): Uint8Array;
+type DecodedPrecompile = {
+    fnSig: string;
+    args: Record<string, unknown>;
+};
 /**
- * Deserialises a Uint8Array as a little-endian unsigned bigint.
+ * Decodes EVM calldata for a known Orbinum precompile.
+ *
+ * @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 bytesToBigintLE(bytes: Uint8Array): bigint;
+declare function decodePrecompileCalldata(address: string, input: string): DecodedPrecompile | null;
+
 /**
- * Serialises a bigint as a 32-byte big-endian Uint8Array.
+ * TypeScript types for events emitted by pallet-shielded-pool.
+ *
+ * Conventions:
+ *   - Byte arrays (Commitment, Nullifier, Hash) → `string`  (0x-prefixed hex, LE)
+ *   - Balances (BalanceOf<T>)                   → `bigint`
+ *   - AccountId                                 → `string`  (SS58 or 0x-prefixed)
+ *   - BoundedVec<T, N>                          → `T[]`     (max N documented per field)
+ *   - u32 / leaf indices                        → `number`
+ *   - Option<T>                                 → `T | null`
  */
-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.
+ * Emitted by `shield()` when a note is deposited into the shielded pool.
+ * Rust variant: `Shielded { depositor, amount, commitment, encrypted_memo, leaf_index }`
  */
-declare function bigintTo32LeArr(n: bigint): number[];
+type ShieldedEvent = {
+    /** SS58 AccountId of the depositor. */
+    depositor: string;
+    amount: bigint;
+    /** 0x-prefixed 32-byte Poseidon commitment (LE). */
+    commitment: string;
+    /** 0x-prefixed encrypted memo bytes (104 bytes). */
+    encryptedMemo: string;
+    /** Leaf index assigned in the Merkle tree. */
+    leafIndex: 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).
+ * Emitted by `private_transfer()`.
+ * Rust variant: `PrivateTransfer { nullifiers, commitments, encrypted_memos, leaf_indices }`
+ * Max 2 inputs / 2 outputs.
  */
-declare function computePathIndices(leafIndex: number, depth: number): number[];
+type PrivateTransferEvent = {
+    /** Input nullifiers — max 2. 0x-prefixed 32-byte hex each. */
+    nullifiers: string[];
+    /** Output commitments — max 2. 0x-prefixed 32-byte hex each. */
+    commitments: string[];
+    /** Encrypted memos for each output — max 2. */
+    encryptedMemos: string[];
+    /** Leaf indices assigned to output commitments — max 2. */
+    leafIndices: number[];
+};
 /**
- * Decodes a little-endian hex string (0x-prefixed or bare) to a bigint.
- * Equivalent to `bytesToBigintLE(fromHex(hex))`.
+ * Emitted by `unshield()` when a note is withdrawn to the public chain.
+ * Rust variant: `Unshielded { nullifier, amount, recipient }`
  */
-declare function leHexToBigint(hex: string): bigint;
-
+type UnshieldedEvent = {
+    /** 0x-prefixed 32-byte Poseidon nullifier (LE). */
+    nullifier: string;
+    amount: bigint;
+    /** SS58 AccountId of the recipient. */
+    recipient: string;
+};
 /**
- * Normalises an EVM address to lowercase with 0x prefix.
+ * Emitted after every Merkle tree update (shield / transfer / unshield).
+ * Rust variant: `MerkleRootUpdated { old_root, new_root, tree_size }`
  */
-declare function normalizeEvmAddress(addr: string): string;
+type MerkleRootUpdatedEvent = {
+    /** 0x-prefixed previous Merkle root (32 bytes, LE). */
+    oldRoot: string;
+    /** 0x-prefixed new Merkle root (32 bytes, LE). */
+    newRoot: string;
+    /** Total number of leaves after the update. */
+    treeSize: number;
+};
 /**
- * Returns true if the string looks like an SS58 encoded address
- * (not a 0x-prefixed hex).
+ * Emitted by `set_audit_policy()` when an account sets or updates its audit policy.
+ * Rust variant: `AuditPolicySet { account, version }`
  */
-declare function isSs58(addr: string): boolean;
+type AuditPolicySetEvent = {
+    /** SS58 AccountId of the policy owner. */
+    account: string;
+    /** Policy version number (monotonically increasing). */
+    version: number;
+};
 /**
- * Returns true if the string looks like a 20-byte EVM address.
+ * Emitted by `disclose()` when a note is disclosed.
+ * Rust variant: `Disclosed { who, commitment, auditor }`
  */
-declare function isEvmAddress(addr: string): boolean;
+type DisclosedEvent = {
+    /** SS58 AccountId of the discloser. */
+    who: string;
+    /** 0x-prefixed 32-byte commitment of the disclosed note. */
+    commitment: string;
+    /** SS58 AccountId of the auditor, or null for voluntary disclosure. */
+    auditor: string | null;
+};
 /**
- * Pads a 20-byte EVM address to a 32-byte account ID (H256)
- * by prepending 12 zero bytes (Ethereum-compatible mapping).
+ * Emitted by `request_disclosure()` when an auditor requests a note disclosure.
+ * Rust variant: `DisclosureRequested { target, auditor, reason }`
  */
-declare function evmAddressToAccountId(evmAddr: string): Uint8Array;
+type DisclosureRequestedEvent = {
+    /** SS58 AccountId of the note owner (disclosure target). */
+    target: string;
+    /** SS58 AccountId of the requesting auditor. */
+    auditor: string;
+    /** Reason string (max 256 bytes, UTF-8). */
+    reason: string;
+};
 /**
- * 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.
+ * Emitted by `reject_disclosure()` when a note owner rejects a disclosure request.
+ * Rust variant: `DisclosureRejected { target, auditor, reason }`
  */
-declare function evmToImplicitSubstrate(evmAddr: string): string;
+type DisclosureRejectedEvent = {
+    /** SS58 AccountId of the note owner. */
+    target: string;
+    /** SS58 AccountId of the auditor whose request was rejected. */
+    auditor: string;
+    /** Rejection reason string (max 256 bytes, UTF-8). */
+    reason: string;
+};
 /**
- * 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.
+ * Emitted when a pending disclosure request expires (on_finalize pruning).
+ * Rust variant: `DisclosureRequestExpired { target, auditor }`
  */
-declare function isImplicitEvmAccount(accountHex: string): boolean;
+type DisclosureRequestExpiredEvent = {
+    /** SS58 AccountId of the note owner. */
+    target: string;
+    /** SS58 AccountId of the auditor. */
+    auditor: string;
+};
 /**
- * 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.
+ * Emitted by `revoke_disclosure_record()` when an account revokes a previous disclosure.
+ * Rust variant: `DisclosureRecordRevoked { who, commitment }`
  */
-declare function implicitSubstrateToEvm(accountHex: string): string;
+type DisclosureRecordRevokedEvent = {
+    /** SS58 AccountId of the note owner. */
+    who: string;
+    /** 0x-prefixed 32-byte commitment of the revoked note. */
+    commitment: string;
+};
 /**
- * Returns true if `addr` is a valid SS58 substrate address (not EVM).
+ * Emitted by `register_asset()` when a new asset is registered in the pool.
+ * Rust variant: `AssetRegistered { asset_id }`
  */
-declare function isSubstrateAddress(addr: string): boolean;
+type AssetRegisteredEvent = {
+    assetId: number;
+};
 /**
- * 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).
+ * Emitted by `verify_asset()` when an asset is verified (marked as trusted).
+ * Rust variant: `AssetVerified { asset_id }`
  */
-declare function isUnifiedAddress(addr: string): boolean;
+type AssetVerifiedEvent = {
+    assetId: number;
+};
 /**
- * Converts a unified (EVM-derived) Substrate SS58 address to its EVM H160.
- * Returns null for native Substrate accounts or invalid input.
+ * Emitted by `unverify_asset()` when an asset's verified status is removed.
+ * Rust variant: `AssetUnverified { asset_id }`
  */
-declare function substrateToEvm(addr: string): string | null;
+type AssetUnverifiedEvent = {
+    assetId: number;
+};
+/** All events emitted by pallet-shielded-pool as a discriminated union. */
+type ShieldedPoolEvent = {
+    type: 'Shielded';
+    data: ShieldedEvent;
+} | {
+    type: 'PrivateTransfer';
+    data: PrivateTransferEvent;
+} | {
+    type: 'Unshielded';
+    data: UnshieldedEvent;
+} | {
+    type: 'MerkleRootUpdated';
+    data: MerkleRootUpdatedEvent;
+} | {
+    type: 'AuditPolicySet';
+    data: AuditPolicySetEvent;
+} | {
+    type: 'Disclosed';
+    data: DisclosedEvent;
+} | {
+    type: 'DisclosureRequested';
+    data: DisclosureRequestedEvent;
+} | {
+    type: 'DisclosureRejected';
+    data: DisclosureRejectedEvent;
+} | {
+    type: 'DisclosureRequestExpired';
+    data: DisclosureRequestExpiredEvent;
+} | {
+    type: 'DisclosureRecordRevoked';
+    data: DisclosureRecordRevokedEvent;
+} | {
+    type: 'AssetRegistered';
+    data: AssetRegisteredEvent;
+} | {
+    type: 'AssetVerified';
+    data: AssetVerifiedEvent;
+} | {
+    type: 'AssetUnverified';
+    data: AssetUnverifiedEvent;
+};
+
 /**
- * Converts an EVM H160 address to its Substrate SS58 equivalent
- * using the EeSuffixAddressMapping rule: AccountId32 = H160 ++ [0x00; 12].
- * Returns null on invalid input.
+ * TypeScript types for pallet-zk-verifier extrinsics.
+ *
+ * Conventions:
+ *   - Byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Versions     → `number`    (u32)
  */
-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.
+ * On-chain circuit identifier (u32 newtype on-chain).
+ * Use the {@link CircuitId} constant object for named values.
  */
-declare function accountIdHexToSs58(hex: string): string | null;
+type CircuitId = (typeof CircuitId)[keyof typeof CircuitId];
 /**
- * Converts a Substrate SS58 address to its AccountId32 as a 0x-prefixed 64-char hex.
- * Returns null on invalid input.
+ * 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 function substrateSs58ToAccountIdHex(addr: string): string | null;
+declare const CircuitId: {
+    readonly Transfer: 1;
+    readonly Unshield: 2;
+    readonly Disclosure: 3;
+    readonly PrivateLink: 4;
+};
 /**
- * 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.
+ * A single verification key registration entry used in batch operations.
+ * Maps to `VkEntry` in Rust.
  */
-declare function addressToAccountIdHex(addr: string): string | null;
-
+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[];
+};
 /**
- * Types for the arguments passed to pallet-shielded-pool extrinsics.
- * Byte arrays are represented as `number[]` to match SCALE encoding.
+ * Call index 0 — `register_verification_key` (Root origin)
+ * Registers a Groth16 verification key for a specific circuit and version.
  */
-/** Arguments for the `shield` extrinsic. */
-type ShieldArgs = {
-    assetId: number;
-    amount: bigint;
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: number[];
-    /** 104-byte encrypted memo. */
-    encryptedMemo: number[];
-};
-/** Arguments for the `unshield` extrinsic. */
-type UnshieldArgs = {
-    /** Groth16 proof bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: number[];
-    /** 32-byte Poseidon nullifier (LE). */
-    nullifier: number[];
-    assetId: number;
-    amount: bigint;
-    /** 32-byte recipient AccountId. */
-    recipient: number[];
+type RegisterVerificationKeyArgs = {
+    circuitId: CircuitId;
+    /** Version to associate with this key. */
+    version: number;
+    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
+    verificationKey: number[];
 };
-/** Single input note for a private transfer. */
-type PrivateTransferInput = {
-    /** 32-byte Poseidon nullifier (LE). */
-    nullifier: number[];
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: 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;
 };
-/** Single output note for a private transfer. */
-type PrivateTransferOutput = {
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: number[];
-    /** 104-byte encrypted memo. */
-    memo: 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;
 };
-/** Arguments for the `private_transfer` extrinsic. */
-type PrivateTransferArgs = {
-    inputs: PrivateTransferInput[];
-    outputs: PrivateTransferOutput[];
+/**
+ * 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[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: 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[][];
 };
-
 /**
- * Types for events emitted by pallet-shielded-pool.
- * Hex strings are 0x-prefixed 32-byte LE Poseidon values.
+ * 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.
  */
-/** Emitted by `shield()` when a note is deposited. */
-type ShieldedEvent = {
-    /** SS58 or 0x-prefixed AccountId of the depositor. */
-    depositor: string;
-    amount: bigint;
-    /** 0x-prefixed 32-byte commitment hex (LE). */
-    commitment: string;
-    /** 0x-prefixed encrypted memo hex. */
-    encryptedMemo: string;
-    /** Leaf index assigned in the Merkle tree. */
-    leafIndex: number;
+type BatchRegisterVerificationKeysArgs = {
+    /** Up to 10 VK entries. */
+    entries: VkEntry[];
 };
-/** Emitted by `private_transfer()`. */
-type PrivateTransferEvent = {
-    /** Input nullifiers (0x-prefixed 32-byte hex each). */
-    nullifiers: string[];
-    /** Output commitments (0x-prefixed 32-byte hex each). */
-    commitments: string[];
-    /** Encrypted memos for each output. */
-    encryptedMemos: string[];
-    /** Leaf indices assigned to output commitments. */
-    leafIndices: 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;
 };
-/** Emitted by `unshield()` when a note is withdrawn. */
-type UnshieldedEvent = {
-    /** 0x-prefixed 32-byte nullifier hex (LE). */
-    nullifier: string;
-    amount: bigint;
-    /** SS58 or 0x-prefixed AccountId of the recipient. */
-    recipient: string;
+
+/**
+ * TypeScript types for events emitted by pallet-zk-verifier.
+ *
+ * Conventions:
+ *   - CircuitId  → imported from pallet-extrinsics (u32 newtype)
+ *   - version    → `number` (u32)
+ *   - count      → `number` (u32)
+ */
+
+/**
+ * Emitted by `register_verification_key()` when a new VK is stored.
+ * Rust variant: `VerificationKeyRegistered { circuit_id, version }`
+ */
+type VerificationKeyRegisteredEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
-/** Emitted after every Merkle tree update. */
-type MerkleRootUpdatedEvent = {
-    /** 0x-prefixed previous root hex. */
-    oldRoot: string;
-    /** 0x-prefixed new root hex. */
-    newRoot: string;
-    /** New total number of leaves. */
-    treeSize: number;
+/**
+ * Emitted by `set_active_version()` when the active VK version changes.
+ * Rust variant: `ActiveVersionSet { circuit_id, version }`
+ */
+type ActiveVersionSetEvent = {
+    circuitId: CircuitId;
+    version: number;
 };
-/** Discriminated union of all shielded-pool events. */
-type ShieldedPoolEvent = {
-    type: 'Shielded';
-    data: ShieldedEvent;
+/**
+ * Emitted by `remove_verification_key()` when a VK is deleted.
+ * Rust variant: `VerificationKeyRemoved { circuit_id, version }`
+ */
+type VerificationKeyRemovedEvent = {
+    circuitId: CircuitId;
+    version: number;
+};
+/**
+ * Emitted by `verify_proof()` when a ZK proof is successfully verified.
+ * Rust variant: `ProofVerified { circuit_id, version }`
+ */
+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: 'PrivateTransfer';
-    data: PrivateTransferEvent;
+    type: 'ActiveVersionSet';
+    data: ActiveVersionSetEvent;
 } | {
-    type: 'Unshielded';
-    data: UnshieldedEvent;
+    type: 'VerificationKeyRemoved';
+    data: VerificationKeyRemovedEvent;
 } | {
-    type: 'MerkleRootUpdated';
-    data: MerkleRootUpdatedEvent;
+    type: 'ProofVerified';
+    data: ProofVerifiedEvent;
+} | {
+    type: 'ProofVerificationFailed';
+    data: ProofVerificationFailedEvent;
+} | {
+    type: 'BatchVerificationKeysRegistered';
+    data: BatchVerificationKeysRegisteredEvent;
+};
+
+/**
+ * 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`
+ */
+
+/**
+ * Call index 2 — `register_alias` (Signed origin)
+ * Registers a human-readable identity alias for the caller's Substrate account.
+ * Valid characters: alphanumeric, underscore, hyphen.
+ * Length bounded by `T::MaxAliasLength` on-chain (configurable; typically ≤ 32 bytes).
+ */
+type RegisterAliasArgs = {
+    alias: string;
+};
+/**
+ * Call index 4 — `transfer_alias` (Signed origin)
+ * Transfers the caller's alias to another account.
+ * The current owner loses the alias; the new owner must not already hold one.
+ */
+type TransferAliasArgs = {
+    /** AccountId of the new owner. */
+    newOwner: string;
+};
+/**
+ * Call index 5 — `put_alias_on_sale` (Signed origin)
+ * Lists the caller's alias for purchase at a given planck price.
+ */
+type PutAliasOnSaleArgs = {
+    /** Sale price in planck (native token smallest unit). Cannot be zero. */
+    price: bigint;
+    /**
+     * Optional whitelist of AccountIds allowed to buy.
+     * Null = unrestricted public sale.
+     * Max {@link MAX_WHITELIST_SIZE} entries.
+     */
+    allowedBuyers: string[] | null;
+};
+/**
+ * Call index 7 — `buy_alias` (Signed origin)
+ * Purchases an alias currently listed for sale.
+ * The buyer must not already hold an alias.
+ */
+type BuyAliasArgs = {
+    /** The alias to purchase. */
+    alias: string;
+};
+/**
+ * Call index 8 — `add_chain_link` (Signed origin)
+ * Links an external-chain address to the caller's Orbinum identity.
+ * The `signature` must be produced over a deterministic challenge message
+ * using the private key corresponding to `address` on the given chain.
+ */
+type AddChainLinkArgs = {
+    /** u32 chain identifier (must be in the supported chains registry). */
+    chainId: number;
+    /** Raw external address bytes — 20 bytes for EVM, 32 bytes for Ed25519 chains. */
+    address: number[];
+    /** Ownership proof signature bytes. */
+    signature: number[];
+};
+/**
+ * Call index 9 — `remove_chain_link` (Signed origin)
+ * Removes a previously verified external chain link from the caller's identity.
+ */
+type RemoveChainLinkArgs = {
+    /** u32 chain identifier of the link to remove. */
+    chainId: number;
+};
+/**
+ * Call index 10 — `set_account_metadata` (Signed origin)
+ * Sets or updates the caller's public profile metadata.
+ * Fields set to null are cleared from storage.
+ */
+type SetAccountMetadataArgs = {
+    /** Display name — max 64 bytes UTF-8. Null removes the field. */
+    displayName: string | null;
+    /** Short biography — max 512 bytes UTF-8. Null removes the field. */
+    bio: string | null;
+    /** Avatar URL or IPFS CID — max 256 bytes. Null removes the field. */
+    avatar: string | null;
+};
+/**
+ * Call index 11 — `add_supported_chain` (Root origin)
+ * Registers a new external chain in the supported chains registry.
+ */
+type AddSupportedChainArgs = {
+    /** u32 chain identifier (e.g. SLIP-0044 coin type). */
+    chainId: number;
+    /** Signature scheme used for address-ownership proofs on this chain. */
+    scheme: SignatureScheme;
+};
+/**
+ * Call index 12 — `remove_supported_chain` (Root origin)
+ * Removes a chain from the supported chains registry.
+ * Existing links for that chain are unaffected.
+ */
+type RemoveSupportedChainArgs = {
+    /** u32 chain identifier to remove. */
+    chainId: number;
+};
+/**
+ * Call index 13 — `dispatch_as_linked_account` (Signed origin, relayer)
+ * Dispatches a RuntimeCall on behalf of an account that owns a verified chain link.
+ * The relayer pays fees; authorisation comes from the external chain signature.
+ */
+type DispatchAsLinkedAccountArgs = {
+    /** AccountId on whose behalf to dispatch. */
+    owner: string;
+    /** u32 chain identifier of the link used for authorisation. */
+    chainId: number;
+    /** Raw external address bytes of the authorising signer. */
+    address: number[];
+    /** Signature over the SCALE-encoded `call` payload. */
+    signature: number[];
+    /** SCALE-encoded RuntimeCall to dispatch. */
+    call: number[];
+};
+/**
+ * Call index 14 — `register_private_link` (Signed origin)
+ * Registers a hidden chain link using a Poseidon commitment: H(address, blinding).
+ * The actual external address is not revealed on-chain.
+ */
+type RegisterPrivateLinkArgs = {
+    /** u32 chain identifier. */
+    chainId: number;
+    /** 32-byte Poseidon commitment: H(address || blinding) (LE). */
+    commitment: number[];
+};
+/**
+ * Call index 15 — `remove_private_link` (Signed origin)
+ * Removes a private chain link identified by its commitment.
+ */
+type RemovePrivateLinkArgs = {
+    /** 32-byte commitment identifying the link to remove (LE). */
+    commitment: number[];
+};
+/**
+ * Call index 16 — `reveal_private_link` (Signed origin)
+ * Reveals a previously registered private link by providing the commitment preimage.
+ * After this call the link becomes publicly readable in storage.
+ */
+type RevealPrivateLinkArgs = {
+    /** 32-byte commitment: H(address || blinding) (LE). */
+    commitment: number[];
+    /** The actual raw external address bytes being revealed. */
+    address: number[];
+    /** 32-byte blinding factor used when creating the commitment (LE). */
+    blinding: number[];
+    /** Ownership proof signature produced with the external-chain key. */
+    signature: number[];
+};
+/**
+ * Call index 17 — `dispatch_as_private_link` (Signed origin, relayer)
+ * Dispatches a RuntimeCall on behalf of an account identified only by a private
+ * link commitment. A Groth16 ZK proof (PRIVATE_LINK circuit) authorises the
+ * dispatch without revealing the external address.
+ */
+type DispatchAsPrivateLinkArgs = {
+    /** AccountId on whose behalf to dispatch. */
+    owner: string;
+    /** 32-byte commitment identifying the private link (LE). */
+    commitment: number[];
+    /** Groth16 proof bytes (PRIVATE_LINK circuit). */
+    zkProof: number[];
+    /** SCALE-encoded RuntimeCall to dispatch. */
+    call: number[];
+};
+/** All pallet-account-mapping calls as a discriminated union. */
+type AccountMappingCall = {
+    type: 'mapAccount';
+} | {
+    type: 'unmapAccount';
+} | {
+    type: 'registerAlias';
+    args: RegisterAliasArgs;
+} | {
+    type: 'releaseAlias';
+} | {
+    type: 'transferAlias';
+    args: TransferAliasArgs;
+} | {
+    type: 'putAliasOnSale';
+    args: PutAliasOnSaleArgs;
+} | {
+    type: 'cancelSale';
+} | {
+    type: 'buyAlias';
+    args: BuyAliasArgs;
+} | {
+    type: 'addChainLink';
+    args: AddChainLinkArgs;
+} | {
+    type: 'removeChainLink';
+    args: RemoveChainLinkArgs;
+} | {
+    type: 'setAccountMetadata';
+    args: SetAccountMetadataArgs;
+} | {
+    type: 'addSupportedChain';
+    args: AddSupportedChainArgs;
+} | {
+    type: 'removeSupportedChain';
+    args: RemoveSupportedChainArgs;
+} | {
+    type: 'dispatchAsLinkedAccount';
+    args: DispatchAsLinkedAccountArgs;
+} | {
+    type: 'registerPrivateLink';
+    args: RegisterPrivateLinkArgs;
+} | {
+    type: 'removePrivateLink';
+    args: RemovePrivateLinkArgs;
+} | {
+    type: 'revealPrivateLink';
+    args: RevealPrivateLinkArgs;
+} | {
+    type: 'dispatchAsPrivateLink';
+    args: DispatchAsPrivateLinkArgs;
 };
 
-/** 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;
-    };
+/**
+ * TypeScript types for events emitted by pallet-account-mapping.
+ *
+ * Conventions:
+ *   - AccountId     → `string`  (SS58)
+ *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
+ *   - AliasOf<T>    → `string`  (bounded string, max configurable)
+ *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
+ *   - ExternalAddr  → `string`  (chain-specific address string)
+ *   - BalanceOf<T>  → `bigint`
+ *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
+ *   - SignatureScheme → imported from pallet-extrinsics
+ */
+
+/**
+ * Emitted when a Substrate account is mapped to an Ethereum address.
+ * Rust variant: `AccountMapped { account, address }`
+ */
+type AccountMappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
+};
+/**
+ * Emitted when an existing account mapping is removed.
+ * Rust variant: `AccountUnmapped { account, address }`
+ */
+type AccountUnmappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
+};
+/**
+ * Emitted by `register_alias()` when a new alias is claimed.
+ * Rust variant: `AliasRegistered { account, alias, evm_address }`
+ */
+type AliasRegisteredEvent = {
+    account: string;
+    alias: string;
+    /** Optional EVM address linked at registration time. */
+    evmAddress: string | null;
+};
+/**
+ * Emitted when an alias is released (burned / expired).
+ * Rust variant: `AliasReleased { account, alias }`
+ */
+type AliasReleasedEvent = {
+    account: string;
+    alias: string;
+};
+/**
+ * Emitted by `transfer_alias()` when ownership changes hands.
+ * Rust variant: `AliasTransferred { from, to, alias }`
+ */
+type AliasTransferredEvent = {
+    from: string;
+    to: string;
+    alias: string;
+};
+/**
+ * Emitted by `put_alias_on_sale()` when an alias is listed on the marketplace.
+ * Rust variant: `AliasListedForSale { seller, alias, price, private }`
+ */
+type AliasListedForSaleEvent = {
+    seller: string;
+    alias: string;
+    price: bigint;
+    /** Whether the listing is private (whitelist-only). */
+    private: boolean;
+};
+/**
+ * Emitted when an alias listing is cancelled before a sale.
+ * Rust variant: `AliasSaleCancelled { seller, alias }`
+ */
+type AliasSaleCancelledEvent = {
+    seller: string;
+    alias: string;
+};
+/**
+ * Emitted by `buy_alias()` when an alias is purchased.
+ * Rust variant: `AliasSold { seller, buyer, alias, price }`
+ */
+type AliasSoldEvent = {
+    seller: string;
+    buyer: string;
+    alias: string;
+    price: bigint;
+};
+/**
+ * Emitted by `add_chain_link()` when an external address is linked.
+ * Rust variant: `ChainLinkAdded { account, chain_id, address }`
+ */
+type ChainLinkAddedEvent = {
+    account: string;
+    /** SLIP-0044 coin-type identifying the external chain. */
+    chainId: number;
+    /** Chain-specific address string. */
+    address: string;
+};
+/**
+ * Emitted by `remove_chain_link()` when an external address link is removed.
+ * Rust variant: `ChainLinkRemoved { account, chain_id }`
+ */
+type ChainLinkRemovedEvent = {
+    account: string;
+    chainId: number;
+};
+/**
+ * Emitted by `set_account_metadata()` when an account's metadata is updated.
+ * Rust variant: `MetadataUpdated { account }`
+ */
+type MetadataUpdatedEvent = {
+    account: string;
+};
+/**
+ * Emitted by `add_supported_chain()` (governance) when a new chain type is whitelisted.
+ * Rust variant: `SupportedChainAdded { chain_id, scheme }`
+ */
+type SupportedChainAddedEvent = {
+    chainId: number;
+    scheme: SignatureScheme;
+};
+/**
+ * Emitted by `remove_supported_chain()` (governance) when a chain type is removed.
+ * Rust variant: `SupportedChainRemoved { chain_id }`
+ */
+type SupportedChainRemovedEvent = {
+    chainId: number;
+};
+/**
+ * Emitted after a successful `dispatch_as_linked_account()` call.
+ * Rust variant: `ProxyCallExecuted { owner, chain_id, address }`
+ */
+type ProxyCallExecutedEvent = {
+    owner: string;
+    chainId: number;
+    address: string;
+};
+/**
+ * Emitted by `register_private_link()` when a private (commitment-based) chain link is added.
+ * Rust variant: `PrivateChainLinkAdded { account, chain_id, commitment }`
+ */
+type PrivateChainLinkAddedEvent = {
+    account: string;
+    chainId: number;
+    /** 0x-prefixed 32-byte Poseidon commitment of the private link. */
+    commitment: string;
+};
+/**
+ * Emitted by `remove_private_link()` when a private chain link is removed.
+ * Rust variant: `PrivateChainLinkRemoved { account, chain_id, commitment }`
+ */
+type PrivateChainLinkRemovedEvent = {
+    account: string;
+    chainId: number;
+    /** 0x-prefixed 32-byte commitment. */
+    commitment: string;
+};
+/**
+ * Emitted by `reveal_private_link()` when a private link is publicly revealed.
+ * Rust variant: `PrivateChainLinkRevealed { account, chain_id, address }`
+ */
+type PrivateChainLinkRevealedEvent = {
+    account: string;
+    chainId: number;
+    /** The now-revealed external address. */
+    address: string;
+};
+/**
+ * Emitted after a successful `dispatch_as_private_link()` call.
+ * Rust variant: `PrivateLinkDispatchExecuted { owner, commitment }`
+ */
+type PrivateLinkDispatchExecutedEvent = {
+    owner: string;
+    /** 0x-prefixed 32-byte commitment of the private link used. */
+    commitment: string;
+};
+/** All events emitted by pallet-account-mapping as a discriminated union. */
+type AccountMappingEvent = {
+    type: 'AccountMapped';
+    data: AccountMappedEvent;
+} | {
+    type: 'AccountUnmapped';
+    data: AccountUnmappedEvent;
+} | {
+    type: 'AliasRegistered';
+    data: AliasRegisteredEvent;
+} | {
+    type: 'AliasReleased';
+    data: AliasReleasedEvent;
+} | {
+    type: 'AliasTransferred';
+    data: AliasTransferredEvent;
+} | {
+    type: 'AliasListedForSale';
+    data: AliasListedForSaleEvent;
+} | {
+    type: 'AliasSaleCancelled';
+    data: AliasSaleCancelledEvent;
+} | {
+    type: 'AliasSold';
+    data: AliasSoldEvent;
+} | {
+    type: 'ChainLinkAdded';
+    data: ChainLinkAddedEvent;
+} | {
+    type: 'ChainLinkRemoved';
+    data: ChainLinkRemovedEvent;
+} | {
+    type: 'MetadataUpdated';
+    data: MetadataUpdatedEvent;
+} | {
+    type: 'SupportedChainAdded';
+    data: SupportedChainAddedEvent;
+} | {
+    type: 'SupportedChainRemoved';
+    data: SupportedChainRemovedEvent;
+} | {
+    type: 'ProxyCallExecuted';
+    data: ProxyCallExecutedEvent;
+} | {
+    type: 'PrivateChainLinkAdded';
+    data: PrivateChainLinkAddedEvent;
+} | {
+    type: 'PrivateChainLinkRemoved';
+    data: PrivateChainLinkRemovedEvent;
+} | {
+    type: 'PrivateChainLinkRevealed';
+    data: PrivateChainLinkRevealedEvent;
+} | {
+    type: 'PrivateLinkDispatchExecuted';
+    data: PrivateLinkDispatchExecutedEvent;
+};
+
+/**
+ * TypeScript types for pallet-shielded-pool extrinsics and supporting structures.
+ *
+ * Conventions:
+ *   - Fixed/bounded byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Balances (u128)            → `bigint`
+ *   - AccountId                  → `string`    (SS58 or 0x-prefixed 64-char hex)
+ *   - Block numbers              → `number`
+ *   - Optional fields            → `T | null`
+ */
+/**
+ * 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;
 }
-/** 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;
+interface DecodedShieldBatchOperation {
+    asset_id: number | string;
+    amount: string;
+    commitment: string;
+    encrypted_memo: string;
 }
-/** A spent nullifier stored by the indexer. */
-interface SpentNullifier {
-    nullifierHex: string;
-    blockNumber: number;
-    extrinsicIndex: number | null;
-    txType: 'unshield' | 'private_transfer';
-    timestampMs: number | null;
+interface DecodedShieldBatchArgs {
+    operations: DecodedShieldBatchOperation[];
 }
-/** 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;
+interface DecodedPrivateTransferArgs {
+    proof: string;
+    merkle_root: string;
+    nullifiers: string[];
+    commitments: string[];
+    encrypted_memos: string[];
 }
-/** 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). */
+interface DecodedUnshieldArgs {
+    proof: string;
+    merkle_root: string;
+    nullifier: string;
+    asset_id: number | string;
     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;
+interface DecodedSetAuditPolicyArgs {
+    auditors: string[];
+    conditions: unknown;
+    max_frequency: number;
 }
-/** Response from the nullifier status endpoint. */
-interface NullifierStatusResult {
-    nullifier: string;
-    spent: boolean;
-    txType?: 'unshield' | 'private_transfer';
-    blockNumber?: 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;
+}
+
 /**
- * HTTP client for the Orbinum indexer REST API.
+ * Decoded pallet event data shapes — "explorer/read path".
  *
- * All methods throw on network errors.
- * Methods returning a single entity return `null` when the server responds 404.
+ * 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.
  */
-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>;
+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, AccountMappingModule, AccountMappingPrecompile, type AccountMetadata, type AddChainLinkParams, type AliasFullIdentity, type AliasInfo, type ChainInfo, type ChainLink, ChainModule, type CommitmentMerkleProof, CryptoPrecompiles, type DecryptedMemo, type DispatchAsLinkedParams, EncryptedMemo, EvmClient, type EvmSigner, type EvmTxRequest, type FullIdentityInfo, IndexerClient, type IndexerClientConfig, KNOWN_PRECOMPILES, type KnownPrecompileInfo, type ListingInfo, MerkleModule, type MerkleProof, type MerkleRoot, type MerkleRootUpdatedEvent, type MerkleTreeInfo, NoteBuilder, type NoteInput, type NullifierStatus, type NullifierStatusResult, OrbinumClient, type OrbinumClientConfig, PRECOMPILE_ADDR, type PaginatedResult, type PoolBalance, type PoolStats, PrivacyKeyManager, type PrivateLink, type PrivateTransfer, type PrivateTransferArgs, type PrivateTransferEvent, type PrivateTransferInput, type PrivateTransferOutput, type PrivateTransferParams, type PutOnSaleParams, type ResolvedAlias, SLIP0044_NAMESPACE, type ScanCommitment, type SetMetadataParams, type ShieldArgs, type ShieldParams, type ShieldResult, type ShieldedCommitment, type ShieldedEvent, type ShieldedPoolEvent, ShieldedPoolModule, ShieldedPoolPrecompile, type SignatureScheme, type SpentNullifier, SubstrateClient, type SupportedChain, type TransferInput, type TransferOutput, type TxResult, type Unshield, type UnshieldArgs, type UnshieldParams, type UnshieldedEvent, type ZkNote, accountIdHexToSs58, addressToAccountIdHex, bigintTo32Be, bigintTo32Le, bigintTo32LeArr, bytesToBigintLE, computePathIndices, decryptJson, deriveOwnerPk, deriveSpendingKeyFromSignature, deriveSpendingKeyMessage, deriveVaultKey, deriveViewingKey, encryptJson, ensureHexPrefix, evmAddressToAccountId, evmToImplicitSubstrate, evmToSubstrate, 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 };