@armory-sh/client-web3 0.2.10 → 0.2.12

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
-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';
+import { NetworkConfig, CustomToken, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2 } from '@armory-sh/base';
+export { EIP3009Authorization, PaymentPayloadV2, PaymentRequirementsV2, SchemePayloadV2, SettlementResponseV2 } from '@armory-sh/base';
 
 type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>;
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
@@ -8,7 +8,7 @@ type Token = CustomToken;
 interface Web3ClientConfig {
     account: Web3Account;
     network: NetworkConfig | string;
-    version?: 1 | 2;
+    version?: 2;
     rpcUrl?: string;
     /** Pre-configured token object (overrides individual fields below) */
     token?: Token;
@@ -18,15 +18,12 @@ interface Web3ClientConfig {
     domainVersion?: string;
 }
 interface PaymentSignatureResult {
-    v?: number;
-    r?: string;
-    s?: string;
     signature?: {
         v: number;
         r: string;
         s: string;
     };
-    payload: PaymentPayloadV1 | PaymentPayloadV2;
+    payload: PaymentPayloadV2;
 }
 interface PaymentSignOptions {
     amount: string | bigint;
@@ -35,31 +32,24 @@ interface PaymentSignOptions {
     expiry?: number;
     validAfter?: number;
 }
-interface X402RequestContext {
-    url: string;
-    method: string;
-    headers: Record<string, string> | Headers;
-    body?: string | Record<string, unknown> | null;
-    version: 1 | 2;
-}
 interface X402TransportOptions {
     client: Web3X402Client;
     autoSign?: boolean;
     maxRetries?: number;
 }
+interface X402Transport {
+    fetch(url: string | Request, init?: RequestInit): Promise<Response>;
+    getClient(): Web3X402Client;
+}
 interface Web3X402Client {
     fetch(url: string | Request, init?: RequestInit): Promise<Response>;
     getAccount(): Web3Account;
     getNetwork(): NetworkConfig;
-    getVersion(): 1 | 2;
+    getVersion(): 2;
     signPayment(options: PaymentSignOptions): Promise<PaymentSignatureResult>;
     createPaymentHeaders(options: PaymentSignOptions): Promise<Headers>;
-    handlePaymentRequired(requirements: PaymentRequirementsV1 | PaymentRequirementsV2): Promise<PaymentSignatureResult>;
-    verifySettlement(response: SettlementResponseV1 | SettlementResponseV2): boolean;
-}
-interface X402Transport {
-    fetch(url: string | Request, init?: RequestInit): Promise<Response>;
-    getClient(): Web3X402Client;
+    handlePaymentRequired(requirements: PaymentRequirementsV2): Promise<PaymentSignatureResult>;
+    verifySettlement(response: SettlementResponseV2): boolean;
 }
 interface Web3TransferWithAuthorization {
     from: string;
@@ -76,10 +66,6 @@ interface Web3EIP712Domain {
     verifyingContract: string;
     [key: string]: string | number;
 }
-declare const isV1Requirements: (requirements: PaymentRequirementsV1 | PaymentRequirementsV2) => requirements is PaymentRequirementsV1;
-declare const isV2Requirements: (requirements: PaymentRequirementsV1 | PaymentRequirementsV2) => requirements is PaymentRequirementsV2;
-declare const isV1Settlement: (response: SettlementResponseV1 | SettlementResponseV2) => response is SettlementResponseV1;
-declare const isV2Settlement: (response: SettlementResponseV1 | SettlementResponseV2) => response is SettlementResponseV2;
 
 declare const createX402Client: (config: Web3ClientConfig) => Web3X402Client;
 
@@ -87,137 +73,7 @@ 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";
-        readonly type: "string";
-    }, {
-        readonly name: "version";
-        readonly type: "string";
-    }, {
-        readonly name: "chainId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "verifyingContract";
-        readonly type: "address";
-    }];
-    readonly TransferWithAuthorization: readonly [{
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly name: "value";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
-    }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "uint256";
-    }];
-};
-declare const USDC_DOMAIN: {
-    readonly NAME: "USD Coin";
-    readonly VERSION: "2";
-};
 declare const createEIP712Domain: (chainId: number | string, contractAddress: string, domainName?: string, domainVersion?: string) => Web3EIP712Domain;
 declare const createTransferWithAuthorization: (params: Web3TransferWithAuthorization) => Record<string, string>;
 declare const validateTransferWithAuthorization: (message: Web3TransferWithAuthorization) => boolean;
