@orbinum/sdk 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   createClient,
   Binary
 } from "polkadot-api";
-import { getWsProvider } from "polkadot-api/ws-provider";
+import { getWsProvider } from "polkadot-api/ws";
 import { getDynamicBuilder, getLookupFn } from "@polkadot-api/metadata-builders";
 import { decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
 import { AccountId } from "@polkadot-api/substrate-bindings";
@@ -226,20 +226,20 @@ var SubstrateClient = class _SubstrateClient {
    * into a PAPI UnsafeTransaction that can be signed and submitted.
    */
   async txFromCallData(callData) {
-    return this._papi.getUnsafeApi().txFromCallData(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(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(Binary.fromHex(signedHex));
   }
   /**
    * Submits a bare (unsigned) extrinsic hex and waits for finalization.
@@ -247,7 +247,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(Binary.fromHex(bareTxHex));
   }
   /**
    * Convenience: wrap raw call bytes and sign+submit in one step.
@@ -1190,6 +1190,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() {
@@ -1672,7 +1712,7 @@ var ShieldedPoolModule = class {
       asset_id: params.assetId,
       amount: params.amount,
       commitment: Binary2.fromHex(params.commitment),
-      encrypted_memo: Binary2.fromBytes(params.encryptedMemo)
+      encrypted_memo: params.encryptedMemo
     });
     return toTxResult(
       await (txOptions !== void 0 ? tx.signAndSubmit(signer, txOptions) : tx.signAndSubmit(signer))
@@ -1692,12 +1732,12 @@ var ShieldedPoolModule = class {
     let changeEncryptedMemo;
     if (params.changeEncryptedMemo && params.changeEncryptedMemo.length > 0) {
       EncryptedMemo.validate(params.changeEncryptedMemo, "changeEncryptedMemo");
-      changeEncryptedMemo = Binary2.fromBytes(params.changeEncryptedMemo);
+      changeEncryptedMemo = params.changeEncryptedMemo;
     } else {
-      changeEncryptedMemo = Binary2.fromBytes(new Uint8Array(0));
+      changeEncryptedMemo = new Uint8Array(0);
     }
     const tx = callUnsafeTx(entry, {
-      proof: Binary2.fromBytes(params.proof),
+      proof: params.proof,
       merkle_root: Binary2.fromHex(params.merkleRoot),
       nullifier: Binary2.fromHex(params.nullifier),
       asset_id: params.assetId,
@@ -1730,11 +1770,11 @@ var ShieldedPoolModule = class {
         out.encryptedMemo,
         `privateTransfer.outputs[${i}].encryptedMemo`
       );
-      return Binary2.fromBytes(out.encryptedMemo);
+      return out.encryptedMemo;
     });
     const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "private_transfer");
     const tx = callUnsafeTx(entry, {
-      proof: Binary2.fromBytes(params.proof),
+      proof: params.proof,
       merkle_root: Binary2.fromHex(params.merkleRoot),
       nullifiers,
       commitments,
@@ -1762,7 +1802,7 @@ var ShieldedPoolModule = class {
         assetId: item.assetId,
         amount: item.amount.toString(),
         commitment: Binary2.fromHex(item.commitment),
-        encryptedMemo: Binary2.fromBytes(item.encryptedMemo)
+        encryptedMemo: item.encryptedMemo
       };
     });
     const entry = resolveTx(this.substrate.unsafe, "ShieldedPool", "shield_batch");
@@ -1774,7 +1814,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)
    */
@@ -1785,98 +1825,9 @@ var ShieldedPoolModule = class {
       commitment: Binary2.fromHex(params.commitment),
       amount: params.amount,
       asset_id: params.assetId,
-      encrypted_memo: Binary2.fromBytes(params.encryptedMemo),
-      proof: Binary2.fromBytes(params.proof),
-      public_signals: Binary2.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: Binary2.fromBytes(new Uint8Array(params.commitment)),
-      required_fields: {
-        value: params.requiredFields.value,
-        asset_id: params.requiredFields.assetId,
-        owner: params.requiredFields.owner
-      },
-      reason: Binary2.fromText(params.reason),
-      auditor_bjj_pk_x: Binary2.fromBytes(new Uint8Array(params.auditorBjjPkX)),
-      auditor_bjj_pk_y: Binary2.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: Binary2.fromBytes(new Uint8Array(params.commitment)),
-      proof_bytes: Binary2.fromBytes(new Uint8Array(params.proofBytes)),
-      public_signals: Binary2.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: Binary2.fromBytes(new Uint8Array(params.commitment)),
-      reason: Binary2.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: Binary2.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: Binary2.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))
@@ -2188,12 +2139,7 @@ var AccountMappingModule = class {
    */
   async addChainLink(params, signer) {
     const entry = resolveTx(this.substrate.unsafe, "accountMapping", "addChainLink");
-    const tx = callUnsafeTx(
-      entry,
-      params.chainId,
-      Binary3.fromBytes(params.address),
-      Binary3.fromBytes(params.signature)
-    );
+    const tx = callUnsafeTx(entry, params.chainId, params.address, params.signature);
     return toTxResult(await tx.signAndSubmit(signer));
   }
   /**
@@ -2264,14 +2210,30 @@ var AccountMappingModule = class {
       entry,
       params.owner,
       params.chainId,
-      Binary3.fromBytes(params.address),
-      Binary3.fromBytes(params.signature),
-      Binary3.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 {
@@ -2632,14 +2594,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) ─────────────────────────────────────────────
@@ -2685,10 +2641,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)"
     }
   }
 };
@@ -2851,132 +2804,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)`.
-   *
-   * 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.
+   * `claimShieldedFees(bytes32,uint256,uint32,bytes,bytes,bytes)`.
    *
-   * 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)
+    });
   }
 };
 
@@ -3377,6 +3275,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). */
@@ -3395,6 +3295,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 ? {
@@ -3985,6 +3886,56 @@ function tryDecryptNoteVerbose(commitment, viewingSecretKey, spendingKey, ownOwn
   };
 }
 
+// src/shielded-pool/protocol/NoteDisclosure.ts
+import { poseidon4 as poseidon43 } from "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 = poseidon43([
+      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) {
@@ -4021,51 +3972,6 @@ function buildDummyTransferInput(assetId) {
   };
 }
 
-// src/shielded-pool/protocol/disclosure.ts
-import {
-  generateDisclosureProof
-} from "@orbinum/proof-generator";
-import { mulPointEscalar as mulPointEscalar5, Base8 as Base83 } from "@zk-kit/baby-jubjub";
-import { poseidon1, poseidon3 } from "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 = poseidon1([keyBigInt]);
-  const pk = mulPointEscalar5(Base83, 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 = mulPointEscalar5([enc.epkX, enc.epkY], auditorBjjSk);
-  const sharedX = shared[0];
-  const sharedY = shared[1];
-  const k0 = poseidon3([sharedX, sharedY, 0n]);
-  const k1 = poseidon3([sharedX, sharedY, 1n]);
-  const k2 = 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);
@@ -4077,7 +3983,7 @@ function randomBlinding() {
 // src/privacy-keys/PrivacyKeys.ts
 import { hkdf as hkdf2 } from "@noble/hashes/hkdf.js";
 import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
-import { mulPointEscalar as mulPointEscalar6, Base8 as Base84, packPoint as packPoint2 } from "@zk-kit/baby-jubjub";
+import { mulPointEscalar as mulPointEscalar5, Base8 as Base83, packPoint as packPoint2 } from "@zk-kit/baby-jubjub";
 var IVK_DOMAIN = new TextEncoder().encode("orbinum-ivk-v1");
 function deriveSpendingKeyMessage(chainId, address) {
   return `orbinum-spending-key-v1
@@ -4100,13 +4006,13 @@ function deriveViewingSecretKey(spendingKey) {
 }
 function deriveViewingPublicKey(ivsk) {
   const ivskScalar = BigInt(toHex(ivsk)) % BABYJUB_SUBORDER || 1n;
-  const ivkPoint = mulPointEscalar6(Base84, ivskScalar);
+  const ivkPoint = mulPointEscalar5(Base83, ivskScalar);
   const packed = packPoint2(ivkPoint);
   return bigintTo32Le(packed);
 }
 function deriveOwnerPk(spendingKey) {
   try {
-    const pubPoint = mulPointEscalar6(Base84, spendingKey);
+    const pubPoint = mulPointEscalar5(Base83, spendingKey);
     return pubPoint[0];
   } catch {
     return 0n;
@@ -4383,8 +4289,8 @@ import {
   WebArtifactProvider
 } from "@orbinum/proof-generator";
 import { randomBytes as randomBytes3 } from "@noble/ciphers/utils.js";
-import { mulPointEscalar as mulPointEscalar7, Base8 as Base85 } from "@zk-kit/baby-jubjub";
-import { poseidon4 as poseidon43 } from "poseidon-lite";
+import { mulPointEscalar as mulPointEscalar6, Base8 as Base84 } from "@zk-kit/baby-jubjub";
+import { poseidon4 as poseidon44 } from "poseidon-lite";
 
 // src/proof-generator/merkle.ts
 function merkleProofToCircuit(siblings, leafIndex) {
@@ -4406,9 +4312,9 @@ async function generateUnshieldProof(inputs, options = {}) {
   if (changeValue < 0n) {
     throw new Error("changeValue must be >= 0.");
   }
-  const changeOwnerPubkey = inputs.changeOwnerPubkey ?? mulPointEscalar7(Base85, inputs.spendingKey)[0];
+  const changeOwnerPubkey = inputs.changeOwnerPubkey ?? mulPointEscalar6(Base84, inputs.spendingKey)[0];
   const changeBlinding = inputs.changeBlinding ?? (changeValue > 0n ? bytesToBigintLE(randomBytes3(32)) : 0n);
-  const changeCommitment = changeValue > 0n ? poseidon43([changeValue, inputs.assetId, changeOwnerPubkey, changeBlinding]) : 0n;
+  const changeCommitment = changeValue > 0n ? poseidon44([changeValue, inputs.assetId, changeOwnerPubkey, changeBlinding]) : 0n;
   const circuitInputs = {
     merkle_root: leHexToBigint(inputs.merkleRoot).toString(),
     nullifier: inputs.nullifier.toString(),
@@ -4472,41 +4378,34 @@ async function generateTransferProof(params, options = {}) {
 
 // src/proof-generator/fee-claim.ts
 import {
-  generateDisclosureProof as generateDisclosureProof2
+  CircuitType as CircuitType3,
+  generateProof as generateProof3,
+  WebArtifactProvider as WebArtifactProvider3
 } from "@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;
-}
 async function generateFeeClaimProof(inputs, options = {}) {
-  const result = await generateDisclosureProof2(
-    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 WebArtifactProvider3();
+  const opts = { provider };
+  if (options.verbose !== void 0) opts.verbose = options.verbose;
+  const proofResult = await generateProof3(CircuitType3.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)
   };
 }
 
@@ -4576,6 +4475,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: {} };
 }
 
@@ -4583,8 +4493,8 @@ function decodePrecompileCalldata(address, input) {
 var CircuitId = {
   Transfer: 1,
   Unshield: 2,
-  Disclosure: 3,
-  PrivateLink: 4
+  ValueProof: 4,
+  PrivateLink: 5
 };
 
 // src/utils/string.ts
@@ -4773,39 +4683,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"),
@@ -4820,19 +4697,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") };
@@ -5056,51 +4920,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") };
   }
@@ -5390,17 +5209,16 @@ export {
   bigintTo32Be,
   bigintTo32Le,
   bigintTo32LeArr,
-  buildDisclosurePublicSignals,
   buildDummyTransferInput,
   bytesToBigintLE,
   computeNullifier,
   computePathIndices,
   connectInjectedExtension,
+  createNoteDisclosureKey,
+  decodeNoteDisclosureKey,
   decodePrecompileCalldata,
-  decryptDisclosureSignals,
   decryptJson,
   decryptNoteRecord,
-  deriveBabyJubjubKeypair,
   deriveMasterKeyBytes,
   deriveOwnerPk,
   deriveSpendingKeyFromSignature,
@@ -5421,7 +5239,6 @@ export {
   formatORB,
   fromBase64,
   fromHex,
-  generateDisclosureProof,
   generateFeeClaimProof,
   generateTransferProof,
   generateUnshieldProof,