@armory-sh/client-viem 0.2.4 → 0.2.12

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 import { Address, Account, WalletClient, Transport } from 'viem';
-import { CustomToken, PaymentPayloadV1, PaymentPayloadV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
-export { ArmoryPaymentResult, FacilitatorConfig, NetworkId, TokenId } from '@armory-sh/base';
+import { CustomToken, X402PaymentPayloadV1, PaymentPayloadV2, X402PaymentRequirementsV1, PaymentRequirementsV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
+export { ArmoryPaymentResult, EIP3009Authorization, EIP3009AuthorizationV1, FacilitatorConfig, NetworkId, PaymentPayloadV2, PaymentRequiredV2, PaymentRequirementsV2, ResourceInfo, SchemePayloadV2, SettlementResponseV2, TokenId, V1_HEADERS, V2_HEADERS, X402PaymentPayloadV1, X402PaymentRequiredV1, X402PaymentRequirementsV1, X402SchemePayloadV1, X402SettlementResponseV1 } from '@armory-sh/base';
 
-type X402Wallet = {
+/**
+ * X402 Client Types - V1 and V2 Compatible
+ */
+
+type X402Wallet$1 = {
     type: "account";
     account: Account;
 } | {
@@ -13,7 +17,7 @@ type X402ProtocolVersion = 1 | 2 | "auto";
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
 type Token = CustomToken;
 interface X402ClientConfig {
-    wallet: X402Wallet;
+    wallet: X402Wallet$1;
     version?: X402ProtocolVersion;
     defaultExpiry?: number;
     nonceGenerator?: () => string;
@@ -28,11 +32,11 @@ interface X402ClientConfig {
 interface X402Client {
     fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     getAddress(): Address;
-    createPayment(amount: string, to: Address, contractAddress: Address, chainId: number, expiry?: number): Promise<PaymentPayloadV1 | PaymentPayloadV2>;
-    signPayment<T extends PaymentPayloadV1 | PaymentPayloadV2>(payload: Omit<T, "signature" | "v" | "r" | "s">): Promise<T>;
+    createPayment(amount: string, to: Address, contractAddress: Address, chainId: number, expiry?: number): Promise<X402PaymentPayloadV1 | PaymentPayloadV2>;
+    signPayment(payload: Omit<X402PaymentPayloadV1 | PaymentPayloadV2, "signature" | "v" | "r" | "s">): Promise<X402PaymentPayloadV1 | PaymentPayloadV2>;
 }
 interface X402TransportConfig {
-    wallet: X402Wallet;
+    wallet: X402Wallet$1;
     transport?: Transport;
     version?: X402ProtocolVersion;
     defaultExpiry?: number;
@@ -52,8 +56,16 @@ interface PaymentResult {
     timestamp: number;
 }
 
+/**
+ * X402 Client for Viem - Full V1 and V2 Support
+ *
+ * Handles x402 V1 (Base64 encoded) and V2 (JSON) protocols.
+ * Uses protocol.ts for parsing and creating payment payloads.
+ */
+
+declare const createFetch: (wallet: X402Wallet$1, config: Omit<X402ClientConfig, "wallet">) => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 declare const createX402Client: (config: X402ClientConfig) => X402Client;
-declare const createX402Transport: (config: X402TransportConfig) => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+declare const createX402Transport: (config: X402TransportConfig) => ReturnType<typeof createFetch>;
 
 declare class X402ClientError extends Error {
     readonly cause?: unknown;
@@ -66,6 +78,54 @@ declare class PaymentError extends X402ClientError {
     constructor(message: string, cause?: unknown);
 }
 
+/**
+ * X402 Protocol Implementation for Viem Client
+ *
+ * Handles parsing x402 V1 and V2 PAYMENT-REQUIRED headers
+ * and generating x402 V1 and V2 PAYMENT-SIGNATURE payloads
+ */
+
+type X402Wallet = {
+    type: "account";
+    account: Account;
+} | {
+    type: "walletClient";
+    walletClient: WalletClient;
+};
+/**
+ * Detect x402 protocol version from response headers
+ */
+declare function detectX402Version(response: Response): 1 | 2;
+/**
+ * Parse x402 PAYMENT-REQUIRED header from response
+ * Automatically detects V1 or V2 format
+ */
+interface ParsedPaymentRequirements {
+    version: 1 | 2;
+    requirements: X402PaymentRequirementsV1 | PaymentRequirementsV2;
+}
+declare function parsePaymentRequired(response: Response): ParsedPaymentRequirements;
+/**
+ * Create x402 V1 payment payload
+ */
+declare function createX402V1Payment(wallet: X402Wallet, requirements: X402PaymentRequirementsV1, fromAddress: Address, nonce: `0x${string}`, validBefore: number, domainName?: string, domainVersion?: string): Promise<X402PaymentPayloadV1>;
+/**
+ * Create x402 V2 payment payload
+ */
+declare function createX402V2Payment(wallet: X402Wallet, 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(wallet: X402Wallet, 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;
+
 /**
  * Simple one-line payment API for Armory
  * Focus on DX/UX - "everything just magically works"
@@ -149,4 +209,4 @@ declare const getNetworks: () => string[];
  */
 declare const getTokens: () => string[];
 
-export { PaymentError, type PaymentResult, SigningError, type SimpleWallet, type Token, type X402Client, type X402ClientConfig, X402ClientError, type X402ProtocolVersion, type X402TransportConfig, type X402Wallet, armoryGet, armoryPay, armoryPost, createX402Client, createX402Transport, getNetworks, getTokens, getWalletAddress, validateNetwork, validateToken };
+export { type ParsedPaymentRequirements, PaymentError, type PaymentResult, type X402Wallet as ProtocolWallet, SigningError, type SimpleWallet, type Token, type X402Client, type X402ClientConfig, X402ClientError, type X402ProtocolVersion, type X402TransportConfig, type X402Wallet$1 as X402Wallet, armoryGet, armoryPay, armoryPost, createX402Client, createX402Payment, createX402Transport, createX402V1Payment, createX402V2Payment, detectX402Version, encodeX402Payment, getNetworks, getPaymentHeaderName, getTokens, getWalletAddress, parsePaymentRequired, validateNetwork, validateToken };

package/dist/index.js

@@ -1,12 +1,13 @@
 // src/client.ts
 import {
-  encodePaymentV1,
-  encodePaymentV2,
-  V1_HEADERS,
-  V2_HEADERS,
-  createEIP712Domain,
-  createTransferWithAuthorization,
-  EIP712_TYPES
+  V1_HEADERS as V1_HEADERS2,
+  V2_HEADERS as V2_HEADERS2,
+  decodeSettlementV1,
+  decodeSettlementV2,
+  isX402V1Settlement,
+  isX402V2Settlement,
+  getNetworkByChainId as getNetworkByChainId2,
+  normalizeNetworkName as normalizeNetworkName2
 } from "@armory-sh/base";
 
 // src/errors.ts
@@ -31,19 +32,91 @@ var PaymentError = class extends X402ClientError {
   }
 };
 
-// src/client.ts
-var DEFAULT_EXPIRY = 3600;
-var DEFAULT_NONCE = () => `${Date.now()}`;
-var parseSignature = (signature) => {
-  const sig = signature.slice(2);
-  return {
-    v: parseInt(sig.slice(128, 130), 16) + 27,
-    r: `0x${sig.slice(0, 64)}`,
-    s: `0x${sig.slice(64, 128)}`
-  };
-};
-var getWalletAddress = (wallet) => wallet.type === "account" ? wallet.account.address : wallet.walletClient.account.address;
-var signTypedData = (wallet, domain, types, message) => {
+// src/protocol.ts
+import {
+  V1_HEADERS,
+  V2_HEADERS,
+  safeBase64Decode,
+  isX402V1PaymentRequired,
+  isX402V2PaymentRequired,
+  getNetworkByChainId,
+  getNetworkConfig,
+  createEIP712Domain,
+  createTransferWithAuthorization,
+  EIP712_TYPES,
+  normalizeNetworkName
+} from "@armory-sh/base";
+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 getWalletAddress(wallet) {
+  return wallet.type === "account" ? wallet.account.address : wallet.walletClient.account.address;
+}
+async function signTypedData(wallet, domain, types, message) {
   if (wallet.type === "account" && !wallet.account.signTypedData) {
     throw new SigningError("Account does not support signTypedData");
   }
@@ -53,151 +126,183 @@ var signTypedData = (wallet, domain, types, message) => {
     primaryType: "TransferWithAuthorization",
     message
   };
-  return wallet.type === "account" ? wallet.account.signTypedData(params) : wallet.walletClient.signTypedData({ ...params, account: wallet.walletClient.account });
-};
-var withCustomDomain = (domain, domainName, domainVersion) => domainName || domainVersion ? { ...domain, name: domainName ?? domain.name, version: domainVersion ?? domain.version } : domain;
-var toNetworkName = (chainId) => chainId === 1 ? "ethereum" : chainId === 8453 ? "base" : "evm";
-var createPaymentV1 = async (wallet, from, to, amount, chainId, contractAddress, nonce, expiry, domainName, domainVersion) => {
-  const domain = createEIP712Domain(chainId, contractAddress);
-  const value = createTransferWithAuthorization({
-    from,
-    to,
-    value: BigInt(Math.floor(parseFloat(amount) * 1e6)),
-    validAfter: 0n,
-    validBefore: BigInt(expiry),
-    nonce: BigInt(nonce)
-  });
-  const signature = await signTypedData(wallet, withCustomDomain(domain, domainName, domainVersion), EIP712_TYPES, value);
-  const { v, r, s } = parseSignature(signature);
-  return { from, to, amount, nonce, expiry, v, r, s, chainId, contractAddress, network: toNetworkName(chainId) };
-};
-var createPaymentV2 = async (wallet, from, to, amount, chainId, assetId, nonce, expiry, domainName, domainVersion) => {
-  const contractAddress = assetId.split(":")[2];
-  const domain = createEIP712Domain(chainId, contractAddress);
-  const value = createTransferWithAuthorization({
-    from,
-    to,
-    value: BigInt(Math.floor(parseFloat(amount) * 1e6)),
-    validAfter: 0n,
-    validBefore: BigInt(expiry),
-    nonce: BigInt(nonce)
+  if (wallet.type === "account") {
+    return wallet.account.signTypedData(params);
+  }
+  return wallet.walletClient.signTypedData({
+    ...params,
+    account: wallet.walletClient.account
   });
-  const signature = await signTypedData(wallet, withCustomDomain(domain, domainName, domainVersion), EIP712_TYPES, value);
-  const { v, r, s } = parseSignature(signature);
+}
+function parseSignature(signature) {
+  const sig = signature.slice(2);
   return {
-    from,
-    to,
-    amount,
-    nonce,
-    expiry,
-    signature: { v, r, s },
-    chainId: `eip155:${chainId}`,
-    assetId
+    v: parseInt(sig.slice(128, 130), 16) + 27,
+    r: `0x${sig.slice(0, 64)}`,
+    s: `0x${sig.slice(64, 128)}`
   };
-};
-var detectVersion = (response, version) => {
-  if (version === 1) return 1;
-  if (version === 2) return 2;
-  const headers = response.headers;
-  if (headers.has(V1_HEADERS.PAYMENT_RESPONSE) || headers.has("X-PAYMENT-REQUIRED")) {
-    return 1;
+}
+function toAtomicUnits(amount) {
+  return Math.floor(parseFloat(amount) * 1e6).toString();
+}
+function extractChainId(network) {
+  if (network.startsWith("eip155:")) {
+    return parseInt(network.split(":")[1], 10);
   }
-  return 2;
-};
-var parseRequirements = (response, version) => {
-  if (version === 1) {
-    const text = response.headers.get("X-PAYMENT-REQUIRED");
-    if (text) {
-      try {
-        const json = atob(text);
-        return JSON.parse(json);
-      } catch {
-        throw new PaymentError("Failed to decode v1 payment requirements");
-      }
-    }
-    return {
-      amount: "1.0",
-      network: "base",
-      contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      payTo: "0x0000000000000000000000000000000000000000",
-      expiry: Math.floor(Date.now() / 1e3) + 3600
-    };
+  const net = getNetworkConfig(normalizeNetworkName(network));
+  if (net) {
+    return net.chainId;
   }
-  const v2Text = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
-  if (v2Text) {
-    try {
-      return JSON.parse(v2Text);
-    } catch {
-      throw new PaymentError("Failed to decode v2 payment requirements");
+  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);
+}
+async function createX402V1Payment(wallet, requirements, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  const network = getNetworkSlug(requirements.network);
+  const contractAddress = requirements.asset;
+  const domain = createEIP712Domain(extractChainId(requirements.network), 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 value = createTransferWithAuthorization({
+    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 signTypedData(wallet, customDomain, EIP712_TYPES, value);
+  const { v, r, s } = parseSignature(signature);
+  const payload = {
+    signature: `0x${r.slice(2)}${s.slice(2)}${v.toString(16).padStart(2, "0")}`,
+    authorization
+  };
   return {
-    amount: "1.0",
-    to: "0x0000000000000000000000000000000000000000",
-    chainId: "eip155:8453",
-    assetId: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    nonce: `${Date.now()}`,
-    expiry: Math.floor(Date.now() / 1e3) + 3600
+    x402Version: 1,
+    scheme: "exact",
+    network,
+    payload
   };
-};
-var createPaymentFromRequirements = async (wallet, requirements, version, getAddress, nonceGenerator, domainName, domainVersion) => {
-  const from = getAddress();
-  const nonce = nonceGenerator();
-  const expiry = requirements.expiry;
-  if (version === 1) {
-    const req2 = requirements;
-    return createPaymentV1(
+}
+async function createX402V2Payment(wallet, requirements, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  const contractAddress = requirements.asset;
+  const network = requirements.network;
+  const domain = createEIP712Domain(extractChainId(network), 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 value = createTransferWithAuthorization({
+    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 signTypedData(wallet, customDomain, EIP712_TYPES, value);
+  const { v, r, s } = parseSignature(signature);
+  const payload = {
+    signature: `0x${r.slice(2)}${s.slice(2)}${v.toString(16).padStart(2, "0")}`,
+    authorization
+  };
+  return {
+    x402Version: 2,
+    accepted: requirements,
+    payload
+  };
+}
+async function createX402Payment(wallet, parsed, fromAddress, nonce, validBefore, domainName, domainVersion) {
+  if (parsed.version === 1) {
+    return createX402V1Payment(
       wallet,
-      from,
-      req2.payTo,
-      req2.amount,
-      req2.network === "base" ? 8453 : 1,
-      req2.contractAddress,
+      parsed.requirements,
+      fromAddress,
       nonce,
-      expiry,
+      validBefore,
       domainName,
       domainVersion
     );
   }
-  const req = requirements;
-  const chainId = parseInt(req.chainId.split(":")[1], 10);
-  const to = typeof req.to === "string" ? req.to : "0x0000000000000000000000000000000000000000";
-  return createPaymentV2(wallet, from, to, req.amount, chainId, req.assetId, nonce, expiry, domainName, domainVersion);
-};
-var addPaymentHeader = (headers, payment, version) => {
-  if (version === 1) {
-    headers.set(V1_HEADERS.PAYMENT, encodePaymentV1(payment));
-  } else {
-    headers.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV2(payment));
-  }
+  return createX402V2Payment(
+    wallet,
+    parsed.requirements,
+    fromAddress,
+    nonce,
+    validBefore,
+    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;
+}
+
+// src/client.ts
+var DEFAULT_EXPIRY = 3600;
+var toProtocolWallet = (wallet) => wallet.type === "account" ? { type: "account", account: wallet.account } : { type: "walletClient", walletClient: wallet.walletClient };
+var generateNonce = (nonceGenerator) => {
+  const nonce = nonceGenerator?.() ?? Date.now().toString();
+  return nonce.startsWith("0x") ? nonce : `0x${nonce.padStart(64, "0")}`;
 };
 var checkSettlement = (response, version) => {
-  const v1Header = response.headers.get(V1_HEADERS.PAYMENT_RESPONSE);
-  const v2Header = response.headers.get(V2_HEADERS.PAYMENT_RESPONSE);
-  let settlement = null;
+  const v1Header = response.headers.get(V1_HEADERS2.PAYMENT_RESPONSE);
+  const v2Header = response.headers.get(V2_HEADERS2.PAYMENT_RESPONSE);
   if (version === 1 && v1Header) {
     try {
-      const json = atob(v1Header);
-      settlement = JSON.parse(json);
-    } catch {
+      const settlement = decodeSettlementV1(v1Header);
+      if (isX402V1Settlement(settlement) && !settlement.success) {
+        throw new PaymentError(settlement.errorReason ?? "Payment settlement failed");
+      }
+    } catch (error) {
+      if (error instanceof PaymentError) throw error;
     }
   } else if (version === 2 && v2Header) {
     try {
-      settlement = JSON.parse(v2Header);
-    } catch {
+      const settlement = decodeSettlementV2(v2Header);
+      if (isX402V2Settlement(settlement) && !settlement.success) {
+        throw new PaymentError(settlement.errorReason ?? "Payment settlement failed");
+      }
+    } catch (error) {
+      if (error instanceof PaymentError) throw error;
     }
   }
-  if (settlement) {
-    const success = "success" in settlement ? settlement.success : settlement.status === "success";
-    if (!success) {
-      const error = "error" in settlement ? settlement.error : "Payment settlement failed";
-      throw new PaymentError(error);
-    }
+};
+var addPaymentHeader = (headers, payment, version) => {
+  if (version === 1) {
+    headers.set(V1_HEADERS2.PAYMENT, encodeX402Payment(payment));
+  } else {
+    headers.set(V2_HEADERS2.PAYMENT_SIGNATURE, JSON.stringify(payment));
   }
 };
 var createFetch = (wallet, config) => {
-  const { version = "auto", nonceGenerator = DEFAULT_NONCE, debug = false, domainName, domainVersion } = config;
-  const getAddress = () => getWalletAddress(wallet);
+  const { version = "auto", nonceGenerator, debug = false, domainName, domainVersion } = config;
+  const protocolWallet = toProtocolWallet(wallet);
+  const getAddress = () => getWalletAddress(protocolWallet);
   return async (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     if (debug) {
@@ -208,89 +313,148 @@ var createFetch = (wallet, config) => {
       if (debug) {
         console.log(`[X402] Payment required for: ${url}`);
       }
-      const detectedVersion = detectVersion(response, version);
+      let detectedVersion;
+      if (version === "auto") {
+        detectedVersion = detectX402Version(response);
+      } else {
+        detectedVersion = version;
+      }
       if (debug) {
         console.log(`[X402] Detected protocol v${detectedVersion}`);
       }
-      const requirements = parseRequirements(response, detectedVersion);
+      const parsed = parsePaymentRequired(response);
       if (debug) {
-        console.log(`[X402] Payment requirements:`, requirements);
+        console.log(`[X402] Payment requirements:`, parsed.requirements);
       }
-      const payment = await createPaymentFromRequirements(wallet, requirements, detectedVersion, getAddress, nonceGenerator, domainName, domainVersion);
+      const fromAddress = getAddress();
+      const nonce = generateNonce(nonceGenerator);
+      const validBefore = Math.floor(Date.now() / 1e3) + (config.defaultExpiry ?? DEFAULT_EXPIRY);
+      const payment = await createX402Payment(
+        protocolWallet,
+        parsed,
+        fromAddress,
+        nonce,
+        validBefore,
+        domainName,
+        domainVersion
+      );
       if (debug) {
-        console.log(`[X402] Created payment:`, payment);
+        console.log(`[X402] Created payment payload`);
       }
       const headers = new Headers(init?.headers);
-      addPaymentHeader(headers, payment, detectedVersion);
+      addPaymentHeader(headers, payment, parsed.version);
       response = await fetch(input, { ...init, headers });
       if (debug) {
         console.log(`[X402] Payment response status: ${response.status}`);
       }
-      checkSettlement(response, detectedVersion);
+      checkSettlement(response, parsed.version);
     }
     return response;
   };
 };
 var extractDomainConfig = (config) => config.token ? { domainName: config.token.name, domainVersion: config.token.version } : { domainName: config.domainName, domainVersion: config.domainVersion };
 var createX402Client = (config) => {
-  const { wallet, version = "auto", defaultExpiry = DEFAULT_EXPIRY, nonceGenerator = DEFAULT_NONCE } = config;
+  const { wallet, version = "auto", defaultExpiry = DEFAULT_EXPIRY, nonceGenerator } = config;
   const { domainName, domainVersion } = extractDomainConfig(config);
-  const getAddress = () => getWalletAddress(wallet);
-  const fetchFn = createFetch(wallet, { version, defaultExpiry, nonceGenerator, debug: config.debug, domainName, domainVersion });
+  const protocolWallet = toProtocolWallet(wallet);
+  const getAddress = () => getWalletAddress(protocolWallet);
+  const fetchFn = createFetch(wallet, {
+    version,
+    defaultExpiry,
+    nonceGenerator,
+    debug: config.debug,
+    domainName,
+    domainVersion
+  });
   return {
     fetch: fetchFn,
     getAddress,
     async createPayment(amount, to, contractAddress, chainId, expiry) {
       const from = getAddress();
-      const nonce = nonceGenerator();
-      const validExpiry = expiry ?? Math.floor(Date.now() / 1e3) + defaultExpiry;
+      const nonce = generateNonce(nonceGenerator);
+      const validBefore = expiry ?? Math.floor(Date.now() / 1e3) + defaultExpiry;
       const targetVersion = version === "auto" ? 1 : version;
+      const networkConfig = getNetworkByChainId2(chainId);
+      const networkSlug = networkConfig ? normalizeNetworkName2(networkConfig.name) : `eip155:${chainId}`;
       if (targetVersion === 1) {
-        return createPaymentV1(wallet, from, to, amount, chainId, contractAddress, nonce, validExpiry, domainName, domainVersion);
+        const requirements2 = {
+          scheme: "exact",
+          network: networkSlug,
+          maxAmountRequired: amount,
+          asset: contractAddress,
+          payTo: to,
+          resource: "",
+          description: "",
+          maxTimeoutSeconds: defaultExpiry
+        };
+        const parsed2 = { version: 1, requirements: requirements2 };
+        return createX402Payment(protocolWallet, parsed2, from, nonce, validBefore, domainName, domainVersion);
       }
-      const assetId = `eip155:${chainId}/erc20:${contractAddress}`;
-      return createPaymentV2(wallet, from, to, amount, chainId, assetId, nonce, validExpiry, domainName, domainVersion);
+      const requirements = {
+        scheme: "exact",
+        network: `eip155:${chainId}`,
+        amount,
+        asset: contractAddress,
+        payTo: to,
+        maxTimeoutSeconds: defaultExpiry
+      };
+      const parsed = { version: 2, requirements };
+      return createX402Payment(protocolWallet, parsed, from, nonce, validBefore, domainName, domainVersion);
     },
     async signPayment(payload) {
       const from = getAddress();
-      const chainId = typeof payload.chainId === "number" ? payload.chainId : parseInt(payload.chainId.split(":")[1], 10);
-      const to = payload.to;
-      const expiry = payload.expiry;
-      const nonce = nonceGenerator();
-      if ("contractAddress" in payload) {
-        const input2 = payload;
-        return createPaymentV1(
-          wallet,
-          from,
-          to,
-          input2.amount,
-          chainId,
-          input2.contractAddress,
-          nonce,
-          expiry,
-          domainName,
-          domainVersion
+      const nonce = generateNonce(nonceGenerator);
+      const hasContractAddress = (p) => typeof p === "object" && p !== null && "contractAddress" in p;
+      if (hasContractAddress(payload)) {
+        const networkConfig = getNetworkByChainId2(
+          "chainId" in payload && typeof payload.chainId === "number" ? payload.chainId : 84532
         );
+        const networkSlug = networkConfig ? normalizeNetworkName2(networkConfig.name) : "base";
+        const to2 = "to" in payload && typeof payload.to === "string" ? payload.to : "0x0000000000000000000000000000000000000000";
+        const requirements2 = {
+          scheme: "exact",
+          network: networkSlug,
+          maxAmountRequired: payload.amount,
+          asset: payload.contractAddress,
+          payTo: to2,
+          resource: "",
+          description: "",
+          maxTimeoutSeconds: defaultExpiry
+        };
+        const parsed2 = { version: 1, requirements: requirements2 };
+        const validBefore2 = payload.expiry ?? Math.floor(Date.now() / 1e3) + defaultExpiry;
+        return createX402Payment(protocolWallet, parsed2, from, nonce, validBefore2, domainName, domainVersion);
       }
-      const input = payload;
-      return createPaymentV2(
-        wallet,
-        from,
-        to,
-        input.amount,
-        chainId,
-        input.assetId,
-        nonce,
-        expiry,
-        domainName,
-        domainVersion
-      );
+      const to = "payTo" in payload && typeof payload.payTo === "string" ? payload.payTo : "0x0000000000000000000000000000000000000000";
+      const amount = "amount" in payload && typeof payload.amount === "string" ? payload.amount : "1000000";
+      const network = "network" in payload && typeof payload.network === "string" ? payload.network : "eip155:8453";
+      const chainId = parseInt(network.split(":")[1], 10);
+      const defaultAsset = getNetworkByChainId2(chainId)?.usdcAddress ?? "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+      const asset = "asset" in payload && typeof payload.asset === "string" ? payload.asset : defaultAsset;
+      const requirements = {
+        scheme: "exact",
+        network,
+        amount,
+        asset,
+        payTo: to,
+        maxTimeoutSeconds: defaultExpiry
+      };
+      const parsed = { version: 2, requirements };
+      const validBefore = "expiry" in payload && typeof payload.expiry === "number" ? payload.expiry : Math.floor(Date.now() / 1e3) + defaultExpiry;
+      return createX402Payment(protocolWallet, parsed, from, nonce, validBefore, domainName, domainVersion);
     }
   };
 };
 var createX402Transport = (config) => {
-  const { wallet, transport, version, defaultExpiry, nonceGenerator, debug, token, domainName, domainVersion } = config;
-  return createFetch(wallet, { version, defaultExpiry, nonceGenerator, debug, token, domainName, domainVersion });
+  const { wallet, version, defaultExpiry, nonceGenerator, debug, token, domainName, domainVersion } = config;
+  return createFetch(wallet, {
+    version,
+    defaultExpiry,
+    nonceGenerator,
+    debug,
+    domainName: domainName ?? token?.name,
+    domainVersion: domainVersion ?? token?.version
+  });
 };
 
 // src/simple.ts
@@ -404,18 +568,30 @@ var getNetworks = () => {
 var getTokens = () => {
   return getAvailableTokens();
 };
+
+// src/index.ts
+import { V1_HEADERS as V1_HEADERS3, V2_HEADERS as V2_HEADERS3 } from "@armory-sh/base";
 export {
   PaymentError,
   SigningError,
+  V1_HEADERS3 as V1_HEADERS,
+  V2_HEADERS3 as V2_HEADERS,
   X402ClientError,
   armoryGet,
   armoryPay,
   armoryPost,
   createX402Client,
+  createX402Payment,
   createX402Transport,
+  createX402V1Payment,
+  createX402V2Payment,
+  detectX402Version,
+  encodeX402Payment,
   getNetworks,
+  getPaymentHeaderName,
   getTokens,
   getWalletAddress2 as getWalletAddress,
+  parsePaymentRequired,
   validateNetwork,
   validateToken
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-viem",
-  "version": "0.2.4",
+  "version": "0.2.12",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,7 +27,7 @@
     "directory": "packages/client-viem"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.4",
+    "@armory-sh/base": "^0.2.12",
     "viem": "2.45.0"
   },
   "devDependencies": {