@@ -239,4 +95,4 @@ declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domai
     s: string;
 }>;
 
-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 };
+export { adjustVForChainId, concatenateSignature, createEIP712Domain, createTransferWithAuthorization, createX402Client, createX402Transport, parseSignature, signTypedData, signWithPrivateKey, validateTransferWithAuthorization };

package/dist/index.js

@@ -2,32 +2,13 @@
 import { Web3 } from "web3";
 import {
   getNetworkConfig,
-  encodePaymentV1,
   encodePaymentV2,
-  isX402V1Requirements,
-  isX402V2Requirements,
+  networkToCaip2,
   combineSignatureV2,
-  V1_HEADERS as V1_HEADERS2,
   V2_HEADERS as V2_HEADERS2
 } from "@armory-sh/base";
 
 // src/eip3009.ts
-var EIP712_TYPES = {
-  EIP712Domain: [
-    { name: "name", type: "string" },
-    { name: "version", type: "string" },
-    { name: "chainId", type: "uint256" },
-    { name: "verifyingContract", type: "address" }
-  ],
-  TransferWithAuthorization: [
-    { name: "from", type: "address" },
-    { name: "to", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "validAfter", type: "uint256" },
-    { name: "validBefore", type: "uint256" },
-    { name: "nonce", type: "uint256" }
-  ]
-};
 var USDC_DOMAIN = {
   NAME: "USD Coin",
   VERSION: "2"
@@ -125,107 +106,40 @@ var signWithPrivateKey = async (_privateKey, _domain, _message) => {
 
 // src/protocol.ts
 import {
-  V1_HEADERS,
   V2_HEADERS,
-  decodeX402PaymentRequiredV1,
-  isX402V1PaymentRequired,
-  isX402V2PaymentRequired,
-  getPaymentRequiredHeaderName,
-  getPaymentHeaderName
+  isX402V2PaymentRequired
 } 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 detectX402Version = (_response, _fallbackVersion = 2) => {
+  return 2;
 };
-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);
+var parsePaymentRequired = async (response, _version) => {
+  const v2Header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
+  if (!v2Header) {
+    throw new Error("No PAYMENT-REQUIRED header found in V2 response");
   }
-  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)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(v2Header);
+    } catch {
+      const decoded = Buffer.from(v2Header, "base64").toString("utf-8");
+      parsed = JSON.parse(decoded);
+    }
+    if (!isX402V2PaymentRequired(parsed)) {
+      throw new Error("Invalid x402 V2 payment required format");
+    }
+    if (!parsed.accepts || parsed.accepts.length === 0) {
+      throw new Error("No payment requirements found in accepts array");
+    }
     return {
-      version: 1,
+      version: 2,
       requirements: parsed.accepts,
       raw: parsed
     };
+  } catch (error) {
+    if (error instanceof Error) throw error;
+    throw new Error(`Failed to parse V2 PAYMENT-REQUIRED header: ${error}`);
   }
-  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 = {
@@ -240,37 +154,20 @@ var createX402V2Payment = (params) => {
     x402Version: 2,
     scheme: params.accepted.scheme,
     network: params.accepted.network,
-    resource: params.resource,
     payload: {
       signature: params.signature,
       authorization
-    }
+    },
+    resource: params.resource
   };
 };
-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
-  );
+  return response.headers.has(V2_HEADERS.PAYMENT_REQUIRED);
 };
 
 // src/client.ts
 var DEFAULT_EXPIRY_SECONDS = 3600;
