@x402/evm 2.3.1 → 2.5.0

package/dist/cjs/index.js

@@ -38,8 +38,8 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/exact/client/eip3009.ts
-var import_viem4 = require("viem");
+// src/exact/client/scheme.ts
+var import_extensions2 = require("@x402/extensions");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -66,8 +66,7 @@ var permit2WitnessTypes = {
   ],
   Witness: [
     { name: "to", type: "address" },
-    { name: "validAfter", type: "uint256" },
-    { name: "extra", type: "bytes" }
+    { name: "validAfter", type: "uint256" }
   ]
 };
 var eip3009ABI = [
@@ -118,9 +117,58 @@ var eip3009ABI = [
     type: "function"
   }
 ];
+var eip2612PermitTypes = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var eip2612NoncesAbi = [
+  {
+    type: "function",
+    name: "nonces",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var erc20ApproveAbi = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+var erc20AllowanceAbi = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var ERC20_APPROVE_GAS_LIMIT = 70000n;
+var DEFAULT_MAX_FEE_PER_GAS = 1000000000n;
+var DEFAULT_MAX_PRIORITY_FEE_PER_GAS = 100000000n;
 var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
-var x402ExactPermit2ProxyAddress = "0x4020615294c913F045dc10f0a5cdEbd86c280001";
-var x402UptoPermit2ProxyAddress = "0x4020633461b2895a48930Ff97eE8fCdE8E520002";
+var x402ExactPermit2ProxyAddress = "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
+var x402UptoPermit2ProxyAddress = "0x402039b3d6E6BEC5A02c2C9fd937ac17A6940002";
+var permit2WitnessABIComponents = [
+  { name: "to", type: "address", internalType: "address" },
+  { name: "validAfter", type: "uint256", internalType: "uint256" }
+];
 var x402ExactPermit2ProxyABI = [
   {
     type: "function",
@@ -143,13 +191,6 @@ var x402ExactPermit2ProxyABI = [
     outputs: [{ name: "", type: "string", internalType: "string" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "initialize",
-    inputs: [{ name: "_permit2", type: "address", internalType: "address" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
   {
     type: "function",
     name: "settle",
@@ -176,12 +217,8 @@ var x402ExactPermit2ProxyABI = [
       {
         name: "witness",
         type: "tuple",
-        internalType: "struct x402BasePermit2Proxy.Witness",
-        components: [
-          { name: "to", type: "address", internalType: "address" },
-          { name: "validAfter", type: "uint256", internalType: "uint256" },
-          { name: "extra", type: "bytes", internalType: "bytes" }
-        ]
+        internalType: "struct x402ExactPermit2Proxy.Witness",
+        components: permit2WitnessABIComponents
       },
       { name: "signature", type: "bytes", internalType: "bytes" }
     ],
@@ -195,7 +232,7 @@ var x402ExactPermit2ProxyABI = [
       {
         name: "permit2612",
         type: "tuple",
-        internalType: "struct x402BasePermit2Proxy.EIP2612Permit",
+        internalType: "struct x402ExactPermit2Proxy.EIP2612Permit",
         components: [
           { name: "value", type: "uint256", internalType: "uint256" },
           { name: "deadline", type: "uint256", internalType: "uint256" },
@@ -226,12 +263,8 @@ var x402ExactPermit2ProxyABI = [
       {
         name: "witness",
         type: "tuple",
-        internalType: "struct x402BasePermit2Proxy.Witness",
-        components: [
-          { name: "to", type: "address", internalType: "address" },
-          { name: "validAfter", type: "uint256", internalType: "uint256" },
-          { name: "extra", type: "bytes", internalType: "bytes" }
-        ]
+        internalType: "struct x402ExactPermit2Proxy.Witness",
+        components: permit2WitnessABIComponents
       },
       { name: "signature", type: "bytes", internalType: "bytes" }
     ],
@@ -240,47 +273,31 @@ var x402ExactPermit2ProxyABI = [
   },
   { type: "event", name: "Settled", inputs: [], anonymous: false },
   { type: "event", name: "SettledWithPermit", inputs: [], anonymous: false },
-  { type: "error", name: "AlreadyInitialized", inputs: [] },
+  { type: "error", name: "InvalidAmount", inputs: [] },
   { type: "error", name: "InvalidDestination", inputs: [] },
   { type: "error", name: "InvalidOwner", inputs: [] },
   { type: "error", name: "InvalidPermit2Address", inputs: [] },
   { type: "error", name: "PaymentTooEarly", inputs: [] },
+  { type: "error", name: "Permit2612AmountMismatch", inputs: [] },
   { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] }
 ];
 
-// src/utils.ts
-var import_viem3 = require("viem");
-
-// src/exact/v1/client/scheme.ts
-var import_viem = require("viem");
-
-// src/exact/v1/facilitator/scheme.ts
-var import_viem2 = require("viem");
-
-// src/v1/index.ts
-var EVM_NETWORK_CHAIN_ID_MAP = {
-  ethereum: 1,
-  sepolia: 11155111,
-  abstract: 2741,
-  "abstract-testnet": 11124,
-  "base-sepolia": 84532,
-  base: 8453,
-  "avalanche-fuji": 43113,
-  avalanche: 43114,
-  iotex: 4689,
-  sei: 1329,
-  "sei-testnet": 1328,
-  polygon: 137,
-  "polygon-amoy": 80002,
-  peaq: 3338,
-  story: 1514,
-  educhain: 41923,
-  "skale-base-sepolia": 324705682,
-  megaeth: 4326
-};
-var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
+// src/exact/client/scheme.ts
+var import_viem6 = require("viem");
 
 // src/utils.ts
+var import_viem = require("viem");
+function getEvmChainId(network) {
+  if (network.startsWith("eip155:")) {
+    const idStr = network.split(":")[1];
+    const chainId = parseInt(idStr, 10);
+    if (isNaN(chainId)) {
+      throw new Error(`Invalid CAIP-2 chain ID: ${network}`);
+    }
+    return chainId;
+  }
+  throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
+}
 function getCrypto() {
   const cryptoObj = globalThis.crypto;
   if (!cryptoObj) {
@@ -289,20 +306,21 @@ function getCrypto() {
   return cryptoObj;
 }
 function createNonce() {
-  return (0, import_viem3.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
+  return (0, import_viem.toHex)(getCrypto().getRandomValues(new Uint8Array(32)));
 }
 function createPermit2Nonce() {
   const randomBytes = getCrypto().getRandomValues(new Uint8Array(32));
-  return BigInt((0, import_viem3.toHex)(randomBytes)).toString();
+  return BigInt((0, import_viem.toHex)(randomBytes)).toString();
 }
 
 // src/exact/client/eip3009.ts
+var import_viem2 = require("viem");
 async function createEIP3009Payload(signer, x402Version, paymentRequirements) {
   const nonce = createNonce();
   const now = Math.floor(Date.now() / 1e3);
   const authorization = {
     from: signer.address,
-    to: (0, import_viem4.getAddress)(paymentRequirements.payTo),
+    to: (0, import_viem2.getAddress)(paymentRequirements.payTo),
     value: paymentRequirements.amount,
     validAfter: (now - 600).toString(),
     validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
@@ -319,7 +337,7 @@ async function createEIP3009Payload(signer, x402Version, paymentRequirements) {
   };
 }
 async function signEIP3009Authorization(signer, authorization, requirements) {
-  const chainId = parseInt(requirements.network.split(":")[1]);
+  const chainId = getEvmChainId(requirements.network);
   if (!requirements.extra?.name || !requirements.extra?.version) {
     throw new Error(
       `EIP-712 domain parameters (name, version) are required in payment requirements for asset ${requirements.asset}`
@@ -330,11 +348,11 @@ async function signEIP3009Authorization(signer, authorization, requirements) {
     name,
     version,
     chainId,
-    verifyingContract: (0, import_viem4.getAddress)(requirements.asset)
+    verifyingContract: (0, import_viem2.getAddress)(requirements.asset)
   };
   const message = {
-    from: (0, import_viem4.getAddress)(authorization.from),
-    to: (0, import_viem4.getAddress)(authorization.to),
+    from: (0, import_viem2.getAddress)(authorization.from),
+    to: (0, import_viem2.getAddress)(authorization.to),
     value: BigInt(authorization.value),
     validAfter: BigInt(authorization.validAfter),
     validBefore: BigInt(authorization.validBefore),
@@ -349,7 +367,7 @@ async function signEIP3009Authorization(signer, authorization, requirements) {
 }
 
 // src/exact/client/permit2.ts
-var import_viem5 = require("viem");
+var import_viem3 = require("viem");
 var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   const now = Math.floor(Date.now() / 1e3);
@@ -359,16 +377,15 @@ async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   const permit2Authorization = {
     from: signer.address,
     permitted: {
-      token: (0, import_viem5.getAddress)(paymentRequirements.asset),
+      token: (0, import_viem3.getAddress)(paymentRequirements.asset),
       amount: paymentRequirements.amount
     },
     spender: x402ExactPermit2ProxyAddress,
     nonce,
     deadline,
     witness: {
-      to: (0, import_viem5.getAddress)(paymentRequirements.payTo),
-      validAfter,
-      extra: "0x"
+      to: (0, import_viem3.getAddress)(paymentRequirements.payTo),
+      validAfter
     }
   };
   const signature = await signPermit2Authorization(
@@ -386,7 +403,7 @@ async function createPermit2Payload(signer, x402Version, paymentRequirements) {
   };
 }
 async function signPermit2Authorization(signer, permit2Authorization, requirements) {
-  const chainId = parseInt(requirements.network.split(":")[1]);
+  const chainId = getEvmChainId(requirements.network);
   const domain = {
     name: "Permit2",
     chainId,
@@ -394,16 +411,15 @@ async function signPermit2Authorization(signer, permit2Authorization, requiremen
   };
   const message = {
     permitted: {
-      token: (0, import_viem5.getAddress)(permit2Authorization.permitted.token),
+      token: (0, import_viem3.getAddress)(permit2Authorization.permitted.token),
       amount: BigInt(permit2Authorization.permitted.amount)
     },
-    spender: (0, import_viem5.getAddress)(permit2Authorization.spender),
+    spender: (0, import_viem3.getAddress)(permit2Authorization.spender),
     nonce: BigInt(permit2Authorization.nonce),
     deadline: BigInt(permit2Authorization.deadline),
     witness: {
-      to: (0, import_viem5.getAddress)(permit2Authorization.witness.to),
-      validAfter: BigInt(permit2Authorization.witness.validAfter),
-      extra: permit2Authorization.witness.extra
+      to: (0, import_viem3.getAddress)(permit2Authorization.witness.to),
+      validAfter: BigInt(permit2Authorization.witness.validAfter)
     }
   };
   return await signer.signTypedData({
@@ -413,47 +429,107 @@ async function signPermit2Authorization(signer, permit2Authorization, requiremen
     message
   });
 }
-var erc20ApproveAbi = [
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ type: "bool" }],
-    stateMutability: "nonpayable"
-  }
-];
-var erc20AllowanceAbi = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  }
-];
 function createPermit2ApprovalTx(tokenAddress) {
-  const data = (0, import_viem5.encodeFunctionData)({
+  const data = (0, import_viem3.encodeFunctionData)({
     abi: erc20ApproveAbi,
     functionName: "approve",
     args: [PERMIT2_ADDRESS, MAX_UINT256]
   });
   return {
-    to: (0, import_viem5.getAddress)(tokenAddress),
+    to: (0, import_viem3.getAddress)(tokenAddress),
     data
   };
 }
 function getPermit2AllowanceReadParams(params) {
   return {
-    address: (0, import_viem5.getAddress)(params.tokenAddress),
+    address: (0, import_viem3.getAddress)(params.tokenAddress),
     abi: erc20AllowanceAbi,
     functionName: "allowance",
-    args: [(0, import_viem5.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+    args: [(0, import_viem3.getAddress)(params.ownerAddress), PERMIT2_ADDRESS]
+  };
+}
+
+// src/exact/client/eip2612.ts
+var import_viem4 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
+  const owner = signer.address;
+  const spender = (0, import_viem4.getAddress)(PERMIT2_ADDRESS);
+  const nonce = await signer.readContract({
+    address: tokenAddress,
+    abi: eip2612NoncesAbi,
+    functionName: "nonces",
+    args: [owner]
+  });
+  const domain = {
+    name: tokenName,
+    version: tokenVersion,
+    chainId,
+    verifyingContract: tokenAddress
+  };
+  const approvalAmount = BigInt(permittedAmount);
+  const message = {
+    owner,
+    spender,
+    value: approvalAmount,
+    nonce,
+    deadline: BigInt(deadline)
+  };
+  const signature = await signer.signTypedData({
+    domain,
+    types: eip2612PermitTypes,
+    primaryType: "Permit",
+    message
+  });
+  return {
+    from: owner,
+    asset: tokenAddress,
+    spender,
+    amount: approvalAmount.toString(),
+    nonce: nonce.toString(),
+    deadline,
+    signature,
+    version: "1"
+  };
+}
+
+// src/exact/client/erc20approval.ts
+var import_viem5 = require("viem");
+var import_extensions = require("@x402/extensions");
+async function signErc20ApprovalTransaction(signer, tokenAddress, chainId) {
+  const from = signer.address;
+  const spender = (0, import_viem5.getAddress)(PERMIT2_ADDRESS);
+  const data = (0, import_viem5.encodeFunctionData)({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [spender, import_viem5.maxUint256]
+  });
+  const nonce = await signer.getTransactionCount({ address: from });
+  let maxFeePerGas;
+  let maxPriorityFeePerGas;
+  try {
+    const fees = await signer.estimateFeesPerGas();
+    maxFeePerGas = fees.maxFeePerGas;
+    maxPriorityFeePerGas = fees.maxPriorityFeePerGas;
+  } catch {
+    maxFeePerGas = DEFAULT_MAX_FEE_PER_GAS;
+    maxPriorityFeePerGas = DEFAULT_MAX_PRIORITY_FEE_PER_GAS;
+  }
+  const signedTransaction = await signer.signTransaction({
+    to: tokenAddress,
+    data,
+    nonce,
+    gas: ERC20_APPROVE_GAS_LIMIT,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    chainId
+  });
+  return {
+    from,
+    asset: tokenAddress,
+    spender,
+    amount: import_viem5.maxUint256.toString(),
+    signedTransaction,
+    version: import_extensions.ERC20_APPROVAL_GAS_SPONSORING_VERSION
   };
 }
 
@@ -462,7 +538,9 @@ var ExactEvmScheme = class {
   /**
    * Creates a new ExactEvmClient instance.
    *
-   * @param signer - The EVM signer for client operations
+   * @param signer - The EVM signer for client operations.
+   *   Must support `readContract` for EIP-2612 gas sponsoring.
+   *   Use `createWalletClient(...).extend(publicActions)` or `toClientEvmSigner(account, publicClient)`.
    */
   constructor(signer) {
     this.signer = signer;
@@ -472,22 +550,197 @@ var ExactEvmScheme = class {
    * Creates a payment payload for the Exact scheme.
    * Routes to EIP-3009 or Permit2 based on requirements.extra.assetTransferMethod.
    *
+   * For Permit2 flows, if the server advertises `eip2612GasSponsoring` and the
+   * signer supports `readContract`, automatically signs an EIP-2612 permit
+   * when Permit2 allowance is insufficient.
+   *
    * @param x402Version - The x402 protocol version
    * @param paymentRequirements - The payment requirements
-   * @returns Promise resolving to a payment payload result
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result (with optional extensions)
    */
-  async createPaymentPayload(x402Version, paymentRequirements) {
+  async createPaymentPayload(x402Version, paymentRequirements, context) {
     const assetTransferMethod = paymentRequirements.extra?.assetTransferMethod ?? "eip3009";
     if (assetTransferMethod === "permit2") {
-      return createPermit2Payload(this.signer, x402Version, paymentRequirements);
+      const result = await createPermit2Payload(this.signer, x402Version, paymentRequirements);
+      const eip2612Extensions = await this.trySignEip2612Permit(
+        paymentRequirements,
+        result,
+        context
+      );
+      if (eip2612Extensions) {
+        return {
+          ...result,
+          extensions: eip2612Extensions
+        };
+      }
+      const erc20Extensions = await this.trySignErc20Approval(paymentRequirements, result, context);
+      if (erc20Extensions) {
+        return {
+          ...result,
+          extensions: erc20Extensions
+        };
+      }
+      return result;
     }
     return createEIP3009Payload(this.signer, x402Version, paymentRequirements);
   }
+  /**
+   * Attempts to sign an EIP-2612 permit for gasless Permit2 approval.
+   *
+   * Returns extension data if:
+   * 1. Server advertises eip2612GasSponsoring
+   * 2. Signer has readContract capability
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param result - The payment payload result from the scheme
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for EIP-2612 gas sponsoring, or undefined if not applicable
+   */
+  async trySignEip2612Permit(requirements, result, context) {
+    if (!context?.extensions?.[import_extensions2.EIP2612_GAS_SPONSORING.key]) {
+      return void 0;
+    }
+    const tokenName = requirements.extra?.name;
+    const tokenVersion = requirements.extra?.version;
+    if (!tokenName || !tokenVersion) {
+      return void 0;
+    }
+    const chainId = getEvmChainId(requirements.network);
+    const tokenAddress = (0, import_viem6.getAddress)(requirements.asset);
+    try {
+      const allowance = await this.signer.readContract({
+        address: tokenAddress,
+        abi: erc20AllowanceAbi,
+        functionName: "allowance",
+        args: [this.signer.address, PERMIT2_ADDRESS]
+      });
+      if (allowance >= BigInt(requirements.amount)) {
+        return void 0;
+      }
+    } catch {
+    }
+    const permit2Auth = result.payload?.permit2Authorization;
+    const deadline = permit2Auth?.deadline ?? Math.floor(Date.now() / 1e3 + requirements.maxTimeoutSeconds).toString();
+    const info = await signEip2612Permit(
+      this.signer,
+      tokenAddress,
+      tokenName,
+      tokenVersion,
+      chainId,
+      deadline,
+      requirements.amount
+    );
+    return {
+      [import_extensions2.EIP2612_GAS_SPONSORING.key]: { info }
+    };
+  }
+  /**
+   * Attempts to sign an ERC-20 approval transaction for gasless Permit2 approval.
+   *
+   * This is the fallback path when the token does not support EIP-2612. The client
+   * signs (but does not broadcast) a raw `approve(Permit2, MaxUint256)` transaction.
+   * The facilitator broadcasts it atomically before settling.
+   *
+   * Returns extension data if:
+   * 1. Server advertises erc20ApprovalGasSponsoring
+   * 2. Signer has signTransaction + getTransactionCount capabilities
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param _result - The payment payload result from the scheme (unused)
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for ERC-20 approval gas sponsoring, or undefined if not applicable
+   */
+  async trySignErc20Approval(requirements, _result, context) {
+    if (!context?.extensions?.[import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key]) {
+      return void 0;
+    }
+    if (!this.signer.signTransaction || !this.signer.getTransactionCount) {
+      return void 0;
+    }
+    const chainId = getEvmChainId(requirements.network);
+    const tokenAddress = (0, import_viem6.getAddress)(requirements.asset);
+    try {
+      const allowance = await this.signer.readContract({
+        address: tokenAddress,
+        abi: erc20AllowanceAbi,
+        functionName: "allowance",
+        args: [this.signer.address, PERMIT2_ADDRESS]
+      });
+      if (allowance >= BigInt(requirements.amount)) {
+        return void 0;
+      }
+    } catch {
+    }
+    const info = await signErc20ApprovalTransaction(this.signer, tokenAddress, chainId);
+    return {
+      [import_extensions2.ERC20_APPROVAL_GAS_SPONSORING.key]: { info }
+    };
+  }
+};
+
+// src/exact/v1/client/scheme.ts
+var import_viem8 = require("viem");
+
+// src/exact/v1/facilitator/scheme.ts
+var import_viem7 = require("viem");
+
+// src/v1/index.ts
+var EVM_NETWORK_CHAIN_ID_MAP = {
+  ethereum: 1,
+  sepolia: 11155111,
+  abstract: 2741,
+  "abstract-testnet": 11124,
+  "base-sepolia": 84532,
+  base: 8453,
+  "avalanche-fuji": 43113,
+  avalanche: 43114,
+  iotex: 4689,
+  sei: 1329,
+  "sei-testnet": 1328,
+  polygon: 137,
+  "polygon-amoy": 80002,
+  peaq: 3338,
+  story: 1514,
+  educhain: 41923,
+  "skale-base-sepolia": 324705682,
+  megaeth: 4326,
+  monad: 143
 };
+var NETWORKS = Object.keys(EVM_NETWORK_CHAIN_ID_MAP);
 
 // src/signer.ts
-function toClientEvmSigner(signer) {
-  return signer;
+function toClientEvmSigner(signer, publicClient) {
+  const readContract = signer.readContract ?? publicClient?.readContract.bind(publicClient);
+  if (!readContract) {
+    throw new Error(
+      "toClientEvmSigner requires either a signer with readContract or a publicClient. Use createWalletClient(...).extend(publicActions) or pass a publicClient."
+    );
+  }
+  const result = {
+    address: signer.address,
+    signTypedData: (msg) => signer.signTypedData(msg),
+    readContract
+  };
+  const signTransaction = signer.signTransaction;
+  if (signTransaction) {
+    result.signTransaction = (args) => signTransaction(args);
+  }
+  const getTransactionCount = signer.getTransactionCount ?? publicClient?.getTransactionCount?.bind(publicClient);
+  if (getTransactionCount) {
+    result.getTransactionCount = (args) => getTransactionCount(args);
+  }
+  const estimateFeesPerGas = signer.estimateFeesPerGas ?? publicClient?.estimateFeesPerGas?.bind(publicClient);
+  if (estimateFeesPerGas) {
+    result.estimateFeesPerGas = () => estimateFeesPerGas();
+  }
+  return result;
 }
 function toFacilitatorEvmSigner(client) {
   return {