@armory-sh/base 0.2.27-alpha.23.73 → 0.2.27-alpha.23.76

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class X402ClientError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class SigningError extends X402ClientError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class PaymentException extends X402ClientError {
+    constructor(message: string, cause?: unknown);
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { X402_VERSION, SCHEMES, isPaymentPayload, isExactEvmPayload, } from "./t
 export { safeBase64Encode, safeBase64Decode, encodePayment, decodePayment, encodeSettlementResponse, decodeSettlementResponse, encodeX402Response, decodeX402Response, detectPaymentVersion, extractPaymentFromHeaders, createPaymentRequiredHeaders, createSettlementHeaders, } from "./encoding/x402";
 export type { PaymentRequiredOptions } from "./encoding/x402";
 export { createNonce, toAtomicUnits, fromAtomicUnits, caip2ToNetwork, networkToCaip2, getCurrentTimestamp, isValidAddress, normalizeAddress, } from "./utils/x402";
+export { encodeUtf8ToBase64, decodeBase64ToUtf8, toBase64Url, normalizeBase64Url, } from "./utils/base64";
 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";
@@ -22,3 +23,8 @@ export type { NetworkId, TokenId, FacilitatorConfig, FacilitatorVerifyResult, Fa
 export type { PaymentRequiredContext, PaymentPayloadContext, HookResult, OnPaymentRequiredHook, BeforePaymentHook, ExtensionHook, HookConfig, HookRegistry, } from "./types/hooks";
 export type { FacilitatorClientConfig, SupportedKind, SupportedResponse, } from "./payment-client";
 export { verifyPayment, settlePayment, getSupported, decodePayloadHeader, extractPayerAddress, } from "./payment-client";
+export { createPaymentRequirements, findRequirementByNetwork, } from "./payment-requirements";
+export type { PaymentConfig, ResolvedRequirementsConfig, } from "./payment-requirements";
+export { X402ClientError, SigningError, PaymentException, } from "./errors";
+export { parseJsonOrBase64, detectX402Version, getPaymentHeaderName, generateNonce, calculateValidBefore, } from "./protocol";
+export type { PaymentWallet } from "./types/wallet";

package/dist/index.js

@@ -1350,4 +1350,196 @@ function extractPayerAddress(payload) {
   throw new Error("Unable to extract payer address from payload");
 }
 
-export { EIP712_TYPES, ERC20_ABI, EURC_BASE, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, 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, 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 };
+// src/payment-requirements.ts
+var DEFAULT_NETWORKS = [
+  "ethereum",
+  "base",
+  "base-sepolia",
+  "skale-base",
+  "skale-base-sepolia",
+  "ethereum-sepolia"
+];
+var DEFAULT_TOKENS = ["usdc"];
+var isValidationError2 = (value) => {
+  return typeof value === "object" && value !== null && "code" in value;
+};
+function resolvePayTo(config, network, token) {
+  const chainId = network.config.chainId;
+  if (config.payToByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(config.payToByToken)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        for (const [tokenKey2, address] of Object.entries(tokenMap)) {
+          const resolvedToken = resolveToken(tokenKey2, network);
+          if (!isValidationError2(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
+            return address;
+          }
+        }
+      }
+    }
+  }
+  if (config.payToByChain) {
+    for (const [chainKey, address] of Object.entries(config.payToByChain)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return address;
+      }
+    }
+  }
+  return config.payTo;
+}
+function resolveFacilitatorUrl(config, network, token) {
+  const chainId = network.config.chainId;
+  if (config.facilitatorUrlByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(config.facilitatorUrlByToken)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        for (const [tokenKey2, url] of Object.entries(tokenMap)) {
+          const resolvedToken = resolveToken(tokenKey2, network);
+          if (!isValidationError2(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
+            return url;
+          }
+        }
+      }
+    }
+  }
+  if (config.facilitatorUrlByChain) {
+    for (const [chainKey, url] of Object.entries(config.facilitatorUrlByChain)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return url;
+      }
+    }
+  }
+  return config.facilitatorUrl;
+}
+function resolveNetworks(chainInputs) {
+  const resolvedNetworks = [];
+  const errors = [];
+  const networks = chainInputs?.length ? chainInputs : DEFAULT_NETWORKS;
+  for (const networkId of networks) {
+    const resolved = resolveNetwork(networkId);
+    if (isValidationError2(resolved)) {
+      errors.push(`Network "${networkId}": ${resolved.message}`);
+    } else {
+      resolvedNetworks.push(resolved);
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      networks: resolvedNetworks,
+      error: {
+        code: "VALIDATION_FAILED",
+        message: errors.join("; ")
+      }
+    };
+  }
+  return { networks: resolvedNetworks };
+}
+function createPaymentRequirements(config) {
+  const {
+    payTo,
+    chains,
+    chain,
+    tokens,
+    token,
+    amount = "1.0",
+    maxTimeoutSeconds = 300
+  } = config;
+  const chainInputs = chain ? [chain] : chains;
+  const tokenInputs = token ? [token] : tokens;
+  const { networks, error: networksError } = resolveNetworks(chainInputs);
+  if (networksError) {
+    return { requirements: [], error: networksError };
+  }
+  const requirements = [];
+  for (const network of networks) {
+    const tokensToResolve = tokenInputs?.length ? tokenInputs : DEFAULT_TOKENS;
+    for (const tokenId of tokensToResolve) {
+      const resolvedToken = resolveToken(tokenId, network);
+      if (isValidationError2(resolvedToken)) {
+        continue;
+      }
+      const atomicAmount = toAtomicUnits(amount);
+      const tokenConfig = resolvedToken.config;
+      const resolvedPayTo = resolvePayTo(config, network, resolvedToken);
+      resolveFacilitatorUrl(config, network, resolvedToken);
+      const requirement = {
+        scheme: "exact",
+        network: network.caip2,
+        amount: atomicAmount,
+        asset: tokenConfig.contractAddress,
+        payTo: resolvedPayTo,
+        maxTimeoutSeconds,
+        extra: {
+          name: tokenConfig.name,
+          version: tokenConfig.version
+        }
+      };
+      requirements.push(requirement);
+    }
+  }
+  if (requirements.length === 0) {
+    return {
+      requirements: [],
+      error: {
+        code: "VALIDATION_FAILED",
+        message: "No valid network/token combinations found"
+      }
+    };
+  }
+  return { requirements };
+}
+function findRequirementByNetwork(requirements, network) {
+  const normalized = normalizeNetworkName(network);
+  const netConfig = getNetworkConfig(normalized);
+  if (!netConfig) return void 0;
+  return requirements.find((r) => r.network === netConfig.caip2Id);
+}
+
+// src/errors.ts
+var X402ClientError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "X402ClientError";
+    this.cause = cause;
+  }
+};
+var SigningError = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Signing failed: ${message}`, cause);
+    this.name = "SigningError";
+  }
+};
+var PaymentException = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Payment failed: ${message}`, cause);
+    this.name = "PaymentException";
+  }
+};
+
+// src/protocol.ts
+function parseJsonOrBase64(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    const normalized = normalizeBase64Url(value);
+    return JSON.parse(decodeBase64ToUtf8(normalized));
+  }
+}
+function detectX402Version(_response) {
+  return 2;
+}
+function getPaymentHeaderName(_version) {
+  return V2_HEADERS.PAYMENT_SIGNATURE;
+}
+function generateNonce() {
+  const now = Math.floor(Date.now() / 1e3);
+  return `0x${(now * 1e3).toString(16).padStart(64, "0")}`;
+}
+function calculateValidBefore(expirySeconds = 3600) {
+  return Math.floor(Date.now() / 1e3) + expirySeconds;
+}
+
+export { EIP712_TYPES, ERC20_ABI, EURC_BASE, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, PaymentException, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, SigningError, 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, X402ClientError, X402_VERSION, addressToAssetId, assetIdToAddress, caip2ToNetwork, calculateValidBefore, checkFacilitatorSupport, combineSignature as combineSignatureV2, createEIP712Domain, createError, createNonce, createPaymentRequiredHeaders, createPaymentRequirements, createSettlementHeaders, createTransferWithAuthorization, decodeBase64ToUtf8, decodePayloadHeader, decodePayment, decodePaymentV2, decodeSettlementResponse, decodeSettlementV2, decodeX402Response, detectPaymentVersion, detectX402Version, encodePayment, encodePaymentV2, encodeSettlementResponse, encodeSettlementV2, encodeUtf8ToBase64, encodeX402Response, extractPayerAddress, extractPaymentFromHeaders, findMatchingRoute, findRequirementByNetwork, fromAtomicUnits, generateNonce, getAllCustomTokens, getAllTokens, getAvailableNetworks, getAvailableTokens, getCurrentTimestamp, getCustomToken, getEURCTokens, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, 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, normalizeBase64Url, normalizeNetworkName, parseJsonOrBase64, parseRoutePattern, parseSignature as parseSignatureV2, registerToken, resolveFacilitator, resolveNetwork, resolveToken, safeBase64Decode, safeBase64Encode, settlePayment, toAtomicUnits, toBase64Url, unregisterToken, validateAcceptConfig, validatePaymentConfig, validateRouteConfig, validateTransferWithAuthorization, verifyPayment };

