@orbinum/sdk 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -4,10 +4,45 @@ import {
   Binary
 } from "polkadot-api";
 import { getWsProvider } from "polkadot-api/ws-provider";
+import { getDynamicBuilder, getLookupFn } from "@polkadot-api/metadata-builders";
+import { decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
+import { AccountId } from "@polkadot-api/substrate-bindings";
+import { getExtrinsicDecoder } from "@polkadot-api/tx-utils";
+
+// src/utils/hex.ts
+function toHex(bytes) {
+  return "0x" + Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean.length % 2 !== 0) {
+    throw new Error(`Invalid hex string \u2014 odd length: "${hex}"`);
+  }
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    if (isNaN(byte)) throw new Error(`Invalid hex character at position ${i * 2}`);
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+function ensureHexPrefix(hex) {
+  return hex.startsWith("0x") ? hex : `0x${hex}`;
+}
+function hexToNumber(hex) {
+  return parseInt(hex, 16);
+}
+function hexToBigint(hex) {
+  return BigInt(hex);
+}
+
+// src/substrate/SubstrateClient.ts
 var SubstrateClient = class _SubstrateClient {
   constructor(_papi) {
     this._papi = _papi;
   }
+  _dynamicBuilder = null;
+  _extDecoder = null;
   /**
    * Connects to the Orbinum node via WebSocket.
    * Throws if the node does not respond within `timeoutMs`.
@@ -33,13 +68,145 @@ var SubstrateClient = class _SubstrateClient {
   async request(method, params = []) {
     return this._papi._request(method, params);
   }
+  /**
+   * Returns basic chain information from the node.
+   * Combines `system_name`, `system_chain`, `system_properties`, and `state_getRuntimeVersion`.
+   */
+  async getChainInfo() {
+    const [chainName, version, props] = await Promise.all([
+      this.request("system_chain", []),
+      this.request("state_getRuntimeVersion", []),
+      this.request(
+        "system_properties",
+        []
+      )
+    ]);
+    const rawSymbol = props.tokenSymbol;
+    const rawDecimals = props.tokenDecimals;
+    return {
+      name: chainName,
+      version: String(version.specVersion),
+      ss58Prefix: version.ss58Prefix ?? 42,
+      symbol: Array.isArray(rawSymbol) ? rawSymbol[0] ?? "ORB" : rawSymbol ?? "ORB",
+      decimals: Array.isArray(rawDecimals) ? rawDecimals[0] ?? 18 : rawDecimals ?? 18
+    };
+  }
+  /**
+   * Returns the node's peer count and sync status.
+   */
+  async getHealth() {
+    return this.request("system_health", []);
+  }
+  /**
+   * Returns the node's software version string.
+   */
+  async getNodeVersion() {
+    return this.request("system_version", []);
+  }
+  /**
+   * Returns the genesis hash hex.
+   */
+  async getGenesisHash() {
+    return this.request("chain_getBlockHash", [0]);
+  }
+  /**
+   * Returns the block hash for a given block number.
+   * Returns null when the block does not exist or has been pruned.
+   */
+  async getBlockHash(blockNumber) {
+    const hash = await this.request("chain_getBlockHash", [blockNumber]);
+    if (!hash || /^0x0+$/.test(hash) || hash === "0x" + "00".repeat(32)) return null;
+    return hash;
+  }
+  /**
+   * 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.
+   */
+  async getBlock(hashOrNumber) {
+    try {
+      let blockHash;
+      if (typeof hashOrNumber === "number" || /^\d+$/.test(String(hashOrNumber))) {
+        const num = typeof hashOrNumber === "number" ? hashOrNumber : parseInt(hashOrNumber, 10);
+        const h = await this.getBlockHash(num);
+        if (!h) return null;
+        blockHash = h;
+      } else {
+        blockHash = hashOrNumber;
+      }
+      const raw = await this.request("chain_getBlock", [blockHash]);
+      if (!raw?.block) return null;
+      const { header, extrinsics } = raw.block;
+      const builder = await this.getDynamicBuilder().catch(() => null);
+      const ss58Prefix = builder?.ss58Prefix ?? 42;
+      let timestampMs = null;
+      if (builder) {
+        try {
+          const tsStore = builder.buildStorage("Timestamp", "Now");
+          const tsRaw = await this.request("state_getStorage", [
+            tsStore.keys.enc(),
+            blockHash
+          ]);
+          if (tsRaw) {
+            timestampMs = Number(tsStore.value.dec(fromHex(tsRaw)));
+          }
+        } catch {
+        }
+      }
+      if (!timestampMs) {
+        const tsHex = extrinsics.find((hex) => {
+          try {
+            const b = fromHex(hex);
+            return b.length > 6 && b[4] === 3 && b[5] === 0;
+          } catch {
+            return false;
+          }
+        });
+        if (tsHex) {
+          try {
+            const b = fromHex(tsHex);
+            const view = new DataView(b.buffer, b.byteOffset + 6, 8);
+            const lo = view.getUint32(0, true);
+            const hi = view.getUint32(4, true);
+            const ms = lo + hi * 4294967296;
+            if (ms > 0) timestampMs = ms;
+          } catch {
+          }
+        }
+      }
+      const author = _SubstrateClient.extractAuthorFromLogs(header.digest.logs, ss58Prefix);
+      return { header, extrinsics, timestampMs, author };
+    } catch {
+      return 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() {
     return this._papi;
   }
+  /**
+   * Observable that emits a new entry each time a best-block is reported by the node.
+   * Delegates to PAPI's `blocks$`.
+   */
+  get blocks$() {
+    return this._papi.blocks$;
+  }
+  /**
+   * Returns the block header for a given tag or block hash.
+   * Delegates to PAPI's `getBlockHeader`.
+   */
+  getBlockHeader(...args) {
+    return this._papi.getBlockHeader(...args);
+  }
   /**
    * Returns the PAPI UnsafeApi for dynamic, metadata-driven transaction building.
    * The first access triggers a metadata fetch from the node.
@@ -84,34 +251,148 @@ var SubstrateClient = class _SubstrateClient {
   destroy() {
     this._papi.destroy();
   }
-};
-
-// src/utils/hex.ts
-function toHex(bytes) {
-  return "0x" + Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function fromHex(hex) {
-  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-  if (clean.length % 2 !== 0) {
-    throw new Error(`Invalid hex string \u2014 odd length: "${hex}"`);
+  /**
+   * 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.
+   */
+  async queryBlockEvents(blockHash) {
+    try {
+      const builder = await this.getDynamicBuilder();
+      const { keys, value } = builder.buildStorage("System", "Events");
+      const raw = await this.request("state_getStorage", [
+        keys.enc(),
+        blockHash
+      ]);
+      if (!raw) return null;
+      const decoded = value.dec(fromHex(raw));
+      return _SubstrateClient._toEventRecords(decoded);
+    } catch {
+      return null;
+    }
   }
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    const byte = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
-    if (isNaN(byte)) throw new Error(`Invalid hex character at position ${i * 2}`);
-    bytes[i] = byte;
+  // ─── Internal helpers ─────────────────────────────────────────────────────
+  async getDynamicBuilder() {
+    if (this._dynamicBuilder) return this._dynamicBuilder;
+    const rawMetadata = await this._papi.getMetadata("best");
+    const metadata = decAnyMetadata(rawMetadata);
+    const unified = unifyMetadata(metadata);
+    const lookup = getLookupFn(unified);
+    this._dynamicBuilder = getDynamicBuilder(lookup);
+    return this._dynamicBuilder;
+  }
+  async getExtrinsicDecoder() {
+    if (this._extDecoder) return this._extDecoder;
+    const rawMetadata = await this._papi.getMetadata("best");
+    this._extDecoder = getExtrinsicDecoder(rawMetadata);
+    return this._extDecoder;
+  }
+  static _buildDataProxy(value) {
+    const formatValue = (v) => {
+      if (v instanceof Uint8Array) return fromHex(v).toString();
+      if (typeof v === "bigint") return v.toString();
+      return String(v);
+    };
+    const jsonifyValue = (v) => {
+      if (v === null || v === void 0) return v;
+      if (typeof v === "bigint") return v.toString();
+      if (v instanceof Uint8Array)
+        return Array.from(v).map((b) => b.toString(16).padStart(2, "0")).join("");
+      if (Array.isArray(v)) return v.map(jsonifyValue);
+      if (typeof v === "object") {
+        return Object.fromEntries(
+          Object.entries(v).filter(([, val]) => typeof val !== "function").map(([k, val]) => [k, jsonifyValue(val)])
+        );
+      }
+      return v;
+    };
+    const entries = Array.isArray(value) ? value : value !== null && typeof value === "object" ? Object.values(value) : [value];
+    const items = entries.map((v) => ({
+      toString: () => formatValue(v),
+      toJSON: () => jsonifyValue(v),
+      toHuman: () => jsonifyValue(v),
+      ...v !== null && typeof v === "object" ? v : {}
+    }));
+    return Object.assign(items, {
+      toJSON: () => jsonifyValue(value),
+      toHuman: () => jsonifyValue(value)
+    });
   }
-  return bytes;
-}
-function ensureHexPrefix(hex) {
-  return hex.startsWith("0x") ? hex : `0x${hex}`;
-}
-function hexToNumber(hex) {
-  return parseInt(hex, 16);
-}
-function hexToBigint(hex) {
-  return BigInt(hex);
-}
+  /**
+   * 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, ss58Prefix) {
+    try {
+      for (const hex of logs) {
+        const bytes = fromHex(hex);
+        if (bytes.length < 6 || bytes[0] !== 6) continue;
+        const firstLenByte = bytes[5];
+        const mode = firstLenByte & 3;
+        let payloadStart;
+        let payloadLen;
+        if (mode === 0) {
+          payloadLen = firstLenByte >> 2;
+          payloadStart = 6;
+        } else if (mode === 1) {
+          if (bytes.length < 7) continue;
+          payloadLen = firstLenByte >> 2 | bytes[6] << 6;
+          payloadStart = 7;
+        } else if (mode === 2) {
+          if (bytes.length < 9) continue;
+          payloadLen = (firstLenByte >> 2 | bytes[6] << 6 | bytes[7] << 14 | bytes[8] << 22) >>> 0;
+          payloadStart = 9;
+        } else {
+          continue;
+        }
+        const payload = bytes.slice(payloadStart, payloadStart + payloadLen);
+        if (payload.length >= 32) {
+          try {
+            return AccountId(ss58Prefix).dec(payload.slice(0, 32));
+          } catch {
+            return toHex(payload.slice(0, 32));
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  static _toEventRecords(decoded) {
+    return decoded.flatMap((e) => {
+      try {
+        const raw = e;
+        const isApply = raw.phase.type === "ApplyExtrinsic";
+        const extIdx = isApply ? raw.phase.value : 0;
+        const section = raw.event.type.charAt(0).toLowerCase() + raw.event.type.slice(1);
+        const method = raw.event.value.type;
+        const record = {
+          phase: {
+            isApplyExtrinsic: isApply,
+            asApplyExtrinsic: {
+              eq: (n) => n === extIdx,
+              toString: () => String(extIdx),
+              toNumber: () => extIdx
+            }
+          },
+          event: {
+            section,
+            method,
+            data: _SubstrateClient._buildDataProxy(raw.event.value.value)
+          }
+        };
+        return [record];
+      } catch {
+        return [];
+      }
+    });
+  }
+};
 
 // src/evm/EvmClient.ts
 var EvmClient = class {
@@ -208,85 +489,590 @@ var EvmClient = class {
    * Returns a transaction receipt by hash, or null if not yet mined.
    */
   async getTransactionReceipt(txHash) {
-    return this.request("eth_getTransactionReceipt", [txHash]);
+    const res = await fetch(this.rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      })
+    });
+    if (!res.ok) throw new Error(`EVM HTTP ${res.status}: ${res.statusText}`);
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`EVM RPC [${json.error.code}]: ${json.error.message}`);
+    }
+    return json.result ?? null;
   }
 };
 
