@x402/evm 2.4.0 → 2.5.0

package/dist/cjs/exact/client/index.d.ts

@@ -1,7 +1,7 @@
-export { E as ExactEvmScheme, P as Permit2AllowanceParams, c as createPermit2ApprovalTx, e as erc20AllowanceAbi, g as getPermit2AllowanceReadParams } from '../../permit2-CzKPU5By.js';
+export { E as ExactEvmScheme, a as Permit2AllowanceParams, c as createPermit2ApprovalTx, d as erc20AllowanceAbi, g as getPermit2AllowanceReadParams } from '../../permit2-CQbXqCMC.js';
 import { SelectPaymentRequirements, PaymentPolicy, x402Client } from '@x402/core/client';
 import { Network } from '@x402/core/types';
-import { C as ClientEvmSigner } from '../../signer-3KGwtdNT.js';
+import { C as ClientEvmSigner } from '../../signer-DC81R8wQ.js';
 
 /**
  * Configuration options for registering EVM schemes to an x402Client

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

@@ -29,7 +29,7 @@ __export(client_exports, {
 module.exports = __toCommonJS(client_exports);
 
 // src/exact/client/scheme.ts
-var import_extensions = require("@x402/extensions");
+var import_extensions2 = require("@x402/extensions");
 
 // src/constants.ts
 var authorizationTypes = {
@@ -56,8 +56,7 @@ var permit2WitnessTypes = {
   ],
   Witness: [
     { name: "to", type: "address" },
-    { name: "validAfter", type: "uint256" },
-    { name: "extra", type: "bytes" }
+    { name: "validAfter", type: "uint256" }
   ]
 };
 var eip2612PermitTypes = {
@@ -78,133 +77,51 @@ var eip2612NoncesAbi = [
     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 x402ExactPermit2ProxyAddress = "0x402085c248EeA27D92E8b30b2C58ed07f9E20001";
 
 // src/exact/client/scheme.ts
-var import_viem7 = require("viem");
-
-// src/exact/client/eip3009.ts
-var import_viem4 = require("viem");
+var import_viem6 = require("viem");
 
 // src/utils.ts
-var import_viem3 = require("viem");
-
-// src/exact/v1/client/scheme.ts
 var import_viem = require("viem");
-var ExactEvmSchemeV1 = class {
-  /**
-   * Creates a new ExactEvmClientV1 instance.
-   *
-   * @param signer - The EVM signer for client operations
-   */
-  constructor(signer) {
-    this.signer = signer;
-    this.scheme = "exact";
-  }
-  /**
-   * Creates a payment payload for the Exact scheme (V1).
-   *
-   * @param x402Version - The x402 protocol version
-   * @param paymentRequirements - The payment requirements
-   * @returns Promise resolving to a payment payload
-   */
-  async createPaymentPayload(x402Version, paymentRequirements) {
-    const selectedV1 = paymentRequirements;
-    const nonce = createNonce();
-    const now = Math.floor(Date.now() / 1e3);
-    const authorization = {
-      from: this.signer.address,
-      to: (0, import_viem.getAddress)(selectedV1.payTo),
-      value: selectedV1.maxAmountRequired,
-      validAfter: (now - 600).toString(),
-      // 10 minutes before
-      validBefore: (now + selectedV1.maxTimeoutSeconds).toString(),
-      nonce
-    };
-    const signature = await this.signAuthorization(authorization, selectedV1);
-    const payload = {
-      authorization,
-      signature
-    };
-    return {
-      x402Version,
-      scheme: selectedV1.scheme,
-      network: selectedV1.network,
-      payload
-    };
-  }
-  /**
-   * Sign the EIP-3009 authorization using EIP-712
-   *
-   * @param authorization - The authorization to sign
-   * @param requirements - The payment requirements
-   * @returns Promise resolving to the signature
-   */
-  async signAuthorization(authorization, requirements) {
-    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}`
-      );
-    }
-    const { name, version } = requirements.extra;
-    const domain = {
-      name,
-      version,
-      chainId,
-      verifyingContract: (0, import_viem.getAddress)(requirements.asset)
-    };
-    const message = {
-      from: (0, import_viem.getAddress)(authorization.from),
-      to: (0, import_viem.getAddress)(authorization.to),
-      value: BigInt(authorization.value),
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-      nonce: authorization.nonce
-    };
-    return await this.signer.signTypedData({
-      domain,
-      types: authorizationTypes,
-      primaryType: "TransferWithAuthorization",
-      message
-    });
-  }
-};
-
-// 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/utils.ts
 function getEvmChainId(network) {
-  const chainId = EVM_NETWORK_CHAIN_ID_MAP[network];
-  if (!chainId) {
-    throw new Error(`Unsupported network: ${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;
   }