-var DEFAULT_VALID_AFTER = 0;
 var extractDomainConfig = (config) => {
   if (config.token) {
     return {
@@ -334,64 +231,6 @@ var signTypedDataWrapper = async (account, domain, message) => {
   }
   throw new Error("Account does not support EIP-712 signing.");
 };
-var signPaymentV1 = async (state, params) => {
-  const { from, to, amount, nonce, expiry, validAfter } = params;
-  const { network, domainName, domainVersion } = state;
-  const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
-  const message = createTransferWithAuthorization({
-    from,
-    to,
-    value: amount,
-    validAfter: `0x${validAfter.toString(16)}`,
-    validBefore: `0x${expiry.toString(16)}`,
-    nonce: `0x${nonce}`
-  });
-  const signature = await signTypedDataWrapper(state.account, domain, message);
-  const legacyPayload = {
-    from,
-    to,
-    amount,
-    nonce,
-    expiry,
-    v: signature.v,
-    r: signature.r,
-    s: signature.s,
-    chainId: network.chainId,
-    contractAddress: network.usdcAddress,
-    network: network.name.toLowerCase().replace(" ", "-")
-  };
-  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, accepted } = params;
   const { network, domainName, domainVersion } = state;
@@ -408,7 +247,7 @@ var signPaymentV2 = async (state, params) => {
   const combinedSig = combineSignatureV2(signature.v, signature.r, signature.s);
   const defaultAccepted = accepted ?? {
     scheme: "exact",
-    network: network.caip2Id,
+    network: networkToCaip2(network.name),
     amount,
     asset: network.usdcAddress,
     payTo: to,
@@ -422,6 +261,7 @@ var signPaymentV2 = async (state, params) => {
     validAfter: "0x0",
     validBefore: `0x${expiry.toString(16)}`,
     signature: combinedSig,
+    network: defaultAccepted.network,
     accepted: defaultAccepted
   });
   return {
@@ -440,32 +280,23 @@ var createX402Client = (config) => {
     if (response.status === 402) {
       const version = detectX402Version(response, state.version);
       const parsed = await parsePaymentRequired(response, version);
-      const selectedRequirements = selectSchemeRequirements(parsed.requirements, "exact");
+      const selectedRequirements = parsed.requirements[0];
       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 req = selectedRequirements;
+      const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
+      const 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));
-      }
+      paymentHeaders.set(V2_HEADERS2.PAYMENT_SIGNATURE, encodePaymentV2(result.payload));
       response = await fetch2(url, { ...init, headers: paymentHeaders });
     }
     return response;
@@ -481,89 +312,46 @@ var createX402Client = (config) => {
       const amount = options.amount.toString();
       const nonce = options.nonce ?? crypto.randomUUID();
       const expiry = options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS;
-      if (state.version === 1) {
-        return signPaymentV1(state, {
-          from,
-          to,
-          amount,
-          nonce,
-          expiry,
-          validAfter: options.validAfter ?? DEFAULT_VALID_AFTER
-        });
-      }
       return signPaymentV2(state, { from, to, amount, nonce, expiry });
     },
     createPaymentHeaders: async (options) => {
-      const result = await signPayment(options, state);
+      const from = getAddress(state.account);
+      const to = options.to;
+      const amount = options.amount.toString();
+      const nonce = options.nonce ?? crypto.randomUUID();
+      const expiry = options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS;
+      const result = await signPaymentV2(state, { from, to, amount, nonce, expiry });
       const headers = new Headers();
-      if (state.version === 1) {
-        headers.set("X-PAYMENT", encodePaymentV1(result.payload));
-      } else {
-        headers.set("PAYMENT-SIGNATURE", encodePaymentV2(result.payload));
-      }
+      headers.set("PAYMENT-SIGNATURE", encodePaymentV2(result.payload));
       return headers;
     },
     handlePaymentRequired: async (requirements) => {
-      return handlePaymentRequirements(requirements, state);
+      const from = getAddress(state.account);
+      const to = typeof requirements.payTo === "string" ? requirements.payTo : "0x0000000000000000000000000000000000000000";
+      return signPaymentV2(state, {
+        from,
+        to,
+        amount: requirements.amount,
+        nonce: crypto.randomUUID(),
+        expiry: Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS,
+        accepted: requirements
+      });
     },
     verifySettlement: (response) => {
-      if ("success" in response) {
-        return response.success;
-      }
-      return false;
+      return response.success === true;
     }
   };
 };
-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) {
-    return signPaymentV1(state, {
-      from,
-      to: options.to,
-      amount: options.amount.toString(),
-      nonce: options.nonce ?? crypto.randomUUID(),
-      expiry: options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS,
-      validAfter: options.validAfter ?? DEFAULT_VALID_AFTER
-    });
-  }
-  return signPaymentV2(state, {
-    from,
-    to: options.to,
-    amount: options.amount.toString(),
-    nonce: options.nonce ?? crypto.randomUUID(),
-    expiry: options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS
-  });
-};
 
 // src/transport.ts
 import {
-  V1_HEADERS as V1_HEADERS3,
   V2_HEADERS as V2_HEADERS3,
-  encodePaymentV1 as encodePaymentV12,
-  encodePaymentV2 as encodePaymentV22,
-  isX402V1Requirements as isX402V1Requirements2,
-  isX402V2Requirements as isX402V2Requirements2
+  encodePaymentV2 as encodePaymentV22
 } from "@armory-sh/base";
 var DEFAULT_MAX_RETRIES = 3;