-// src/shielded-pool/MerkleModule.ts
-var MerkleModule = class {
-  constructor(substrate) {
-    this.substrate = substrate;
+// src/utils/format.ts
+var LOCALE_DECIMAL_SEP = new Intl.NumberFormat(void 0).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
+function formatIntegerLocale(intPart) {
+  try {
+    return BigInt(intPart || "0").toLocaleString(void 0);
+  } catch {
+    return (intPart || "0").replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   }
-  /**
-   * Returns the current Merkle tree state: root, number of leaves, and depth.
-   */
-  async getTreeInfo() {
-    const raw = await this.substrate.request(
-      "shieldedPool_getMerkleTreeInfo",
-      []
+}
+function normalizeDecimalForDisplay(raw, maxFractionDigits) {
+  let value = raw.trim();
+  if (!value) return null;
+  let sign = "";
+  if (value.startsWith("-")) {
+    sign = "-";
+    value = value.slice(1);
+  }
+  if (!/^\d*(\.\d*)?$/.test(value)) return null;
+  let [integerPart = "0", fractionPart = ""] = value.split(".");
+  integerPart = integerPart.replace(/^0+(?=\d)/, "") || "0";
+  const limit = Math.max(0, maxFractionDigits);
+  fractionPart = fractionPart.slice(0, limit).replace(/0+$/, "");
+  const formattedInt = formatIntegerLocale(integerPart);
+  return fractionPart ? `${sign}${formattedInt}${LOCALE_DECIMAL_SEP}${fractionPart}` : `${sign}${formattedInt}`;
+}
+function bigintFormatUnits(value, decimals) {
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const divider = 10n ** BigInt(decimals);
+  const intPart = abs / divider;
+  const fracPart = abs % divider;
+  const fracStr = fracPart.toString().padStart(decimals, "0");
+  return (negative ? "-" : "") + intPart.toString() + "." + fracStr;
+}
+function isCanonicalDecimal(value) {
+  return /^-?(?:\d+\.\d*|\d*\.\d+)$/.test(value);
+}
+function isBigIntLikeInteger(value) {
+  return /^-?\d+$/.test(value) || /^0[xX][0-9a-fA-F]+$/.test(value);
+}
+function formatBalance(raw, options = {}) {
+  const opts = typeof options === "number" ? { decimals: options } : options;
+  const { decimals = 18, symbol = "ORB", showSymbol = true, precision = 6 } = opts;
+  const zero = showSymbol ? `0 ${symbol}` : "0";
+  if (raw === null || raw === void 0) return zero;
+  if (typeof raw === "number" && !Number.isFinite(raw)) return zero;
+  const rawStr = String(raw).trim();
+  if (!rawStr) return zero;
+  if (isCanonicalDecimal(rawStr)) {
+    const formatted = normalizeDecimalForDisplay(rawStr, precision);
+    if (!formatted || formatted === "0" || formatted === "-0") return zero;
+    return showSymbol ? `${formatted} ${symbol}` : formatted;
+  }
+  if (!isBigIntLikeInteger(rawStr)) return zero;
+  try {
+    const n = BigInt(rawStr);
+    const decimalStr = bigintFormatUnits(n, decimals);
+    const formatted = normalizeDecimalForDisplay(decimalStr, precision);
+    if (!formatted || formatted === "0" || formatted === "-0") return zero;
+    return showSymbol ? `${formatted} ${symbol}` : formatted;
+  } catch {
+    return zero;
+  }
+}
+function formatORB(raw, precision = 6) {
+  return formatBalance(raw, { decimals: 18, symbol: "ORB", showSymbol: true, precision });
+}
+
+// src/evm-explorer/EvmExplorer.ts
+var EvmExplorer = class _EvmExplorer {
+  constructor(evm) {
+    this.evm = evm;
+  }
+  // --- Blocks ---
+  async getLatestBlocks(count = 10) {
+    const latest = await this.evm.getBlockNumber();
+    const nums = Array.from({ length: Math.min(count, latest + 1) }, (_, i) => latest - i);
+    const results = await Promise.all(
+      nums.map(
+        (n) => this.evm.request("eth_getBlockByNumber", [
+          `0x${n.toString(16)}`,
+          false
+        ]).catch(() => null)
+      )
+    );
+    return results.filter((b) => b !== null && !!b.hash).map((b) => this.parseBlock(b));
+  }
+  async getBlock(hashOrNumber) {
+    const b = await this.fetchBlock(hashOrNumber, false);
+    return b ? this.parseBlock(b) : null;
+  }
+  async getBlockTransactions(hashOrNumber) {
+    try {
+      const b = await this.fetchBlock(hashOrNumber, true);
+      if (!b || !b.transactions.length) return [];
+      const txs = b.transactions;
+      const receipts = await this.evm.batchRequest(txs.map((tx) => ({ method: "eth_getTransactionReceipt", params: [tx.hash] }))).catch(() => txs.map(() => null));
+      return txs.map((tx, i) => this.parseTx(tx, receipts[i] ?? null));
+    } catch {
+      return [];
+    }
+  }
+  // --- Transactions ---
+  async getTransaction(hash) {
+    try {
+      const [tx, receipt] = await Promise.all([
+        this.evm.request("eth_getTransactionByHash", [hash]),
+        this.evm.request("eth_getTransactionReceipt", [hash]).catch(() => null)
+      ]);
+      if (!tx) return null;
+      return this.parseTx(tx, receipt);
+    } catch {
+      return null;
+    }
+  }
+  async getTransactionsByAddress(address, maxBlocks = 300) {
+    const addr = address.toLowerCase();
+    const latest = await this.evm.getBlockNumber();
+    const from = Math.max(0, latest - maxBlocks + 1);
+    const blockNums = Array.from({ length: latest - from + 1 }, (_, i) => latest - i);
+    const blocks = await Promise.all(
+      blockNums.map(
+        (n) => this.evm.request("eth_getBlockByNumber", [
+          `0x${n.toString(16)}`,
+          true
+        ]).catch(() => null)
+      )
     );
+    const matchingTxs = [];
+    for (const block of blocks) {
+      if (!block?.transactions) continue;
+      const blockTimestamp = block.timestamp ? hexToNumber(block.timestamp) : null;
+      for (const tx of block.transactions) {
+        if (tx.from?.toLowerCase() === addr || tx.to?.toLowerCase() === addr) {
+          matchingTxs.push({ tx, timestamp: blockTimestamp });
+        }
+      }
+    }
+    if (!matchingTxs.length) return [];
+    const receipts = await this.evm.batchRequest(
+      matchingTxs.map(({ tx }) => ({
+        method: "eth_getTransactionReceipt",
+        params: [tx.hash]
+      }))
+    ).catch(() => matchingTxs.map(() => null));
+    const results = matchingTxs.map(({ tx, timestamp }, i) => {
+      const receipt = receipts[i] ?? null;
+      return {
+        hash: tx.hash,
+        blockNumber: hexToNumber(tx.blockNumber),
+        timestamp,
+        from: tx.from,
+        to: tx.to,
+        value: tx.value ?? "0x0",
+        input: tx.input ?? "0x",
+        gasUsed: receipt ? hexToNumber(receipt.gasUsed) : hexToNumber(tx.gas),
+        gasPrice: tx.gasPrice ?? "0x0",
+        status: receipt ? receipt.status === "0x1" : true,
+        isContractCreation: !tx.to,
+        contractAddress: receipt?.contractAddress ?? null
+      };
+    });
+    results.sort((a, b) => b.blockNumber - a.blockNumber);
+    return results;
+  }
+  // --- Address ---
+  async getAddressInfo(address) {
+    const latest = await this.evm.getBlockNumber().catch(() => 0);
+    const fromBlock = `0x${Math.max(0, latest - 5e3).toString(16)}`;
+    const [balance, nonce, code, logs] = await Promise.all([
+      this.evm.request("eth_getBalance", [address, "latest"]).catch(() => null),
+      this.evm.getTransactionCount(address).catch(() => 0),
+      this.evm.request("eth_getCode", [address, "latest"]).catch(() => null),
+      this.evm.request("eth_getLogs", [{ fromBlock, toBlock: "latest", address }]).catch(() => [])
+    ]);
+    const codeHex = code ?? "0x";
+    const isContract = codeHex !== "0x" && codeHex.length > 2;
+    const codeBytes = isContract ? Math.floor((codeHex.length - 2) / 2) : 0;
+    const recentLogs = (logs ?? []).slice(-50).map((l) => ({
+      address: l.address,
+      topics: l.topics,
+      data: l.data,
+      blockNumber: hexToNumber(l.blockNumber),
+      transactionHash: l.transactionHash,
+      logIndex: hexToNumber(l.logIndex)
+    }));
     return {
-      root: raw.root,
-      treeSize: raw.tree_size,
-      depth: raw.depth
+      address,
+      isContract,
+      balance: balance ?? "0x0",
+      nonce: typeof nonce === "number" ? nonce : hexToNumber(nonce ?? "0x0"),
+      codeSize: codeBytes,
+      code: isContract ? codeHex.length > 202 ? `${codeHex.slice(0, 202)}\u2026` : codeHex : "0x",
+      recentLogs
     };
   }
-  /**
-   * Returns the Merkle inclusion proof for a leaf at `leafIndex`.
-   */
-  async getProof(leafIndex) {
-    const raw = await this.substrate.request("shieldedPool_getMerkleProof", [
-      leafIndex
-    ]);
+  async getBalance(address) {
+    try {
+      const val = await this.evm.getBalance(address);
+      return formatBalance(val, { showSymbol: false, precision: 18 });
+    } catch {
+      return "0";
+    }
+  }
+  async getNonce(address) {
+    try {
+      return await this.evm.getTransactionCount(address);
+    } catch {
+      return 0;
+    }
+  }
+  async getIsContract(address) {
+    try {
+      const code = await this.evm.request("eth_getCode", [address, "latest"]);
+      return code !== "0x" && code !== "0x0" && code.length > 2;
+    } catch {
+      return false;
+    }
+  }
+  // --- Tokens ---
+  async getTokenInfo(address) {
+    const addr = address.toLowerCase();
+    const [name, symbol, decimals, totalSupply] = await this.evm.batchRequest([
+      { method: "eth_call", params: [{ to: addr, data: "0x06fdde03" }, "latest"] },
+      { method: "eth_call", params: [{ to: addr, data: "0x95d89b41" }, "latest"] },
+      { method: "eth_call", params: [{ to: addr, data: "0x313ce567" }, "latest"] },
+      { method: "eth_call", params: [{ to: addr, data: "0x18160ddd" }, "latest"] }
+    ]).catch(() => [null, null, null, null]);
+    const isErc20 = !!(totalSupply && totalSupply !== "0x" && symbol && decimals);
+    if (!isErc20 && !name && !symbol) return null;
     return {
-      root: raw.root,
-      leafIndex: raw.leaf_index,
-      siblings: raw.siblings
+      address: addr,
+      name: name ? _EvmExplorer.decodeAbiString(name) : "",
+      symbol: symbol ? _EvmExplorer.decodeAbiString(symbol) : "",
+      decimals: decimals ? Number(_EvmExplorer.decodeAbiUint(decimals)) : 18,
+      totalSupply: totalSupply ?? "0x0",
+      isErc20
     };
   }
-  /**
-   * Returns the Merkle inclusion proof for a given commitment (0x-prefixed hex).
-   * Searches the tree for the commitment and returns its proof.
-   */
-  async getProofByCommitment(commitmentHex) {
-    const raw = await this.substrate.request("shieldedPool_getMerkleProof", [
-      commitmentHex
-    ]);
+  async getTokenTransfers(address, holderAddress) {
+    const TRANSFER = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+    const latest = await this.evm.getBlockNumber().catch(() => 0);
+    const fromBlock = `0x${Math.max(0, latest - 5e3).toString(16)}`;
+    let logs;
+    if (holderAddress) {
+      const padded = `0x${holderAddress.replace(/^0x/, "").toLowerCase().padStart(64, "0")}`;
+      const [sent, received] = await Promise.all([
+        this.evm.request("eth_getLogs", [{ fromBlock, toBlock: "latest", address, topics: [TRANSFER, padded] }]).catch(() => []),
+        this.evm.request("eth_getLogs", [{ fromBlock, toBlock: "latest", address, topics: [TRANSFER, null, padded] }]).catch(() => [])
+      ]);
+      const merged = [...sent ?? [], ...received ?? []];
+      merged.sort((a, b) => hexToNumber(b.blockNumber) - hexToNumber(a.blockNumber));
+      logs = merged.slice(0, 100);
+    } else {
+      const all = await this.evm.request("eth_getLogs", [{ fromBlock, toBlock: "latest", address, topics: [TRANSFER] }]).catch(() => []);
+      logs = (all ?? []).slice(-100).reverse();
+    }
+    return logs.map((l) => ({
+      transactionHash: l.transactionHash,
+      blockNumber: hexToNumber(l.blockNumber),
+      from: `0x${(l.topics[1] ?? "").slice(-40)}`,
+      to: `0x${(l.topics[2] ?? "").slice(-40)}`,
+      value: l.data,
+      logIndex: hexToNumber(l.logIndex)
+    }));
+  }
+  async getTokenBalance(tokenAddress, holderAddress) {
+    const padded = holderAddress.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+    const result = await this.ethCall(tokenAddress, `0x70a08231${padded}`);
+    return result ?? "0x0";
+  }
+  // --- Private: parsers ---
+  parseBlock(b) {
     return {
-      root: raw.root,
-      leafIndex: raw.leaf_index,
-      siblings: raw.siblings
+      hash: b.hash,
+      number: hexToNumber(b.number),
+      timestamp: hexToNumber(b.timestamp),
+      transactions: b.transactions.map((tx) => typeof tx === "string" ? tx : tx.hash),
+      gasUsed: hexToNumber(b.gasUsed).toString(),
+      gasLimit: hexToNumber(b.gasLimit).toString(),
+      miner: b.miner,
+      parentHash: b.parentHash
     };
   }
-  /**
-   * Returns the current Merkle root without fetching the full tree info.
-   */
-  async getRoot() {
-    const info = await this.getTreeInfo();
-    return info.root;
+  parseTx(tx, receipt) {
+    const parsed = {
+      hash: tx.hash,
+      blockNumber: tx.blockNumber ? hexToNumber(tx.blockNumber) : 0,
+      from: tx.from,
+      to: tx.to ?? null,
+      value: tx.value,
+      gasUsed: receipt ? hexToNumber(receipt.gasUsed).toString() : "0",
+      gasPrice: _EvmExplorer.hexToDecimalStr(tx.gasPrice),
+      nonce: hexToNumber(tx.nonce),
+      input: tx.input ?? "0x",
+      status: receipt ? hexToNumber(receipt.status) : 0,
+      contractAddress: receipt?.contractAddress ?? null,
+      timestamp: null
+    };
+    if (tx.blockHash) parsed.blockHash = tx.blockHash;
+    return parsed;
   }
-  /**
-   * Returns an array of commitment leaves from index `from` to `to` (inclusive).
-   * Defaults to returning all leaves.
-   */
-  async getLeaves(from = 0, to) {
-    return this.substrate.request("shieldedPool_getMerkleLeaves", [from, to ?? null]);
+  // --- Private: fetch helpers ---
+  async fetchBlock(hashOrNumber, withTxObjects) {
+    try {
+      if (typeof hashOrNumber === "number" || /^\d+$/.test(String(hashOrNumber))) {
+        const hexN = `0x${parseInt(String(hashOrNumber), 10).toString(16)}`;
+        return await this.evm.request("eth_getBlockByNumber", [
+          hexN,
+          withTxObjects
+        ]);
+      }
+      return await this.evm.request("eth_getBlockByHash", [
+        hashOrNumber,
+        withTxObjects
+      ]);
+    } catch {
+      return null;
+    }
+  }
+  async ethCall(to, data) {
+    try {
+      return await this.evm.call(to, data);
+    } catch {
+      return null;
+    }
+  }
+  // --- Private static: ABI decoders ---
+  static decodeAbiString(hex) {
+    if (!hex || hex === "0x") return "";
+    const data = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (data.length < 128) return "";
+    const length = parseInt(data.slice(64, 128), 16);
+    if (!length) return "";
+    const strHex = data.slice(128, 128 + length * 2);
+    try {
+      const bytes = new Uint8Array(strHex.match(/../g)?.map((b) => parseInt(b, 16)) ?? []);
+      return new TextDecoder("utf-8", { fatal: false }).decode(bytes).replace(/\0/g, "");
+    } catch {
+      return "";
+    }
+  }
+  static decodeAbiUint(hex) {
+    if (!hex || hex === "0x") return 0n;
+    const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+    return BigInt(`0x${clean || "0"}`);
+  }
+  static hexToDecimalStr(hex) {
+    try {
+      return BigInt(hex).toString();
+    } catch {
+      return "0";
+    }
   }
 };
 
-// src/shielded-pool/ShieldedPoolModule.ts
-import { Binary as Binary2 } from "polkadot-api";
-
-// src/shielded-pool/EncryptedMemo.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { randomBytes } from "@noble/ciphers/utils.js";
-
-// src/utils/bytes.ts
-function bigintTo32Le(n) {
-  const buf = new Uint8Array(32);
-  let v = n;
-  for (let i = 0; i < 32; i++) {
+// src/indexer/IndexerClient.ts
+var IndexerClient = class {
+  baseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+  }
+  // ─── Internal helpers ──────────────────────────────────────────────────────
+  async _fetchResponse(path) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await fetch(`${this.baseUrl}${path}`, { signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async get(path) {
+    const res = await this._fetchResponse(path);
+    if (!res.ok) {
+      throw new Error(`IndexerClient: HTTP ${res.status} for ${path}`);
+    }
+    return res.json();
+  }
+  async getOrNull(path) {
+    const res = await this._fetchResponse(path);
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      throw new Error(`IndexerClient: HTTP ${res.status} for ${path}`);
+    }
+    return res.json();
+  }
+  buildQuery(params) {
+    const entries = Object.entries(params).filter(([, v]) => v !== void 0);
+    if (entries.length === 0) return "";
+    const qs = entries.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    return `?${qs}`;
+  }
+  // ─── Commitments ───────────────────────────────────────────────────────────
+  /** Returns the total count of shielded commitments. */
+  async getCommitmentsCount() {
+    const res = await this.get("/shielded/commitments/count");
+    return res.total;
+  }
+  /** Returns a paginated list of shielded commitments. */
+  async getCommitments(params) {
+    const qs = this.buildQuery({
+      page: params?.page,
+      limit: params?.limit,
+      since_leaf_index: params?.sinceLeafIndex
+    });
+    return this.get(`/shielded/commitments${qs}`);
+  }
+  /** Returns a single commitment by its hex string, or null if not found. */
+  async getCommitmentByHex(hex) {
+    return this.getOrNull(
+      `/shielded/commitments/${encodeURIComponent(hex)}`
+    );
+  }
+  // ─── Nullifiers ────────────────────────────────────────────────────────────
+  /** Returns a paginated list of spent nullifiers. */
+  async getNullifiers(params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(`/shielded/nullifiers${qs}`);
+  }
+  /** Returns the spent/unspent status of a nullifier. */
+  async getNullifierStatus(hex) {
+    return this.get(
+      `/shielded/nullifier/${encodeURIComponent(hex)}/status`
+    );
+  }
+  // ─── Private transfers ─────────────────────────────────────────────────────
+  /** Returns a paginated list of private transfer events. */
+  async getTransfers(params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(`/shielded/transfers${qs}`);
+  }
+  // ─── Unshields ─────────────────────────────────────────────────────────────
+  /** Returns a paginated list of unshield events. */
+  async getUnshields(params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(`/shielded/unshields${qs}`);
+  }
+  // ─── Merkle roots ──────────────────────────────────────────────────────────
+  /** Returns a paginated list of Merkle root checkpoints. */
+  async getMerkleRoots(params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(`/shielded/merkle-roots${qs}`);
+  }
+  /** Returns the latest Merkle root, or null if none exists. */
+  async getLatestMerkleRoot() {
+    return this.getOrNull("/shielded/merkle-roots/latest");
+  }
+  // ─── Address activity ──────────────────────────────────────────────────────
+  /** Returns a paginated list of extrinsics signed by the given address. */
+  async getAddressExtrinsics(address, params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(
+      `/address/${encodeURIComponent(address.toLowerCase())}/extrinsics${qs}`
+    );
+  }
+  /** Returns a paginated list of EVM transactions filtered by address and/or block number. */
+  async getEvmTransactions(params) {
+    const qs = this.buildQuery({
+      page: params?.page,
+      limit: params?.limit,
+      address: params?.address?.toLowerCase(),
+      blockNumber: params?.blockNumber
+    });
+    return this.get(`/evm/transactions${qs}`);
+  }
+  /** Returns a single EVM transaction by hash, or null if not found. */
+  async getEvmTransactionByHash(hash) {
+    return this.getOrNull(
+      `/evm/transactions/${encodeURIComponent(hash.toLowerCase())}`
+    );
+  }
+  // ─── Blocks ────────────────────────────────────────────────────────────────
+  /** Returns a paginated list of indexed blocks. */
+  async getBlocks(params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(`/blocks${qs}`);
+  }
+  /** Returns a single block by number or hash, or null if not found. */
+  async getBlock(numberOrHash) {
+    return this.getOrNull(`/blocks/${encodeURIComponent(String(numberOrHash))}`);
+  }
+  // ─── Address commitments ───────────────────────────────────────────────────
+  /** Returns a paginated list of shielded commitments initiated by an address. */
+  async getAddressCommitments(address, params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(
+      `/address/${encodeURIComponent(address.toLowerCase())}/shielded${qs}`
+    );
+  }
+  /**
+   * 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.
+   */
+  async getAddressShieldedActivity(address, params) {
+    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
+    return this.get(
+      `/shielded/address/${encodeURIComponent(address.toLowerCase())}${qs}`
+    );
+  }
+  // ─── Stats & Health ────────────────────────────────────────────────────────
+  /** Returns aggregated indexer statistics. */
+  async getStats() {
+    return this.get("/stats");
+  }
+  /** Returns true if the indexer health endpoint responds OK. */
+  async isHealthy() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const res = await fetch(`${this.baseUrl}/health`, {
+          signal: controller.signal
+        });
+        return res.ok;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/shielded-pool/ShieldedPoolModule.ts
+import { Binary as Binary2 } from "polkadot-api";
+
+// src/utils/tx.ts
+function toTxResult(payload) {
+  const base = {
+    txHash: payload.txHash,
+    blockHash: payload.block.hash,
+    blockNumber: payload.block.number,
+    ok: payload.ok
+  };
+  if (!payload.ok) {
+    return { ...base, error: payload.dispatchError.type };
+  }
+  return base;
+}
+function callUnsafeTx(txEntry, ...args) {
+  return txEntry(...args);
+}
+function resolveTx(unsafe, pallet, call) {
+  const u = unsafe;
+  const p = u["tx"]?.[pallet];
+  if (p === void 0) throw new Error(`Pallet "${pallet}" not found in runtime metadata`);
+  const entry = p[call];
+  if (entry === void 0)
+    throw new Error(`Call "${pallet}.${call}" not found in runtime metadata`);
+  return entry;
+}
+
+// src/shielded-pool/EncryptedMemo.ts
+import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { randomBytes } from "@noble/ciphers/utils.js";
+
+// src/utils/bytes.ts
+function bigintTo32Le(n) {
+  const buf = new Uint8Array(32);
+  let v = n;
+  for (let i = 0; i < 32; i++) {
     buf[i] = Number(v & 0xffn);
     v >>= 8n;
   }
@@ -335,11 +1121,10 @@ function leHexToBigint(hex) {
   return bytesToBigintLE(bytes);
 }
 
-// src/shielded-pool/EncryptedMemo.ts
+// src/shielded-pool/helpers.ts
+import { sha256 } from "@noble/hashes/sha2.js";
 var KEY_DOMAIN = new TextEncoder().encode("orbinum-note-encryption-v1");
-var NONCE_SIZE = 12;
 var MEMO_PLAINTEXT_SIZE = 76;
-var ENCRYPTED_MEMO_SIZE = 104;
 function serializeMemo(value, ownerPk, blinding, assetId) {
   const buf = new Uint8Array(MEMO_PLAINTEXT_SIZE);
   const view = new DataView(buf.buffer);
@@ -356,6 +1141,22 @@ function deriveEncryptionKey(viewingKey, commitment) {
   h.update(KEY_DOMAIN);
   return h.digest();
 }
+function toBase64(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  let str = "";
+  for (const b of bytes) str += String.fromCharCode(b);
+  return btoa(str);
+}
+function fromBase64(b64) {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+// src/shielded-pool/EncryptedMemo.ts
+var NONCE_SIZE = 12;
+var ENCRYPTED_MEMO_SIZE = 104;
 var EncryptedMemo = {
   /**
    * Build and encrypt a memo for a note.
@@ -501,34 +1302,9 @@ var NoteBuilder = class {
 };
 
 // src/shielded-pool/ShieldedPoolModule.ts
-function toTxResult(payload) {
-  const base = {
-    txHash: payload.txHash,
-    blockHash: payload.block.hash,
-    blockNumber: payload.block.number,
-    ok: payload.ok
-  };
-  if (!payload.ok) {
-    return { ...base, error: payload.dispatchError.type };
-  }
-  return base;
-}
-function callUnsafeTx(txEntry, ...args) {
-  return txEntry(...args);
-}
-function resolveTx(unsafe, pallet, call) {
-  const u = unsafe;
-  const p = u["tx"]?.[pallet];
-  if (p === void 0) throw new Error(`Pallet "${pallet}" not found in runtime metadata`);
-  const entry = p[call];
-  if (entry === void 0)
-    throw new Error(`Call "${pallet}.${call}" not found in runtime metadata`);
-  return entry;
-}
 var ShieldedPoolModule = class {
-  constructor(substrate, merkle) {
+  constructor(substrate) {
     this.substrate = substrate;
-    this.merkle = merkle;
   }
   // ─── Extrinsics ────────────────────────────────────────────────────────────
   /**
@@ -620,44 +1396,26 @@ var ShieldedPoolModule = class {
     );
     return toTxResult(await tx.signAndSubmit(signer));
   }
-  // ─── Queries ───────────────────────────────────────────────────────────────
-  /** Returns whether a nullifier has already been spent. */
-  async isNullifierSpent(nullifierHex) {
-    const raw = await this.substrate.request(
-      "privacy_getNullifierStatus",
-      [nullifierHex]
-    );
-    return raw.is_spent;
-  }
-  /** Returns the full nullifier status object. */
-  async getNullifierStatus(nullifierHex) {
-    const raw = await this.substrate.request(
-      "privacy_getNullifierStatus",
-      [nullifierHex]
-    );
-    return { nullifier: raw.nullifier, isSpent: raw.is_spent };
-  }
-  /** Returns the total locked balance in the pool for a given asset. */
-  async getPoolBalance(assetId) {
-    const raw = await this.substrate.request(
-      "shieldedPool_getPoolBalance",
-      [assetId]
-    );
-    return { assetId, balance: BigInt(raw.balance) };
-  }
   /**
-   * Returns Merkle tree info and pool balance for a given asset in a single call.
-   * Convenience wrapper used by both `app` and `privacy-explorer`.
+   * Deposits multiple notes into the shielded pool in a single extrinsic.
+   * Extrinsic: shieldedPool.shieldBatch(operations) — max 20 items.
    */
-  async getPoolStats(assetId = 0) {
-    const [merkle, balance] = await Promise.all([
-      this.merkle.getTreeInfo(),
-      this.getPoolBalance(assetId)
-    ]);
-    return { merkle, balance };
+  async shieldBatch(params, signer) {
+    const operations = params.items.map((item) => ({
+      assetId: item.assetId,
+      amount: item.amount.toString(),
+      commitment: Binary2.fromHex(item.commitment),
+      encryptedMemo: Binary2.fromBytes(item.encryptedMemo ?? EncryptedMemo.dummy())
+    }));
+    const entry = resolveTx(this.substrate.unsafe, "shieldedPool", "shieldBatch");
+    const tx = callUnsafeTx(entry, operations);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
 };
 
+// src/account-mapping/AccountMappingModule.ts
+import { Binary as Binary3 } from "polkadot-api";
+
 // src/utils/address.ts
 import { decodeAddress, encodeAddress } from "@polkadot/util-crypto";
 function normalizeEvmAddress(addr) {
@@ -688,6 +1446,10 @@ function evmToImplicitSubstrate(evmAddr) {
   }
   return "0x" + clean.toLowerCase() + "0".repeat(24);
 }
+function evmToMappedAccountHex(address) {
+  if (!isEvmAddress(address)) return null;
+  return evmToImplicitSubstrate(address);
+}
 function isImplicitEvmAccount(accountHex) {
   const clean = accountHex.startsWith("0x") ? accountHex.slice(2) : accountHex;
   if (clean.length !== 64) return false;
@@ -790,139 +1552,14 @@ function addressToAccountIdHex(addr) {
   return substrateSs58ToAccountIdHex(addr);
 }
 
-// src/chain/ChainModule.ts
-var ChainModule = class {
-  constructor(substrate, evm) {
-    this.substrate = substrate;
-    this.evm = evm;
-  }
-  // ─── Node info ─────────────────────────────────────────────────────────────
-  /**
-   * Returns basic chain information from the node.
-   */
-  async getChainInfo() {
-    const [name, version] = await Promise.all([
-      this.substrate.request("system_name", []),
-      this.substrate.request("state_getRuntimeVersion", [])
-    ]);
-    return {
-      name,
-      version: String(version.specVersion),
-      ss58Prefix: version.ss58Prefix ?? 42
-    };
-  }
-  /**
-   * Returns the node's peer count and sync status.
-   */
-  async getHealth() {
-    return this.substrate.request("system_health", []);
-  }
-  /**
-   * Returns the node's software version string.
-   */
-  async getNodeVersion() {
-    return this.substrate.request("system_version", []);
-  }
-  /**
-   * Returns the genesis hash hex.
-   */
-  async getGenesisHash() {
-    return this.substrate.request("chain_getBlockHash", [0]);
-  }
-  // ─── Account mapping ───────────────────────────────────────────────────────
-  /**
-   * Resolves the full identity (Substrate + EVM addresses, alias) for an account.
-   * Accepts an EVM address (0x...) or a Substrate account hex (0x...32bytes).
-   */
-  async getFullIdentity(address) {
-    try {
-      const raw = await this.substrate.request(
-        "accountMapping_resolveFullIdentity",
-        [address]
-      );
-      return {
-        substrateAddress: raw.substrate_address ?? null,
-        evmAddress: raw.evm_address ? normalizeEvmAddress(raw.evm_address) : null,
-        alias: raw.alias ?? null
-      };
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Returns the mapped Substrate account hex for a given EVM address, or null.
-   */
-  async getMappedAccountByEvm(evmAddress) {
-    try {
-      return await this.substrate.request("accountMapping_getMappedAccount", [
-        normalizeEvmAddress(evmAddress)
-      ]);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Returns the alias registered for a Substrate account, or null.
-   */
-  async getAliasOf(accountHex) {
-    try {
-      return await this.substrate.request("accountMapping_getAliasOf", [
-        accountHex
-      ]);
-    } catch {
-      return null;
-    }
-  }
-  // ─── EVM helpers ───────────────────────────────────────────────────────────
-  /**
-   * Returns estimated EVM chain ID from the EVM RPC endpoint. Requires evmRpc
-   * to have been provided in `OrbinumClientConfig`.
-   */
-  async getEvmChainId() {
-    if (!this.evm)
-      throw new Error("No EVM RPC URL configured. Set evmRpc in OrbinumClientConfig.");
-    return this.evm.getChainId();
-  }
-  /**
-   * Returns the current EVM block number.
-   */
-  async getEvmBlockNumber() {
-    if (!this.evm) throw new Error("No EVM RPC URL configured.");
-    return this.evm.getBlockNumber();
-  }
-};
-
-// src/account-mapping/AccountMappingModule.ts
-import { Binary as Binary3 } from "polkadot-api";
-function toTxResult2(payload) {
-  const base = {
-    txHash: payload.txHash,
-    blockHash: payload.block.hash,
-    blockNumber: payload.block.number,
-    ok: payload.ok
-  };
-  if (!payload.ok) {
-    return { ...base, error: payload.dispatchError.type };
-  }
-  return base;
-}
-function callUnsafeTx2(txEntry, ...args) {
-  return txEntry(...args);
-}
-function resolveTx2(unsafe, pallet, call) {
-  const u = unsafe;
-  const p = u["tx"]?.[pallet];
-  if (p === void 0) throw new Error(`Pallet "${pallet}" not found in runtime metadata`);
-  const entry = p[call];
-  if (entry === void 0)
-    throw new Error(`Call "${pallet}.${call}" not found in runtime metadata`);
-  return entry;
-}
+// src/account-mapping/helpers.ts
 function mapRawScheme(raw) {
   if (raw === "Eip191" || raw === "eip191") return "Eip191";
   if (raw === "Ed25519" || raw === "ed25519") return "Ed25519";
   return raw;
 }
+
+// src/account-mapping/AccountMappingModule.ts
 var AccountMappingModule = class {
   constructor(substrate) {
     this.substrate = substrate;
@@ -1162,18 +1799,18 @@ var AccountMappingModule = class {
    * Extrinsic: accountMapping.mapAccount()
    */
   async mapAccount(signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "mapAccount");
-    const tx = callUnsafeTx2(entry);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "mapAccount");
+    const tx = callUnsafeTx(entry);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Removes the EVM → Substrate mapping for the caller.
    * Extrinsic: accountMapping.unmapAccount()
    */
   async unmapAccount(signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "unmapAccount");
-    const tx = callUnsafeTx2(entry);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "unmapAccount");
+    const tx = callUnsafeTx(entry);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Registers a unique @alias for the caller.
@@ -1181,27 +1818,27 @@ var AccountMappingModule = class {
    * Extrinsic: accountMapping.registerAlias(alias)
    */
   async registerAlias(alias, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "registerAlias");
-    const tx = callUnsafeTx2(entry, Binary3.fromText(alias));
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "registerAlias");
+    const tx = callUnsafeTx(entry, Binary3.fromText(alias));
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Releases the caller's alias and recovers the deposit.
    * Extrinsic: accountMapping.releaseAlias()
    */
   async releaseAlias(signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "releaseAlias");
-    const tx = callUnsafeTx2(entry);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "releaseAlias");
+    const tx = callUnsafeTx(entry);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Transfers the caller's alias to another account.
    * Extrinsic: accountMapping.transferAlias(newOwner)
    */
   async transferAlias(newOwnerHex, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "transferAlias");
-    const tx = callUnsafeTx2(entry, newOwnerHex);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "transferAlias");
+    const tx = callUnsafeTx(entry, newOwnerHex);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Adds a verified public link to an external-chain wallet.
@@ -1214,65 +1851,65 @@ var AccountMappingModule = class {
    * Extrinsic: accountMapping.addChainLink(chainId, address, signature)
    */
   async addChainLink(params, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "addChainLink");
-    const tx = callUnsafeTx2(
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "addChainLink");
+    const tx = callUnsafeTx(
       entry,
       params.chainId,
       Binary3.fromBytes(params.address),
       Binary3.fromBytes(params.signature)
     );
-    return toTxResult2(await tx.signAndSubmit(signer));
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Removes the external-chain link for the given chain ID.
    * Extrinsic: accountMapping.removeChainLink(chainId)
    */
   async removeChainLink(chainId, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "removeChainLink");
-    const tx = callUnsafeTx2(entry, chainId);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "removeChainLink");
+    const tx = callUnsafeTx(entry, chainId);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Updates the caller's public profile metadata.
    * Extrinsic: accountMapping.setAccountMetadata(displayName, bio, avatar)
    */
   async setAccountMetadata(params, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "setAccountMetadata");
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "setAccountMetadata");
     const encode2 = (v) => v != null ? Binary3.fromText(v) : void 0;
-    const tx = callUnsafeTx2(
+    const tx = callUnsafeTx(
       entry,
       encode2(params.displayName),
       encode2(params.bio),
       encode2(params.avatar)
     );
-    return toTxResult2(await tx.signAndSubmit(signer));
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Lists the caller's alias for sale on the alias marketplace.
    * Extrinsic: accountMapping.putAliasOnSale(price, isPrivate)
    */
   async putAliasOnSale(params, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "putAliasOnSale");
-    const tx = callUnsafeTx2(entry, params.price.toString(), params.isPrivate);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "putAliasOnSale");
+    const tx = callUnsafeTx(entry, params.price.toString(), params.isPrivate);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Cancels an active alias sale listing.
    * Extrinsic: accountMapping.cancelSale()
    */
   async cancelSale(signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "cancelSale");
-    const tx = callUnsafeTx2(entry);
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "cancelSale");
+    const tx = callUnsafeTx(entry);
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Purchases an alias listed for sale.
    * Extrinsic: accountMapping.buyAlias(alias)
    */
   async buyAlias(alias, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "buyAlias");
-    const tx = callUnsafeTx2(entry, Binary3.fromText(alias));
-    return toTxResult2(await tx.signAndSubmit(signer));
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "buyAlias");
+    const tx = callUnsafeTx(entry, Binary3.fromText(alias));
+    return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
    * Dispatches an arbitrary call on behalf of a linked external-chain wallet.
@@ -1286,8 +1923,8 @@ var AccountMappingModule = class {
    * Extrinsic: accountMapping.dispatchAsLinkedAccount(owner, chainId, address, signature, call)
    */
   async dispatchAsLinkedAccount(params, signer) {
-    const entry = resolveTx2(this.substrate.unsafe, "accountMapping", "dispatchAsLinkedAccount");
-    const tx = callUnsafeTx2(
+    const entry = resolveTx(this.substrate.unsafe, "accountMapping", "dispatchAsLinkedAccount");
+    const tx = callUnsafeTx(
       entry,
       params.owner,
       params.chainId,
@@ -1295,29 +1932,128 @@ var AccountMappingModule = class {
       Binary3.fromBytes(params.signature),
       Binary3.fromBytes(params.callData)
     );
-    return toTxResult2(await tx.signAndSubmit(signer));
+    return toTxResult(await tx.signAndSubmit(signer));
   }
 };
 
-// src/precompiles/abi.ts
-function concat(arrays) {
-  const total = arrays.reduce((s, a) => s + a.length, 0);
-  const out = new Uint8Array(total);
-  let o = 0;
-  for (const a of arrays) {
-    out.set(a, o);
-    o += a.length;
-  }
-  return out;
-}
-function padTo32Multiple(data) {
-  const rem = data.length % 32;
-  if (rem === 0) return data;
-  const padded = new Uint8Array(data.length + (32 - rem));
-  padded.set(data);
-  return padded;
+// src/rpc-v2/helpers.ts
+function mapAssetBalance(balance) {
+  return {
+    assetId: balance.asset_id,
+    balance: balance.balance.toString()
+  };
+}
+
+// src/rpc-v2/PrivacyModule.ts
+var PrivacyModule = class {
+  constructor(substrate) {
+    this.substrate = substrate;
+  }
+  /** Returns the current Merkle tree root. */
+  async getMerkleRoot() {
+    return this.substrate.request("privacy_getMerkleRoot", []);
+  }
+  /** Returns the Merkle proof for the given leaf index or commitment hex. */
+  async getMerkleProof(leafIndex) {
+    const raw = await this.substrate.request("privacy_getMerkleProof", [
+      leafIndex
+    ]);
+    return {
+      path: raw.path,
+      leafIndex: raw.leaf_index,
+      treeDepth: raw.tree_depth
+    };
+  }
+  /**
+   * Returns the Merkle inclusion proof for a given commitment hex,
+   * bundled with the current Merkle root.
+   */
+  async getMerkleProofByCommitment(commitmentHex) {
+    const [proof, root] = await Promise.all([
+      this.getMerkleProof(commitmentHex),
+      this.getMerkleRoot()
+    ]);
+    return { ...proof, root };
+  }
+  /** Returns the spend status of a nullifier. */
+  async getNullifierStatus(nullifier) {
+    const raw = await this.substrate.request(
+      "privacy_getNullifierStatus",
+      [nullifier]
+    );
+    return {
+      nullifier: raw.nullifier,
+      isSpent: raw.is_spent
+    };
+  }
+  /** Returns aggregated statistics for the shielded pool from `rpc-v2`. */
+  async getPoolStats() {
+    const raw = await this.substrate.request("privacy_getPoolStats", []);
+    return {
+      merkleRoot: raw.merkle_root,
+      commitmentCount: raw.commitment_count,
+      totalBalance: raw.total_balance.toString(),
+      assetBalances: raw.asset_balances.map(mapAssetBalance),
+      treeDepth: raw.tree_depth
+    };
+  }
+};
+
+// src/zk-verifier/ZkVerifierModule.ts
+function mapVkHash(raw) {
+  return { version: raw.version, vkHash: raw.vk_hash };
+}
+function mapCircuitVersionInfo(raw) {
+  return {
+    circuitId: raw.circuit_id,
+    activeVersion: raw.active_version,
+    proofSystem: "Groth16",
+    supportedVersions: raw.supported_versions,
+    vkHashes: raw.vk_hashes.map(mapVkHash),
+    historicalVersions: []
+  };
+}
+var ZkVerifierModule = class {
+  constructor(substrate) {
+    this.substrate = substrate;
+  }
+  /** Returns basic version info for all registered circuits. */
+  async getAllCircuitVersions() {
+    const raw = await this.substrate.request(
+      "zkVerifier_getAllCircuitVersions",
+      []
+    );
+    return raw.map(mapCircuitVersionInfo);
+  }
+  /** Returns version info for a specific circuit, or null if not found. */
+  async getCircuitVersionInfo(circuitId) {
+    const raw = await this.substrate.request(
+      "zkVerifier_getCircuitVersionInfo",
+      [circuitId]
+    );
+    return raw ? mapCircuitVersionInfo(raw) : null;
+  }
+};
+
+// src/precompiles/helpers.ts
+var STATIC_TYPES = /* @__PURE__ */ new Set(["uint", "bytes32", "address", "bool"]);
+function concat(arrays) {
+  const total = arrays.reduce((sum, array) => sum + array.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const array of arrays) {
+    out.set(array, offset);
+    offset += array.length;
+  }
+  return out;
+}
+function padTo32Multiple(data) {
+  const rem = data.length % 32;
+  if (rem === 0) return data;
+  const padded = new Uint8Array(data.length + (32 - rem));
+  padded.set(data);
+  return padded;
 }
-var STATIC_TYPES = /* @__PURE__ */ new Set(["uint", "bytes32", "address", "bool"]);
 function encodeStaticParam(param) {
   const buf = new Uint8Array(32);
   switch (param.type) {
@@ -1398,6 +2134,8 @@ function encodeDynamicParam(param) {
       );
   }
 }
+
+// src/precompiles/abi.ts
 function encode(selector, ...params) {
   const n = params.length;
   const headSize = n * 32;
@@ -1922,23 +2660,28 @@ var AccountMappingPrecompile = class {
     return signer({ to: this.addr, data });
   }
   /**
-   * Updates the signer's public profile metadata.
-   * Pass `null` for any field to leave it unchanged.
-   *
-   * Extrinsic: `accountMapping.setAccountMetadata(displayName, bio, avatar)`
-   */
-  async setAccountMetadata(displayName, bio, avatar, signer) {
-    const enc = (v) => 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`. */
+       * Updates the signer's public profile metadata.
+       * Pass `null` for any field to leave it unchanged.
+      }
+          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) {
     return encodeHex(AM_SEL.REGISTER_ALIAS, { type: "string", value: alias });
   }
@@ -2060,30 +2803,44 @@ var CryptoPrecompiles = class {
   }
 };
 
-// src/client.ts
+// src/client/OrbinumClient.ts
 var OrbinumClient = class _OrbinumClient {
   /** Raw access to the Substrate WebSocket connection and RPC. */
   substrate;
   /** Raw access to the EVM HTTP JSON-RPC endpoint (if configured). */
   evm;
+  /**
+   * High-level EVM block and transaction explorer (if `evmRpc` is configured).
+   * Provides enriched queries for blocks, transactions, addresses, and token transfers.
+   */
+  evmExplorer;
+  /**
+   * HTTP client for the Orbinum indexer REST API (if `indexerUrl` is configured).
+   * Provides paginated access to indexed blocks, extrinsics, shielded events, and nullifiers.
+   */
+  indexer;
   /** Shielded-pool operations: shield, unshield, privateTransfer, and merkle queries. */
   shieldedPool;
-  /** General chain queries: node info, identity resolution. */
-  chain;
   /** Account mapping: aliases, chain links, metadata, marketplace, and identity extrinsics. */
   accountMapping;
+  /** Typed access to Orbinum `privacy_*` RPC endpoints. */
+  privacy;
+  /** Typed access to zkVerifier_* RPC endpoints. */
+  zkVerifier;
   /**
    * EVM precompiles: shielded pool + account mapping callable from an EVM wallet.
    * Only available when `evmRpc` is configured. Methods throw if `evm` is null.
    */
   precompiles;
-  constructor(substrate, evm) {
+  constructor(substrate, evm, indexer) {
     this.substrate = substrate;
     this.evm = evm;
-    const merkle = new MerkleModule(substrate);
-    this.shieldedPool = new ShieldedPoolModule(substrate, merkle);
-    this.chain = new ChainModule(substrate, evm);
+    this.evmExplorer = evm ? new EvmExplorer(evm) : null;
+    this.indexer = indexer;
+    this.shieldedPool = new ShieldedPoolModule(substrate);
     this.accountMapping = new AccountMappingModule(substrate);
+    this.privacy = new PrivacyModule(substrate);
+    this.zkVerifier = new ZkVerifierModule(substrate);
     this.precompiles = evm ? {
       shieldedPool: new ShieldedPoolPrecompile(evm),
       accountMapping: new AccountMappingPrecompile(evm),
@@ -2100,13 +2857,8 @@ var OrbinumClient = class _OrbinumClient {
       config.connectTimeoutMs ?? 15e3
     );
     const evm = config.evmRpc ? new EvmClient(config.evmRpc) : null;
-    return new _OrbinumClient(substrate, evm);
-  }
-  /**
-   * Convenience getter for the Merkle module (shortcut for `shieldedPool.merkle`).
-   */
-  get merkle() {
-    return this.shieldedPool.merkle;
+    const indexer = config.indexerUrl ? new IndexerClient({ baseUrl: config.indexerUrl }) : null;
+    return new _OrbinumClient(substrate, evm, indexer);
   }
   /** Closes the WebSocket connection to the Substrate node. */
   destroy() {
@@ -2114,6 +2866,215 @@ var OrbinumClient = class _OrbinumClient {
   }
 };
 
+// src/client/OrbinumClientProvider.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 8e3;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
+var DEFAULT_HEARTBEAT_TIMEOUT_MS = 4e3;
+var DEFAULT_RECONNECT_BASE_MS = 3e3;
+var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var OrbinumClientProvider = class {
+  config;
+  connectTimeoutMs;
+  heartbeatIntervalMs;
+  heartbeatTimeoutMs;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  // ─── State ──────────────────────────────────────────────────────────────
+  _status = "idle";
+  _orbinumClient = null;
+  _connectingPromise = null;
+  // ─── Timers ─────────────────────────────────────────────────────────────
+  _heartbeatTimer = null;
+  _reconnectTimer = null;
+  _reconnectAttempt = 0;
+  // ─── Events ─────────────────────────────────────────────────────────────
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = config;
+    this.connectTimeoutMs = config.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    this.heartbeatIntervalMs = config.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.heartbeatTimeoutMs = config.heartbeatTimeoutMs ?? DEFAULT_HEARTBEAT_TIMEOUT_MS;
+    this.reconnectBaseMs = config.reconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
+    this.reconnectMaxMs = config.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
+  }
+  // ─── Status ─────────────────────────────────────────────────────────────
+  get status() {
+    return this._status;
+  }
+  setStatus(status, error) {
+    this._status = status;
+    const event = { status, ...error ? { error } : {} };
+    this._listeners.forEach((fn) => {
+      try {
+        fn(event);
+      } catch {
+      }
+    });
+  }
+  onStatusChange(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────
+  connect() {
+    if (this._status !== "idle") return;
+    this.startConnectAttempt();
+  }
+  reset() {
+    this.cancelReconnect();
+    this.teardownClient();
+    this._reconnectAttempt = 0;
+    this.setStatus("idle");
+  }
+  // ─── Internal connection flow ───────────────────────────────────────────
+  startConnectAttempt() {
+    this.setStatus("connecting");
+    this._connectingPromise = this.attemptConnect();
+    this._connectingPromise.catch(() => {
+      if (this._status !== "idle") this.scheduleReconnect();
+    });
+  }
+  async attemptConnect() {
+    let timeoutId = null;
+    let orphanClient = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(
+          new Error(
+            `Node unavailable \u2014 could not connect to ${this.config.substrateWs} within ${this.connectTimeoutMs / 1e3}s`
+          )
+        ),
+        this.connectTimeoutMs
+      );
+    });
+    try {
+      const connectConfig = {
+        substrateWs: this.config.substrateWs
+      };
+      if (this.config.evmRpc) connectConfig.evmRpc = this.config.evmRpc;
+      if (this.config.indexerUrl) connectConfig.indexerUrl = this.config.indexerUrl;
+      const clientPromise = OrbinumClient.connect(connectConfig);
+      const client = await Promise.race([clientPromise, timeoutPromise]);
+      orphanClient = client;
+      clearTimeout(timeoutId);
+      orphanClient = null;
+      this._orbinumClient = client;
+      this._connectingPromise = null;
+      this._reconnectAttempt = 0;
+      this.setStatus("connected");
+      this.startHeartbeat();
+      return client;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (orphanClient) {
+        try {
+          orphanClient.destroy();
+        } catch {
+        }
+      }
+      this._connectingPromise = null;
+      this.setStatus(
+        "disconnected",
+        err instanceof Error ? err.message : "Connection failed"
+      );
+      throw err;
+    }
+  }
+  // ─── Heartbeat ──────────────────────────────────────────────────────────
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this._heartbeatTimer = setInterval(async () => {
+      if (this._status !== "connected" || !this._orbinumClient) return;
+      const alive = await this.probe();
+      if (!alive && this._status === "connected") {
+        this.setStatus("disconnected", "Node is unreachable");
+        this.teardownClient();
+        this.scheduleReconnect();
+      }
+    }, this.heartbeatIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+  async probe() {
+    if (!this._orbinumClient) return false;
+    try {
+      await Promise.race([
+        this._orbinumClient.substrate.request("system_health", []),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("timeout")), this.heartbeatTimeoutMs)
+        )
+      ]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ─── Reconnection ───────────────────────────────────────────────────────
+  scheduleReconnect() {
+    if (this._reconnectTimer) clearTimeout(this._reconnectTimer);
+    const delay = Math.min(
+      this.reconnectBaseMs * 2 ** this._reconnectAttempt,
+      this.reconnectMaxMs
+    );
+    this._reconnectAttempt++;
+    this.setStatus("reconnecting");
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      if (this._status !== "idle") this.startConnectAttempt();
+    }, delay);
+  }
+  cancelReconnect() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+  // ─── Client teardown ────────────────────────────────────────────────────
+  teardownClient() {
+    this.stopHeartbeat();
+    try {
+      this._orbinumClient?.destroy();
+    } catch {
+    }
+    this._orbinumClient = null;
+    this._connectingPromise = null;
+  }
+  // ─── Client access ──────────────────────────────────────────────────────
+  async getOrbinumClient() {
+    if (this._orbinumClient) return this._orbinumClient;
+    if (this._connectingPromise) return this._connectingPromise;
+    throw new Error(`OrbinumClientProvider: cannot get client in status '${this._status}'`);
+  }
+  async tryGetOrbinumClient() {
+    try {
+      return await this.getOrbinumClient();
+    } catch {
+      return null;
+    }
+  }
+  // ─── Convenience RPC helpers ────────────────────────────────────────────
+  async rpcSend(method, params = []) {
+    const client = await this.getOrbinumClient();
+    return client.substrate.request(method, params);
+  }
+  async evmRpc(method, params = []) {
+    const client = await this.getOrbinumClient();
+    if (!client.evm) throw new Error("EVM RPC not configured");
+    return client.evm.request(method, params);
+  }
+  async evmRpcBatch(calls) {
+    const client = await this.getOrbinumClient();
+    if (!client.evm) throw new Error("EVM RPC not configured");
+    return client.evm.batchRequest(calls);
+  }
+};
+
 // src/shielded-pool/NoteDecryptor.ts
 import { poseidon2 as poseidon22, poseidon4 as poseidon42 } from "poseidon-lite";
 function tryDecryptNote(commitment, viewingKey, spendingKey) {
@@ -2156,7 +3117,11 @@ function tryDecryptNote(commitment, viewingKey, spendingKey) {
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { mulPointEscalar, Base8 } from "@zk-kit/baby-jubjub";
+
+// src/shielded-pool/constants.ts
 var BN254_R = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+// src/shielded-pool/PrivacyKeys.ts
 var IVK_DOMAIN = new TextEncoder().encode("orbinum-ivk-v1");
 function deriveSpendingKeyMessage(chainId, address) {
   return `orbinum-spending-key-v1
@@ -2187,13 +3152,12 @@ function deriveOwnerPk(spendingKey) {
 }
 
 // src/shielded-pool/PrivacyKeyManager.ts
-var BN254_R2 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-var _state = {
-  spendingKey: null,
-  viewingKey: null,
-  ownerPk: null
-};
-var PrivacyKeyManager = {
+var PrivacyKeyManager = class {
+  _state = {
+    spendingKey: null,
+    viewingKey: null,
+    ownerPk: null
+  };
   /**
    * Load a spending key into the in-memory session.
    * Derives viewingKey and ownerPk immediately.
@@ -2202,52 +3166,52 @@ var PrivacyKeyManager = {
   async load(spendingKey) {
     const viewingKey = deriveViewingKey(spendingKey);
     const ownerPk = deriveOwnerPk(spendingKey);
-    _state = { spendingKey, viewingKey, ownerPk };
-  },
+    this._state = { spendingKey, viewingKey, ownerPk };
+  }
   /** Clear all key material from memory. Call on vault lock / sign-out. */
   clear() {
-    _state = { spendingKey: null, viewingKey: null, ownerPk: null };
-  },
+    this._state = { spendingKey: null, viewingKey: null, ownerPk: null };
+  }
   /** Returns true if a spending key has been loaded. */
   isLoaded() {
-    return _state.spendingKey !== null;
-  },
+    return this._state.spendingKey !== null;
+  }
   /** Returns the spending key. Throws if not loaded. */
   getSpendingKey() {
-    if (_state.spendingKey === null) {
+    if (this._state.spendingKey === null) {
       throw new Error("PrivacyKeyManager: no key loaded. Call load() first.");
     }
-    return _state.spendingKey;
-  },
+    return this._state.spendingKey;
+  }
   /** Returns the 32-byte viewing key. Throws if not loaded. */
   getViewingKey() {
-    if (_state.viewingKey === null) {
+    if (this._state.viewingKey === null) {
       throw new Error("PrivacyKeyManager: no key loaded. Call load() first.");
     }
-    return _state.viewingKey;
-  },
+    return this._state.viewingKey;
+  }
   /** Returns the BabyJubJub owner public key (x-coordinate). Throws if not loaded. */
   getOwnerPk() {
-    if (_state.ownerPk === null) {
+    if (this._state.ownerPk === null) {
       throw new Error("PrivacyKeyManager: no key loaded. Call load() first.");
     }
-    return _state.ownerPk;
-  },
+    return this._state.ownerPk;
+  }
   /** Returns the spending key as a 32-byte little-endian Uint8Array. Throws if not loaded. */
   getSpendingKeyBytes() {
     return bigintTo32Le(this.getSpendingKey());
-  },
+  }
   /** Exports the spending key as a 0x-prefixed 64-char hex string. Throws if not loaded. */
   exportHex() {
     return "0x" + this.getSpendingKey().toString(16).padStart(64, "0");
-  },
+  }
   /**
    * Load a spending key from a 0x-prefixed or bare hex string.
    * Validates the key is in the valid range [1, BN254_R).
    */
   async importFromHex(hex) {
     const key = BigInt(hex.startsWith("0x") ? hex : "0x" + hex);
-    if (key === 0n || key >= BN254_R2) {
+    if (key === 0n || key >= BN254_R) {
       throw new Error("PrivacyKeyManager: invalid spending key \u2014 out of BN254 range.");
     }
     await this.load(key);
@@ -2265,18 +3229,6 @@ function vaultReviver(_key, value) {
   }
   return value;
 }
-function toBase64(buf) {
-  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
-  let str = "";
-  for (const b of bytes) str += String.fromCharCode(b);
-  return btoa(str);
-}
-function fromBase64(b64) {
-  const bin = atob(b64);
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
 var VAULT_KEY_INFO = new TextEncoder().encode("orbinum-vault-key-v1");
 var IV_BYTES = 12;
 async function deriveVaultKey(spendingKeyBytes) {
@@ -2315,36 +3267,859 @@ async function decryptJson(key, iv, ciphertext) {
   return JSON.parse(new TextDecoder().decode(plainBuf), vaultReviver);
 }
 
-// src/types.ts
+// src/account-mapping/types/index.ts
+var SignatureScheme = {
+  Eip191: "Eip191",
+  Ed25519: "Ed25519"
+};
 var SLIP0044_NAMESPACE = 2147483648;
 
+// src/precompiles/decode.ts
+function decodePrecompileCalldata(address, input) {
+  const info = KNOWN_PRECOMPILES[address.toLowerCase()];
+  if (!info || !input || input.length < 10) return null;
+  const selector = input.slice(2, 10).toLowerCase();
+  const fnSig = info.functions[selector];
+  if (!fnSig) return null;
+  if (fnSig.startsWith("registerAlias")) {
+    try {
+      const data = hexToBytes(input.slice(10));
+      const alias = decodeString(data, 0);
+      return { fnSig, args: { alias } };
+    } catch {
+      return { fnSig, args: {} };
+    }
+  }
+  if (fnSig.startsWith("shield(")) {
+    try {
+      const data = hexToBytes(input.slice(10));
+      const assetId = decodeUint(data, 0);
+      const amount = decodeUint(data, 32);
+      const commitment = toHex(data.slice(64, 96));
+      return { fnSig, args: { assetId, amount, commitment } };
+    } catch {
+      return { fnSig, args: {} };
+    }
+  }
+  if (fnSig.startsWith("unshield(")) {
+    try {
+      const data = hexToBytes(input.slice(10));
+      const root = toHex(data.slice(32, 64));
+      const nullifier = toHex(data.slice(64, 96));
+      const assetId = decodeUint(data, 96);
+      const amount = decodeUint(data, 128);
+      const recipient = toHex(data.slice(160, 192));
+      return { fnSig, args: { root, nullifier, assetId, amount, recipient } };
+    } catch {
+      return { fnSig, args: {} };
+    }
+  }
+  if (fnSig.startsWith("privateTransfer(")) {
+    try {
+      const data = hexToBytes(input.slice(10));
+      const root = toHex(data.slice(32, 64));
+      const nullOffset = Number(decodeUint(data, 64));
+      const commOffset = Number(decodeUint(data, 96));
+      const nullifiers = Number(decodeUint(data, nullOffset));
+      const commitments = Number(decodeUint(data, commOffset));
+      return { fnSig, args: { root, nullifiers, commitments } };
+    } catch {
+      return { fnSig, args: {} };
+    }
+  }
+  return { fnSig, args: {} };
+}
+
+// src/zk-verifier/types/pallet-extrinsics.ts
+var CircuitId = {
+  Transfer: 1,
+  Unshield: 2,
+  Disclosure: 3,
+  PrivateLink: 4
+};
+
+// src/utils/string.ts
+function truncateMiddle(str, start, end) {
+  if (!str) return "";
+  if (str.length <= start + end + 1) return str;
+  return `${str.slice(0, start)}\u2026${str.slice(-end)}`;
+}
+function shortHash(h, start = 8, end = 6) {
+  return truncateMiddle(h, start, end);
+}
+
+// src/extrinsic/index.ts
+function mapExtrinsicArgs(section, method, args) {
+  if (!args || Object.keys(args).length === 0) return args;
+  const s = section.toLowerCase();
+  const m = method.toLowerCase();
+  const get = (idx, name) => {
+    if (name in args) return args[name];
+    const argKey = `arg${idx}`;
+    if (argKey in args) return args[argKey];
+    if (idx in args) return args[idx];
+    const strIdx = idx.toString();
+    if (strIdx in args) return args[strIdx];
+    return void 0;
+  };
+  if (s === "system") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "remark" || m_norm === "remarkwithevent") {
+      return { remark: get(0, "remark") };
+    }
+    if (m_norm === "setheappages") {
+      return { pages: get(0, "pages") };
+    }
+    if (m_norm === "setcode" || m_norm === "setcodewithoutchecks") {
+      return { code: get(0, "code") };
+    }
+    if (m_norm === "setstorage") {
+      return { items: get(0, "items") };
+    }
+    if (m_norm === "killstorage") {
+      return { keys: get(0, "keys") };
+    }
+    if (m_norm === "killprefix") {
+      return {
+        prefix: get(0, "prefix"),
+        subkeys: get(1, "subkeys")
+      };
+    }
+    if (m_norm === "authorizeupgrade" || m_norm === "authorizeupgradewithoutchecks") {
+      return { code_hash: get(0, "code_hash") };
+    }
+    if (m_norm === "applyauthorizedupgrade") {
+      return { code: get(0, "code") };
+    }
+  }
+  if (s === "timestamp") {
+    if (m === "set") {
+      return { now: get(0, "now") };
+    }
+  }
+  if (s === "balances") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm.startsWith("transfer")) {
+      return {
+        recipient: get(0, "dest") || get(0, "destination") || get(0, "recipient"),
+        amount: get(1, "value") || get(1, "amount")
+      };
+    }
+    if (m_norm === "forcetransfer") {
+      return {
+        source: get(0, "source"),
+        dest: get(1, "dest"),
+        value: get(2, "value")
+      };
+    }
+    if (m_norm === "forceunreserve") {
+      return {
+        who: get(0, "who"),
+        amount: get(1, "amount")
+      };
+    }
+    if (m_norm === "upgradeaccounts") {
+      return { who: get(0, "who") };
+    }
+    if (m_norm === "forcesetbalance") {
+      return {
+        who: get(0, "who"),
+        new_free: get(1, "new_free")
+      };
+    }
+    if (m_norm === "forceadjusttotalissuance") {
+      return {
+        direction: get(0, "direction"),
+        delta: get(1, "delta")
+      };
+    }
+    if (m_norm === "burn") {
+      return {
+        value: get(0, "value"),
+        keep_alive: get(1, "keep_alive")
+      };
+    }
+  }
+  if (s === "sudo") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "sudo") {
+      return { call: get(0, "call") };
+    }
+    if (m_norm === "sudouncheckedweight") {
+      return {
+        call: get(0, "call"),
+        weight: get(1, "weight")
+      };
+    }
+    if (m_norm === "setkey") {
+      return { new: get(0, "new") };
+    }
+    if (m_norm === "sudoas") {
+      return {
+        who: get(0, "who"),
+        call: get(1, "call")
+      };
+    }
+  }
+  if (s === "grandpa") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "reportequivocation" || m_norm === "reportequivocationunsigned") {
+      return {
+        equivocation_proof: get(0, "equivocation_proof"),
+        key_owner_proof: get(1, "key_owner_proof")
+      };
+    }
+    if (m_norm === "notestalled") {
+      return {
+        delay: get(0, "delay"),
+        best_finalized_block_number: get(1, "best_finalized_block_number")
+      };
+    }
+  }
+  if (s === "shieldedpool") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "shield") {
+      return {
+        asset_id: get(0, "asset_id"),
+        amount: get(1, "amount"),
+        commitment: get(2, "commitment"),
+        encrypted_memo: get(3, "encrypted_memo")
+      };
+    }
+    if (m_norm === "shieldbatch") {
+      const ops = get(0, "operations") || get(0, "arg0");
+      if (Array.isArray(ops)) {
+        return {
+          operations: ops.map((op) => {
+            if (Array.isArray(op)) {
+              return {
+                asset_id: op[0],
+                amount: op[1],
+                commitment: op[2],
+                encrypted_memo: op[3]
+              };
+            }
+            return op;
+          })
+        };
+      }
+      return { operations: ops };
+    }
+    if (m_norm === "privatetransfer" || m_norm === "transfer") {
+      return {
+        proof: get(0, "proof"),
+        merkle_root: get(1, "merkle_root"),
+        nullifiers: get(2, "nullifiers"),
+        commitments: get(3, "commitments"),
+        encrypted_memos: get(4, "encrypted_memos")
+      };
+    }
+    if (m_norm === "unshield") {
+      return {
+        proof: get(0, "proof"),
+        merkle_root: get(1, "merkle_root"),
+        nullifier: get(2, "nullifier"),
+        asset_id: get(3, "asset_id"),
+        amount: get(4, "amount"),
+        recipient: get(5, "recipient")
+      };
+    }
+    if (m_norm === "setauditpolicy") {
+      return {
+        auditors: get(0, "auditors"),
+        conditions: get(1, "conditions"),
+        max_frequency: get(2, "max_frequency"),
+        valid_until: get(3, "valid_until")
+      };
+    }
+    if (m_norm === "requestdisclosure") {
+      return {
+        target: get(0, "target"),
+        reason: get(1, "reason")
+      };
+    }
+    if (m_norm === "disclose") {
+      return {
+        commitment: get(0, "commitment"),
+        proof_bytes: get(1, "proof_bytes"),
+        public_signals: get(2, "public_signals"),
+        auditor: get(3, "auditor")
+      };
+    }
+    if (m_norm === "rejectdisclosure") {
+      return {
+        auditor: get(0, "auditor"),
+        reason: get(1, "reason")
+      };
+    }
+    if (m_norm === "registerasset") {
+      return {
+        name: get(0, "name"),
+        symbol: get(1, "symbol"),
+        decimals: get(2, "decimals"),
+        contract_address: get(3, "contract_address")
+      };
+    }
+    if (m_norm === "verifyasset") {
+      return { asset_id: get(0, "asset_id") };
+    }
+    if (m_norm === "unverifyasset") {
+      return { asset_id: get(0, "asset_id") };
+    }
+    if (m_norm === "batchsubmitdisclosureproofs") {
+      return { submissions: get(0, "submissions") };
+    }
+    if (m_norm === "pruneexpiredrequest") {
+      return {
+        target: get(0, "target"),
+        auditor: get(1, "auditor")
+      };
+    }
+    if (m_norm === "revokedisclosurerecord") {
+      return { commitment: get(0, "commitment") };
+    }
+  }
+  if (s === "ethereum" && m === "transact") {
+    return { transaction: get(0, "transaction") };
+  }
+  if (s === "evm") {
+    if (m === "withdraw") {
+      return {
+        address: get(0, "address"),
+        value: get(1, "value")
+      };
+    }
+    if (m === "call") {
+      return {
+        source: get(0, "source"),
+        target: get(1, "target"),
+        input: get(2, "input"),
+        value: get(3, "value"),
+        gas_limit: get(4, "gas_limit"),
+        max_fee_per_gas: get(5, "max_fee_per_gas"),
+        max_priority_fee_per_gas: get(6, "max_priority_fee_per_gas"),
+        nonce: get(7, "nonce"),
+        access_list: get(8, "access_list"),
+        authorization_list: get(9, "authorization_list")
+      };
+    }
+    if (m === "create") {
+      return {
+        source: get(0, "source"),
+        init: get(1, "init"),
+        value: get(2, "value"),
+        gas_limit: get(3, "gas_limit"),
+        max_fee_per_gas: get(4, "max_fee_per_gas"),
+        max_priority_fee_per_gas: get(5, "max_priority_fee_per_gas"),
+        nonce: get(6, "nonce"),
+        access_list: get(7, "access_list"),
+        authorization_list: get(8, "authorization_list")
+      };
+    }
+    if (m === "create2") {
+      return {
+        source: get(0, "source"),
+        init: get(1, "init"),
+        salt: get(2, "salt"),
+        value: get(3, "value"),
+        gas_limit: get(4, "gas_limit"),
+        max_fee_per_gas: get(5, "max_fee_per_gas"),
+        max_priority_fee_per_gas: get(6, "max_priority_fee_per_gas"),
+        nonce: get(7, "nonce"),
+        access_list: get(8, "access_list"),
+        authorization_list: get(9, "authorization_list")
+      };
+    }
+  }
+  if (s === "accountmapping") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "registeralias") {
+      return { alias: get(0, "alias") };
+    }
+    if (m_norm === "transferalias") {
+      return { new_owner: get(0, "new_owner") };
+    }
+    if (m_norm === "putaliasonsale") {
+      return {
+        price: get(0, "price"),
+        allowed_buyers: get(1, "allowed_buyers")
+      };
+    }
+    if (m_norm === "buyalias") {
+      return { alias: get(0, "alias") };
+    }
+    if (m_norm === "addchainlink") {
+      return {
+        chain_id: get(0, "chain_id"),
+        address: get(1, "address"),
+        signature: get(2, "signature")
+      };
+    }
+    if (m_norm === "removechainlink") {
+      return { chain_id: get(0, "chain_id") };
+    }
+    if (m_norm === "setaccountmetadata") {
+      return {
+        display_name: get(0, "display_name"),
+        bio: get(1, "bio"),
+        avatar: get(2, "avatar")
+      };
+    }
+    if (m_norm === "addsupportedchain") {
+      return {
+        chain_id: get(0, "chain_id"),
+        scheme: get(1, "scheme")
+      };
+    }
+    if (m_norm === "removesupportedchain") {
+      return { chain_id: get(0, "chain_id") };
+    }
+    if (m_norm === "dispatchaslinkedaccount") {
+      return {
+        owner: get(0, "owner"),
+        chain_id: get(1, "chain_id"),
+        address: get(2, "address"),
+        signature: get(3, "signature"),
+        call: get(4, "call")
+      };
+    }
+    if (m_norm === "registerprivatelink") {
+      return {
+        chain_id: get(0, "chain_id"),
+        commitment: get(1, "commitment")
+      };
+    }
+    if (m_norm === "removeprivatelink") {
+      return { commitment: get(0, "commitment") };
+    }
+    if (m_norm === "revealprivatelink") {
+      return {
+        commitment: get(0, "commitment"),
+        address: get(1, "address"),
+        blinding: get(2, "blinding"),
+        signature: get(3, "signature")
+      };
+    }
+    if (m_norm === "dispatchasprivatelink") {
+      return {
+        owner: get(0, "owner"),
+        commitment: get(1, "commitment"),
+        zk_proof: get(2, "zk_proof"),
+        call: get(3, "call")
+      };
+    }
+  }
+  if (s === "zkverifier") {
+    const m_norm = m.replace(/_/g, "");
+    if (m_norm === "batchregisterverificationkeys") {
+      const entries = get(0, "entries");
+      if (Array.isArray(entries)) {
+        return {
+          entries: entries.map((e) => ({
+            circuit_id: e["circuit_id"],
+            version: e["version"],
+            verification_key: e["verification_key"],
+            set_active: e["set_active"]
+          }))
+        };
+      }
+      return { entries };
+    }
+    if (m_norm === "registerverificationkey") {
+      return {
+        circuit_id: get(0, "circuit_id"),
+        version: get(1, "version"),
+        verification_key: get(2, "verification_key")
+      };
+    }
+    if (m_norm === "setactiveversion") {
+      return {
+        circuit_id: get(0, "circuit_id"),
+        version: get(1, "version")
+      };
+    }
+    if (m_norm === "removeverificationkey") {
+      return {
+        circuit_id: get(0, "circuit_id"),
+        version: get(1, "version")
+      };
+    }
+    if (m_norm === "verifyproof") {
+      return {
+        circuit_id: get(0, "circuit_id"),
+        proof: get(1, "proof"),
+        public_inputs: get(2, "public_inputs")
+      };
+    }
+  }
+  return args;
+}
+function mapZkEventData(method, data) {
+  const m = method.toLowerCase();
+  const get = (idx, name) => {
+    if (name in data) return data[name];
+    const argKey = `arg${idx}`;
+    if (argKey in data) return data[argKey];
+    if (idx in data) return data[idx];
+    const strIdx = idx.toString();
+    if (strIdx in data) return data[strIdx];
+    return void 0;
+  };
+  const formatAmount = (val) => {
+    if (val === void 0 || val === null) return null;
+    return formatBalance(String(val));
+  };
+  if (m === "shielded" || m === "deposit") {
+    return {
+      sender: get(0, "depositor") || get(0, "sender"),
+      amount: formatAmount(get(1, "amount")),
+      commitment: get(2, "commitment"),
+      memo: get(3, "encrypted_memo") || get(3, "memo"),
+      index: get(4, "leaf_index") || get(4, "index")
+    };
+  }
+  if (m === "privatetransfer") {
+    return {
+      nullifiers: get(0, "nullifiers"),
+      commitments: get(1, "commitments"),
+      memos: get(2, "encrypted_memos") || get(2, "memos"),
+      indices: get(3, "leaf_indices") || get(3, "indices")
+    };
+  }
+  if (m === "unshielded" || m === "withdraw") {
+    return {
+      nullifier: get(0, "nullifier"),
+      amount: formatAmount(get(1, "amount")),
+      recipient: get(2, "recipient")
+    };
+  }
+  if (m === "merklerootupdated" || m === "merkleroot") {
+    return {
+      old_root: get(0, "old_root"),
+      new_root: get(1, "new_root"),
+      size: get(2, "tree_size") || get(2, "size")
+    };
+  }
+  const m_norm = m.replace(/_/g, "");
+  if (m_norm === "auditpolicyset") {
+    return {
+      account: get(0, "account"),
+      version: get(1, "version")
+    };
+  }
+  if (m_norm === "disclosed") {
+    return {
+      who: get(0, "who"),
+      commitment: get(1, "commitment"),
+      auditor: get(2, "auditor")
+    };
+  }
+  if (m_norm === "disclosurerequested") {
+    return {
+      target: get(0, "target"),
+      auditor: get(1, "auditor"),
+      reason: get(2, "reason")
+    };
+  }
+  if (m_norm === "disclosurerejected") {
+    return {
+      target: get(0, "target"),
+      auditor: get(1, "auditor"),
+      reason: get(2, "reason")
+    };
+  }
+  if (m_norm === "disclosurerequestexpired") {
+    return {
+      target: get(0, "target"),
+      auditor: get(1, "auditor")
+    };
+  }
+  if (m_norm === "disclosurerecordrevoked") {
+    return {
+      who: get(0, "who"),
+      commitment: get(1, "commitment")
+    };
+  }
+  if (m_norm === "assetregistered") {
+    return { asset_id: get(0, "asset_id") };
+  }
+  if (m_norm === "assetverified") {
+    return { asset_id: get(0, "asset_id") };
+  }
+  if (m_norm === "assetunverified") {
+    return { asset_id: get(0, "asset_id") };
+  }
+  if (m_norm === "accountmapped" || m_norm === "accountunmapped") {
+    return {
+      account: get(0, "account"),
+      address: get(1, "address")
+    };
+  }
+  if (m_norm === "aliasregistered") {
+    return {
+      account: get(0, "account"),
+      alias: get(1, "alias"),
+      evm_address: get(2, "evm_address")
+    };
+  }
+  if (m_norm === "aliasreleased") {
+    return {
+      account: get(0, "account"),
+      alias: get(1, "alias")
+    };
+  }
+  if (m_norm === "aliastransferred") {
+    return {
+      from: get(0, "from"),
+      to: get(1, "to"),
+      alias: get(2, "alias")
+    };
+  }
+  if (m_norm === "aliaslistedforsale") {
+    return {
+      seller: get(0, "seller"),
+      alias: get(1, "alias"),
+      price: get(2, "price"),
+      private: get(3, "private")
+    };
+  }
+  if (m_norm === "aliassalecancelled") {
+    return {
+      seller: get(0, "seller"),
+      alias: get(1, "alias")
+    };
+  }
+  if (m_norm === "aliassold") {
+    return {
+      seller: get(0, "seller"),
+      buyer: get(1, "buyer"),
+      alias: get(2, "alias"),
+      price: get(3, "price")
+    };
+  }
+  if (m_norm === "chainlinkadded") {
+    return {
+      account: get(0, "account"),
+      chain_id: get(1, "chain_id"),
+      address: get(2, "address")
+    };
+  }
+  if (m_norm === "chainlinkremoved") {
+    return {
+      account: get(0, "account"),
+      chain_id: get(1, "chain_id")
+    };
+  }
+  if (m_norm === "metadataupdated") {
+    return { account: get(0, "account") };
+  }
+  if (m_norm === "supportedchainadded") {
+    return {
+      chain_id: get(0, "chain_id"),
+      scheme: get(1, "scheme")
+    };
+  }
+  if (m_norm === "supportedchainremoved") {
+    return { chain_id: get(0, "chain_id") };
+  }
+  if (m_norm === "proxycallexecuted") {
+    return {
+      owner: get(0, "owner"),
+      chain_id: get(1, "chain_id"),
+      address: get(2, "address")
+    };
+  }
+  if (m_norm === "privatechainlinkadded" || m_norm === "privatechainlinkremoved") {
+    return {
+      account: get(0, "account"),
+      chain_id: get(1, "chain_id"),
+      commitment: get(2, "commitment")
+    };
+  }
+  if (m_norm === "privatechainlinkrevealed") {
+    return {
+      account: get(0, "account"),
+      chain_id: get(1, "chain_id"),
+      address: get(2, "address")
+    };
+  }
+  if (m_norm === "privatelinkdispatchexecuted") {
+    return {
+      owner: get(0, "owner"),
+      commitment: get(1, "commitment")
+    };
+  }
+  if (m_norm === "verificationkeyregistered" || m_norm === "activeversionset" || m_norm === "verificationkeyremoved" || m_norm === "proofverified" || m_norm === "proofverificationfailed") {
+    return {
+      circuit_id: get(0, "circuit_id"),
+      version: get(1, "version")
+    };
+  }
+  if (m_norm === "log") {
+    return { log: get(0, "log") };
+  }
+  if (m_norm === "created" || m_norm === "createdfailed" || m_norm === "executed" || m_norm === "executedfailed") {
+    return { address: get(0, "address") };
+  }
+  if (m_norm === "executed") {
+    return {
+      from: get(0, "from"),
+      to: get(1, "to"),
+      transaction_hash: get(2, "transaction_hash"),
+      exit_reason: get(3, "exit_reason")
+    };
+  }
+  if (m_norm === "extrinsicsuccess") {
+    return { dispatch_info: get(0, "dispatch_info") };
+  }
+  if (m_norm === "extrinsicfailed") {
+    return {
+      dispatch_error: get(0, "dispatch_error"),
+      dispatch_info: get(1, "dispatch_info")
+    };
+  }
+  if (m_norm === "newaccount" || m_norm === "killedaccount") {
+    return { account: get(0, "account") };
+  }
+  if (m_norm === "remarked") {
+    return {
+      sender: get(0, "sender"),
+      hash: get(1, "hash")
+    };
+  }
+  if (m_norm === "upgradeauthorized") {
+    return {
+      code_hash: get(0, "code_hash"),
+      check_version: get(1, "check_version")
+    };
+  }
+  if (m_norm === "rejectedinvalidauthorizedupgrade") {
+    return {
+      code_hash: get(0, "code_hash"),
+      error: get(1, "error")
+    };
+  }
+  if (m_norm === "endowed") {
+    return {
+      account: get(0, "account"),
+      free_balance: get(1, "free_balance")
+    };
+  }
+  if (m_norm === "dustlost") {
+    return {
+      account: get(0, "account"),
+      amount: get(1, "amount")
+    };
+  }
+  if (m_norm === "transfer") {
+    return {
+      from: get(0, "from"),
+      to: get(1, "to"),
+      amount: get(2, "amount")
+    };
+  }
+  if (m_norm === "balanceset") {
+    return {
+      who: get(0, "who"),
+      free: get(1, "free")
+    };
+  }
+  if (m_norm === "reserved" || m_norm === "unreserved" || m_norm === "deposit" || m_norm === "slashed" || m_norm === "minted" || m_norm === "burned" || m_norm === "suspended" || m_norm === "restored" || m_norm === "locked" || m_norm === "unlocked" || m_norm === "frozen" || m_norm === "thawed") {
+    return {
+      who: get(0, "who"),
+      amount: get(1, "amount")
+    };
+  }
+  if (m_norm === "reserverepatriated") {
+    return {
+      from: get(0, "from"),
+      to: get(1, "to"),
+      amount: get(2, "amount"),
+      destination_status: get(3, "destination_status")
+    };
+  }
+  if (m_norm === "upgraded") {
+    return { who: get(0, "who") };
+  }
+  if (m_norm === "issued" || m_norm === "rescinded") {
+    return { amount: get(0, "amount") };
+  }
+  if (m_norm === "totalissuanceforced") {
+    return {
+      old: get(0, "old"),
+      new: get(1, "new")
+    };
+  }
+  if (m_norm === "sudid" || m_norm === "sudoasdone") {
+    return { sudo_result: get(0, "sudo_result") };
+  }
+  if (m_norm === "keychanged") {
+    return {
+      old: get(0, "old"),
+      new: get(1, "new")
+    };
+  }
+  if (m_norm === "newauthorities") {
+    return { authority_set: get(0, "authority_set") };
+  }
+  if (m_norm === "transactionfeepaid") {
+    return {
+      who: get(0, "who"),
+      actual_fee: get(1, "actual_fee"),
+      tip: get(2, "tip")
+    };
+  }
+  return data;
+}
+
 // src/index.ts
+import {
+  Blake2256,
+  AccountId as AccountId2,
+  u128,
+  u64,
+  Storage,
+  Keccak256
+} from "@polkadot-api/substrate-bindings";
+import { base58 } from "@scure/base";
 import { getPolkadotSigner } from "polkadot-api/signer";
 import { getPolkadotSignerFromPjs } from "polkadot-api/pjs-signer";
+import { getSs58AddressInfo } from "polkadot-api";
 export {
+  AccountId2 as AccountId,
   AccountMappingModule,
   AccountMappingPrecompile,
-  ChainModule,
+  Blake2256,
+  CircuitId,
   CryptoPrecompiles,
   EncryptedMemo,
   EvmClient,
+  EvmExplorer,
+  IndexerClient,
   KNOWN_PRECOMPILES,
-  MerkleModule,
+  Keccak256,
   NoteBuilder,
   OrbinumClient,
+  OrbinumClientProvider,
   PRECOMPILE_ADDR,
   PrivacyKeyManager,
+  PrivacyModule,
   SLIP0044_NAMESPACE,
   ShieldedPoolModule,
   ShieldedPoolPrecompile,
+  SignatureScheme,
+  Storage,
   SubstrateClient,
+  ZkVerifierModule,
   accountIdHexToSs58,
   addressToAccountIdHex,
+  base58,
   bigintTo32Be,
   bigintTo32Le,
   bigintTo32LeArr,
   bytesToBigintLE,
   computePathIndices,
+  decodePrecompileCalldata,
   decryptJson,
   deriveOwnerPk,
   deriveSpendingKeyFromSignature,
@@ -2355,11 +4130,18 @@ export {
   ensureHexPrefix,
   evmAddressToAccountId,
   evmToImplicitSubstrate,
+  evmToMappedAccountHex,
   evmToSubstrate,
+  formatBalance,
+  formatORB,
+  fromBase64,
   fromHex,
   getPolkadotSigner,
   getPolkadotSignerFromPjs,
   getPrecompileLabel,
+  getSs58AddressInfo,
+  hexToBigint,
+  hexToNumber,
   implicitSubstrateToEvm,
   isEvmAddress,
   isImplicitEvmAccount,
@@ -2367,11 +4149,19 @@ export {
   isSubstrateAddress,
   isUnifiedAddress,
   leHexToBigint,
+  mapExtrinsicArgs,
+  mapZkEventData,
   normalizeEvmAddress,
+  shortHash,
   substrateSs58ToAccountIdHex,
   substrateToEvm,
+  toBase64,
   toHex,
+  toTxResult,
+  truncateMiddle,
   tryDecryptNote,
+  u128,
+  u64,
   vaultReplacer,
   vaultReviver
 };