@fairblock/stabletrust 1.0.17 → 1.0.18

package/examples/complete-flow.js

@@ -11,203 +11,375 @@ dotenv.config();
  * https://docs.fairblock.network/docs/confidential_transfers/technical_overview
  */
 
-// Standard ERC20 token contract. Any ERC20 on this chain ID can be used.
-const TOKEN_ADDRESS =
-  process.env.TOKEN_ADDRESS || "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9";
-const RPC_URL =
-  process.env.ETHEREUM_RPC_URL || "https://rpc.testnet.stable.xyz";
-const EXPLORER_URL =
-  process.env.EXPLORER_URL || "https://testnet.stablescan.xyz/tx/";
-const CHAIN_ID = process.env.CHAIN_ID || 2201;
+const CHAINS = [
+  {
+    network: "Stable",
+    chainId: 2201,
+    tokenAddress: "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9",
+    rpcUrl: "https://rpc.testnet.stable.xyz",
+    explorerUrl: "https://testnet.stablescan.xyz/tx/",
+  },
+  {
+    network: "Arc",
+    chainId: 1244,
+    tokenAddress: "0x3600000000000000000000000000000000000000",
+    rpcUrl: "https://rpc.testnet.arc.network",
+    explorerUrl: "https://testnet.arcscan.app/tx/",
+  },
+  {
+    network: "Base",
+    chainId: 84532,
+    tokenAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    rpcUrl: "https://base-testnet.api.pocket.network",
+    explorerUrl: "https://sepolia.basescan.org/tx/",
+  },
+  {
+    network: "Ethereum",
+    chainId: 11155111,
+    tokenAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    explorerUrl: "https://sepolia.etherscan.io/tx/",
+  },
+  {
+    network: "Arbitrum",
+    chainId: 421614,
+    tokenAddress: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    rpcUrl: "https://arbitrum-sepolia-testnet.api.pocket.network",
+    explorerUrl: "https://sepolia.arbiscan.io/tx/",
+  },
+  {
+    network: "Tempo",
+    chainId: 42431,
+    tokenAddress: "0x20c0000000000000000000000000000000000000",
+    rpcUrl: "https://rpc.moderato.tempo.xyz",
+    explorerUrl: "https://explore.tempo.xyz/tx/",
+  },
+];
+
+const actionSummary = [];
 
 /**
- * Performance Utility: Tracks execution time and provides timestamps
+ * Performance Utility: Tracks execution time and provides timestamps and network congestion
  */
