@payai/x402-evm 2.3.4 → 2.3.6

package/dist/cjs/exact/facilitator/index.js

@@ -31,7 +31,7 @@ function isPermit2Payload(payload) {
 }
 
 // src/exact/facilitator/eip3009.ts
-var import_viem2 = require("viem");
+var import_viem4 = require("viem");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -107,6 +107,23 @@ var eip3009ABI = [
     outputs: [{ name: "", type: "string" }],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "authorizer", type: "address" },
+      { name: "nonce", type: "bytes32" }
+    ],
+    name: "authorizationState",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
 var erc20ApproveAbi = [
@@ -133,6 +150,8 @@ var erc20AllowanceAbi = [
     stateMutability: "view"
   }
 ];
+var ERC20_APPROVE_GAS_LIMIT = 70000n;
+var DEFAULT_MAX_FEE_PER_GAS = 1000000000n;
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var x402ExactPermit2ProxyAddress = "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
 var permit2WitnessABIComponents = [
@@ -266,29 +285,327 @@ function getEvmChainId(network) {
   throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
 }
 
+// src/exact/facilitator/errors.ts
+var ErrInvalidScheme = "invalid_exact_evm_scheme";
+var ErrNetworkMismatch = "invalid_exact_evm_network_mismatch";
+var ErrMissingEip712Domain = "invalid_exact_evm_missing_eip712_domain";
+var ErrRecipientMismatch = "invalid_exact_evm_recipient_mismatch";
+var ErrInvalidSignature = "invalid_exact_evm_signature";
+var ErrValidBeforeExpired = "invalid_exact_evm_payload_authorization_valid_before";
+var ErrValidAfterInFuture = "invalid_exact_evm_payload_authorization_valid_after";
+var ErrInvalidAuthorizationValue = "invalid_exact_evm_authorization_value";
+var ErrUndeployedSmartWallet = "invalid_exact_evm_payload_undeployed_smart_wallet";
+var ErrTransactionFailed = "invalid_exact_evm_transaction_failed";
+var ErrEip3009TokenNameMismatch = "invalid_exact_evm_token_name_mismatch";
+var ErrEip3009TokenVersionMismatch = "invalid_exact_evm_token_version_mismatch";
+var ErrEip3009NotSupported = "invalid_exact_evm_eip3009_not_supported";
+var ErrEip3009NonceAlreadyUsed = "invalid_exact_evm_nonce_already_used";
+var ErrEip3009InsufficientBalance = "invalid_exact_evm_insufficient_balance";
+var ErrEip3009SimulationFailed = "invalid_exact_evm_transaction_simulation_failed";
+var ErrPermit2InvalidSpender = "invalid_permit2_spender";
+var ErrPermit2RecipientMismatch = "invalid_permit2_recipient_mismatch";
+var ErrPermit2DeadlineExpired = "permit2_deadline_expired";
+var ErrPermit2NotYetValid = "permit2_not_yet_valid";
+var ErrPermit2AmountMismatch = "permit2_amount_mismatch";
+var ErrPermit2TokenMismatch = "permit2_token_mismatch";
+var ErrPermit2InvalidSignature = "invalid_permit2_signature";
+var ErrPermit2AllowanceRequired = "permit2_allowance_required";
+var ErrPermit2SimulationFailed = "permit2_simulation_failed";
+var ErrPermit2InsufficientBalance = "permit2_insufficient_balance";
+var ErrPermit2ProxyNotDeployed = "permit2_proxy_not_deployed";
+var ErrPermit2InvalidAmount = "permit2_invalid_amount";
+var ErrPermit2InvalidDestination = "permit2_invalid_destination";
+var ErrPermit2InvalidOwner = "permit2_invalid_owner";
+var ErrPermit2PaymentTooEarly = "permit2_payment_too_early";
+var ErrPermit2InvalidNonce = "permit2_invalid_nonce";
+var ErrPermit2612AmountMismatch = "permit2_2612_amount_mismatch";
+var ErrErc20ApprovalInsufficientEthForGas = "erc20_approval_insufficient_eth_for_gas";
+var ErrErc20ApprovalInvalidFormat = "invalid_erc20_approval_extension_format";
+var ErrErc20ApprovalFromMismatch = "erc20_approval_from_mismatch";
+var ErrErc20ApprovalAssetMismatch = "erc20_approval_asset_mismatch";
+var ErrErc20ApprovalSpenderNotPermit2 = "erc20_approval_spender_not_permit2";
+var ErrErc20ApprovalTxWrongTarget = "erc20_approval_tx_wrong_target";
+var ErrErc20ApprovalTxWrongSelector = "erc20_approval_tx_wrong_selector";
+var ErrErc20ApprovalTxWrongSpender = "erc20_approval_tx_wrong_spender";
+var ErrErc20ApprovalTxInvalidCalldata = "erc20_approval_tx_invalid_calldata";
+var ErrErc20ApprovalTxSignerMismatch = "erc20_approval_tx_signer_mismatch";
+var ErrErc20ApprovalTxInvalidSignature = "erc20_approval_tx_invalid_signature";
+var ErrErc20ApprovalTxParseFailed = "erc20_approval_tx_parse_failed";
+var ErrErc20ApprovalTxFailed = "erc20_approval_tx_failed";
+var ErrInvalidEip2612ExtensionFormat = "invalid_eip2612_extension_format";
+var ErrEip2612FromMismatch = "eip2612_from_mismatch";
+var ErrEip2612AssetMismatch = "eip2612_asset_mismatch";
+var ErrEip2612SpenderNotPermit2 = "eip2612_spender_not_permit2";
+var ErrEip2612DeadlineExpired = "eip2612_deadline_expired";
+var ErrUnsupportedPayloadType = "unsupported_payload_type";
+var ErrInvalidTransactionState = "invalid_transaction_state";
+
+// src/exact/facilitator/eip3009-utils.ts
+var import_viem3 = require("viem");
+
+// src/multicall.ts
+var import_viem2 = require("viem");
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var multicall3GetEthBalanceAbi = [
+  {
+    name: "getEthBalance",
+    inputs: [{ name: "addr", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var multicall3ABI = [
+  {
+    inputs: [
+      { name: "requireSuccess", type: "bool" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        name: "returnData",
+        type: "tuple[]",
+        components: [
+          { name: "success", type: "bool" },
+          { name: "returnData", type: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+async function multicall(readContract, calls) {
+  const aggregateCalls = calls.map((call) => {
+    if ("callData" in call) {
+      return { target: call.address, callData: call.callData };
+    }
+    const callData = (0, import_viem2.encodeFunctionData)({
+      abi: call.abi,
+      functionName: call.functionName,
+      args: call.args
+    });
+    return { target: call.address, callData };
+  });
+  const rawResults = await readContract({
+    address: MULTICALL3_ADDRESS,
+    abi: multicall3ABI,
+    functionName: "tryAggregate",
+    args: [false, aggregateCalls]
+  });
+  return rawResults.map((raw, i) => {
+    if (!raw.success) {
+      return {
+        status: "failure",
+        error: new Error(`multicall: call reverted (returnData: ${raw.returnData})`)
+      };
+    }
+    const call = calls[i];
+    if ("callData" in call) {
+      return { status: "success", result: void 0 };
+    }
+    try {
+      const decoded = (0, import_viem2.decodeFunctionResult)({
+        abi: call.abi,
+        functionName: call.functionName,
+        data: raw.returnData
+      });
+      return { status: "success", result: decoded };
+    } catch (err) {
+      return {
+        status: "failure",
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  });
+}
+
+// src/exact/facilitator/eip3009-utils.ts
+async function simulateEip3009Transfer(signer, erc20Address, payload, eip6492Deployment) {
+  const auth = payload.authorization;
+  const transferArgs = [
+    (0, import_viem3.getAddress)(auth.from),
+    (0, import_viem3.getAddress)(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (eip6492Deployment) {
+    const { signature: innerSignature } = (0, import_viem3.parseErc6492Signature)(payload.signature);
+    const transferCalldata = (0, import_viem3.encodeFunctionData)({
+      abi: eip3009ABI,
+      functionName: "transferWithAuthorization",
+      args: [...transferArgs, innerSignature]
+    });
+    try {
+      const results = await multicall(signer.readContract.bind(signer), [
+        {
+          address: (0, import_viem3.getAddress)(eip6492Deployment.factoryAddress),
+          callData: eip6492Deployment.factoryCalldata
+        },
+        {
+          address: erc20Address,
+          callData: transferCalldata
+        }
+      ]);
+      return results[1]?.status === "success";
+    } catch {
+      return false;
+    }
+  }
+  const sig = payload.signature;
+  const sigLength = sig.startsWith("0x") ? sig.length - 2 : sig.length;
+  const isECDSA = sigLength === 130;
+  try {
+    if (isECDSA) {
+      const parsedSig = (0, import_viem3.parseSignature)(sig);
+      await signer.readContract({
+        address: erc20Address,
+        abi: eip3009ABI,
+        functionName: "transferWithAuthorization",
+        args: [
+          ...transferArgs,
+          parsedSig.v ?? parsedSig.yParity,
+          parsedSig.r,
+          parsedSig.s
+        ]
+      });
+    } else {
+      await signer.readContract({
+        address: erc20Address,
+        abi: eip3009ABI,
+        functionName: "transferWithAuthorization",
+        args: [...transferArgs, sig]
+      });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function diagnoseEip3009SimulationFailure(signer, erc20Address, payload, requirements, amountRequired) {
+  const payer = payload.authorization.from;
+  const diagnosticCalls = [
+    {
+      address: erc20Address,
+      abi: eip3009ABI,
+      functionName: "balanceOf",
+      args: [payload.authorization.from]
+    },
+    {
+      address: erc20Address,
+      abi: eip3009ABI,
+      functionName: "name"
+    },
+    {
+      address: erc20Address,
+      abi: eip3009ABI,
+      functionName: "version"
+    },
+    {
+      address: erc20Address,
+      abi: eip3009ABI,
+      functionName: "authorizationState",
+      args: [payload.authorization.from, payload.authorization.nonce]
+    }
+  ];
+  try {
+    const results = await multicall(signer.readContract.bind(signer), diagnosticCalls);
+    const [balanceResult, nameResult, versionResult, authStateResult] = results;
+    if (authStateResult.status === "failure") {
+      return { isValid: false, invalidReason: ErrEip3009NotSupported, payer };
+    }
+    if (authStateResult.status === "success" && authStateResult.result === true) {
+      return { isValid: false, invalidReason: ErrEip3009NonceAlreadyUsed, payer };
+    }
+    if (nameResult.status === "success" && requirements.extra?.name && nameResult.result !== requirements.extra.name) {
+      return { isValid: false, invalidReason: ErrEip3009TokenNameMismatch, payer };
+    }
+    if (versionResult.status === "success" && requirements.extra?.version && versionResult.result !== requirements.extra.version) {
+      return { isValid: false, invalidReason: ErrEip3009TokenVersionMismatch, payer };
+    }
+    if (balanceResult.status === "success") {
+      const balance = balanceResult.result;
+      if (balance < BigInt(amountRequired)) {
+        return {
+          isValid: false,
+          invalidReason: ErrEip3009InsufficientBalance,
+          payer
+        };
+      }
+    }
+  } catch {
+  }
+  return { isValid: false, invalidReason: ErrEip3009SimulationFailed, payer };
+}
+async function executeTransferWithAuthorization(signer, erc20Address, payload) {
+  const { signature } = (0, import_viem3.parseErc6492Signature)(payload.signature);
+  const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+  const isECDSA = signatureLength === 130;
+  const auth = payload.authorization;
+  const baseArgs = [
+    (0, import_viem3.getAddress)(auth.from),
+    (0, import_viem3.getAddress)(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (isECDSA) {
+    const parsedSig = (0, import_viem3.parseSignature)(signature);
+    return signer.writeContract({
+      address: erc20Address,
+      abi: eip3009ABI,
+      functionName: "transferWithAuthorization",
+      args: [
+        ...baseArgs,
+        parsedSig.v || parsedSig.yParity,
+        parsedSig.r,
+        parsedSig.s
+      ]
+    });
+  }
+  return signer.writeContract({
+    address: erc20Address,
+    abi: eip3009ABI,
+    functionName: "transferWithAuthorization",
+    args: [...baseArgs, signature]
+  });
+}
+
 // src/exact/facilitator/eip3009.ts
-async function verifyEIP3009(signer, payload, requirements, eip3009Payload) {
+async function verifyEIP3009(signer, payload, requirements, eip3009Payload, options) {
   const payer = eip3009Payload.authorization.from;
+  let eip6492Deployment;
   if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
     return {
       isValid: false,
-      invalidReason: "unsupported_scheme",
+      invalidReason: ErrInvalidScheme,
       payer
     };
   }
   if (!requirements.extra?.name || !requirements.extra?.version) {
     return {
       isValid: false,
-      invalidReason: "missing_eip712_domain",
+      invalidReason: ErrMissingEip712Domain,
       payer
     };
   }
   const { name, version } = requirements.extra;
-  const erc20Address = (0, import_viem2.getAddress)(requirements.asset);
+  const erc20Address = (0, import_viem4.getAddress)(requirements.asset);
   if (payload.accepted.network !== requirements.network) {
     return {
       isValid: false,
-      invalidReason: "network_mismatch",
+      invalidReason: ErrNetworkMismatch,
       payer
     };
   }
@@ -310,55 +627,49 @@ async function verifyEIP3009(signer, payload, requirements, eip3009Payload) {
       nonce: eip3009Payload.authorization.nonce
     }
   };
+  let isValid = false;
   try {
-    const recoveredAddress = await signer.verifyTypedData({
+    isValid = await signer.verifyTypedData({
       address: eip3009Payload.authorization.from,
       ...permitTypedData,
       signature: eip3009Payload.signature
     });
-    if (!recoveredAddress) {
+  } catch {
+    isValid = false;
+  }
+  const signature = eip3009Payload.signature;
+  const sigLen = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+  const erc6492Data = (0, import_viem4.parseErc6492Signature)(signature);
+  const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem4.isAddressEqual)(erc6492Data.address, "0x0000000000000000000000000000000000000000");
+  if (hasDeploymentInfo) {
+    eip6492Deployment = {
+      factoryAddress: erc6492Data.address,
+      factoryCalldata: erc6492Data.data
+    };
+  }
+  if (!isValid) {
+    const isSmartWallet = sigLen > 130;
+    if (!isSmartWallet) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_signature",
+        invalidReason: ErrInvalidSignature,
         payer
       };
     }
-  } catch {
-    const signature = eip3009Payload.signature;
-    const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
-    const isSmartWallet = signatureLength > 130;
-    if (isSmartWallet) {
-      const payerAddress = eip3009Payload.authorization.from;
-      const bytecode = await signer.getCode({ address: payerAddress });
-      if (!bytecode || bytecode === "0x") {
-        const erc6492Data = (0, import_viem2.parseErc6492Signature)(signature);
-        const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem2.isAddressEqual)(erc6492Data.address, "0x0000000000000000000000000000000000000000");
-        if (!hasDeploymentInfo) {
-          return {
-            isValid: false,
-            invalidReason: "invalid_exact_evm_payload_undeployed_smart_wallet",
-            payer: payerAddress
-          };
-        }
-      } else {
-        return {
-          isValid: false,
-          invalidReason: "invalid_exact_evm_payload_signature",
-          payer
-        };
-      }
-    } else {
+    const bytecode = await signer.getCode({ address: payer });
+    const isDeployed = bytecode && bytecode !== "0x";
+    if (!isDeployed && !hasDeploymentInfo) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_signature",
+        invalidReason: ErrUndeployedSmartWallet,
         payer
       };
     }
   }
-  if ((0, import_viem2.getAddress)(eip3009Payload.authorization.to) !== (0, import_viem2.getAddress)(requirements.payTo)) {
+  if ((0, import_viem4.getAddress)(eip3009Payload.authorization.to) !== (0, import_viem4.getAddress)(requirements.payTo)) {
     return {
       isValid: false,
-      invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
+      invalidReason: ErrRecipientMismatch,
       payer
     };
   }
@@ -366,41 +677,41 @@ async function verifyEIP3009(signer, payload, requirements, eip3009Payload) {
   if (BigInt(eip3009Payload.authorization.validBefore) < BigInt(now + 6)) {
     return {
       isValid: false,
-      invalidReason: "invalid_exact_evm_payload_authorization_valid_before",
+      invalidReason: ErrValidBeforeExpired,
       payer
     };
   }
   if (BigInt(eip3009Payload.authorization.validAfter) > BigInt(now)) {
     return {
       isValid: false,
-      invalidReason: "invalid_exact_evm_payload_authorization_valid_after",
+      invalidReason: ErrValidAfterInFuture,
       payer
     };
   }
-  try {
-    const balance = await signer.readContract({
-      address: erc20Address,
-      abi: eip3009ABI,
-      functionName: "balanceOf",
-      args: [eip3009Payload.authorization.from]
-    });
-    if (BigInt(balance) < BigInt(requirements.amount)) {
-      return {
-        isValid: false,
-        invalidReason: "insufficient_funds",
-        invalidMessage: `Insufficient funds to complete the payment. Required: ${requirements.amount} ${requirements.asset}, Available: ${balance.toString()} ${requirements.asset}. Please add funds to your wallet and try again.`,
-        payer
-      };
-    }
-  } catch {
-  }
   if (BigInt(eip3009Payload.authorization.value) !== BigInt(requirements.amount)) {
     return {
       isValid: false,
-      invalidReason: "invalid_exact_evm_payload_authorization_value_mismatch",
+      invalidReason: ErrInvalidAuthorizationValue,
       payer
     };
   }
+  if (options?.simulate !== false) {
+    const simulationSucceeded = await simulateEip3009Transfer(
+      signer,
+      erc20Address,
+      eip3009Payload,
+      eip6492Deployment
+    );
+    if (!simulationSucceeded) {
+      return diagnoseEip3009SimulationFailure(
+        signer,
+        erc20Address,
+        eip3009Payload,
+        requirements,
+        requirements.amount
+      );
+    }
+  }
   return {
     isValid: true,
     invalidReason: void 0,
@@ -409,20 +720,23 @@ async function verifyEIP3009(signer, payload, requirements, eip3009Payload) {
 }
 async function settleEIP3009(signer, payload, requirements, eip3009Payload, config) {
   const payer = eip3009Payload.authorization.from;
-  const valid = await verifyEIP3009(signer, payload, requirements, eip3009Payload);
+  const valid = await verifyEIP3009(signer, payload, requirements, eip3009Payload, {
+    simulate: config.simulateInSettle ?? false
+  });
   if (!valid.isValid) {
     return {
       success: false,
       network: payload.accepted.network,
       transaction: "",
-      errorReason: valid.invalidReason ?? "invalid_scheme",
+      errorReason: valid.invalidReason ?? ErrInvalidScheme,
       payer
     };
   }
   try {
-    const parseResult = (0, import_viem2.parseErc6492Signature)(eip3009Payload.signature);
-    const { signature, address: factoryAddress, data: factoryCalldata } = parseResult;
-    if (config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem2.isAddressEqual)(factoryAddress, "0x0000000000000000000000000000000000000000")) {
+    const { address: factoryAddress, data: factoryCalldata } = (0, import_viem4.parseErc6492Signature)(
+      eip3009Payload.signature
+    );
+    if (config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem4.isAddressEqual)(factoryAddress, "0x0000000000000000000000000000000000000000")) {
       const bytecode = await signer.getCode({ address: payer });
       if (!bytecode || bytecode === "0x") {
         const deployTx = await signer.sendTransaction({
@@ -432,48 +746,16 @@ async function settleEIP3009(signer, payload, requirements, eip3009Payload, conf
         await signer.waitForTransactionReceipt({ hash: deployTx });
       }
     }
-    const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
-    const isECDSA = signatureLength === 130;
-    let tx;
-    if (isECDSA) {
-      const parsedSig = (0, import_viem2.parseSignature)(signature);
-      tx = await signer.writeContract({
-        address: (0, import_viem2.getAddress)(requirements.asset),
-        abi: eip3009ABI,
-        functionName: "transferWithAuthorization",
-        args: [
-          (0, import_viem2.getAddress)(eip3009Payload.authorization.from),
-          (0, import_viem2.getAddress)(eip3009Payload.authorization.to),
-          BigInt(eip3009Payload.authorization.value),
-          BigInt(eip3009Payload.authorization.validAfter),
-          BigInt(eip3009Payload.authorization.validBefore),
-          eip3009Payload.authorization.nonce,
-          parsedSig.v || parsedSig.yParity,
-          parsedSig.r,
-          parsedSig.s
-        ]
-      });
-    } else {
-      tx = await signer.writeContract({
-        address: (0, import_viem2.getAddress)(requirements.asset),
-        abi: eip3009ABI,
-        functionName: "transferWithAuthorization",
-        args: [
-          (0, import_viem2.getAddress)(eip3009Payload.authorization.from),
-          (0, import_viem2.getAddress)(eip3009Payload.authorization.to),
-          BigInt(eip3009Payload.authorization.value),
-          BigInt(eip3009Payload.authorization.validAfter),
-          BigInt(eip3009Payload.authorization.validBefore),
-          eip3009Payload.authorization.nonce,
-          signature
-        ]
-      });
-    }
+    const tx = await executeTransferWithAuthorization(
+      signer,
+      (0, import_viem4.getAddress)(requirements.asset),
+      eip3009Payload
+    );
     const receipt = await signer.waitForTransactionReceipt({ hash: tx });
     if (receipt.status !== "success") {
       return {
         success: false,
-        errorReason: "invalid_transaction_state",
+        errorReason: ErrTransactionFailed,
         transaction: tx,
         network: payload.accepted.network,
         payer
@@ -488,7 +770,7 @@ async function settleEIP3009(signer, payload, requirements, eip3009Payload, conf
   } catch {
     return {
       success: false,
-      errorReason: "transaction_failed",
+      errorReason: ErrTransactionFailed,
       transaction: "",
       network: payload.accepted.network,
       payer
@@ -496,57 +778,80 @@ async function settleEIP3009(signer, payload, requirements, eip3009Payload, conf
   }
 }
 
-// src/exact/facilitator/permit2.ts
-var import_extensions2 = require("@payai/x402-extensions");
-var import_viem4 = require("viem");
+// src/exact/extensions.ts
+var EIP2612_GAS_SPONSORING_KEY = "eip2612GasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSORING_KEY = "erc20ApprovalGasSponsoring";
+function _extractInfo(payload, extensionKey) {
+  const extensions = payload.extensions;
+  if (!extensions) return null;
+  const extension = extensions[extensionKey];
+  if (!extension?.info) return null;
+  return extension.info;
+}
+function extractEip2612GasSponsoringInfo(payload) {
+  const info = _extractInfo(payload, EIP2612_GAS_SPONSORING_KEY);
+  if (!info) return null;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.nonce || !info.deadline || !info.signature || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateEip2612GasSponsoringInfo(info) {
+  const addressPattern = /^0x[a-fA-F0-9]{40}$/;
+  const numericPattern = /^[0-9]+$/;
+  const hexPattern = /^0x[a-fA-F0-9]+$/;
+  const versionPattern = /^[0-9]+(\.[0-9]+)*$/;
+  return addressPattern.test(info.from) && addressPattern.test(info.asset) && addressPattern.test(info.spender) && numericPattern.test(info.amount) && numericPattern.test(info.nonce) && numericPattern.test(info.deadline) && hexPattern.test(info.signature) && versionPattern.test(info.version);
+}
+function extractErc20ApprovalGasSponsoringInfo(payload) {
+  const info = _extractInfo(payload, ERC20_APPROVAL_GAS_SPONSORING_KEY);
+  if (!info) return null;
+  if (!info.from || !info.asset || !info.spender || !info.amount || !info.signedTransaction || !info.version) {
+    return null;
+  }
+  return info;
+}
+function validateErc20ApprovalGasSponsoringInfo(info) {
+  const addressPattern = /^0x[a-fA-F0-9]{40}$/;
+  const numericPattern = /^[0-9]+$/;
+  const hexPattern = /^0x[a-fA-F0-9]+$/;
+  const versionPattern = /^[0-9]+(\.[0-9]+)*$/;
+  return addressPattern.test(info.from) && addressPattern.test(info.asset) && addressPattern.test(info.spender) && numericPattern.test(info.amount) && hexPattern.test(info.signedTransaction) && versionPattern.test(info.version);
+}
+function resolveErc20ApprovalExtensionSigner(extension, network) {
+  if (!extension) return void 0;
+  return extension.signerForNetwork?.(network) ?? extension.signer;
+}
 
-// src/exact/facilitator/errors.ts
-var ErrPermit2InvalidSignature = "invalid_permit2_signature";
-var ErrPermit2InvalidAmount = "permit2_invalid_amount";
-var ErrPermit2InvalidDestination = "permit2_invalid_destination";
-var ErrPermit2InvalidOwner = "permit2_invalid_owner";
-var ErrPermit2PaymentTooEarly = "permit2_payment_too_early";
-var ErrPermit2InvalidNonce = "permit2_invalid_nonce";
-var ErrPermit2612AmountMismatch = "permit2_2612_amount_mismatch";
-var ErrErc20ApprovalInvalidFormat = "invalid_erc20_approval_extension_format";
-var ErrErc20ApprovalFromMismatch = "erc20_approval_from_mismatch";
-var ErrErc20ApprovalAssetMismatch = "erc20_approval_asset_mismatch";
-var ErrErc20ApprovalSpenderNotPermit2 = "erc20_approval_spender_not_permit2";
-var ErrErc20ApprovalTxWrongTarget = "erc20_approval_tx_wrong_target";
-var ErrErc20ApprovalTxWrongSelector = "erc20_approval_tx_wrong_selector";
-var ErrErc20ApprovalTxWrongSpender = "erc20_approval_tx_wrong_spender";
-var ErrErc20ApprovalTxInvalidCalldata = "erc20_approval_tx_invalid_calldata";
-var ErrErc20ApprovalTxSignerMismatch = "erc20_approval_tx_signer_mismatch";
-var ErrErc20ApprovalTxInvalidSignature = "erc20_approval_tx_invalid_signature";
-var ErrErc20ApprovalTxParseFailed = "erc20_approval_tx_parse_failed";
+// src/exact/facilitator/permit2.ts
+var import_viem7 = require("viem");
 
 // src/exact/facilitator/erc20approval.ts
-var import_viem3 = require("viem");
-var import_extensions = require("@payai/x402-extensions");
+var import_viem5 = require("viem");
 var APPROVE_SELECTOR = "0x095ea7b3";
 async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
-  if (!(0, import_extensions.validateErc20ApprovalGasSponsoringInfo)(info)) {
+  if (!validateErc20ApprovalGasSponsoringInfo(info)) {
     return {
       isValid: false,
       invalidReason: ErrErc20ApprovalInvalidFormat,
       invalidMessage: "ERC-20 approval extension info failed schema validation"
     };
   }
-  if ((0, import_viem3.getAddress)(info.from) !== (0, import_viem3.getAddress)(payer)) {
+  if ((0, import_viem5.getAddress)(info.from) !== (0, import_viem5.getAddress)(payer)) {
     return {
       isValid: false,
       invalidReason: ErrErc20ApprovalFromMismatch,
       invalidMessage: `Expected from=${payer}, got ${info.from}`
     };
   }
-  if ((0, import_viem3.getAddress)(info.asset) !== tokenAddress) {
+  if ((0, import_viem5.getAddress)(info.asset) !== tokenAddress) {
     return {
       isValid: false,
       invalidReason: ErrErc20ApprovalAssetMismatch,
       invalidMessage: `Expected asset=${tokenAddress}, got ${info.asset}`
     };
   }
-  if ((0, import_viem3.getAddress)(info.spender) !== (0, import_viem3.getAddress)(PERMIT2_ADDRESS)) {
+  if ((0, import_viem5.getAddress)(info.spender) !== (0, import_viem5.getAddress)(PERMIT2_ADDRESS)) {
     return {
       isValid: false,
       invalidReason: ErrErc20ApprovalSpenderNotPermit2,
@@ -555,8 +860,8 @@ async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
   }
   try {
     const serializedTx = info.signedTransaction;
-    const tx = (0, import_viem3.parseTransaction)(serializedTx);
-    if (!tx.to || (0, import_viem3.getAddress)(tx.to) !== tokenAddress) {
+    const tx = (0, import_viem5.parseTransaction)(serializedTx);
+    if (!tx.to || (0, import_viem5.getAddress)(tx.to) !== tokenAddress) {
       return {
         isValid: false,
         invalidReason: ErrErc20ApprovalTxWrongTarget,
@@ -572,12 +877,12 @@ async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
       };
     }
     try {
-      const decoded = (0, import_viem3.decodeFunctionData)({
+      const decoded = (0, import_viem5.decodeFunctionData)({
         abi: erc20ApproveAbi,
         data
       });
-      const calldataSpender = (0, import_viem3.getAddress)(decoded.args[0]);
-      if (calldataSpender !== (0, import_viem3.getAddress)(PERMIT2_ADDRESS)) {
+      const calldataSpender = (0, import_viem5.getAddress)(decoded.args[0]);
+      if (calldataSpender !== (0, import_viem5.getAddress)(PERMIT2_ADDRESS)) {
         return {
           isValid: false,
           invalidReason: ErrErc20ApprovalTxWrongSpender,
@@ -592,10 +897,10 @@ async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
       };
     }
     try {
-      const recoveredAddress = await (0, import_viem3.recoverTransactionAddress)({
+      const recoveredAddress = await (0, import_viem5.recoverTransactionAddress)({
         serializedTransaction: serializedTx
       });
-      if ((0, import_viem3.getAddress)(recoveredAddress) !== (0, import_viem3.getAddress)(payer)) {
+      if ((0, import_viem5.getAddress)(recoveredAddress) !== (0, import_viem5.getAddress)(payer)) {
         return {
           isValid: false,
           invalidReason: ErrErc20ApprovalTxSignerMismatch,
@@ -619,65 +924,314 @@ async function validateErc20ApprovalForPayment(info, payer, tokenAddress) {
   return { isValid: true };
 }
 
-// src/exact/facilitator/permit2.ts
-async function verifyPermit2(signer, payload, requirements, permit2Payload, context) {
-  const payer = permit2Payload.permit2Authorization.from;
-  if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
-    return {
-      isValid: false,
-      invalidReason: "unsupported_scheme",
-      payer
-    };
-  }
-  if (payload.accepted.network !== requirements.network) {
-    return {
-      isValid: false,
-      invalidReason: "network_mismatch",
-      payer
-    };
-  }
-  const chainId = getEvmChainId(requirements.network);
-  const tokenAddress = (0, import_viem4.getAddress)(requirements.asset);
-  if ((0, import_viem4.getAddress)(permit2Payload.permit2Authorization.spender) !== (0, import_viem4.getAddress)(x402ExactPermit2ProxyAddress)) {
-    return {
-      isValid: false,
-      invalidReason: "invalid_permit2_spender",
-      payer
-    };
+// src/exact/facilitator/permit2-utils.ts
+var import_viem6 = require("viem");
+async function simulatePermit2Settle(signer, permit2Payload) {
+  try {
+    await signer.readContract({
+      address: x402ExactPermit2ProxyAddress,
+      abi: x402ExactPermit2ProxyABI,
+      functionName: "settle",
+      args: buildPermit2SettleArgs(permit2Payload)
+    });
+    return true;
+  } catch {
+    return false;
   }
-  if ((0, import_viem4.getAddress)(permit2Payload.permit2Authorization.witness.to) !== (0, import_viem4.getAddress)(requirements.payTo)) {
-    return {
-      isValid: false,
-      invalidReason: "invalid_permit2_recipient_mismatch",
-      payer
-    };
+}
+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 now = Math.floor(Date.now() / 1e3);
-  if (BigInt(permit2Payload.permit2Authorization.deadline) < BigInt(now + 6)) {
-    return {
-      isValid: false,
-      invalidReason: "permit2_deadline_expired",
-      payer
+  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: (0, import_viem6.getAddress)(permit2Payload.permit2Authorization.permitted.token),
+        amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
+      },
+      nonce: BigInt(permit2Payload.permit2Authorization.nonce),
+      deadline: BigInt(permit2Payload.permit2Authorization.deadline)
+    },
+    (0, import_viem6.getAddress)(permit2Payload.permit2Authorization.from),
+    {
+      to: (0, import_viem6.getAddress)(permit2Payload.permit2Authorization.witness.to),
+      validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
+    },
+    permit2Payload.signature
+  ];
+}
+function encodePermit2SettleCalldata(permit2Payload) {
+  return (0, import_viem6.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 ((0, import_viem6.getAddress)(info.from) !== (0, import_viem6.getAddress)(payer)) {
+    return { isValid: false, invalidReason: ErrEip2612FromMismatch };
+  }
+  if ((0, import_viem6.getAddress)(info.asset) !== tokenAddress) {
+    return { isValid: false, invalidReason: ErrEip2612AssetMismatch };
+  }
+  if ((0, import_viem6.getAddress)(info.spender) !== (0, import_viem6.getAddress)(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
+async function verifyPermit2(signer, payload, requirements, permit2Payload, context, options) {
+  const payer = permit2Payload.permit2Authorization.from;
+  if (payload.accepted.scheme !== "exact" || requirements.scheme !== "exact") {
+    return {
+      isValid: false,
+      invalidReason: ErrUnsupportedPayloadType,
+      payer
+    };
+  }
+  if (payload.accepted.network !== requirements.network) {
+    return {
+      isValid: false,
+      invalidReason: ErrNetworkMismatch,
+      payer
+    };
+  }
+  const chainId = getEvmChainId(requirements.network);
+  const tokenAddress = (0, import_viem7.getAddress)(requirements.asset);
+  if ((0, import_viem7.getAddress)(permit2Payload.permit2Authorization.spender) !== (0, import_viem7.getAddress)(x402ExactPermit2ProxyAddress)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2InvalidSpender,
+      payer
+    };
+  }
+  if ((0, import_viem7.getAddress)(permit2Payload.permit2Authorization.witness.to) !== (0, import_viem7.getAddress)(requirements.payTo)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2RecipientMismatch,
+      payer
+    };
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (BigInt(permit2Payload.permit2Authorization.deadline) < BigInt(now + 6)) {
+    return {
+      isValid: false,
+      invalidReason: ErrPermit2DeadlineExpired,
+      payer
     };
   }
   if (BigInt(permit2Payload.permit2Authorization.witness.validAfter) > BigInt(now)) {
     return {
       isValid: false,
-      invalidReason: "permit2_not_yet_valid",
+      invalidReason: ErrPermit2NotYetValid,
       payer
     };
   }
   if (BigInt(permit2Payload.permit2Authorization.permitted.amount) !== BigInt(requirements.amount)) {
     return {
       isValid: false,
-      invalidReason: "permit2_amount_mismatch",
+      invalidReason: ErrPermit2AmountMismatch,
       payer
     };
   }
-  if ((0, import_viem4.getAddress)(permit2Payload.permit2Authorization.permitted.token) !== tokenAddress) {
+  if ((0, import_viem7.getAddress)(permit2Payload.permit2Authorization.permitted.token) !== tokenAddress) {
     return {
       isValid: false,
-      invalidReason: "permit2_token_mismatch",
+      invalidReason: ErrPermit2TokenMismatch,
       payer
     };
   }
@@ -691,144 +1245,132 @@ async function verifyPermit2(signer, payload, requirements, permit2Payload, cont
     },
     message: {
       permitted: {
-        token: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.permitted.token),
+        token: (0, import_viem7.getAddress)(permit2Payload.permit2Authorization.permitted.token),
         amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
       },
-      spender: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.spender),
+      spender: (0, import_viem7.getAddress)(permit2Payload.permit2Authorization.spender),
       nonce: BigInt(permit2Payload.permit2Authorization.nonce),
       deadline: BigInt(permit2Payload.permit2Authorization.deadline),
       witness: {
-        to: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.witness.to),
+        to: (0, import_viem7.getAddress)(permit2Payload.permit2Authorization.witness.to),
         validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
       }
     }
   };
+  let signatureValid = false;
   try {
-    const isValid = await signer.verifyTypedData({
+    signatureValid = await signer.verifyTypedData({
       address: payer,
       ...permit2TypedData,
       signature: permit2Payload.signature
     });
-    if (!isValid) {
-      return {
-        isValid: false,
-        invalidReason: "invalid_permit2_signature",
-        payer
-      };
-    }
   } catch {
-    return {
-      isValid: false,
-      invalidReason: "invalid_permit2_signature",
-      payer
-    };
+    signatureValid = false;
   }
-  const allowanceResult = await _verifyPermit2Allowance(
-    signer,
-    payload,
-    requirements,
-    payer,
-    tokenAddress,
-    context
-  );
-  if (allowanceResult) {
-    return allowanceResult;
-  }
-  try {
-    const balance = await signer.readContract({
-      address: tokenAddress,
-      abi: eip3009ABI,
-      functionName: "balanceOf",
-      args: [payer]
-    });
-    if (balance < BigInt(requirements.amount)) {
+  if (!signatureValid) {
+    const bytecode = await signer.getCode({ address: payer });
+    const isDeployedContract = bytecode && bytecode !== "0x";
+    if (!isDeployedContract) {
       return {
         isValid: false,
-        invalidReason: "insufficient_funds",
-        invalidMessage: `Insufficient funds to complete the payment. Required: ${requirements.amount} ${requirements.asset}, Available: ${balance.toString()} ${requirements.asset}. Please add funds to your wallet and try again.`,
+        invalidReason: ErrPermit2InvalidSignature,
         payer
       };
     }
-  } catch {
   }
-  return {
-    isValid: true,
-    invalidReason: void 0,
-    payer
-  };
-}
-async function _verifyPermit2Allowance(signer, payload, requirements, payer, tokenAddress, context) {
-  try {
-    const allowance = await signer.readContract({
-      address: tokenAddress,
-      abi: erc20AllowanceAbi,
-      functionName: "allowance",
-      args: [payer, PERMIT2_ADDRESS]
-    });
-    if (allowance >= BigInt(requirements.amount)) {
-      return null;
+  if (options?.simulate === false) {
+    return { isValid: true, invalidReason: void 0, payer };
+  }
+  const eip2612Info = extractEip2612GasSponsoringInfo(payload);
+  if (eip2612Info) {
+    const fieldResult = validateEip2612PermitForPayment(eip2612Info, payer, tokenAddress);
+    if (!fieldResult.isValid) {
+      return { isValid: false, invalidReason: fieldResult.invalidReason, payer };
     }
-    const eip2612Info = (0, import_extensions2.extractEip2612GasSponsoringInfo)(payload);
-    if (eip2612Info) {
-      const result = validateEip2612PermitForPayment(eip2612Info, payer, tokenAddress);
-      if (!result.isValid) {
-        return { isValid: false, invalidReason: result.invalidReason, payer };
-      }
-      return null;
+    const simOk2 = await simulatePermit2SettleWithPermit(signer, permit2Payload, eip2612Info);
+    if (!simOk2) {
+      return diagnosePermit2SimulationFailure(
+        signer,
+        tokenAddress,
+        permit2Payload,
+        requirements.amount
+      );
     }
-    const erc20GasSponsorshipExtension = context?.getExtension(
-      import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key
-    );
-    if (erc20GasSponsorshipExtension) {
-      const erc20Info = (0, import_extensions2.extractErc20ApprovalGasSponsoringInfo)(payload);
-      if (erc20Info) {
-        const result = await validateErc20ApprovalForPayment(erc20Info, payer, tokenAddress);
-        if (!result.isValid) {
-          return { isValid: false, invalidReason: result.invalidReason, payer };
-        }
-        return null;
+    return { isValid: true, invalidReason: void 0, payer };
+  }
+  const erc20GasSponsorshipExtension = context?.getExtension(
+    ERC20_APPROVAL_GAS_SPONSORING_KEY
+  );
+  if (erc20GasSponsorshipExtension) {
+    const erc20Info = extractErc20ApprovalGasSponsoringInfo(payload);
+    if (erc20Info) {
+      const fieldResult = await validateErc20ApprovalForPayment(erc20Info, payer, tokenAddress);
+      if (!fieldResult.isValid) {
+        return { isValid: false, invalidReason: fieldResult.invalidReason, payer };
       }
-    }
-    return { isValid: false, invalidReason: "permit2_allowance_required", payer };
-  } catch {
-    const eip2612Info = (0, import_extensions2.extractEip2612GasSponsoringInfo)(payload);
-    if (eip2612Info) {
-      const result = validateEip2612PermitForPayment(eip2612Info, payer, tokenAddress);
-      if (!result.isValid) {
-        return { isValid: false, invalidReason: result.invalidReason, payer };
+      const extensionSigner = resolveErc20ApprovalExtensionSigner(
+        erc20GasSponsorshipExtension,
+        requirements.network
+      );
+      if (extensionSigner?.simulateTransactions) {
+        const simOk2 = await simulatePermit2SettleWithErc20Approval(
+          extensionSigner,
+          permit2Payload,
+          erc20Info
+        );
+        if (!simOk2) {
+          return diagnosePermit2SimulationFailure(
+            signer,
+            tokenAddress,
+            permit2Payload,
+            requirements.amount
+          );
+        }
+        return { isValid: true, invalidReason: void 0, payer };
       }
+      return checkPermit2Prerequisites(signer, tokenAddress, payer, requirements.amount);
     }
-    return null;
   }
+  const simOk = await simulatePermit2Settle(signer, permit2Payload);
+  if (!simOk) {
+    return diagnosePermit2SimulationFailure(
+      signer,
+      tokenAddress,
+      permit2Payload,
+      requirements.amount
+    );
+  }
+  return { isValid: true, invalidReason: void 0, payer };
 }
-async function settlePermit2(signer, payload, requirements, permit2Payload, context) {
+async function settlePermit2(signer, payload, requirements, permit2Payload, context, config) {
   const payer = permit2Payload.permit2Authorization.from;
-  const valid = await verifyPermit2(signer, payload, requirements, permit2Payload, context);
+  const valid = await verifyPermit2(signer, payload, requirements, permit2Payload, context, {
+    simulate: config?.simulateInSettle ?? false
+  });
   if (!valid.isValid) {
     return {
       success: false,
       network: payload.accepted.network,
       transaction: "",
-      errorReason: valid.invalidReason ?? "invalid_scheme",
+      errorReason: valid.invalidReason ?? ErrInvalidScheme,
       payer
     };
   }
-  const eip2612Info = (0, import_extensions2.extractEip2612GasSponsoringInfo)(payload);
+  const eip2612Info = extractEip2612GasSponsoringInfo(payload);
   if (eip2612Info) {
     return _settlePermit2WithEIP2612(signer, payload, permit2Payload, eip2612Info);
   }
-  const erc20Info = (0, import_extensions2.extractErc20ApprovalGasSponsoringInfo)(payload);
+  const erc20Info = extractErc20ApprovalGasSponsoringInfo(payload);
   if (erc20Info) {
     const erc20GasSponsorshipExtension = context?.getExtension(
-      import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key
+      ERC20_APPROVAL_GAS_SPONSORING_KEY
     );
-    if (erc20GasSponsorshipExtension?.signer) {
-      return _settlePermit2WithERC20Approval(
-        erc20GasSponsorshipExtension.signer,
-        payload,
-        permit2Payload,
-        erc20Info
-      );
+    const extensionSigner = resolveErc20ApprovalExtensionSigner(
+      erc20GasSponsorshipExtension,
+      payload.accepted.network
+    );
+    if (extensionSigner) {
+      return _settlePermit2WithERC20Approval(extensionSigner, payload, permit2Payload, erc20Info);
     }
   }
   return _settlePermit2Direct(signer, payload, permit2Payload);
@@ -849,69 +1391,26 @@ async function _settlePermit2WithEIP2612(signer, payload, permit2Payload, eip261
           s,
           v
         },
-        {
-          permitted: {
-            token: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.permitted.token),
-            amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
-          },
-          nonce: BigInt(permit2Payload.permit2Authorization.nonce),
-          deadline: BigInt(permit2Payload.permit2Authorization.deadline)
-        },
-        (0, import_viem4.getAddress)(payer),
-        {
-          to: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.witness.to),
-          validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
-        },
-        permit2Payload.signature
+        ...buildPermit2SettleArgs(permit2Payload)
       ]
     });
-    return _waitAndReturn(signer, tx, payload, payer);
+    return waitAndReturn(signer, tx, payload, payer);
   } catch (error) {
-    return _mapSettleError(error, payload, payer);
+    return mapSettleError(error, payload, payer);
   }
 }
 async function _settlePermit2WithERC20Approval(extensionSigner, payload, permit2Payload, erc20Info) {
   const payer = permit2Payload.permit2Authorization.from;
   try {
-    const approvalTxHash = await extensionSigner.sendRawTransaction({
-      serializedTransaction: erc20Info.signedTransaction
-    });
-    const approvalReceipt = await extensionSigner.waitForTransactionReceipt({
-      hash: approvalTxHash
-    });
-    if (approvalReceipt.status !== "success") {
-      return {
-        success: false,
-        errorReason: "erc20_approval_tx_failed",
-        transaction: approvalTxHash,
-        network: payload.accepted.network,
-        payer
-      };
-    }
-    const tx = await extensionSigner.writeContract({
-      address: x402ExactPermit2ProxyAddress,
-      abi: x402ExactPermit2ProxyABI,
-      functionName: "settle",
-      args: [
-        {
-          permitted: {
-            token: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.permitted.token),
-            amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
-          },
-          nonce: BigInt(permit2Payload.permit2Authorization.nonce),
-          deadline: BigInt(permit2Payload.permit2Authorization.deadline)
-        },
-        (0, import_viem4.getAddress)(payer),
-        {
-          to: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.witness.to),
-          validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
-        },
-        permit2Payload.signature
-      ]
-    });
-    return _waitAndReturn(extensionSigner, tx, payload, payer);
+    const settleData = encodePermit2SettleCalldata(permit2Payload);
+    const txHashes = await extensionSigner.sendTransactions([
+      erc20Info.signedTransaction,
+      { to: x402ExactPermit2ProxyAddress, data: settleData, gas: BigInt(3e5) }
+    ]);
+    const settleTxHash = txHashes[txHashes.length - 1];
+    return waitAndReturn(extensionSigner, settleTxHash, payload, payer);
   } catch (error) {
-    return _mapSettleError(error, payload, payer);
+    return mapSettleError(error, payload, payer);
   }
 }
 async function _settlePermit2Direct(signer, payload, permit2Payload) {
@@ -921,106 +1420,12 @@ async function _settlePermit2Direct(signer, payload, permit2Payload) {
       address: x402ExactPermit2ProxyAddress,
       abi: x402ExactPermit2ProxyABI,
       functionName: "settle",
-      args: [
-        {
-          permitted: {
-            token: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.permitted.token),
-            amount: BigInt(permit2Payload.permit2Authorization.permitted.amount)
-          },
-          nonce: BigInt(permit2Payload.permit2Authorization.nonce),
-          deadline: BigInt(permit2Payload.permit2Authorization.deadline)
-        },
-        (0, import_viem4.getAddress)(payer),
-        {
-          to: (0, import_viem4.getAddress)(permit2Payload.permit2Authorization.witness.to),
-          validAfter: BigInt(permit2Payload.permit2Authorization.witness.validAfter)
-        },
-        permit2Payload.signature
-      ]
+      args: buildPermit2SettleArgs(permit2Payload)
     });
-    return _waitAndReturn(signer, tx, payload, payer);
+    return waitAndReturn(signer, tx, payload, payer);
   } catch (error) {
-    return _mapSettleError(error, payload, payer);
-  }
-}
-async function _waitAndReturn(signer, tx, payload, payer) {
-  const receipt = await signer.waitForTransactionReceipt({ hash: tx });
-  if (receipt.status !== "success") {
-    return {
-      success: false,
-      errorReason: "invalid_transaction_state",
-      transaction: tx,
-      network: payload.accepted.network,
-      payer
-    };
-  }
-  return {
-    success: true,
-    transaction: tx,
-    network: payload.accepted.network,
-    payer
-  };
-}
-function _mapSettleError(error, payload, payer) {
-  let errorReason = "transaction_failed";
-  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 {
-      errorReason = `transaction_failed: ${message.slice(0, 500)}`;
-    }
-  }
-  return {
-    success: false,
-    errorReason,
-    transaction: "",
-    network: payload.accepted.network,
-    payer
-  };
-}
-function validateEip2612PermitForPayment(info, payer, tokenAddress) {
-  if (!(0, import_extensions2.validateEip2612GasSponsoringInfo)(info)) {
-    return { isValid: false, invalidReason: "invalid_eip2612_extension_format" };
+    return mapSettleError(error, payload, payer);
   }
-  if ((0, import_viem4.getAddress)(info.from) !== (0, import_viem4.getAddress)(payer)) {
-    return { isValid: false, invalidReason: "eip2612_from_mismatch" };
-  }
-  if ((0, import_viem4.getAddress)(info.asset) !== tokenAddress) {
-    return { isValid: false, invalidReason: "eip2612_asset_mismatch" };
-  }
-  if ((0, import_viem4.getAddress)(info.spender) !== (0, import_viem4.getAddress)(PERMIT2_ADDRESS)) {
-    return { isValid: false, invalidReason: "eip2612_spender_not_permit2" };
-  }
-  const now = Math.floor(Date.now() / 1e3);
-  if (BigInt(info.deadline) < BigInt(now + 6)) {
-    return { isValid: false, invalidReason: "eip2612_deadline_expired" };
-  }
-  return { isValid: true };
-}
-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 };
 }
 
 // src/exact/facilitator/scheme.ts
@@ -1036,7 +1441,8 @@ var ExactEvmScheme = class {
     this.scheme = "exact";
     this.caipFamily = "eip155:*";
     this.config = {
-      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false
+      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false,
+      simulateInSettle: config?.simulateInSettle ?? false
     };
   }
   /**
@@ -1067,7 +1473,8 @@ var ExactEvmScheme = class {
    */
   async verify(payload, requirements, context) {
     const rawPayload = payload.payload;
-    if (isPermit2Payload(rawPayload)) {
+    const isPermit2 = isPermit2Payload(rawPayload);
+    if (isPermit2) {
       return verifyPermit2(this.signer, payload, requirements, rawPayload, context);
     }
     const eip3009Payload = rawPayload;
@@ -1083,8 +1490,11 @@ var ExactEvmScheme = class {
    */
   async settle(payload, requirements, context) {
     const rawPayload = payload.payload;
-    if (isPermit2Payload(rawPayload)) {
-      return settlePermit2(this.signer, payload, requirements, rawPayload, context);
+    const isPermit2 = isPermit2Payload(rawPayload);
+    if (isPermit2) {
+      return settlePermit2(this.signer, payload, requirements, rawPayload, context, {
+        simulateInSettle: this.config.simulateInSettle
+      });
     }
     const eip3009Payload = rawPayload;
     return settleEIP3009(this.signer, payload, requirements, eip3009Payload, this.config);
@@ -1092,10 +1502,10 @@ var ExactEvmScheme = class {
 };
 
 // src/exact/v1/facilitator/scheme.ts
-var import_viem6 = require("viem");
+var import_viem9 = require("viem");
 
 // src/exact/v1/client/scheme.ts
-var import_viem5 = require("viem");
+var import_viem8 = require("viem");
 
 // src/v1/index.ts
 var EVM_NETWORK_CHAIN_ID_MAP = {
@@ -1117,7 +1527,9 @@ var EVM_NETWORK_CHAIN_ID_MAP = {
   educhain: 41923,
   "skale-base-sepolia": 324705682,
   megaeth: 4326,
-  monad: 143
+  monad: 143,
+  kiteai: 2366,
+  "kiteai-testnet": 2368
 };
 var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
 function getEvmChainIdV1(network) {
@@ -1141,7 +1553,8 @@ var ExactEvmSchemeV12 = class {
     this.scheme = "exact";
     this.caipFamily = "eip155:*";
     this.config = {
-      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false
+      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false,
+      simulateInSettle: config?.simulateInSettle ?? false
     };
   }
   /**
@@ -1172,14 +1585,95 @@ var ExactEvmSchemeV12 = class {
    * @returns Promise resolving to verification response
    */
   async verify(payload, requirements) {
+    return this._verify(payload, requirements);
+  }
+  /**
+   * Settles a payment by executing the transfer (V1).
+   *
+   * @param payload - The payment payload to settle
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to settlement response
+   */
+  async settle(payload, requirements) {
+    const payloadV1 = payload;
+    const exactEvmPayload = payload.payload;
+    const valid = await this._verify(payload, requirements, {
+      simulate: this.config.simulateInSettle ?? false
+    });
+    if (!valid.isValid) {
+      return {
+        success: false,
+        network: payloadV1.network,
+        transaction: "",
+        errorReason: valid.invalidReason ?? ErrInvalidScheme,
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+    try {
+      const { address: factoryAddress, data: factoryCalldata } = (0, import_viem9.parseErc6492Signature)(
+        exactEvmPayload.signature
+      );
+      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem9.isAddressEqual)(factoryAddress, "0x0000000000000000000000000000000000000000")) {
+        const payerAddress = exactEvmPayload.authorization.from;
+        const bytecode = await this.signer.getCode({ address: payerAddress });
+        if (!bytecode || bytecode === "0x") {
+          const deployTx = await this.signer.sendTransaction({
+            to: factoryAddress,
+            data: factoryCalldata
+          });
+          await this.signer.waitForTransactionReceipt({ hash: deployTx });
+        }
+      }
+      const tx = await executeTransferWithAuthorization(
+        this.signer,
+        (0, import_viem9.getAddress)(requirements.asset),
+        exactEvmPayload
+      );
+      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          errorReason: ErrTransactionFailed,
+          transaction: tx,
+          network: payloadV1.network,
+          payer: exactEvmPayload.authorization.from
+        };
+      }
+      return {
+        success: true,
+        transaction: tx,
+        network: payloadV1.network,
+        payer: exactEvmPayload.authorization.from
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errorReason: error instanceof Error ? error.message : ErrTransactionFailed,
+        transaction: "",
+        network: payloadV1.network,
+        payer: exactEvmPayload.authorization.from
+      };
+    }
+  }
+  /**
+   * Internal verify with optional simulation control.
+   *
+   * @param payload - The payment payload to verify
+   * @param requirements - The payment requirements
+   * @param options - Verification options (e.g. simulate)
+   * @returns Promise resolving to verification response
+   */
+  async _verify(payload, requirements, options) {
     const requirementsV1 = requirements;
     const payloadV1 = payload;
     const exactEvmPayload = payload.payload;
+    const payer = exactEvmPayload.authorization.from;
+    let eip6492Deployment;
     if (payloadV1.scheme !== "exact" || requirements.scheme !== "exact") {
       return {
         isValid: false,
-        invalidReason: "unsupported_scheme",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrInvalidScheme,
+        payer
       };
     }
     let chainId;
@@ -1188,24 +1682,24 @@ var ExactEvmSchemeV12 = class {
     } catch {
       return {
         isValid: false,
-        invalidReason: `invalid_network`,
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrNetworkMismatch,
+        payer
       };
     }
     if (!requirements.extra?.name || !requirements.extra?.version) {
       return {
         isValid: false,
-        invalidReason: "missing_eip712_domain",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrMissingEip712Domain,
+        payer
       };
     }
     const { name, version } = requirements.extra;
-    const erc20Address = (0, import_viem6.getAddress)(requirements.asset);
+    const erc20Address = (0, import_viem9.getAddress)(requirements.asset);
     if (payloadV1.network !== requirements.network) {
       return {
         isValid: false,
-        invalidReason: "network_mismatch",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrNetworkMismatch,
+        payer
       };
     }
     const permitTypedData = {
@@ -1226,210 +1720,97 @@ var ExactEvmSchemeV12 = class {
         nonce: exactEvmPayload.authorization.nonce
       }
     };
+    let isValid = false;
     try {
-      const recoveredAddress = await this.signer.verifyTypedData({
-        address: exactEvmPayload.authorization.from,
+      isValid = await this.signer.verifyTypedData({
+        address: payer,
         ...permitTypedData,
         signature: exactEvmPayload.signature
       });
-      if (!recoveredAddress) {
+    } catch {
+      isValid = false;
+    }
+    const signature = exactEvmPayload.signature;
+    const sigLen = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+    const erc6492Data = (0, import_viem9.parseErc6492Signature)(signature);
+    const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem9.isAddressEqual)(erc6492Data.address, "0x0000000000000000000000000000000000000000");
+    if (hasDeploymentInfo) {
+      eip6492Deployment = {
+        factoryAddress: erc6492Data.address,
+        factoryCalldata: erc6492Data.data
+      };
+    }
+    if (!isValid) {
+      const isSmartWallet = sigLen > 130;
+      if (!isSmartWallet) {
         return {
           isValid: false,
-          invalidReason: "invalid_exact_evm_payload_signature",
-          payer: exactEvmPayload.authorization.from
+          invalidReason: ErrInvalidSignature,
+          payer
         };
       }
-    } catch {
-      const signature = exactEvmPayload.signature;
-      const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
-      const isSmartWallet = signatureLength > 130;
-      if (isSmartWallet) {
-        const payerAddress = exactEvmPayload.authorization.from;
-        const bytecode = await this.signer.getCode({ address: payerAddress });
-        if (!bytecode || bytecode === "0x") {
-          const erc6492Data = (0, import_viem6.parseErc6492Signature)(signature);
-          const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem6.isAddressEqual)(erc6492Data.address, "0x0000000000000000000000000000000000000000");
-          if (!hasDeploymentInfo) {
-            return {
-              isValid: false,
-              invalidReason: "invalid_exact_evm_payload_undeployed_smart_wallet",
-              payer: payerAddress
-            };
-          }
-        } else {
-          return {
-            isValid: false,
-            invalidReason: "invalid_exact_evm_payload_signature",
-            payer: exactEvmPayload.authorization.from
-          };
-        }
-      } else {
+      const bytecode = await this.signer.getCode({ address: payer });
+      const isDeployed = bytecode && bytecode !== "0x";
+      if (!isDeployed && !hasDeploymentInfo) {
         return {
           isValid: false,
-          invalidReason: "invalid_exact_evm_payload_signature",
-          payer: exactEvmPayload.authorization.from
+          invalidReason: ErrUndeployedSmartWallet,
+          payer
         };
       }
     }
-    if ((0, import_viem6.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem6.getAddress)(requirements.payTo)) {
+    if ((0, import_viem9.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem9.getAddress)(requirements.payTo)) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_recipient_mismatch",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrRecipientMismatch,
+        payer
       };
     }
     const now = Math.floor(Date.now() / 1e3);
     if (BigInt(exactEvmPayload.authorization.validBefore) < BigInt(now + 6)) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_authorization_valid_before",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrValidBeforeExpired,
+        payer
       };
     }
     if (BigInt(exactEvmPayload.authorization.validAfter) > BigInt(now)) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_authorization_valid_after",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrValidAfterInFuture,
+        payer
       };
     }
-    try {
-      const balance = await this.signer.readContract({
-        address: erc20Address,
-        abi: eip3009ABI,
-        functionName: "balanceOf",
-        args: [exactEvmPayload.authorization.from]
-      });
-      if (BigInt(balance) < BigInt(requirementsV1.maxAmountRequired)) {
-        return {
-          isValid: false,
-          invalidReason: "insufficient_funds",
-          invalidMessage: `Insufficient funds to complete the payment. Required: ${requirementsV1.maxAmountRequired} ${requirements.asset}, Available: ${balance.toString()} ${requirements.asset}. Please add funds to your wallet and try again.`,
-          payer: exactEvmPayload.authorization.from
-        };
-      }
-    } catch {
-    }
     if (BigInt(exactEvmPayload.authorization.value) !== BigInt(requirementsV1.maxAmountRequired)) {
       return {
         isValid: false,
-        invalidReason: "invalid_exact_evm_payload_authorization_value_mismatch",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrInvalidAuthorizationValue,
+        payer
       };
     }
+    if (options?.simulate !== false) {
+      const simulationSucceeded = await simulateEip3009Transfer(
+        this.signer,
+        erc20Address,
+        exactEvmPayload,
+        eip6492Deployment
+      );
+      if (!simulationSucceeded) {
+        return diagnoseEip3009SimulationFailure(
+          this.signer,
+          erc20Address,
+          exactEvmPayload,
+          requirements,
+          requirementsV1.maxAmountRequired
+        );
+      }
+    }
     return {
       isValid: true,
       invalidReason: void 0,
-      payer: exactEvmPayload.authorization.from
+      payer
     };
   }
-  /**
-   * Settles a payment by executing the transfer (V1).
-   *
-   * @param payload - The payment payload to settle
-   * @param requirements - The payment requirements
-   * @returns Promise resolving to settlement response
-   */
-  async settle(payload, requirements) {
-    const payloadV1 = payload;
-    const exactEvmPayload = payload.payload;
-    const valid = await this.verify(payload, requirements);
-    if (!valid.isValid) {
-      return {
-        success: false,
-        network: payloadV1.network,
-        transaction: "",
-        errorReason: valid.invalidReason ?? "invalid_scheme",
-        payer: exactEvmPayload.authorization.from
-      };
-    }
-    try {
-      const parseResult = (0, import_viem6.parseErc6492Signature)(exactEvmPayload.signature);
-      const { signature, address: factoryAddress, data: factoryCalldata } = parseResult;
-      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem6.isAddressEqual)(factoryAddress, "0x0000000000000000000000000000000000000000")) {
-        const payerAddress = exactEvmPayload.authorization.from;
-        const bytecode = await this.signer.getCode({ address: payerAddress });
-        if (!bytecode || bytecode === "0x") {
-          try {
-            console.log(`Deploying ERC-4337 smart wallet for ${payerAddress} via EIP-6492`);
-            const deployTx = await this.signer.sendTransaction({
-              to: factoryAddress,
-              data: factoryCalldata
-            });
-            await this.signer.waitForTransactionReceipt({ hash: deployTx });
-            console.log(`Successfully deployed smart wallet for ${payerAddress}`);
-          } catch (deployError) {
-            console.error("Smart wallet deployment failed:", deployError);
-            throw deployError;
-          }
-        } else {
-          console.log(`Smart wallet for ${payerAddress} already deployed, skipping deployment`);
-        }
-      }
-      const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
-      const isECDSA = signatureLength === 130;
-      let tx;
-      if (isECDSA) {
-        const parsedSig = (0, import_viem6.parseSignature)(signature);
-        tx = await this.signer.writeContract({
-          address: (0, import_viem6.getAddress)(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            (0, import_viem6.getAddress)(exactEvmPayload.authorization.from),
-            (0, import_viem6.getAddress)(exactEvmPayload.authorization.to),
-            BigInt(exactEvmPayload.authorization.value),
-            BigInt(exactEvmPayload.authorization.validAfter),
-            BigInt(exactEvmPayload.authorization.validBefore),
-            exactEvmPayload.authorization.nonce,
-            parsedSig.v || parsedSig.yParity,
-            parsedSig.r,
-            parsedSig.s
-          ]
-        });
-      } else {
-        tx = await this.signer.writeContract({
-          address: (0, import_viem6.getAddress)(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            (0, import_viem6.getAddress)(exactEvmPayload.authorization.from),
-            (0, import_viem6.getAddress)(exactEvmPayload.authorization.to),
-            BigInt(exactEvmPayload.authorization.value),
-            BigInt(exactEvmPayload.authorization.validAfter),
-            BigInt(exactEvmPayload.authorization.validBefore),
-            exactEvmPayload.authorization.nonce,
-            signature
-          ]
-        });
-      }
-      const receipt = await this.signer.waitForTransactionReceipt({ hash: tx });
-      if (receipt.status !== "success") {
-        return {
-          success: false,
-          errorReason: "invalid_transaction_state",
-          transaction: tx,
-          network: payloadV1.network,
-          payer: exactEvmPayload.authorization.from
-        };
-      }
-      return {
-        success: true,
-        transaction: tx,
-        network: payloadV1.network,
-        payer: exactEvmPayload.authorization.from
-      };
-    } catch (error) {
-      console.error("Failed to settle transaction:", error);
-      return {
-        success: false,
-        errorReason: "transaction_failed",
-        transaction: "",
-        network: payloadV1.network,
-        payer: exactEvmPayload.authorization.from
-      };
-    }
-  }
 };
 
 // src/exact/facilitator/register.ts
@@ -1437,13 +1818,15 @@ function registerExactEvmScheme(facilitator, config) {
   facilitator.register(
     config.networks,
     new ExactEvmScheme(config.signer, {
-      deployERC4337WithEIP6492: config.deployERC4337WithEIP6492
+      deployERC4337WithEIP6492: config.deployERC4337WithEIP6492,
+      simulateInSettle: config.simulateInSettle
     })
   );
   facilitator.registerV1(
     NETWORKS,
     new ExactEvmSchemeV12(config.signer, {
-      deployERC4337WithEIP6492: config.deployERC4337WithEIP6492
+      deployERC4337WithEIP6492: config.deployERC4337WithEIP6492,
+      simulateInSettle: config.simulateInSettle
     })
   );
   return facilitator;