@fairblock/stabletrust 2.0.14 → 2.0.16

package/README.md

@@ -63,13 +63,23 @@ The following contract addresses are available for confidential transfers on tes
 
 | Network(Testnet) | Chain ID | Contract Address                             |
 | :--------------- | :------- | :------------------------------------------- |
-| Stable           | 2201     | `0xe1c1456CAb802312759a8cFc3976f88bf87082cf` |
-| Arc              | 5042002  | `0x1B4f05f67CC33788Da4C89a7cd0b2f8E0055E605` |
-| Base             | 84532    | `0x4a251C9D79faCa20b193630A4ee313af7cBCDD93` |
-| Ethereum         | 11155111 | `0x7507a13352AFAa79D33E994f86f2f62463ba8DE4` |
-| Arbitrum         | 421614   | `0x5acECCdeb5CbD3C727eCB49F8706Eb80EF2f977F` |
+| Stable           | 2201     | `0x0b6791C168ffBF52e82F5E862929Dbf505c3A46E` |
+| Arc              | 5042002  | `0xA90621B79d49c8E3A5eeEBcaaa839E2f886240C5` |
+| Base             | 84532    | `0xb6cdAE7ccfEE03e351694c63436D5c5c073aEF84` |
+| Ethereum         | 11155111 | `0x5A061604A1d94f4fa9939544707f6B200d6bB5cf` |
+| Arbitrum         | 421614   | `0x147C6D8cA1a4784Ed76d98b0E3CcA41C38a49A5f` |
 | Tempo            | 42431    | `0xE559fB936C69c46E216bf61B07C16bF1a6d444aa` |
 
+## Available Confidential Contract Addresses (Mainnet)
+
+The following contract addresses are **live mainnet** deployments:
+
+| Network(Mainnet) | Chain ID | Contract Address                             |
+| :--------------- | :------- | :------------------------------------------- |
+| Arbitrum One     | 42161    | `0xCAA6384D5Ac8b9111D482dd676BB890f2b6e9513` |
+| Base             | 8453     | `0xF90a80eef61e934CF20E5B4fa48FBe9F5fB58aED` |
+| Ethereum         | 1        | `0xa9661635cc97756190973Ef281d4529693EcAcD0` |
+
 ---
 
 ## ConfidentialTransferClient

package/package.json

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

package/src/backend.js

@@ -16,6 +16,8 @@ export const CHAIN_KEY_BY_ID = {
   421614: "arbitrumSepolia",
   42431: "tempo",
   42161: "arbitrumOne",
+  8453: "base",
+  1: "ethereum",
 };
 
 /**

package/src/constants.js

@@ -2,15 +2,25 @@
  * Contract ABIs and Constants
  */
 
-const CREATE_CONFIDENTIAL_ACCOUNT_SIGNATURE = "createConfidentialAccount(bytes)";
-const DEPOSIT_SIGNATURE = "deposit(address,uint256)";
+export const PREDICATE_ATTESTATION_SIGNATURE =
+  "(string,uint256,address,bytes)";
+const PREDICATE_ATTESTATION_ABI =
+  "(string uuid,uint256 expiration,address attester,bytes signature) attestation";
+
+export const CREATE_CONFIDENTIAL_ACCOUNT_SIGNATURE =
+  `createConfidentialAccount(bytes,${PREDICATE_ATTESTATION_SIGNATURE})`;
+export const DEPOSIT_SIGNATURE =
+  `deposit(address,uint256,${PREDICATE_ATTESTATION_SIGNATURE})`;
 const GET_ACCOUNT_CORE_SIGNATURE = "getAccountCore(address)";
 const GET_AVAILABLE_SIGNATURE = "getAvailable(address,address)";
 const GET_PENDING_SIGNATURE = "getPending(address,address)";
-const APPLY_PENDING_SIGNATURE = "applyPending()";
+export const APPLY_PENDING_SIGNATURE =
+  `applyPending(${PREDICATE_ATTESTATION_SIGNATURE})`;
 
