@orbinum/sdk 0.5.0 → 0.7.0

package/dist/index.js

@@ -27,7 +27,7 @@ __export(index_exports, {
   BN254_R: () => BN254_R,
   Blake2256: () => import_substrate_bindings3.Blake2256,
   CircuitId: () => CircuitId,
-  CircuitType: () => import_proof_generator2.CircuitType,
+  CircuitType: () => import_proof_generator.CircuitType,
   CryptoPrecompiles: () => CryptoPrecompiles,
   ENCRYPTED_MEMO_SIZE: () => ENCRYPTED_MEMO_SIZE,
   EncryptedMemo: () => EncryptedMemo,
@@ -50,7 +50,7 @@ __export(index_exports, {
   Storage: () => import_substrate_bindings3.Storage,
   SubstrateClient: () => SubstrateClient,
   VaultLockedError: () => VaultLockedError,
-  WebArtifactProvider: () => import_proof_generator2.WebArtifactProvider,
+  WebArtifactProvider: () => import_proof_generator.WebArtifactProvider,
   ZkVerifierModule: () => ZkVerifierModule,
   accountIdHexToSs58: () => accountIdHexToSs58,
   addressToAccountIdHex: () => addressToAccountIdHex,
@@ -59,17 +59,16 @@ __export(index_exports, {
   bigintTo32Be: () => bigintTo32Be,
   bigintTo32Le: () => bigintTo32Le,
   bigintTo32LeArr: () => bigintTo32LeArr,
-  buildDisclosurePublicSignals: () => buildDisclosurePublicSignals,
   buildDummyTransferInput: () => buildDummyTransferInput,
   bytesToBigintLE: () => bytesToBigintLE,
   computeNullifier: () => computeNullifier,
   computePathIndices: () => computePathIndices,
   connectInjectedExtension: () => import_pjs_signer.connectInjectedExtension,
+  createNoteDisclosureKey: () => createNoteDisclosureKey,
+  decodeNoteDisclosureKey: () => decodeNoteDisclosureKey,
   decodePrecompileCalldata: () => decodePrecompileCalldata,
-  decryptDisclosureSignals: () => decryptDisclosureSignals,
   decryptJson: () => decryptJson,
   decryptNoteRecord: () => decryptNoteRecord,
-  deriveBabyJubjubKeypair: () => deriveBabyJubjubKeypair,
   deriveMasterKeyBytes: () => deriveMasterKeyBytes,
   deriveOwnerPk: () => deriveOwnerPk,
   deriveSpendingKeyFromSignature: () => deriveSpendingKeyFromSignature,
@@ -90,7 +89,6 @@ __export(index_exports, {
   formatORB: () => formatORB,
   fromBase64: () => fromBase64,
   fromHex: () => fromHex,
-  generateDisclosureProof: () => import_proof_generator.generateDisclosureProof,
   generateFeeClaimProof: () => generateFeeClaimProof,
   generateTransferProof: () => generateTransferProof,
   generateUnshieldProof: () => generateUnshieldProof,
@@ -132,7 +130,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/substrate/SubstrateClient.ts
 var import_polkadot_api = require("polkadot-api");
-var import_ws_provider = require("polkadot-api/ws-provider");
+var import_ws = require("polkadot-api/ws");
 var import_metadata_builders = require("@polkadot-api/metadata-builders");
 var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
 var import_substrate_bindings2 = require("@polkadot-api/substrate-bindings");
@@ -178,7 +176,7 @@ var SubstrateClient = class _SubstrateClient {
    * Throws if the node does not respond within `timeoutMs`.
    */
   static async connect(wsUrl, timeoutMs = 15e3) {
-    const provider = (0, import_ws_provider.getWsProvider)(wsUrl);
+    const provider = (0, import_ws.getWsProvider)(wsUrl);
     const papi = (0, import_polkadot_api.createClient)(provider);
     await Promise.race([
       papi._request("system_name", []),
@@ -355,20 +353,20 @@ var SubstrateClient = class _SubstrateClient {
    * into a PAPI UnsafeTransaction that can be signed and submitted.
    */
   async txFromCallData(callData) {
-    return this._papi.getUnsafeApi().txFromCallData(import_polkadot_api.Binary.fromBytes(callData));
+    return this._papi.getUnsafeApi().txFromCallData(callData);
   }
   /**
    * Submits a pre-signed extrinsic (hex string) and waits for finalization.
    */
   async submit(signedHex) {
-    return this._papi.submit(signedHex);
+    return this._papi.submit(import_polkadot_api.Binary.fromHex(signedHex));
   }
   /**
    * Submits a pre-signed extrinsic and returns an Observable of tx lifecycle events.
    * Events: TxSigned → TxBroadcasted → TxBestBlocksState → TxFinalized
    */
   submitAndWatch(signedHex) {
-    return this._papi.submitAndWatch(signedHex);
+    return this._papi.submitAndWatch(import_polkadot_api.Binary.fromHex(signedHex));
   }
   /**
    * Submits a bare (unsigned) extrinsic hex and waits for finalization.
@@ -376,7 +374,7 @@ var SubstrateClient = class _SubstrateClient {
    * The bare tx hex is produced by `tx.getBareTx()` from polkadot-api.
    */
   async submitUnsignedAndWatch(bareTxHex) {
-    return this._papi.submit(bareTxHex);
+    return this._papi.submit(import_polkadot_api.Binary.fromHex(bareTxHex));
   }
   /**
    * Convenience: wrap raw call bytes and sign+submit in one step.
@@ -1319,6 +1317,46 @@ var IndexerClient = class {
       `/shielded/address/${encodeURIComponent(address.toLowerCase())}${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)}`);
+  }
   // ─── Stats & Health ────────────────────────────────────────────────────────
   /** Returns aggregated indexer statistics. */
   async getStats() {
@@ -1801,7 +1839,7 @@ var ShieldedPoolModule = class {
       asset_id: params.assetId,
       amount: params.amount,
       commitment: import_polkadot_api2.Binary.fromHex(params.commitment),
-      encrypted_memo: import_polkadot_api2.Binary.fromBytes(params.encryptedMemo)
+      encrypted_memo: params.encryptedMemo
     });
     return toTxResult(
       await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
@@ -1821,12 +1859,12 @@ var ShieldedPoolModule = class {
     let changeEncryptedMemo;
     if (params.changeEncryptedMemo && params.changeEncryptedMemo.length > 0) {
       EncryptedMemo.validate(params.changeEncryptedMemo, "changeEncryptedMemo");
-      changeEncryptedMemo = import_polkadot_api2.Binary.fromBytes(params.changeEncryptedMemo);
+      changeEncryptedMemo = params.changeEncryptedMemo;
     } else {
-      changeEncryptedMemo = import_polkadot_api2.Binary.fromBytes(new Uint8Array(0));
+      changeEncryptedMemo = new Uint8Array(0);
     }
     const tx = callUnsafeTx(entry, {
-      proof: import_polkadot_api2.Binary.fromBytes(params.proof),
+      proof: params.proof,
       merkle_root: import_polkadot_api2.Binary.fromHex(params.merkleRoot),
       nullifier: import_polkadot_api2.Binary.fromHex(params.nullifier),
       asset_id: params.assetId,
@@ -1859,11 +1897,11 @@ var ShieldedPoolModule = class {
         out.encryptedMemo,
         `privateTransfer.outputs[${i}].encryptedMemo`
       );
-      return import_polkadot_api2.Binary.fromBytes(out.encryptedMemo);
+      return out.encryptedMemo;
     });
     const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "private_transfer");
     const tx = callUnsafeTx(entry, {
-      proof: import_polkadot_api2.Binary.fromBytes(params.proof),
+      proof: params.proof,
       merkle_root: import_polkadot_api2.Binary.fromHex(params.merkleRoot),
       nullifiers,
       commitments,
@@ -1891,7 +1929,7 @@ var ShieldedPoolModule = class {
         assetId: item.assetId,
         amount: item.amount.toString(),
         commitment: import_polkadot_api2.Binary.fromHex(item.commitment),
-        encryptedMemo: import_polkadot_api2.Binary.fromBytes(item.encryptedMemo)
+        encryptedMemo: item.encryptedMemo
       };
     });
     const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "shield_batch");
@@ -1903,7 +1941,7 @@ var ShieldedPoolModule = class {
   /**
    * Claims accrued relay fees into the shielded pool.
    * This is a SIGNED transaction — the relayer must sign it with their wallet.
-   * Before calling this, generate a ZK disclosure proof with generateFeeClaimProof().
+   * 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)
    */
@@ -1914,98 +1952,9 @@ var ShieldedPoolModule = class {
       commitment: import_polkadot_api2.Binary.fromHex(params.commitment),
       amount: params.amount,
       asset_id: params.assetId,
-      encrypted_memo: import_polkadot_api2.Binary.fromBytes(params.encryptedMemo),
-      proof: import_polkadot_api2.Binary.fromBytes(params.proof),
-      public_signals: import_polkadot_api2.Binary.fromBytes(params.publicSignals)
-    });
-    return toTxResult(
-      await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
-    );
-  }
-  // ─── Selective Disclosure ──────────────────────────────────────────────────
-  /**
-   * Requests a selective disclosure from a target account for a specific commitment.
-   * The auditor's Baby Jubjub public key is included so the note owner knows
-   * which key to encrypt to when generating the proof.
-   * Extrinsic: shieldedPool.request_disclosure(target, commitment, required_fields,
-   *                                             reason, auditor_bjj_pk_x, auditor_bjj_pk_y)
-   */
-  async requestDisclosure(params, signer, txOptions) {
-    const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "request_disclosure");
-    const tx = callUnsafeTx(entry, {
-      target: params.target,
-      commitment: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.commitment)),
-      required_fields: {
-        value: params.requiredFields.value,
-        asset_id: params.requiredFields.assetId,
-        owner: params.requiredFields.owner
-      },
-      reason: import_polkadot_api2.Binary.fromText(params.reason),
-      auditor_bjj_pk_x: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.auditorBjjPkX)),
-      auditor_bjj_pk_y: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.auditorBjjPkY))
-    });
-    return toTxResult(
-      await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
-    );
-  }
-  /**
-   * Submits a Groth16 ZK disclosure proof for a note commitment.
-   * The proof reveals the selected fields (value, asset_id, owner_hash) on-chain.
-   * Use generateDisclosureProof() + buildDisclosurePublicSignals() before calling this.
-   * Extrinsic: shieldedPool.disclose(commitment, proof_bytes, public_signals, auditor)
-   */
-  async disclose(params, signer, txOptions) {
-    const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "disclose");
-    const tx = callUnsafeTx(entry, {
-      commitment: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.commitment)),
-      proof_bytes: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.proofBytes)),
-      public_signals: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.publicSignals)),
-      auditor: params.auditor
-    });
-    return toTxResult(
-      await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
-    );
-  }
-  /**
-   * Rejects a pending disclosure request from an auditor for a specific commitment.
-   * Extrinsic: shieldedPool.reject_disclosure(auditor, commitment, reason)
-   */
-  async rejectDisclosure(params, signer, txOptions) {
-    const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "reject_disclosure");
-    const tx = callUnsafeTx(entry, {
-      auditor: params.auditor,
-      commitment: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.commitment)),
-      reason: import_polkadot_api2.Binary.fromText(params.reason)
-    });
-    return toTxResult(
-      await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
-    );
-  }
-  /**
-   * Cleans up a disclosure request that has passed its expiration block.
-   * Permissionless — any account can prune expired requests.
-   * Extrinsic: shieldedPool.prune_expired_request(target, auditor, commitment)
-   */
-  async pruneExpiredRequest(params, signer, txOptions) {
-    const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "prune_expired_request");
-    const tx = callUnsafeTx(entry, {
-      target: params.target,
-      auditor: params.auditor,
-      commitment: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.commitment))
-    });
-    return toTxResult(
-      await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
-    );
-  }
-  /**
-   * Revokes a previously submitted voluntary disclosure record.
-   * Only applies to self-disclosures (auditor = None). Auditor-requested records are permanent.
-   * Extrinsic: shieldedPool.revoke_disclosure_record(commitment)
-   */
-  async revokeDisclosureRecord(params, signer, txOptions) {
-    const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "revoke_disclosure_record");
-    const tx = callUnsafeTx(entry, {
-      commitment: import_polkadot_api2.Binary.fromBytes(new Uint8Array(params.commitment))
+      encrypted_memo: params.encryptedMemo,
+      proof: params.proof,
+      public_signals: params.publicSignals
     });
     return toTxResult(
       await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
@@ -2317,12 +2266,7 @@ var AccountMappingModule = class {
    */
   async addChainLink(params, signer) {
     const entry = resolveTx(this.substrate.unsafe, "accountMapping", "addChainLink");
-    const tx = callUnsafeTx(
-      entry,
-      params.chainId,
-      import_polkadot_api3.Binary.fromBytes(params.address),
-      import_polkadot_api3.Binary.fromBytes(params.signature)
-    );
+    const tx = callUnsafeTx(entry, params.chainId, params.address, params.signature);
     return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
@@ -2393,14 +2337,30 @@ var AccountMappingModule = class {
       entry,
       params.owner,
       params.chainId,
-      import_polkadot_api3.Binary.fromBytes(params.address),
-      import_polkadot_api3.Binary.fromBytes(params.signature),
-      import_polkadot_api3.Binary.fromBytes(params.callData)
+      params.address,
+      params.signature,
+      params.callData
     );
     return toTxResult(await tx.signAndSubmit(signer));
   }
 };
 
+// src/rpc-v2/ChainModule.ts
+var ChainModule = class {
+  constructor(substrate) {
+    this.substrate = substrate;
+  }
+  substrate;
+  /**
+   * Returns `true` if the given SS58 account is an active Aura validator.
+   *
+   * Reads `pallet_aura::Authorities` directly from storage at the best known block.
+   */
+  async isValidator(ss58Address) {
+    return this.substrate.request("chain_isValidator", [ss58Address]);
+  }
+};
+
 // src/rpc-v2/helpers.ts
 function mapAssetBalance(balance) {
   return {
@@ -2761,14 +2721,8 @@ var SP_SEL = {
   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]),
-  // requestDisclosure(bytes32,bytes32,bool,bool,bool,bytes,bytes32,bytes32)      → 0xe7022933  (caller = auditor)
-  REQUEST_DISCLOSURE: new Uint8Array([231, 2, 41, 51]),
-  // disclose(bytes32,bytes,bytes,bytes32)                                        → 0xea8a4165  (caller = note owner)
-  DISCLOSE: new Uint8Array([234, 138, 65, 101]),
-  // rejectDisclosure(bytes32,bytes32,bytes)                                      → 0x72b895a9  (caller = target)
-  REJECT_DISCLOSURE: new Uint8Array([114, 184, 149, 169]),
-  // pruneExpiredRequest(bytes32,bytes32,bytes32)                                 → 0x0c338dcf  (permissionless)
-  PRUNE_EXPIRED_REQUEST: new Uint8Array([12, 51, 141, 207])
+  // claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)                → 0x42e1e74c
+  CLAIM_SHIELDED_FEES: new Uint8Array([66, 225, 231, 76])
 };
 var KNOWN_PRECOMPILES = {
   // ── Ethereum standard (EIP) ─────────────────────────────────────────────
@@ -2814,10 +2768,7 @@ var KNOWN_PRECOMPILES = {
       "9feb22ea": "shield(uint32,bytes32,bytes)",
       "8c0f5d24": "privateTransfer(bytes,bytes32,bytes32[],bytes32[],bytes[],uint32,uint256)",
       d21d9a79: "unshield(bytes,bytes32,bytes32,uint32,uint256,bytes32,uint256,bytes32)",
-      e7022933: "requestDisclosure(bytes32,bytes32,bool,bool,bool,bytes,bytes32,bytes32)",
-      ea8a4165: "disclose(bytes32,bytes,bytes,bytes32)",
-      "72b895a9": "rejectDisclosure(bytes32,bytes32,bytes)",
-      "0c338dcf": "pruneExpiredRequest(bytes32,bytes32,bytes32)"
+      "42e1e74c": "claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)"
     }
   }
 };
