@orbinum/sdk 0.11.0 → 0.13.0

package/dist/index.js

@@ -26,14 +26,15 @@ __export(index_exports, {
   BABYJUB_SUBORDER: () => BABYJUB_SUBORDER,
   BN254_R: () => BN254_R,
   Blake2256: () => import_substrate_bindings3.Blake2256,
+  CURRENT_CIRCUIT_VERSION: () => CURRENT_CIRCUIT_VERSION,
   CircuitId: () => CircuitId,
-  CircuitType: () => import_proof_generator.CircuitType,
+  CircuitType: () => import_proof_generator2.CircuitType,
+  CircuitVersionResolver: () => CircuitVersionResolver,
   CryptoPrecompiles: () => CryptoPrecompiles,
   ENCRYPTED_MEMO_SIZE: () => ENCRYPTED_MEMO_SIZE,
   EncryptedMemo: () => EncryptedMemo,
   EvmClient: () => EvmClient,
   EvmExplorer: () => EvmExplorer,
-  IndexerClient: () => IndexerClient,
   KNOWN_PRECOMPILES: () => KNOWN_PRECOMPILES,
   Keccak256: () => import_substrate_bindings3.Keccak256,
   NoteBuilder: () => NoteBuilder,
@@ -50,7 +51,7 @@ __export(index_exports, {
   Storage: () => import_substrate_bindings3.Storage,
   SubstrateClient: () => SubstrateClient,
   VaultLockedError: () => VaultLockedError,
-  WebArtifactProvider: () => import_proof_generator.WebArtifactProvider,
+  WebArtifactProvider: () => import_proof_generator2.WebArtifactProvider,
   ZkVerifierModule: () => ZkVerifierModule,
   accountIdHexToSs58: () => accountIdHexToSs58,
   addressToAccountIdHex: () => addressToAccountIdHex,
@@ -1149,397 +1150,6 @@ var EvmExplorer = class _EvmExplorer {
   }
 };
 
-// src/indexer/IndexerClient.ts
-var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
-function normalizeBaseUrl(baseUrl) {
-  let url;
-  try {
-    url = new URL(baseUrl);
-  } catch {
-    throw new Error(`IndexerClient: invalid baseUrl ${JSON.stringify(baseUrl)}`);
-  }
-  const isLocal = LOCAL_HOSTS.has(url.hostname);
-  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLocal)) {
-    throw new Error(
-      `IndexerClient: baseUrl must use https:// (got ${url.protocol}//${url.hostname}). Plain http is only allowed for localhost.`
-    );
-  }
-  return baseUrl.replace(/\/$/, "");
-}
-var IndexerClient = class _IndexerClient {
-  baseUrl;
-  timeoutMs;
-  constructor(config) {
-    this.baseUrl = normalizeBaseUrl(config.baseUrl);
-    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)}`
-    );
-  }
-  /**
-   * Returns a paginated list of stealth scan hints ordered ascending by leafIndex.
-   * Each hint contains only the fields required for ECDH triage and decryption:
-   * leafIndex, commitmentHex, assetId, ephPkHex, encryptedMemo.
-   *
-   * Use `sinceLeafIndex` for incremental scans (cursor = last seen leafIndex + 1).
-   */
-  async getScanHints(params) {
-    const qs = this.buildQuery({
-      page: params?.page,
-      limit: params?.limit,
-      since_leaf_index: params?.sinceLeafIndex
-    });
-    return this.get(`/shielded/scan-hints${qs}`);
-  }
-  // ─── 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`
-    );
-  }
-  /**
-   * Downloads the full spent nullifier set and returns it as a Set of lowercase hex strings.
-   *
-   * The server sees an identical GET request regardless of which notes the wallet holds —
-   * the intersection is computed locally (PIR-A privacy model).
-   *
-   * Kept as the FALLBACK for readers that don't serve sealed chunks yet (and for
-   * small sets). New integrations should prefer the incremental chunk flow:
-   * `getNullifierManifest` → `getNullifierChunk` for missing chunks →
-   * `getNullifierTail`, persisting the set locally between rescans.
-   */
-  async getAllSpentNullifiers() {
-    const res = await this.get("/shielded/nullifiers/all");
-    return new Set(res.data.map((h) => h.toLowerCase()));
-  }
-  /**
-   * Universal index of the sealed nullifier chunks — identical request and
-   * response for every caller (no client-supplied position: PIR-A preserved).
-   *
-   * Returns `null` when the reader does not serve chunks yet (404) — the
-   * caller should fall back to `getAllSpentNullifiers`.
-   */
-  async getNullifierManifest() {
-    return this.getOrNull("/shielded/nullifiers/manifest");
-  }
-  /**
-   * One sealed, immutable chunk of the spent-nullifier set (ascending hex,
-   * lowercased). The digest comes from the manifest and lives in the URL, so
-   * a corrected chunk is a different URL — safe to cache forever client-side.
-   */
-  async getNullifierChunk(idx, digest) {
-    const res = await this.get(
-      `/shielded/nullifiers/chunks/${idx}/${encodeURIComponent(digest)}`
-    );
-    return res.data.map((h) => h.toLowerCase());
-  }
-  /**
-   * The mutable remainder of the nullifier set after the last sealed chunk.
-   * Identical request for every caller (no input). `afterChunks` lets the
-   * client detect a chunk sealed between its manifest fetch and this one.
-   */
-  async getNullifierTail() {
-    const res = await this.get("/shielded/nullifiers/tail");
-    return { afterChunks: res.afterChunks, data: res.data.map((h) => h.toLowerCase()) };
-  }
-  // ─── Private transfers ─────────────────────────────────────────────────────
-  /** Server-enforced max items per by-nullifiers / by-commitments request. */
-  static TRANSFER_LOOKUP_CHUNK = 50;
-  /**
-   * Chunked fetch for the transfer timestamp lookups. The reader silently
-   * truncates each request to 50 items, so larger inputs MUST be split or
-   * results are silently lost. Responses are merged per extrinsic
-   * (`blockNumber:extrinsicIndex`), concatenating the matched arrays, and
-   * sorted by block descending.
-   *
-   * Privacy note: these lookups send the wallet's own note identifiers to
-   * the indexer — a bounded, documented linkage tradeoff for timestamp
-   * recovery. They are NEVER used for spent-STATUS checks (PIR-A: status
-   * comes from the anonymous full-set `/shielded/nullifiers/all` download).
-   */
-  async fetchTransfersChunked(path, param, items, matchedField) {
-    if (items.length === 0) return [];
-    const normalized = items.map((i) => i.toLowerCase());
-    const chunks = [];
-    for (let i = 0; i < normalized.length; i += _IndexerClient.TRANSFER_LOOKUP_CHUNK) {
-      chunks.push(normalized.slice(i, i + _IndexerClient.TRANSFER_LOOKUP_CHUNK));
-    }
-    const responses = await Promise.all(
-      chunks.map((chunk) => {
-        const qs = this.buildQuery({ [param]: chunk.join(",") });
-        return this.get(
-          `${path}${qs}`
-        );
-      })
-    );
-    const byExtrinsic = /* @__PURE__ */ new Map();
-    for (const res of responses) {
-      for (const transfer of res.data) {
-        const key = `${transfer.blockNumber}:${transfer.extrinsicIndex ?? "null"}`;
-        const existing = byExtrinsic.get(key);
-        if (!existing) {
-          byExtrinsic.set(key, transfer);
-          continue;
-        }
-        const merged = /* @__PURE__ */ new Set([
-          ...existing[matchedField] ?? [],
-          ...transfer[matchedField] ?? []
-        ]);
-        existing[matchedField] = [...merged];
-      }
-    }
-    return [...byExtrinsic.values()].sort((a, b) => b.blockNumber - a.blockNumber);
-  }
-  /**
-   * Returns temporal metadata for private transfers that spent any of the given nullifiers.
-   * Only blockNumber, extrinsicIndex, timestampMs, and hash are returned — no cross-link
-   * between inputs and outputs to prevent graph reconstruction.
-   * Inputs of any size are transparently chunked into requests of 50 (the server cap)
-   * and merged per extrinsic.
-   */
-  async getTransfersByNullifiers(nullifiers) {
-    return this.fetchTransfersChunked(
-      "/shielded/transfers/by-nullifiers",
-      "nullifiers",
-      nullifiers,
-      "matchedNullifiers"
-    );
-  }
-  /**
-   * Returns temporal metadata for private transfers that produced any of the given commitments.
-   * Only blockNumber, extrinsicIndex, timestampMs, and hash are returned — no cross-link
-   * between outputs and inputs to prevent graph reconstruction.
-   * Inputs of any size are transparently chunked into requests of 50 (the server cap)
-   * and merged per extrinsic.
-   */
-  async getTransfersByCommitments(commitments) {
-    return this.fetchTransfersChunked(
-      "/shielded/transfers/by-commitments",
-      "commitments",
-      commitments,
-      "matchedCommitments"
-    );
-  }
-  // ─── 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-scoped shielded activity ─────────────────────────────────────
-  /**
-   * Returns a paginated list of unshield events where the given address is the recipient.
-   * Accepts a 0x-prefixed EVM address or an SS58 Substrate address.
-   */
-  async getAddressUnshields(address, params) {
-    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
-    return this.get(
-      `/address/${encodeURIComponent(address)}/unshields${qs}`
-    );
-  }
-  /**
-   * Returns the shielded-pool BOUNDARY activity for an address: shields it
-   * deposited and unshields it received, tagged `kind: 'shield' | 'unshield'`.
-   * Only boundary fields are returned (block, asset, amount for unshields,
-   * timestamp, tx hash) — note internals are never served per-address, and
-   * private transfers carry no address at all (PIR-A).
-   */
-  async getAddressShieldedActivity(address, params) {
-    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
-    return this.get(
-      `/shielded/address/${encodeURIComponent(address)}${qs}`
-    );
-  }
-  // ─── Relayers ──────────────────────────────────────────────────────────────
-  /** Returns a paginated list of relayers. Filter by active status with `active`. */
-  async getRelayers(params) {
-    const qs = this.buildQuery({
-      page: params?.page,
-      limit: params?.limit,
-      active: params?.active === void 0 ? void 0 : params.active ? "true" : "false"
-    });
-    return this.get(`/relayers${qs}`);
-  }
-  /** Returns a single relayer by EVM address, or null if not found. */
-  async getRelayer(evmAddress) {
-    return this.getOrNull(`/relayers/${encodeURIComponent(evmAddress.toLowerCase())}`);
-  }
-  /** Returns a paginated list of relay fee events. */
-  async getRelayFees(params) {
-    const qs = this.buildQuery({
-      page: params?.page,
-      limit: params?.limit,
-      relayer: params?.relayer,
-      type: params?.type
-    });
-    return this.get(`/relayers/fees${qs}`);
-  }
-  /** Returns aggregated relay fee balances per asset for a given relayer account. */
-  async getRelayFeesSummary(relayer) {
-    return this.get(
-      `/relayers/fees/summary/${encodeURIComponent(relayer)}`
-    );
-  }
-  // ─── Registered assets ─────────────────────────────────────────────────────
-  /** Returns a paginated list of assets registered via register_asset. */
-  async getRegisteredAssets(params) {
-    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
-    return this.get(`/shielded/assets${qs}`);
-  }
-  /** Returns a single registered asset by its ID, or null if not found. */
-  async getRegisteredAsset(assetId) {
-    return this.getOrNull(`/shielded/assets/${encodeURIComponent(assetId)}`);
-  }
-  // ─── Validators ────────────────────────────────────────────────────────────
-  /** Returns a paginated list of validators. Filter by lifecycle status with `status`. */
-  async getValidators(params) {
-    const qs = this.buildQuery({
-      page: params?.page,
-      limit: params?.limit,
-      status: params?.status
-    });
-    return this.get(`/validators${qs}`);
-  }
-  /** Returns a single validator by account address, or null if not found. */
-  async getValidator(account) {
-    return this.getOrNull(`/validators/${encodeURIComponent(account)}`);
-  }
-  // ─── Sessions ──────────────────────────────────────────────────────────────
-  /** Returns a paginated list of session rotations, ordered by most recent first. */
-  async getSessions(params) {
-    const qs = this.buildQuery({ page: params?.page, limit: params?.limit });
-    return this.get(`/sessions${qs}`);
-  }
-  // ─── Stats & Health ────────────────────────────────────────────────────────
-  /** Returns aggregated indexer statistics. */
-  async getStats() {
-    return this.get("/stats");
-  }
-  /**
-   * Returns transaction activity bucketed per hour over the last `hours` hours
-   * of chain time (default 24, max 168). For sparklines / activity charts.
-   */
-  async getActivity(hours = 24) {
-    return this.get(`/stats/activity?hours=${hours}`);
-  }
-  /** 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/pallet/ShieldedPoolModule.ts
 var import_polkadot_api2 = require("polkadot-api");
 
@@ -1648,8 +1258,8 @@ var BABYJUB_SUBORDER = 273603035897990940278080071815715938607681397215856725920
 // src/shielded-pool/protocol/memo.ts
 var import_sha2 = require("@noble/hashes/sha2.js");
 var KEY_DOMAIN = new TextEncoder().encode("orbinum-note-encryption-v1");
-var MEMO_PLAINTEXT_SIZE = 116;
-function serializeMemo(value, ownerPk, blinding, assetId, counterpartyPk) {
+var MEMO_PLAINTEXT_SIZE = 120;
+function serializeMemo(value, ownerPk, blinding, assetId, counterpartyPk, circuitVersion) {
   const buf = new Uint8Array(MEMO_PLAINTEXT_SIZE);
   const view = new DataView(buf.buffer);
   view.setBigUint64(0, value & 0xffffffffffffffffn, true);
@@ -1658,6 +1268,7 @@ function serializeMemo(value, ownerPk, blinding, assetId, counterpartyPk) {
   buf.set(blinding.slice(0, 32), 48);
   view.setUint32(80, assetId >>> 0, true);
   buf.set(counterpartyPk.slice(0, 32), 84);
+  view.setUint32(116, circuitVersion >>> 0, true);
   return buf;
 }
 function deriveEncryptionKey(sharedSecret, commitment) {
@@ -1670,7 +1281,7 @@ function deriveEncryptionKey(sharedSecret, commitment) {
 
 // src/shielded-pool/protocol/EncryptedMemo.ts
 var NONCE_SIZE = 12;
-var CIPHERTEXT_SIZE = 132;
+var CIPHERTEXT_SIZE = 136;
 var EPH_PK_SIZE = 32;
 var ENCRYPTED_MEMO_SIZE = NONCE_SIZE + CIPHERTEXT_SIZE + EPH_PK_SIZE;
 function bytesToBjjScalar(bytes) {
@@ -1689,14 +1300,15 @@ function parsePlaintext(nonce, ciphertextWithMac, encKey) {
     const blinding = bytesToBigintLE(plaintext.slice(48, 80));
     const assetId = BigInt(view.getUint32(80, true));
     const counterpartyPk = bytesToBigintLE(plaintext.slice(84, 116));
-    return { value, ownerPk, blinding, assetId, counterpartyPk };
+    const circuitVersion = view.getUint32(116, true);
+    return { value, ownerPk, blinding, assetId, counterpartyPk, circuitVersion };
   } catch {
     return null;
   }
 }
 var EncryptedMemo = {
   /**
-   * Build and encrypt a memo for a note using ECDH (v2, 168 bytes).
+   * Build and encrypt a memo for a note using ECDH (v2, 180 bytes).
    *
    * @param value              Note value in planck.
    * @param ownerPk            32-byte owner public key (LE).
@@ -1708,11 +1320,20 @@ var EncryptedMemo = {
    *                           decoded from a privacy address).
    *                           Pass `new Uint8Array(32)` (all zeros) for a publicly-readable memo.
    * @param counterpartyPk     32-byte counterparty BJJ Ax. Default: all zeros.
-   * @returns 168-byte encrypted memo: nonce(12) || ciphertext+MAC(124) || ephPk(32).
+   * @param circuitVersion     ZK circuit version the note is spent under. Default: 0.
+   * @param ephSkOverride      32-byte ephemeral secret key (stealth coordination). Optional.
+   * @returns 180-byte encrypted memo: nonce(12) || ciphertext+MAC(136) || ephPk(32).
    */
