@armory-sh/client-viem 0.2.12 → 0.2.14

package/dist/index.d.ts

@@ -1,23 +1,23 @@
 import { Address, Account, WalletClient, Transport } from 'viem';
-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';
+import { CustomToken, PaymentPayloadV2, PaymentRequirementsV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
+export { ArmoryPaymentResult, EIP3009Authorization, FacilitatorConfig, NetworkId, PaymentPayloadV2, PaymentRequiredV2, PaymentRequirementsV2, ResourceInfo, SchemePayloadV2, SettlementResponseV2, TokenId, V2_HEADERS } from '@armory-sh/base';
 
 /**
- * X402 Client Types - V1 and V2 Compatible
+ * X402 Client Types - V2 Only
  */
 
-type X402Wallet$1 = {
+type X402Wallet = {
     type: "account";
     account: Account;
 } | {
     type: "walletClient";
     walletClient: WalletClient;
 };
-type X402ProtocolVersion = 1 | 2 | "auto";
+type X402ProtocolVersion = 2;
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
 type Token = CustomToken;
 interface X402ClientConfig {
-    wallet: X402Wallet$1;
+    wallet: X402Wallet;
     version?: X402ProtocolVersion;
     defaultExpiry?: number;
     nonceGenerator?: () => string;
@@ -32,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<X402PaymentPayloadV1 | PaymentPayloadV2>;
-    signPayment(payload: Omit<X402PaymentPayloadV1 | PaymentPayloadV2, "signature" | "v" | "r" | "s">): Promise<X402PaymentPayloadV1 | PaymentPayloadV2>;
+    createPayment(amount: string, to: Address, contractAddress: Address, chainId: number, expiry?: number): Promise<PaymentPayloadV2>;
+    signPayment(payload: UnsignedPaymentPayload): Promise<PaymentPayloadV2>;
 }
 interface X402TransportConfig {
-    wallet: X402Wallet$1;
+    wallet: X402Wallet;
     transport?: Transport;
     version?: X402ProtocolVersion;
     defaultExpiry?: number;
@@ -55,17 +55,23 @@ interface PaymentResult {
     error?: string;
     timestamp: number;
 }
+interface UnsignedPaymentPayload {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    amount: string;
+    nonce: string;
+    expiry: number;
+    chainId: number;
+    contractAddress: `0x${string}`;
+    network: string;
+}
 
 /**
- * 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.
+ * X402 Client for Viem - V2 Only
  */
 
-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) => ReturnType<typeof createFetch>;
+declare const createX402Transport: (config: X402TransportConfig) => ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>);
 
 declare class X402ClientError extends Error {
     readonly cause?: unknown;
@@ -79,52 +85,16 @@ declare class PaymentError extends X402ClientError {
 }
 
 /**
- * X402 Protocol Implementation for Viem Client
+ * X402 Protocol Implementation for Viem Client (V2 Only)
  *
- * Handles parsing x402 V1 and V2 PAYMENT-REQUIRED headers
- * and generating x402 V1 and V2 PAYMENT-SIGNATURE payloads
+ * Handles parsing x402 V2 PAYMENT-REQUIRED headers
+ * and generating x402 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;
-}
+type X402Version = 2;
+declare function detectX402Version(_response: Response): X402Version;
+type ParsedPaymentRequirements = 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
@@ -166,8 +136,8 @@ declare const armoryPay: <T = unknown>(wallet: SimpleWallet, url: string, networ
     body?: unknown;
     /** Request headers */
     headers?: Record<string, string>;
-    /** Protocol version (default: auto-detect) */
-    version?: 1 | 2 | "auto";
+    /** Protocol version (V2 only) */
+    version?: 2;
     /** Payment amount in token units (default: from 402 header) */
     amount?: string;
     /** Enable debug logging */
@@ -209,4 +179,4 @@ declare const getNetworks: () => string[];
  */
 declare const getTokens: () => string[];
 
-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 };
+export { type ParsedPaymentRequirements, PaymentError, type PaymentResult, SigningError, type SimpleWallet, type Token, type X402Client, type X402ClientConfig, X402ClientError, type X402ProtocolVersion, type X402TransportConfig, type X402Wallet, armoryGet, armoryPay, armoryPost, createX402Client, createX402Transport, detectX402Version, getNetworks, getTokens, getWalletAddress, parsePaymentRequired, validateNetwork, validateToken };

package/dist/index.js

@@ -1,13 +1,8 @@
 // src/client.ts
 import {
-  V1_HEADERS as V1_HEADERS2,
   V2_HEADERS as V2_HEADERS2,
-  decodeSettlementV1,
   decodeSettlementV2,
-  isX402V1Settlement,
-  isX402V2Settlement,
-  getNetworkByChainId as getNetworkByChainId2,
-  normalizeNetworkName as normalizeNetworkName2
+  getNetworkByChainId
 } from "@armory-sh/base";
 
 // src/errors.ts
@@ -34,301 +29,110 @@ var PaymentError = class extends X402ClientError {
 
 // src/protocol.ts
 import {
-  V1_HEADERS,
   V2_HEADERS,
-  safeBase64Decode,
-  isX402V1PaymentRequired,
-  isX402V2PaymentRequired,
-  getNetworkByChainId,
-  getNetworkConfig,
-  createEIP712Domain,
-  createTransferWithAuthorization,
-  EIP712_TYPES,
-  normalizeNetworkName
+  isX402V2PaymentRequired
 } 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 {
-    }
-  }
+function detectX402Version(_response) {
   return 2;
 }
+function getWalletAddress(wallet) {
+  return wallet.type === "account" ? wallet.account.address : wallet.walletClient.account.address;
+}
 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");
+  const v2Header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
+  if (!v2Header) {
+    throw new PaymentError("No PAYMENT-REQUIRED header found in V2 response");
   }
   try {
-    const decoded = safeBase64Decode(v1Header);
+    const decoded = Buffer.from(v2Header, "base64").toString("utf-8");
     const parsed = JSON.parse(decoded);
-    if (!isX402V1PaymentRequired(parsed)) {
-      throw new PaymentError("Invalid x402 V1 payment required format");
+    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: 1,
-      requirements: parsed.accepts[0]
-    };
+    return parsed;
   } 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");
+    throw new PaymentError(`Failed to parse V2 PAYMENT-REQUIRED header: ${error}`);
   }
