@armory-sh/client-ethers 0.2.9 → 0.2.13

package/dist/index.d.ts

@@ -1,40 +1,80 @@
-import { PaymentRequirements, CAIP2ChainId, CAIPAssetId, CustomToken } from '@armory-sh/base';
-export { Address, BalanceOfParams, CAIP2ChainId, CAIPAssetId, EIP712_TYPES, ERC20_ABI, Extensions, NETWORKS, NetworkConfig, PayToV2, PaymentPayload, PaymentPayloadV1, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponse, SettlementResponseV1, SettlementResponseV2, Signature, TransferWithAuthorizationParams, V1_HEADERS, V2_HEADERS, createEIP712Domain, createTransferWithAuthorization, decodePayment, decodePaymentV1, decodePaymentV2, decodeSettlementLegacy, decodeSettlementV1, decodeSettlementV2, detectPaymentVersion, encodePaymentV1, encodePaymentV2, encodeSettlementV1, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, getPaymentRequiredHeaderName, getPaymentResponseHeaderName, getPaymentVersion, getRequirementsVersion, getSettlementVersion, getTestnets, getTxHash, isAddress, isCAIP2ChainId, isCAIPAssetId, isPaymentV1, isPaymentV2, isSettlementSuccessful, isSettlementV1, isSettlementV2, isV1, isV2, validateTransferWithAuthorization } from '@armory-sh/base';
+import { X402PaymentRequirementsV1, PaymentRequirementsV2, Address, X402PaymentPayloadV1, PaymentPayloadV2, CustomToken } from '@armory-sh/base';
+export { Address, BalanceOfParams, CAIP2ChainId, CAIPAssetId, EIP712_TYPES, ERC20_ABI, Extensions, NETWORKS, NetworkConfig, PayToV2, PaymentPayload, PaymentPayloadV1, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponse, SettlementResponseV1, SettlementResponseV2, Signature, TransferWithAuthorizationParams, V1_HEADERS, V2_HEADERS, createEIP712Domain, createTransferWithAuthorization, decodePayment, decodePaymentV1, decodePaymentV2, decodeSettlementLegacy, decodeSettlementV1, decodeSettlementV2, detectPaymentVersion, encodePaymentV1, encodePaymentV2, encodeSettlementV1, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName as getPaymentHeaderNameBase, getPaymentRequiredHeaderName, getPaymentResponseHeaderName, getPaymentVersion, getRequirementsVersion, getSettlementVersion, getTestnets, getTxHash, isCAIP2ChainId, isCAIPAssetId, isPaymentV1, isPaymentV2, isSettlementSuccessful, isSettlementV1, isSettlementV2, isV1, isV2, isX402V1PaymentRequired, isX402V1Requirements, isX402V2PaymentRequired, safeBase64Decode, validateTransferWithAuthorization } from '@armory-sh/base';
 import { Signer, Provider } from 'ethers';
-export { Signer } from 'ethers';
+export { Provider, Signer } from 'ethers';
 