@@ -2980,132 +2931,77 @@ var ShieldedPoolPrecompile = class {
       data: this.buildUnshieldCalldata(params)
     });
   }
-  // ─── requestDisclosure ─────────────────────────────────────────────────────
+  // ─── claimShieldedFees ───────────────────────────────────────────────────────────────────
   /**
    * Returns the ABI-encoded calldata for
-   * `requestDisclosure(bytes32,bytes32,bool,bool,bool,bytes,bytes32,bytes32)`.
+   * `claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)`.
    *
-   * The **EVM caller** of the resulting transaction is treated as the **auditor**
-   * on-chain. No explicit auditor argument is needed.
-   */
-  buildRequestDisclosureCalldata(params) {
-    if (params.auditorBjjPkX.length !== 32)
-      throw new RangeError("requestDisclosure: auditorBjjPkX must be 32 bytes");
-    if (params.auditorBjjPkY.length !== 32)
-      throw new RangeError("requestDisclosure: auditorBjjPkY must be 32 bytes");
-    const target = fromHex(params.target);
-    const commitment = fromHex(params.commitment);
-    const reasonBytes = new TextEncoder().encode(params.reason);
-    return encodeHex(
-      SP_SEL.REQUEST_DISCLOSURE,
-      { type: "bytes32", value: target },
-      { type: "bytes32", value: commitment },
-      { type: "bool", value: params.disclosedValue },
-      { type: "bool", value: params.disclosedAssetId },
-      { type: "bool", value: params.disclosedOwner },
-      { type: "bytes", value: reasonBytes },
-      { type: "bytes32", value: params.auditorBjjPkX },
-      { type: "bytes32", value: params.auditorBjjPkY }
-    );
-  }
-  /**
-   * Requests selective disclosure of a specific commitment.
-   *
-   * The EVM caller is recorded as the auditor on-chain. The note owner can
-   * respond with `disclose()` or reject with `rejectDisclosure()`.
+   * ABI layout (params after selector):
+   * - `commitment`    — bytes32 (fixed)
+   * - `amount`        — uint256 (fixed)
+   * - `asset_id`      — uint32  (fixed, right-aligned)
+   * - `memo`          — bytes   (dynamic)
+   * - `proof`         — bytes   (dynamic, 128 bytes Groth16)
+   * - `publicSignals` — bytes   (dynamic, 76 bytes)
    *
-   * Extrinsic: `shieldedPool.requestDisclosure(target, commitment, requiredFields, reason, bjjPkX, bjjPkY)`
+   * The validator identity is derived from `msg.sender` in the precompile —
+   * do NOT include it in the calldata.
    */