-  const params = {
-    domain,
-    types,
-    primaryType: "TransferWithAuthorization",
-    message
-  };
-  if (wallet.type === "account") {
-    return wallet.account.signTypedData(params);
-  }
-  return wallet.walletClient.signTypedData({
-    ...params,
-    account: wallet.walletClient.account
-  });
 }
-function 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)}`
-  };
-}
-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 encodeX402Payment(payload) {
+  return Buffer.from(JSON.stringify(payload)).toString("base64");
 }
-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);
+async function createX402Payment(wallet, requirements, from, nonce = `0x${Date.now().toString(16).padStart(64, "0")}`, validBefore, _domainName, _domainVersion) {
+  const walletAccount = wallet.type === "account" ? wallet.account : wallet.walletClient.account;
+  if (!walletAccount.signTypedData) {
+    throw new SigningError("Wallet account does not support signTypedData");
   }
-  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 {
-    x402Version: 1,
-    scheme: "exact",
-    network,
-    payload
-  };
-}
-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,
+    from,
     to: requirements.payTo,
-    value: toAtomicUnits(requirements.amount),
+    value: requirements.amount,
     validAfter: "0",
-    validBefore: validBefore.toString(),
+    validBefore: (validBefore ?? Math.floor(Date.now() / 1e3 + 3600)).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
+    scheme: requirements.scheme,
+    network: requirements.network,
+    payload: {
+      signature: "0x",
+      authorization
+    }
   };
 }
-async function createX402Payment(wallet, parsed, fromAddress, nonce, validBefore, domainName, domainVersion) {
-  if (parsed.version === 1) {
-    return createX402V1Payment(
-      wallet,
-      parsed.requirements,
-      fromAddress,
-      nonce,
-      validBefore,
-      domainName,
-      domainVersion
-    );
-  }
-  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 toCaip2Id = (chainId) => `eip155:${chainId}`;
 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_HEADERS2.PAYMENT_RESPONSE);
-  const v2Header = response.headers.get(V2_HEADERS2.PAYMENT_RESPONSE);
-  if (version === 1 && v1Header) {
-    try {
-      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 {
-      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 (nonce.startsWith("0x")) {
+    return nonce;
   }
+  const numValue = parseInt(nonce, 10);
+  if (isNaN(numValue)) {
+    return `0x${nonce.padStart(64, "0")}`;
+  }
+  return `0x${numValue.toString(16).padStart(64, "0")}`;
+};
+var extractDomainConfig = (config) => config.token ? { domainName: config.token.name, domainVersion: config.token.version } : { domainName: config.domainName, domainVersion: config.domainVersion };
+var addPaymentHeader = (headers, payment) => {
+  const encoded = encodeX402Payment(payment);
+  headers.set(V2_HEADERS2.PAYMENT_SIGNATURE, encoded);
 };
-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 checkSettlement = (response) => {
+  const settlementHeader = response.headers.get(V2_HEADERS2.PAYMENT_RESPONSE);
+  if (!settlementHeader) {
+    throw new PaymentError("No PAYMENT-RESPONSE header found");
+  }
+  try {
+    return decodeSettlementV2(settlementHeader);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new PaymentError(`Failed to decode settlement: ${error.message}`);
+    }
+    throw error;
   }
 };
 var createFetch = (wallet, config) => {
-  const { version = "auto", nonceGenerator, debug = false, domainName, domainVersion } = config;
   const protocolWallet = toProtocolWallet(wallet);
   const getAddress = () => getWalletAddress(protocolWallet);
+  const { defaultExpiry, nonceGenerator, debug, domainName, domainVersion } = config;
   return async (input, init) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (debug) {
-      console.log(`[X402] Fetching: ${url}`);
-    }
     let response = await fetch(input, init);
     if (response.status === 402) {
       if (debug) {
-        console.log(`[X402] Payment required for: ${url}`);
-      }
-      let detectedVersion;
-      if (version === "auto") {
-        detectedVersion = detectX402Version(response);
-      } else {
-        detectedVersion = version;
-      }
-      if (debug) {
-        console.log(`[X402] Detected protocol v${detectedVersion}`);
+        console.log("[X402] Payment required");
       }
       const parsed = parsePaymentRequired(response);
       if (debug) {
-        console.log(`[X402] Payment requirements:`, parsed.requirements);
+        console.log("[X402] Payment requirements:", parsed);
       }
       const fromAddress = getAddress();
       const nonce = generateNonce(nonceGenerator);
-      const validBefore = Math.floor(Date.now() / 1e3) + (config.defaultExpiry ?? DEFAULT_EXPIRY);
+      const validBefore = Math.floor(Date.now() / 1e3) + defaultExpiry;
       const payment = await createX402Payment(
         protocolWallet,
         parsed,
@@ -339,22 +143,21 @@ var createFetch = (wallet, config) => {
         domainVersion
       );
       if (debug) {
-        console.log(`[X402] Created payment payload`);
+        console.log("[X402] Created payment payload");
       }
       const headers = new Headers(init?.headers);
-      addPaymentHeader(headers, payment, parsed.version);
+      addPaymentHeader(headers, payment);
       response = await fetch(input, { ...init, headers });
       if (debug) {
         console.log(`[X402] Payment response status: ${response.status}`);
       }
-      checkSettlement(response, parsed.version);
+      checkSettlement(response);
     }
     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 } = config;
+  const { wallet, version = 2, defaultExpiry = DEFAULT_EXPIRY, nonceGenerator } = config;
   const { domainName, domainVersion } = extractDomainConfig(config);
   const protocolWallet = toProtocolWallet(wallet);
   const getAddress = () => getWalletAddress(protocolWallet);
@@ -373,91 +176,51 @@ var createX402Client = (config) => {
       const from = getAddress();
       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) {
-        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 networkConfig = getNetworkByChainId(chainId);
+      const caip2Network = networkConfig?.caip2Id ?? toCaip2Id(chainId);
       const requirements = {
         scheme: "exact",
-        network: `eip155:${chainId}`,
+        network: caip2Network,
         amount,
         asset: contractAddress,
         payTo: to,
-        maxTimeoutSeconds: defaultExpiry
+        maxTimeoutSeconds: validBefore - Math.floor(Date.now() / 1e3)
       };
-      const parsed = { version: 2, requirements };
-      return createX402Payment(protocolWallet, parsed, from, nonce, validBefore, domainName, domainVersion);
+      return createX402Payment(protocolWallet, requirements, from, nonce, validBefore, domainName, domainVersion);
     },
     async signPayment(payload) {
       const from = getAddress();
-      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 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 nonce = payload.nonce.startsWith("0x") ? payload.nonce : `0x${parseInt(payload.nonce, 10).toString(16).padStart(64, "0")}`;
+      const validBefore = payload.expiry;
+      const networkConfig = getNetworkByChainId(payload.chainId);
+      const caip2Network = networkConfig?.caip2Id ?? toCaip2Id(payload.chainId);
       const requirements = {
         scheme: "exact",
-        network,
-        amount,
-        asset,
-        payTo: to,
-        maxTimeoutSeconds: defaultExpiry
+        network: caip2Network,
+        amount: payload.amount,
+        asset: payload.contractAddress,
+        payTo: payload.to,
+        maxTimeoutSeconds: validBefore - Math.floor(Date.now() / 1e3)
       };
-      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);
+      return createX402Payment(protocolWallet, requirements, from, nonce, validBefore, domainName, domainVersion);
     }
   };
 };
 var createX402Transport = (config) => {
-  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
+  const client = createX402Client({
+    wallet: config.wallet,
+    version: config.version ?? 2,
+    defaultExpiry: config.defaultExpiry,
+    nonceGenerator: config.nonceGenerator,
+    debug: config.debug,
+    token: config.token,
+    domainName: config.domainName,
+    domainVersion: config.domainVersion
   });
+  return client.fetch;
 };
 
-// src/simple.ts
+// src/payment-api.ts
 import {
   resolveNetwork,
   resolveToken,
@@ -480,7 +243,7 @@ var armoryPay = async (wallet, url, network, token, options) => {
     }
     const client = createX402Client({
       wallet: x402Wallet,
-      version: options?.version ?? "auto",
+      version: options?.version ?? 2,
       token: config.token.config,
       debug: options?.debug ?? false
     });
@@ -570,25 +333,19 @@ var getTokens = () => {
 };
 
 // src/index.ts
-import { V1_HEADERS as V1_HEADERS3, V2_HEADERS as V2_HEADERS3 } from "@armory-sh/base";
+import { 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,

package/package.json

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