-declare function createPaymentPayloadV1(params: {
-    signer: Signer;
-    from: string;
-    to: string;
-    amount: string;
-    nonce: string;
-    expiry: number;
-    chainId: number;
-    contractAddress: string;
-    network: string;
-    domainName?: string;
-    domainVersion?: string;
-}): Promise<string>;
-declare function createPaymentPayloadV2(params: {
-    signer: Signer;
-    from: `0x${string}`;
-    to: `0x${string}` | {
-        role?: string;
-        callback?: string;
-    };
-    amount: string;
-    nonce: string;
-    expiry: number;
-    chainId: CAIP2ChainId;
-    assetId: CAIPAssetId;
-    extensions?: Record<string, unknown>;
-    domainName?: string;
-    domainVersion?: string;
-}): Promise<string>;
-declare function detectProtocolVersion(requirements: PaymentRequirements): 1 | 2;
-declare function createPaymentPayload(requirements: PaymentRequirements, signer: Signer, from: string): Promise<[string, string]>;
-declare function parsePaymentRequirements(response: Response): Promise<PaymentRequirements>;
+/**
+ * X402 Protocol Implementation for Ethers Client
+ *
+ * Handles parsing x402 V1 and V2 PAYMENT-REQUIRED headers
+ * and generating x402 V1 and V2 PAYMENT-SIGNATURE payloads
+ */
+
+/**
+ * Detect x402 protocol version from response headers
+ */
+declare function detectX402Version(response: Response): 1 | 2;
+interface ParsedPaymentRequirements {
+    version: 1 | 2;
+    requirements: X402PaymentRequirementsV1 | PaymentRequirementsV2;
+}
+/**
+ * Parse x402 PAYMENT-REQUIRED header from response
+ * Automatically detects V1 or V2 format
+ */
+declare function parsePaymentRequired(response: Response): ParsedPaymentRequirements;
+/**
+ * Create x402 V1 payment payload
+ */
+declare function createX402V1Payment(signer: Signer, requirements: X402PaymentRequirementsV1, fromAddress: Address, nonce: `0x${string}`, validBefore: number, domainName?: string, domainVersion?: string): Promise<X402PaymentPayloadV1>;
+/**
+ * Create x402 V2 payment payload
+ */
+declare function createX402V2Payment(signer: Signer, requirements: PaymentRequirementsV2, fromAddress: Address, nonce: `0x${string}`, validBefore: number, domainName?: string, domainVersion?: string): Promise<PaymentPayloadV2>;
+/**
+ * Create x402 payment payload (auto-detects version)
+ */
+declare function createX402Payment(signer: Signer, parsed: ParsedPaymentRequirements, fromAddress: Address, nonce?: `0x${string}`, validBefore?: number, domainName?: string, domainVersion?: string): Promise<X402PaymentPayloadV1 | PaymentPayloadV2>;
+/**
+ * Encode x402 payment payload to Base64 for transport
+ */
+declare function encodeX402Payment(payload: X402PaymentPayloadV1 | PaymentPayloadV2): string;
+/**
+ * Get the correct header name for payment based on version
+ */
+declare function getPaymentHeaderName(version: 1 | 2): string;
+/**
+ * @deprecated Use createX402Payment instead
+ */
+declare function createPaymentPayload(requirements: unknown, signer: Signer, from: string): Promise<[string, string]>;
+/**
+ * @deprecated Use parsePaymentRequired instead
+ */
+declare function parsePaymentRequirements(response: Response): Promise<unknown>;
+/**
+ * @deprecated Use detectX402Version instead
+ */
+declare function detectProtocolVersion(requirements: unknown): 1 | 2;
+
+declare class X402ClientError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+declare class SigningError extends X402ClientError {
+    constructor(message: string, cause?: unknown);
+}
+declare class PaymentError extends X402ClientError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SignerRequiredError extends X402ClientError {
+    constructor(message?: string);
+}
+declare class AuthorizationError extends X402ClientError {
+    constructor(message: string, cause?: unknown);
+}
+declare class ProviderRequiredError extends X402ClientError {
+    constructor(message?: string);
+}
 
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
 type Token = CustomToken;
@@ -76,6 +116,20 @@ interface X402RequestInit extends Omit<RequestInit, "headers"> {
     skipAutoPay?: boolean;
     forceProtocolVersion?: 1 | 2;
 }