-  return chainId;
+  throw new Error(`Unsupported network format: ${network} (expected eip155:CHAIN_ID)`);
 }
 function getCrypto() {
   const cryptoObj = globalThis.crypto;
@@ -214,20 +131,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(),
@@ -244,7 +162,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}`
@@ -255,11 +173,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),
@@ -274,7 +192,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);
@@ -284,16 +202,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(
@@ -311,7 +228,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,
@@ -319,16 +236,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({
@@ -338,56 +254,31 @@ 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_viem6 = require("viem");
-var MAX_UINT2562 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline) {
+var import_viem4 = require("viem");
+async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion, chainId, deadline, permittedAmount) {
   const owner = signer.address;
-  const spender = (0, import_viem6.getAddress)(PERMIT2_ADDRESS);
+  const spender = (0, import_viem4.getAddress)(PERMIT2_ADDRESS);
   const nonce = await signer.readContract({
     address: tokenAddress,
     abi: eip2612NoncesAbi,
@@ -400,10 +291,11 @@ async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion,
     chainId,
     verifyingContract: tokenAddress
   };
+  const approvalAmount = BigInt(permittedAmount);
   const message = {
     owner,
     spender,
-    value: MAX_UINT2562,
+    value: approvalAmount,
     nonce,
     deadline: BigInt(deadline)
   };
@@ -417,7 +309,7 @@ async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion,
     from: owner,
     asset: tokenAddress,
     spender,
-    amount: MAX_UINT2562.toString(),
+    amount: approvalAmount.toString(),
     nonce: nonce.toString(),
     deadline,
     signature,
@@ -425,19 +317,48 @@ async function signEip2612Permit(signer, tokenAddress, tokenName, tokenVersion,
   };
 }
 
-// src/exact/client/scheme.ts
-var erc20AllowanceAbi2 = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
+// 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
+  };
+}
+
+// src/exact/client/scheme.ts
 var ExactEvmScheme = class {
   /**
    * Creates a new ExactEvmClient instance.
@@ -478,6 +399,13 @@ var ExactEvmScheme = class {
           extensions: eip2612Extensions
         };
       }
+      const erc20Extensions = await this.trySignErc20Approval(paymentRequirements, result, context);
+      if (erc20Extensions) {
+        return {
+          ...result,
+          extensions: erc20Extensions
+        };
+      }
       return result;
     }
     return createEIP3009Payload(this.signer, x402Version, paymentRequirements);
@@ -498,7 +426,7 @@ var ExactEvmScheme = class {
    * @returns Extension data for EIP-2612 gas sponsoring, or undefined if not applicable
    */
   async trySignEip2612Permit(requirements, result, context) {
-    if (!context?.extensions?.[import_extensions.EIP2612_GAS_SPONSORING.key]) {
+    if (!context?.extensions?.[import_extensions2.EIP2612_GAS_SPONSORING.key]) {
       return void 0;
     }
     const tokenName = requirements.extra?.name;
@@ -506,12 +434,12 @@ var ExactEvmScheme = class {
     if (!tokenName || !tokenVersion) {
       return void 0;
     }
-    const chainId = parseInt(requirements.network.split(":")[1]);
-    const tokenAddress = (0, import_viem7.getAddress)(requirements.asset);
+    const chainId = getEvmChainId(requirements.network);
+    const tokenAddress = (0, import_viem6.getAddress)(requirements.asset);
     try {
       const allowance = await this.signer.readContract({
         address: tokenAddress,
-        abi: erc20AllowanceAbi2,
+        abi: erc20AllowanceAbi,
         functionName: "allowance",
         args: [this.signer.address, PERMIT2_ADDRESS]
       });
@@ -528,12 +456,176 @@ var ExactEvmScheme = class {
       tokenName,
       tokenVersion,
       chainId,
-      deadline
+      deadline,
+      requirements.amount
     );
     return {
-      [import_extensions.EIP2612_GAS_SPONSORING.key]: { info }
+      [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);
+function getEvmChainIdV1(network) {
+  const chainId = EVM_NETWORK_CHAIN_ID_MAP[network];
+  if (!chainId) {
+    throw new Error(`Unsupported v1 network: ${network}`);
+  }
+  return chainId;
+}
+
+// src/exact/v1/client/scheme.ts
+var ExactEvmSchemeV1 = class {
+  /**
+   * Creates a new ExactEvmClientV1 instance.
+   *
+   * @param signer - The EVM signer for client operations
+   */
+  constructor(signer) {
+    this.signer = signer;
+    this.scheme = "exact";
+  }
+  /**
+   * Creates a payment payload for the Exact scheme (V1).
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    const selectedV1 = paymentRequirements;
+    const nonce = createNonce();
+    const now = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: this.signer.address,
+      to: (0, import_viem8.getAddress)(selectedV1.payTo),
+      value: selectedV1.maxAmountRequired,
+      validAfter: (now - 600).toString(),
+      // 10 minutes before
+      validBefore: (now + selectedV1.maxTimeoutSeconds).toString(),
+      nonce
+    };
+    const signature = await this.signAuthorization(authorization, selectedV1);
+    const payload = {
+      authorization,
+      signature
+    };
+    return {
+      x402Version,
+      scheme: selectedV1.scheme,
+      network: selectedV1.network,
+      payload
+    };
+  }
+  /**
+   * Sign the EIP-3009 authorization using EIP-712
+   *
+   * @param authorization - The authorization to sign
+   * @param requirements - The payment requirements
+   * @returns Promise resolving to the signature
+   */
+  async signAuthorization(authorization, requirements) {
+    const chainId = getEvmChainIdV1(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}`
+      );
+    }
+    const { name, version } = requirements.extra;
+    const domain = {
+      name,
+      version,
+      chainId,
+      verifyingContract: (0, import_viem8.getAddress)(requirements.asset)
+    };
+    const message = {
+      from: (0, import_viem8.getAddress)(authorization.from),
+      to: (0, import_viem8.getAddress)(authorization.to),
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    };
+    return await this.signer.signTypedData({
+      domain,
+      types: authorizationTypes,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
+  }
 };
 
 // src/exact/client/register.ts