@armory-sh/base 0.2.21-alpha.3.16 → 0.2.21-alpha.3.17

package/dist/encoding/x402.d.ts

@@ -4,7 +4,7 @@
  * Payment payloads are JSON-encoded for transport in HTTP headers.
  * Matches the Coinbase x402 v2 SDK format.
  */
-import type { PaymentPayload, X402Response, PaymentPayloadV2, PaymentRequirements, SettlementResponse } from "../types/x402";
+import type { PaymentPayload, X402Response, PaymentRequirements, SettlementResponse } from "../types/x402";
 /**
  * Safe Base64 encode (URL-safe, no padding)
  */
@@ -16,7 +16,7 @@ export declare function safeBase64Decode(str: string): string;
 /**
  * Encode payment payload to JSON string
  */
-export declare function encodePayment(payload: PaymentPayload | PaymentPayloadV2): string;
+export declare function encodePayment(payload: PaymentPayload): string;
 /**
  * Decode payment payload from JSON string
  */
@@ -56,10 +56,6 @@ export declare function createPaymentRequiredHeaders(requirements: PaymentRequir
  * Create settlement response headers (V2 format)
  */
 export declare function createSettlementHeaders(settlement: SettlementResponse): Record<string, string>;
-/**
- * Type guard for legacy V2 payload (without x402Version)
- */
-export declare function isLegacyV2(payload: unknown): payload is PaymentPayloadV2;
 /**
  * Decode settlement from headers (V2 only)
  */

package/dist/fixtures/payloads.d.ts

@@ -1,13 +1,12 @@
 /**
  * Mock Payment Payloads for Testing (V2 Only)
  */
-import type { X402PayloadV2, PaymentPayloadV2 } from "@armory-sh/base";
+import type { PaymentPayloadV2 } from "@armory-sh/base";
 export declare const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000001";
 export declare const TEST_PAYER_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1";
 export declare const TEST_PAY_TO_ADDRESS = "0x1234567890123456789012345678901234567890";
 export declare const TEST_CONTRACT_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
 export declare const createX402V2Payload: (nonce?: string) => PaymentPayloadV2;
-export declare const createLegacyV2Payload: (nonce?: string) => X402PayloadV2;
 export declare const INVALID_PAYLOADS: {
     readonly missingFields: {};
     readonly invalidAddress: PaymentPayloadV2;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export type { Address as X402Address, Hex, X402Version, Scheme, Network as X402Network, ExactEvmAuthorization, ExactEvmPayload, PaymentPayload as X402PaymentPayload, UnsignedPaymentPayload as X402UnsignedPaymentPayload, PaymentRequirements as X402PaymentRequirements, SettlementResponse as X402SettlementResponse, VerifyResponse, X402Response, PaymentPayloadV2 as X402PayloadV2, LegacyPaymentPayload as X402LegacyPayload, } from "./types/x402";
-export { X402_VERSION, SCHEMES, isPaymentPayload, isExactEvmPayload, legacyToPaymentPayload, } from "./types/x402";
-export { safeBase64Encode, safeBase64Decode, encodePayment, decodePayment, encodeSettlementResponse, decodeSettlementResponse, encodeX402Response, decodeX402Response, detectPaymentVersion, extractPaymentFromHeaders, createPaymentRequiredHeaders, createSettlementHeaders, isLegacyV2, } from "./encoding/x402";
+export type { Address as X402Address, Hex, X402Version, Scheme, Network as X402Network, ExactEvmAuthorization, ExactEvmPayload, PaymentPayload as X402PaymentPayload, UnsignedPaymentPayload as X402UnsignedPaymentPayload, PaymentRequirements as X402PaymentRequirements, SettlementResponse as X402SettlementResponse, VerifyResponse, X402Response, } from "./types/x402";
+export { X402_VERSION, SCHEMES, isPaymentPayload, isExactEvmPayload, } from "./types/x402";
+export { safeBase64Encode, safeBase64Decode, encodePayment, decodePayment, encodeSettlementResponse, decodeSettlementResponse, encodeX402Response, decodeX402Response, detectPaymentVersion, extractPaymentFromHeaders, createPaymentRequiredHeaders, createSettlementHeaders, } from "./encoding/x402";
 export { createNonce, toAtomicUnits, fromAtomicUnits, caip2ToNetwork, networkToCaip2, getCurrentTimestamp, isValidAddress, normalizeAddress, } from "./utils/x402";
 export type { CAIP2Network as CAIP2ChainId, CAIPAssetId, Address, Signature, PayToV2, Extensions, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, PaymentRequiredV2, ResourceInfo, EIP3009Authorization, SchemePayloadV2, } from "./types/v2";
 export { V2_HEADERS, isCAIP2ChainId, isCAIPAssetId, isAddress, isPaymentRequiredV2, isPaymentPayloadV2, assetIdToAddress, addressToAssetId, parseSignature as parseSignatureV2, combineSignature as combineSignatureV2, } from "./types/v2";
 export type { PaymentPayload, PaymentRequirements, SettlementResponse, PaymentRequired, } from "./types/protocol";
-export { isX402V2Payload, isX402V2Requirements, isX402V2Settlement, isX402V2PaymentRequired, isLegacyV2Payload, isSettlementSuccessful, getTxHash, PAYMENT_SIGNATURE_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_REQUIRED_HEADER, } from "./types/protocol";
+export { isX402V2Payload, isX402V2Requirements, isX402V2Settlement, isX402V2PaymentRequired, isSettlementSuccessful, getTxHash, PAYMENT_SIGNATURE_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_REQUIRED_HEADER, } from "./types/protocol";
 export type { NetworkConfig, CustomToken } from "./types/networks";
 export { NETWORKS, getNetworkConfig, getNetworkByChainId, getMainnets, getTestnets, registerToken, getCustomToken, getAllCustomTokens, unregisterToken, isCustomToken, } from "./types/networks";
 export { TOKENS, USDC_BASE, EURC_BASE, USDC_BASE_SEPOLIA, USDC_SKALE_BASE, SKL_SKALE_BASE, USDT_SKALE_BASE, WBTC_SKALE_BASE, WETH_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, USDC_SKALE_BASE_SEPOLIA, USDT_SKALE_BASE_SEPOLIA, WBTC_SKALE_BASE_SEPOLIA, WETH_SKALE_BASE_SEPOLIA, getToken, getAllTokens, getTokensBySymbol, getTokensByChain, getUSDCTokens, getEURCTokens, getSKLTokens, getUSDTTokens, getWBTCTokens, getWETHTokens, } from "./data/tokens";
@@ -19,5 +19,7 @@ export { parseRoutePattern, matchRoute, findMatchingRoute, validateRouteConfig,
 export { encodePaymentV2, decodePaymentV2, encodeSettlementV2, decodeSettlementV2, isPaymentV2, isSettlementV2, } from "./encoding";
 export type { NetworkId, TokenId, FacilitatorConfig, FacilitatorVerifyResult, FacilitatorSettleResult, SettlementMode, PayToAddress, AcceptPaymentOptions, PricingConfig, PaymentResult, PaymentError, PaymentErrorCode, ArmoryPaymentResult, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, } from "./types/api";
 export type { PaymentRequiredContext, PaymentPayloadContext, HookResult, OnPaymentRequiredHook, BeforePaymentHook, ExtensionHook, HookConfig, HookRegistry, } from "./types/hooks";
-export { createX402V2Payload, createLegacyV2Payload, INVALID_PAYLOADS, TEST_PAYER_ADDRESS, TEST_PAY_TO_ADDRESS, TEST_CONTRACT_ADDRESS, TEST_PRIVATE_KEY, } from "./fixtures/payloads";
+export type { FacilitatorClientConfig, SupportedKind, SupportedResponse, } from "./payment-client";
+export { verifyPayment, settlePayment, getSupported, decodePayloadHeader, extractPayerAddress, } from "./payment-client";
+export { createX402V2Payload, INVALID_PAYLOADS, TEST_PAYER_ADDRESS, TEST_PAY_TO_ADDRESS, TEST_CONTRACT_ADDRESS, TEST_PRIVATE_KEY, } from "./fixtures/payloads";
 export { DEFAULT_PAYMENT_CONFIG, type TestPaymentConfig } from "./fixtures/config";

package/dist/index.js

@@ -1,110 +1,14 @@
 import { randomBytes } from 'crypto';
 
 // src/types/x402.ts
-var X402_VERSION = 1;
+var X402_VERSION = 2;
 var SCHEMES = ["exact"];
-var CHAIN_ID_TO_NETWORK = {
-  1: "ethereum",
-  8453: "base",
-  84532: "base-sepolia",
-  137: "polygon",
-  42161: "arbitrum",
-  421614: "arbitrum-sepolia",
-  10: "optimism",
-  11155420: "optimism-sepolia",
-  11155111: "ethereum-sepolia"
-};
 function isPaymentPayload(obj) {
   return typeof obj === "object" && obj !== null && "x402Version" in obj && "scheme" in obj && "network" in obj && "payload" in obj;
 }
 function isExactEvmPayload(obj) {
   return typeof obj === "object" && obj !== null && "signature" in obj && "authorization" in obj;
 }
-function extractNetworkFromLegacy(legacy) {
-  if ("network" in legacy && typeof legacy.network === "string") {
-    return legacy.network;
-  }
-  if ("chainId" in legacy && typeof legacy.chainId === "string") {
-    const match = legacy.chainId.match(/^eip155:(\d+)$/);
-    if (match) {
-      const chainId = parseInt(match[1], 10);
-      return CHAIN_ID_TO_NETWORK[chainId] || `eip155:${chainId}`;
-    }
-  }
-  if ("chainId" in legacy && typeof legacy.chainId === "number") {
-    return CHAIN_ID_TO_NETWORK[legacy.chainId] || `eip155:${legacy.chainId}`;
-  }
-  return "base";
-}
-function extractSignatureFromLegacy(legacy) {
-  if ("v" in legacy && "r" in legacy && "s" in legacy) {
-    const v = legacy.v.toString(16).padStart(2, "0");
-    const r = legacy.r.startsWith("0x") ? legacy.r.slice(2) : legacy.r;
-    const s = legacy.s.startsWith("0x") ? legacy.s.slice(2) : legacy.s;
-    return `0x${r}${s}${v}`;
-  }
-  if ("signature" in legacy && typeof legacy.signature === "object" && legacy.signature !== null) {
-    const sig = legacy.signature;
-    const v = sig.v.toString(16).padStart(2, "0");
-    const r = sig.r.startsWith("0x") ? sig.r.slice(2) : sig.r;
-    const s = sig.s.startsWith("0x") ? sig.s.slice(2) : sig.s;
-    return `0x${r}${s}${v}`;
-  }
-  return "0x";
-}
-function convertAmountToAtomic(amount) {
-  if (amount.includes(".")) {
-    const parts = amount.split(".");
-    const whole = parts[0];
-    const fractional = parts[1] || "";
-    const paddedFractional = fractional.padEnd(6, "0").slice(0, 6);
-    return `${whole}${paddedFractional}`;
-  }
-  return amount;
-}
-function convertNonceToHex(nonce) {
-  if (nonce.startsWith("0x") && nonce.length === 66) {
-    return nonce;
-  }
-  const hex = BigInt(nonce).toString(16).padStart(64, "0");
-  return `0x${hex}`;
-}
-function extractFromAddress(legacy) {
-  return legacy.from;
-}
-function extractToAddress(legacy) {
-  if ("to" in legacy && typeof legacy.to === "string") {
-    return legacy.to;
-  }
-  return legacy.from;
-}
-function legacyToPaymentPayload(legacy) {
-  if (isPaymentPayload(legacy)) {
-    return legacy;
-  }
-  const network = extractNetworkFromLegacy(legacy);
-  const signature = extractSignatureFromLegacy(legacy);
-  const value = convertAmountToAtomic(legacy.amount);
-  const nonce = convertNonceToHex(legacy.nonce);
-  const from = extractFromAddress(legacy);
-  const to = extractToAddress(legacy);
-  return {
-    x402Version: X402_VERSION,
-    scheme: "exact",
-    network,
-    payload: {
-      signature,
-      authorization: {
-        from,
-        to,
-        value,
-        validAfter: "0",
-        validBefore: legacy.expiry.toString(),
-        nonce
-      }
-    }
-  };
-}
 
 // src/types/v2.ts
 var V2_HEADERS = {
@@ -165,13 +69,10 @@ function safeBase64Decode(str) {
   return Buffer.from(str, "base64").toString("utf-8");
 }
 function encodePayment(payload) {
-  let normalizedPayload;
-  if (isPaymentPayload(payload)) {
-    normalizedPayload = payload;
-  } else {
-    normalizedPayload = legacyToPaymentPayload(payload);
+  if (!isPaymentPayload(payload)) {
+    throw new Error("Invalid payment payload format");
   }
-  const safePayload = JSON.parse(JSON.stringify(normalizedPayload, (_, value) => {
+  const safePayload = JSON.parse(JSON.stringify(payload, (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -180,10 +81,15 @@ function encodePayment(payload) {
   return safeBase64Encode(JSON.stringify(safePayload));
 }
 function decodePayment(encoded) {
-  const decoded = safeBase64Decode(encoded);
-  const parsed = JSON.parse(decoded);
+  let parsed;
+  try {
+    parsed = JSON.parse(encoded);
+  } catch {
+    const decoded = safeBase64Decode(encoded);
+    parsed = JSON.parse(decoded);
+  }
   if (!isPaymentPayload(parsed)) {
-    return legacyToPaymentPayload(parsed);
+    throw new Error("Invalid payment payload format");
   }
   return parsed;
 }
@@ -197,15 +103,23 @@ function encodeSettlementResponse(response) {
   return safeBase64Encode(JSON.stringify(safeResponse));
 }
 function decodeSettlementResponse(encoded) {
-  const decoded = safeBase64Decode(encoded);
-  return JSON.parse(decoded);
+  try {
+    return JSON.parse(encoded);
+  } catch {
+    const decoded = safeBase64Decode(encoded);
+    return JSON.parse(decoded);
+  }
 }
 function encodeX402Response(response) {
   return safeBase64Encode(JSON.stringify(response));
 }
 function decodeX402Response(encoded) {
-  const decoded = safeBase64Decode(encoded);
-  return JSON.parse(decoded);
+  try {
+    return JSON.parse(encoded);
+  } catch {
+    const decoded = safeBase64Decode(encoded);
+    return JSON.parse(decoded);
+  }
 }
 function detectPaymentVersion(headers) {
   if (headers.has("PAYMENT-SIGNATURE")) {
@@ -237,9 +151,6 @@ function createSettlementHeaders(settlement) {
     [V2_HEADERS.PAYMENT_RESPONSE]: encodeSettlementResponse(settlement)
   };
 }
-function isLegacyV2(payload) {
-  return typeof payload === "object" && payload !== null && "signature" in payload && typeof payload.signature === "object";
-}
 function createNonce() {
   const bytes = randomBytes(32);
   return `0x${bytes.toString("hex")}`;
@@ -315,12 +226,6 @@ function normalizeAddress(address) {
 function isX402V2Payload(obj) {
   return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "signature" in obj && "chainId" in obj && "assetId" in obj;
 }
-function isLegacyV2Payload(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const record = obj;
-  const signature = record.signature;
-  return "signature" in record && typeof signature === "object" && signature !== null && "v" in signature && "chainId" in record && typeof record.chainId === "string" && record.chainId.startsWith("eip155:") && "assetId" in record && !("x402Version" in record);
-}
 function isX402V2Requirements(obj) {
   return typeof obj === "object" && obj !== null && "scheme" in obj && obj.scheme === "exact" && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:") && // CAIP-2 format
   "amount" in obj && "asset" in obj && "payTo" in obj && "maxTimeoutSeconds" in obj;
@@ -1291,6 +1196,131 @@ var decodeSettlementV2 = (encoded) => base64JsonDecode(encoded);
 var isPaymentV2 = (payload) => "signature" in payload && typeof payload.signature === "object";
 var isSettlementV2 = (response) => "status" in response;
 
+// src/payment-client.ts
+var DEFAULT_FACILITATOR_URL = "https://facilitator.payai.network";
+function toJsonSafe(data) {
+  function convert(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, convert(val)]));
+    }
+    if (Array.isArray(value)) {
+      return value.map(convert);
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  }
+  return convert(data);
+}
+function resolveUrl(config) {
+  return config?.url ?? DEFAULT_FACILITATOR_URL;
+}
+async function resolveHeaders(config) {
+  const base = { "Content-Type": "application/json" };
+  if (!config?.createHeaders) return base;
+  const extra = await config.createHeaders();
+  return { ...base, ...extra };
+}
+async function verifyPayment(payload, requirements, config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/verify`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      x402Version: payload.x402Version,
+      paymentPayload: toJsonSafe(payload),
+      paymentRequirements: toJsonSafe(requirements)
+    })
+  });
+  if (response.status !== 200) {
+    const text = await response.text().catch(() => response.statusText);
+    throw new Error(`Facilitator verify failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function settlePayment(payload, requirements, config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/settle`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      x402Version: payload.x402Version,
+      paymentPayload: toJsonSafe(payload),
+      paymentRequirements: toJsonSafe(requirements)
+    })
+  });
+  if (response.status !== 200) {
+    const text = await response.text().catch(() => response.statusText);
+    throw new Error(`Facilitator settle failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+async function getSupported(config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/supported`, {
+    method: "GET",
+    headers
+  });
+  if (response.status !== 200) {
+    throw new Error(`Facilitator supported failed: ${response.statusText}`);
+  }
+  return await response.json();
+}
+function tryParseHeaderJson(headerValue) {
+  if (headerValue.startsWith("{")) {
+    return JSON.parse(headerValue);
+  }
+  const normalized = headerValue.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(headerValue.length / 4) * 4, "=");
+  return JSON.parse(Buffer.from(normalized, "base64").toString("utf-8"));
+}
+function isCompactV2Payload(payload) {
+  if (typeof payload !== "object" || payload === null) return false;
+  const record = payload;
+  return typeof record.x402Version === "number" && "payload" in record;
+}
+function decodePayloadHeader(headerValue, defaults) {
+  if (headerValue.startsWith("{")) {
+    const parsed = JSON.parse(headerValue);
+    if (isPaymentPayload(parsed)) return parsed;
+    if (isCompactV2Payload(parsed)) {
+      const compact = parsed;
+      return {
+        x402Version: 2,
+        scheme: defaults?.scheme ?? "exact",
+        network: defaults?.network ?? "base",
+        payload: compact.payload
+      };
+    }
+    throw new Error("Invalid payment payload: unrecognized format");
+  }
+  try {
+    return decodePayment(headerValue);
+  } catch {
+    const parsed = tryParseHeaderJson(headerValue);
+    if (isPaymentPayload(parsed)) return parsed;
+    if (isCompactV2Payload(parsed)) {
+      const compact = parsed;
+      return {
+        x402Version: 2,
+        scheme: defaults?.scheme ?? "exact",
+        network: defaults?.network ?? "base",
+        payload: compact.payload
+      };
+    }
+    throw new Error("Invalid payment payload: unrecognized format");
+  }
+}
+function extractPayerAddress(payload) {
+  if (isExactEvmPayload(payload.payload)) {
+    return payload.payload.authorization.from;
+  }
+  throw new Error("Unable to extract payer address from payload");
+}
+
 // src/fixtures/payloads.ts
 var TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000001";
 var TEST_PAYER_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1";
@@ -1318,20 +1348,6 @@ var createX402V2Payload = (nonce) => ({
     description: "Test resource"
   }
 });
-var createLegacyV2Payload = (nonce) => ({
-  from: TEST_PAYER_ADDRESS,
-  to: TEST_PAY_TO_ADDRESS,
-  amount: "1000000",
-  nonce: nonce ?? "test_legacy_v2_nonce",
-  expiry: Math.floor(Date.now() / 1e3) + 3600,
-  signature: {
-    v: 27,
-    r: `0x${"f".repeat(64)}`,
-    s: `0x${"0".repeat(64)}`
-  },
-  chainId: "eip155:84532",
-  assetId: `eip155:84532/erc20:${TEST_CONTRACT_ADDRESS.slice(2)}`
-});
 var INVALID_PAYLOADS = {
   missingFields: {},
   invalidAddress: {
@@ -1381,4 +1397,4 @@ var DEFAULT_PAYMENT_CONFIG = {
   }
 };
 
-export { DEFAULT_PAYMENT_CONFIG, EIP712_TYPES, ERC20_ABI, EURC_BASE, INVALID_PAYLOADS, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, TEST_CONTRACT_ADDRESS, TEST_PAYER_ADDRESS, TEST_PAY_TO_ADDRESS, TEST_PRIVATE_KEY, TOKENS, USDC_BASE, USDC_BASE_SEPOLIA, USDC_DOMAIN, USDC_SKALE_BASE, USDC_SKALE_BASE_SEPOLIA, USDT_SKALE_BASE, USDT_SKALE_BASE_SEPOLIA, V2_HEADERS, WBTC_SKALE_BASE, WBTC_SKALE_BASE_SEPOLIA, WETH_SKALE_BASE, WETH_SKALE_BASE_SEPOLIA, X402_VERSION, addressToAssetId, assetIdToAddress, caip2ToNetwork, checkFacilitatorSupport, combineSignature as combineSignatureV2, createEIP712Domain, createError, createLegacyV2Payload, createNonce, createPaymentRequiredHeaders, createSettlementHeaders, createTransferWithAuthorization, createX402V2Payload, decodePayment, decodePaymentV2, decodeSettlementResponse, decodeSettlementV2, decodeX402Response, detectPaymentVersion, encodePayment, encodePaymentV2, encodeSettlementResponse, encodeSettlementV2, encodeX402Response, extractPaymentFromHeaders, findMatchingRoute, fromAtomicUnits, getAllCustomTokens, getAllTokens, getAvailableNetworks, getAvailableTokens, getCurrentTimestamp, getCustomToken, getEURCTokens, getMainnets, getNetworkByChainId, getNetworkConfig, getSKLTokens, getTestnets, getToken, getTokensByChain, getTokensBySymbol, getTxHash, getUSDCTokens, getUSDTTokens, getWBTCTokens, getWETHTokens, isAddress, isCAIP2ChainId, isCAIPAssetId, isCustomToken, isExactEvmPayload, isLegacyV2, isLegacyV2Payload, isPaymentPayload, isPaymentPayloadV2, isPaymentRequiredV2, isPaymentV2, isResolvedNetwork, isResolvedToken, isSettlementSuccessful, isSettlementV2, isValidAddress, isValidationError, isX402V2Payload, isX402V2PaymentRequired, isX402V2Requirements, isX402V2Settlement, legacyToPaymentPayload, matchRoute, networkToCaip2, normalizeAddress, normalizeNetworkName, parseRoutePattern, parseSignature as parseSignatureV2, registerToken, resolveFacilitator, resolveNetwork, resolveToken, safeBase64Decode, safeBase64Encode, toAtomicUnits, unregisterToken, validateAcceptConfig, validatePaymentConfig, validateRouteConfig, validateTransferWithAuthorization };
+export { DEFAULT_PAYMENT_CONFIG, EIP712_TYPES, ERC20_ABI, EURC_BASE, INVALID_PAYLOADS, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, TEST_CONTRACT_ADDRESS, TEST_PAYER_ADDRESS, TEST_PAY_TO_ADDRESS, TEST_PRIVATE_KEY, TOKENS, USDC_BASE, USDC_BASE_SEPOLIA, USDC_DOMAIN, USDC_SKALE_BASE, USDC_SKALE_BASE_SEPOLIA, USDT_SKALE_BASE, USDT_SKALE_BASE_SEPOLIA, V2_HEADERS, WBTC_SKALE_BASE, WBTC_SKALE_BASE_SEPOLIA, WETH_SKALE_BASE, WETH_SKALE_BASE_SEPOLIA, X402_VERSION, addressToAssetId, assetIdToAddress, caip2ToNetwork, checkFacilitatorSupport, combineSignature as combineSignatureV2, createEIP712Domain, createError, createNonce, createPaymentRequiredHeaders, createSettlementHeaders, createTransferWithAuthorization, createX402V2Payload, decodePayloadHeader, decodePayment, decodePaymentV2, decodeSettlementResponse, decodeSettlementV2, decodeX402Response, detectPaymentVersion, encodePayment, encodePaymentV2, encodeSettlementResponse, encodeSettlementV2, encodeX402Response, extractPayerAddress, extractPaymentFromHeaders, findMatchingRoute, fromAtomicUnits, getAllCustomTokens, getAllTokens, getAvailableNetworks, getAvailableTokens, getCurrentTimestamp, getCustomToken, getEURCTokens, getMainnets, getNetworkByChainId, getNetworkConfig, getSKLTokens, getSupported, getTestnets, getToken, getTokensByChain, getTokensBySymbol, getTxHash, getUSDCTokens, getUSDTTokens, getWBTCTokens, getWETHTokens, isAddress, isCAIP2ChainId, isCAIPAssetId, isCustomToken, isExactEvmPayload, isPaymentPayload, isPaymentPayloadV2, isPaymentRequiredV2, isPaymentV2, isResolvedNetwork, isResolvedToken, isSettlementSuccessful, isSettlementV2, isValidAddress, isValidationError, isX402V2Payload, isX402V2PaymentRequired, isX402V2Requirements, isX402V2Settlement, matchRoute, networkToCaip2, normalizeAddress, normalizeNetworkName, parseRoutePattern, parseSignature as parseSignatureV2, registerToken, resolveFacilitator, resolveNetwork, resolveToken, safeBase64Decode, safeBase64Encode, settlePayment, toAtomicUnits, unregisterToken, validateAcceptConfig, validatePaymentConfig, validateRouteConfig, validateTransferWithAuthorization, verifyPayment };

package/dist/payment-client.d.ts

@@ -0,0 +1,24 @@
+import type { PaymentPayload, PaymentRequirements, VerifyResponse, SettlementResponse } from "./types/x402";
+export interface FacilitatorClientConfig {
+    url: string;
+    createHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+}
+export declare function verifyPayment(payload: PaymentPayload, requirements: PaymentRequirements, config?: FacilitatorClientConfig): Promise<VerifyResponse>;
+export declare function settlePayment(payload: PaymentPayload, requirements: PaymentRequirements, config?: FacilitatorClientConfig): Promise<SettlementResponse>;
+export interface SupportedKind {
+    x402Version: number;
+    scheme: string;
+    network: string;
+    extra?: Record<string, unknown>;
+}
+export interface SupportedResponse {
+    kinds: SupportedKind[];
+}
+interface DecodePayloadDefaults {
+    scheme?: string;
+    network?: string;
+}
+export declare function getSupported(config?: FacilitatorClientConfig): Promise<SupportedResponse>;
+export declare function decodePayloadHeader(headerValue: string, defaults?: DecodePayloadDefaults): PaymentPayload;
+export declare function extractPayerAddress(payload: PaymentPayload): string;
+export {};

package/dist/types/protocol.d.ts

@@ -53,10 +53,6 @@ export type CAIPAssetId = `eip155:${string}/erc20:${string}`;
  * Check if payload is x402 V2 format (Coinbase format)
  */
 export declare function isX402V2Payload(obj: unknown): obj is PaymentPayloadV2;
-/**
- * Check if payload is legacy Armory V2 format
- */
-export declare function isLegacyV2Payload(obj: unknown): boolean;
 /**
  * Check if requirements is x402 V2 format
  */

package/dist/types/x402.d.ts

@@ -6,7 +6,7 @@
  */
 export type Address = `0x${string}`;
 export type Hex = `0x${string}`;
-export declare const X402_VERSION: 1;
+export declare const X402_VERSION: 2;
 export type X402Version = typeof X402_VERSION;
 export declare const SCHEMES: readonly ["exact"];
 export type Scheme = (typeof SCHEMES)[number];
@@ -92,44 +92,8 @@ export interface X402Response {
     accepts?: PaymentRequirements[];
     payer?: Address;
 }
-export interface PaymentPayloadV1 {
-    from: string;
-    to: string;
-    amount: string;
-    nonce: string;
-    expiry: number;
-    v: number;
-    r: string;
-    s: string;
-    chainId: number;
-    contractAddress: string;
-    network: string;
-}
-export interface PaymentPayloadV2 {
-    from: Address;
-    to: Address | {
-        role?: string;
-        callback?: string;
-    };
-    amount: string;
-    nonce: string;
-    expiry: number;
-    signature: {
-        v: number;
-        r: string;
-        s: string;
-    };
-    chainId: `eip155:${string}`;
-    assetId: `eip155:${string}/erc20:${string}`;
-    extensions?: Record<string, unknown>;
-}
-export type LegacyPaymentPayload = PaymentPayloadV1 | PaymentPayloadV2;
 /**
  * Type guards
  */
 export declare function isPaymentPayload(obj: unknown): obj is PaymentPayload;
 export declare function isExactEvmPayload(obj: unknown): obj is ExactEvmPayload;
-/**
- * Convert legacy payload to new format
- */
-export declare function legacyToPaymentPayload(legacy: LegacyPaymentPayload | PaymentPayload): PaymentPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/base",
-  "version": "0.2.21-alpha.3.16",
+  "version": "0.2.21-alpha.3.17",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",

package/dist/types/v1.d.ts

@@ -1,156 +0,0 @@
-/**
- * Armory V1 Types - x402 Protocol V1 Compatible
- *
- * Supports both the x402 V1 specification format and legacy Armory V1 format.
- *
- * x402 V1 Specification: https://github.com/coinbase/x402
- */
-import type { Address } from "./v2";
-/**
- * Network name for x402 V1 (e.g., "base-sepolia", "ethereum-mainnet")
- */
-export type X402V1Network = string;
-/**
- * EIP-3009 authorization data (same format for V1 and V2)
- */
-export interface EIP3009AuthorizationV1 {
-    from: Address;
-    to: Address;
-    value: string;
-    validAfter: string;
-    validBefore: string;
-    nonce: `0x${string}`;
-}
-/**
- * Payment requirements for a specific payment method (x402 V1)
- */
-export interface X402PaymentRequirementsV1 {
-    scheme: "exact";
-    network: X402V1Network;
-    maxAmountRequired: string;
-    asset: Address;
-    payTo: Address;
-    resource: string;
-    description: string;
-    mimeType?: string;
-    outputSchema?: object | null;
-    maxTimeoutSeconds: number;
-    extra?: Record<string, unknown>;
-}
-/**
- * Payment requirements response (x402 V1)
- * Matches x402 V1 PaymentRequirementsResponse spec
- */
-export interface X402PaymentRequiredV1 {
-    x402Version: 1;
-    error: string;
-    accepts: X402PaymentRequirementsV1[];
-}
-/**
- * Scheme payload data (x402 V1)
- */
-export interface X402SchemePayloadV1 {
-    signature: `0x${string}`;
-    authorization: EIP3009AuthorizationV1;
-}
-/**
- * Payment payload (x402 V1)
- * Matches x402 V1 PaymentPayload spec
- */
-export interface X402PaymentPayloadV1 {
-    x402Version: 1;
-    scheme: "exact";
-    network: X402V1Network;
-    payload: X402SchemePayloadV1;
-}
-/**
- * Settlement response (x402 V1)
- * Matches x402 V1 SettlementResponse spec
- */
-export interface X402SettlementResponseV1 {
-    success: boolean;
-    errorReason?: string;
-    transaction: string;
-    network: X402V1Network;
-    payer: Address;
-}
-/**
- * Legacy Armory V1 payment payload format
- * @deprecated Use X402PaymentPayloadV1 for new code
- */
-export interface LegacyPaymentPayloadV1 {
-    from: string;
-    to: string;
-    amount: string;
-    nonce: string;
-    expiry: number;
-    v: number;
-    r: string;
-    s: string;
-    chainId: number;
-    contractAddress: string;
-    network: string;
-}
-/**
- * Legacy Armory V1 payment requirements format
- * @deprecated Use X402PaymentRequirementsV1 for new code
- */
-export interface LegacyPaymentRequirementsV1 {
-    amount: string;
-    network: string;
-    contractAddress: string;
-    payTo: string;
-    expiry: number;
-}
-/**
- * Legacy Armory V1 settlement response format
- * @deprecated Use X402SettlementResponseV1 for new code
- */
-export interface LegacySettlementResponseV1 {
-    success: boolean;
-    txHash?: string;
-    error?: string;
-    timestamp: number;
-}
-export type PaymentPayloadV1 = X402PaymentPayloadV1 | LegacyPaymentPayloadV1;
-export type PaymentRequirementsV1 = X402PaymentRequirementsV1 | LegacyPaymentRequirementsV1;
-export type SettlementResponseV1 = X402SettlementResponseV1 | LegacySettlementResponseV1;
-export declare const V1_HEADERS: {
-    readonly PAYMENT: "X-PAYMENT";
-    readonly PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE";
-    readonly PAYMENT_REQUIRED: "X-PAYMENT-REQUIRED";
-};
-export declare function encodeX402PaymentRequiredV1(data: X402PaymentRequiredV1): string;
-export declare function decodeX402PaymentRequiredV1(encoded: string): X402PaymentRequiredV1;
-export declare function encodeX402PaymentPayloadV1(data: X402PaymentPayloadV1): string;
-export declare function decodeX402PaymentPayloadV1(encoded: string): X402PaymentPayloadV1;
-export declare function encodeX402SettlementResponseV1(data: X402SettlementResponseV1): string;
-export declare function decodeX402SettlementResponseV1(encoded: string): X402SettlementResponseV1;
-/**
- * @deprecated Use encodeX402PaymentPayloadV1 instead
- */
-export declare function encodePaymentPayloadLegacy(payload: LegacyPaymentPayloadV1): string;
-/**
- * @deprecated Use decodeX402PaymentPayloadV1 instead
- */
-export declare function decodePaymentPayloadLegacy(encoded: string): LegacyPaymentPayloadV1;
-/**
- * @deprecated Use encodeX402SettlementResponseV1 instead
- */
-export declare function encodeSettlementResponseLegacy(response: LegacySettlementResponseV1): string;
-/**
- * @deprecated Use decodeX402SettlementResponseV1 instead
- */
-export declare function decodeSettlementResponseLegacy(encoded: string): LegacySettlementResponseV1;
-/**
- * Check if value is x402 V1 PaymentRequired
- */
-export declare function isX402PaymentRequiredV1(obj: unknown): obj is X402PaymentRequiredV1;
-/**
- * Check if value is x402 V1 PaymentPayload
- */
-export declare function isX402PaymentPayloadV1(obj: unknown): obj is X402PaymentPayloadV1;
-/**
- * Check if value is legacy Armory V1 format
- */
-export declare function isLegacyPaymentPayloadV1(obj: unknown): obj is LegacyPaymentPayloadV1;