-export const TRANSFER_CONFIDENTIAL_SIGNATURE = "transferConfidential(address,address,bytes,bool)";
-export const WITHDRAW_CONFIDENTIAL_SIGNATURE = "withdraw(address,uint256,bytes,bool)";
+export const TRANSFER_CONFIDENTIAL_SIGNATURE =
+  `transferConfidential(address,address,bytes,bool,${PREDICATE_ATTESTATION_SIGNATURE})`;
+export const WITHDRAW_CONFIDENTIAL_SIGNATURE =
+  `withdraw(address,uint256,bytes,bool,${PREDICATE_ATTESTATION_SIGNATURE})`;
 export const FEE_TOKEN_SIGNATURE = "feeToken()";
 export const FEE_ACCOUNT_SIGNATURE = "feeAccount()";
 export const NON_ANONYMOUS_TRANSFER_FEE_SIGNATURE = "nonAnonymousTransferFee()";
@@ -21,14 +31,14 @@ export const ANONYMOUS_INLINE_TRANSFER_FEE_SIGNATURE = "anonymousInlineTransferF
 export const ANONYMOUS_WITHDRAW_FEE_PPM_SIGNATURE = "anonymousWithdrawFeePpm()";
 
 export const CONTRACT_ABI = [
-  `function ${CREATE_CONFIDENTIAL_ACCOUNT_SIGNATURE} external`,
-  `function ${DEPOSIT_SIGNATURE} external`,
+  `function createConfidentialAccount(bytes elgamalPubkey,${PREDICATE_ATTESTATION_ABI}) external`,
+  `function deposit(address token,uint256 plainAmount,${PREDICATE_ATTESTATION_ABI}) external`,
   `function ${GET_ACCOUNT_CORE_SIGNATURE} external view returns ((bool exists, bool finalized, bool pendingAction, uint256 txId, bytes elgamalPubkey, uint64 pendingCreditCounter))`,
   `function ${GET_AVAILABLE_SIGNATURE} external view returns (bytes c1, bytes c2)`,
   `function ${GET_PENDING_SIGNATURE} external view returns (bytes c1, bytes c2)`,
-  `function ${TRANSFER_CONFIDENTIAL_SIGNATURE} external payable`,
-  `function ${WITHDRAW_CONFIDENTIAL_SIGNATURE} external payable`,
-  `function ${APPLY_PENDING_SIGNATURE} external`,
+  `function transferConfidential(address recipient,address token,bytes proof,bool offchainZKP,${PREDICATE_ATTESTATION_ABI}) external payable`,
+  `function withdraw(address token,uint256 plainAmount,bytes proof,bool offchainZKP,${PREDICATE_ATTESTATION_ABI}) external payable`,
+  `function applyPending(${PREDICATE_ATTESTATION_ABI}) external`,
   `function ${FEE_TOKEN_SIGNATURE} external view returns (address)`,
   `function ${FEE_ACCOUNT_SIGNATURE} external view returns (address)`,
   `function ${NON_ANONYMOUS_TRANSFER_FEE_SIGNATURE} external view returns (uint256)`,
@@ -63,13 +73,15 @@ export const ERC20_ABI = [
 export const TEMPO_FEE_TOKEN_ADDRESS =
   "0x20c0000000000000000000000000000000000000";
 export const STABLETRUST_CONTRACTS_BY_CHAIN_ID = Object.freeze({
-  2201: "0xe1c1456CAb802312759a8cFc3976f88bf87082cf", //Stable
-  5042002: "0x1B4f05f67CC33788Da4C89a7cd0b2f8E0055E605", //Arc
-  84532: "0x4a251C9D79faCa20b193630A4ee313af7cBCDD93", //Base
-  11155111: "0x7507a13352AFAa79D33E994f86f2f62463ba8DE4", //Ethereum
-  421614: "0x5acECCdeb5CbD3C727eCB49F8706Eb80EF2f977F", //Arbitrum
+  2201: "0x0b6791C168ffBF52e82F5E862929Dbf505c3A46E", //Stable
+  5042002: "0xA90621B79d49c8E3A5eeEBcaaa839E2f886240C5", //Arc
+  84532: "0xb6cdAE7ccfEE03e351694c63436D5c5c073aEF84", //Base
+  11155111: "0x5A061604A1d94f4fa9939544707f6B200d6bB5cf", //Ethereum
+  421614: "0x147C6D8cA1a4784Ed76d98b0E3CcA41C38a49A5f", //Arbitrum Sepolia
   42431: "0xE559fB936C69c46E216bf61B07C16bF1a6d444aa", //Tempo
   42161: "0xCAA6384D5Ac8b9111D482dd676BB890f2b6e9513", //Arbitrum One (mainnet)
+  8453: "0xF90a80eef61e934CF20E5B4fa48FBe9F5fB58aED", //Base (mainnet)
+  1: "0xa9661635cc97756190973Ef281d4529693EcAcD0", //Ethereum (mainnet)
 });
 
 export function getStabletrustContractAddress(chainId) {

package/src/index.d.ts

@@ -468,8 +468,11 @@ declare module "@fairblock/stabletrust" {
   }
 
   export type StableTrustChainId =
-    | 5042002
+    | 1
     | 2201
+    | 5042002
+    | 8453
+    | 42161
     | 42431
     | 84532
     | 421614

package/src/index.js

@@ -3,7 +3,7 @@ export {
   ControlledConfidentialTransferClient,
   AnonymousTransferClient,
   WITHDRAW_FEE_PPM_DENOMINATOR,
-} from "./fee-aware-clients.js";
+} from "./predicate-fee-aware-clients.js";
 export { deriveKeys, decryptCiphertext, combineCiphertext } from "./crypto.js";
 export {
   encodeTransferProof,
@@ -14,7 +14,11 @@ export {
 export {
   CONTRACT_ABI,
   ERC20_ABI,
+  PREDICATE_ATTESTATION_SIGNATURE,
+  CREATE_CONFIDENTIAL_ACCOUNT_SIGNATURE,
+  DEPOSIT_SIGNATURE,
   TRANSFER_CONFIDENTIAL_SIGNATURE,
+  APPLY_PENDING_SIGNATURE,
   WITHDRAW_CONFIDENTIAL_SIGNATURE,
   FEE_TOKEN_SIGNATURE,
   FEE_ACCOUNT_SIGNATURE,
@@ -27,4 +31,9 @@ export {
   STABLETRUST_CONTRACTS_BY_CHAIN_ID,
   getStabletrustContractAddress,
 } from "./constants.js";
+export {
+  emptyPredicateAttestation,
+  injectPredicateAttestation,
+  isPredicateAttestation,
+} from "./predicate-contract.js";
 // Note: initializeWasm is now internal - WASM auto-initializes on first client use

package/src/predicate-contract.js

@@ -0,0 +1,126 @@
+import { ethers } from "ethers";
+
+const PREDICATE_BUSINESS_ARG_COUNTS = Object.freeze({
+  createConfidentialAccount: 1,
+  deposit: 2,
+  transferConfidential: 4,
+  applyPending: 0,
+  withdraw: 4,
+});
+
+const METHOD_HELPERS = [
+  "estimateGas",
+  "populateTransaction",
+  "send",
+  "staticCall",
+  "staticCallResult",
+];
+
+const PREDICATE_WRAPPED = Symbol("stabletrust.predicateWrappedContract");
+
+/**
+ * Empty Predicate attestation used while on-chain Predicate enforcement is off.
+ * A fresh array is returned for each call so callers/ethers never share mutable
+ * tuple state between transactions.
+ */
+export function emptyPredicateAttestation() {
+  return ["", 0n, ethers.ZeroAddress, "0x"];
+}
+
+export function isPredicateAttestation(value) {
+  if (Array.isArray(value)) return value.length === 4;
+  if (!value || typeof value !== "object") return false;
+  return (
+    "uuid" in value &&
+    "expiration" in value &&
+    "attester" in value &&
+    "signature" in value
+  );
+}
+
+/**
+ * Convert the pre-Predicate SDK call shape into the upgraded Diamond call shape.
+ * Existing SDK methods may optionally append an ethers transaction-overrides
+ * object, so the attestation must be inserted immediately before overrides.
+ *
+ * Calls that already contain an explicit attestation are left unchanged. This
+ * makes the wrapped contract usable directly by applications that obtain a real
+ * Predicate attestation later.
+ */
+export function injectPredicateAttestation(methodName, args) {
+  const businessArgCount = PREDICATE_BUSINESS_ARG_COUNTS[methodName];
+  if (businessArgCount === undefined) return args;
+
+  if (args.length === businessArgCount) {
+    return [...args, emptyPredicateAttestation()];
+  }
+
+  if (args.length === businessArgCount + 1) {
+    if (isPredicateAttestation(args[businessArgCount])) {
+      return args;
+    }
+    return [
+      ...args.slice(0, businessArgCount),
+      emptyPredicateAttestation(),
+      args[businessArgCount],
+    ];
+  }
+
+  if (
+    args.length === businessArgCount + 2 &&
+    isPredicateAttestation(args[businessArgCount])
+  ) {
+    return args;
+  }
+
+  // Let ethers surface its normal argument-count/type error for malformed calls.
+  return args;
+}
+
+function wrapPredicateMethod(methodName, method) {
+  const wrapped = (...args) =>
+    method(...injectPredicateAttestation(methodName, args));
+
+  for (const helperName of METHOD_HELPERS) {
+    const helper = method?.[helperName];
+    if (typeof helper === "function") {
+      wrapped[helperName] = (...args) =>
+        helper(...injectPredicateAttestation(methodName, args));
+    }
+  }
+
+  return wrapped;
+}
+
+/**
+ * Wrap an ethers Contract so the SDK's existing high-level methods keep their
+ * public API while targeting the upgraded Attestation-bearing selectors.
+ *
+ * `connect()` is wrapped recursively because every state-changing SDK path uses
+ * `this.contract.connect(wallet)` before invoking the contract.
+ */
+export function wrapPredicateContract(contract) {
+  if (!contract || contract[PREDICATE_WRAPPED]) return contract;
+
+  return new Proxy(contract, {
+    get(target, prop) {
+      if (prop === PREDICATE_WRAPPED) return true;
+
+      if (prop === "connect") {
+        return (runner) => wrapPredicateContract(target.connect(runner));
+      }
+
+      if (
+        typeof prop === "string" &&
+        Object.prototype.hasOwnProperty.call(PREDICATE_BUSINESS_ARG_COUNTS, prop)
+      ) {
+        const method = target[prop];
+        if (typeof method === "function") {
+          return wrapPredicateMethod(prop, method);
+        }
+      }
+
+      return Reflect.get(target, prop, target);
+    },
+  });
+}

package/src/predicate-fee-aware-clients.js

@@ -0,0 +1,31 @@
+import {
+  ConfidentialTransferClient as FeeAwareConfidentialTransferClient,
+  ControlledConfidentialTransferClient as FeeAwareControlledConfidentialTransferClient,
+  AnonymousTransferClient,
+  WITHDRAW_FEE_PPM_DENOMINATOR,
+} from "./fee-aware-clients.js";
+import { wrapPredicateContract } from "./predicate-contract.js";
+
+/**
+ * Public non-anonymous clients target the upgraded ConfidentialMirror ABI.
+ * Existing SDK methods still call the pre-Predicate argument shape internally;
+ * the wrapped ethers Contract inserts an empty attestation while enforcement is
+ * disabled, without changing the high-level SDK API.
+ */
+export class ConfidentialTransferClient extends FeeAwareConfidentialTransferClient {
+  constructor(...args) {
+    super(...args);
+    this.contract = wrapPredicateContract(this.contract);
+  }
+}
+
+export class ControlledConfidentialTransferClient extends FeeAwareControlledConfidentialTransferClient {
+  constructor(...args) {
+    super(...args);
+    this.contract = wrapPredicateContract(this.contract);
+  }
+}
+
+// Anonymous flows are intentionally not Predicate-gated and must remain
+// byte-for-byte/API compatible with the existing anonymous client behavior.
+export { AnonymousTransferClient, WITHDRAW_FEE_PPM_DENOMINATOR };