uvd-x402-sdk 2.17.0 → 2.19.0

package/dist/backend/index.js

@@ -1,5 +1,12 @@
 'use strict';
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/types/index.ts
 var CAIP2_IDENTIFIERS = {
   // EVM chains
@@ -1901,15 +1908,66 @@ function escrowTimeRemaining(escrow) {
   return new Date(escrow.expiresAt).getTime() - Date.now();
 }
 var ERC8004_EXTENSION_ID = "8004-reputation";
+var MAINNET_IDENTITY = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+var MAINNET_REPUTATION = "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63";
+var TESTNET_IDENTITY = "0x8004A818BFB912233c491871b3d84c89A494BD9e";
+var TESTNET_REPUTATION = "0x8004B663056A597Dffe9eCcC1965A193B7388713";
+var TESTNET_VALIDATION = "0x8004Cb1BF31DAf7788923b405b754f57acEB4272";
 var ERC8004_CONTRACTS = {
+  // Mainnets (7)
   ethereum: {
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63"
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  "base-mainnet": {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  polygon: {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
   },
+  arbitrum: {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  celo: {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  bsc: {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  monad: {
+    identityRegistry: MAINNET_IDENTITY,
+    reputationRegistry: MAINNET_REPUTATION
+  },
+  // Testnets (5)
   "ethereum-sepolia": {
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
-    validationRegistry: "0x8004Cb1BF31DAf7788923b405b754f57acEB4272"
+    identityRegistry: TESTNET_IDENTITY,
+    reputationRegistry: TESTNET_REPUTATION,
+    validationRegistry: TESTNET_VALIDATION
+  },
+  "base-sepolia": {
+    identityRegistry: TESTNET_IDENTITY,
+    reputationRegistry: TESTNET_REPUTATION,
+    validationRegistry: TESTNET_VALIDATION
+  },
+  "polygon-amoy": {
+    identityRegistry: TESTNET_IDENTITY,
+    reputationRegistry: TESTNET_REPUTATION,
+    validationRegistry: TESTNET_VALIDATION
+  },
+  "arbitrum-sepolia": {
+    identityRegistry: TESTNET_IDENTITY,
+    reputationRegistry: TESTNET_REPUTATION,
+    validationRegistry: TESTNET_VALIDATION
+  },
+  "celo-sepolia": {
+    identityRegistry: TESTNET_IDENTITY,
+    reputationRegistry: TESTNET_REPUTATION,
+    validationRegistry: TESTNET_VALIDATION
   }
 };
 var Erc8004Client = class {
@@ -2241,15 +2299,389 @@ function buildErc8004PaymentRequirements(options) {
     }
   };
 }
+var PAYMENT_INFO_TYPEHASH = "0xae68ac7ce30c86ece8196b61a7c486d8f0061f575037fbd34e7fe4e2820c6591";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var DEPOSIT_LIMIT_USDC = "100000000";
+var BASE_MAINNET_CONTRACTS = {
+  operator: "0xa06958D93135BEd7e43893897C0d9fA931EF051C",
+  escrow: "0x320a3c35F131E5D2Fb36af56345726B298936037",
+  tokenCollector: "0x32d6AC59BCe8DFB3026F10BcaDB8D00AB218f5b6",
+  usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+};
+var TIER_TIMINGS = {
+  micro: { pre: 3600, auth: 7200, refund: 86400 },
+  standard: { pre: 7200, auth: 86400, refund: 604800 },
+  premium: { pre: 14400, auth: 172800, refund: 1209600 },
+  enterprise: { pre: 86400, auth: 604800, refund: 2592e3 }
+};
+var OPERATOR_ABI = [
+  "function release(tuple(address operator, address payer, address receiver, address token, uint120 maxAmount, uint48 preApprovalExpiry, uint48 authorizationExpiry, uint48 refundExpiry, uint16 minFeeBps, uint16 maxFeeBps, address feeReceiver, uint256 salt) paymentInfo, uint256 amount)",
+  "function refundInEscrow(tuple(address operator, address payer, address receiver, address token, uint120 maxAmount, uint48 preApprovalExpiry, uint48 authorizationExpiry, uint48 refundExpiry, uint16 minFeeBps, uint16 maxFeeBps, address feeReceiver, uint256 salt) paymentInfo, uint120 amount)",
+  "function charge(tuple(address operator, address payer, address receiver, address token, uint120 maxAmount, uint48 preApprovalExpiry, uint48 authorizationExpiry, uint48 refundExpiry, uint16 minFeeBps, uint16 maxFeeBps, address feeReceiver, uint256 salt) paymentInfo, uint256 amount, address tokenCollector, bytes collectorData)",
+  "function refundPostEscrow(tuple(address operator, address payer, address receiver, address token, uint120 maxAmount, uint48 preApprovalExpiry, uint48 authorizationExpiry, uint48 refundExpiry, uint16 minFeeBps, uint16 maxFeeBps, address feeReceiver, uint256 salt) paymentInfo, uint256 amount, address tokenCollector, bytes collectorData)"
+];
+var AdvancedEscrowClient = class {
+  facilitatorUrl;
+  chainId;
+  gasLimit;
+  contracts;
+  signer;
+  // ethers.Signer
+  payerAddress = "";
+  constructor(signer, options = {}) {
+    this.signer = signer;
+    this.facilitatorUrl = (options.facilitatorUrl || "https://facilitator.ultravioletadao.xyz").replace(/\/$/, "");
+    this.chainId = options.chainId || 8453;
+    this.gasLimit = options.gasLimit || 3e5;
+    this.contracts = options.contracts || BASE_MAINNET_CONTRACTS;
+  }
+  /**
+   * Initialize the client (resolves signer address).
+   * Call this before using any methods.
+   */
+  async init() {
+    this.payerAddress = await this.signer.getAddress();
+  }
+  /**
+   * Build a PaymentInfo struct with appropriate timing for the task tier.
+   *
+   * @param receiver - Worker's wallet address
+   * @param amount - Amount in token atomic units (e.g., '5000000' for $5 USDC)
+   * @param tier - Task tier determines timing parameters
+   * @param salt - Random salt (auto-generated if not provided)
+   */
+  buildPaymentInfo(receiver, amount, tier = "standard", salt) {
+    const now = Math.floor(Date.now() / 1e3);
+    const t = TIER_TIMINGS[tier];
+    let generatedSalt = salt;
+    if (!generatedSalt) {
+      const bytes = new Uint8Array(32);
+      if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+      } else {
+        const nodeCrypto = __require("crypto");
+        const buf = nodeCrypto.randomBytes(32);
+        bytes.set(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+      }
+      generatedSalt = "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return {
+      operator: this.contracts.operator,
+      receiver,
+      token: this.contracts.usdc,
+      maxAmount: amount,
+      preApprovalExpiry: now + t.pre,
+      authorizationExpiry: now + t.auth,
+      refundExpiry: now + t.refund,
+      minFeeBps: 0,
+      maxFeeBps: 800,
+      feeReceiver: this.contracts.operator,
+      salt: generatedSalt
+    };
+  }
+  /**
+   * Compute the correct nonce (with PAYMENT_INFO_TYPEHASH).
+   * Matches the on-chain AuthCaptureEscrow nonce derivation.
+   */
+  async computeNonce(paymentInfo) {
+    const { ethers } = await import('ethers');
+    const piTuple = ethers.AbiCoder.defaultAbiCoder().encode(
+      ["bytes32", "tuple(address,address,address,address,uint120,uint48,uint48,uint48,uint16,uint16,address,uint256)"],
+      [
+        PAYMENT_INFO_TYPEHASH,
+        [
+          paymentInfo.operator,
+          ZERO_ADDRESS,
+          // payer = 0 for payer-agnostic hash
+          paymentInfo.receiver,
+          paymentInfo.token,
+          paymentInfo.maxAmount,
+          paymentInfo.preApprovalExpiry,
+          paymentInfo.authorizationExpiry,
+          paymentInfo.refundExpiry,
+          paymentInfo.minFeeBps,
+          paymentInfo.maxFeeBps,
+          paymentInfo.feeReceiver,
+          paymentInfo.salt
+        ]
+      ]
+    );
+    const piHash = ethers.keccak256(piTuple);
+    const finalEncoded = ethers.AbiCoder.defaultAbiCoder().encode(
+      ["uint256", "address", "bytes32"],
+      [this.chainId, this.contracts.escrow, piHash]
+    );
+    return ethers.keccak256(finalEncoded);
+  }
+  /**
+   * Sign ReceiveWithAuthorization for ERC-3009.
+   */
+  async signErc3009(auth) {
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.chainId,
+      verifyingContract: this.contracts.usdc
+    };
+    const types = {
+      ReceiveWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from: auth.from,
+      to: auth.to,
+      value: auth.value,
+      validAfter: auth.validAfter,
+      validBefore: auth.validBefore,
+      nonce: auth.nonce
+    };
+    return this.signer.signTypedData(domain, types, message);
+  }
+  /**
+   * Build the on-chain PaymentInfo tuple for contract calls.
+   */
+  buildTuple(pi) {
+    return [
+      pi.operator,
+      this.payerAddress,
+      pi.receiver,
+      pi.token,
+      pi.maxAmount,
+      pi.preApprovalExpiry,
+      pi.authorizationExpiry,
+      pi.refundExpiry,
+      pi.minFeeBps,
+      pi.maxFeeBps,
+      pi.feeReceiver,
+      pi.salt
+    ];
+  }
+  /**
+   * AUTHORIZE: Lock funds in escrow via the facilitator.
+   *
+   * Sends an ERC-3009 ReceiveWithAuthorization to the facilitator,
+   * which calls PaymentOperator.authorize() on-chain.
+   */
+  async authorize(paymentInfo) {
+    if (!this.payerAddress) await this.init();
+    try {
+      const nonce = await this.computeNonce(paymentInfo);
+      const auth = {
+        from: this.payerAddress,
+        to: this.contracts.tokenCollector,
+        value: paymentInfo.maxAmount,
+        validAfter: "0",
+        validBefore: String(paymentInfo.preApprovalExpiry),
+        nonce
+      };
+      const signature = await this.signErc3009(auth);
+      const payload = {
+        x402Version: 2,
+        scheme: "escrow",
+        payload: {
+          authorization: auth,
+          signature,
+          paymentInfo
+        },
+        paymentRequirements: {
+          scheme: "escrow",
+          network: `eip155:${this.chainId}`,
+          maxAmountRequired: paymentInfo.maxAmount,
+          asset: this.contracts.usdc,
+          payTo: paymentInfo.receiver,
+          extra: {
+            escrowAddress: this.contracts.escrow,
+            operatorAddress: this.contracts.operator,
+            tokenCollector: this.contracts.tokenCollector
+          }
+        }
+      };
+      const response = await fetch(`${this.facilitatorUrl}/settle`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      const result = await response.json();
+      if (result.success) {
+        return {
+          success: true,
+          transactionHash: result.transaction,
+          paymentInfo,
+          salt: paymentInfo.salt
+        };
+      }
+      return { success: false, error: result.errorReason };
+    } catch (e) {
+      return { success: false, error: e.message || String(e) };
+    }
+  }
+  /**
+   * RELEASE: Capture escrowed funds to receiver (worker gets paid).
+   *
+   * Calls PaymentOperator.release() -> escrow.capture()
+   *
+   * @param paymentInfo - PaymentInfo from the authorize step
+   * @param amount - Amount to release (defaults to maxAmount)
+   */
+  async release(paymentInfo, amount) {
+    if (!this.payerAddress) await this.init();
+    try {
+      const { ethers } = await import('ethers');
+      const contract = new ethers.Contract(this.contracts.operator, OPERATOR_ABI, this.signer);
+      const amt = amount || paymentInfo.maxAmount;
+      const tuple = this.buildTuple(paymentInfo);
+      const tx = await contract.release(tuple, amt, { gasLimit: this.gasLimit });
+      const receipt = await tx.wait();
+      return {
+        success: receipt.status === 1,
+        transactionHash: receipt.hash,
+        gasUsed: Number(receipt.gasUsed),
+        error: receipt.status !== 1 ? "Transaction reverted" : void 0
+      };
+    } catch (e) {
+      return { success: false, error: e.message || String(e) };
+    }
+  }
+  /**
+   * REFUND IN ESCROW: Return escrowed funds to payer (cancel task).
+   *
+   * Calls PaymentOperator.refundInEscrow() -> escrow.partialVoid()
+   *
+   * @param paymentInfo - PaymentInfo from the authorize step
+   * @param amount - Amount to refund (defaults to maxAmount)
+   */
+  async refundInEscrow(paymentInfo, amount) {
+    if (!this.payerAddress) await this.init();
+    try {
+      const { ethers } = await import('ethers');
+      const contract = new ethers.Contract(this.contracts.operator, OPERATOR_ABI, this.signer);
+      const amt = amount || paymentInfo.maxAmount;
+      const tuple = this.buildTuple(paymentInfo);
+      const tx = await contract.refundInEscrow(tuple, amt, { gasLimit: this.gasLimit });
+      const receipt = await tx.wait();
+      return {
+        success: receipt.status === 1,
+        transactionHash: receipt.hash,
+        gasUsed: Number(receipt.gasUsed),
+        error: receipt.status !== 1 ? "Transaction reverted" : void 0
+      };
+    } catch (e) {
+      return { success: false, error: e.message || String(e) };
+    }
+  }
+  /**
+   * CHARGE: Direct instant payment (no escrow hold).
+   *
+   * Calls PaymentOperator.charge() -> escrow.charge()
+   * Funds go directly from payer to receiver.
+   *
+   * @param paymentInfo - PaymentInfo with receiver and amount
+   * @param amount - Amount to charge (defaults to maxAmount)
+   */
+  async charge(paymentInfo, amount) {
+    if (!this.payerAddress) await this.init();
+    try {
+      const { ethers } = await import('ethers');
+      const nonce = await this.computeNonce(paymentInfo);
+      const amt = amount || paymentInfo.maxAmount;
+      const auth = {
+        from: this.payerAddress,
+        to: this.contracts.tokenCollector,
+        value: String(amt),
+        validAfter: "0",
+        validBefore: String(paymentInfo.preApprovalExpiry),
+        nonce
+      };
+      const signature = await this.signErc3009(auth);
+      const collectorData = ethers.getBytes(signature);
+      const contract = new ethers.Contract(this.contracts.operator, OPERATOR_ABI, this.signer);
+      const tuple = this.buildTuple(paymentInfo);
+      const tx = await contract.charge(
+        tuple,
+        amt,
+        this.contracts.tokenCollector,
+        collectorData,
+        { gasLimit: this.gasLimit }
+      );
+      const receipt = await tx.wait();
+      return {
+        success: receipt.status === 1,
+        transactionHash: receipt.hash,
+        gasUsed: Number(receipt.gasUsed),
+        error: receipt.status !== 1 ? "Transaction reverted" : void 0
+      };
+    } catch (e) {
+      return { success: false, error: e.message || String(e) };
+    }
+  }
+  /**
+   * REFUND POST ESCROW: Dispute refund after funds were released.
+   *
+   * Calls PaymentOperator.refundPostEscrow() -> escrow.refund()
+   *
+   * WARNING: NOT FUNCTIONAL IN PRODUCTION (as of 2026-02-03).
+   * The protocol team has not implemented the required tokenCollector
+   * contract. This call will fail on-chain.
+   *
+   * For dispute resolution, use refundInEscrow() instead: keep funds
+   * in escrow and refund before releasing. This guarantees funds are
+   * available and under arbiter control.
+   *
+   * Kept for future use when tokenCollector is implemented.
+   *
+   * @param paymentInfo - PaymentInfo from the original authorization
+   * @param amount - Amount to refund (defaults to maxAmount)
+   * @param tokenCollector - Address of token collector for refund sourcing
+   * @param collectorData - Data for the token collector
+   */
+  async refundPostEscrow(paymentInfo, amount, tokenCollector, collectorData) {
+    if (!this.payerAddress) await this.init();
+    try {
+      const { ethers } = await import('ethers');
+      const contract = new ethers.Contract(this.contracts.operator, OPERATOR_ABI, this.signer);
+      const amt = amount || paymentInfo.maxAmount;
+      const tuple = this.buildTuple(paymentInfo);
+      const tx = await contract.refundPostEscrow(
+        tuple,
+        amt,
+        tokenCollector || ZERO_ADDRESS,
+        collectorData || "0x",
+        { gasLimit: this.gasLimit }
+      );
+      const receipt = await tx.wait();
+      return {
+        success: receipt.status === 1,
+        transactionHash: receipt.hash,
+        gasUsed: Number(receipt.gasUsed),
+        error: receipt.status !== 1 ? "Transaction reverted" : void 0
+      };
+    } catch (e) {
+      return { success: false, error: e.message || String(e) };
+    }
+  }
+};
 
+exports.AdvancedEscrowClient = AdvancedEscrowClient;
+exports.BASE_MAINNET_CONTRACTS = BASE_MAINNET_CONTRACTS;
 exports.BazaarClient = BazaarClient;
+exports.DEPOSIT_LIMIT_USDC = DEPOSIT_LIMIT_USDC;
 exports.ERC8004_CONTRACTS = ERC8004_CONTRACTS;
 exports.ERC8004_EXTENSION_ID = ERC8004_EXTENSION_ID;
 exports.Erc8004Client = Erc8004Client;
 exports.EscrowClient = EscrowClient;
 exports.FacilitatorClient = FacilitatorClient;
+exports.OPERATOR_ABI = OPERATOR_ABI;
+exports.PAYMENT_INFO_TYPEHASH = PAYMENT_INFO_TYPEHASH;
+exports.TIER_TIMINGS = TIER_TIMINGS;
 exports.X402_CORS_HEADERS = X402_CORS_HEADERS;
 exports.X402_HEADER_NAMES = X402_HEADER_NAMES;
+exports.ZERO_ADDRESS = ZERO_ADDRESS;
 exports.buildErc8004PaymentRequirements = buildErc8004PaymentRequirements;
 exports.buildPaymentRequirements = buildPaymentRequirements;
 exports.buildSettleRequest = buildSettleRequest;