-  encrypt(value, ownerPk, blinding, assetId, commitment, recipientIvkPacked, counterpartyPk = new Uint8Array(32), ephSkOverride) {
+  encrypt(value, ownerPk, blinding, assetId, commitment, recipientIvkPacked, counterpartyPk = new Uint8Array(32), circuitVersion = 0, ephSkOverride) {
     const nonce = (0, import_utils.randomBytes)(NONCE_SIZE);
-    const plaintext = serializeMemo(value, ownerPk, blinding, assetId, counterpartyPk);
+    const plaintext = serializeMemo(
+      value,
+      ownerPk,
+      blinding,
+      assetId,
+      counterpartyPk,
+      circuitVersion
+    );
     const isZeroKey = recipientIvkPacked.every((b) => b === 0);
     let sharedSecret;
     let ephPkPackedBytes;
@@ -1743,29 +1364,31 @@ var EncryptedMemo = {
     return result;
   },
   /**
-   * Returns a 168-byte public memo encrypted with a zero viewing key.
+   * Returns a 180-byte public memo encrypted with a zero viewing key.
    * Decryptable by anyone with `decrypt(memo, commitment, new Uint8Array(32))`.
    * Convenience alias for `encrypt(..., new Uint8Array(32))`.
    */
-  encryptPublic(value, ownerPk, blinding, assetId, commitment) {
+  encryptPublic(value, ownerPk, blinding, assetId, commitment, circuitVersion = 0) {
     return EncryptedMemo.encrypt(
       value,
       ownerPk,
       blinding,
       assetId,
       commitment,
-      new Uint8Array(32)
+      new Uint8Array(32),
+      new Uint8Array(32),
+      circuitVersion
     );
   },
   /**
-   * Returns a 168-byte zeroed dummy memo (no information, always valid on-chain).
+   * Returns a 180-byte zeroed dummy memo (no information, always valid on-chain).
    */
   dummy() {
     return new Uint8Array(ENCRYPTED_MEMO_SIZE);
   },
   /**
    * Validates that `bytes` is a properly-sized encrypted memo.
-   * Throws an Error if the length is not ENCRYPTED_MEMO_SIZE (168 bytes).
+   * Throws an Error if the length is not ENCRYPTED_MEMO_SIZE (180 bytes).
    *
    * Call this at system boundaries (extrinsic builders, precompile encoders)
    * to catch malformed memos before they reach the chain and fail on-chain.
@@ -1786,7 +1409,7 @@ var EncryptedMemo = {
    * Returns null if decryption fails — wrong key, bad MAC, or malformed memo.
    * Never throws; safe for scan loops.
    *
-   * @param memoBytes        168-byte encrypted memo.
+   * @param memoBytes        180-byte encrypted memo.
    * @param commitment       32-byte note commitment (LE).
    * @param viewingSecretKey 32-byte HKDF viewing secret key from deriveViewingSecretKey().
    */
@@ -1798,13 +1421,13 @@ var EncryptedMemo = {
    * Extract the ECDH shared secret from an encrypted memo using the recipient's viewing secret key.
    *
    * Used by NoteDecryptor to obtain the shared secret needed for stealth address derivation
-   * without re-running the full decrypt path. Safe to call on any 168-byte memo.
+   * without re-running the full decrypt path. Safe to call on any 180-byte memo.
    *
    * Returns `new Uint8Array(32)` (all zeros) for public/dummy memos (zero ephPk).
    * Returns `null` if the memo is malformed or the ephPk is not a valid BJJ point.
    * Never throws; safe for scan loops.
    *
-   * @param memoBytes        168-byte encrypted memo.
+   * @param memoBytes        180-byte encrypted memo.
    * @param viewingSecretKey 32-byte HKDF viewing secret key from deriveViewingSecretKey().
    */
   extractSharedSecret(memoBytes, viewingSecretKey) {
@@ -2008,7 +1631,7 @@ var ShieldedPoolModule = class {
    * Withdraws tokens from the shielded pool to a public address.
    * Submits as an UNSIGNED (gasless) transaction — fee is embedded in the ZK proof.
    * Pass a `signer` to fall back to signed submission (e.g. for testing).
-   * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient, fee)
+   * Extrinsic: shieldedPool.unshield(proof, merkleRoot, nullifier, assetId, amount, recipient, fee, changeCommitment, changeEncryptedMemo, relayer, circuitVersion)
    */
   async unshield(params, signer, txOptions) {
     const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "unshield");
@@ -2032,8 +1655,9 @@ var ShieldedPoolModule = class {
       fee: params.fee ?? 0n,
       change_commitment: changeCommitment,
       change_encrypted_memo: changeEncryptedMemo,
-      relayer: void 0
+      relayer: void 0,
       // Option<H160> — None for direct Substrate submissions
+      circuit_version: params.circuitVersion
     });
     if (signer) {
       return toTxResult(
@@ -2046,7 +1670,7 @@ var ShieldedPoolModule = class {
    * Performs a private (shielded) transfer between two notes.
    * Submits as an UNSIGNED (gasless) transaction — fee is embedded in the ZK proof.
    * Pass a `signer` to fall back to signed submission (e.g. for testing).
-   * Extrinsic: shieldedPool.privateTransfer(proof, merkleRoot, nullifiers, commitments, memos, assetId, fee)
+   * Extrinsic: shieldedPool.privateTransfer(proof, merkleRoot, nullifiers, commitments, memos, assetId, fee, relayer, circuitVersion)
    */
   async privateTransfer(params, signer, txOptions) {
     const nullifiers = params.inputs.map((inp) => inp.nullifier);
@@ -2067,8 +1691,9 @@ var ShieldedPoolModule = class {
       encrypted_memos: memos,
       asset_id: params.assetId,
       fee: params.fee ?? 0n,
-      relayer: void 0
+      relayer: void 0,
       // Option<H160> — None for direct Substrate submissions
+      circuit_version: params.circuitVersion
     });
     if (signer) {
       return toTxResult(
@@ -2102,7 +1727,7 @@ var ShieldedPoolModule = class {
    * This is a SIGNED transaction — the relayer must sign it with their wallet.
    * Before calling this, generate a ZK value proof with generateFeeClaimProof() (not yet implemented).
    *
-   * Extrinsic: shieldedPool.claim_shielded_fees(commitment, amount, asset_id, memo, proof, public_signals)
+   * Extrinsic: shieldedPool.claim_shielded_fees(commitment, amount, asset_id, memo, proof, public_signals, circuit_version)
    */
   async claimShieldedFees(params, signer, txOptions) {
     EncryptedMemo.validate(params.encryptedMemo, "claimShieldedFees.encryptedMemo");
@@ -2113,7 +1738,8 @@ var ShieldedPoolModule = class {
       asset_id: params.assetId,
       encrypted_memo: params.encryptedMemo,
       proof: params.proof,
-      public_signals: params.publicSignals
+      public_signals: params.publicSignals,
+      circuit_version: params.circuitVersion
     });
     return toTxResult(
       await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
@@ -2631,6 +2257,74 @@ var ZkVerifierModule = class {
   }
 };
 
+// src/shielded-pool/CircuitVersionResolver.ts
+var import_proof_generator = require("@orbinum/proof-generator");
+var CircuitVersionResolver = class {
+  constructor(zkVerifier, baseUrl, providerFactory) {
+    this.zkVerifier = zkVerifier;
+    this.makeProvider = providerFactory ?? ((circuit, noteVersion) => new import_proof_generator.WebArtifactProvider({
+      ...baseUrl ? { baseUrl } : {},
+      circuitVersions: { [circuit]: noteVersion }
+    }));
+  }
+  zkVerifier;
+  makeProvider;
+  /**
+   * Resolves the prover + on-chain version for spending a note of `circuit`
+   * created under `noteVersion`. Fail-closed: throws on unsupported version or
+   * VK-hash mismatch (CDN vs chain), before generating any proof.
+   */
+  async resolve(circuit, noteVersion) {
+    if (!Number.isInteger(noteVersion) || noteVersion <= 0) {
+      throw new Error(
+        `CircuitVersionResolver: invalid note circuitVersion ${noteVersion} for ${circuit}`
+      );
+    }
+    const provider = this.makeProvider(circuit, noteVersion);
+    const resolved = await provider.getResolvedVersion(circuit);
+    if (resolved.version !== noteVersion) {
+      throw new Error(
+        `CircuitVersionResolver: prover resolved ${circuit} to v${resolved.version}, expected v${noteVersion}`
+      );
+    }
+    const circuitId = (0, import_proof_generator.circuitTypeToId)(circuit);
+    const info = await this.zkVerifier.getCircuitVersionInfo(circuitId);
+    if (!info) {
+      throw new Error(
+        `CircuitVersionResolver: chain reports no version info for ${circuit} (id ${circuitId})`
+      );
+    }
+    if (!info.supportedVersions.includes(noteVersion)) {
+      throw new Error(
+        `CircuitVersionResolver: chain does not support ${circuit} v${noteVersion} (supported: ${info.supportedVersions.join(", ")})`
+      );
+    }
+    const chainVk = info.vkHashes.find((h) => h.version === noteVersion);
+    if (!chainVk) {
+      throw new Error(
+        `CircuitVersionResolver: chain has no VK hash for ${circuit} v${noteVersion}`
+      );
+    }
+    if (!vkHashEquals(chainVk.vkHash, resolved.vkHash)) {
+      throw new Error(
+        `CircuitVersionResolver: VK hash mismatch for ${circuit} v${noteVersion} \u2014 prover ${resolved.vkHash}, chain ${chainVk.vkHash}`
+      );
+    }
+    return { provider, version: noteVersion };
+  }
+};
+function vkHashEquals(a, b) {
+  const na = normalizeHash(a);
+  const nb = normalizeHash(b);
+  if (na === null || nb === null) return false;
+  return na === nb;
+}
+function normalizeHash(h) {
+  if (typeof h !== "string") return null;
+  const s = h.toLowerCase().startsWith("0x") ? h.toLowerCase().slice(2) : h.toLowerCase();
+  return /^[0-9a-f]{64}$/.test(s) ? s : null;
+}
+
 // src/relayer/RelayerStatusModule.ts
 var RelayerStatusModule = class {
   constructor(substrate) {
@@ -2876,12 +2570,12 @@ var AM_SEL = {
 var SP_SEL = {
   // shield(uint32,bytes32,bytes)                                               → 0x9feb22ea  (payable, amount = msg.value)
   SHIELD: new Uint8Array([159, 235, 34, 234]),
-  // privateTransfer(bytes,bytes32,bytes32[],bytes32[],bytes[],uint32,uint256)    → 0x8c0f5d24
-  PRIVATE_TRANSFER: new Uint8Array([140, 15, 93, 36]),
-  // unshield(bytes,bytes32,bytes32,uint32,uint256,bytes32,uint256,bytes32)               → 0xd21d9a79
-  UNSHIELD: new Uint8Array([210, 29, 154, 121]),
-  // claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)                → 0x42e1e74c
-  CLAIM_SHIELDED_FEES: new Uint8Array([66, 225, 231, 76])
+  // privateTransfer(bytes,bytes32,bytes32[],bytes32[],bytes[],uint32,uint256,uint32)  → 0x66ed2cd4
+  PRIVATE_TRANSFER: new Uint8Array([102, 237, 44, 212]),
+  // unshield(bytes,bytes32,bytes32,uint32,uint256,bytes32,uint256,bytes32,bytes,uint32)  → 0x4e505348
+  UNSHIELD: new Uint8Array([78, 80, 83, 72]),
+  // claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes,uint32)         → 0x88d9deba
+  CLAIM_SHIELDED_FEES: new Uint8Array([136, 217, 222, 186])
 };
 var KNOWN_PRECOMPILES = {
   // ── Ethereum standard (EIP) ─────────────────────────────────────────────
@@ -2925,9 +2619,9 @@ var KNOWN_PRECOMPILES = {
     name: "ShieldedPool",
     functions: {
       "9feb22ea": "shield(uint32,bytes32,bytes)",
-      "8c0f5d24": "privateTransfer(bytes,bytes32,bytes32[],bytes32[],bytes[],uint32,uint256)",
-      d21d9a79: "unshield(bytes,bytes32,bytes32,uint32,uint256,bytes32,uint256,bytes32)",
-      "42e1e74c": "claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)"
+      "66ed2cd4": "privateTransfer(bytes,bytes32,bytes32[],bytes32[],bytes[],uint32,uint256,uint32)",
+      "4e505348": "unshield(bytes,bytes32,bytes32,uint32,uint256,bytes32,uint256,bytes32,bytes,uint32)",
+      "88d9deba": "claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes,uint32)"
     }
   }
 };
@@ -2981,7 +2675,8 @@ var ShieldedPoolPrecompile = class {
   // ─── privateTransfer ───────────────────────────────────────────────────────
   /**
    * Returns the ABI-encoded calldata for
-   * `privateTransfer(bytes, bytes32, bytes32[], bytes32[], bytes[], uint32, uint256)`.
+   * `privateTransfer(bytes, bytes32, bytes32[], bytes32[], bytes[], uint32, uint256, uint32)`.
+   * The trailing `uint32` is the circuit version the input notes were created under.
    */
   buildPrivateTransferCalldata(params) {
     const nullifiers = params.inputs.map((i) => fromHex(i.nullifier));
@@ -3002,7 +2697,8 @@ var ShieldedPoolPrecompile = class {
       { type: "bytes32[]", value: commitments },
       { type: "bytes[]", value: memos },
       { type: "uint", value: BigInt(params.assetId) },
-      { type: "uint", value: params.fee ?? 0n }
+      { type: "uint", value: params.fee ?? 0n },
+      { type: "uint", value: BigInt(params.circuitVersion) }
     );
   }
   /**
@@ -3043,7 +2739,8 @@ var ShieldedPoolPrecompile = class {
       { type: "bytes32", value: recipientBytes },
       { type: "uint", value: params.fee ?? 0n },
       { type: "bytes32", value: changeCommitment },
-      { type: "bytes", value: changeEncryptedMemo }
+      { type: "bytes", value: changeEncryptedMemo },
+      { type: "uint", value: BigInt(params.circuitVersion) }
     );
   }
   /**
@@ -3093,7 +2790,7 @@ var ShieldedPoolPrecompile = class {
   // ─── claimShieldedFees ───────────────────────────────────────────────────────────────────
   /**
    * Returns the ABI-encoded calldata for
-   * `claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)`.
+   * `claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes,uint32)`.
    *
    * ABI layout (params after selector):
    * - `commitment`    — bytes32 (fixed)
@@ -3102,6 +2799,7 @@ var ShieldedPoolPrecompile = class {
    * - `memo`          — bytes   (dynamic)
    * - `proof`         — bytes   (dynamic, 128 bytes Groth16)
    * - `publicSignals` — bytes   (dynamic, 76 bytes)
+   * - `circuitVersion` — uint32 (fixed, right-aligned)
    *
    * The validator identity is derived from `msg.sender` in the precompile —
    * do NOT include it in the calldata.
@@ -3127,7 +2825,8 @@ var ShieldedPoolPrecompile = class {
       { type: "uint", value: BigInt(params.assetId) },
       { type: "bytes", value: params.encryptedMemo },
       { type: "bytes", value: params.proof },
-      { type: "bytes", value: params.publicSignals }
+      { type: "bytes", value: params.publicSignals },
+      { type: "uint", value: BigInt(params.circuitVersion) }
     );
   }
   /**
@@ -3549,12 +3248,6 @@ var OrbinumClient = class _OrbinumClient {
    * `null` when `evmRpc` is not configured.
    */
   evmExplorer;
-  /**
-   * HTTP client for the Orbinum indexer REST API.
-   * Provides paginated access to indexed blocks, extrinsics, shielded events, and nullifiers.
-   * `null` when `indexerUrl` is not configured.
-   */
-  indexer;
   /** Shielded-pool extrinsics and Merkle tree queries (`shield`, `unshield`, `privateTransfer`, …). */
   shieldedPool;
   /** Account-mapping extrinsics: aliases, chain links, metadata, marketplace, and identity. */
@@ -3565,6 +3258,11 @@ var OrbinumClient = class _OrbinumClient {
   chain;
   /** Typed access to `zkVerifier_*` custom RPC endpoints. */
   zkVerifier;
+  /**
+   * Resolves a note's circuit version to a pinned prover + on-chain version
+   * before spending it (fail-closed: throws on unsupported version / VK mismatch).
+   */
+  circuitVersionResolver;
   /** Typed access to `relayer_*` RPC endpoints (registry lookup and pending fee queries). */
   relayerStatus;
   /**
@@ -3573,16 +3271,16 @@ var OrbinumClient = class _OrbinumClient {
    */
   precompiles;
   /** @internal Use `OrbinumClient.connect()` to obtain an instance. */
-  constructor(substrate, evm, indexer) {
+  constructor(substrate, evm, circuitsBaseUrl) {
     this.substrate = substrate;
     this.evm = 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.chain = new ChainModule(substrate);
     this.zkVerifier = new ZkVerifierModule(substrate);
+    this.circuitVersionResolver = new CircuitVersionResolver(this.zkVerifier, circuitsBaseUrl);
     this.relayerStatus = new RelayerStatusModule(substrate);
     this.precompiles = evm ? {
       shieldedPool: new ShieldedPoolPrecompile(evm),
@@ -3602,8 +3300,7 @@ var OrbinumClient = class _OrbinumClient {
       config.connectTimeoutMs ?? 15e3
     );
     const evm = config.evmRpc ? new EvmClient(config.evmRpc) : null;
-    const indexer = config.indexerUrl ? new IndexerClient({ baseUrl: config.indexerUrl }) : null;
-    return new _OrbinumClient(substrate, evm, indexer);
+    return new _OrbinumClient(substrate, evm, config.circuitsBaseUrl);
   }
   /** Closes the underlying Substrate WebSocket connection and releases all resources. */
   destroy() {
@@ -3724,7 +3421,8 @@ var OrbinumClientProvider = class {
         substrateWs: this.config.substrateWs
       };
       if (this.config.evmRpc) connectConfig.evmRpc = this.config.evmRpc;
-      if (this.config.indexerUrl) connectConfig.indexerUrl = this.config.indexerUrl;
+      if (this.config.circuitsBaseUrl)
+        connectConfig.circuitsBaseUrl = this.config.circuitsBaseUrl;
       const clientPromise = OrbinumClient.connect(connectConfig);
       const client = await Promise.race([clientPromise, timeoutPromise]);
       orphanClient = client;
@@ -3911,6 +3609,9 @@ var OrbinumClientProvider = class {
   }
 };
 
+// src/shielded-pool/protocol/types.ts
+var CURRENT_CIRCUIT_VERSION = 1;
+
 // src/utils/stealth.ts
 var import_sha22 = require("@noble/hashes/sha2.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
@@ -4019,6 +3720,7 @@ var NoteBuilder = class {
     const blinding = input.blinding ?? BigInt(Date.now());
     const spendingKey = input.spendingKey ?? 0n;
     const counterpartyPk = input.counterpartyPk ?? 0n;
+    const circuitVersion = input.circuitVersion ?? CURRENT_CIRCUIT_VERSION;
     const useStealth = input.viewingPublicKey !== void 0 && input.recipientOwnerPk !== void 0;
     let memo;
     if (useStealth) {
@@ -4053,6 +3755,7 @@ var NoteBuilder = class {
           stealthCommitmentBytes,
           recipientIvkPacked,
           bigintTo32Le(counterpartyPk),
+          circuitVersion,
           ephSk
         )
       );
@@ -4070,6 +3773,7 @@ var NoteBuilder = class {
         ownerPk: effectiveOwnerPk,
         blinding,
         spendingKey,
+        circuitVersion,
         spent: false,
         spentAt: null,
         commitment: commitment2,
@@ -4092,7 +3796,8 @@ var NoteBuilder = class {
         Number(assetId),
         commitmentBytes,
         input.viewingPublicKey,
-        bigintTo32Le(counterpartyPk)
+        bigintTo32Le(counterpartyPk),
+        circuitVersion
       )
     ) : Array.from(EncryptedMemo.dummy());
     if (memo.length !== ENCRYPTED_MEMO_SIZE)
@@ -4105,6 +3810,7 @@ var NoteBuilder = class {
       ownerPk,
       blinding,
       spendingKey,
+      circuitVersion,
       spent: false,
       spentAt: null,
       commitment,
@@ -4116,7 +3822,7 @@ var NoteBuilder = class {
     };
   }
   /**
-   * Build the 168-byte ECDH-encrypted memo for a note.
+   * Build the 180-byte ECDH-encrypted memo for a note.
    *
    * Pure TypeScript implementation — no WASM dependency.
    * Uses ChaCha20-Poly1305 with ECDH key agreement (BabyJubJub ephemeral keypair).
@@ -4135,7 +3841,8 @@ var NoteBuilder = class {
       Number(note.assetId),
       bigintTo32Le(note.commitment),
       recipientIvkPacked ?? new Uint8Array(32),
-      counterpartyPk ?? bigintTo32Le(note.counterpartyPk ?? 0n)
+      counterpartyPk ?? bigintTo32Le(note.counterpartyPk ?? 0n),
+      note.circuitVersion
     );
   }
 };
@@ -4197,6 +3904,7 @@ function tryDecryptNoteVerbose(commitment, viewingSecretKey, spendingKey, ownOwn
       ownerPk: effectiveOwnerPk,
       blinding: plaintext.blinding,
       spendingKey: effectiveSpendingKey,
+      circuitVersion: plaintext.circuitVersion,
       spent: false,
       spentAt: null,
       commitment: recomputed,
@@ -4270,7 +3978,7 @@ function selectNotes(notes, needed) {
     for (let j = i + 1; j < sorted.length; j++) {
       const a = sorted[i];
       const b = sorted[j];
-      if (a !== void 0 && b !== void 0 && a.value + b.value >= needed) {
+      if (a !== void 0 && b !== void 0 && a.circuitVersion === b.circuitVersion && a.value + b.value >= needed) {
         return [a, b];
       }
     }
@@ -4627,6 +4335,11 @@ async function encryptNote(key, blindKey, note) {
 }
 async function decryptNoteRecord(key, rec) {
   const note = await decryptJson(key, rec.iv, rec.ciphertext);
+  if (typeof note.circuitVersion !== "number") {
+    throw new Error(
+      "decryptNoteRecord: note is missing circuitVersion (invalid or corrupt record)"
+    );
+  }
   return applyNoteStatus(note, {
     ...rec.spent !== void 0 && { spent: rec.spent },
     spentAt: rec.spentAt ?? null
@@ -4637,7 +4350,7 @@ async function noteBlindTag(blindKey, hex) {
 }
 
 // src/proof-generator/unshield.ts
-var import_proof_generator = require("@orbinum/proof-generator");
+var import_proof_generator2 = require("@orbinum/proof-generator");
 var import_utils3 = require("@noble/ciphers/utils.js");
 var import_baby_jubjub6 = require("@zk-kit/baby-jubjub");
 var import_poseidon_lite4 = require("poseidon-lite");
@@ -4683,15 +4396,15 @@ async function generateUnshieldProof(inputs, options = {}) {
     change_blinding: changeBlinding.toString(),
     change_owner_pubkey: changeOwnerPubkey.toString()
   };
-  const provider = options.provider ?? new import_proof_generator.WebArtifactProvider();
+  const provider = options.provider ?? new import_proof_generator2.WebArtifactProvider();
   const opts = { provider };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  const proofResult = await (0, import_proof_generator.generateProof)(import_proof_generator.CircuitType.Unshield, circuitInputs, opts);
+  const proofResult = await (0, import_proof_generator2.generateProof)(import_proof_generator2.CircuitType.Unshield, circuitInputs, opts);
   return { ...proofResult, changeCommitment, changeValue, changeBlinding, changeOwnerPubkey };
 }
 
 // src/proof-generator/transfer.ts
-var import_proof_generator2 = require("@orbinum/proof-generator");
+var import_proof_generator3 = require("@orbinum/proof-generator");
 async function generateTransferProof(params, options = {}) {
   const root = leHexToBigint(params.merkleRoot).toString();
   const [i0, i1] = params.inputs;
@@ -4716,14 +4429,14 @@ async function generateTransferProof(params, options = {}) {
     output_owner_pubkeys: [o0.ownerPk.toString(), o1.ownerPk.toString()],
     output_blindings: [o0.blinding.toString(), o1.blinding.toString()]
   };
-  const provider = options.provider ?? new import_proof_generator2.WebArtifactProvider();
+  const provider = options.provider ?? new import_proof_generator3.WebArtifactProvider();
   const opts = { provider };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  return (0, import_proof_generator2.generateProof)(import_proof_generator2.CircuitType.Transfer, circuitInputs, opts);
+  return (0, import_proof_generator3.generateProof)(import_proof_generator3.CircuitType.Transfer, circuitInputs, opts);
 }
 
 // src/proof-generator/fee-claim.ts
-var import_proof_generator3 = require("@orbinum/proof-generator");
+var import_proof_generator4 = require("@orbinum/proof-generator");
 async function generateFeeClaimProof(inputs, options = {}) {
   if (inputs.amount <= 0n) {
     throw new Error("Fee claim amount must be greater than zero.");
@@ -4735,10 +4448,10 @@ async function generateFeeClaimProof(inputs, options = {}) {
     owner_pubkey: inputs.ownerPubkey.toString(),
     blinding: inputs.blinding.toString()
   };
-  const provider = options.provider ?? new import_proof_generator3.WebArtifactProvider();
+  const provider = options.provider ?? new import_proof_generator4.WebArtifactProvider();
   const opts = { provider };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  const proofResult = await (0, import_proof_generator3.generateProof)(import_proof_generator3.CircuitType.ValueProof, circuitInputs, opts);
+  const proofResult = await (0, import_proof_generator4.generateProof)(import_proof_generator4.CircuitType.ValueProof, circuitInputs, opts);
   const [sigCommitment, sigValue, sigAssetId, sigOwnerHash] = proofResult.publicSignals.map(BigInt);
   const buf = new Uint8Array(76);
   buf.set(bigintTo32Le(sigCommitment), 0);
@@ -4794,9 +4507,19 @@ function decodePrecompileCalldata(address, input) {
       const recipient = toHex(data.slice(160, 192));
       const fee = decodeUint(data, 192);
       const changeCommitment = toHex(data.slice(224, 256));
+      const circuitVersion = decodeUint(data, 288);
       return {
         fnSig,
-        args: { root, nullifier, assetId, amount, recipient, fee, changeCommitment }
+        args: {
+          root,
+          nullifier,
+          assetId,
+          amount,
+          recipient,
+          fee,
+          changeCommitment,
+          circuitVersion
+        }
       };
     } catch {
       return { fnSig, args: {} };
@@ -4812,7 +4535,8 @@ function decodePrecompileCalldata(address, input) {
       const commitments = Number(decodeUint(data, commOffset));
       const assetId = decodeUint(data, 160);
       const fee = decodeUint(data, 192);
-      return { fnSig, args: { root, nullifiers, commitments, assetId, fee } };
+      const circuitVersion = decodeUint(data, 224);
+      return { fnSig, args: { root, nullifiers, commitments, assetId, fee, circuitVersion } };
     } catch {
       return { fnSig, args: {} };
     }
@@ -4823,7 +4547,8 @@ function decodePrecompileCalldata(address, input) {
       const commitment = toHex(data.slice(0, 32));
       const amount = decodeUint(data, 32);
       const assetId = decodeUint(data, 64);
-      return { fnSig, args: { commitment, amount, assetId } };
+      const circuitVersion = decodeUint(data, 192);
+      return { fnSig, args: { commitment, amount, assetId, circuitVersion } };
     } catch {
       return { fnSig, args: {} };
     }
@@ -4835,8 +4560,8 @@ function decodePrecompileCalldata(address, input) {
 var CircuitId = {
   Transfer: 1,
   Unshield: 2,
-  ValueProof: 4,
-  PrivateLink: 5
+  PrivateLink: 5,
+  ValueProof: 6
 };
 
 // src/utils/string.ts
@@ -5508,14 +5233,15 @@ var import_polkadot_api4 = require("polkadot-api");
   BABYJUB_SUBORDER,
   BN254_R,
   Blake2256,
+  CURRENT_CIRCUIT_VERSION,
   CircuitId,
   CircuitType,
+  CircuitVersionResolver,
   CryptoPrecompiles,
   ENCRYPTED_MEMO_SIZE,
   EncryptedMemo,
   EvmClient,
   EvmExplorer,
-  IndexerClient,
   KNOWN_PRECOMPILES,
   Keccak256,
   NoteBuilder,