@x402/evm 2.8.0 → 2.9.0

package/dist/esm/exact/client/index.mjs

@@ -1,13 +1,16 @@
 import {
   ExactEvmScheme,
-  createPermit2ApprovalTx,
-  getPermit2AllowanceReadParams,
   registerExactEvmScheme
-} from "../../chunk-WJWNS4G4.mjs";
-import "../../chunk-GD4MKCN7.mjs";
+} from "../../chunk-RN3WQM6A.mjs";
+import "../../chunk-YUJQ7TLD.mjs";
+import {
+  createPermit2ApprovalTx,
+  getPermit2AllowanceReadParams
+} from "../../chunk-WKBC5YMI.mjs";
+import "../../chunk-CRT6YNY5.mjs";
 import {
   erc20AllowanceAbi
-} from "../../chunk-IZEI7JTG.mjs";
+} from "../../chunk-C4ZQMS77.mjs";
 export {
   ExactEvmScheme,
   createPermit2ApprovalTx,

package/dist/esm/exact/facilitator/index.mjs

@@ -1,57 +1,42 @@
 import {
   isPermit2Payload
-} from "../../chunk-TKN5V2BV.mjs";
+} from "../../chunk-JII456TS.mjs";
+import {
+  ExactEvmSchemeV1,
+  NETWORKS,
+  diagnoseEip3009SimulationFailure,
+  executeTransferWithAuthorization,
+  simulateEip3009Transfer
+} from "../../chunk-YUJQ7TLD.mjs";
 import {
   ERC20_APPROVAL_GAS_SPONSORING_KEY,
+  buildExactPermit2SettleArgs,
+  checkPermit2Prerequisites,
+  diagnosePermit2SimulationFailure,
   extractEip2612GasSponsoringInfo,
   extractErc20ApprovalGasSponsoringInfo,
+  mapSettleError,
   resolveErc20ApprovalExtensionSigner,
-  validateEip2612GasSponsoringInfo,
-  validateErc20ApprovalGasSponsoringInfo
-} from "../../chunk-GD4MKCN7.mjs";
+  simulatePermit2Settle,
+  simulatePermit2SettleWithErc20Approval,
+  simulatePermit2SettleWithPermit,
+  splitEip2612Signature,
+  validateEip2612PermitForPayment,
+  validateErc20ApprovalForPayment,
+  waitAndReturnSettleResponse
+} from "../../chunk-CRT6YNY5.mjs";
 import {
-  DEFAULT_MAX_FEE_PER_GAS,
-  ERC20_APPROVE_GAS_LIMIT,
-  ErrEip2612AssetMismatch,
-  ErrEip2612DeadlineExpired,
-  ErrEip2612FromMismatch,
-  ErrEip2612SpenderNotPermit2,
-  ErrErc20ApprovalAssetMismatch,
-  ErrErc20ApprovalFromMismatch,
-  ErrErc20ApprovalInsufficientEthForGas,
-  ErrErc20ApprovalInvalidFormat,
-  ErrErc20ApprovalSpenderNotPermit2,
-  ErrErc20ApprovalTxFailed,
-  ErrErc20ApprovalTxInvalidCalldata,
-  ErrErc20ApprovalTxInvalidSignature,
-  ErrErc20ApprovalTxParseFailed,
-  ErrErc20ApprovalTxSignerMismatch,
-  ErrErc20ApprovalTxWrongSelector,
-  ErrErc20ApprovalTxWrongSpender,
-  ErrErc20ApprovalTxWrongTarget,
   ErrInvalidAuthorizationValue,
-  ErrInvalidEip2612ExtensionFormat,
   ErrInvalidScheme,
   ErrInvalidSignature,
-  ErrInvalidTransactionState,
   ErrMissingEip712Domain,
   ErrNetworkMismatch,
-  ErrPermit2612AmountMismatch,
-  ErrPermit2AllowanceRequired,
   ErrPermit2AmountMismatch,
   ErrPermit2DeadlineExpired,
-  ErrPermit2InsufficientBalance,
-  ErrPermit2InvalidAmount,
-  ErrPermit2InvalidDestination,
-  ErrPermit2InvalidNonce,
-  ErrPermit2InvalidOwner,
   ErrPermit2InvalidSignature,
   ErrPermit2InvalidSpender,
   ErrPermit2NotYetValid,
-  ErrPermit2PaymentTooEarly,
-  ErrPermit2ProxyNotDeployed,
   ErrPermit2RecipientMismatch,
-  ErrPermit2SimulationFailed,
   ErrPermit2TokenMismatch,
   ErrRecipientMismatch,
   ErrTransactionFailed,
@@ -59,24 +44,13 @@ import {
   ErrUnsupportedPayloadType,
   ErrValidAfterInFuture,
   ErrValidBeforeExpired,
-  ExactEvmSchemeV1,
-  MULTICALL3_ADDRESS,
-  NETWORKS,
   PERMIT2_ADDRESS,
   authorizationTypes,
-  diagnoseEip3009SimulationFailure,
-  eip3009ABI,
-  erc20AllowanceAbi,
-  erc20ApproveAbi,
-  executeTransferWithAuthorization,
   getEvmChainId,
-  multicall,
-  multicall3GetEthBalanceAbi,
   permit2WitnessTypes,
-  simulateEip3009Transfer,
   x402ExactPermit2ProxyABI,
   x402ExactPermit2ProxyAddress
-} from "../../chunk-IZEI7JTG.mjs";
+} from "../../chunk-C4ZQMS77.mjs";
 
 // src/exact/facilitator/eip3009.ts
 import { getAddress, isAddressEqual, parseErc6492Signature } from "viem";
