@orbinum/sdk 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -270,7 +270,7 @@ type FullIdentityInfo = {
  * Signature verification scheme for cross-chain links.
  * Mirrors `SignatureScheme` in pallet-account-mapping.
  */
-type SignatureScheme = 'Eip191' | 'Ed25519';
+type SignatureScheme$1 = 'Eip191' | 'Ed25519';
 /** A verified public link to an external chain wallet. */
 type ChainLink = {
     chainId: number;
@@ -320,7 +320,7 @@ type AccountListing = {
 /** A supported chain and its signature verification scheme. */
 type SupportedChain = {
     chainId: number;
-    scheme: SignatureScheme;
+    scheme: SignatureScheme$1;
 };
 /**
  * Bitmask to convert a SLIP-0044 coin type into an Orbinum ChainId.
@@ -1340,6 +1340,49 @@ declare const KNOWN_PRECOMPILES: Record<string, KnownPrecompileInfo>;
  */
 declare function getPrecompileLabel(address: string | null | undefined): string | null;
 
+/**
+ * Options for {@link formatBalance}.
+ */
+interface FormatOptions {
+    /** On-chain token decimals. Defaults to `18`. */
+    decimals?: number;
+    /** Token symbol appended to the output. Defaults to `'ORB'`. */
+    symbol?: string;
+    /** Whether to append the symbol. Defaults to `true`. */
+    showSymbol?: boolean;
+    /** Maximum number of decimal digits shown in output. Defaults to `6`. */
+    precision?: number;
+}
+/**
+ * Formats a raw on-chain token amount to a human-readable string.
+ *
+ * Handles the following input forms:
+ * - `bigint` — raw planck/wei amount.
+ * - `string` — decimal integer, hex (`0x`-prefixed), or already-formatted decimal.
+ * - `number` — interpreted as a plain integer.
+ * - `null` / `undefined` — treated as zero.
+ *
+ * Does NOT depend on `ethers`. Uses pure BigInt arithmetic.
+ *
+ * @example
+ * formatBalance('1000000000000000000') // '1 ORB'
+ * formatBalance(500000000000000000n, { precision: 2 }) // '0.50 ORB'
+ * formatBalance('0x0de0b6b3a7640000', { showSymbol: false }) // '1'
+ * formatBalance(null) // '0 ORB'
+ */
+declare function formatBalance(raw: string | bigint | number | null | undefined, options?: FormatOptions | number): string;
+/**
+ * Convenience wrapper for formatting ORB amounts with 18 decimals.
+ *
+ * @param raw       Raw planck amount (string, bigint, number, or null).
+ * @param precision Max decimal digits shown. Defaults to `6`.
+ *
+ * @example
+ * formatORB('1000000000000000000') // '1 ORB'
+ * formatORB(500000000000000000n, 2) // '0.50 ORB'
+ */
+declare function formatORB(raw: string | bigint | number | null | undefined, precision?: number): string;
+
 /**
  * Serialises a bigint as a 32-byte little-endian Uint8Array.
  */
@@ -1449,100 +1492,157 @@ declare function substrateSs58ToAccountIdHex(addr: string): string | null;
 declare function addressToAccountIdHex(addr: string): string | null;
 
 /**
- * Types for the arguments passed to pallet-shielded-pool extrinsics.
- * Byte arrays are represented as `number[]` to match SCALE encoding.
+ * 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`
  */
-/** 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[];
-};
-/** Single input note for a private transfer. */
-type PrivateTransferInput = {
-    /** 32-byte Poseidon nullifier (LE). */
-    nullifier: number[];
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: number[];
-};
-/** Single output note for a private transfer. */
-type PrivateTransferOutput = {
-    /** 32-byte Poseidon commitment (LE). */
-    commitment: number[];
-    /** 104-byte encrypted memo. */
-    memo: number[];
-};
-/** Arguments for the `private_transfer` extrinsic. */
-type PrivateTransferArgs = {
-    inputs: PrivateTransferInput[];
-    outputs: PrivateTransferOutput[];
-    /** Groth16 proof bytes. */
-    proof: number[];
-    /** 32-byte Merkle root (LE). */
-    merkleRoot: number[];
-};
-
 /**
- * Types for events emitted by pallet-shielded-pool.
- * Hex strings are 0x-prefixed 32-byte LE Poseidon values.
+ * Emitted by `shield()` when a note is deposited into the shielded pool.
+ * Rust variant: `Shielded { depositor, amount, commitment, encrypted_memo, leaf_index }`
  */
-/** Emitted by `shield()` when a note is deposited. */
 type ShieldedEvent = {
-    /** SS58 or 0x-prefixed AccountId of the depositor. */
+    /** SS58 AccountId of the depositor. */
     depositor: string;
     amount: bigint;
-    /** 0x-prefixed 32-byte commitment hex (LE). */
+    /** 0x-prefixed 32-byte Poseidon commitment (LE). */
     commitment: string;
-    /** 0x-prefixed encrypted memo hex. */
+    /** 0x-prefixed encrypted memo bytes (104 bytes). */
     encryptedMemo: string;
     /** Leaf index assigned in the Merkle tree. */
     leafIndex: number;
 };
-/** Emitted by `private_transfer()`. */
+/**
+ * Emitted by `private_transfer()`.
+ * Rust variant: `PrivateTransfer { nullifiers, commitments, encrypted_memos, leaf_indices }`
+ * Max 2 inputs / 2 outputs.
+ */
 type PrivateTransferEvent = {
-    /** Input nullifiers (0x-prefixed 32-byte hex each). */
+    /** Input nullifiers — max 2. 0x-prefixed 32-byte hex each. */
     nullifiers: string[];
-    /** Output commitments (0x-prefixed 32-byte hex each). */
+    /** Output commitments — max 2. 0x-prefixed 32-byte hex each. */
     commitments: string[];
-    /** Encrypted memos for each output. */
+    /** Encrypted memos for each output — max 2. */
     encryptedMemos: string[];
-    /** Leaf indices assigned to output commitments. */
+    /** Leaf indices assigned to output commitments — max 2. */
     leafIndices: number[];
 };
-/** Emitted by `unshield()` when a note is withdrawn. */
+/**
+ * Emitted by `unshield()` when a note is withdrawn to the public chain.
+ * Rust variant: `Unshielded { nullifier, amount, recipient }`
+ */
 type UnshieldedEvent = {
-    /** 0x-prefixed 32-byte nullifier hex (LE). */
+    /** 0x-prefixed 32-byte Poseidon nullifier (LE). */
     nullifier: string;
     amount: bigint;
-    /** SS58 or 0x-prefixed AccountId of the recipient. */
+    /** SS58 AccountId of the recipient. */
     recipient: string;
 };
-/** Emitted after every Merkle tree update. */
+/**
+ * Emitted after every Merkle tree update (shield / transfer / unshield).
+ * Rust variant: `MerkleRootUpdated { old_root, new_root, tree_size }`
+ */
 type MerkleRootUpdatedEvent = {
-    /** 0x-prefixed previous root hex. */
+    /** 0x-prefixed previous Merkle root (32 bytes, LE). */
     oldRoot: string;
-    /** 0x-prefixed new root hex. */
+    /** 0x-prefixed new Merkle root (32 bytes, LE). */
     newRoot: string;
-    /** New total number of leaves. */
+    /** Total number of leaves after the update. */
     treeSize: number;
 };
-/** Discriminated union of all shielded-pool events. */
+/**
+ * Emitted by `set_audit_policy()` when an account sets or updates its audit policy.
+ * Rust variant: `AuditPolicySet { account, version }`
+ */
+type AuditPolicySetEvent = {
+    /** SS58 AccountId of the policy owner. */
+    account: string;
+    /** Policy version number (monotonically increasing). */
+    version: number;
+};
+/**
+ * Emitted by `disclose()` when a note is disclosed.
+ * Rust variant: `Disclosed { who, commitment, auditor }`
+ */
+type DisclosedEvent = {
+    /** SS58 AccountId of the discloser. */
+    who: string;
+    /** 0x-prefixed 32-byte commitment of the disclosed note. */
+    commitment: string;
+    /** SS58 AccountId of the auditor, or null for voluntary disclosure. */
+    auditor: string | null;
+};
+/**
+ * Emitted by `request_disclosure()` when an auditor requests a note disclosure.
+ * Rust variant: `DisclosureRequested { target, auditor, reason }`
+ */
+type DisclosureRequestedEvent = {
+    /** SS58 AccountId of the note owner (disclosure target). */
+    target: string;
+    /** SS58 AccountId of the requesting auditor. */
+    auditor: string;
+    /** Reason string (max 256 bytes, UTF-8). */
+    reason: string;
+};
+/**
+ * Emitted by `reject_disclosure()` when a note owner rejects a disclosure request.
+ * Rust variant: `DisclosureRejected { target, auditor, reason }`
+ */
+type DisclosureRejectedEvent = {
+    /** SS58 AccountId of the note owner. */
+    target: string;
+    /** SS58 AccountId of the auditor whose request was rejected. */
+    auditor: string;
+    /** Rejection reason string (max 256 bytes, UTF-8). */
+    reason: string;
+};
+/**
+ * Emitted when a pending disclosure request expires (on_finalize pruning).
+ * Rust variant: `DisclosureRequestExpired { target, auditor }`
+ */
+type DisclosureRequestExpiredEvent = {
+    /** SS58 AccountId of the note owner. */
+    target: string;
+    /** SS58 AccountId of the auditor. */
+    auditor: string;
+};
+/**
+ * Emitted by `revoke_disclosure_record()` when an account revokes a previous disclosure.
+ * Rust variant: `DisclosureRecordRevoked { who, commitment }`
+ */
+type DisclosureRecordRevokedEvent = {
+    /** SS58 AccountId of the note owner. */
+    who: string;
+    /** 0x-prefixed 32-byte commitment of the revoked note. */
+    commitment: string;
+};
+/**
+ * Emitted by `register_asset()` when a new asset is registered in the pool.
+ * Rust variant: `AssetRegistered { asset_id }`
+ */
+type AssetRegisteredEvent = {
+    assetId: number;
+};
+/**
+ * Emitted by `verify_asset()` when an asset is verified (marked as trusted).
+ * Rust variant: `AssetVerified { asset_id }`
+ */
+type AssetVerifiedEvent = {
+    assetId: number;
+};
+/**
+ * Emitted by `unverify_asset()` when an asset's verified status is removed.
+ * Rust variant: `AssetUnverified { asset_id }`
+ */
+type AssetUnverifiedEvent = {
+    assetId: number;
+};
+/** All events emitted by pallet-shielded-pool as a discriminated union. */
 type ShieldedPoolEvent = {
     type: 'Shielded';
     data: ShieldedEvent;
@@ -1555,6 +1655,973 @@ type ShieldedPoolEvent = {
 } | {
     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;
+};
+
+/**
+ * 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. */
+type PrivateTransferInput = {
+    /** 32-byte Poseidon nullifier (LE). */
+    nullifier: Bytes32;
+    /** 32-byte Poseidon commitment (LE). */
+    commitment: Bytes32;
+};
+/** Output note created by a private transfer. */
+type PrivateTransferOutput = {
+    /** 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: PrivateTransferInput[];
+    outputs: PrivateTransferOutput[];
+    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;
+};
+
+/**
+ * TypeScript types for pallet-zk-verifier extrinsics.
+ *
+ * Conventions:
+ *   - Byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Versions     → `number`    (u32)
+ */
+/**
+ * On-chain circuit identifier (u32 newtype on-chain).
+ * Use the {@link CircuitId} constant object for named values.
+ */
+type CircuitId = (typeof CircuitId)[keyof typeof CircuitId];
+/**
+ * Named constants for all supported ZK circuits.
+ *
+ * | Name         | Value | Circuit                         |
+ * |--------------|-------|---------------------------------|
+ * | Transfer     | 1     | 2-in-2-out private transfer     |
+ * | Unshield     | 2     | Withdrawal from the pool        |
+ * | Disclosure   | 3     | Selective disclosure            |
+ * | PrivateLink  | 4     | Private chain-link proof        |
+ */
+declare const CircuitId: {
+    readonly Transfer: 1;
+    readonly Unshield: 2;
+    readonly Disclosure: 3;
+    readonly PrivateLink: 4;
+};
+/**
+ * A single verification key registration entry used in batch operations.
+ * Maps to `VkEntry` in Rust.
+ */
+type VkEntry = {
+    circuitId: CircuitId;
+    /** Circuit version number (u32 on-chain). Versions are independent per circuit. */
+    version: number;
+    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
+    verificationKey: number[];
+};
+/**
+ * Call index 0 — `register_verification_key` (Root origin)
+ * Registers a Groth16 verification key for a specific circuit and version.
+ */
+type RegisterVerificationKeyArgs = {
+    circuitId: CircuitId;
+    /** Version to associate with this key. */
+    version: number;
+    /** Serialised Groth16 verification key bytes — max 8 192 bytes. */
+    verificationKey: number[];
+};
+/**
+ * Call index 1 — `set_active_version` (Root origin)
+ * Designates a specific version as the active one used for proof verification.
+ */
+type SetActiveVersionArgs = {
+    circuitId: CircuitId;
+    version: number;
+};
+/**
+ * Call index 2 — `remove_verification_key` (Root origin)
+ * Removes a registered verification key.
+ * The currently active version cannot be removed.
+ */
+type RemoveVerificationKeyArgs = {
+    circuitId: CircuitId;
+    version: number;
+};
+/**
+ * Call index 3 — `verify_proof` (Signed origin)
+ * Verifies a single Groth16 proof on-chain for the specified circuit.
+ * Uses the circuit's currently active verification key version.
+ */
+type VerifyProofArgs = {
+    circuitId: CircuitId;
+    /** Groth16 proof bytes. */
+    proof: number[];
+    /**
+     * Public inputs as a list of 32-byte field elements (LE).
+     * Number and meaning of inputs depends on the circuit:
+     * - Transfer:    [merkle_root, nullifier_0, nullifier_1, commitment_0, commitment_1]
+     * - Unshield:    [merkle_root, nullifier, amount_fe, recipient_hash, asset_id_fe]
+     * - Disclosure:  [commitment, revealed_value_fe, revealed_asset_id_fe, owner_hash]
+     * - PrivateLink: [commitment, call_hash_fe]
+     */
+    publicInputs: number[][];
+};
+/**
+ * Call index 4 — `batch_register_verification_keys` (Root origin)
+ * Registers up to 10 verification keys in one extrinsic.
+ * Useful for initial chain setup or coordinated upgrades.
+ */
+type BatchRegisterVerificationKeysArgs = {
+    /** Up to 10 VK entries. */
+    entries: VkEntry[];
+};
+/** All pallet-zk-verifier calls as a discriminated union. */
+type ZkVerifierCall = {
+    type: 'registerVerificationKey';
+    args: RegisterVerificationKeyArgs;
+} | {
+    type: 'setActiveVersion';
+    args: SetActiveVersionArgs;
+} | {
+    type: 'removeVerificationKey';
+    args: RemoveVerificationKeyArgs;
+} | {
+    type: 'verifyProof';
+    args: VerifyProofArgs;
+} | {
+    type: 'batchRegisterVerificationKeys';
+    args: BatchRegisterVerificationKeysArgs;
+};
+
+/**
+ * TypeScript types for pallet-account-mapping extrinsics.
+ *
+ * Conventions:
+ *   - Byte arrays  → `number[]`  (SCALE-compatible)
+ *   - Balances     → `bigint`
+ *   - AccountId    → `string`    (SS58 or 0x-prefixed 64-char hex)
+ *   - ChainId      → `number`    (u32, typically a SLIP-0044 coin type)
+ *   - Optional     → `T | null`
+ */
+/**
+ * External chain signature scheme.
+ * Maps to `SignatureScheme` enum in pallet-account-mapping.
+ *
+ * - `Eip191`  — Ethereum personal_sign (EIP-191 prefix)
+ * - `Ed25519` — Raw Ed25519 signature (Solana, Polkadot, etc.)
+ */
+type SignatureScheme = 'Eip191' | 'Ed25519';
+/**
+ * Call index 2 — `register_alias` (Signed origin)
+ * Registers a human-readable identity alias for the caller's Substrate account.
+ * 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;
+};
+
+/**
+ * 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 by `set_active_version()` when the active VK version changes.
+ * Rust variant: `ActiveVersionSet { circuit_id, version }`
+ */
+type ActiveVersionSetEvent = {
+    circuitId: CircuitId;
+    version: number;
+};
+/**
+ * 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: 'ActiveVersionSet';
+    data: ActiveVersionSetEvent;
+} | {
+    type: 'VerificationKeyRemoved';
+    data: VerificationKeyRemovedEvent;
+} | {
+    type: 'ProofVerified';
+    data: ProofVerifiedEvent;
+} | {
+    type: 'ProofVerificationFailed';
+    data: ProofVerificationFailedEvent;
+} | {
+    type: 'BatchVerificationKeysRegistered';
+    data: BatchVerificationKeysRegisteredEvent;
+};
+
+/**
+ * TypeScript types for events emitted by pallet-account-mapping.
+ *
+ * Conventions:
+ *   - AccountId     → `string`  (SS58)
+ *   - H160          → `string`  (0x-prefixed 20-byte Ethereum address)
+ *   - AliasOf<T>    → `string`  (bounded string, max configurable)
+ *   - ChainId       → `number`  (SLIP-0044 coin-type u32)
+ *   - ExternalAddr  → `string`  (chain-specific address string)
+ *   - BalanceOf<T>  → `bigint`
+ *   - [u8; 32]      → `string`  (0x-prefixed hex, for private commitments)
+ *   - SignatureScheme → imported from pallet-extrinsics
+ */
+
+/**
+ * Emitted when a Substrate account is mapped to an Ethereum address.
+ * Rust variant: `AccountMapped { account, address }`
+ */
+type AccountMappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
+};
+/**
+ * Emitted when an existing account mapping is removed.
+ * Rust variant: `AccountUnmapped { account, address }`
+ */
+type AccountUnmappedEvent = {
+    account: string;
+    /** 0x-prefixed 20-byte Ethereum address. */
+    address: string;
+};
+/**
+ * Emitted by `register_alias()` when a new alias is claimed.
+ * Rust variant: `AliasRegistered { account, alias, evm_address }`
+ */
+type AliasRegisteredEvent = {
+    account: string;
+    alias: string;
+    /** Optional EVM address linked at registration time. */
+    evmAddress: string | null;
+};
+/**
+ * Emitted when an alias is released (burned / expired).
+ * Rust variant: `AliasReleased { account, alias }`
+ */
+type AliasReleasedEvent = {
+    account: string;
+    alias: string;
+};
+/**
+ * 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;
 };
 
 /** Configuration for IndexerClient. */
@@ -1688,4 +2755,4 @@ declare class IndexerClient {
     getLatestMerkleRoot(): Promise<MerkleRoot | null>;
 }
 
-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 AccountMappedEvent, type AccountMappingCall, type AccountMappingEvent, AccountMappingModule, AccountMappingPrecompile, type AccountMetadata, type AccountUnmappedEvent, type ActiveVersionSetEvent, type AddChainLinkArgs, type AddChainLinkParams, type AddSupportedChainArgs, type AliasFullIdentity, type AliasInfo, type AliasListedForSaleEvent, type AliasRegisteredEvent, type AliasReleasedEvent, type AliasSaleCancelledEvent, type AliasSoldEvent, type AliasTransferredEvent, type AssetRegisteredEvent, type AssetUnverifiedEvent, type AssetVerifiedEvent, type AuditPolicySetEvent, type Auditor, type BatchDisclosureSubmission, type BatchRegisterVerificationKeysArgs, type BatchSubmitDisclosureProofsArgs, type BatchVerificationKeysRegisteredEvent, type BuyAliasArgs, type Bytes32, type ChainInfo, type ChainLink, type ChainLinkAddedEvent, type ChainLinkRemovedEvent, ChainModule, CircuitId, CircuitId as CircuitIdType, type CommitmentMerkleProof, CryptoPrecompiles, type DecryptedMemo, type DiscloseArgs, type DisclosedEvent, type DisclosureCondition, type DisclosurePublicSignals, type DisclosureRecordRevokedEvent, type DisclosureRejectedEvent, type DisclosureRequestExpiredEvent, type DisclosureRequestedEvent, type DispatchAsLinkedAccountArgs, type DispatchAsLinkedParams, type DispatchAsPrivateLinkArgs, EncryptedMemo, EvmClient, type EvmSigner, type EvmTxRequest, type FormatOptions, type FullIdentityInfo, IndexerClient, type IndexerClientConfig, KNOWN_PRECOMPILES, type KnownPrecompileInfo, type ListingInfo, MerkleModule, type MerkleProof, type MerkleRoot, type MerkleRootUpdatedEvent, type MerkleTreeInfo, type MetadataUpdatedEvent, NoteBuilder, type NoteInput, type NullifierStatus, type NullifierStatusResult, OrbinumClient, type OrbinumClientConfig, PRECOMPILE_ADDR, type PaginatedResult, type PoolBalance, type PoolStats, PrivacyKeyManager, type PrivateChainLinkAddedEvent, type PrivateChainLinkRemovedEvent, type PrivateChainLinkRevealedEvent, type PrivateLink, type PrivateLinkDispatchExecutedEvent, type PrivateTransfer, type PrivateTransferArgs, type PrivateTransferEvent, type PrivateTransferInput, type PrivateTransferOutput, type PrivateTransferParams, type ProofVerificationFailedEvent, type ProofVerifiedEvent, type ProxyCallExecutedEvent, type PruneExpiredRequestArgs, type PutAliasOnSaleArgs, type PutOnSaleParams, type RegisterAliasArgs, type RegisterAssetArgs, type RegisterPrivateLinkArgs, type RegisterVerificationKeyArgs, type RejectDisclosureArgs, type RemoveChainLinkArgs, type RemovePrivateLinkArgs, type RemoveSupportedChainArgs, type RemoveVerificationKeyArgs, type RequestDisclosureArgs, type ResolvedAlias, type RevealPrivateLinkArgs, type RevokeDisclosureRecordArgs, SLIP0044_NAMESPACE, type ScanCommitment, type SetAccountMetadataArgs, type SetActiveVersionArgs, type SetAuditPolicyArgs, type SetMetadataParams, type ShieldArgs, type ShieldBatchArgs, type ShieldOperation, type ShieldParams, type ShieldResult, type ShieldedCommitment, type ShieldedEvent, type ShieldedPoolCall, type ShieldedPoolEvent, ShieldedPoolModule, ShieldedPoolPrecompile, type SignatureScheme$1 as SignatureScheme, type SpentNullifier, SubstrateClient, type SupportedChain, type SupportedChainAddedEvent, type SupportedChainRemovedEvent, type TransferAliasArgs, type TransferInput, type TransferOutput, type TxResult, type Unshield, type UnshieldArgs, type UnshieldParams, type UnshieldedEvent, type UnverifyAssetArgs, type VerificationKeyRegisteredEvent, type VerificationKeyRemovedEvent, type VerifyAssetArgs, type VerifyProofArgs, type VkEntry, type ZkNote, type ZkVerifierCall, type ZkVerifierEvent, accountIdHexToSs58, addressToAccountIdHex, bigintTo32Be, bigintTo32Le, bigintTo32LeArr, bytesToBigintLE, computePathIndices, decryptJson, deriveOwnerPk, deriveSpendingKeyFromSignature, deriveSpendingKeyMessage, deriveVaultKey, deriveViewingKey, encryptJson, ensureHexPrefix, evmAddressToAccountId, evmToImplicitSubstrate, evmToSubstrate, formatBalance, formatORB, fromHex, getPrecompileLabel, implicitSubstrateToEvm, isEvmAddress, isImplicitEvmAccount, isSs58, isSubstrateAddress, isUnifiedAddress, leHexToBigint, normalizeEvmAddress, substrateSs58ToAccountIdHex, substrateToEvm, toHex, tryDecryptNote, vaultReplacer, vaultReviver };