+interface TransferWithAuthorizationParams {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: bigint | number;
+    validAfter: bigint | number;
+    validBefore: bigint | number;
+    nonce: bigint | number;
+}
+interface EIP712Domain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: `0x${string}`;
+}
 
 interface X402Transport {
     fetch(url: string, init?: X402RequestInit): Promise<Response>;
@@ -89,4 +143,78 @@ interface X402Transport {
 }
 declare const createX402Transport: (config?: X402TransportConfig) => X402Transport;
 
-export { type ClientConfig, type X402ClientConfig, createPaymentPayload, createPaymentPayloadV1, createPaymentPayloadV2, createX402Transport, detectProtocolVersion, parsePaymentRequirements };
+declare function signEIP3009(signer: Signer, params: TransferWithAuthorizationParams, domain: EIP712Domain): Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+declare function signEIP3009WithDomain(signer: Signer, params: TransferWithAuthorizationParams, chainId: number, verifyingContract: `0x${string}`, domainName?: string, domainVersion?: string): Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+declare function signPayment(signer: Signer, from: `0x${string}`, to: `0x${string}`, value: bigint, chainId: number, verifyingContract: `0x${string}`, expirySeconds?: number, domainName?: string, domainVersion?: string): Promise<{
+    v: number;
+    r: string;
+    s: string;
+    nonce: bigint;
+}>;
+declare function recoverEIP3009Signer(params: TransferWithAuthorizationParams, signature: {
+    v: number;
+    r: string;
+    s: string;
+}, domain: EIP712Domain): Promise<`0x${string}`>;
+
+/**
+ * X402 Client Factory for Ethers
+ *
+ * Creates a configured client instance for making X-402 payments
+ */
+
+/**
+ * X402 Client instance
+ * Provides a high-level API for making X-402 authenticated requests
+ */
+interface X402Client {
+    /**
+     * Make a GET request
+     */
+    get(url: string, init?: X402RequestInit): Promise<Response>;
+    /**
+     * Make a POST request
+     */
+    post(url: string, body?: unknown, init?: X402RequestInit): Promise<Response>;
+    /**
+     * Make a PUT request
+     */
+    put(url: string, body?: unknown, init?: X402RequestInit): Promise<Response>;
+    /**
+     * Make a DELETE request
+     */
+    del(url: string, init?: X402RequestInit): Promise<Response>;
+    /**
+     * Make a PATCH request
+     */
+    patch(url: string, body?: unknown, init?: X402RequestInit): Promise<Response>;
+    /**
+     * Set the signer for payment signing
+     */
+    setSigner(signer: Signer): void;
+    /**
+     * Get the current signer
+     */
+    getSigner(): Signer | undefined;
+}
+
+/**
+ * Create an X402 client
+ *
+ * @param config - Client configuration
+ * @returns Configured X402 client
+ */
+declare function createX402Client(config: X402ClientConfig & SignerClientConfig & {
+    signer: Signer;
+}): X402Client;
+declare function createX402Client(config: X402ClientConfig & ProviderClientConfig): X402Client;
+
+export { AuthorizationError, type ClientConfig, type ParsedPaymentRequirements, PaymentError, ProviderRequiredError, SignerRequiredError, SigningError, type X402Client, type X402ClientConfig, X402ClientError, type X402RequestInit, type X402Transport, type X402TransportConfig, createPaymentPayload, createX402Client, createX402Payment, createX402Transport, createX402V1Payment, createX402V2Payment, detectProtocolVersion, detectX402Version, encodeX402Payment, getPaymentHeaderName, parsePaymentRequired, parsePaymentRequirements, recoverEIP3009Signer, signEIP3009, signEIP3009WithDomain, signPayment };

package/dist/index.js

@@ -1,28 +1,28 @@
 // src/index.ts
 import {
-  V1_HEADERS as V1_HEADERS2,
-  V2_HEADERS as V2_HEADERS2,
+  V1_HEADERS as V1_HEADERS3,
+  V2_HEADERS as V2_HEADERS3,
   isV1,
   isV2,
   getPaymentVersion,
   getRequirementsVersion,
   getSettlementVersion,
-  getPaymentHeaderName,
+  getPaymentHeaderName as getPaymentHeaderName2,
   getPaymentResponseHeaderName,
   getPaymentRequiredHeaderName,
-  isSettlementSuccessful,
+  isSettlementSuccessful as isSettlementSuccessful2,
   getTxHash,
   NETWORKS,
-  getNetworkConfig,
+  getNetworkConfig as getNetworkConfig2,
   getNetworkByChainId as getNetworkByChainId2,
   getMainnets,
   getTestnets,
   ERC20_ABI,
-  encodePaymentV1 as encodePaymentV12,
+  encodePaymentV1,
   decodePaymentV1,
   encodeSettlementV1,
   decodeSettlementV1,
-  encodePaymentV2 as encodePaymentV22,
+  encodePaymentV2,
   decodePaymentV2,
   encodeSettlementV2,
   decodeSettlementV2,
@@ -33,30 +33,39 @@ import {
   isPaymentV2,
   isSettlementV1,
   isSettlementV2,
-  EIP712_TYPES,
-  createEIP712Domain as createEIP712Domain2,
-  createTransferWithAuthorization,
+  isX402V1PaymentRequired as isX402V1PaymentRequired2,
+  isX402V2PaymentRequired as isX402V2PaymentRequired2,
+  isX402V1Requirements as isX402V1Requirements2,
+  EIP712_TYPES as EIP712_TYPES2,
+  createEIP712Domain as createEIP712Domain3,
+  createTransferWithAuthorization as createTransferWithAuthorization2,
   validateTransferWithAuthorization,
   isCAIP2ChainId,
   isCAIPAssetId,
-  isAddress
+  safeBase64Decode as safeBase64Decode2
 } from "@armory-sh/base";
 
 // src/protocol.ts
 import {
-  encodePaymentV1,
-  encodePaymentV2,
   V1_HEADERS,
   V2_HEADERS,
-  getNetworkByChainId
+  safeBase64Decode,
+  isX402V1PaymentRequired,
+  isX402V2PaymentRequired,
+  isX402V1Requirements,
+  getNetworkByChainId,
+  getNetworkConfig,
+  createEIP712Domain as createEIP712Domain2,
+  normalizeNetworkName
 } from "@armory-sh/base";
 
 // src/eip3009.ts
+import { ethers } from "ethers";
 import {
   createEIP712Domain
 } from "@armory-sh/base";
 
-// src/types.ts
+// src/errors.ts
 var X402ClientError = class extends Error {
   cause;
   constructor(message, cause) {
@@ -65,6 +74,18 @@ var X402ClientError = class extends Error {
     this.cause = cause;
   }
 };
+var SigningError = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Signing failed: ${message}`, cause);
+    this.name = "SigningError";
+  }
+};
+var PaymentError = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Payment failed: ${message}`, cause);
+    this.name = "PaymentError";
+  }
+};
 var SignerRequiredError = class extends X402ClientError {
   constructor(message = "Signer is required for this operation") {
     super(message);
@@ -77,6 +98,12 @@ var AuthorizationError = class extends X402ClientError {
     this.name = "AuthorizationError";
   }
 };
+var ProviderRequiredError = class extends X402ClientError {
+  constructor(message = "Provider is required for this operation") {
+    super(message);
+    this.name = "ProviderRequiredError";
+  }
+};
 
 // src/eip3009.ts
 var EIP712_TYPES_ETHERS = {
@@ -109,128 +136,257 @@ async function signEIP3009(signer, params, domain) {
     );
   }
 }