-var createPaymentHeaders = (payload, version) => {
+var createPaymentHeaders = (payload, _version) => {
   const headers = new Headers();
-  if (version === 1) {
-    headers.set(V1_HEADERS3.PAYMENT, encodePaymentV12(payload));
-  } else {
-    headers.set(V2_HEADERS3.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") || error.message.includes("Payment");
@@ -575,20 +363,12 @@ var backoff = (attempt) => {
 var handlePaymentRequired = async (response, client) => {
   const version = detectX402Version(response, client.getVersion());
   const parsed = await parsePaymentRequired(response, version);
-  const selectedRequirements = selectSchemeRequirements(parsed.requirements, "exact");
+  const selectedRequirements = parsed.requirements[0];
   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);
-  }
+  const req = selectedRequirements;
+  const result = await client.handlePaymentRequired(req);
   return createPaymentHeaders(result.payload, version);
 };
 var mergePaymentHeaders = (init = {}, paymentHeaders) => {
@@ -631,123 +411,15 @@ var createX402Transport = (options) => {
     }
   };
 };
-var createFetchWithX402 = (transport) => (url, init) => transport.fetch(url, init);
-
-// src/types.ts
-var isV1Requirements = (requirements) => "contractAddress" in requirements;
-var isV2Requirements = (requirements) => "chainId" in requirements && "assetId" in requirements;
-var isV1Settlement = (response) => "success" in response;
-var isV2Settlement = (response) => "status" in response;
-
-// src/index.ts
-import {
-  V1_HEADERS as V1_HEADERS4,
-  V2_HEADERS as V2_HEADERS4,
-  encodePaymentV1 as encodePaymentV13,
-  decodePaymentV1,
-  encodeSettlementV1,
-  decodeSettlementV1,
-  encodePaymentV2 as encodePaymentV23,
-  decodePaymentV2,
-  encodeSettlementV2,
-  decodeSettlementV2,
-  isV1,
-  isV2,
-  getPaymentVersion,
-  getRequirementsVersion,
-  getSettlementVersion,
-  getPaymentHeaderName as getPaymentHeaderName2,
-  getPaymentResponseHeaderName,
-  getPaymentRequiredHeaderName as getPaymentRequiredHeaderName2,
-  isSettlementSuccessful,
-  getTxHash,
-  NETWORKS,
-  getNetworkConfig as getNetworkConfig2,
-  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,
-  createTransferWithAuthorization as createTransferWithAuthorization2,
-  validateTransferWithAuthorization as validateTransferWithAuthorization2
-} from "@armory-sh/base";
 export {
-  EIP712_TYPES2 as CORE_EIP712_TYPES,
-  USDC_DOMAIN2 as CORE_USDC_DOMAIN,
-  EIP712_TYPES,
-  NETWORKS,
-  USDC_DOMAIN,
-  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,
-  encodeSettlementV2,
-  getMainnets,
-  getNetworkByChainId,
-  getNetworkConfig2 as getNetworkConfig,
-  getPaymentHeader,
-  getPaymentHeaderName2 as getPaymentHeaderName,
-  getPaymentRequiredHeader,
-  getPaymentRequiredHeaderName2 as getPaymentRequiredHeaderName,
-  getPaymentResponseHeaderName,
-  getPaymentVersion,
-  getRequirementsVersion,
-  getSettlementVersion,
-  getTestnets,
-  getTxHash,
-  isPaymentRequiredResponse,
-  isSettlementSuccessful,
-  isV1,
-  isV1Requirements,
-  isV1Settlement,
-  isV2,
-  isV2Requirements,
-  isV2Settlement,
-  isX402V1Payload,
-  isX402V1Requirements3 as isX402V1Requirements,
-  isX402V1Settlement,
-  isX402V2Payload,
-  isX402V2Requirements3 as isX402V2Requirements,
-  isX402V2Settlement,
-  parsePaymentRequired,
-  parsePaymentRequiredFromBody,
-  parsePaymentRequiredFromHeader,
   parseSignature,
-  parseSignatureV2,
-  selectSchemeRequirements,
   signTypedData,
   signWithPrivateKey,
-  validateTransferWithAuthorization2 as validateCoreTransferWithAuthorization,
   validateTransferWithAuthorization
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-web3",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,7 +27,7 @@
     "directory": "packages/client-web3"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.13",
+    "@armory-sh/base": "^0.2.16",
     "web3": "4.16.0",
     "web3-types": "1.10.0"
   },