@@ -276,361 +250,11 @@ async function settleEIP3009(signer, payload, requirements, eip3009Payload, conf
 }
 
 // src/exact/facilitator/permit2.ts
-import { getAddress as getAddress4 } from "viem";
-
-// src/exact/facilitator/erc20approval.ts
-import {
-  getAddress as getAddress2,
-  parseTransaction,
-  decodeFunctionData,
-  recoverTransactionAddress
-} from "viem";
-var APPROVE_SELECTOR = "0x095ea7b3";
-async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
-  if (!validateErc20ApprovalGasSponsoringInfo(info)) {
-    return {
-      isValid: false,
-      invalidReason: ErrErc20ApprovalInvalidFormat,
-      invalidMessage: "ERC-20 approval extension info failed schema validation"
-    };
-  }
-  if (getAddress2(info.from) !== getAddress2(payer)) {
-    return {
-      isValid: false,
-      invalidReason: ErrErc20ApprovalFromMismatch,
-      invalidMessage: `Expected from=${payer}, got ${info.from}`
-    };
-  }
-  if (getAddress2(info.asset) !== tokenAddress) {
-    return {
-      isValid: false,
-      invalidReason: ErrErc20ApprovalAssetMismatch,
-      invalidMessage: `Expected asset=${tokenAddress}, got ${info.asset}`
-    };
-  }
-  if (getAddress2(info.spender) !== getAddress2(PERMIT2_ADDRESS)) {
-    return {
-      isValid: false,
-      invalidReason: ErrErc20ApprovalSpenderNotPermit2,
-      invalidMessage: `Expected spender=${PERMIT2_ADDRESS}, got ${info.spender}`
-    };
-  }
-  try {
-    const serializedTx = info.signedTransaction;
-    const tx = parseTransaction(serializedTx);
-    if (!tx.to || getAddress2(tx.to) !== tokenAddress) {
-      return {
-        isValid: false,
-        invalidReason: ErrErc20ApprovalTxWrongTarget,
-        invalidMessage: `Transaction targets ${tx.to ?? "null"}, expected ${tokenAddress}`
-      };
-    }
-    const data = tx.data ?? "0x";
-    if (!data.startsWith(APPROVE_SELECTOR)) {
-      return {
-        isValid: false,
-        invalidReason: ErrErc20ApprovalTxWrongSelector,
-        invalidMessage: `Transaction calldata does not start with approve() selector ${APPROVE_SELECTOR}`
-      };
-    }
-    try {
-      const decoded = decodeFunctionData({
-        abi: erc20ApproveAbi,
-        data
-      });
-      const calldataSpender = getAddress2(decoded.args[0]);
-      if (calldataSpender !== getAddress2(PERMIT2_ADDRESS)) {
-        return {
-          isValid: false,
-          invalidReason: ErrErc20ApprovalTxWrongSpender,
-          invalidMessage: `approve() spender is ${calldataSpender}, expected Permit2 ${PERMIT2_ADDRESS}`
-        };
-      }
-    } catch {
-      return {
-        isValid: false,
-        invalidReason: ErrErc20ApprovalTxInvalidCalldata,
-        invalidMessage: "Failed to decode approve() calldata from the signed transaction"
-      };
-    }
-    try {
-      const recoveredAddress = await recoverTransactionAddress({
-        serializedTransaction: serializedTx
-      });
-      if (getAddress2(recoveredAddress) !== getAddress2(payer)) {
-        return {
-          isValid: false,
-          invalidReason: ErrErc20ApprovalTxSignerMismatch,
-          invalidMessage: `Transaction signed by ${recoveredAddress}, expected payer ${payer}`
-        };
-      }
-    } catch {
-      return {
-        isValid: false,
-        invalidReason: ErrErc20ApprovalTxInvalidSignature,
-        invalidMessage: "Failed to recover signer from the signed transaction"
-      };
-    }
-  } catch {
-    return {
-      isValid: false,
-      invalidReason: ErrErc20ApprovalTxParseFailed,
-      invalidMessage: "Failed to parse the signed transaction"
-    };
-  }
-  return { isValid: true };
-}
-
-// src/exact/facilitator/permit2-utils.ts
-import { encodeFunctionData, getAddress as getAddress3 } from "viem";
-async function simulatePermit2Settle(signer, permit2Payload) {
-  try {
-    await signer.readContract({
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
-      functionName: "settle",
-      args: buildPermit2SettleArgs(permit2Payload)
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function splitEip2612Signature(signature) {
-  const sig = signature.startsWith("0x") ? signature.slice(2) : signature;
-  if (sig.length !== 130) {
-    throw new Error(
-      `invalid EIP-2612 signature length: expected 65 bytes (130 hex chars), got ${sig.length / 2} bytes`
-    );
-  }
-  const r = `0x${sig.slice(0, 64)}`;
-  const s = `0x${sig.slice(64, 128)}`;
-  const v = parseInt(sig.slice(128, 130), 16);
-  return { v, r, s };
-}
-function buildPermit2SettleArgs(permit2Payload) {
-  return [
-    {
-      permitted: {
-        token: getAddress3(permit2Payload.permit2Authorization.permitted.token),
-        amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
-      },
-      nonce: BigInt(permit2Payload.permit2Authorization.nonce),
-      deadline: BigInt(permit2Payload.permit2Authorization.deadline)
-    },
-    getAddress3(permit2Payload.permit2Authorization.from),
-    {
-      to: getAddress3(permit2Payload.permit2Authorization.witness.to),
-      validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
-    },
-    permit2Payload.signature
-  ];
-}
-function encodePermit2SettleCalldata(permit2Payload) {
-  return encodeFunctionData({
-    abi: x402ExactPermit2ProxyABI,
-    functionName: "settle",
-    args: buildPermit2SettleArgs(permit2Payload)
-  });
-}
-async function simulatePermit2SettleWithPermit(signer, permit2Payload, eip2612Info) {
-  try {
-    const { v, r, s } = splitEip2612Signature(eip2612Info.signature);
-    await signer.readContract({
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
-      functionName: "settleWithPermit",
-      args: [
-        {
-          value: BigInt(eip2612Info.amount),
-          deadline: BigInt(eip2612Info.deadline),
-          r,
-          s,
-          v
-        },
-        ...buildPermit2SettleArgs(permit2Payload)
-      ]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function diagnosePermit2SimulationFailure(signer, tokenAddress, permit2Payload, amountRequired) {
-  const payer = permit2Payload.permit2Authorization.from;
-  const diagnosticCalls = [
-    {
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
-      functionName: "PERMIT2"
-    },
-    {
-      address: tokenAddress,
-      abi: eip3009ABI,
-      functionName: "balanceOf",
-      args: [payer]
-    },
-    {
-      address: tokenAddress,
-      abi: erc20AllowanceAbi,
-      functionName: "allowance",
-      args: [payer, PERMIT2_ADDRESS]
-    }
-  ];
-  try {
-    const results = await multicall(signer.readContract.bind(signer), diagnosticCalls);
-    const [proxyResult, balanceResult, allowanceResult] = results;
-    if (proxyResult.status === "failure") {
-      return { isValid: false, invalidReason: ErrPermit2ProxyNotDeployed, payer };
-    }
-    if (balanceResult.status === "success") {
-      const balance = balanceResult.result;
-      if (balance < BigInt(amountRequired)) {
-        return { isValid: false, invalidReason: ErrPermit2InsufficientBalance, payer };
-      }
-    }
-    if (allowanceResult.status === "success") {
-      const allowance = allowanceResult.result;
-      if (allowance < BigInt(amountRequired)) {
-        return { isValid: false, invalidReason: ErrPermit2AllowanceRequired, payer };
-      }
-    }
-  } catch {
-  }
-  return { isValid: false, invalidReason: ErrPermit2SimulationFailed, payer };
-}
-async function checkPermit2Prerequisites(signer, tokenAddress, payer, amountRequired) {
-  const diagnosticCalls = [
-    {
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
-      functionName: "PERMIT2"
-    },
-    {
-      address: tokenAddress,
-      abi: eip3009ABI,
-      functionName: "balanceOf",
-      args: [payer]
-    },
-    {
-      address: MULTICALL3_ADDRESS,
-      abi: multicall3GetEthBalanceAbi,
-      functionName: "getEthBalance",
-      args: [payer]
-    }
-  ];
-  try {
-    const results = await multicall(signer.readContract.bind(signer), diagnosticCalls);
-    const [proxyResult, balanceResult, ethBalanceResult] = results;
-    if (proxyResult.status === "failure") {
-      return { isValid: false, invalidReason: ErrPermit2ProxyNotDeployed, payer };
-    }
-    if (balanceResult.status === "success") {
-      const balance = balanceResult.result;
-      if (balance < BigInt(amountRequired)) {
-        return { isValid: false, invalidReason: ErrPermit2InsufficientBalance, payer };
-      }
-    }
-    if (ethBalanceResult.status === "success") {
-      const minEthForApprovalGas = ERC20_APPROVE_GAS_LIMIT * DEFAULT_MAX_FEE_PER_GAS;
-      const ethBalance = ethBalanceResult.result;
-      if (ethBalance < minEthForApprovalGas) {
-        return {
-          isValid: false,
-          invalidReason: ErrErc20ApprovalInsufficientEthForGas,
-          payer
-        };
-      }
-    }
-  } catch {
-  }
-  return { isValid: true, invalidReason: void 0, payer };
-}
-async function simulatePermit2SettleWithErc20Approval(extensionSigner, permit2Payload, erc20Info) {
-  if (!extensionSigner.simulateTransactions) {
-    return false;
-  }
-  try {
-    const settleData = encodePermit2SettleCalldata(permit2Payload);
-    return await extensionSigner.simulateTransactions([
-      erc20Info.signedTransaction,
-      { to: x402ExactPermit2ProxyAddress, data: settleData, gas: BigInt(3e5) }
-    ]);
-  } catch {
-    return false;
-  }
-}
-async function waitAndReturn(signer, tx, payload, payer) {
-  const receipt = await signer.waitForTransactionReceipt({ hash: tx });
-  if (receipt.status !== "success") {
-    return {
-      success: false,
-      errorReason: ErrInvalidTransactionState,
-      transaction: tx,
-      network: payload.accepted.network,
-      payer
-    };
-  }
-  return {
-    success: true,
-    transaction: tx,
-    network: payload.accepted.network,
-    payer
-  };
-}
-function mapSettleError(error, payload, payer) {
-  let errorReason = ErrTransactionFailed;
-  if (error instanceof Error) {
-    const message = error.message;
-    if (message.includes("Permit2612AmountMismatch")) {
-      errorReason = ErrPermit2612AmountMismatch;
-    } else if (message.includes("InvalidAmount")) {
-      errorReason = ErrPermit2InvalidAmount;
-    } else if (message.includes("InvalidDestination")) {
-      errorReason = ErrPermit2InvalidDestination;
-    } else if (message.includes("InvalidOwner")) {
-      errorReason = ErrPermit2InvalidOwner;
-    } else if (message.includes("PaymentTooEarly")) {
-      errorReason = ErrPermit2PaymentTooEarly;
-    } else if (message.includes("InvalidSignature") || message.includes("SignatureExpired")) {
-      errorReason = ErrPermit2InvalidSignature;
-    } else if (message.includes("InvalidNonce")) {
-      errorReason = ErrPermit2InvalidNonce;
-    } else if (message.includes("erc20_approval_tx_failed")) {
-      errorReason = ErrErc20ApprovalTxFailed;
-    } else {
-      errorReason = `${ErrTransactionFailed}: ${message.slice(0, 500)}`;
-    }
-  }
-  return {
-    success: false,
-    errorReason,
-    transaction: "",
-    network: payload.accepted.network,
-    payer
-  };
-}
-function validateEip2612PermitForPayment(info, payer, tokenAddress) {
-  if (!validateEip2612GasSponsoringInfo(info)) {
-    return { isValid: false, invalidReason: ErrInvalidEip2612ExtensionFormat };
-  }
-  if (getAddress3(info.from) !== getAddress3(payer)) {
-    return { isValid: false, invalidReason: ErrEip2612FromMismatch };
-  }
-  if (getAddress3(info.asset) !== tokenAddress) {
-    return { isValid: false, invalidReason: ErrEip2612AssetMismatch };
-  }
-  if (getAddress3(info.spender) !== getAddress3(PERMIT2_ADDRESS)) {
-    return { isValid: false, invalidReason: ErrEip2612SpenderNotPermit2 };
-  }
-  const now = Math.floor(Date.now() / 1e3);
-  if (BigInt(info.deadline) < BigInt(now + 6)) {
-    return { isValid: false, invalidReason: ErrEip2612DeadlineExpired };
-  }
-  return { isValid: true };
-}
-
-// src/exact/facilitator/permit2.ts
+import { getAddress as getAddress2, encodeFunctionData } from "viem";
+var exactProxyConfig = {
+  proxyAddress: x402ExactPermit2ProxyAddress,
+  proxyABI: x402ExactPermit2ProxyABI
+};
 async function verifyPermit2(signer, payload, requirements, permit2Payload, context, options) {
   const payer = permit2Payload.permit2Authorization.from;
   if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
@@ -648,15 +272,15 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
     };
   }
   const chainId = getEvmChainId(requirements.network);
-  const tokenAddress = getAddress4(requirements.asset);
-  if (getAddress4(permit2Payload.permit2Authorization.spender) !== getAddress4(x402ExactPermit2ProxyAddress)) {
+  const tokenAddress = getAddress2(requirements.asset);
+  if (getAddress2(permit2Payload.permit2Authorization.spender) !== getAddress2(x402ExactPermit2ProxyAddress)) {
     return {
       isValid: false,
       invalidReason: ErrPermit2InvalidSpender,
       payer
     };
   }
-  if (getAddress4(permit2Payload.permit2Authorization.witness.to) !== getAddress4(requirements.payTo)) {
+  if (getAddress2(permit2Payload.permit2Authorization.witness.to) !== getAddress2(requirements.payTo)) {
     return {
       isValid: false,
       invalidReason: ErrPermit2RecipientMismatch,
@@ -685,7 +309,7 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
       payer
     };
   }
-  if (getAddress4(permit2Payload.permit2Authorization.permitted.token) !== tokenAddress) {
+  if (getAddress2(permit2Payload.permit2Authorization.permitted.token) !== tokenAddress) {
     return {
       isValid: false,
       invalidReason: ErrPermit2TokenMismatch,
@@ -702,14 +326,14 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
     },
     message: {
       permitted: {
-        token: getAddress4(permit2Payload.permit2Authorization.permitted.token),
+        token: getAddress2(permit2Payload.permit2Authorization.permitted.token),
         amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
       },
-      spender: getAddress4(permit2Payload.permit2Authorization.spender),
+      spender: getAddress2(permit2Payload.permit2Authorization.spender),
       nonce: BigInt(permit2Payload.permit2Authorization.nonce),
       deadline: BigInt(permit2Payload.permit2Authorization.deadline),
       witness: {
-        to: getAddress4(permit2Payload.permit2Authorization.witness.to),
+        to: getAddress2(permit2Payload.permit2Authorization.witness.to),
         validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
       }
     }
@@ -744,9 +368,16 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
     if (!fieldResult.isValid) {
       return { isValid: false, invalidReason: fieldResult.invalidReason, payer };
     }
-    const simOk2 = await simulatePermit2SettleWithPermit(signer, permit2Payload, eip2612Info);
+    const exactSettleArgs = buildExactPermit2SettleArgs(permit2Payload);
+    const simOk2 = await simulatePermit2SettleWithPermit(
+      exactProxyConfig,
+      signer,
+      exactSettleArgs,
+      eip2612Info
+    );
     if (!simOk2) {
       return diagnosePermit2SimulationFailure(
+        exactProxyConfig,
         signer,
         tokenAddress,
         permit2Payload,
@@ -771,12 +402,14 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
       );
       if (extensionSigner?.simulateTransactions) {
         const simOk2 = await simulatePermit2SettleWithErc20Approval(
+          exactProxyConfig,
           extensionSigner,
-          permit2Payload,
+          buildExactPermit2SettleArgs(permit2Payload),
           erc20Info
         );
         if (!simOk2) {
           return diagnosePermit2SimulationFailure(
+            exactProxyConfig,
             signer,
             tokenAddress,
             permit2Payload,
@@ -785,12 +418,23 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
         }
         return { isValid: true, invalidReason: void 0, payer };
       }
-      return checkPermit2Prerequisites(signer, tokenAddress, payer, requirements.amount);
+      return checkPermit2Prerequisites(
+        exactProxyConfig,
+        signer,
+        tokenAddress,
+        payer,
+        requirements.amount
+      );
     }
   }
-  const simOk = await simulatePermit2Settle(signer, permit2Payload);
+  const simOk = await simulatePermit2Settle(
+    exactProxyConfig,
+    signer,
+    buildExactPermit2SettleArgs(permit2Payload)
+  );
   if (!simOk) {
     return diagnosePermit2SimulationFailure(
+      exactProxyConfig,
       signer,
       tokenAddress,
       permit2Payload,
@@ -815,7 +459,7 @@ async function settlePermit2(signer, payload, requirements, permit2Payload, cont
   }
   const eip2612Info = extractEip2612GasSponsoringInfo(payload);
   if (eip2612Info) {
-    return _settlePermit2WithEIP2612(signer, payload, permit2Payload, eip2612Info);
+    return settlePermit2WithEIP2612(exactProxyConfig, signer, payload, permit2Payload, eip2612Info);
   }
   const erc20Info = extractErc20ApprovalGasSponsoringInfo(payload);
   if (erc20Info) {
@@ -827,18 +471,24 @@ async function settlePermit2(signer, payload, requirements, permit2Payload, cont
       payload.accepted.network
     );
     if (extensionSigner) {
-      return _settlePermit2WithERC20Approval(extensionSigner, payload, permit2Payload, erc20Info);
+      return settlePermit2WithERC20Approval(
+        exactProxyConfig,
+        extensionSigner,
+        payload,
+        permit2Payload,
+        erc20Info
+      );
     }
   }
-  return _settlePermit2Direct(signer, payload, permit2Payload);
+  return settlePermit2Direct(exactProxyConfig, signer, payload, permit2Payload);
 }
-async function _settlePermit2WithEIP2612(signer, payload, permit2Payload, eip2612Info) {
+async function settlePermit2WithEIP2612(config, signer, payload, permit2Payload, eip2612Info) {
   const payer = permit2Payload.permit2Authorization.from;
   try {
     const { v, r, s } = splitEip2612Signature(eip2612Info.signature);
     const tx = await signer.writeContract({
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
+      address: config.proxyAddress,
+      abi: config.proxyABI,
       functionName: "settleWithPermit",
       args: [
         {
@@ -848,38 +498,42 @@ async function _settlePermit2WithEIP2612(signer, payload, permit2Payload, eip261
           s,
           v
         },
-        ...buildPermit2SettleArgs(permit2Payload)
+        ...buildExactPermit2SettleArgs(permit2Payload)
       ]
     });
-    return waitAndReturn(signer, tx, payload, payer);
+    return waitAndReturnSettleResponse(signer, tx, payload, payer);
   } catch (error) {
     return mapSettleError(error, payload, payer);
   }
 }
-async function _settlePermit2WithERC20Approval(extensionSigner, payload, permit2Payload, erc20Info) {
+async function settlePermit2WithERC20Approval(config, extensionSigner, payload, permit2Payload, erc20Info) {
   const payer = permit2Payload.permit2Authorization.from;
   try {
-    const settleData = encodePermit2SettleCalldata(permit2Payload);
+    const settleData = encodeFunctionData({
+      abi: config.proxyABI,
+      functionName: "settle",
+      args: buildExactPermit2SettleArgs(permit2Payload)
+    });
     const txHashes = await extensionSigner.sendTransactions([
       erc20Info.signedTransaction,
-      { to: x402ExactPermit2ProxyAddress, data: settleData, gas: BigInt(3e5) }
+      { to: config.proxyAddress, data: settleData, gas: BigInt(3e5) }
     ]);
     const settleTxHash = txHashes[txHashes.length - 1];
-    return waitAndReturn(extensionSigner, settleTxHash, payload, payer);
+    return waitAndReturnSettleResponse(extensionSigner, settleTxHash, payload, payer);
   } catch (error) {
     return mapSettleError(error, payload, payer);
   }
 }
-async function _settlePermit2Direct(signer, payload, permit2Payload) {
+async function settlePermit2Direct(config, signer, payload, permit2Payload) {
   const payer = permit2Payload.permit2Authorization.from;
   try {
     const tx = await signer.writeContract({
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
+      address: config.proxyAddress,
+      abi: config.proxyABI,
       functionName: "settle",
-      args: buildPermit2SettleArgs(permit2Payload)
+      args: buildExactPermit2SettleArgs(permit2Payload)
     });
-    return waitAndReturn(signer, tx, payload, payer);
+    return waitAndReturnSettleResponse(signer, tx, payload, payer);
   } catch (error) {
     return mapSettleError(error, payload, payer);
   }