+async function signEIP3009WithDomain(signer, params, chainId, verifyingContract, domainName, domainVersion) {
+  const domain = createEIP712Domain(chainId, verifyingContract);
+  const customDomain = domainName || domainVersion ? { ...domain, name: domainName ?? domain.name, version: domainVersion ?? domain.version } : domain;
+  return signEIP3009(signer, params, customDomain);
+}
+async function signPayment(signer, from, to, value, chainId, verifyingContract, expirySeconds = 3600, domainName, domainVersion) {
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = BigInt(now * 1e3);
+  const signature = await signEIP3009WithDomain(
+    signer,
+    { from, to, value, validAfter: 0n, validBefore: BigInt(now + expirySeconds), nonce },
+    chainId,
+    verifyingContract,
+    domainName,
+    domainVersion
+  );
+  return { ...signature, nonce };
+}
+async function recoverEIP3009Signer(params, signature, domain) {
+  const message = {
+    from: params.from,
+    to: params.to,
+    value: BigInt(params.value),
+    validAfter: BigInt(params.validAfter),
+    validBefore: BigInt(params.validBefore),
+    nonce: BigInt(params.nonce)
+  };
+  const sig = ethers.Signature.from({
+    v: signature.v,
+    r: signature.r,
+    s: signature.s
+  });
+  const address = ethers.verifyTypedData(domain, EIP712_TYPES_ETHERS, message, sig);
+  return address;
+}
 
 // src/protocol.ts