-  async requestDisclosure(params, signer) {
-    return signer({ to: this.addr, data: this.buildRequestDisclosureCalldata(params) });
-  }
-  // ─── disclose ──────────────────────────────────────────────────────────────
-  /**
-   * Returns the ABI-encoded calldata for `disclose(bytes32,bytes,bytes,bytes32)`.
-   *
-   * The **EVM caller** is treated as the **note owner** on-chain.
-   * `params.proofBytes` must be exactly 128 bytes; `params.publicSignals` exactly 256 bytes.
-   */
-  buildDiscloseCalldata(params) {
-    if (params.proofBytes.length !== 128)
-      throw new RangeError("disclose: proofBytes must be exactly 128 bytes");
-    if (params.publicSignals.length !== 256)
-      throw new RangeError("disclose: publicSignals must be exactly 256 bytes");
-    const commitment = fromHex(params.commitment);
-    const auditor = fromHex(params.auditor);
-    return encodeHex(
-      SP_SEL.DISCLOSE,
-      { type: "bytes32", value: commitment },
-      { type: "bytes", value: params.proofBytes },
-      { type: "bytes", value: params.publicSignals },
-      { type: "bytes32", value: auditor }
+  buildClaimShieldedFeesCalldata(params) {
+    EncryptedMemo.validate(
+      params.encryptedMemo,
+      "buildClaimShieldedFeesCalldata.encryptedMemo"
     );
-  }
-  /**
-   * Submits a selective disclosure proof for a commitment.
-   *
-   * The EVM caller is treated as the note owner on-chain. The Groth16 proof is
-   * verified by the runtime; on success the encrypted signals are stored for
-   * the auditor to decrypt off-chain.
-   *
-   * Extrinsic: `shieldedPool.disclose(commitment, proofBytes, publicSignals, auditor)`
-   */
-  async disclose(params, signer) {
-    return signer({ to: this.addr, data: this.buildDiscloseCalldata(params) });
-  }
-  // ─── rejectDisclosure ──────────────────────────────────────────────────────
-  /**
-   * Returns the ABI-encoded calldata for `rejectDisclosure(bytes32,bytes32,bytes)`.
-   *
-   * The **EVM caller** is treated as the **target** (note owner) on-chain.
-   */
-  buildRejectDisclosureCalldata(params) {
-    const auditor = fromHex(params.auditor);
+    if (params.proof.length === 0) {
+      throw new Error("claimShieldedFees: proof must not be empty");
+    }
+    if (params.publicSignals.length !== 76) {
+      throw new Error(
+        `claimShieldedFees: publicSignals must be 76 bytes, got ${params.publicSignals.length}`
+      );
+    }
     const commitment = fromHex(params.commitment);
-    const reasonBytes = new TextEncoder().encode(params.reason);
     return encodeHex(
-      SP_SEL.REJECT_DISCLOSURE,
-      { type: "bytes32", value: auditor },
+      SP_SEL.CLAIM_SHIELDED_FEES,
       { type: "bytes32", value: commitment },
-      { type: "bytes", value: reasonBytes }
+      { type: "uint", value: params.amount },
+      { type: "uint", value: BigInt(params.assetId) },
+      { type: "bytes", value: params.encryptedMemo },
+      { type: "bytes", value: params.proof },
+      { type: "bytes", value: params.publicSignals }
     );
   }
   /**
-   * Rejects a pending disclosure request.
+   * Claims accumulated relay fees as a private shielded note.
    *
-   * The EVM caller is treated as the note owner (target) on-chain.
+   * This extrinsic is for **validators/relayers** who have accrued fees in
+   * `pallet-relayer` and want to receive them privately inside the shielded pool
+   * instead of as a public balance credit.
    *
-   * Extrinsic: `shieldedPool.rejectDisclosure(auditor, commitment, reason)`
-   */
-  async rejectDisclosure(params, signer) {
-    return signer({ to: this.addr, data: this.buildRejectDisclosureCalldata(params) });
-  }
-  // ─── pruneExpiredRequest ───────────────────────────────────────────────────
-  /**
-   * Returns the ABI-encoded calldata for `pruneExpiredRequest(bytes32,bytes32,bytes32)`.
+   * The ZK `value_proof` binds `commitment` to `(amount, assetId, ownerPk, blinding)`
+   * so the runtime can verify the note encodes exactly the claimed fee amount,
+   * preventing a malicious relayer from inflating the withdrawal.
    *
-   * Permissionless: any EVM caller can prune an expired request.
+   * The `msg.sender` EVM address is used as the validator identity; it must match
+   * the address that has pending relay fees in `pallet-relayer`.
+   *
+   * Extrinsic: `shieldedPool.claim_shielded_fees(commitment, amount, assetId, memo, proof, publicSignals)`
    */
-  buildPruneExpiredRequestCalldata(params) {
-    const target = fromHex(params.target);
-    const auditor = fromHex(params.auditor);
-    const commitment = fromHex(params.commitment);
-    return encodeHex(
-      SP_SEL.PRUNE_EXPIRED_REQUEST,
-      { type: "bytes32", value: target },
-      { type: "bytes32", value: auditor },
-      { type: "bytes32", value: commitment }
-    );
+  async claimShieldedFees(params, signer) {
+    return signer({
+      to: this.addr,
+      data: this.buildClaimShieldedFeesCalldata(params)
+    });
   }
   /**
-   * Removes an expired disclosure request from storage.
-   *
-   * Permissionless: any EVM account can call this once `expires_at` has passed.
-   *
-   * Extrinsic: `shieldedPool.pruneExpiredRequest(target, auditor, commitment)`
+   * Estimates the EVM gas for a `claimShieldedFees` call.
    */
-  async pruneExpiredRequest(params, signer) {
-    return signer({ to: this.addr, data: this.buildPruneExpiredRequestCalldata(params) });
+  async estimateClaimShieldedFeesGas(params, from) {
+    return this.evm.estimateGas({
+      from,
+      to: this.addr,
+      data: this.buildClaimShieldedFeesCalldata(params)
+    });
   }
 };
 
@@ -3506,6 +3402,8 @@ var OrbinumClient = class _OrbinumClient {
   accountMapping;
   /** Typed access to `privacy_*` custom RPC endpoints. */
   privacy;
+  /** Typed access to general chain state via `chain_*` custom RPC endpoints. */
+  chain;
   /** Typed access to `zkVerifier_*` custom RPC endpoints. */
   zkVerifier;
   /** Typed access to `relayer_*` RPC endpoints (registry lookup and pending fee queries). */
@@ -3524,6 +3422,7 @@ var OrbinumClient = class _OrbinumClient {
     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.relayerStatus = new RelayerStatusModule(substrate);
     this.precompiles = evm ? {
@@ -4114,6 +4013,56 @@ function tryDecryptNoteVerbose(commitment, viewingSecretKey, spendingKey, ownOwn
   };
 }
 
+// src/shielded-pool/protocol/NoteDisclosure.ts
+var import_poseidon_lite3 = require("poseidon-lite");
+var PREFIX = "orbdisc:";
+var VERSION = 1;
+function toHex2(n) {
+  return "0x" + n.toString(16);
+}
+function fromHex2(s) {
+  return BigInt(s);
+}
+function createNoteDisclosureKey(note) {
+  const payload = {
+    v: VERSION,
+    c: toHex2(note.commitment),
+    val: toHex2(note.value),
+    aid: toHex2(note.assetId),
+    opk: toHex2(note.ownerPk),
+    bld: toHex2(note.blinding)
+  };
+  const json = JSON.stringify(payload);
+  const b64 = btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return PREFIX + b64;
+}
+function decodeNoteDisclosureKey(key) {
+  try {
+    if (!key.startsWith(PREFIX)) return null;
+    const b64 = key.slice(PREFIX.length).replace(/-/g, "+").replace(/_/g, "/");
+    const json = atob(b64);
+    const payload = JSON.parse(json);
+    if (payload.v !== VERSION) return null;
+    const disclosure = {
+      commitment: fromHex2(payload.c),
+      value: fromHex2(payload.val),
+      assetId: fromHex2(payload.aid),
+      ownerPk: fromHex2(payload.opk),
+      blinding: fromHex2(payload.bld)
+    };
+    const recomputed = (0, import_poseidon_lite3.poseidon4)([
+      disclosure.value,
+      disclosure.assetId,
+      disclosure.ownerPk,
+      disclosure.blinding
+    ]);
+    if (recomputed !== disclosure.commitment) return null;
+    return disclosure;
+  } catch {
+    return null;
+  }
+}
+
 // src/shielded-pool/protocol/coinSelection.ts
 var TRANSFER_TREE_DEPTH = 20;
 function selectNotes(notes, needed) {
@@ -4150,49 +4099,6 @@ function buildDummyTransferInput(assetId) {
   };
 }
 
-// src/shielded-pool/protocol/disclosure.ts
-var import_proof_generator = require("@orbinum/proof-generator");
-var import_baby_jubjub5 = require("@zk-kit/baby-jubjub");
-var import_poseidon_lite3 = require("poseidon-lite");
-function hexFieldToBytes32(hex) {
-  const clean = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
-  return fromHex(clean.padStart(64, "0"));
-}
-function deriveBabyJubjubKeypair(substrateSigningKey) {
-  let keyBigInt = 0n;
-  for (let i = 0; i < substrateSigningKey.length; i++) {
-    keyBigInt = keyBigInt << 8n | BigInt(substrateSigningKey[i]);
-  }
-  const sk = (0, import_poseidon_lite3.poseidon1)([keyBigInt]);
-  const pk = (0, import_baby_jubjub5.mulPointEscalar)(import_baby_jubjub5.Base8, sk);
-  return { sk, pkX: pk[0], pkY: pk[1] };
-}
-function buildDisclosurePublicSignals(commitment, auditorPkX, auditorPkY, proofOutput) {
-  const buf = new Uint8Array(256);
-  buf.set(hexFieldToBytes32(commitment), 0);
-  buf.set(bigintTo32Le(auditorPkX), 32);
-  buf.set(bigintTo32Le(auditorPkY), 64);
-  buf.set(hexFieldToBytes32(proofOutput.encryptedData.epkX), 96);
-  buf.set(hexFieldToBytes32(proofOutput.encryptedData.epkY), 128);
-  buf.set(hexFieldToBytes32(proofOutput.encryptedData.encValue), 160);
-  buf.set(hexFieldToBytes32(proofOutput.encryptedData.encAssetId), 192);
-  buf.set(hexFieldToBytes32(proofOutput.encryptedData.encOwnerHash), 224);
-  return Array.from(buf);
-}
-function decryptDisclosureSignals(auditorBjjSk, enc) {
-  const shared = (0, import_baby_jubjub5.mulPointEscalar)([enc.epkX, enc.epkY], auditorBjjSk);
-  const sharedX = shared[0];
-  const sharedY = shared[1];
-  const k0 = (0, import_poseidon_lite3.poseidon3)([sharedX, sharedY, 0n]);
-  const k1 = (0, import_poseidon_lite3.poseidon3)([sharedX, sharedY, 1n]);
-  const k2 = (0, import_poseidon_lite3.poseidon3)([sharedX, sharedY, 2n]);
-  return {
-    value: (enc.encValue - k0 + BN254_R) % BN254_R,
-    assetId: (enc.encAssetId - k1 + BN254_R) % BN254_R,
-    ownerHash: (enc.encOwnerHash - k2 + BN254_R) % BN254_R
-  };
-}
-
 // src/utils/blinding.ts
 function randomBlinding() {
   const buf = new Uint8Array(32);
@@ -4204,7 +4110,7 @@ function randomBlinding() {
 // src/privacy-keys/PrivacyKeys.ts
 var import_hkdf2 = require("@noble/hashes/hkdf.js");
 var import_sha23 = require("@noble/hashes/sha2.js");
-var import_baby_jubjub6 = require("@zk-kit/baby-jubjub");
+var import_baby_jubjub5 = require("@zk-kit/baby-jubjub");
 var IVK_DOMAIN = new TextEncoder().encode("orbinum-ivk-v1");
 function deriveSpendingKeyMessage(chainId, address) {
   return `orbinum-spending-key-v1
@@ -4227,13 +4133,13 @@ function deriveViewingSecretKey(spendingKey) {
 }
 function deriveViewingPublicKey(ivsk) {
   const ivskScalar = BigInt(toHex(ivsk)) % BABYJUB_SUBORDER || 1n;
-  const ivkPoint = (0, import_baby_jubjub6.mulPointEscalar)(import_baby_jubjub6.Base8, ivskScalar);
-  const packed = (0, import_baby_jubjub6.packPoint)(ivkPoint);
+  const ivkPoint = (0, import_baby_jubjub5.mulPointEscalar)(import_baby_jubjub5.Base8, ivskScalar);
+  const packed = (0, import_baby_jubjub5.packPoint)(ivkPoint);
   return bigintTo32Le(packed);
 }
 function deriveOwnerPk(spendingKey) {
   try {
-    const pubPoint = (0, import_baby_jubjub6.mulPointEscalar)(import_baby_jubjub6.Base8, spendingKey);
+    const pubPoint = (0, import_baby_jubjub5.mulPointEscalar)(import_baby_jubjub5.Base8, spendingKey);
     return pubPoint[0];
   } catch {
     return 0n;
@@ -4504,9 +4410,9 @@ async function decryptNoteRecord(key, rec) {
 }
 
 // src/proof-generator/unshield.ts
-var import_proof_generator2 = require("@orbinum/proof-generator");
+var import_proof_generator = require("@orbinum/proof-generator");
 var import_utils3 = require("@noble/ciphers/utils.js");
-var import_baby_jubjub7 = require("@zk-kit/baby-jubjub");
+var import_baby_jubjub6 = require("@zk-kit/baby-jubjub");
 var import_poseidon_lite4 = require("poseidon-lite");
 
 // src/proof-generator/merkle.ts
@@ -4529,7 +4435,7 @@ async function generateUnshieldProof(inputs, options = {}) {
   if (changeValue < 0n) {
     throw new Error("changeValue must be >= 0.");
   }
-  const changeOwnerPubkey = inputs.changeOwnerPubkey ?? (0, import_baby_jubjub7.mulPointEscalar)(import_baby_jubjub7.Base8, inputs.spendingKey)[0];
+  const changeOwnerPubkey = inputs.changeOwnerPubkey ?? (0, import_baby_jubjub6.mulPointEscalar)(import_baby_jubjub6.Base8, inputs.spendingKey)[0];
   const changeBlinding = inputs.changeBlinding ?? (changeValue > 0n ? bytesToBigintLE((0, import_utils3.randomBytes)(32)) : 0n);
   const changeCommitment = changeValue > 0n ? (0, import_poseidon_lite4.poseidon4)([changeValue, inputs.assetId, changeOwnerPubkey, changeBlinding]) : 0n;
   const circuitInputs = {
@@ -4550,15 +4456,15 @@ async function generateUnshieldProof(inputs, options = {}) {
     change_blinding: changeBlinding.toString(),
     change_owner_pubkey: changeOwnerPubkey.toString()
   };
-  const provider = options.provider ?? new import_proof_generator2.WebArtifactProvider();
+  const provider = options.provider ?? new import_proof_generator.WebArtifactProvider();
   const opts = { provider };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  const proofResult = await (0, import_proof_generator2.generateProof)(import_proof_generator2.CircuitType.Unshield, circuitInputs, opts);
+  const proofResult = await (0, import_proof_generator.generateProof)(import_proof_generator.CircuitType.Unshield, circuitInputs, opts);
   return { ...proofResult, changeCommitment, changeValue, changeBlinding, changeOwnerPubkey };
 }
 
 // src/proof-generator/transfer.ts
-var import_proof_generator3 = require("@orbinum/proof-generator");
+var import_proof_generator2 = require("@orbinum/proof-generator");
 async function generateTransferProof(params, options = {}) {
   const root = leHexToBigint(params.merkleRoot).toString();
   const [i0, i1] = params.inputs;
@@ -4583,47 +4489,38 @@ 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_generator3.WebArtifactProvider();
+  const provider = options.provider ?? new import_proof_generator2.WebArtifactProvider();
   const opts = { provider };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  return (0, import_proof_generator3.generateProof)(import_proof_generator3.CircuitType.Transfer, circuitInputs, opts);
+  return (0, import_proof_generator2.generateProof)(import_proof_generator2.CircuitType.Transfer, circuitInputs, opts);
 }
 
 // src/proof-generator/fee-claim.ts
-var import_proof_generator4 = require("@orbinum/proof-generator");
-function hexSignalToBytes(hex) {
-  const clean = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
-  const padded = clean.padStart(64, "0");
-  const bytes = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
+var import_proof_generator3 = require("@orbinum/proof-generator");
 async function generateFeeClaimProof(inputs, options = {}) {
-  const result = await (0, import_proof_generator4.generateDisclosureProof)(
-    inputs.amount,
-    inputs.ownerPubkey,
-    inputs.blinding,
-    inputs.assetId,
-    inputs.commitment,
-    // Baby Jubjub base point G — placeholder, no real auditor for fee claiming
-    5299619240641551281634865583518297030282874472190772894086521144482721001553n,
-    16950150798460657717958625567821834550301663161624707787222815936182638968203n,
-    1n,
-    // r — placeholder ephemeral scalar (NOT cryptographically secure)
-    { discloseValue: true, discloseAssetId: true, discloseOwner: false },
-    options
-  );
-  const [, , sigEncValue, sigEncAssetId, sigEncOwnerHash, sigCommitment] = result.publicSignals.map(hexSignalToBytes);
-  const compact = new Uint8Array(76);
-  compact.set(sigCommitment);
-  compact.set(sigEncValue.subarray(0, 8), 32);
-  compact.set(sigEncAssetId.subarray(0, 4), 40);
-  compact.set(sigEncOwnerHash, 44);
+  if (inputs.amount <= 0n) {
+    throw new Error("Fee claim amount must be greater than zero.");
+  }
+  const circuitInputs = {
+    commitment: inputs.commitment.toString(),
+    value: inputs.amount.toString(),
+    asset_id: inputs.assetId.toString(),
+    owner_pubkey: inputs.ownerPubkey.toString(),
+    blinding: inputs.blinding.toString()
+  };
+  const provider = options.provider ?? new import_proof_generator3.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 [sigCommitment, sigValue, sigAssetId, sigOwnerHash] = proofResult.publicSignals.map(BigInt);
+  const buf = new Uint8Array(76);
+  buf.set(bigintTo32Le(sigCommitment), 0);
+  buf.set(bigintTo32Le(sigValue).subarray(0, 8), 32);
+  buf.set(bigintTo32Le(sigAssetId).subarray(0, 4), 40);
+  buf.set(bigintTo32Le(sigOwnerHash), 44);
   return {
-    proof: result.proof,
-    publicSignals: Array.from(compact)
+    proof: proofResult.proof,
+    publicSignals: Array.from(buf)
   };
 }
 
@@ -4693,6 +4590,17 @@ function decodePrecompileCalldata(address, input) {
       return { fnSig, args: {} };
     }
   }
+  if (fnSig.startsWith("claimShieldedFees(")) {
+    try {
+      const data = fromHex(input.slice(10));
+      const commitment = toHex(data.slice(0, 32));
+      const amount = decodeUint(data, 32);
+      const assetId = decodeUint(data, 64);
+      return { fnSig, args: { commitment, amount, assetId } };
+    } catch {
+      return { fnSig, args: {} };
+    }
+  }
   return { fnSig, args: {} };
 }
 
@@ -4700,8 +4608,8 @@ function decodePrecompileCalldata(address, input) {
 var CircuitId = {
   Transfer: 1,
   Unshield: 2,
-  Disclosure: 3,
-  PrivateLink: 4
+  ValueProof: 4,
+  PrivateLink: 5
 };
 
 // src/utils/string.ts
@@ -4890,39 +4798,6 @@ function mapExtrinsicArgs(section, method, args) {
         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"),
-        commitment: get(1, "commitment"),
-        required_fields: get(2, "required_fields"),
-        reason: get(3, "reason"),
-        auditor_bjj_pk_x: get(4, "auditor_bjj_pk_x"),
-        auditor_bjj_pk_y: get(5, "auditor_bjj_pk_y")
-      };
-    }
-    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"),
-        commitment: get(1, "commitment"),
-        reason: get(2, "reason")
-      };
-    }
     if (m_norm === "registerasset") {
       return {
         name: get(0, "name"),
@@ -4937,19 +4812,6 @@ function mapExtrinsicArgs(section, method, args) {
     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"),
-        commitment: get(2, "commitment")
-      };
-    }
-    if (m_norm === "revokedisclosurerecord") {
-      return { commitment: get(0, "commitment") };
-    }
   }
   if (s === "ethereum" && m === "transact") {
     return { transaction: get(0, "transaction") };
@@ -5173,51 +5035,6 @@ function mapZkEventData(method, data) {
     };
   }
   const m_norm = m.replace(/_/g, "");
-  if (m_norm === "auditpolicyset") {
-    return {
-      account: get(0, "account"),
-      version: get(1, "version")
-    };
-  }
-  if (m_norm === "disclosed") {
-    return {
-      target: get(0, "target"),
-      auditor: get(1, "auditor"),
-      commitment: get(2, "commitment"),
-      signals: get(3, "signals")
-    };
-  }
-  if (m_norm === "disclosurerequested") {
-    return {
-      target: get(0, "target"),
-      auditor: get(1, "auditor"),
-      commitment: get(2, "commitment"),
-      required_fields: get(3, "required_fields"),
-      auditor_bjj_pk_x: get(4, "auditor_bjj_pk_x"),
-      auditor_bjj_pk_y: get(5, "auditor_bjj_pk_y")
-    };
-  }
-  if (m_norm === "disclosurerejected") {
-    return {
-      target: get(0, "target"),
-      auditor: get(1, "auditor"),
-      commitment: get(2, "commitment"),
-      reason: get(3, "reason")
-    };
-  }
-  if (m_norm === "disclosurerequestexpired") {
-    return {
-      target: get(0, "target"),
-      auditor: get(1, "auditor"),
-      commitment: get(2, "commitment")
-    };
-  }
-  if (m_norm === "disclosurerecordrevoked") {
-    return {
-      who: get(0, "who"),
-      commitment: get(1, "commitment")
-    };
-  }
   if (m_norm === "assetregistered") {
     return { asset_id: get(0, "asset_id") };
   }
@@ -5497,17 +5314,16 @@ var import_polkadot_api4 = require("polkadot-api");
   bigintTo32Be,
   bigintTo32Le,
   bigintTo32LeArr,
-  buildDisclosurePublicSignals,
   buildDummyTransferInput,
   bytesToBigintLE,
   computeNullifier,
   computePathIndices,
   connectInjectedExtension,
+  createNoteDisclosureKey,
+  decodeNoteDisclosureKey,
   decodePrecompileCalldata,
-  decryptDisclosureSignals,
   decryptJson,
   decryptNoteRecord,
-  deriveBabyJubjubKeypair,
   deriveMasterKeyBytes,
   deriveOwnerPk,
   deriveSpendingKeyFromSignature,
@@ -5528,7 +5344,6 @@ var import_polkadot_api4 = require("polkadot-api");
   formatORB,
   fromBase64,
   fromHex,
-  generateDisclosureProof,
   generateFeeClaimProof,
   generateTransferProof,
   generateUnshieldProof,