@armory-sh/client-web3 0.2.6 → 0.2.10

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
-import { PaymentPayloadV1, PaymentPayloadV2, CustomToken, NetworkConfig, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponseV1, SettlementResponseV2 } from '@armory-sh/base';
-export { EIP712_TYPES as CORE_EIP712_TYPES, USDC_DOMAIN as CORE_USDC_DOMAIN, NETWORKS, NetworkConfig, PaymentPayload, PaymentPayloadV1, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponse, SettlementResponseV1, SettlementResponseV2, V1_HEADERS, V2_HEADERS, createEIP712Domain as createCoreEIP712Domain, createTransferWithAuthorization as createCoreTransferWithAuthorization, decodePaymentV1, decodePaymentV2, decodeSettlementV1, decodeSettlementV2, encodePaymentV1, encodePaymentV2, encodeSettlementV1, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, getPaymentRequiredHeaderName, getPaymentResponseHeaderName, getPaymentVersion, getRequirementsVersion, getSettlementVersion, getTestnets, getTxHash, isAddress, isCAIP2ChainId, isCAIPAssetId, isSettlementSuccessful, isV1, isV2, validateTransferWithAuthorization as validateCoreTransferWithAuthorization } from '@armory-sh/base';
+import { PaymentPayloadV1, PaymentPayloadV2, CustomToken, NetworkConfig, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponseV1, SettlementResponseV2, X402PaymentRequiredV1, PaymentRequiredV2, X402PaymentPayloadV1 } from '@armory-sh/base';
+export { EIP712_TYPES as CORE_EIP712_TYPES, USDC_DOMAIN as CORE_USDC_DOMAIN, NETWORKS, NetworkConfig, PaymentPayload, PaymentPayloadV1, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponse, SettlementResponseV1, SettlementResponseV2, V1_HEADERS, V2_HEADERS, combineSignatureV2, createEIP712Domain as createCoreEIP712Domain, createTransferWithAuthorization as createCoreTransferWithAuthorization, createNonce, decodePaymentV1, decodePaymentV2, decodeSettlementV1, decodeSettlementV2, encodePaymentV1, encodePaymentV2, encodeSettlementV1, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, getPaymentRequiredHeaderName, getPaymentResponseHeaderName, getPaymentVersion, getRequirementsVersion, getSettlementVersion, getTestnets, getTxHash, isSettlementSuccessful, isV1, isV2, isX402V1Payload, isX402V1Requirements, isX402V1Settlement, isX402V2Payload, isX402V2Requirements, isX402V2Settlement, parseSignatureV2, validateTransferWithAuthorization as validateCoreTransferWithAuthorization } from '@armory-sh/base';
 
 type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>;
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
@@ -48,6 +48,7 @@ interface X402TransportOptions {
     maxRetries?: number;
 }
 interface Web3X402Client {
+    fetch(url: string | Request, init?: RequestInit): Promise<Response>;
     getAccount(): Web3Account;
     getNetwork(): NetworkConfig;
     getVersion(): 1 | 2;
@@ -82,9 +83,103 @@ declare const isV2Settlement: (response: SettlementResponseV1 | SettlementRespon
 
 declare const createX402Client: (config: Web3ClientConfig) => Web3X402Client;
 
+/**
+ * Create an x402 transport layer for handling payment-required responses
+ */
 declare const createX402Transport: (options: X402TransportOptions) => X402Transport;
+/**
+ * Create a fetch function bound to an x402 transport
+ */
 declare const createFetchWithX402: (transport: X402Transport) => (url: string | Request, init?: RequestInit) => Promise<Response>;
 
+/**
+ * X402 Protocol Detection and Parsing Functions
+ *
+ * Handles both x402 V1 and V2 protocol detection and parsing from HTTP responses.
+ */
+
+type X402Version = 1 | 2;
+interface ParsedPaymentRequired {
+    version: X402Version;
+    requirements: PaymentRequirementsV1[] | PaymentRequirementsV2[];
+    raw: X402PaymentRequiredV1 | PaymentRequiredV2;
+}
+/**
+ * Detect x402 protocol version from response headers
+ * Returns V2 if PAYMENT-REQUIRED header exists, V1 for X-PAYMENT-REQUIRED
+ * Falls back to body detection if no headers present
+ */
+declare const detectX402Version: (response: Response, fallbackVersion?: X402Version) => X402Version;
+/**
+ * Detect version from a parsed payment required object
+ */
+declare const detectVersionFromObject: (obj: unknown) => X402Version | null;
+/**
+ * Parse PAYMENT-REQUIRED header or response body
+ * Handles both V1 (base64 encoded) and V2 (JSON) formats
+ */
+declare const parsePaymentRequired: (response: Response, version?: X402Version) => Promise<ParsedPaymentRequired>;
+/**
+ * Parse payment required from header value
+ */
+declare const parsePaymentRequiredFromHeader: (header: string, version: X402Version) => ParsedPaymentRequired;
+/**
+ * Parse payment required from response body
+ */
+declare const parsePaymentRequiredFromBody: (body: string, version: X402Version) => ParsedPaymentRequired;
+/**
+ * Create x402 V1 payment payload
+ */
+declare const createX402V1Payment: (params: {
+    from: string;
+    to: string;
+    value: string;
+    nonce: `0x${string}`;
+    validAfter: string;
+    validBefore: string;
+    signature: `0x${string}`;
+    network: string;
+}) => X402PaymentPayloadV1;
+/**
+ * Create x402 V2 payment payload
+ */
+declare const createX402V2Payment: (params: {
+    from: string;
+    to: string;
+    value: string;
+    nonce: `0x${string}`;
+    validAfter: string;
+    validBefore: string;
+    signature: `0x${string}`;
+    accepted: PaymentRequirementsV2;
+    resource?: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+}) => PaymentPayloadV2;
+/**
+ * Create payment header for request
+ */
+declare const createPaymentHeader: (payload: X402PaymentPayloadV1 | PaymentPayloadV2, version: X402Version) => string;
+/**
+ * Get the payment header name for a version
+ */
+declare const getPaymentHeader: (version: X402Version) => string;
+/**
+ * Get the payment required header name for a version
+ */
+declare const getPaymentRequiredHeader: (version: X402Version) => string;
+/**
+ * Check if response indicates payment is required
+ */
+declare const isPaymentRequiredResponse: (response: Response) => boolean;
+/**
+ * Extract requirements for a specific scheme from accepts array
+ * Uses type assertion to handle union types
+ */
+declare const selectSchemeRequirements: (requirements: PaymentRequirementsV1[] | PaymentRequirementsV2[], scheme?: string) => PaymentRequirementsV1 | PaymentRequirementsV2 | undefined;
+
 declare const EIP712_TYPES: {
     readonly EIP712Domain: readonly [{
         readonly name: "name";
@@ -144,4 +239,4 @@ declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domai
     s: string;
 }>;
 
-export { EIP712_TYPES, type PaymentSignOptions, type PaymentSignatureResult, type Token, USDC_DOMAIN, type Web3Account, type Web3ClientConfig, type Web3EIP712Domain, type Web3TransferWithAuthorization, type Web3X402Client, type X402RequestContext, type X402Transport, type X402TransportOptions, adjustVForChainId, concatenateSignature, createEIP712Domain, createFetchWithX402, createTransferWithAuthorization, createX402Client, createX402Transport, isV1Requirements, isV1Settlement, isV2Requirements, isV2Settlement, parseSignature, signTypedData, signWithPrivateKey, validateTransferWithAuthorization };
+export { EIP712_TYPES, type ParsedPaymentRequired, type PaymentSignOptions, type PaymentSignatureResult, type Token, USDC_DOMAIN, type Web3Account, type Web3ClientConfig, type Web3EIP712Domain, type Web3TransferWithAuthorization, type Web3X402Client, type X402RequestContext, type X402Transport, type X402TransportOptions, type X402Version, adjustVForChainId, concatenateSignature, createEIP712Domain, createFetchWithX402, createPaymentHeader, createTransferWithAuthorization, createX402Client, createX402Transport, createX402V1Payment, createX402V2Payment, detectVersionFromObject, detectX402Version, getPaymentHeader, getPaymentRequiredHeader, isPaymentRequiredResponse, isV1Requirements, isV1Settlement, isV2Requirements, isV2Settlement, parsePaymentRequired, parsePaymentRequiredFromBody, parsePaymentRequiredFromHeader, parseSignature, selectSchemeRequirements, signTypedData, signWithPrivateKey, validateTransferWithAuthorization };

package/dist/index.js

@@ -3,7 +3,12 @@ import { Web3 } from "web3";
 import {
   getNetworkConfig,
   encodePaymentV1,
-  encodePaymentV2
+  encodePaymentV2,
+  isX402V1Requirements,
+  isX402V2Requirements,
+  combineSignatureV2,
+  V1_HEADERS as V1_HEADERS2,
+  V2_HEADERS as V2_HEADERS2
 } from "@armory-sh/base";
 
 // src/eip3009.ts
@@ -118,6 +123,151 @@ var signWithPrivateKey = async (_privateKey, _domain, _message) => {
   );
 };
 
+// src/protocol.ts
+import {
+  V1_HEADERS,
+  V2_HEADERS,
+  decodeX402PaymentRequiredV1,
+  isX402V1PaymentRequired,
+  isX402V2PaymentRequired,
+  getPaymentRequiredHeaderName,
+  getPaymentHeaderName
+} from "@armory-sh/base";
+var detectX402Version = (response, fallbackVersion = 2) => {
+  if (response.headers.has(V2_HEADERS.PAYMENT_REQUIRED)) {
+    return 2;
+  }
+  if (response.headers.has(V1_HEADERS.PAYMENT_REQUIRED)) {
+    return 1;
+  }
+  if (response.headers.has("Payment-Required")) {
+    return 2;
+  }
+  return fallbackVersion;
+};
+var detectVersionFromObject = (obj) => {
+  if (isX402V2PaymentRequired(obj)) return 2;
+  if (isX402V1PaymentRequired(obj)) return 1;
+  return null;
+};
+var parsePaymentRequired = async (response, version) => {
+  const detectedVersion = version ?? detectX402Version(response);
+  const headerName = getPaymentRequiredHeaderName(detectedVersion);
+  const header = response.headers.get(headerName);
+  if (header) {
+    return parsePaymentRequiredFromHeader(header, detectedVersion);
+  }
+  const body = await response.clone().text();
+  return parsePaymentRequiredFromBody(body, detectedVersion);
+};
+var parsePaymentRequiredFromHeader = (header, version) => {
+  if (version === 1) {
+    const decoded = decodeX402PaymentRequiredV1(header);
+    return {
+      version: 1,
+      requirements: decoded.accepts,
+      raw: decoded
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(header);
+  } catch {
+    const decoded = Buffer.from(header, "base64").toString("utf-8");
+    parsed = JSON.parse(decoded);
+  }
+  return {
+    version: 2,
+    requirements: parsed.accepts,
+    raw: parsed
+  };
+};
+var parsePaymentRequiredFromBody = (body, version) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    const decoded = Buffer.from(body, "base64").toString("utf-8");
+    parsed = JSON.parse(decoded);
+  }
+  const detectedVersion = detectVersionFromObject(parsed) ?? version;
+  if (detectedVersion === 1 && isX402V1PaymentRequired(parsed)) {
+    return {
+      version: 1,
+      requirements: parsed.accepts,
+      raw: parsed
+    };
+  }
+  if (detectedVersion === 2 && isX402V2PaymentRequired(parsed)) {
+    const v2Parsed = parsed;
+    return {
+      version: 2,
+      requirements: v2Parsed.accepts,
+      raw: v2Parsed
+    };
+  }
+  throw new Error("Unable to parse payment required response");
+};
+var createX402V1Payment = (params) => {
+  const authorization = {
+    from: params.from,
+    to: params.to,
+    value: params.value,
+    validAfter: params.validAfter,
+    validBefore: params.validBefore,
+    nonce: params.nonce
+  };
+  return {
+    x402Version: 1,
+    scheme: "exact",
+    network: params.network,
+    payload: {
+      signature: params.signature,
+      authorization
+    }
+  };
+};
+var createX402V2Payment = (params) => {
+  const authorization = {
+    from: params.from,
+    to: params.to,
+    value: params.value,
+    validAfter: params.validAfter,
+    validBefore: params.validBefore,
+    nonce: params.nonce
+  };
+  return {
+    x402Version: 2,
+    scheme: params.accepted.scheme,
+    network: params.accepted.network,
+    resource: params.resource,
+    payload: {
+      signature: params.signature,
+      authorization
+    }
+  };
+};
+var createPaymentHeader = (payload, version) => {
+  const headerName = getPaymentHeaderName(version);
+  const encoded = Buffer.from(JSON.stringify(payload)).toString("base64");
+  return encoded;
+};
+var getPaymentHeader = (version) => {
+  return getPaymentHeaderName(version);
+};
+var getPaymentRequiredHeader = (version) => {
+  return getPaymentRequiredHeaderName(version);
+};
+var isPaymentRequiredResponse = (response) => {
+  if (response.status === 402) return true;
+  return response.headers.has(V1_HEADERS.PAYMENT_REQUIRED) || response.headers.has(V2_HEADERS.PAYMENT_REQUIRED) || response.headers.has("Payment-Required");
+};
+var selectSchemeRequirements = (requirements, scheme = "exact") => {
+  return requirements.find(
+    (r) => "scheme" in r && r.scheme === scheme
+  );
+};
+
 // src/client.ts
 var DEFAULT_EXPIRY_SECONDS = 3600;
 var DEFAULT_VALID_AFTER = 0;
@@ -167,7 +317,7 @@ var signTypedDataWrapper = async (account, domain, message) => {
     const sig = await acc.signTypedData(domain, message);
     return parseSignature2(sig);
   }
-  const getAddress2 = () => {
+  const getAddressLocal = () => {
     if ("address" in account) return account.address;
     if (Array.isArray(account) && account[0]) return account[0].address;
     throw new Error("Unable to get address from account");
@@ -175,7 +325,7 @@ var signTypedDataWrapper = async (account, domain, message) => {
   if (typeof acc.request === "function") {
     const sig = await acc.request({
       method: "eth_signTypedData_v4",
-      params: [getAddress2(), JSON.stringify({ domain, message })]
+      params: [getAddressLocal(), JSON.stringify({ domain, message })]
     });
     return parseSignature2(sig);
   }
@@ -197,7 +347,7 @@ var signPaymentV1 = async (state, params) => {
     nonce: `0x${nonce}`
   });
   const signature = await signTypedDataWrapper(state.account, domain, message);
-  const payload = {
+  const legacyPayload = {
     from,
     to,
     amount,
@@ -210,10 +360,40 @@ var signPaymentV1 = async (state, params) => {
     contractAddress: network.usdcAddress,
     network: network.name.toLowerCase().replace(" ", "-")
   };
-  return { v: signature.v, r: signature.r, s: signature.s, payload };
+  return { v: signature.v, r: signature.r, s: signature.s, payload: legacyPayload };
+};
+var handlePaymentRequirements = async (requirements, state) => {
+  const version = detectVersionFromRequirements(requirements);
+  if (version === 1) {
+    const req2 = requirements;
+    if (isX402V1Requirements(req2)) {
+      const x402Req = req2;
+      return signPayment({
+        amount: x402Req.maxAmountRequired,
+        to: x402Req.payTo
+      }, state);
+    }
+    const legacyReq = req2;
+    return signPayment({
+      amount: legacyReq.amount,
+      to: legacyReq.payTo,
+      expiry: legacyReq.expiry
+    }, state);
+  }
+  const req = requirements;
+  const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
+  const from = getAddress(state.account);
+  return signPaymentV2(state, {
+    from,
+    to,
+    amount: req.amount,
+    nonce: crypto.randomUUID(),
+    expiry: Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS,
+    accepted: req
+  });
 };
 var signPaymentV2 = async (state, params) => {
-  const { from, to, amount, nonce, expiry } = params;
+  const { from, to, amount, nonce, expiry, accepted } = params;
   const { network, domainName, domainVersion } = state;
   const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
   const message = createTransferWithAuthorization({
@@ -225,25 +405,73 @@ var signPaymentV2 = async (state, params) => {
     nonce: `0x${nonce}`
   });
   const signature = await signTypedDataWrapper(state.account, domain, message);
-  const payload = {
+  const combinedSig = combineSignatureV2(signature.v, signature.r, signature.s);
+  const defaultAccepted = accepted ?? {
+    scheme: "exact",
+    network: network.caip2Id,
+    amount,
+    asset: network.usdcAddress,
+    payTo: to,
+    maxTimeoutSeconds: expiry - Math.floor(Date.now() / 1e3)
+  };
+  const x402Payload = createX402V2Payment({
     from,
     to,
-    amount,
-    nonce,
-    expiry,
+    value: amount,
+    nonce: `0x${nonce.padStart(64, "0")}`,
+    validAfter: "0x0",
+    validBefore: `0x${expiry.toString(16)}`,
+    signature: combinedSig,
+    accepted: defaultAccepted
+  });
+  return {
     signature: {
       v: signature.v,
       r: signature.r,
       s: signature.s
     },
-    chainId: network.caip2Id,
-    assetId: network.caipAssetId
+    payload: x402Payload
   };
-  return { signature: payload.signature, payload };
 };
 var createX402Client = (config) => {
   const state = createClientState(config);
+  const fetch2 = async (url, init) => {
+    let response = await fetch2(url, init);
+    if (response.status === 402) {
+      const version = detectX402Version(response, state.version);
+      const parsed = await parsePaymentRequired(response, version);
+      const selectedRequirements = selectSchemeRequirements(parsed.requirements, "exact");
+      if (!selectedRequirements) {
+        throw new Error("No supported payment scheme found in requirements");
+      }
+      const from = getAddress(state.account);
+      let result;
+      if (version === 1) {
+        result = await handlePaymentRequirements(selectedRequirements, state);
+      } else {
+        const req = selectedRequirements;
+        const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
+        result = await signPaymentV2(state, {
+          from,
+          to,
+          amount: req.amount,
+          nonce: crypto.randomUUID(),
+          expiry: Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS,
+          accepted: req
+        });
+      }
+      const paymentHeaders = new Headers(init?.headers);
+      if (version === 1) {
+        paymentHeaders.set(V1_HEADERS2.PAYMENT, encodePaymentV1(result.payload));
+      } else {
+        paymentHeaders.set(V2_HEADERS2.PAYMENT_SIGNATURE, encodePaymentV2(result.payload));
+      }
+      response = await fetch2(url, { ...init, headers: paymentHeaders });
+    }
+    return response;
+  };
   return {
+    fetch: fetch2,
     getAccount: () => state.account,
     getNetwork: () => state.network,
     getVersion: () => state.version,
@@ -276,28 +504,28 @@ var createX402Client = (config) => {
       return headers;
     },
     handlePaymentRequired: async (requirements) => {
-      if ("contractAddress" in requirements) {
-        const req2 = requirements;
-        return signPayment({
-          amount: req2.amount,
-          to: req2.payTo,
-          expiry: req2.expiry
-        }, state);
-      }
-      const req = requirements;
-      const to = typeof req.to === "string" ? req.to : "0x0000000000000000000000000000000000000000";
-      return signPayment({
-        amount: req.amount,
-        to,
-        nonce: req.nonce,
-        expiry: req.expiry
-      }, state);
+      return handlePaymentRequirements(requirements, state);
     },
     verifySettlement: (response) => {
-      return "success" in response ? response.success : response.status === "success";
+      if ("success" in response) {
+        return response.success;
+      }
+      return false;
     }
   };
 };
+var detectVersionFromRequirements = (requirements) => {
+  if (isX402V2Requirements(requirements)) {
+    return 2;
+  }
+  if (isX402V1Requirements(requirements)) {
+    return 1;
+  }
+  if ("contractAddress" in requirements) {
+    return 1;
+  }
+  return 2;
+};
 var signPayment = async (options, state) => {
   const from = getAddress(state.account);
   if (state.version === 1) {
@@ -320,50 +548,47 @@ var signPayment = async (options, state) => {
 };
 
 // src/transport.ts
-import { V1_HEADERS, V2_HEADERS, encodePaymentV1 as encodePaymentV12, encodePaymentV2 as encodePaymentV22 } from "@armory-sh/base";
+import {
+  V1_HEADERS as V1_HEADERS3,
+  V2_HEADERS as V2_HEADERS3,
+  encodePaymentV1 as encodePaymentV12,
+  encodePaymentV2 as encodePaymentV22,
+  isX402V1Requirements as isX402V1Requirements2,
+  isX402V2Requirements as isX402V2Requirements2
+} from "@armory-sh/base";
 var DEFAULT_MAX_RETRIES = 3;
-var detectProtocolVersion = (response, client) => {
-  if (response.headers.has(V2_HEADERS.PAYMENT_REQUIRED) || response.headers.has("PAYMENT-REQUIRED")) {
-    return 2;
-  }
-  if (response.headers.has("X-PAYMENT-REQUIRED")) {
-    return 1;
-  }
-  return client.getVersion();
-};
-var parsePaymentRequirements = async (response, version) => {
-  if (version === 2) {
-    const header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
-    if (header) return JSON.parse(header);
-  } else {
-    const header = response.headers.get("X-PAYMENT-REQUIRED");
-    if (header) {
-      const json = Buffer.from(header, "base64").toString("utf-8");
-      return JSON.parse(json);
-    }
-  }
-  return JSON.parse(await response.clone().text());
-};
 var createPaymentHeaders = (payload, version) => {
   const headers = new Headers();
   if (version === 1) {
-    headers.set(V1_HEADERS.PAYMENT, encodePaymentV12(payload));
+    headers.set(V1_HEADERS3.PAYMENT, encodePaymentV12(payload));
   } else {
-    headers.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV22(payload));
+    headers.set(V2_HEADERS3.PAYMENT_SIGNATURE, encodePaymentV22(payload));
   }
   return headers;
 };
-var isPaymentRelatedError = (error) => error.message.includes("402") || error.message.includes("payment") || error.message.includes("signature");
+var isPaymentRelatedError = (error) => error.message.includes("402") || error.message.includes("payment") || error.message.includes("signature") || error.message.includes("Payment");
 var backoff = (attempt) => {
-  const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
-  return new Promise((resolve) => setTimeout(resolve, delay));
+  const baseDelay = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
+  const jitter = Math.random() * 100;
+  return new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
 };
 var handlePaymentRequired = async (response, client) => {
-  const version = detectProtocolVersion(response, client);
-  const requirements = await parsePaymentRequirements(response, version);
-  const result = await client.handlePaymentRequired(
-    requirements
-  );
+  const version = detectX402Version(response, client.getVersion());
+  const parsed = await parsePaymentRequired(response, version);
+  const selectedRequirements = selectSchemeRequirements(parsed.requirements, "exact");
+  if (!selectedRequirements) {
+    throw new Error("No supported payment scheme found in requirements");
+  }
+  let result;
+  if (version === 1 && isX402V1Requirements2(selectedRequirements)) {
+    const req = selectedRequirements;
+    result = await client.handlePaymentRequired(req);
+  } else if (version === 2 && isX402V2Requirements2(selectedRequirements)) {
+    const req = selectedRequirements;
+    result = await client.handlePaymentRequired(req);
+  } else {
+    result = await client.handlePaymentRequired(selectedRequirements);
+  }
   return createPaymentHeaders(result.payload, version);
 };
 var mergePaymentHeaders = (init = {}, paymentHeaders) => {
@@ -386,7 +611,7 @@ var createX402Transport = (options) => {
         attempt++;
         try {
           const response = await fetch(url, init);
-          if (response.status === 402 && autoSign) {
+          if (isPaymentRequiredResponse(response) && autoSign) {
             const paymentHeaders = await handlePaymentRequired(response, client);
             const newInit = mergePaymentHeaders(init, paymentHeaders);
             return await fetch(url, newInit);
@@ -416,15 +641,12 @@ var isV2Settlement = (response) => "status" in response;
 
 // src/index.ts
 import {
-  V1_HEADERS as V1_HEADERS2,
+  V1_HEADERS as V1_HEADERS4,
+  V2_HEADERS as V2_HEADERS4,
   encodePaymentV1 as encodePaymentV13,
   decodePaymentV1,
   encodeSettlementV1,
   decodeSettlementV1,
-  V2_HEADERS as V2_HEADERS2,
-  isCAIP2ChainId,
-  isCAIPAssetId,
-  isAddress,
   encodePaymentV2 as encodePaymentV23,
   decodePaymentV2,
   encodeSettlementV2,
@@ -434,9 +656,9 @@ import {
   getPaymentVersion,
   getRequirementsVersion,
   getSettlementVersion,
-  getPaymentHeaderName,
+  getPaymentHeaderName as getPaymentHeaderName2,
   getPaymentResponseHeaderName,
-  getPaymentRequiredHeaderName,
+  getPaymentRequiredHeaderName as getPaymentRequiredHeaderName2,
   isSettlementSuccessful,
   getTxHash,
   NETWORKS,
@@ -444,6 +666,15 @@ import {
   getNetworkByChainId,
   getMainnets,
   getTestnets,
+  isX402V1Payload,
+  isX402V2Payload,
+  isX402V1Requirements as isX402V1Requirements3,
+  isX402V2Requirements as isX402V2Requirements3,
+  isX402V1Settlement,
+  isX402V2Settlement,
+  combineSignatureV2 as combineSignatureV22,
+  parseSignatureV2,
+  createNonce as createNonce2,
   EIP712_TYPES as EIP712_TYPES2,
   USDC_DOMAIN as USDC_DOMAIN2,
   createEIP712Domain as createEIP712Domain2,
@@ -456,21 +687,28 @@ export {
   EIP712_TYPES,
   NETWORKS,
   USDC_DOMAIN,
-  V1_HEADERS2 as V1_HEADERS,
-  V2_HEADERS2 as V2_HEADERS,
+  V1_HEADERS4 as V1_HEADERS,
+  V2_HEADERS4 as V2_HEADERS,
   adjustVForChainId,
+  combineSignatureV22 as combineSignatureV2,
   concatenateSignature,
   createEIP712Domain2 as createCoreEIP712Domain,
   createTransferWithAuthorization2 as createCoreTransferWithAuthorization,
   createEIP712Domain,
   createFetchWithX402,
+  createNonce2 as createNonce,
+  createPaymentHeader,
   createTransferWithAuthorization,
   createX402Client,
   createX402Transport,
+  createX402V1Payment,
+  createX402V2Payment,
   decodePaymentV1,
   decodePaymentV2,
   decodeSettlementV1,
   decodeSettlementV2,
+  detectVersionFromObject,
+  detectX402Version,
   encodePaymentV13 as encodePaymentV1,
   encodePaymentV23 as encodePaymentV2,
   encodeSettlementV1,
@@ -478,17 +716,17 @@ export {
   getMainnets,
   getNetworkByChainId,
   getNetworkConfig2 as getNetworkConfig,
-  getPaymentHeaderName,
-  getPaymentRequiredHeaderName,
+  getPaymentHeader,
+  getPaymentHeaderName2 as getPaymentHeaderName,
+  getPaymentRequiredHeader,
+  getPaymentRequiredHeaderName2 as getPaymentRequiredHeaderName,
   getPaymentResponseHeaderName,
   getPaymentVersion,
   getRequirementsVersion,
   getSettlementVersion,
   getTestnets,
   getTxHash,
-  isAddress,
-  isCAIP2ChainId,
-  isCAIPAssetId,
+  isPaymentRequiredResponse,
   isSettlementSuccessful,
   isV1,
   isV1Requirements,
@@ -496,7 +734,18 @@ export {
   isV2,
   isV2Requirements,
   isV2Settlement,
+  isX402V1Payload,
+  isX402V1Requirements3 as isX402V1Requirements,
+  isX402V1Settlement,
+  isX402V2Payload,
+  isX402V2Requirements3 as isX402V2Requirements,
+  isX402V2Settlement,
+  parsePaymentRequired,
+  parsePaymentRequiredFromBody,
+  parsePaymentRequiredFromHeader,
   parseSignature,
+  parseSignatureV2,
+  selectSchemeRequirements,
   signTypedData,
   signWithPrivateKey,
   validateTransferWithAuthorization2 as validateCoreTransferWithAuthorization,

package/package.json

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