@x402/evm 2.6.0 → 2.8.0

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

@@ -25,7 +25,7 @@ __export(facilitator_exports, {
 module.exports = __toCommonJS(facilitator_exports);
 
 // src/exact/v1/facilitator/scheme.ts
-var import_viem3 = require("viem");
+var import_viem5 = require("viem");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -84,6 +84,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"
   }
 ];
 
@@ -124,6 +141,257 @@ function getEvmChainIdV1(network) {
   return chainId;
 }
 
+// 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";
+
+// src/exact/facilitator/eip3009-utils.ts
+var import_viem4 = require("viem");
+
+// src/multicall.ts
+var import_viem3 = require("viem");
+var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+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_viem3.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_viem3.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_viem4.getAddress)(auth.from),
+    (0, import_viem4.getAddress)(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (eip6492Deployment) {
+    const { signature: innerSignature } = (0, import_viem4.parseErc6492Signature)(payload.signature);
+    const transferCalldata = (0, import_viem4.encodeFunctionData)({
+      abi: eip3009ABI,
+      functionName: "transferWithAuthorization",
+      args: [...transferArgs, innerSignature]
+    });
+    try {
+      const results = await multicall(signer.readContract.bind(signer), [
+        {
+          address: (0, import_viem4.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_viem4.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_viem4.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_viem4.getAddress)(auth.from),
+    (0, import_viem4.getAddress)(auth.to),
+    BigInt(auth.value),
+    BigInt(auth.validAfter),
+    BigInt(auth.validBefore),
+    auth.nonce
+  ];
+  if (isECDSA) {
+    const parsedSig = (0, import_viem4.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 {
   /**
@@ -137,7 +405,8 @@ var ExactEvmSchemeV12 = class {
     this.scheme = "exact";
     this.caipFamily = "eip155:*";
     this.config = {
-      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false
+      deployERC4337WithEIP6492: config?.deployERC4337WithEIP6492 ?? false,
+      simulateInSettle: config?.simulateInSettle ?? false
     };
   }
   /**
@@ -168,14 +437,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_viem5.parseErc6492Signature)(
+        exactEvmPayload.signature
+      );
+      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem5.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_viem5.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;
@@ -184,24 +534,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_viem3.getAddress)(requirements.asset);
+    const erc20Address = (0, import_viem5.getAddress)(requirements.asset);
     if (payloadV1.network !== requirements.network) {
       return {
         isValid: false,
-        invalidReason: "network_mismatch",
-        payer: exactEvmPayload.authorization.from
+        invalidReason: ErrNetworkMismatch,
+        payer
       };
     }
     const permitTypedData = {
@@ -222,210 +572,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_viem5.parseErc6492Signature)(signature);
+    const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem5.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_viem3.parseErc6492Signature)(signature);
-          const hasDeploymentInfo = erc6492Data.address && erc6492Data.data && !(0, import_viem3.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_viem3.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem3.getAddress)(requirements.payTo)) {
+    if ((0, import_viem5.getAddress)(exactEvmPayload.authorization.to) !== (0, import_viem5.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_viem3.parseErc6492Signature)(exactEvmPayload.signature);
-      const { signature, address: factoryAddress, data: factoryCalldata } = parseResult;
-      if (this.config.deployERC4337WithEIP6492 && factoryAddress && factoryCalldata && !(0, import_viem3.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_viem3.parseSignature)(signature);
-        tx = await this.signer.writeContract({
-          address: (0, import_viem3.getAddress)(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            (0, import_viem3.getAddress)(exactEvmPayload.authorization.from),
-            (0, import_viem3.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_viem3.getAddress)(requirements.asset),
-          abi: eip3009ABI,
-          functionName: "transferWithAuthorization",
-          args: [
-            (0, import_viem3.getAddress)(exactEvmPayload.authorization.from),
-            (0, import_viem3.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
-      };
-    }
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {