@armory-sh/base 0.2.12 → 0.2.13

package/dist/eip712.d.ts

@@ -19,6 +19,7 @@ export interface TransferWithAuthorization {
     validBefore: bigint;
     nonce: bigint;
 }
+export type TransferWithAuthorizationRecord = TransferWithAuthorization & Record<string, unknown>;
 export type TypedDataField = {
     name: string;
     type: string;
@@ -57,5 +58,5 @@ export declare const createTransferWithAuthorization: (params: Omit<TransferWith
     validAfter: bigint | number;
     validBefore: bigint | number;
     nonce: bigint | number;
-}) => TransferWithAuthorization;
+}) => TransferWithAuthorizationRecord;
 export declare const validateTransferWithAuthorization: (message: TransferWithAuthorization) => boolean;

package/dist/fixtures/config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Test Configuration
+ *
+ * Shared configuration for E2E tests including network configs,
+ * test keys, and facilitator URLs.
+ */
+export declare const TEST_PRIVATE_KEY: `0x${string}`;
+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 TEST_NETWORK: "base-sepolia";
+export declare const TEST_CHAIN_ID: 84532;
+export declare const TEST_CAIP2_NETWORK: "eip155:84532";
+export declare const TEST_ASSET_ID: "eip155:84532/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+export declare const TEST_AMOUNT: "1000000";
+export declare const TEST_AMOUNT_DECIMAL: "1.0";
+export declare const FACILITATOR_URL: string;
+export declare const MOCK_FACILITATOR_PORT = 8899;
+export declare const TEST_TIMEOUT_MS = 30000;
+export declare const SERVER_STARTUP_DELAY_MS = 100;
+export declare const SETTLEMENT_TIMEOUT_MS = 10000;
+export declare const TEST_RPC_URL: string;
+export interface TestPaymentConfig {
+    payTo: `0x${string}`;
+    amount: string;
+    network: string;
+    defaultVersion: 1 | 2;
+    accept: {
+        networks: string[];
+        tokens: string[];
+        facilitators: Array<{
+            url: string;
+        }>;
+    };
+}
+export declare const DEFAULT_PAYMENT_CONFIG: TestPaymentConfig;
+/**
+ * Get a random port for test servers
+ */
+export declare const getRandomPort: () => number;
+/**
+ * Create a test nonce with timestamp
+ */
+export declare const createTestNonce: (prefix: string) => string;
+/**
+ * Sleep for specified milliseconds
+ */
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/fixtures/payloads.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mock Payment Payloads for Testing
+ */
+import type { X402PaymentPayloadV1, X402PayloadV2, PaymentPayloadV2 } from "@armory-sh/base";
+export declare const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000000001";
+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 createX402V1Payload: (nonce?: string) => X402PaymentPayloadV1;
+export declare const createFaremeterPayload: (nonce?: string) => X402PaymentPayloadV1;
+export declare const createX402V2Payload: (nonce?: string) => PaymentPayloadV2;
+export declare const createLegacyV2Payload: (nonce?: string) => X402PayloadV2;
+export declare const INVALID_PAYLOADS: {
+    readonly missingFields: {};
+    readonly invalidAddress: PaymentPayloadV2;
+    readonly expired: PaymentPayloadV2;
+    readonly malformedSignature: PaymentPayloadV2;
+};

package/dist/fixtures/requirements.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Mock Payment Requirements for Testing
+ */
+import type { X402PaymentRequirementsV1, PaymentRequirementsV2 } from "@armory-sh/base";
+export declare const MOCK_X402_V1_REQUIREMENTS: X402PaymentRequirementsV1;
+export declare const createX402V1Requirements: (overrides?: Partial<X402PaymentRequirementsV1>) => X402PaymentRequirementsV1;
+export declare const MOCK_X402_V2_REQUIREMENTS: PaymentRequirementsV2;
+export declare const createX402V2Requirements: (overrides?: Partial<PaymentRequirementsV2>) => PaymentRequirementsV2;
+export declare const INVALID_REQUIREMENTS: {
+    readonly missingAmount: {
+        scheme: "exact";
+        network: import("@armory-sh/base").CAIP2ChainId;
+        amount: string;
+        asset: import("@armory-sh/base").Address;
+        payTo: import("@armory-sh/base").Address;
+        maxTimeoutSeconds: number;
+        extra?: import("@armory-sh/base").Extensions;
+    };
+    readonly invalidNetwork: {
+        readonly scheme: "exact";
+        readonly network: `eip155:${string}`;
+        readonly amount: "1000000";
+        readonly asset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+        readonly payTo: "0x1234567890123456789012345678901234567890";
+        readonly maxTimeoutSeconds: 300;
+    };
+    readonly invalidAsset: {
+        readonly scheme: "exact";
+        readonly network: "eip155:84532";
+        readonly amount: "1000000";
+        readonly asset: `0x${string}`;
+        readonly payTo: "0x1234567890123456789012345678901234567890";
+        readonly maxTimeoutSeconds: 300;
+    };
+};

package/dist/index.d.ts