-async function trackPerformance(actionName, action) {
-  const timestamp = new Date().toISOString();
+async function trackPerformance(actionName, action, provider, chainNetwork) {
+  const startTimeMs = Date.now();
+  const startTimestamp = new Date(startTimeMs).toISOString();
   const start = performance.now();
+
   const result = await action();
+
   const end = performance.now();
+  const endTimeMs = Date.now();
+  const endTimestamp = new Date(endTimeMs).toISOString();
+
   const duration = ((end - start) / 1000).toFixed(3);
 
+  let congestionStr = "N/A";
+  let congestionInfo = "";
+  if (provider && result && (result.hash || result.transactionHash)) {
+    try {
+      const hash = result.hash || result.transactionHash;
+      // Wait for tx to be mined to be able to get block details
+      const receipt = await provider.waitForTransaction(hash, 1, 60000); // 60s timeout
+      if (receipt && receipt.blockNumber) {
+        const block = await provider.getBlock(receipt.blockNumber);
+        congestionStr = block.transactions.length;
+        congestionInfo = ` | Block TXs (Congestion): ${congestionStr}`;
+      }
+    } catch (e) {
+      congestionStr = "Unknown";
+      congestionInfo = " | Block TXs (Congestion): Unknown";
+    }
+  }
+
   console.log(`Action: ${actionName}`);
-  console.log(`Timestamp: ${timestamp}`);
-  console.log(`Duration: ${duration}s`);
+  console.log(`Started: ${startTimestamp}`);
+  console.log(`Duration: ${duration}s${congestionInfo}`);
+  console.log(`Completed: ${endTimestamp}`);
+
+  actionSummary.push({
+    Chain: chainNetwork,
+    Action: actionName,
+    "Duration (s)": duration,
+    Congestion: congestionStr,
+    "Started At": startTimestamp,
+    "Completed At": endTimestamp,
+  });
+
   return { result, duration };
 }
 
-async function main() {
-  console.log("=== Starting Confidential Flow Performance Test ===\n");
+async function runChainFlow(chain, senderPrivateKey, recipientPrivateKey) {
+  console.log(`\n======================================================`);
+  console.log(`=== Starting Confidential Flow for ${chain.network} ===`);
+  console.log(
+    `=== Chain ID: ${chain.chainId} | Token: ${chain.tokenAddress} ===`,
+  );
+  console.log(`======================================================\n`);
 
-  const client = new ConfidentialTransferClient(RPC_URL, Number(CHAIN_ID));
+  try {
+    const rpcUrl = chain.rpcUrl;
+    const explorerBaseUrl = chain.explorerUrl;
+    const client = new ConfidentialTransferClient(
+      rpcUrl,
+      Number(chain.chainId),
+    );
 
-  const provider = new ethers.JsonRpcProvider(RPC_URL);
-  const sender = new ethers.Wallet(process.env.SENDER_PRIVATE_KEY, provider);
-  const recipient = new ethers.Wallet(
-    process.env.RECIPIENT_PRIVATE_KEY,
-    provider,
-  );
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const sender = new ethers.Wallet(senderPrivateKey, provider);
+    const recipient = new ethers.Wallet(recipientPrivateKey, provider);
 
-  const tokenContract = new ethers.Contract(TOKEN_ADDRESS, ERC20_ABI, provider);
-  const tokenDecimals = await tokenContract.decimals();
+    const tokenContract = new ethers.Contract(
+      chain.tokenAddress,
+      ERC20_ABI,
+      provider,
+    );
+    const tokenDecimals = await tokenContract.decimals();
 
-  console.log("Sender Address:", sender.address);
-  console.log("Recipient Address:", recipient.address);
+    console.log("Sender Address:", sender.address);
+    console.log("Recipient Address:", recipient.address);
 
-  const senderKeys = await client.ensureAccount(sender);
-  const recipientKeys = await client.ensureAccount(recipient);
+    const senderKeysRes = await trackPerformance(
+      "ENSURE_SENDER_ACCOUNT",
+      () => client.ensureAccount(sender),
+      provider,
+      chain.network,
+    );
+    const senderKeys = senderKeysRes.result;
 
-  // 1. DEPOSIT PHASE
-  const depositAmount = ethers.parseUnits("0.1", tokenDecimals);
-  const senderConfidentialBalanceBefore = await client.getConfidentialBalance(
-    sender.address,
-    senderKeys.privateKey,
-    TOKEN_ADDRESS,
-  );
+    const recipientKeysRes = await trackPerformance(
+      "ENSURE_RECIPIENT_ACCOUNT",
+      () => client.ensureAccount(recipient),
+      provider,
+      chain.network,
+    );
+    const recipientKeys = recipientKeysRes.result;
 
-  console.log(
-    "Sender Confidential Balance (Pre-Deposit):",
-    ethers.formatUnits(senderConfidentialBalanceBefore.amount, tokenDecimals),
-  );
+    // 1. DEPOSIT PHASE
+    console.log("\n--- Phase 1: Deposit ---");
+    const depositAmount = ethers.parseUnits("0.1", tokenDecimals);
+    const senderConfidentialBalanceBefore = await client.getConfidentialBalance(
+      sender.address,
+      senderKeys.privateKey,
+      chain.tokenAddress,
+    );
 
-  console.log("Depositing 0.1 tokens into confidential contract...");
+    console.log(
+      "Sender Confidential Balance (Pre-Deposit):",
+      ethers.formatUnits(senderConfidentialBalanceBefore.amount, tokenDecimals),
+    );
 
-  const depRes = await trackPerformance("DEPOSIT_TOKENS", () =>
-    client.confidentialDeposit(sender, TOKEN_ADDRESS, depositAmount),
-  );
-  // Fixed hash reference: checking for result.transactionHash or result.hash
-  const depHash = depRes.result.hash;
-  console.log(`Transaction Hash: ${depHash}`);
-  console.log(`View Transaction: ${EXPLORER_URL}${depHash}`);
-
-  const senderConfidentialBalanceAfterDep = await client.getConfidentialBalance(
-    sender.address,
-    senderKeys.privateKey,
-    TOKEN_ADDRESS,
-  );
-  console.log(
-    "Sender Confidential Balance (Post-Deposit):",
-    ethers.formatUnits(senderConfidentialBalanceAfterDep.amount, tokenDecimals),
-  );
+    console.log("Depositing 0.1 tokens into confidential contract...");
 
-  // 2. TRANSFER PHASE
-  const transferAmount = ethers.parseUnits("0.05", tokenDecimals);
-  const senderConfidentialBalanceBeforeTx = await client.getConfidentialBalance(
-    sender.address,
-    senderKeys.privateKey,
-    TOKEN_ADDRESS,
-  );
+    const depRes = await trackPerformance(
+      "DEPOSIT_TOKENS",
+      () =>
+        client.confidentialDeposit(sender, chain.tokenAddress, depositAmount),
+      provider,
+      chain.network,
+    );
+    const depHash = depRes.result.hash || depRes.result.transactionHash;
+    console.log(`Transaction Hash: ${depHash}`);
+    console.log(`View Transaction: ${explorerBaseUrl}${depHash}`);
 
-  const recipientConfidentialBalanceBeforeTx =
-    await client.getConfidentialBalance(
-      recipient.address,
-      recipientKeys.privateKey,
-      TOKEN_ADDRESS,
+    const senderConfidentialBalanceAfterDep =
+      await client.getConfidentialBalance(
+        sender.address,
+        senderKeys.privateKey,
+        chain.tokenAddress,
+      );
+    console.log(
+      "Sender Confidential Balance (Post-Deposit):",
+      ethers.formatUnits(
+        senderConfidentialBalanceAfterDep.amount,
+        tokenDecimals,
+      ),
     );
 
-  console.log(
-    "Sender Confidential Balance (Pre-Transfer):",
-    ethers.formatUnits(senderConfidentialBalanceBeforeTx.amount, tokenDecimals),
-  );
-  console.log(
-    "Recipient Confidential Balance (Pre-Transfer):",
-    ethers.formatUnits(
-      recipientConfidentialBalanceBeforeTx.amount,
-      tokenDecimals,
-    ),
-  );
+    // 2. TRANSFER PHASE
+    console.log("\n--- Phase 2: Transfer ---");
+    const transferAmount = ethers.parseUnits("0.05", tokenDecimals);
+    const senderConfidentialBalanceBeforeTx =
+      await client.getConfidentialBalance(
+        sender.address,
+        senderKeys.privateKey,
+        chain.tokenAddress,
+      );
 
-  console.log("Transferring 0.05 tokens confidentially to recipient...");
+    const recipientConfidentialBalanceBeforeTx =
+      await client.getConfidentialBalance(
+        recipient.address,
+        recipientKeys.privateKey,
+        chain.tokenAddress,
+      );
 
-  // FIXED: Ensured all arguments are explicitly passed in the arrow function
-  const txRes = await trackPerformance("CONFIDENTIAL_TRANSFER", () =>
-    client.confidentialTransfer(
-      sender,
-      recipient.address,
-      TOKEN_ADDRESS,
-      transferAmount,
-    ),
-  );
+    console.log(
+      "Sender Confidential Balance (Pre-Transfer):",
+      ethers.formatUnits(
+        senderConfidentialBalanceBeforeTx.amount,
+        tokenDecimals,
+      ),
+    );
+    console.log(
+      "Recipient Confidential Balance (Pre-Transfer):",
+      ethers.formatUnits(
+        recipientConfidentialBalanceBeforeTx.amount,
+        tokenDecimals,
+      ),
+    );
 
-  const txHash = txRes.result.hash;
-  console.log(
-    "Status:Confidential Transfer is completed. Transfer amount is hidden on-chain.",
-  );
-  console.log(`Transaction Hash: ${txHash}`);
-  console.log(`View Transaction: ${EXPLORER_URL}${txHash}`);
+    console.log("Transferring 0.05 tokens confidentially to recipient...");
 
-  const senderConfidentialBalanceAfterTx = await client.getConfidentialBalance(
-    sender.address,
-    senderKeys.privateKey,
-    TOKEN_ADDRESS,
-  );
+    const txRes = await trackPerformance(
+      "CONFIDENTIAL_TRANSFER",
+      () =>
+        client.confidentialTransfer(
+          sender,
+          recipient.address,
+          chain.tokenAddress,
+          transferAmount,
+        ),
+      provider,
+      chain.network,
+    );
 
-  const recipientConfidentialBalanceAfterTx =
-    await client.getConfidentialBalance(
-      recipient.address,
-      recipientKeys.privateKey,
-      TOKEN_ADDRESS,
+    const txHash = txRes.result.hash || txRes.result.transactionHash;
+    console.log(
+      "Status: Confidential Transfer is completed. Transfer amount is hidden on-chain.",
     );
+    console.log(`Transaction Hash: ${txHash}`);
+    console.log(`View Transaction: ${explorerBaseUrl}${txHash}`);
 
-  console.log(
-    "Sender Confidential Balance (Post-Transfer):",
-    ethers.formatUnits(senderConfidentialBalanceAfterTx.amount, tokenDecimals),
-  );
-  console.log(
-    "Recipient Confidential Balance (Post-Transfer):",
-    ethers.formatUnits(
-      recipientConfidentialBalanceAfterTx.amount,
-      tokenDecimals,
-    ),
-    "\n",
-  );
+    const senderConfidentialBalanceAfterTx =
+      await client.getConfidentialBalance(
+        sender.address,
+        senderKeys.privateKey,
+        chain.tokenAddress,
+      );
 
-  // 3. WITHDRAW PHASE
-  const withdrawAmount = ethers.parseUnits("0.025", tokenDecimals);
-  console.log(
-    "Withdrawing 0.025 tokens from confidential contract to recipient's public balance...",
-  );
-  let recipientConfidentialBalanceBeforeWithdraw =
-    await client.getConfidentialBalance(
-      recipient.address,
-      recipientKeys.privateKey,
-      TOKEN_ADDRESS,
+    const recipientConfidentialBalanceAfterTx =
+      await client.getConfidentialBalance(
+        recipient.address,
+        recipientKeys.privateKey,
+        chain.tokenAddress,
+      );
+
+    console.log(
+      "Sender Confidential Balance (Post-Transfer):",
+      ethers.formatUnits(
+        senderConfidentialBalanceAfterTx.amount,
+        tokenDecimals,
+      ),
+    );
+    console.log(
+      "Recipient Confidential Balance (Post-Transfer):",
+      ethers.formatUnits(
+        recipientConfidentialBalanceAfterTx.amount,
+        tokenDecimals,
+      ),
     );
 
-  console.log(
-    "Recipient Confidential Balance (Pre-Withdraw):",
-    ethers.formatUnits(
-      recipientConfidentialBalanceBeforeWithdraw.amount,
-      tokenDecimals,
-    ),
-  );
-  const withdrawRes = await trackPerformance("WITHDRAW_TOKENS", () =>
-    client.withdraw(recipient, TOKEN_ADDRESS, withdrawAmount),
-  );
+    // 3. WITHDRAW PHASE
+    console.log("\n--- Phase 3: Withdraw ---");
+    const withdrawAmount = ethers.parseUnits("0.025", tokenDecimals);
+    console.log(
+      "Withdrawing 0.025 tokens from confidential contract to recipient's public balance...",
+    );
 
-  const withdrawHash = withdrawRes.result.hash;
-  console.log(`Transaction Hash: ${withdrawHash}`);
-  console.log(`View Transaction: ${EXPLORER_URL}${withdrawHash}`);
+    const recipientConfidentialBalanceBeforeWithdraw =
+      await client.getConfidentialBalance(
+        recipient.address,
+        recipientKeys.privateKey,
+        chain.tokenAddress,
+      );
 
-  const recipientConfidentialBalanceAfterWithdraw =
-    await client.getConfidentialBalance(
-      recipient.address,
-      recipientKeys.privateKey,
-      TOKEN_ADDRESS,
+    console.log(
+      "Recipient Confidential Balance (Pre-Withdraw):",
+      ethers.formatUnits(
+        recipientConfidentialBalanceBeforeWithdraw.amount,
+        tokenDecimals,
+      ),
     );
 
+    const withdrawRes = await trackPerformance(
+      "WITHDRAW_TOKENS",
+      () => client.withdraw(recipient, chain.tokenAddress, withdrawAmount),
+      provider,
+      chain.network,
+    );
+
+    const withdrawHash =
+      withdrawRes.result.hash || withdrawRes.result.transactionHash;
+    console.log(`Transaction Hash: ${withdrawHash}`);
+    console.log(`View Transaction: ${explorerBaseUrl}${withdrawHash}`);
+
+    const recipientConfidentialBalanceAfterWithdraw =
+      await client.getConfidentialBalance(
+        recipient.address,
+        recipientKeys.privateKey,
+        chain.tokenAddress,
+      );
+
+    console.log(
+      "Recipient Confidential Balance (Final):",
+      ethers.formatUnits(
+        recipientConfidentialBalanceAfterWithdraw.amount,
+        tokenDecimals,
+      ),
+    );
+
+    console.log(`\n=== Successfully completed flow for ${chain.network} ===`);
+
+    const currentChainSummary = actionSummary
+      .filter((s) => s.Chain === chain.network)
+      .map((s) => ({
+        Action: s.Action,
+        "Duration (s)": s["Duration (s)"],
+        Congestion: s.Congestion,
+        "Started At": s["Started At"],
+        "Completed At": s["Completed At"],
+      }));
+
+    if (currentChainSummary.length > 0) {
+      console.log(`\n=== Execution Summary for ${chain.network} ===`);
+      console.table(currentChainSummary);
+    }
+  } catch (err) {
+    console.error(
+      `\n[!] Error running flow on ${chain.network} (Chain ID: ${chain.chainId}):`,
+    );
+    console.error(err.message || err);
+    console.log(`Skipping ${chain.network} and moving to the next chain...\n`);
+  }
+}
+
+async function main() {
   console.log(
-    "Recipient Confidential Balance (Final):",
-    ethers.formatUnits(
-      recipientConfidentialBalanceAfterWithdraw.amount,
-      tokenDecimals,
-    ),
+    "=== Starting Multi-Chain Confidential Flow Performance Test ===\n",
   );
 
-  console.log("\n=== Complete Flow Execution Finished ===");
+  const senderPrivateKey = process.env.SENDER_PRIVATE_KEY;
+  const recipientPrivateKey = process.env.RECIPIENT_PRIVATE_KEY;
+
+  if (!senderPrivateKey || !recipientPrivateKey) {
+    console.error(
+      "Missing SENDER_PRIVATE_KEY or RECIPIENT_PRIVATE_KEY in .env",
+    );
+    process.exit(1);
+  }
+
+  for (const chain of CHAINS) {
+    await runChainFlow(chain, senderPrivateKey, recipientPrivateKey);
+  }
+
+  console.log("\n=== All Chain Flows Execution Finished ===");
+  if (actionSummary.length > 0) {
+    console.log("\n=== Actions Summary Table ===");
+    console.table(actionSummary);
+  }
 }
 
 main().catch((error) => {
-  console.error("Execution Error:", error);
+  console.error("Critical Execution Error:", error);
   process.exit(1);
 });

package/examples/simple-snippets.js

@@ -1,6 +1,7 @@
 import { ethers } from "ethers";
 import dotenv from "dotenv";
 import { ConfidentialTransferClient } from "@fairblock/stabletrust";
+import { ERC20_ABI } from "./constants.js";
 dotenv.config();
 const RPC_URL = process.env.RPC_URL || "https://rpc.testnet.stable.xyz";
 const EXPLORER_URL =
@@ -19,9 +20,9 @@ async function minimalFlow() {
   // 2. Initialize Confidential Accounts (View Keys)
   await client.ensureAccount(sender);
   await client.ensureAccount(recipient);
-  const tokenContract = new ethers.Contract(TOKEN_ADDRESS, ERC20_ABI, provider);
-  const tokenDecimals = await tokenContract.decimals();
   const TOKEN = "0x78Cf24370174180738C5B8E352B6D14c83a6c9A9";
+  const tokenContract = new ethers.Contract(TOKEN, ERC20_ABI, provider);
+  const tokenDecimals = await tokenContract.decimals();
   const amount = ethers.parseUnits("0.1", tokenDecimals);
   let res;
   // 3. DEPOSIT: Move public ERC20 into the confidential contract

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fairblock/stabletrust",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "SDK for confidential transfers using homomorphic encryption and zero-knowledge proofs",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/client.js

@@ -3,10 +3,14 @@ import {
   CONTRACT_ABI,
   ERC20_ABI,
   getStableTrustContractAddress,
-  TEMPO_FEE_TOKEN_ADDRESS,
 } from "./constants.js";
 import { deriveKeys, decryptCiphertext, combineCiphertext } from "./crypto.js";
-import { encodeTransferProof, encodeWithdrawProof, sleep } from "./utils.js";
+import {
+  encodeTransferProof,
+  encodeWithdrawProof,
+  sleep,
+  uploadBytesToIpfs,
+} from "./utils.js";
 import { initializeWasm } from "./wasm-loader.js";
 
 // Auto-initialize WASM on first use
@@ -545,30 +549,49 @@ export class ConfidentialTransferClient {
 
       if (!proof.success) {
         throw new Error(
-          `Proof generation failed: ${proof.error || "Unknown error. Check your balance and amount."}`,
+          `Proof generation failed: ${
+            proof.error || "Unknown error. Check your balance and amount."
+          }`,
         );
       }
+      const encodedProof = ethers.getBytes(encodeTransferProof(proof.data));
+      let transferZkpArg;
+      let txOverrides;
+
+      if (this.config.chainId === 42431) {
+        // Tempo: upload proof to IPFS and pass an ipfs:// pointer; no native fee
+        try {
+          const cid = await uploadBytesToIpfs(
+            encodedProof,
+            "transfer-proof.bin",
+          );
+          transferZkpArg = ethers.toUtf8Bytes(`ipfs://${cid}`);
+        } catch (ipfsError) {
+          throw new Error(
+            `Failed to upload proof to IPFS: ${ipfsError.message}`,
+          );
+        }
+        txOverrides = { value: 0n };
+      } else {
+        // Standard chains: pass encoded proof bytes with native fee
+        transferZkpArg = encodedProof;
+        txOverrides = { value: await this.contract.feeAmount() };
+      }
+
+      const tx = await this.contract
+        .connect(senderWallet)
+        .transferConfidential(
+          recipientAddress,
+          tokenAddress,
+          transferZkpArg,
+          useOffchainVerify,
+          txOverrides,
+        );
 
-      // Execute transfer based on chain type
-      // Tempo chain (42431) uses token-based(fee token for the current contract is pathUSD)fees instead of native currency
-      const receipt =
-        this.config.chainId === 42431
-          ? await this._executeTempoTransfer(
-              senderWallet,
-              senderAddress,
-              recipientAddress,
-              tokenAddress,
-              proof,
-              useOffchainVerify,
-              fee,
-            )
-          : await this._executeStandardTransfer(
-              senderWallet,
-              recipientAddress,
-              tokenAddress,
-              proof,
-              useOffchainVerify,
-            );
+      const receipt = await tx.wait();
+      if (!receipt || receipt.status === 0) {
+        throw new Error("Transfer transaction failed");
+      }
 
       if (waitForFinalization) {
         await this._waitForGlobalState(senderAddress, "transfer");
@@ -587,159 +610,6 @@ export class ConfidentialTransferClient {
     }
   }
 
-  /**
-   * Execute confidential transfer on Tempo chain (chainId 42431)
-   *
-   * Tempo is a stablecoin-focused chain without native currency for smart contracts.
-   * This method handles token-based fee payment using PathUSD, requiring:
-   * - Fee token approval before transfer
-   * - Fee token balance validation
-   * - Gas estimation with fallback for estimation failures
-   *
-   * @private
-   */
-  async _executeTempoTransfer(
-    senderWallet,
-    senderAddress,
-    recipientAddress,
-    tokenAddress,
-    proof,
-    useOffchainVerify,
-    fee,
-  ) {
-    const feeTokenAddress = TEMPO_FEE_TOKEN_ADDRESS;
-    let tx;
-
-    // Check if feeTokenAddress is configured - this indicates token-based fee payment
-    if (feeTokenAddress) {
-      // Approve fee token for the contract
-      const feeTokenContract = this._getTokenContract(feeTokenAddress);
-
-      // Check balance first
-      const feeTokenBalance = await feeTokenContract.balanceOf(senderAddress);
-      if (feeTokenBalance < fee) {
-        throw new Error(
-          `Insufficient fee token ${TEMPO_FEE_TOKEN_ADDRESS} balance. Required: ${fee}, Available: ${feeTokenBalance}`,
-        );
-      }
-
-      const allowance = await feeTokenContract.allowance(
-        senderAddress,
-        this.config.contractAddress,
-      );
-
-      if (allowance < fee) {
-        const approveTx = await feeTokenContract
-          .connect(senderWallet)
-          .approve(this.config.contractAddress, ethers.MaxUint256);
-
-        const approveReceipt = await approveTx.wait();
-        if (!approveReceipt || approveReceipt.status === 0) {
-          throw new Error("Fee token approval failed");
-        }
-      }
-
-      // Try to estimate gas first to catch any revert reasons early
-      let gasLimit = 2_000_000n;
-      try {
-        const estimatedGas = await this.contract
-          .connect(senderWallet)
-          .transferConfidential.estimateGas(
-            recipientAddress,
-            tokenAddress,
-            ethers.getBytes(encodeTransferProof(proof.data)),
-            useOffchainVerify,
-            { value: 0 },
-          );
-        // Add 20% buffer to estimated gas
-        gasLimit = (estimatedGas * 120n) / 100n;
-      } catch (gasEstError) {
-        // If gas estimation fails, use default gas limit
-        console.warn(
-          `Gas estimation failed, using default gas limit: ${gasEstError?.message || String(gasEstError)}`,
-        );
-      }
-
-      tx = await this.contract
-        .connect(senderWallet)
-        .transferConfidential(
-          recipientAddress,
-          tokenAddress,
-          ethers.getBytes(encodeTransferProof(proof.data)),
-          useOffchainVerify,
-          { value: 0, gasLimit },
-        );
-    } else {
-      try {
-        tx = await this.contract
-          .connect(senderWallet)
-          .transferConfidential(
-            recipientAddress,
-            tokenAddress,
-            ethers.getBytes(encodeTransferProof(proof.data)),
-            useOffchainVerify,
-            { value: fee },
-          );
-      } catch (gasError) {
-        if (
-          gasError?.code === "CALL_EXCEPTION" ||
-          gasError?.code === "UNKNOWN_ERROR" ||
-          gasError?.message?.includes("estimateGas") ||
-          gasError?.message?.includes("missing revert data")
-        ) {
-          const gasLimit = 2_000_000n;
-          tx = await this.contract
-            .connect(senderWallet)
-            .transferConfidential(
-              recipientAddress,
-              tokenAddress,
-              ethers.getBytes(encodeTransferProof(proof.data)),
-              useOffchainVerify,
-              { value: fee, gasLimit },
-            );
-        } else {
-          throw gasError;
-        }
-      }
-    }
-
-    const receipt = await tx.wait();
-    if (!receipt || receipt.status === 0) {
-      throw new Error("Transfer transaction failed");
-    }
-
-    return receipt;
-  }
-
-  /**
-   * Execute confidential transfer on standard chains
-   * @private
-   */
-  async _executeStandardTransfer(
-    senderWallet,
-    recipientAddress,
-    tokenAddress,
-    proof,
-    useOffchainVerify,
-  ) {
-    const fee = await this.contract.feeAmount();
-    const tx = await this.contract
-      .connect(senderWallet)
-      .transferConfidential(
-        recipientAddress,
-        tokenAddress,
-        ethers.getBytes(encodeTransferProof(proof.data)),
-        useOffchainVerify,
-        { value: fee },
-      );
-
-    const receipt = await tx.wait();
-    if (!receipt || receipt.status === 0) {
-      throw new Error("Transfer transaction failed");
-    }
-
-    return receipt;
-  }
   /**
    * Withdraw confidential tokens to public ERC20
    *
@@ -778,6 +648,7 @@ export class ConfidentialTransferClient {
       }
 
       const address = await wallet.getAddress();
+
       // Fetch balance first — only apply pending if available is insufficient
       let balanceSummary = await this.getConfidentialBalance(
         address,
@@ -838,17 +709,39 @@ export class ConfidentialTransferClient {
 
       if (!proof.success) {
         throw new Error(
-          `Withdrawal proof generation failed: ${proof.error || "Unknown error. Check your balance and amount."}`,
+          `Withdrawal proof generation failed: ${
+            proof.error || "Unknown error. Check your balance and amount."
+          }`,
         );
       }
 
       // Execute withdrawal
+      const encodedProof = ethers.getBytes(encodeWithdrawProof(proof.data));
+      let withdrawZkpArg;
+
+      if (this.config.chainId === 42431) {
+        // Tempo: upload proof to IPFS and pass an ipfs:// pointer
+        try {
+          const cid = await uploadBytesToIpfs(
+            encodedProof,
+            "withdraw-proof.bin",
+          );
+          withdrawZkpArg = ethers.toUtf8Bytes(`ipfs://${cid}`);
+        } catch (ipfsError) {
+          throw new Error(
+            `Failed to upload proof to IPFS: ${ipfsError.message}`,
+          );
+        }
+      } else {
+        withdrawZkpArg = encodedProof;
+      }
+
       const tx = await this.contract
         .connect(wallet)
         .withdraw(
           tokenAddress,
           BigInt(withdrawAmount),
-          ethers.getBytes(encodeWithdrawProof(proof.data)),
+          withdrawZkpArg,
           useOffchainVerify,
         );
 
@@ -930,7 +823,9 @@ export class ConfidentialTransferClient {
       } catch (error) {
         // If we can't get account info, wait and retry
         console.warn(
-          `Warning: Failed to check account state (attempt ${attempts + 1}): ${error.message}`,
+          `Warning: Failed to check account state (attempt ${attempts + 1}): ${
+            error.message
+          }`,
         );
       }
 

package/src/constants.js

@@ -25,12 +25,12 @@ export const TEMPO_FEE_TOKEN_ADDRESS =
   "0x20c0000000000000000000000000000000000000";
 
 export const STABLETRUST_CONTRACTS_BY_CHAIN_ID = Object.freeze({
-  2201: "0xB96aa42b246a956B170fE426A72fB610E4976f9E", //Stable
-  1244: "0xb20aB54e1c6AE55B0DD11FEB7FFf3fF1E9631f19", //Arc
-  84532: "0x962a8A7CD28BfFBb17C4F6Ec388782cca3ffd618", //Base
-  11155111: "0x2E48F3D9b8F4aCA9E6AF0630eaB2ceB7A3f5eEd1", //Ethereum
-  421614: "0x14Afd604971bee5b5fac52df2d56CaE421519Cc5", //Arbitrum
-  42431: "0x08B6563C95dfe3a4F5533CAA6F7D55a74FCb4F6c", //Tempo
+  2201: "0xdf43bC80B5b22A858860947d383b6F4d6C81d8EC", //Stable
+  1244: "0x5d43CE5269Cd46badC67B3664369862F20eC5649", //Arc
+  84532: "0xFBEa2AbCf1208E09dd90266fE94Fb76d8BfC34d9", //Base
+  11155111: "0x72B87207791996F416D2F3B0dcAcbb07F445C496", //Ethereum
+  421614: "0x6C9eDBDd028Fe610b054187A34712714E341D112", //Arbitrum
+  42431: "0xE559fB936C69c46E216bf61B07C16bF1a6d444aa", //Tempo
 });
 
 export function getStableTrustContractAddress(chainId) {

package/src/utils.js

@@ -1,5 +1,8 @@
 import { ethers } from "ethers";
-
+// Pinata uploads API endpoint
+// Docs: https://docs.pinata.cloud
+const PINATA_UPLOAD_URL = "https://uploads.pinata.cloud/v3/files";
+const PINATA_JWT = process.env.PINATA_JWT;
 /**
  * Encodes the ZK-Proof data for a transfer into a format the Solidity contract expects.
  *
@@ -82,3 +85,78 @@ export async function waitForCondition(
   }
   throw new Error(`Timeout waiting for ${actionLabel}`);
 }
+
+/**
+ * Upload a JSON-serializable object to IPFS and return its CID (as a string).
+ * The object will be stored as a UTF-8 JSON blob.
+ *
+ * @param {any} data - JSON-serializable data to store.
+ * @returns {Promise<string>} The CID string.
+ */
+export async function uploadJsonToIpfs(data) {
+  if (!PINATA_JWT) {
+    throw new Error("REACT_APP_PINATA_JWT is not set");
+  }
+
+  const json = JSON.stringify(data);
+  const blob = new Blob([json], { type: "application/json" });
+
+  const form = new FormData();
+  form.append("file", blob, "proof.json");
+  form.append("network", "public");
+  form.append("name", "zk-proof");
+
+  const res = await fetch(PINATA_UPLOAD_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${PINATA_JWT}`,
+    },
+    body: form,
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Pinata upload failed: ${text}`);
+  }
+
+  const jsonRes = await res.json();
+  return jsonRes?.data?.cid?.toString();
+}
+
+/**
+ * Upload raw bytes to IPFS (Pinata) and return the CID.
+ *
+ * @param {Uint8Array|ArrayBuffer} bytes - Raw proof bytes.
+ * @param {string} [name='proof.bin'] - Optional file name metadata.
+ * @returns {Promise<string>} The CID string.
+ */
+export async function uploadBytesToIpfs(bytes, name = "proof.bin") {
+  if (!PINATA_JWT) {
+    throw new Error("REACT_APP_PINATA_JWT is not set");
+  }
+
+  const uint8 = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+
+  const blob = new Blob([uint8], { type: "application/octet-stream" });
+
+  const form = new FormData();
+  form.append("file", blob, name);
+  form.append("network", "public");
+  form.append("name", name);
+
+  const res = await fetch(PINATA_UPLOAD_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${PINATA_JWT}`,
+    },
+    body: form,
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Pinata upload failed: ${text}`);
+  }
+
+  const jsonRes = await res.json();
+  return jsonRes?.data?.cid?.toString();
+}