package/dist/payment-requirements.d.ts

@@ -0,0 +1,22 @@
+import type { PaymentRequirementsV2, Address } from "./types/v2";
+import type { NetworkId, TokenId, ValidationError } from "./types/api";
+export interface PaymentConfig {
+    payTo: Address | string;
+    chains?: NetworkId[];
+    chain?: NetworkId;
+    tokens?: TokenId[];
+    token?: TokenId;
+    amount?: string;
+    maxTimeoutSeconds?: number;
+    payToByChain?: Record<string, Address | string>;
+    payToByToken?: Record<string, Record<string, Address | string>>;
+    facilitatorUrl?: string;
+    facilitatorUrlByChain?: Record<string, string>;
+    facilitatorUrlByToken?: Record<string, Record<string, string>>;
+}
+export interface ResolvedRequirementsConfig {
+    requirements: PaymentRequirementsV2[];
+    error?: ValidationError;
+}
+export declare function createPaymentRequirements(config: PaymentConfig): ResolvedRequirementsConfig;
+export declare function findRequirementByNetwork(requirements: PaymentRequirementsV2[], network: string): PaymentRequirementsV2 | undefined;

package/dist/protocol.d.ts

@@ -0,0 +1,33 @@
+/**
+ * X402 Protocol Utilities (V2 Only)
+ *
+ * Shared protocol utilities for x402 client implementations.
+ * These functions are protocol-level and don't depend on wallet libraries.
+ */
+/**
+ * Parse JSON or Base64-encoded JSON
+ * Handles both raw JSON and Base64URL-encoded JSON
+ */
+export declare function parseJsonOrBase64(value: string): unknown;
+/**
+ * Detect x402 protocol version from response
+ * V2-only: Always returns 2
+ */
+export declare function detectX402Version(_response: Response): 2;
+/**
+ * Get payment header name for protocol version
+ * V2-only: Returns PAYMENT-SIGNATURE header name
+ */
+export declare function getPaymentHeaderName(_version: 2): string;
+/**
+ * Generate a timestamp-based nonce as hex string
+ * Matches Coinbase SDK format: "0x" + 64 hex characters
+ * Uses timestamp for reproducibility (vs random)
+ */
+export declare function generateNonce(): `0x${string}`;
+/**
+ * Calculate expiry timestamp
+ * @param expirySeconds - Seconds from now (default: 3600 = 1 hour)
+ * @returns Unix timestamp
+ */
+export declare function calculateValidBefore(expirySeconds?: number): number;

package/dist/types/wallet.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generic Wallet Adapter Interface
+ *
+ * This interface defines the minimum wallet operations required
+ * for x402 payment signing. Each client package implements this
+ * interface for their specific wallet library (viem, ethers, etc.).
+ */
+export interface PaymentWallet {
+    /**
+     * Get the wallet address
+     * Can be synchronous or asynchronous depending on the wallet library
+     */
+    getAddress(): string | Promise<string>;
+    /**
+     * Sign EIP-712 typed data
+     * Used for EIP-3009 TransferWithAuthorization signatures
+     *
+     * @param domain - EIP-712 domain separator
+     * @param types - EIP-712 type definitions
+     * @param value - Message to sign
+     * @returns Signature as hex string (0x-prefixed)
+     */
+    signTypedData(domain: Record<string, unknown>, types: Record<string, unknown>, value: Record<string, unknown>): Promise<string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/base",
-  "version": "0.2.27-alpha.23.73",
+  "version": "0.2.27-alpha.23.76",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [