@armory-sh/client-web3 0.2.24 → 0.2.26

package/README.md

@@ -8,6 +8,7 @@ Armory x402 SDK — Payment client for Web3.js. Make payments from any Web3.js w
 
 ```bash
 bun add @armory-sh/client-web3
+bun add @armory-sh/client-hooks # optional preference/logger hooks
 ```
 
 ## Why Armory?
@@ -60,9 +61,30 @@ const response = await client.fetch('https://api.example.com/protected')
 const data = await response.json()
 ```
 
+## Hook Pipeline
+
+```typescript
+import { createX402Client } from '@armory-sh/client-web3'
+import { PaymentPreference, Logger } from '@armory-sh/client-hooks'
+
+const client = createX402Client({
+  account,
+  hooks: [
+    PaymentPreference.chain(['base', 'polygon', 'skale']),
+    PaymentPreference.token(['USDT', 'USDC', 'WBTC']),
+    PaymentPreference.cheapest(),
+    Logger.console(),
+  ],
+})
+```
+
+`parsePaymentRequired` returns `accepts[]` (x402 v2 challenge options). Clients select from this list.
+`hooks` are lifecycle callbacks. `extensions` are protocol payload fields. Hooks can drive selection and payload behavior, but they are not extensions.
+
 ## Features
 
 - **Auto 402 Handling**: Automatically intercepts and pays for 402 responses
+- **Detailed Verification Errors**: 402 retry failures include server details (for example `insufficient_funds`)
 - **EIP-3009 Signing**: Full support for EIP-3009 TransferWithAuthorization
 - **Multi-Network**: Ethereum, Base, SKALE support
 - **Multi-Token**: USDC, EURC, USDT, WBTC, WETH, SKL

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
 import { NetworkConfig, CustomToken, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
-export { EIP3009Authorization, PaymentPayloadV2, PaymentRequirementsV2, SchemePayloadV2, SettlementResponseV2 } from '@armory-sh/base';
+import { ClientHook } from '@armory-sh/base/types/hooks';
+import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
 
 type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>;
 /** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
@@ -16,6 +16,7 @@ interface Web3ClientConfig {
     domainName?: string;
     /** Override EIP-712 domain version for custom tokens */
     domainVersion?: string;
+    hooks?: ClientHook<Web3Account>[];
 }
 interface PaymentSignatureResult {
     signature?: {
@@ -67,34 +68,6 @@ interface Web3EIP712Domain {
     [key: string]: string | number;
 }
 
-declare const createX402Client: (config: Web3ClientConfig) => Web3X402Client;
-
-/**
- * Create an x402 transport layer for handling payment-required responses
- */
-declare const createX402Transport: (options: X402TransportOptions) => X402Transport;
-
-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;
-declare const parseSignature: (signature: string) => {
-    v: number;
-    r: string;
-    s: string;
-};
-declare const concatenateSignature: (v: number, r: string, s: string) => string;
-declare const adjustVForChainId: (v: number, chainId: number) => number;
-declare const signTypedData: (_account: Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
-    v: number;
-    r: string;
-    s: string;
-}>;
-declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
-    v: number;
-    r: string;
-    s: string;
-}>;
-
 /**
  * Simple one-line payment API for Armory (Web3)
  * Focus on DX/UX - "everything just magically works"
@@ -205,4 +178,32 @@ interface ArmoryInstance {
 }
 declare const createArmory: (config: ArmoryConfig) => ArmoryInstance;
 
+declare const createX402Client: (config: Web3ClientConfig) => Web3X402Client;
+
+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;
+declare const parseSignature: (signature: string) => {
+    v: number;
+    r: string;
+    s: string;
+};
+declare const concatenateSignature: (v: number, r: string, s: string) => string;
+declare const adjustVForChainId: (v: number, chainId: number) => number;
+declare const signTypedData: (_account: Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+
+/**
+ * Create an x402 transport layer for handling payment-required responses
+ */
+declare const createX402Transport: (options: X402TransportOptions) => X402Transport;
+
 export { type ArmoryConfig, type ArmoryInstance, type HttpMethod, type NormalizedWallet, type PaymentOptions, type SimpleWalletInput, adjustVForChainId, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, concatenateSignature, createArmory, createEIP712Domain, createTransferWithAuthorization, createX402Client, createX402Transport, getNetworks, getTokens, getWalletAddress, normalizeWallet, parseSignature, signTypedData, signWithPrivateKey, validateNetwork, validateToken, validateTransferWithAuthorization };

package/dist/index.js

@@ -1,5 +1,6 @@
+import { encodePaymentV2, validatePaymentConfig, isValidationError, resolveNetwork, resolveToken, V2_HEADERS, getNetworkConfig, getNetworkByChainId, networkToCaip2, combineSignatureV2, normalizeBase64Url, decodeBase64ToUtf8, isX402V2PaymentRequired } from '@armory-sh/base';
+import { runOnPaymentRequiredHooks, getRequirementAttemptOrderWithHooks, runBeforeSignPaymentHooks, runAfterPaymentResponseHooks } from '@armory-sh/base/client-hooks-runtime';
 import { Web3 } from 'web3';
-import { encodePaymentV2, validatePaymentConfig, isValidationError, resolveNetwork, resolveToken, V2_HEADERS, getNetworkConfig, getNetworkByChainId, combineSignatureV2, networkToCaip2, isX402V2PaymentRequired } from '@armory-sh/base';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -74,7 +75,9 @@ var validateTransferWithAuthorization = (message) => {
 var parseSignature = (signature) => {
   const hexSig = signature.startsWith("0x") ? signature.slice(2) : signature;
   if (hexSig.length !== 130) {
-    throw new Error(`Invalid signature length: ${hexSig.length} (expected 130)`);
+    throw new Error(
+      `Invalid signature length: ${hexSig.length} (expected 130)`
+    );
   }
   return {
     r: `0x${hexSig.slice(0, 64)}`,
@@ -103,40 +106,6 @@ var signWithPrivateKey = async (_privateKey, _domain, _message) => {
     "Direct private key signing not implemented. Use wallet provider's signTypedData method instead."
   );
 };
-
-// src/bytes.ts
-new TextEncoder();
-var textDecoder = new TextDecoder();
-function getNodeBuffer() {
-  if ("Buffer" in globalThis) {
-    return globalThis.Buffer;
-  }
-  return void 0;
-}
-function fromBase64(base64) {
-  if (typeof atob === "function") {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) {
-      bytes[index] = binary.charCodeAt(index);
-    }
-    return bytes;
-  }
-  const nodeBuffer = getNodeBuffer();
-  if (nodeBuffer) {
-    return Uint8Array.from(nodeBuffer.from(base64, "base64"));
-  }
-  throw new Error("No base64 decoder available in this runtime");
-}
-function decodeBase64ToUtf8(value) {
-  const bytes = fromBase64(value);
-  return textDecoder.decode(bytes);
-}
-function normalizeBase64Url(value) {
-  return value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
-}
-
-// src/protocol.ts
 var detectX402Version = (_response, _fallbackVersion = 2) => {
   return 2;
 };
@@ -230,7 +199,8 @@ var getAddress = (account) => {
 };
 var parseSignature2 = (signature) => {
   const hexSig = signature.startsWith("0x") ? signature.slice(2) : signature;
-  if (hexSig.length !== 130) throw new Error(`Invalid signature length: ${hexSig.length}`);
+  if (hexSig.length !== 130)
+    throw new Error(`Invalid signature length: ${hexSig.length}`);
   return {
     r: `0x${hexSig.slice(0, 64)}`,
     s: `0x${hexSig.slice(64, 128)}`,
@@ -256,38 +226,52 @@ var signTypedDataWrapper = async (account, domain, message) => {
     return parseSignature2(sig);
   }
   if ("privateKey" in account && typeof account.privateKey === "string") {
-    throw new Error("Direct private key signing not implemented. Use wallet provider with signTypedData.");
+    throw new Error(
+      "Direct private key signing not implemented. Use wallet provider with signTypedData."
+    );
   }
   throw new Error("Account does not support EIP-712 signing.");
 };
 var signPaymentV2 = async (state, network, params) => {
   const { from, to, amount, nonce, expiry, accepted } = params;
-  const { domainName, domainVersion } = state;
-  const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
+  const defaultAccepted = accepted ?? {
+    scheme: "exact",
+    network: networkToCaip2(network.name),
+    amount,
+    asset: network.usdcAddress,
+    payTo: to,
+    maxTimeoutSeconds: expiry - Math.floor(Date.now() / 1e3)
+  };
+  const domainExtra = defaultAccepted.extra;
+  const requirementDomainName = defaultAccepted.name ?? (domainExtra && typeof domainExtra === "object" && typeof domainExtra.name === "string" ? domainExtra.name : void 0);
+  const requirementDomainVersion = defaultAccepted.version ?? (domainExtra && typeof domainExtra === "object" && typeof domainExtra.version === "string" ? domainExtra.version : void 0);
+  const effectiveDomainName = state.domainName ?? requirementDomainName;
+  const effectiveDomainVersion = state.domainVersion ?? requirementDomainVersion;
+  const chainId = parseInt(defaultAccepted.network.split(":")[1], 10);
+  const domain = createEIP712Domain(
+    chainId,
+    defaultAccepted.asset,
+    effectiveDomainName,
+    effectiveDomainVersion
+  );
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const validAfterHex = `0x${(nowSeconds - 600).toString(16)}`;
   const message = createTransferWithAuthorization({
     from,
     to,
     value: amount,
-    validAfter: "0x0",
+    validAfter: validAfterHex,
     validBefore: `0x${expiry.toString(16)}`,
     nonce: `0x${nonce}`
   });
   const signature = await signTypedDataWrapper(state.account, domain, message);
   const combinedSig = combineSignatureV2(signature.v, signature.r, signature.s);
-  const defaultAccepted = accepted ?? {
-    scheme: "exact",
-    network: networkToCaip2(network.name),
-    amount,
-    asset: network.usdcAddress,
-    payTo: to,
-    maxTimeoutSeconds: expiry - Math.floor(Date.now() / 1e3)
-  };
   const x402Payload = createX402V2Payment({
     from,
     to,
     value: amount,
     nonce: `0x${nonce.padStart(64, "0")}`,
-    validAfter: "0x0",
+    validAfter: validAfterHex,
     validBefore: `0x${expiry.toString(16)}`,
     signature: combinedSig,
     network: defaultAccepted.network,
@@ -315,31 +299,111 @@ var extractNetworkFromRequirements = (requirements) => {
   }
   return network;
 };
+var getPaymentFailureDetail = async (response) => {
+  const text = (await response.clone().text()).trim();
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.message === "string" && parsed.message.trim()) {
+      return parsed.message.trim();
+    }
+    if (typeof parsed.error === "string" && parsed.error.trim()) {
+      return parsed.error.trim();
+    }
+  } catch {
+  }
+  return text;
+};
+var createPaymentVerificationError = async (response) => {
+  const detail = await getPaymentFailureDetail(response);
+  return new Error(
+    detail ? `Payment verification failed: ${detail}` : "Payment verification failed"
+  );
+};
 var createX402Client = (config) => {
   const state = createClientState(config);
+  const hooks = config.hooks;
   const fetch2 = async (url, init) => {
-    let response = await fetch2(url, init);
+    let response = await globalThis.fetch(url, init);
     if (response.status === 402) {
       const parsed = await parsePaymentRequired(response);
-      const selectedRequirements = parsed.requirements[0];
+      const selectedRequirements = parsed.requirements.find(
+        (requirement) => requirement.network === state.network?.caip2Id
+      ) ?? parsed.requirements[0];
       if (!selectedRequirements) {
         throw new Error("No supported payment scheme found in requirements");
       }
       const from = getAddress(state.account);
-      const req = selectedRequirements;
-      const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
-      const network = extractNetworkFromRequirements(req);
-      const result = await signPaymentV2(state, network, {
-        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);
-      paymentHeaders.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV2(result.payload));
-      response = await fetch2(url, { ...init, headers: paymentHeaders });
+      const paymentRequiredContext = {
+        url,
+        requestInit: init,
+        accepts: parsed.requirements,
+        requirements: selectedRequirements,
+        selectedRequirement: selectedRequirements,
+        serverExtensions: void 0,
+        fromAddress: from,
+        nonce: `0x${Date.now().toString(16).padStart(64, "0")}`,
+        validBefore: Math.floor(Date.now() / 1e3) + selectedRequirements.maxTimeoutSeconds
+      };
+      await runOnPaymentRequiredHooks(hooks, paymentRequiredContext);
+      const attemptRequirements = await getRequirementAttemptOrderWithHooks(
+        hooks,
+        paymentRequiredContext
+      );
+      let lastError;
+      for (const req of attemptRequirements) {
+        try {
+          const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
+          const attemptValidBefore = Math.floor(Date.now() / 1e3) + req.maxTimeoutSeconds;
+          const attemptContext = {
+            ...paymentRequiredContext,
+            requirements: req,
+            selectedRequirement: req,
+            validBefore: attemptValidBefore
+          };
+          const network = extractNetworkFromRequirements(req);
+          const result = await signPaymentV2(state, network, {
+            from,
+            to,
+            amount: req.amount,
+            nonce: crypto.randomUUID(),
+            expiry: attemptValidBefore,
+            accepted: req
+          });
+          await runBeforeSignPaymentHooks(hooks, {
+            payload: result.payload,
+            requirements: req,
+            wallet: state.account,
+            paymentContext: attemptContext
+          });
+          const paymentHeaders = new Headers(init?.headers);
+          paymentHeaders.set(
+            V2_HEADERS.PAYMENT_SIGNATURE,
+            encodePaymentV2(result.payload)
+          );
+          response = await globalThis.fetch(url, {
+            ...init,
+            headers: paymentHeaders
+          });
+          await runAfterPaymentResponseHooks(hooks, {
+            payload: result.payload,
+            requirements: req,
+            wallet: state.account,
+            paymentContext: attemptContext,
+            response
+          });
+          if (response.status === 402) {
+            lastError = await createPaymentVerificationError(response);
+            continue;
+          }
+          return response;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+        }
+      }
+      throw lastError ?? new Error("Payment verification failed");
     }
     return response;
   };
@@ -350,7 +414,9 @@ var createX402Client = (config) => {
     getVersion: () => state.version,
     signPayment: async (options) => {
       const network = state.network ?? (() => {
-        throw new Error("Network must be configured for manual payment signing");
+        throw new Error(
+          "Network must be configured for manual payment signing"
+        );
       })();
       const from = getAddress(state.account);
       const to = options.to;
@@ -361,14 +427,22 @@ var createX402Client = (config) => {
     },
     createPaymentHeaders: async (options) => {
       const network = state.network ?? (() => {
-        throw new Error("Network must be configured for manual payment signing");
+        throw new Error(
+          "Network must be configured for manual payment signing"
+        );
       })();
       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, network, { from, to, amount, nonce, expiry });
+      const result = await signPaymentV2(state, network, {
+        from,
+        to,
+        amount,
+        nonce,
+        expiry
+      });
       const headers = new Headers();
       headers.set("PAYMENT-SIGNATURE", encodePaymentV2(result.payload));
       return headers;
@@ -391,69 +465,8 @@ var createX402Client = (config) => {
     }
   };
 };
-var DEFAULT_MAX_RETRIES = 3;
-var createPaymentHeaders = (payload, _version) => {
-  const headers = new Headers();
-  headers.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV2(payload));
-  return headers;
-};
-var isPaymentRelatedError = (error) => error.message.includes("402") || error.message.includes("payment") || error.message.includes("signature") || error.message.includes("Payment");
-var backoff = (attempt) => {
-  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) => {
-  detectX402Version(response, client.getVersion());
-  const parsed = await parsePaymentRequired(response);
-  const selectedRequirements = parsed.requirements[0];
-  if (!selectedRequirements) {
-    throw new Error("No supported payment scheme found in requirements");
-  }
-  const req = selectedRequirements;
-  const result = await client.handlePaymentRequired(req);
-  return createPaymentHeaders(result.payload);
-};
-var mergePaymentHeaders = (init = {}, paymentHeaders) => {
-  const existingHeaders = new Headers(init.headers);
-  for (const [key, value] of paymentHeaders.entries()) {
-    existingHeaders.set(key, value);
-  }
-  return { ...init, headers: existingHeaders };
-};
-var createX402Transport = (options) => {
-  const client = options.client;
-  const autoSign = options.autoSign ?? true;
-  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-  return {
-    getClient: () => client,
-    fetch: async (url, init) => {
-      let attempt = 0;
-      let lastError;
-      while (attempt < maxRetries) {
-        attempt++;
-        try {
-          const response = await fetch(url, init);
-          if (isPaymentRequiredResponse(response) && autoSign) {
-            const paymentHeaders = await handlePaymentRequired(response, client);
-            const newInit = mergePaymentHeaders(init, paymentHeaders);
-            return await fetch(url, newInit);
-          }
-          return response;
-        } catch (error) {
-          lastError = error instanceof Error ? error : new Error(String(error));
-          if (!isPaymentRelatedError(lastError)) {
-            throw lastError;
-          }
-          if (attempt < maxRetries) {
-            await backoff(attempt);
-          }
-        }
-      }
-      throw lastError ?? new Error("Max retries exceeded");
-    }
-  };
-};
+
+// src/payment-api.ts
 var normalizeWallet = (wallet) => {
   if (typeof wallet === "object" && wallet !== null && "account" in wallet) {
     return wallet.account;
@@ -522,19 +535,37 @@ var armoryPay = async (wallet, url, network, token, options) => {
   }
 };
 var armoryGet = (wallet, url, network, token, options) => {
-  return armoryPay(wallet, url, network, token, { ...options, method: "GET" });
+  return armoryPay(wallet, url, network, token, {
+    ...options,
+    method: "GET"
+  });
 };
 var armoryPost = (wallet, url, network, token, body, options) => {
-  return armoryPay(wallet, url, network, token, { ...options, method: "POST", body });
+  return armoryPay(wallet, url, network, token, {
+    ...options,
+    method: "POST",
+    body
+  });
 };
 var armoryPut = (wallet, url, network, token, body, options) => {
-  return armoryPay(wallet, url, network, token, { ...options, method: "PUT", body });
+  return armoryPay(wallet, url, network, token, {
+    ...options,
+    method: "PUT",
+    body
+  });
 };
 var armoryDelete = (wallet, url, network, token, options) => {
-  return armoryPay(wallet, url, network, token, { ...options, method: "DELETE" });
+  return armoryPay(wallet, url, network, token, {
+    ...options,
+    method: "DELETE"
+  });
 };
 var armoryPatch = (wallet, url, network, token, body, options) => {
-  return armoryPay(wallet, url, network, token, { ...options, method: "PATCH", body });
+  return armoryPay(wallet, url, network, token, {
+    ...options,
+    method: "PATCH",
+    body
+  });
 };
 var getWalletAddress = (wallet) => {
   const account = normalizeWallet(wallet);
@@ -550,7 +581,7 @@ var validateNetwork = (network) => {
   return { success: true, network: resolved.config.name };
 };
 var validateToken = (token, network) => {
-  let resolvedNetwork = void 0;
+  let resolvedNetwork;
   if (network) {
     const networkResult = resolveNetwork(network);
     if (isValidationError(networkResult)) {
@@ -578,7 +609,13 @@ var getTokens = () => {
 };
 
 // src/armory-api.ts
-var ALL_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+var ALL_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH"
+]);
 var arrayify = (value) => {
   if (value === void 0) return void 0;
   return Array.isArray(value) ? value : [value];
@@ -634,5 +671,73 @@ var createArmory = (config) => {
     call: (url) => makeRequest(url, "GET")
   };
 };
+var DEFAULT_MAX_RETRIES = 3;
+var createPaymentHeaders = (payload, _version) => {
+  const headers = new Headers();
+  headers.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV2(payload));
+  return headers;
+};
+var isPaymentRelatedError = (error) => error.message.includes("402") || error.message.includes("payment") || error.message.includes("signature") || error.message.includes("Payment");
+var backoff = (attempt) => {
+  const baseDelay = Math.min(1e3 * 2 ** (attempt - 1), 1e4);
+  const jitter = Math.random() * 100;
+  return new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
+};
+var handlePaymentRequired = async (response, client) => {
+  detectX402Version(response, client.getVersion());
+  const parsed = await parsePaymentRequired(response);
+  const selectedRequirements = parsed.requirements.find(
+    (requirement) => requirement.network === client.getNetwork()?.caip2Id
+  ) ?? parsed.requirements[0];
+  if (!selectedRequirements) {
+    throw new Error("No supported payment scheme found in requirements");
+  }
+  const req = selectedRequirements;
+  const result = await client.handlePaymentRequired(req);
+  return createPaymentHeaders(result.payload);
+};
+var mergePaymentHeaders = (init = {}, paymentHeaders) => {
+  const existingHeaders = new Headers(init.headers);
+  for (const [key, value] of paymentHeaders.entries()) {
+    existingHeaders.set(key, value);
+  }
+  return { ...init, headers: existingHeaders };
+};
+var createX402Transport = (options) => {
+  const client = options.client;
+  const autoSign = options.autoSign ?? true;
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  return {
+    getClient: () => client,
+    fetch: async (url, init) => {
+      let attempt = 0;
+      let lastError;
+      while (attempt < maxRetries) {
+        attempt++;
+        try {
+          const response = await fetch(url, init);
+          if (isPaymentRequiredResponse(response) && autoSign) {
+            const paymentHeaders = await handlePaymentRequired(
+              response,
+              client
+            );
+            const newInit = mergePaymentHeaders(init, paymentHeaders);
+            return await fetch(url, newInit);
+          }
+          return response;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (!isPaymentRelatedError(lastError)) {
+            throw lastError;
+          }
+          if (attempt < maxRetries) {
+            await backoff(attempt);
+          }
+        }
+      }
+      throw lastError ?? new Error("Max retries exceeded");
+    }
+  };
+};
 
 export { adjustVForChainId, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, concatenateSignature, createArmory, createEIP712Domain, createTransferWithAuthorization, createX402Client, createX402Transport, getNetworks, getTokens, getWalletAddress, normalizeWallet, parseSignature, signTypedData, signWithPrivateKey, validateNetwork, validateToken, validateTransferWithAuthorization };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-web3",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [
@@ -46,7 +46,7 @@
     "directory": "packages/client-web3"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.28",
+    "@armory-sh/base": "0.2.30",
     "web3": "4.16.0",
     "web3-types": "1.10.0"
   },
@@ -56,6 +56,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup",
+    "lint": "bun run build",
+    "format": "bun run lint",
     "test": "bun test",
     "example": "bun run examples/"
   }