@x402/evm 2.6.0 → 2.7.0

package/dist/esm/{chunk-XL6IFXCP.mjs → chunk-IZEI7JTG.mjs}

@@ -75,6 +75,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 eip2612PermitTypes = {
@@ -352,7 +369,306 @@ var ExactEvmSchemeV1 = class {
 };
 
 // src/exact/v1/facilitator/scheme.ts
-import { getAddress as getAddress2, isAddressEqual, parseErc6492Signature, parseSignature } from "viem";
+import { getAddress as getAddress3, isAddressEqual, parseErc6492Signature as parseErc6492Signature2 } from "viem";
+
+// 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
+import { encodeFunctionData as encodeFunctionData2, getAddress as getAddress2, parseErc6492Signature, parseSignature } from "viem";
+
+// src/multicall.ts
+import { encodeFunctionData, decodeFunctionResult } from "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 = 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 = 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 = [
+    getAddress2(auth.from),
+    getAddress2(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (eip6492Deployment) {
+    const { signature: innerSignature } = parseErc6492Signature(payload.signature);
+    const transferCalldata = encodeFunctionData2({
+      abi: eip3009ABI,
+      functionName: "transferWithAuthorization",
+      args: [...transferArgs, innerSignature]
+    });
+    try {
+      const results = await multicall(signer.readContract.bind(signer), [
+        {
+          address: getAddress2(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 = 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 } = parseErc6492Signature(payload.signature);
+  const signatureLength = signature.startsWith("0x") ? signature.length - 2 : signature.length;
+  const isECDSA = signatureLength === 130;
+  const auth = payload.authorization;
+  const baseArgs = [
+    getAddress2(auth.from),
+    getAddress2(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (isECDSA) {
+    const parsedSig = 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/v1/facilitator/scheme.ts
 var ExactEvmSchemeV12 = class {
   /**
    * Creates a new ExactEvmFacilitatorV1 instance.
@@ -365,7 +681,8 @@ var ExactEvmSchemeV12 = class {
     this.scheme = "exact";
     this.caipFamily = "eip155:*";
     this.config = {
-      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false
+      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false,
+      simulateInSettle: config?.simulateInSettle ?? false
     };
   }
   /**
@@ -396,14 +713,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 } = parseErc6492Signature2(
+        exactEvmPayload.signature
+      );
+      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !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,
+        getAddress3(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;
@@ -412,24 +810,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 = getAddress2(requirements.asset);
+    const erc20Address = getAddress3(requirements.asset);
     if (payloadV1.network !== requirements.network) {
       return {
         isValid: false,
-        invalidReason: "network_mismatch",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrNetworkMismatch,
+        payer
       };
     }
     const permitTypedData = {
@@ -450,210 +848,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 = parseErc6492Signature2(signature);
+    const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !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 = parseErc6492Signature(signature);
-          const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !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 (getAddress2(exactEvmPayload.authorization.to) !== getAddress2(requirements.payTo)) {
+    if (getAddress3(exactEvmPayload.authorization.to) !== getAddress3(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 = parseErc6492Signature(exactEvmPayload.signature);
-      const { signature, address: factoryAddress, data: factoryCalldata } = parseResult;
-      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !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 = parseSignature(signature);
-        tx = await this.signer.writeContract({
-          address: getAddress2(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            getAddress2(exactEvmPayload.authorization.from),
-            getAddress2(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: getAddress2(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            getAddress2(exactEvmPayload.authorization.from),
-            getAddress2(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/v1/index.ts
@@ -705,10 +990,63 @@ export {
   getEvmChainId,
   createNonce,
   createPermit2Nonce,
+  ErrInvalidScheme,
+  ErrNetworkMismatch,
+  ErrMissingEip712Domain,
+  ErrRecipientMismatch,
+  ErrInvalidSignature,
+  ErrValidBeforeExpired,
+  ErrValidAfterInFuture,
+  ErrInvalidAuthorizationValue,
+  ErrUndeployedSmartWallet,
+  ErrTransactionFailed,
+  ErrPermit2InvalidSpender,
+  ErrPermit2RecipientMismatch,
+  ErrPermit2DeadlineExpired,
+  ErrPermit2NotYetValid,
+  ErrPermit2AmountMismatch,
+  ErrPermit2TokenMismatch,
+  ErrPermit2InvalidSignature,
+  ErrPermit2AllowanceRequired,
+  ErrPermit2SimulationFailed,
+  ErrPermit2InsufficientBalance,
+  ErrPermit2ProxyNotDeployed,
+  ErrPermit2InvalidAmount,
+  ErrPermit2InvalidDestination,
+  ErrPermit2InvalidOwner,
+  ErrPermit2PaymentTooEarly,
+  ErrPermit2InvalidNonce,
+  ErrPermit2612AmountMismatch,
+  ErrErc20ApprovalInsufficientEthForGas,
+  ErrErc20ApprovalInvalidFormat,
+  ErrErc20ApprovalFromMismatch,
+  ErrErc20ApprovalAssetMismatch,
+  ErrErc20ApprovalSpenderNotPermit2,
+  ErrErc20ApprovalTxWrongTarget,
+  ErrErc20ApprovalTxWrongSelector,
+  ErrErc20ApprovalTxWrongSpender,
+  ErrErc20ApprovalTxInvalidCalldata,
+  ErrErc20ApprovalTxSignerMismatch,
+  ErrErc20ApprovalTxInvalidSignature,
+  ErrErc20ApprovalTxParseFailed,
+  ErrErc20ApprovalTxFailed,
+  ErrInvalidEip2612ExtensionFormat,
+  ErrEip2612FromMismatch,
+  ErrEip2612AssetMismatch,
+  ErrEip2612SpenderNotPermit2,
+  ErrEip2612DeadlineExpired,
+  ErrUnsupportedPayloadType,
+  ErrInvalidTransactionState,
+  MULTICALL3_ADDRESS,
+  multicall3GetEthBalanceAbi,
+  multicall,
+  simulateEip3009Transfer,
+  diagnoseEip3009SimulationFailure,
+  executeTransferWithAuthorization,
   ExactEvmSchemeV12 as ExactEvmSchemeV1,
   EVM_NETWORK_CHAIN_ID_MAP,
   NETWORKS,
   getEvmChainIdV1,
   ExactEvmSchemeV1 as ExactEvmSchemeV12
 };
-//# sourceMappingURL=chunk-XL6IFXCP.mjs.map
+//# sourceMappingURL=chunk-IZEI7JTG.mjs.map