@fairblock/stabletrust 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fairblock/stabletrust",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "SDK for confidential transfers using homomorphic encryption and zero-knowledge proofs",
   "main": "src/index.js",
   "types": "src/withdrawal-fees.d.ts",
@@ -49,7 +49,7 @@
     "@stablelib/chacha20poly1305": "^1.0.1",
     "axios": "^1.16.0",
     "dotenv": "^17.2.3",
-    "ethers": "^6.16.0"
+    "ethers": "^6.17.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/backend.js

@@ -2,6 +2,12 @@ import axios from "axios";
 
 const DEFAULT_API_BASE_URL = "https://stabletrust-backend-api.fairblock.network";
 
+// Bound each request-row POST. Callers await these,
+// so without a timeout a slow/hung backend would stall the caller's transfer()
+// even though the on-chain transfer already completed. On timeout axios rejects
+// with ECONNABORTED, which _postRequest turns into a warning.
+const REQUEST_TIMEOUT_MS = 5000;
+
 export const CHAIN_KEY_BY_ID = {
   2201: "stable",
   5042002: "arc",
@@ -9,11 +15,14 @@ export const CHAIN_KEY_BY_ID = {
   11155111: "ethereumSepolia",
   421614: "arbitrumSepolia",
   42431: "tempo",
+  42161: "arbitrumOne",
 };
 
 /**
  * POST /api/requests — create a request row
  */
 export async function createRequest(requestData, apiBaseUrl = DEFAULT_API_BASE_URL) {
-  await axios.post(`${apiBaseUrl}/api/requests`, requestData);
+  await axios.post(`${apiBaseUrl}/api/requests`, requestData, {
+    timeout: REQUEST_TIMEOUT_MS,
+  });
 }

package/src/confidential-client.js

@@ -9,6 +9,7 @@ import {
   ANONYMOUS_IPFS_TRANSFER_FEE_SIGNATURE,
   ANONYMOUS_INLINE_TRANSFER_FEE_SIGNATURE,
   getStabletrustContractAddress,
+  STABLETRUST_CONTRACTS_BY_CHAIN_ID,
 } from "./constants.js";
 import { deriveKeys, decryptCiphertext, combineCiphertext } from "./crypto.js";
 import {
@@ -76,9 +77,9 @@ export class ConfidentialTransferClient {
       throw new Error("chainId is required");
     }
     if (!resolvedContractAddress) {
-      const supportedChainIds = [2201, 5042002, 84532, 11155111, 421614, 42431]
-        .map(String)
-        .join(", ");
+      const supportedChainIds = Object.keys(
+        STABLETRUST_CONTRACTS_BY_CHAIN_ID,
+      ).join(", ");
       throw new Error(
         `contractAddress is required for chainId ${resolvedChainId}. No default Stabletrust contract is configured for this chain. Supported chainIds: ${supportedChainIds}`,
       );
@@ -120,7 +121,10 @@ export class ConfidentialTransferClient {
   }
 
   /**
-   * Fire-and-forget request row creation
+   * Post a request row. Returns the createRequest promise (which resolves even
+   * on failure - errors are logged and swallowed) so callers that need the row
+   * to exist before returning (e.g. confidentialTransfer) can `await` it.
+   * Callers that don't await keep the old fire-and-forget behavior.
    * @private
    */
   _postRequest(data) {
@@ -131,7 +135,7 @@ export class ConfidentialTransferClient {
       applicationName: this.config.applicationName,
       ...data,
     };
-    createRequest(payload, apiBaseUrl).catch((err) => {
+    return createRequest(payload, apiBaseUrl).catch((err) => {
       const status = err?.response?.status;
       const body = err?.response?.data;
       console.warn("[StableTrust] Failed to post request:", err.message);
@@ -881,67 +885,72 @@ export class ConfidentialTransferClient {
       ]);
       const tokenSymbol = await tokenContract.symbol();
 
-      Promise.all([
-        encryptRandomness(senderAddress, proof.data.sender_randomness),
-        encryptRandomness(recipientAddress, proof.data.receiver_randomness),
-      ])
-        .then(([senderEnc, receiverEnc]) => {
-          const transferDetails = {
-            sender: senderAddress.toLowerCase(),
-            recipient: recipientAddress.toLowerCase(),
-            token: tokenSymbol,
-            tokenAddress,
-          };
-
-          const queuedFields =
-            senderEnc.queuedEncrypted && receiverEnc.queuedEncrypted
-              ? {
-                  queuedEncryptedSenderRandomness: senderEnc.queuedEncrypted,
-                  queuedEncryptedSenderRandomnessId:
-                    senderEnc.queuedEncryptedId,
-                  queuedEncryptedReceiverRandomness:
-                    receiverEnc.queuedEncrypted,
-                  queuedEncryptedReceiverRandomnessId:
-                    receiverEnc.queuedEncryptedId,
-                }
-              : {};
-
-          this._postRequest({
-            requestId,
-            userAddress: senderAddress.toLowerCase(),
-            operationKind: 2,
-            type: "transfer",
-            transactionHash: txHash,
-            status: "pending",
-            details: transferDetails,
-            encryptedSenderRandomness: senderEnc.encrypted,
-            encryptedSenderRandomnessId: senderEnc.encryptedId,
-            encryptedReceiverRandomness: receiverEnc.encrypted,
-            encryptedReceiverRandomnessId: receiverEnc.encryptedId,
-            ...queuedFields,
-          });
-
-          this._postRequest({
-            requestId: `received-${requestId}-${recipientAddress.toLowerCase()}`,
-            userAddress: recipientAddress.toLowerCase(),
-            operationKind: 2,
-            type: "received",
-            transactionHash: txHash,
-            status: "pending",
-            details: transferDetails,
-            encryptedReceiverRandomness: receiverEnc.encrypted,
-            encryptedReceiverRandomnessId: receiverEnc.encryptedId,
-            ...(receiverEnc.queuedEncrypted
-              ? {
-                  queuedEncryptedReceiverRandomness:
-                    receiverEnc.queuedEncrypted,
-                  queuedEncryptedReceiverRandomnessId:
-                    receiverEnc.queuedEncryptedId,
-                }
-              : {}),
-          });
-        })
-        .catch(() => {});
+      let senderEnc = null;
+      let receiverEnc = null;
+      try {
+        [senderEnc, receiverEnc] = await Promise.all([
+          encryptRandomness(senderAddress, proof.data.sender_randomness),
+          encryptRandomness(recipientAddress, proof.data.receiver_randomness),
+        ]);
+      } catch (encErr) {
+        console.warn(
+          `[StableTrust] Transfer ${txHash} Failed to get IBE Randomness (${encErr?.message ?? encErr}). `,
+        );
+      }
+
+      if (senderEnc && receiverEnc) {
+        const transferDetails = {
+          sender: senderAddress.toLowerCase(),
+          recipient: recipientAddress.toLowerCase(),
+          token: tokenSymbol,
+          tokenAddress,
+        };
+
+        const queuedFields =
+          senderEnc.queuedEncrypted && receiverEnc.queuedEncrypted
+            ? {
+                queuedEncryptedSenderRandomness: senderEnc.queuedEncrypted,
+                queuedEncryptedSenderRandomnessId: senderEnc.queuedEncryptedId,
+                queuedEncryptedReceiverRandomness: receiverEnc.queuedEncrypted,
+                queuedEncryptedReceiverRandomnessId:
+                  receiverEnc.queuedEncryptedId,
+              }
+            : {};
+
+        await this._postRequest({
+          requestId,
+          userAddress: senderAddress.toLowerCase(),
+          operationKind: 2,
+          type: "transfer",
+          transactionHash: txHash,
+          status: "pending",
+          details: transferDetails,
+          encryptedSenderRandomness: senderEnc.encrypted,
+          encryptedSenderRandomnessId: senderEnc.encryptedId,
+          encryptedReceiverRandomness: receiverEnc.encrypted,
+          encryptedReceiverRandomnessId: receiverEnc.encryptedId,
+          ...queuedFields,
+        });
+
+        await this._postRequest({
+          requestId: `received-${requestId}-${recipientAddress.toLowerCase()}`,
+          userAddress: recipientAddress.toLowerCase(),
+          operationKind: 2,
+          type: "received",
+          transactionHash: txHash,
+          status: "pending",
+          details: transferDetails,
+          encryptedReceiverRandomness: receiverEnc.encrypted,
+          encryptedReceiverRandomnessId: receiverEnc.encryptedId,
+          ...(receiverEnc.queuedEncrypted
+            ? {
+                queuedEncryptedReceiverRandomness: receiverEnc.queuedEncrypted,
+                queuedEncryptedReceiverRandomnessId:
+                  receiverEnc.queuedEncryptedId,
+              }
+            : {}),
+        });
+      }
 
       if (waitForFinalization) {
         await this._waitForGlobalState(senderAddress, "transfer");

package/src/constants.js

@@ -69,6 +69,7 @@ export const STABLETRUST_CONTRACTS_BY_CHAIN_ID = Object.freeze({
   11155111: "0x7507a13352AFAa79D33E994f86f2f62463ba8DE4", //Ethereum
   421614: "0x5acECCdeb5CbD3C727eCB49F8706Eb80EF2f977F", //Arbitrum
   42431: "0xE559fB936C69c46E216bf61B07C16bF1a6d444aa", //Tempo
+  42161: "0xCAA6384D5Ac8b9111D482dd676BB890f2b6e9513", //Arbitrum One (mainnet)
 });
 
 export function getStabletrustContractAddress(chainId) {

package/src/ibe.js

@@ -3,6 +3,14 @@ import { timelockEncrypt } from "./vendor/ts-ibe/index.js";
 const IBE_PUBKEY_URL =
   "https://anon-testnet-api.fairblock.network/fairyring/keyshare/pubkey";
 
+// Bound the IBE public-key fetch. Without this, a slow or hung endpoint (a
+// socket that accepts the connection but never responds) would block the fetch
+// indefinitely, and because confidentialTransfer awaits encryptRandomness that
+// stall propagates to the caller's transfer() call even though the on-chain
+// transfer already happened. On timeout the fetch aborts and encryptRandomness
+// rejects, which the caller handles as "dashboard record skipped".
+const IBE_FETCH_TIMEOUT_MS = 5000;
+
 /** @type {{ active: string, queued: string | null } | null} */
 let cachedIbePublicKeys = null;
 
@@ -23,9 +31,22 @@ function buildIbeId(userAddress, publicKey) {
 async function getIbePublicKeys() {
   if (cachedIbePublicKeys) return cachedIbePublicKeys;
 
-  const response = await fetch(IBE_PUBKEY_URL, {
-    headers: { Accept: "application/json" },
-  });
+  let response;
+  try {
+    response = await fetch(IBE_PUBKEY_URL, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(IBE_FETCH_TIMEOUT_MS),
+    });
+  } catch (err) {
+    if (err?.name === "TimeoutError" || err?.name === "AbortError") {
+      throw new Error(
+        `IBE public key fetch timed out after ${IBE_FETCH_TIMEOUT_MS}ms`,
+      );
+    }
+    throw new Error(
+      `IBE public key fetch failed: ${err?.message ?? err}`,
+    );
+  }
 
   if (!response.ok) {
     throw new Error(