@x402r/refund 0.0.0

package/dist/cjs/index.js

@@ -0,0 +1,713 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  REFUND_EXTENSION_KEY: () => REFUND_EXTENSION_KEY,
+  REFUND_MARKER_KEY: () => REFUND_MARKER_KEY,
+  computeRelayAddress: () => computeRelayAddress,
+  declareRefundExtension: () => declareRefundExtension,
+  extractRefundInfo: () => extractRefundInfo,
+  isRefundableOption: () => isRefundableOption,
+  refundable: () => refundable,
+  settleWithRefundHelper: () => settleWithRefundHelper,
+  withRefund: () => withRefund
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var REFUND_EXTENSION_KEY = "refund";
+var REFUND_MARKER_KEY = "_x402_refund";
+function isRefundableOption(option) {
+  return option.extra !== void 0 && typeof option.extra === "object" && option.extra !== null && REFUND_MARKER_KEY in option.extra && option.extra[REFUND_MARKER_KEY] === true;
+}
+
+// src/server/computeRelayAddress.ts
+var import_viem = require("viem");
+var import_predict_deterministic_address = require("@whoislewys/predict-deterministic-address");
+function computeRelayAddress(createxAddress, factoryAddress, merchantPayout) {
+  const createx = (0, import_viem.getAddress)(createxAddress);
+  const factory = (0, import_viem.getAddress)(factoryAddress);
+  const merchant = (0, import_viem.getAddress)(merchantPayout);
+  const salt = (0, import_viem.keccak256)((0, import_viem.encodePacked)(["address", "address"], [factory, merchant]));
+  const guardedSalt = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)([{ type: "bytes32" }], [salt])
+  );
+  return (0, import_predict_deterministic_address.predictCreate3Address)(createx, guardedSalt);
+}
+
+// src/server.ts
+function declareRefundExtension(factoryAddress, merchantPayouts) {
+  return {
+    [REFUND_EXTENSION_KEY]: {
+      info: {
+        factoryAddress,
+        merchantPayouts
+      },
+      schema: {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        properties: {
+          factoryAddress: {
+            type: "string",
+            pattern: "^0x[a-fA-F0-9]{40}$",
+            description: "The X402DepositRelayFactory contract address"
+          },
+          merchantPayouts: {
+            type: "object",
+            additionalProperties: {
+              type: "string",
+              pattern: "^0x[a-fA-F0-9]{40}$"
+            },
+            description: "Map of proxy address to merchant payout address"
+          }
+        },
+        required: ["factoryAddress", "merchantPayouts"],
+        additionalProperties: false
+      }
+    }
+  };
+}
+function refundable(option) {
+  const clonedOption = {
+    ...option,
+    extra: {
+      ...option.extra
+    }
+  };
+  if (!clonedOption.extra) {
+    clonedOption.extra = {};
+  }
+  clonedOption.extra[REFUND_MARKER_KEY] = true;
+  return clonedOption;
+}
+var STANDARD_CREATEX_ADDRESSES = {
+  // Ethereum Mainnet
+  "eip155:1": "0xba5Ed099633D3B313e4D5F7bdc1305d3c32ba066",
+  // Base Mainnet
+  "eip155:8453": "0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed",
+  // Base Sepolia
+  "eip155:84532": "0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed"
+  // Add more networks as CreateX deployments become available
+};
+function withRefund(routes, factoryAddress, createxAddress) {
+  if (typeof routes === "object" && routes !== null && !("accepts" in routes)) {
+    const nestedRoutes = routes;
+    const processedRoutes = {};
+    for (const [pattern, config] of Object.entries(nestedRoutes)) {
+      processedRoutes[pattern] = processRouteConfig(config, factoryAddress, createxAddress);
+    }
+    return processedRoutes;
+  } else {
+    return processRouteConfig(routes, factoryAddress, createxAddress);
+  }
+}
+function getCreateXAddress(network, providedAddress) {
+  if (providedAddress) {
+    return providedAddress;
+  }
+  const standardAddress = STANDARD_CREATEX_ADDRESSES[network];
+  if (standardAddress) {
+    return standardAddress;
+  }
+  throw new Error(
+    `CreateX address not provided and no standard address found for network ${network}. Please provide createxAddress parameter or check if CreateX is deployed on this network. See https://github.com/pcaversaccio/createx#createx-deployments for standard deployments.`
+  );
+}
+function processRouteConfig(config, factoryAddress, createxAddress) {
+  const firstOption = Array.isArray(config.accepts) ? config.accepts[0] : config.accepts;
+  const network = firstOption?.network;
+  if (!network) {
+    throw new Error("Payment option must have a network field to determine CreateX address");
+  }
+  const resolvedCreatexAddress = getCreateXAddress(network, createxAddress);
+  const hasRefundable = Array.isArray(config.accepts) ? config.accepts.some(isRefundableOption) : isRefundableOption(config.accepts);
+  const merchantPayoutsMap = {};
+  if (hasRefundable) {
+    const refundableOptions = Array.isArray(config.accepts) ? config.accepts.filter(isRefundableOption) : isRefundableOption(config.accepts) ? [config.accepts] : [];
+    for (const option of refundableOptions) {
+      if (typeof option.payTo === "string") {
+        const merchantPayout = option.payTo;
+        const proxyAddress = computeRelayAddress(
+          resolvedCreatexAddress,
+          factoryAddress,
+          merchantPayout
+        );
+        merchantPayoutsMap[proxyAddress.toLowerCase()] = merchantPayout;
+      }
+    }
+  }
+  const processedConfig = {
+    ...config,
+    accepts: Array.isArray(config.accepts) ? config.accepts.map(
+      (option) => processPaymentOption(option, factoryAddress, resolvedCreatexAddress)
+    ) : processPaymentOption(config.accepts, factoryAddress, resolvedCreatexAddress),
+    extensions: {
+      ...config.extensions
+    }
+  };
+  if (hasRefundable && Object.keys(merchantPayoutsMap).length > 0) {
+    processedConfig.extensions = {
+      ...processedConfig.extensions,
+      ...declareRefundExtension(factoryAddress, merchantPayoutsMap)
+    };
+  } else if (hasRefundable) {
+    throw new Error(
+      "Refundable option must have a string payTo address. DynamicPayTo is not supported for refundable options."
+    );
+  }
+  return processedConfig;
+}
+function processPaymentOption(option, factoryAddress, createxAddress) {
+  if (isRefundableOption(option)) {
+    const merchantPayout = option.payTo;
+    if (typeof merchantPayout !== "string") {
+      throw new Error(
+        "DynamicPayTo is not supported for refundable options. Use a static address."
+      );
+    }
+    const proxyAddress = computeRelayAddress(createxAddress, factoryAddress, merchantPayout);
+    const processedOption = {
+      ...option,
+      payTo: proxyAddress,
+      // Set payTo to proxy address
+      extra: {
+        ...option.extra
+      }
+    };
+    if (processedOption.extra) {
+      delete processedOption.extra[REFUND_MARKER_KEY];
+    }
+    return processedOption;
+  }
+  return { ...option, extra: { ...option.extra } };
+}
+
+// src/facilitator.ts
+var import_viem2 = require("viem");
+function isRateLimitError(error) {
+  if (error && typeof error === "object") {
+    const err = error;
+    if (err.status === 429) {
+      return true;
+    }
+    const message = err.message || err.details || "";
+    if (typeof message === "string" && message.toLowerCase().includes("rate limit")) {
+      return true;
+    }
+    if (err.cause && isRateLimitError(err.cause)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function readContractWithRetry(signer, args, maxRetries = 5) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await signer.readContract(args);
+    } catch (error) {
+      lastError = error;
+      if (!isRateLimitError(error)) {
+        throw error;
+      }
+      if (attempt >= maxRetries) {
+        break;
+      }
+      const delayMs = Math.min(1e3 * Math.pow(2, attempt), 16e3);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw lastError;
+}
+var FACTORY_ABI = [
+  {
+    name: "getMerchantFromRelay",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "relayAddress", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "getRelayAddress",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "merchantPayout", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "deployRelay",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "merchantPayout", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "getCreateX",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+var ESCROW_ABI = [
+  {
+    name: "registerMerchant",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "merchantPayout", type: "address" },
+      { name: "arbiter", type: "address" }
+    ],
+    outputs: []
+  },
+  {
+    name: "registeredMerchants",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "merchantPayout", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "merchantArbiters",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "merchantPayout", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "getArbiter",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "merchantPayout", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "noteDeposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "merchantPayout", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "release",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "depositNonce", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "refund",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "depositNonce", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "deposits",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "depositNonce", type: "uint256" }
+    ],
+    outputs: [
+      { name: "principal", type: "uint256" },
+      { name: "timestamp", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "merchantPayout", type: "address" }
+    ]
+  }
+];
+var RELAY_PROXY_ABI = [
+  {
+    name: "executeDeposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "fromUser", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    name: "MERCHANT_PAYOUT",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "TOKEN",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "ESCROW",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+function extractRefundInfo(paymentPayload, _) {
+  const extension = paymentPayload.extensions?.[REFUND_EXTENSION_KEY];
+  if (!extension || !extension.info || !extension.info.factoryAddress) {
+    return null;
+  }
+  const factoryAddress = extension.info.factoryAddress;
+  const merchantPayouts = extension.info.merchantPayouts || {};
+  if (!(0, import_viem2.isAddress)(factoryAddress)) {
+    return null;
+  }
+  return { factoryAddress, merchantPayouts };
+}
+async function settleWithRefundHelper(paymentPayload, paymentRequirements, signer) {
+  const refundInfo = extractRefundInfo(paymentPayload, paymentRequirements);
+  if (!refundInfo) {
+    return null;
+  }
+  const factoryAddress = refundInfo.factoryAddress;
+  const merchantPayouts = refundInfo.merchantPayouts;
+  try {
+    const factoryCode = await signer.getCode({ address: (0, import_viem2.getAddress)(factoryAddress) });
+    if (!factoryCode || factoryCode === "0x" || factoryCode.length <= 2) {
+      throw new Error(
+        `Factory contract does not exist at ${factoryAddress}. Invalid refund extension.`
+      );
+    }
+  } catch (error2) {
+    throw new Error(
+      `Failed to check factory contract: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  const proxyAddress = (0, import_viem2.getAddress)(paymentRequirements.payTo);
+  const relayCode = await signer.getCode({ address: proxyAddress });
+  const relayExists = relayCode && relayCode !== "0x" && relayCode.length > 2;
+  let merchantPayout;
+  let escrowAddress;
+  if (relayExists) {
+    try {
+      merchantPayout = await readContractWithRetry(signer, {
+        address: proxyAddress,
+        abi: RELAY_PROXY_ABI,
+        functionName: "MERCHANT_PAYOUT",
+        args: []
+      });
+      escrowAddress = await readContractWithRetry(signer, {
+        address: proxyAddress,
+        abi: RELAY_PROXY_ABI,
+        functionName: "ESCROW",
+        args: []
+      });
+    } catch (error2) {
+      return null;
+    }
+  } else {
+    const proxyAddressLower = proxyAddress.toLowerCase();
+    merchantPayout = merchantPayouts[proxyAddress] || merchantPayouts[proxyAddressLower];
+    if (!merchantPayout || merchantPayout === import_viem2.zeroAddress) {
+      return null;
+    }
+  }
+  if (!merchantPayout || merchantPayout === import_viem2.zeroAddress) {
+    return null;
+  }
+  if (!relayExists) {
+    try {
+      const expectedAddress = await readContractWithRetry(signer, {
+        address: (0, import_viem2.getAddress)(factoryAddress),
+        abi: FACTORY_ABI,
+        functionName: "getRelayAddress",
+        args: [(0, import_viem2.getAddress)(merchantPayout)]
+      });
+      if (expectedAddress.toLowerCase() !== proxyAddress.toLowerCase()) {
+        throw new Error(
+          `Address mismatch: Factory computed ${expectedAddress} but expected ${proxyAddress}. This may indicate a version or CreateX address mismatch.`
+        );
+      }
+      const txHash = await signer.writeContract({
+        address: (0, import_viem2.getAddress)(factoryAddress),
+        abi: FACTORY_ABI,
+        functionName: "deployRelay",
+        args: [(0, import_viem2.getAddress)(merchantPayout)]
+      });
+      const receipt = await signer.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status !== "success") {
+        throw new Error(`Relay deployment transaction failed: ${txHash}. Transaction reverted.`);
+      }
+      let deployedCode;
+      for (let i = 0; i < 5; i++) {
+        if (i > 0) {
+          const delay = 1e3 * i;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        deployedCode = await signer.getCode({ address: proxyAddress });
+        if (deployedCode && deployedCode !== "0x" && deployedCode.length > 2) {
+          break;
+        }
+      }
+      if (!deployedCode || deployedCode === "0x" || deployedCode.length <= 2) {
+        const actualAddress = await readContractWithRetry(signer, {
+          address: (0, import_viem2.getAddress)(factoryAddress),
+          abi: FACTORY_ABI,
+          functionName: "getRelayAddress",
+          args: [(0, import_viem2.getAddress)(merchantPayout)]
+        });
+        throw new Error(
+          `Relay deployment completed but contract code not found at ${proxyAddress}. Transaction hash: ${txHash}. Factory computed address: ${actualAddress}. Expected address: ${proxyAddress}. This may indicate a CREATE3 deployment issue, timing problem, or address computation mismatch.`
+        );
+      }
+      escrowAddress = await readContractWithRetry(signer, {
+        address: proxyAddress,
+        abi: RELAY_PROXY_ABI,
+        functionName: "ESCROW",
+        args: []
+      });
+    } catch (error2) {
+      const errorMessage2 = error2 instanceof Error ? error2.message : String(error2);
+      const errorString = errorMessage2.toLowerCase();
+      if (errorString.includes("insufficient funds") || errorString.includes("exceeds the balance") || errorString.includes("insufficient balance") || errorString.includes("the total cost") || errorString.includes("exceeds the balance of the account")) {
+        const facilitatorAddress = signer.getAddresses()[0];
+        throw new Error(
+          `Failed to deploy relay: Insufficient funds in facilitator account.
+The facilitator account (${facilitatorAddress}) does not have enough ETH to pay for gas to deploy the relay contract.
+Please fund the facilitator account with ETH to cover gas costs.
+Original error: ${errorMessage2}`
+        );
+      }
+      throw new Error(
+        `Failed to deploy relay: ${errorMessage2}`
+      );
+    }
+  }
+  if (!escrowAddress) {
+    throw new Error("Internal error: escrowAddress not set after deployment check");
+  }
+  let isRegistered;
+  try {
+    isRegistered = await readContractWithRetry(signer, {
+      address: (0, import_viem2.getAddress)(escrowAddress),
+      abi: ESCROW_ABI,
+      functionName: "registeredMerchants",
+      args: [(0, import_viem2.getAddress)(merchantPayout)]
+    });
+  } catch (error2) {
+    throw new Error(
+      `Failed to check merchant registration: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  if (!isRegistered) {
+    throw new Error(
+      `Merchant ${merchantPayout} is not registered. Please register at https://app.402r.org to enable refund functionality.`
+    );
+  }
+  const payload = paymentPayload.payload;
+  if (!payload.authorization || !payload.signature) {
+    return null;
+  }
+  const { authorization, signature } = payload;
+  const authTo = (0, import_viem2.getAddress)(authorization.to);
+  if (authTo !== proxyAddress) {
+    throw new Error(
+      `Authorization 'to' address (${authTo}) does not match proxy address (${proxyAddress}). The ERC3009 signature must be signed with to=proxyAddress.`
+    );
+  }
+  try {
+    const proxyToken = await readContractWithRetry(signer, {
+      address: proxyAddress,
+      abi: RELAY_PROXY_ABI,
+      functionName: "TOKEN",
+      args: []
+    });
+    const proxyTokenNormalized = (0, import_viem2.getAddress)(proxyToken);
+    const paymentAssetNormalized = (0, import_viem2.getAddress)(paymentRequirements.asset);
+    if (proxyTokenNormalized !== paymentAssetNormalized) {
+      const errorMsg = `\u274C ADDRESS MISMATCH: Proxy has ${proxyTokenNormalized} but payment requires ${paymentAssetNormalized}. The proxy was deployed with the wrong address. This causes transferWithAuthorization to fail. Solution: Redeploy the proxy with the correct address: ${paymentAssetNormalized}`;
+      throw new Error(errorMsg);
+    }
+    const proxyEscrow = await readContractWithRetry(signer, {
+      address: proxyAddress,
+      abi: RELAY_PROXY_ABI,
+      functionName: "ESCROW",
+      args: []
+    });
+    if (proxyEscrow.toLowerCase() !== escrowAddress.toLowerCase()) {
+      throw new Error(
+        `Proxy ESCROW mismatch: proxy reports ${proxyEscrow} but we read ${escrowAddress} earlier`
+      );
+    }
+  } catch (error2) {
+    throw new Error(
+      `Failed to read proxy immutables. This may indicate a proxy deployment issue. Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+  }
+  let parsedSignature;
+  try {
+    const erc6492Result = (0, import_viem2.parseErc6492Signature)(signature);
+    parsedSignature = erc6492Result.signature;
+  } catch {
+    parsedSignature = signature;
+  }
+  const signatureLength = parsedSignature.startsWith("0x") ? parsedSignature.length - 2 : parsedSignature.length;
+  const isECDSA = signatureLength === 130;
+  if (!isECDSA) {
+    return null;
+  }
+  const parsedSig = (0, import_viem2.parseSignature)(parsedSignature);
+  const v = parsedSig.v ?? parsedSig.yParity ?? 0;
+  const r = parsedSig.r;
+  const s = parsedSig.s;
+  try {
+    const tokenAddress = (0, import_viem2.getAddress)(paymentRequirements.asset);
+    const nonceUsed = await readContractWithRetry(signer, {
+      address: tokenAddress,
+      abi: [
+        {
+          inputs: [
+            { name: "authorizer", type: "address" },
+            { name: "nonce", type: "bytes32" }
+          ],
+          name: "authorizationState",
+          outputs: [{ name: "", type: "bool" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "authorizationState",
+      args: [(0, import_viem2.getAddress)(authorization.from), authorization.nonce]
+    });
+    if (nonceUsed) {
+      throw new Error(
+        `ERC3009 nonce ${authorization.nonce} has already been used. This authorization cannot be reused.`
+      );
+    }
+  } catch (error2) {
+  }
+  let lastError;
+  const maxRetries = 5;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const txHash = await signer.writeContract({
+        address: proxyAddress,
+        abi: RELAY_PROXY_ABI,
+        functionName: "executeDeposit",
+        args: [
+          (0, import_viem2.getAddress)(authorization.from),
+          BigInt(authorization.value),
+          BigInt(authorization.validAfter),
+          BigInt(authorization.validBefore),
+          authorization.nonce,
+          v,
+          r,
+          s
+        ]
+      });
+      const receipt = await signer.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status !== "success") {
+        throw new Error(`Proxy.executeDeposit transaction failed: ${txHash}`);
+      }
+      return {
+        success: true,
+        transaction: txHash,
+        network: paymentRequirements.network,
+        payer: authorization.from
+      };
+    } catch (error2) {
+      lastError = error2;
+      if (attempt >= maxRetries) {
+        break;
+      }
+      const delayMs = (attempt + 1) * 1e3;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  const error = lastError;
+  let errorMessage = error instanceof Error ? error.message : String(error);
+  let revertReason;
+  if (error && typeof error === "object") {
+    const errorObj = error;
+    if (errorObj.cause && typeof errorObj.cause === "object") {
+      const cause = errorObj.cause;
+      if (typeof cause.reason === "string") {
+        revertReason = cause.reason;
+      }
+      if (cause.data && typeof cause.data === "string") {
+        if (cause.data.startsWith("0x08c379a0")) {
+          try {
+            const lengthHex = cause.data.slice(138, 202);
+            const length = parseInt(lengthHex, 16);
+            const stringHex = cause.data.slice(202, 202 + length * 2);
+            const decodedReason = Buffer.from(stringHex, "hex").toString("utf8").replace(/\0/g, "");
+            if (decodedReason) {
+              revertReason = decodedReason;
+            }
+          } catch (decodeErr) {
+          }
+        }
+      }
+    }
+    if (typeof errorObj.shortMessage === "string") {
+      if (!revertReason && errorObj.shortMessage.includes("reverted")) {
+        const match = errorObj.shortMessage.match(/reverted(?:[: ]+)?(.+)/i);
+        if (match && match[1]) {
+          revertReason = match[1].trim();
+        }
+      }
+    }
+  }
+  if (revertReason && revertReason !== "execution reverted") {
+    errorMessage = `Contract reverted: ${revertReason}`;
+  } else {
+    errorMessage = `Contract execution reverted (no specific revert reason available). All pre-checks passed: merchant registered, nonce unused, proxy immutables readable. Possible failure points in executeDeposit: 1) _readImmutable staticcall failing (unlikely - we can read immutables directly), 2) ERC3009 transferWithAuthorization failing when called through proxy (most likely), 3) Transfer to escrow failing, 4) Escrow.noteDeposit failing - POOL.supply() may be paused, asset not configured in Aave pool, or pool has restrictions. Check Aave pool status and asset configuration on Base Sepolia. Debugging: Use a transaction trace/debugger on the failed transaction to see exact revert point. The simulation succeeds, so the contract logic is correct - this is likely an execution context issue. Original error: ${errorMessage}`;
+  }
+  throw new Error(`Failed to execute proxy.executeDeposit: ${errorMessage}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REFUND_EXTENSION_KEY,
+  REFUND_MARKER_KEY,
+  computeRelayAddress,
+  declareRefundExtension,
+  extractRefundInfo,
+  isRefundableOption,
+  refundable,
+  settleWithRefundHelper,
+  withRefund
+});
+//# sourceMappingURL=index.js.map