@@ -17,4 +17,4 @@ export type { TypedDataDomain, EIP712Domain, TransferWithAuthorization, TypedDat
 export { EIP712_TYPES, USDC_DOMAIN, createEIP712Domain, createTransferWithAuthorization, validateTransferWithAuthorization, } from "./eip712";
 export { resolveNetwork, resolveToken, resolveFacilitator, checkFacilitatorSupport, validatePaymentConfig, validateAcceptConfig, getAvailableNetworks, getAvailableTokens, isValidationError, isResolvedNetwork, isResolvedToken, createError, normalizeNetworkName, } from "./validation";
 export { encodePaymentV1, decodePaymentV1, encodeSettlementV1, decodeSettlementV1, encodePaymentV2, decodePaymentV2, encodeSettlementV2, decodeSettlementV2, detectPaymentVersion as detectPaymentVersionLegacy, decodePayment as decodePaymentLegacy, decodeSettlement as decodeSettlementLegacy, isPaymentV1, isPaymentV2, isSettlementV1, isSettlementV2, } from "./encoding";
-export type { NetworkId, TokenId, FacilitatorConfig, AcceptPaymentOptions, PricingConfig, PaymentResult, PaymentError, PaymentErrorCode, ArmoryPaymentResult, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, } from "./types/simple";
+export type { NetworkId, TokenId, FacilitatorConfig, FacilitatorVerifyResult, FacilitatorSettleResult, SettlementMode, PayToAddress, AcceptPaymentOptions, PricingConfig, PaymentResult, PaymentError, PaymentErrorCode, ArmoryPaymentResult, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, } from "./types/simple";

package/dist/index.js

@@ -354,7 +354,7 @@ function isPaymentRequiredV2(obj) {
   return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj && Array.isArray(obj.accepts);
 }
 function isPaymentPayloadV2(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "accepted" in obj && "payload" in obj;
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "scheme" in obj && "network" in obj && "payload" in obj;
 }
 function assetIdToAddress(assetId) {
   const match = assetId.match(/\/erc20:(0x[a-fA-F0-9]{40})$/);
@@ -386,7 +386,7 @@ function isX402V1Payload(obj) {
   return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "scheme" in obj && "network" in obj && "payload" in obj;
 }
 function isX402V2Payload(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "accepted" in obj && "payload" in obj;
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "scheme" in obj && "network" in obj && "payload" in obj;
 }
 function isLegacyV1Payload(obj) {
   return typeof obj === "object" && obj !== null && "v" in obj && "r" in obj && "s" in obj && "chainId" in obj && "contractAddress" in obj && !("x402Version" in obj);
@@ -462,172 +462,20 @@ function isV2(obj) {
 }
 
 // src/types/networks.ts
-var tokenRegistry = /* @__PURE__ */ new Map();
-var tokenKey = (chainId, contractAddress) => `${chainId}:${contractAddress.toLowerCase()}`;
-var NETWORKS = {
-  ethereum: {
-    name: "Ethereum Mainnet",
-    chainId: 1,
-    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    rpcUrl: "https://eth.llamarpc.com",
-    caip2Id: "eip155:1",
-    caipAssetId: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
-  },
-  base: {
-    name: "Base Mainnet",
-    chainId: 8453,
-    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    rpcUrl: "https://mainnet.base.org",
-    caip2Id: "eip155:8453",
-    caipAssetId: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-  },
-  "base-sepolia": {
-    name: "Base Sepolia",
-    chainId: 84532,
-    usdcAddress: "0x036CbD53842c5426634e7929541eA237834d2D14",
-    rpcUrl: "https://sepolia.base.org",
-    caip2Id: "eip155:84532",
-    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eA237834d2D14"
-  },
-  "skale-base": {
-    name: "SKALE Base",
-    chainId: 1187947933,
-    usdcAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
-    rpcUrl: "https://skale-base.skalenodes.com/v1/base",
-    caip2Id: "eip155:1187947933",
-    caipAssetId: "eip155:1187947933/erc20:0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
-  },
-  "skale-base-sepolia": {
-    name: "SKALE Base Sepolia",
-    chainId: 324705682,
-    usdcAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
-    rpcUrl: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
-    caip2Id: "eip155:324705682",
-    caipAssetId: "eip155:324705682/erc20:0x2e08028E3C4c2356572E096d8EF835cD5C6030bD"
-  },
-  "ethereum-sepolia": {
-    name: "Ethereum Sepolia",
-    chainId: 11155111,
-    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-    rpcUrl: "https://rpc.sepolia.org",
-    caip2Id: "eip155:11155111",
-    caipAssetId: "eip155:11155111/erc20:0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
-  }
-};
-var getNetworkConfig = (name) => NETWORKS[name];
-var getNetworkByChainId = (chainId) => Object.values(NETWORKS).find((c) => c.chainId === chainId);
-var getMainnets = () => Object.values(NETWORKS).filter((c) => !c.name.toLowerCase().includes("sepolia"));
-var getTestnets = () => Object.values(NETWORKS).filter((c) => c.name.toLowerCase().includes("sepolia"));
-var registerToken = (token) => {
-  tokenRegistry.set(tokenKey(token.chainId, token.contractAddress), token);
-  return token;
-};
-var getCustomToken = (chainId, contractAddress) => tokenRegistry.get(tokenKey(chainId, contractAddress));
-var getAllCustomTokens = () => Array.from(tokenRegistry.values());
-var unregisterToken = (chainId, contractAddress) => tokenRegistry.delete(tokenKey(chainId, contractAddress));
-var isCustomToken = (chainId, contractAddress) => tokenRegistry.has(tokenKey(chainId, contractAddress));
-
-// src/abi/erc20.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "transferWithAuthorization",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "expiry", type: "uint256" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "receiveWithAuthorization",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "expiry", type: "uint256" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "balance", type: "uint256" }]
-  },
-  {
-    type: "function",
-    name: "name",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
-  },
-  {
-    type: "function",
-    name: "symbol",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
-  }
-];
-
-// src/eip712.ts
-var EIP712_TYPES = {
-  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"
-};
-var createEIP712Domain = (chainId, contractAddress) => ({
-  name: USDC_DOMAIN.NAME,
-  version: USDC_DOMAIN.VERSION,
-  chainId,
-  verifyingContract: contractAddress
-});
-var createTransferWithAuthorization = (params) => ({
-  from: params.from,
-  to: params.to,
-  value: BigInt(params.value),
-  validAfter: BigInt(params.validAfter),
-  validBefore: BigInt(params.validBefore),
-  nonce: BigInt(params.nonce)
-});
-var isAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
-var validateTransferWithAuthorization = (message) => {
-  if (!isAddress2(message.from)) throw new Error(`Invalid "from" address: ${message.from}`);
-  if (!isAddress2(message.to)) throw new Error(`Invalid "to" address: ${message.to}`);
-  if (message.value < 0n) throw new Error(`"value" must be non-negative: ${message.value}`);
-  if (message.validAfter < 0n) throw new Error(`"validAfter" must be non-negative: ${message.validAfter}`);
-  if (message.validBefore < 0n) throw new Error(`"validBefore" must be non-negative: ${message.validBefore}`);
-  if (message.validAfter >= message.validBefore) {
-    throw new Error(`"validAfter" (${message.validAfter}) must be before "validBefore" (${message.validBefore})`);
-  }
-  if (message.nonce < 0n) throw new Error(`"nonce" must be non-negative: ${message.nonce}`);
-  return true;
-};
+import { type as arkType2 } from "arktype";
 
 // src/validation.ts
+import { type as arkType } from "arktype";
+var CustomTokenSchema = arkType({
+  symbol: "string",
+  name: "string",
+  version: "string",
+  contractAddress: "/^0x[a-fA-F0-9]{40}$/",
+  chainId: "number.integer > 0",
+  decimals: "number.integer >= 0?"
+});
+var NetworkIdSchema = arkType("string | number | object");
+var TokenIdSchema = arkType("string | number | object");
 var createError = (code, message, details) => ({
   code,
   message,
@@ -635,6 +483,14 @@ var createError = (code, message, details) => ({
 });
 var normalizeNetworkName = (name) => name.toLowerCase().replace(/\s+/g, "-").replace("-mainnet", "").replace(/-mainnet/, "").replace("mainnet-", "").replace(/-sepolia$/, "-sepolia").replace(/^-|-$/g, "");
 var resolveNetwork = (input) => {
+  const inputCheck = NetworkIdSchema(input);
+  if (inputCheck instanceof arkType.errors) {
+    return createError(
+      "VALIDATION_FAILED",
+      "Invalid network input type",
+      { value: input, validOptions: ["string (name/CAIP-2)", "number (chainId)", "NetworkConfig"] }
+    );
+  }
   if (typeof input === "object" && input !== null && "chainId" in input) {
     const config = input;
     if (!config.chainId || !config.usdcAddress || !config.caip2Id) {
@@ -701,6 +557,14 @@ var getAvailableNetworks = () => Object.keys(NETWORKS);
 var normalizeTokenSymbol = (symbol) => symbol.toUpperCase();
 var isEvmAddress = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
 var resolveToken = (input, network) => {
+  const inputCheck = TokenIdSchema(input);
+  if (inputCheck instanceof arkType.errors) {
+    return createError(
+      "VALIDATION_FAILED",
+      "Invalid token input type",
+      { value: input, validOptions: ["string (symbol/address/CAIP Asset)", "number (deprecated)", "CustomToken"] }
+    );
+  }
   if (typeof input === "object" && input !== null && "contractAddress" in input) {
     const config = input;
     if (!config.chainId || !config.contractAddress || !config.symbol) {
@@ -800,7 +664,7 @@ var resolveToken = (input, network) => {
     if (network) {
       const customTokens2 = getAllCustomTokens();
       const matchingToken2 = customTokens2.find(
-        (t) => t.symbol.toUpperCase() === normalizedSymbol && t.chainId === network.config.chainId
+        (t) => t.symbol?.toUpperCase() === normalizedSymbol && t.chainId === network.config.chainId
       );
       if (matchingToken2) {
         return {
@@ -825,7 +689,7 @@ var resolveToken = (input, network) => {
       };
     }
     const customTokens = getAllCustomTokens();
-    const matchingToken = customTokens.find((t) => t.symbol.toUpperCase() === normalizedSymbol);
+    const matchingToken = customTokens.find((t) => t.symbol?.toUpperCase() === normalizedSymbol);
     if (matchingToken) {
       const tokenNetwork = resolveNetwork(matchingToken.chainId);
       if ("code" in tokenNetwork) {
@@ -1042,6 +906,176 @@ var isResolvedToken = (value) => {
   return typeof value === "object" && value !== null && "config" in value && "caipAsset" in value;
 };
 
+// src/types/networks.ts
+var tokenRegistry = /* @__PURE__ */ new Map();
+var tokenKey = (chainId, contractAddress) => `${chainId}:${contractAddress.toLowerCase()}`;
+var NETWORKS = {
+  ethereum: {
+    name: "Ethereum Mainnet",
+    chainId: 1,
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    rpcUrl: "https://eth.llamarpc.com",
+    caip2Id: "eip155:1",
+    caipAssetId: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+  },
+  base: {
+    name: "Base Mainnet",
+    chainId: 8453,
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    rpcUrl: "https://mainnet.base.org",
+    caip2Id: "eip155:8453",
+    caipAssetId: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "base-sepolia": {
+    name: "Base Sepolia",
+    chainId: 84532,
+    usdcAddress: "0x036CbD53842c5426634e7929541eA237834d2D14",
+    rpcUrl: "https://sepolia.base.org",
+    caip2Id: "eip155:84532",
+    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eA237834d2D14"
+  },
+  "skale-base": {
+    name: "SKALE Base",
+    chainId: 1187947933,
+    usdcAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+    rpcUrl: "https://skale-base.skalenodes.com/v1/base",
+    caip2Id: "eip155:1187947933",
+    caipAssetId: "eip155:1187947933/erc20:0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
+  },
+  "skale-base-sepolia": {
+    name: "SKALE Base Sepolia",
+    chainId: 324705682,
+    usdcAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+    rpcUrl: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
+    caip2Id: "eip155:324705682",
+    caipAssetId: "eip155:324705682/erc20:0x2e08028E3C4c2356572E096d8EF835cD5C6030bD"
+  },
+  "ethereum-sepolia": {
+    name: "Ethereum Sepolia",
+    chainId: 11155111,
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    rpcUrl: "https://rpc.sepolia.org",
+    caip2Id: "eip155:11155111",
+    caipAssetId: "eip155:11155111/erc20:0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+  }
+};
+var getNetworkConfig = (name) => NETWORKS[name];
+var getNetworkByChainId = (chainId) => Object.values(NETWORKS).find((c) => c.chainId === chainId);
+var getMainnets = () => Object.values(NETWORKS).filter((c) => !c.name.toLowerCase().includes("sepolia"));
+var getTestnets = () => Object.values(NETWORKS).filter((c) => c.name.toLowerCase().includes("sepolia"));
+var registerToken = (token) => {
+  const validated = CustomTokenSchema(token);
+  if (validated instanceof arkType2.errors) {
+    throw new Error(`Invalid token: ${validated.summary}`);
+  }
+  tokenRegistry.set(tokenKey(validated.chainId, validated.contractAddress), validated);
+  return validated;
+};
+var getCustomToken = (chainId, contractAddress) => tokenRegistry.get(tokenKey(chainId, contractAddress));
+var getAllCustomTokens = () => Array.from(tokenRegistry.values());
+var unregisterToken = (chainId, contractAddress) => tokenRegistry.delete(tokenKey(chainId, contractAddress));
+var isCustomToken = (chainId, contractAddress) => tokenRegistry.has(tokenKey(chainId, contractAddress));
+
+// src/abi/erc20.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "transferWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "receiveWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+
+// src/eip712.ts
+var EIP712_TYPES = {
+  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"
+};
+var createEIP712Domain = (chainId, contractAddress) => ({
+  name: USDC_DOMAIN.NAME,
+  version: USDC_DOMAIN.VERSION,
+  chainId,
+  verifyingContract: contractAddress
+});
+var createTransferWithAuthorization = (params) => ({
+  from: params.from,
+  to: params.to,
+  value: BigInt(params.value),
+  validAfter: BigInt(params.validAfter),
+  validBefore: BigInt(params.validBefore),
+  nonce: BigInt(params.nonce)
+});
+var isAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
+var validateTransferWithAuthorization = (message) => {
+  if (!isAddress2(message.from)) throw new Error(`Invalid "from" address: ${message.from}`);
+  if (!isAddress2(message.to)) throw new Error(`Invalid "to" address: ${message.to}`);
+  if (message.value < 0n) throw new Error(`"value" must be non-negative: ${message.value}`);
+  if (message.validAfter < 0n) throw new Error(`"validAfter" must be non-negative: ${message.validAfter}`);
+  if (message.validBefore < 0n) throw new Error(`"validBefore" must be non-negative: ${message.validBefore}`);
+  if (message.validAfter >= message.validBefore) {
+    throw new Error(`"validAfter" (${message.validAfter}) must be before "validBefore" (${message.validBefore})`);
+  }
+  if (message.nonce < 0n) throw new Error(`"nonce" must be non-negative: ${message.nonce}`);
+  return true;
+};
+
 // src/encoding.ts
 var base64Encode = (data) => Buffer.from(JSON.stringify(data)).toString("base64");
 var base64Decode = (encoded) => JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));

package/dist/types/networks.d.ts

@@ -12,14 +12,14 @@ export interface CustomToken {
     version: string;
     contractAddress: `0x${string}`;
     chainId: number;
-    decimals: number;
+    decimals?: number;
 }
 export declare const NETWORKS: Record<string, NetworkConfig>;
 export declare const getNetworkConfig: (name: string) => NetworkConfig | undefined;
 export declare const getNetworkByChainId: (chainId: number) => NetworkConfig | undefined;
 export declare const getMainnets: () => NetworkConfig[];
 export declare const getTestnets: () => NetworkConfig[];
-export declare const registerToken: (token: CustomToken) => CustomToken;
+export declare const registerToken: (token: unknown) => CustomToken;
 export declare const getCustomToken: (chainId: number, contractAddress: string) => CustomToken | undefined;
 export declare const getAllCustomTokens: () => CustomToken[];
 export declare const unregisterToken: (chainId: number, contractAddress: string) => boolean;

package/dist/types/protocol.d.ts

@@ -4,7 +4,7 @@
  * Handles both x402 V1 and V2 formats along with legacy Armory formats
  */
 import type { X402PaymentPayloadV1, X402PaymentRequiredV1, X402PaymentRequirementsV1, X402SettlementResponseV1, LegacyPaymentPayloadV1, LegacyPaymentRequirementsV1, LegacySettlementResponseV1 } from "./v1";
-import type { PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, PaymentRequiredV2 } from "./v2";
+import type { PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, PaymentRequiredV2, Address } from "./v2";
 /**
  * All x402 compatible payment payload types
  */
@@ -17,16 +17,57 @@ export type PaymentRequirements = X402PaymentRequirementsV1 | PaymentRequirement
  * All x402 compatible settlement response types
  */
 export type SettlementResponse = X402SettlementResponseV1 | SettlementResponseV2 | LegacySettlementResponseV1;
+/**
+ * Configuration for connecting to a facilitator service
+ */
+export interface FacilitatorConfig {
+    url: string;
+    createHeaders?: () => Record<string, string>;
+}
+/**
+ * Result from facilitator verification
+ */
+export interface FacilitatorVerifyResult {
+    success: boolean;
+    payerAddress?: string;
+    balance?: string;
+    requiredAmount?: string;
+    error?: string;
+}
+/**
+ * Result from facilitator settlement
+ */
+export interface FacilitatorSettleResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+/**
+ * Settlement mode - verify only, settle only, or both
+ */
+export type SettlementMode = "verify" | "settle" | "async";
+/**
+ * Payment destination - address, CAIP-2 chain ID, or CAIP asset ID
+ */
+export type PayToAddress = Address | CAIP2ChainId | CAIPAssetId;
 /**
  * All x402 compatible payment required response types
  */
 export type PaymentRequired = X402PaymentRequiredV1 | PaymentRequiredV2;
+/**
+ * CAIP-2 chain ID type (e.g., eip155:8453)
+ */
+export type CAIP2ChainId = `eip155:${string}`;
+/**
+ * CAIP-2 asset ID type (e.g., eip155:8453/erc20:0xa0b8691...)
+ */
+export type CAIPAssetId = `eip155:${string}/erc20:${string}`;
 /**
  * Check if payload is x402 V1 format
  */
 export declare function isX402V1Payload(obj: unknown): obj is X402PaymentPayloadV1;
 /**
- * Check if payload is x402 V2 format
+ * Check if payload is x402 V2 format (Coinbase format)
  */
 export declare function isX402V2Payload(obj: unknown): obj is PaymentPayloadV2;
 /**

package/dist/types/simple.d.ts

@@ -31,6 +31,40 @@ export interface FacilitatorConfig {
     /** Tokens this facilitator supports (optional) */
     tokens?: TokenId[];
 }
+/**
+ * Result from facilitator verification
+ */
+export interface FacilitatorVerifyResult {
+    success: boolean;
+    payerAddress?: string;
+    balance?: string;
+    requiredAmount?: string;
+    error?: string;
+}
+/**
+ * Result from facilitator settlement
+ */
+export interface FacilitatorSettleResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+/**
+ * Settlement mode - verify only, settle only, or both
+ */
+export type SettlementMode = "verify" | "settle" | "async";
+/**
+ * CAIP-2 chain ID type (e.g., eip155:8453)
+ */
+export type CAIP2ChainId = `eip155:${string}`;
+/**
+ * CAIP-2 asset ID type (e.g., eip155:8453/erc20:0xa0b8691...)
+ */
+export type CAIP2AssetId = `eip155:${string}/erc20:${string}`;
+/**
+ * Payment destination - address, CAIP-2 chain ID, or CAIP asset ID
+ */
+export type PayToAddress = `0x${string}` | CAIP2ChainId | CAIP2AssetId;
 /**
  * Pricing configuration for a specific network/token/facilitator combination
  */

package/dist/types/v2.d.ts

@@ -18,6 +18,7 @@ export type PayToV2 = Address | {
     role?: string;
     callback?: string;
 };
+export type PayToAddress = Address | PayToV2;
 export interface Extensions {
     [key: string]: unknown;
 }
@@ -97,17 +98,19 @@ export interface SchemePayloadV2 {
 }
 /**
  * Payment payload sent by client
- * Matches x402 V2 PaymentPayload spec
+ * Matches x402 V2 PaymentPayload spec (Coinbase format)
  */
 export interface PaymentPayloadV2 {
     /** Protocol version identifier */
     x402Version: 2;
-    /** Resource being accessed (echoed from server) */
-    resource?: ResourceInfo;
-    /** Selected payment requirement from server's accepts array */
-    accepted: PaymentRequirementsV2;
+    /** Payment scheme (e.g., "exact") */
+    scheme: string;
+    /** Network identifier in CAIP-2 format */
+    network: string;
     /** Scheme-specific payment data */
     payload: SchemePayloadV2;
+    /** Resource being accessed (optional, echoed from server) */
+    resource?: ResourceInfo;
     /** Protocol extensions data */
     extensions?: Extensions;
 }

package/dist/utils/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test Utilities Index
+ *
+ * Re-exports commonly used test utilities
+ */
+export * from "./mock-facilitator";
+export * from "../../fixtures/config";

package/dist/utils/utils/mock-facilitator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Mock Facilitator for Testing
+ */
+import type { PaymentPayload } from "@armory-sh/base";
+export interface FacilitatorVerifyRequest {
+    payload: PaymentPayload;
+    requirements: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+export interface FacilitatorVerifyResponse {
+    success: boolean;
+    payerAddress?: string;
+    balance?: string;
+    requiredAmount?: string;
+    error?: string;
+}
+export interface FacilitatorSettleRequest {
+    payload: PaymentPayload;
+    requirements: Record<string, unknown>;
+}
+export interface FacilitatorSettleResponse {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+export type AnyFacilitatorRequest = FacilitatorVerifyRequest | FacilitatorSettleRequest;
+export type AnyFacilitatorResponse = FacilitatorVerifyResponse | FacilitatorSettleResponse;
+export interface MockFacilitatorOptions {
+    port?: number;
+    alwaysVerify?: boolean;
+    alwaysSettle?: boolean;
+    verifyDelay?: number;
+    settleDelay?: number;
+}
+export declare const createMockFacilitator: (options?: MockFacilitatorOptions) => Promise<{
+    url: string;
+    close: () => Promise<void>;
+}>;

package/dist/validation.d.ts

@@ -2,45 +2,26 @@
  * Comprehensive validation for Armory configurations
  * Ensures networks, tokens, and facilitators are compatible
  */
-import type { NetworkId, TokenId, FacilitatorConfig, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, PaymentErrorCode } from "./types/simple.js";
+import type { NetworkId, TokenId, FacilitatorConfig, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, PaymentErrorCode } from "./types/simple";
+export declare const CustomTokenSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    symbol: string;
+    name: string;
+    version: string;
+    contractAddress: `0x${string}`;
+    chainId: number;
+    decimals?: number | undefined;
+}, {}>;
 export declare const createError: (code: PaymentErrorCode, message: string, details?: Partial<ValidationError>) => ValidationError;
-/**
- * Normalize network name to match registry keys
- */
 export declare const normalizeNetworkName: (name: string) => string;
-/**
- * Resolve a network identifier to a network config
- */
-export declare const resolveNetwork: (input: NetworkId) => ResolvedNetwork | ValidationError;
-/**
- * Get all available network names
- */
+export declare const resolveNetwork: (input: unknown) => ResolvedNetwork | ValidationError;
 export declare const getAvailableNetworks: () => string[];
-/**
- * Resolve a token identifier to a token config
- */
-export declare const resolveToken: (input: TokenId, network?: ResolvedNetwork) => ResolvedToken | ValidationError;
-/**
- * Get all available token symbols
- */
+export declare const resolveToken: (input: unknown, network?: ResolvedNetwork) => ResolvedToken | ValidationError;
 export declare const getAvailableTokens: () => string[];
-/**
- * Resolve a facilitator configuration
- */
 export declare const resolveFacilitator: (input: FacilitatorConfig, supportedNetworks?: ResolvedNetwork[], supportedTokens?: ResolvedToken[]) => ResolvedFacilitator | ValidationError;
-/**
- * Check if a facilitator supports a specific network/token combination
- */
 export declare const checkFacilitatorSupport: (facilitator: ResolvedFacilitator, network: ResolvedNetwork, token: ResolvedToken) => ValidationError | {
     supported: true;
 };
-/**
- * Validate a complete payment configuration
- */
 export declare const validatePaymentConfig: (network: NetworkId, token: TokenId, facilitators?: FacilitatorConfig | FacilitatorConfig[], payTo?: string, amount?: string) => ResolvedPaymentConfig | ValidationError;
-/**
- * Validate multi-accept configuration (for merchants)
- */
 export declare const validateAcceptConfig: (options: {
     networks?: NetworkId[];
     tokens?: TokenId[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/base",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,6 +27,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
+    "arktype": "^2.1.29",
     "viem": "2.45.0"
   },
   "devDependencies": {
@@ -35,7 +36,8 @@
     "typescript": "5.9.3"
   },
   "scripts": {
-    "build": "tsup && tsc --emitDeclarationOnly",
-    "test": "bun test"
+    "build": "rm -rf dist && tsup && tsc --emitDeclarationOnly",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/validation.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Comprehensive unit tests for validation layer
- * Tests all input formats, cross-checks, and error messages
- */
-export {};