-async function createPaymentPayloadV1(params) {
-  const { signer, from, to, amount, nonce, expiry, chainId, contractAddress, network, domainName, domainVersion } = params;
-  const authParams = {
-    from,
-    to,
-    value: BigInt(Math.floor(parseFloat(amount) * 1e6)),
-    validAfter: 0n,
-    validBefore: BigInt(expiry),
-    nonce: BigInt(nonce)
+function detectX402Version(response) {
+  const v2Header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
+  if (v2Header) {
+    try {
+      const parsed = JSON.parse(v2Header);
+      if (parsed.x402Version === 2) return 2;
+    } catch {
+    }
+  }
+  const v1Header = response.headers.get(V1_HEADERS.PAYMENT_REQUIRED);
+  if (v1Header) {
+    try {
+      const decoded = safeBase64Decode(v1Header);
+      const parsed = JSON.parse(decoded);
+      if (parsed.x402Version === 1) return 1;
+      return 1;
+    } catch {
+    }
+  }
+  return 2;
+}
+function parsePaymentRequired(response) {
+  const version = detectX402Version(response);
+  if (version === 2) {
+    const v2Header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
+    if (!v2Header) {
+      throw new PaymentError("No PAYMENT-REQUIRED header found in 402 response");
+    }
+    try {
+      const parsed = JSON.parse(v2Header);
+      if (!isX402V2PaymentRequired(parsed)) {
+        throw new PaymentError("Invalid x402 V2 payment required format");
+      }
+      if (!parsed.accepts || parsed.accepts.length === 0) {
+        throw new PaymentError("No payment requirements found in accepts array");
+      }
+      return {
+        version: 2,
+        requirements: parsed.accepts[0]
+      };
+    } catch (error) {
+      if (error instanceof PaymentError) throw error;
+      throw new PaymentError(`Failed to parse V2 PAYMENT-REQUIRED header: ${error}`);
+    }
+  }
+  const v1Header = response.headers.get(V1_HEADERS.PAYMENT_REQUIRED);
+  if (!v1Header) {
+    throw new PaymentError("No X-PAYMENT-REQUIRED header found in 402 response");
+  }
+  try {
+    const decoded = safeBase64Decode(v1Header);
+    const parsed = JSON.parse(decoded);
+    if (!isX402V1PaymentRequired(parsed)) {
+      throw new PaymentError("Invalid x402 V1 payment required format");
+    }
+    if (!parsed.accepts || parsed.accepts.length === 0) {
+      throw new PaymentError("No payment requirements found in accepts array");
+    }
+    return {
+      version: 1,
+      requirements: parsed.accepts[0]
+    };
+  } catch (error) {
+    if (error instanceof PaymentError) throw error;
+    throw new PaymentError(`Failed to parse V1 PAYMENT-REQUIRED header: ${error}`);
+  }
+}
+function toAtomicUnits(amount) {
+  return Math.floor(parseFloat(amount) * 1e6).toString();
+}
+function extractChainId(network) {
+  if (network.startsWith("eip155:")) {
+    return parseInt(network.split(":")[1], 10);
+  }
+  const net = getNetworkConfig(normalizeNetworkName(network));
+  if (net) {
+    return net.chainId;
+  }
+  throw new PaymentError(`Unsupported network: ${network}`);
+}
+function getNetworkSlug(network) {
+  if (network.startsWith("eip155:")) {
+    const chainId = parseInt(network.split(":")[1], 10);
+    const net = getNetworkByChainId(chainId);
+    if (!net) {
+      throw new PaymentError(`No network config found for chainId: ${chainId}`);
+    }
+    return normalizeNetworkName(net.name);
+  }
+  return normalizeNetworkName(network);
+}
+function createNonce() {
+  const now = Math.floor(Date.now() / 1e3);
+  return `0x${(now * 1e3).toString(16).padStart(64, "0")}`;
+}
+async function createX402V1Payment(signer, requirements, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  const network = getNetworkSlug(requirements.network);
+  const contractAddress = requirements.asset;
+  const chainId = extractChainId(requirements.network);
+  const domain = createEIP712Domain2(chainId, contractAddress);
+  const customDomain = domainName || domainVersion ? { ...domain, name: domainName ?? domain.name, version: domainVersion ?? domain.version } : domain;
+  const authorization = {
+    from: fromAddress,
+    to: requirements.payTo,
+    value: toAtomicUnits(requirements.maxAmountRequired),
+    validAfter: "0",
+    validBefore: validBefore.toString(),
+    nonce
   };
-  const domain = {
-    name: domainName ?? "USD Coin",
-    version: domainVersion ?? "2",
-    chainId,
-    verifyingContract: contractAddress
+  const authParams = {
+    from: authorization.from,
+    to: authorization.to,
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: BigInt(authorization.nonce)
   };
-  const signature = await signEIP3009(signer, authParams, domain);
+  const signature = await signEIP3009(signer, authParams, customDomain);
+  const combinedSignature = `0x${signature.r.slice(2)}${signature.s.slice(2)}${signature.v.toString(16).padStart(2, "0")}`;
   const payload = {
-    from,
-    to,
-    amount,
-    nonce,
-    expiry,
-    v: signature.v,
-    r: signature.r,
-    s: signature.s,
-    chainId,
-    contractAddress,
-    network
+    signature: combinedSignature,
+    authorization
+  };
+  return {
+    x402Version: 1,
+    scheme: "exact",
+    network,
+    payload
   };
-  return encodePaymentV1(payload);
 }
-async function createPaymentPayloadV2(params) {
-  const { signer, from, to, amount, nonce, expiry, chainId, assetId, extensions, domainName, domainVersion } = params;
-  const chainIdNum = parseInt(chainId.split(":")[1], 10);
-  const contractAddress = assetId.split(":")[2];
-  const authParams = {
-    from,
-    to: typeof to === "string" ? to : "0x0000000000000000000000000000000000000000",
-    value: BigInt(Math.floor(parseFloat(amount) * 1e6)),
-    validAfter: 0n,
-    validBefore: BigInt(expiry),
-    nonce: BigInt(nonce)
+async function createX402V2Payment(signer, requirements, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  const contractAddress = requirements.asset;
+  const chainId = extractChainId(requirements.network);
+  const domain = createEIP712Domain2(chainId, contractAddress);
+  const customDomain = domainName || domainVersion ? { ...domain, name: domainName ?? domain.name, version: domainVersion ?? domain.version } : domain;
+  const authorization = {
+    from: fromAddress,
+    to: requirements.payTo,
+    value: toAtomicUnits(requirements.amount),
+    validAfter: "0",
+    validBefore: validBefore.toString(),
+    nonce
   };
-  const domain = {
-    name: domainName ?? "USD Coin",
-    version: domainVersion ?? "2",
-    chainId: chainIdNum,
-    verifyingContract: contractAddress
+  const authParams = {
+    from: authorization.from,
+    to: authorization.to,
+    value: BigInt(authorization.value),
+    validAfter: BigInt(authorization.validAfter),
+    validBefore: BigInt(authorization.validBefore),
+    nonce: BigInt(authorization.nonce)
   };
-  const signature = await signEIP3009(signer, authParams, domain);
+  const signature = await signEIP3009(signer, authParams, customDomain);
+  const combinedSignature = `0x${signature.r.slice(2)}${signature.s.slice(2)}${signature.v.toString(16).padStart(2, "0")}`;
   const payload = {
-    from,
-    to,
-    amount,
-    nonce,
-    expiry,
-    signature: {
-      v: signature.v,
-      r: signature.r,
-      s: signature.s
-    },
-    chainId,
-    assetId,
-    extensions
+    signature: combinedSignature,
+    authorization
+  };
+  return {
+    x402Version: 2,
+    scheme: requirements.scheme,
+    network: requirements.network,
+    payload
   };
-  return encodePaymentV2(payload);
-}
-function detectProtocolVersion(requirements) {
-  if ("contractAddress" in requirements && "network" in requirements) {
-    return 1;
-  }
-  return 2;
 }
-async function createPaymentPayload(requirements, signer, from) {
-  const version = detectProtocolVersion(requirements);
-  const now = Math.floor(Date.now() / 1e3);
-  const nonce = now.toString();
-  const expiry = now + 3600;
-  if (version === 1) {
-    const req2 = requirements;
-    const networkConfig = getNetworkByChainId(
-      parseInt(req2.contractAddress.slice(0, 10), 16)
-    );
-    const payload2 = await createPaymentPayloadV1({
+async function createX402Payment(signer, parsed, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  const effectiveNonce = nonce ?? createNonce();
+  const effectiveValidBefore = validBefore ?? Math.floor(Date.now() / 1e3) + 3600;
+  if (parsed.version === 1) {
+    return createX402V1Payment(
       signer,
-      from,
-      to: req2.payTo,
-      amount: req2.amount,
-      nonce,
-      expiry,
-      chainId: networkConfig?.chainId || 1,
-      contractAddress: req2.contractAddress,
-      network: req2.network
-    });
-    return [payload2, V1_HEADERS.PAYMENT];
+      parsed.requirements,
+      fromAddress,
+      effectiveNonce,
+      effectiveValidBefore,
+      domainName,
+      domainVersion
+    );
   }
-  const req = requirements;
-  const payload = await createPaymentPayloadV2({
+  return createX402V2Payment(
     signer,
-    from,
-    to: req.to,
-    amount: req.amount,
-    nonce,
-    expiry,
-    chainId: req.chainId,
-    assetId: req.assetId
-  });
-  return [payload, V2_HEADERS.PAYMENT_SIGNATURE];
+    parsed.requirements,
+    fromAddress,
+    effectiveNonce,
+    effectiveValidBefore,
+    domainName,
+    domainVersion
+  );
+}
+function encodeX402Payment(payload) {
+  return Buffer.from(JSON.stringify(payload)).toString("base64");
+}
+function getPaymentHeaderName(version) {
+  return version === 1 ? V1_HEADERS.PAYMENT : V2_HEADERS.PAYMENT_SIGNATURE;
+}
+async function createPaymentPayload(requirements, signer, from) {
+  const parsed = isX402V1Requirements(requirements) ? { version: 1, requirements } : { version: 2, requirements };
+  const payload = await createX402Payment(signer, parsed, from);
+  const encoded = encodeX402Payment(payload);
+  return [encoded, getPaymentHeaderName(parsed.version)];
 }
 async function parsePaymentRequirements(response) {
-  const v2Header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
-  if (v2Header) {
-    return JSON.parse(v2Header);
-  }
-  try {
-    return await response.json();
-  } catch {
-    throw new Error("No payment requirements found in response");
+  const parsed = parsePaymentRequired(response);
+  return parsed.requirements;
+}
+function detectProtocolVersion(requirements) {
+  if (typeof requirements === "object" && requirements !== null) {
+    if ("x402Version" in requirements && requirements.x402Version === 2) {
+      return 2;
+    }
+    if ("chainId" in requirements && "assetId" in requirements && !("contractAddress" in requirements)) {
+      return 2;
+    }
   }
+  return 1;
 }
 
 // src/transport.ts
@@ -274,26 +430,29 @@ var handlePaymentRequired = async (state, response) => {
     throw new SignerRequiredError("Cannot handle payment: no signer configured.");
   }
   try {
-    const requirements = await parsePaymentRequirements(response);
+    const parsed = parsePaymentRequired(response);
     const from = await state.signer.getAddress();
-    const [payload, headerName] = await createPaymentPayload(requirements, state.signer, from);
+    const payload = await createX402Payment(state.signer, parsed, from);
+    const encoded = encodeX402Payment(payload);
+    const headerName = getPaymentHeaderName(parsed.version);
     const paymentResponse = await fetchWithTimeout(
       response.url,
       {
         method: "GET",
-        headers: { ...state.config.headers, [headerName]: payload }
+        headers: { ...state.config.headers, [headerName]: encoded }
       },
       state.config.timeout
     );
-    return { success: true, settlement: decodeSettlementLegacy(paymentResponse.headers) };
+    const settlement = decodeSettlementLegacy(paymentResponse.headers);
+    return { success: true, settlement };
   } catch (error) {
     return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
   }
 };
 var shouldRetryPayment = async (state, response) => {
   if (!state.config.autoPay) return false;
-  const requirements = await parsePaymentRequirements(response);
-  return await state.config.onPaymentRequired(requirements);
+  const parsed = parsePaymentRequired(response);
+  return await state.config.onPaymentRequired(parsed.requirements);
 };
 var x402Fetch = async (state, url, init = {}) => {
   const fullUrl = state.config.baseURL ? new URL(url, state.config.baseURL).toString() : url;
@@ -344,18 +503,58 @@ var createX402Transport = (config) => {
     getSigner: () => state.signer
   };
 };
+
+// src/client.ts
+function createX402Client(config) {
+  const transport = createX402Transport(void 0);
+  if ("signer" in config && config.signer) {
+    transport.setSigner(config.signer);
+  } else if ("provider" in config && config.provider) {
+    const provider = config.provider;
+    if (provider.getSigner) {
+      try {
+        const signer = provider.getSigner();
+        if (signer) {
+          transport.setSigner(signer);
+        }
+      } catch {
+      }
+    }
+  } else {
+    throw new SignerRequiredError(
+      "Either 'signer' or 'provider' with getSigner() must be provided"
+    );
+  }
+  return {
+    get: (url, init) => transport.get(url, init),
+    post: (url, body, init) => transport.post(url, body, init),
+    put: (url, body, init) => transport.put(url, body, init),
+    del: (url, init) => transport.del(url, init),
+    patch: (url, body, init) => transport.patch(url, body, init),
+    setSigner: (signer) => transport.setSigner(signer),
+    getSigner: () => transport.getSigner()
+  };
+}
 export {
-  EIP712_TYPES,
+  AuthorizationError,
+  EIP712_TYPES2 as EIP712_TYPES,
   ERC20_ABI,
   NETWORKS,
-  V1_HEADERS2 as V1_HEADERS,
-  V2_HEADERS2 as V2_HEADERS,
-  createEIP712Domain2 as createEIP712Domain,
+  PaymentError,
+  ProviderRequiredError,
+  SignerRequiredError,
+  SigningError,
+  V1_HEADERS3 as V1_HEADERS,
+  V2_HEADERS3 as V2_HEADERS,
+  X402ClientError,
+  createEIP712Domain3 as createEIP712Domain,
   createPaymentPayload,
-  createPaymentPayloadV1,
-  createPaymentPayloadV2,
-  createTransferWithAuthorization,
+  createTransferWithAuthorization2 as createTransferWithAuthorization,
+  createX402Client,
+  createX402Payment,
   createX402Transport,
+  createX402V1Payment,
+  createX402V2Payment,
   decodePayment,
   decodePaymentV1,
   decodePaymentV2,
@@ -364,14 +563,17 @@ export {
   decodeSettlementV2,
   detectPaymentVersion,
   detectProtocolVersion,
-  encodePaymentV12 as encodePaymentV1,
-  encodePaymentV22 as encodePaymentV2,
+  detectX402Version,
+  encodePaymentV1,
+  encodePaymentV2,
   encodeSettlementV1,
   encodeSettlementV2,
+  encodeX402Payment,
   getMainnets,
   getNetworkByChainId2 as getNetworkByChainId,
-  getNetworkConfig,
+  getNetworkConfig2 as getNetworkConfig,
   getPaymentHeaderName,
+  getPaymentHeaderName2 as getPaymentHeaderNameBase,
   getPaymentRequiredHeaderName,
   getPaymentResponseHeaderName,
   getPaymentVersion,
@@ -379,16 +581,24 @@ export {
   getSettlementVersion,
   getTestnets,
   getTxHash,
-  isAddress,
   isCAIP2ChainId,
   isCAIPAssetId,
   isPaymentV1,
   isPaymentV2,
-  isSettlementSuccessful,
+  isSettlementSuccessful2 as isSettlementSuccessful,
   isSettlementV1,
   isSettlementV2,
   isV1,
   isV2,
+  isX402V1PaymentRequired2 as isX402V1PaymentRequired,
+  isX402V1Requirements2 as isX402V1Requirements,
+  isX402V2PaymentRequired2 as isX402V2PaymentRequired,
+  parsePaymentRequired,
   parsePaymentRequirements,
+  recoverEIP3009Signer,
+  safeBase64Decode2 as safeBase64Decode,
+  signEIP3009,
+  signEIP3009WithDomain,
+  signPayment,
   validateTransferWithAuthorization
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-ethers",
-  "version": "0.2.9",
+  "version": "0.2.13",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,7 +27,7 @@
     "directory": "packages/client-ethers"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.9",
+    "@armory-sh/base": "^0.2.13",
     "ethers": "6.16.0"
   },
   "devDependencies": {
@@ -35,7 +35,7 @@
     "bun-types": "latest"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "rm -rf dist && tsup",
     "test": "bun test",
     "example": "bun run examples/"
   }