@armory-sh/base 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sawyer Cutler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# @armory-sh/base
+
+Core types and utilities for Armory payment protocol.
+
+## Install
+
+```bash
+bun add @armory-sh/base
+```
+
+## Use
+
+```typescript
+import type { PaymentRequest, PaymentResponse } from '@armory-sh/base'
+import { calculateExpiry } from '@armory-sh/base'
+
+const payment: PaymentRequest = {
+  to: '0x...',
+  amount: 1000000n,
+  expiry: calculateExpiry(3600),
+  chainId: 'eip155:8453',
+  assetId: 'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'
+}
+```
+
+---
+
+MIT License | Sawyer Cutler 2026 | Provided "AS IS" without warranty

package/dist/abi/erc20.d.ts

@@ -0,0 +1,116 @@
+export type TransferWithAuthorizationParams = readonly [
+    from: `0x${string}`,
+    to: `0x${string}`,
+    amount: bigint,
+    validAfter: bigint,
+    expiry: bigint,
+    v: number,
+    r: `0x${string}`,
+    s: `0x${string}`
+];
+export type ReceiveWithAuthorizationParams = readonly [
+    from: `0x${string}`,
+    to: `0x${string}`,
+    amount: bigint,
+    validAfter: bigint,
+    expiry: bigint,
+    v: number,
+    r: `0x${string}`,
+    s: `0x${string}`
+];
+export type BalanceOfParams = readonly [account: `0x${string}`];
+export type BalanceOfReturnType = bigint;
+export type NameReturnType = string;
+export type SymbolReturnType = string;
+export declare const ERC20_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "transferWithAuthorization";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "receiveWithAuthorization";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+}];
+export type ERC20Abi = typeof ERC20_ABI;

package/dist/eip712.d.ts

@@ -0,0 +1,61 @@
+export type TypedDataDomain = {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: `0x${string}`;
+    salt?: `0x${string}`;
+};
+export interface EIP712Domain {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: `0x${string}`;
+}
+export interface TransferWithAuthorization {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: bigint;
+    validAfter: bigint;
+    validBefore: bigint;
+    nonce: bigint;
+}
+export type TypedDataField = {
+    name: string;
+    type: string;
+};
+export type EIP712Types = {
+    TransferWithAuthorization: TypedDataField[];
+};
+export declare const EIP712_TYPES: {
+    readonly TransferWithAuthorization: [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+export declare const USDC_DOMAIN: {
+    readonly NAME: "USD Coin";
+    readonly VERSION: "2";
+};
+export declare const createEIP712Domain: (chainId: number, contractAddress: `0x${string}`) => EIP712Domain;
+export declare const createTransferWithAuthorization: (params: Omit<TransferWithAuthorization, "value" | "validAfter" | "validBefore" | "nonce"> & {
+    value: bigint | number;
+    validAfter: bigint | number;
+    validBefore: bigint | number;
+    nonce: bigint | number;
+}) => TransferWithAuthorization;
+export declare const validateTransferWithAuthorization: (message: TransferWithAuthorization) => boolean;

package/dist/encoding.d.ts

@@ -0,0 +1,22 @@
+import type { PaymentPayloadV1, SettlementResponseV1 } from "./types/v1";
+import { V1_HEADERS } from "./types/v1";
+import type { PaymentPayloadV2, SettlementResponseV2 } from "./types/v2";
+import { V2_HEADERS } from "./types/v2";
+export { V1_HEADERS, V2_HEADERS };
+export type PaymentPayload = PaymentPayloadV1 | PaymentPayloadV2;
+export type SettlementResponse = SettlementResponseV1 | SettlementResponseV2;
+export declare const encodePaymentV1: (payload: PaymentPayloadV1) => string;
+export declare const decodePaymentV1: (encoded: string) => PaymentPayloadV1;
+export declare const encodeSettlementV1: (response: SettlementResponseV1) => string;
+export declare const decodeSettlementV1: (encoded: string) => SettlementResponseV1;
+export declare const encodePaymentV2: (payload: PaymentPayloadV2) => string;
+export declare const decodePaymentV2: (encoded: string) => PaymentPayloadV2;
+export declare const encodeSettlementV2: (response: SettlementResponseV2) => string;
+export declare const decodeSettlementV2: (encoded: string) => SettlementResponseV2;
+export declare const detectPaymentVersion: (headers: Headers) => 1 | 2 | null;
+export declare const decodePayment: (headers: Headers) => PaymentPayload;
+export declare const decodeSettlement: (headers: Headers) => SettlementResponse;
+export declare const isPaymentV1: (payload: PaymentPayload) => payload is PaymentPayloadV1;
+export declare const isPaymentV2: (payload: PaymentPayload) => payload is PaymentPayloadV2;
+export declare const isSettlementV1: (response: SettlementResponse) => response is SettlementResponseV1;
+export declare const isSettlementV2: (response: SettlementResponse) => response is SettlementResponseV2;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { PaymentPayloadV1, PaymentRequirementsV1, SettlementResponseV1, } from "./types/v1";
+export { V1_HEADERS, encodePaymentPayload, decodePaymentPayload, encodeSettlementResponse, decodeSettlementResponse, } from "./types/v1";
+export type { CAIP2ChainId, CAIPAssetId, Address, Signature, PayToV2, Extensions, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, } from "./types/v2";
+export { V2_HEADERS, isCAIP2ChainId, isCAIPAssetId, isAddress, } from "./types/v2";
+export type { PaymentPayload, PaymentRequirements, SettlementResponse, } from "./types/protocol";
+export { isV1, isV2, getPaymentVersion as getPaymentVersionFromPayload, getRequirementsVersion, getSettlementVersion, getPaymentHeaderName, getPaymentResponseHeaderName, getPaymentRequiredHeaderName, isSettlementSuccessful, getTxHash, } 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 type { TransferWithAuthorizationParams, ReceiveWithAuthorizationParams, BalanceOfParams, BalanceOfReturnType, NameReturnType, SymbolReturnType, ERC20Abi, } from "./abi/erc20";
+export { ERC20_ABI } from "./abi/erc20";
+export type { PaymentPayload as EncodingPaymentPayload, SettlementResponse as EncodingSettlementResponse, } from "./encoding";
+export { encodePaymentV1, decodePaymentV1, encodeSettlementV1, decodeSettlementV1, encodePaymentV2, decodePaymentV2, encodeSettlementV2, decodeSettlementV2, detectPaymentVersion, decodePayment, decodeSettlement, isPaymentV1, isPaymentV2, isSettlementV1, isSettlementV2, } from "./encoding";
+export type { TypedDataDomain, EIP712Domain, TransferWithAuthorization, TypedDataField, EIP712Types, } from "./eip712";
+export { EIP712_TYPES, USDC_DOMAIN, createEIP712Domain, createTransferWithAuthorization, validateTransferWithAuthorization, } from "./eip712";
+export { resolveNetwork, resolveToken, resolveFacilitator, checkFacilitatorSupport, validatePaymentConfig, validateAcceptConfig, getAvailableNetworks, getAvailableTokens, isValidationError, isResolvedNetwork, isResolvedToken, createError, } from "./validation";
+export type { NetworkId, TokenId, FacilitatorConfig, AcceptPaymentOptions, PaymentResult, PaymentError, PaymentErrorCode, ArmoryPaymentResult, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, } from "./types/simple";

package/dist/index.js

@@ -0,0 +1,730 @@
+// src/types/v1.ts
+var V1_HEADERS = {
+  PAYMENT: "X-PAYMENT",
+  PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE"
+};
+function encodePaymentPayload(payload) {
+  return Buffer.from(JSON.stringify(payload)).toString("base64");
+}
+function decodePaymentPayload(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+}
+function encodeSettlementResponse(response) {
+  return Buffer.from(JSON.stringify(response)).toString("base64");
+}
+function decodeSettlementResponse(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+}
+
+// src/types/v2.ts
+var V2_HEADERS = {
+  PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE",
+  PAYMENT_REQUIRED: "PAYMENT-REQUIRED",
+  PAYMENT_RESPONSE: "PAYMENT-RESPONSE"
+};
+function isCAIP2ChainId(value) {
+  return /^eip155:\d+$/.test(value);
+}
+function isCAIPAssetId(value) {
+  return /^eip155:\d+\/erc20:0x[a-fA-F0-9]+$/.test(value);
+}
+function isAddress(value) {
+  return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+
+// src/types/protocol.ts
+var isV1 = (payload) => "contractAddress" in payload && "network" in payload && "v" in payload;
+var isV2 = (payload) => "chainId" in payload && "assetId" in payload && "signature" in payload;
+var getPaymentVersion = (payload) => isV1(payload) ? 1 : 2;
+var getRequirementsVersion = (requirements) => "contractAddress" in requirements && "network" in requirements ? 1 : 2;
+var getSettlementVersion = (response) => "success" in response ? 1 : 2;
+var getPaymentHeaderName = (version) => version === 1 ? "X-PAYMENT" : "PAYMENT-SIGNATURE";
+var getPaymentResponseHeaderName = (version) => version === 1 ? "X-PAYMENT-RESPONSE" : "PAYMENT-RESPONSE";
+var getPaymentRequiredHeaderName = (version) => version === 1 ? "X-PAYMENT-REQUIRED" : "PAYMENT-REQUIRED";
+var isSettlementSuccessful = (response) => "success" in response ? response.success : response.status === "success";
+var getTxHash = (response) => response.txHash;
+
+// 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/encoding.ts
+var base64Encode = (data) => Buffer.from(JSON.stringify(data)).toString("base64");
+var base64Decode = (encoded) => JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+var jsonEncode = (data) => JSON.stringify(data);
+var jsonDecode = (encoded) => JSON.parse(encoded);
+var encodePaymentV1 = (payload) => base64Encode(payload);
+var decodePaymentV1 = (encoded) => base64Decode(encoded);
+var encodeSettlementV1 = (response) => base64Encode(response);
+var decodeSettlementV1 = (encoded) => base64Decode(encoded);
+var encodePaymentV2 = (payload) => jsonEncode(payload);
+var decodePaymentV2 = (encoded) => jsonDecode(encoded);
+var encodeSettlementV2 = (response) => jsonEncode(response);
+var decodeSettlementV2 = (encoded) => jsonDecode(encoded);
+var detectPaymentVersion = (headers) => {
+  if (headers.has(V1_HEADERS.PAYMENT)) return 1;
+  if (headers.has(V2_HEADERS.PAYMENT_SIGNATURE)) return 2;
+  return null;
+};
+var decodePayment = (headers) => {
+  const version = detectPaymentVersion(headers);
+  if (version === null) {
+    throw new Error("No valid payment headers found. Expected X-PAYMENT (v1) or PAYMENT-SIGNATURE (v2)");
+  }
+  const headerName = version === 1 ? V1_HEADERS.PAYMENT : V2_HEADERS.PAYMENT_SIGNATURE;
+  const encoded = headers.get(headerName);
+  if (!encoded) throw new Error(`Header ${headerName} is empty`);
+  return version === 1 ? decodePaymentV1(encoded) : decodePaymentV2(encoded);
+};
+var decodeSettlement = (headers) => {
+  const v1Response = headers.get(V1_HEADERS.PAYMENT_RESPONSE);
+  if (v1Response) return decodeSettlementV1(v1Response);
+  const v2Response = headers.get(V2_HEADERS.PAYMENT_RESPONSE);
+  if (v2Response) return decodeSettlementV2(v2Response);
+  throw new Error("No valid settlement response headers found. Expected X-PAYMENT-RESPONSE (v1) or PAYMENT-RESPONSE (v2)");
+};
+var isPaymentV1 = (payload) => "v" in payload && typeof payload.v === "number";
+var isPaymentV2 = (payload) => "signature" in payload && typeof payload.signature === "object";
+var isSettlementV1 = (response) => "success" in response;
+var isSettlementV2 = (response) => "status" in response;
+
+// 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/validation.ts
+var createError = (code, message, details) => ({
+  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) => {
+  if (typeof input === "object" && input !== null && "chainId" in input) {
+    const config = input;
+    if (!config.chainId || !config.usdcAddress || !config.caip2Id) {
+      return createError("INVALID_CAIP_FORMAT", "Invalid network config", { value: config });
+    }
+    return {
+      input,
+      config,
+      caip2: config.caip2Id
+    };
+  }
+  if (typeof input === "number") {
+    const config = getNetworkByChainId(input);
+    if (!config) {
+      const validChainIds = Object.values(NETWORKS).map((n) => n.chainId);
+      return createError(
+        "UNKNOWN_NETWORK",
+        `Unknown chain ID: ${input}`,
+        { value: input, validOptions: validChainIds.map(String) }
+      );
+    }
+    return {
+      input,
+      config,
+      caip2: config.caip2Id
+    };
+  }
+  if (typeof input === "string") {
+    if (input.startsWith("eip155:")) {
+      const parts = input.split(":");
+      if (parts.length !== 2 || isNaN(Number(parts[1]))) {
+        return createError("INVALID_CAIP_FORMAT", `Invalid CAIP-2 format: ${input}`, { value: input });
+      }
+      const chainId = Number(parts[1]);
+      const config2 = getNetworkByChainId(chainId);
+      if (!config2) {
+        return createError("UNKNOWN_NETWORK", `Unknown CAIP-2 network: ${input}`, { value: input });
+      }
+      return {
+        input,
+        config: config2,
+        caip2: input
+      };
+    }
+    const normalizedName = normalizeNetworkName(input);
+    const config = getNetworkConfig(normalizedName);
+    if (!config) {
+      const validNames = Object.keys(NETWORKS);
+      return createError(
+        "UNKNOWN_NETWORK",
+        `Unknown network: "${input}"`,
+        { value: input, validOptions: validNames }
+      );
+    }
+    return {
+      input,
+      config,
+      caip2: config.caip2Id
+    };
+  }
+  return createError("UNKNOWN_NETWORK", `Invalid network identifier type: ${typeof input}`, { value: input });
+};
+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) => {
+  if (typeof input === "object" && input !== null && "contractAddress" in input) {
+    const config = input;
+    if (!config.chainId || !config.contractAddress || !config.symbol) {
+      return createError("VALIDATION_FAILED", "Invalid token config", { value: config });
+    }
+    if (network && config.chainId !== network.config.chainId) {
+      return createError(
+        "TOKEN_NOT_ON_NETWORK",
+        `Token ${config.symbol} is on chain ${config.chainId}, but expected chain ${network.config.chainId}`,
+        { value: config }
+      );
+    }
+    const tokenNetwork = resolveNetwork(config.chainId);
+    if ("code" in tokenNetwork) {
+      return tokenNetwork;
+    }
+    const caipAsset = `eip155:${config.chainId}/erc20:${config.contractAddress}`;
+    return {
+      input,
+      config,
+      caipAsset,
+      network: tokenNetwork
+    };
+  }
+  if (typeof input === "string") {
+    if (isEvmAddress(input)) {
+      const contractAddress = input;
+      if (network) {
+        const customToken = getCustomToken(network.config.chainId, contractAddress);
+        const config = customToken || {
+          symbol: "CUSTOM",
+          name: "Custom Token",
+          version: "1",
+          chainId: network.config.chainId,
+          contractAddress,
+          decimals: 18
+        };
+        const caipAsset = `eip155:${network.config.chainId}/erc20:${contractAddress}`;
+        return {
+          input,
+          config,
+          caipAsset,
+          network
+        };
+      }
+      const customTokens2 = getAllCustomTokens();
+      const matchingToken2 = customTokens2.find(
+        (t) => t.contractAddress.toLowerCase() === contractAddress.toLowerCase()
+      );
+      if (matchingToken2) {
+        const tokenNetwork = resolveNetwork(matchingToken2.chainId);
+        if ("code" in tokenNetwork) {
+          return tokenNetwork;
+        }
+        const caipAsset = `eip155:${matchingToken2.chainId}/erc20:${contractAddress}`;
+        return {
+          input,
+          config: matchingToken2,
+          caipAsset,
+          network: tokenNetwork
+        };
+      }
+      return createError(
+        "UNKNOWN_TOKEN",
+        `Token address "${contractAddress}" not found in registry. Please specify a network.`,
+        { value: input, validOptions: ["Specify network parameter"] }
+      );
+    }
+    if (input.includes("/erc20:")) {
+      const parts = input.split("/");
+      if (parts.length !== 2) {
+        return createError("INVALID_CAIP_FORMAT", `Invalid CAIP Asset ID format: ${input}`, { value: input });
+      }
+      const chainId = Number(parts[0].split(":")[1]);
+      const contractAddress = parts[1].split(":")[1];
+      const tokenNetwork = resolveNetwork(chainId);
+      if ("code" in tokenNetwork) {
+        return tokenNetwork;
+      }
+      const customToken = getCustomToken(chainId, contractAddress);
+      const config = customToken || {
+        symbol: "CUSTOM",
+        name: "Custom Token",
+        version: "1",
+        chainId,
+        contractAddress,
+        decimals: 18
+      };
+      return {
+        input,
+        config,
+        caipAsset: input,
+        network: tokenNetwork
+      };
+    }
+    const normalizedSymbol = normalizeTokenSymbol(input);
+    if (network) {
+      const customTokens2 = getAllCustomTokens();
+      const matchingToken2 = customTokens2.find(
+        (t) => t.symbol.toUpperCase() === normalizedSymbol && t.chainId === network.config.chainId
+      );
+      if (matchingToken2) {
+        return {
+          input,
+          config: matchingToken2,
+          caipAsset: `eip155:${matchingToken2.chainId}/erc20:${matchingToken2.contractAddress}`,
+          network
+        };
+      }
+      return {
+        input,
+        config: {
+          symbol: normalizedSymbol,
+          name: network.config.name + " " + normalizedSymbol,
+          version: "2",
+          chainId: network.config.chainId,
+          contractAddress: network.config.usdcAddress,
+          decimals: 6
+        },
+        caipAsset: network.config.caipAssetId,
+        network
+      };
+    }
+    const customTokens = getAllCustomTokens();
+    const matchingToken = customTokens.find((t) => t.symbol.toUpperCase() === normalizedSymbol);
+    if (matchingToken) {
+      const tokenNetwork = resolveNetwork(matchingToken.chainId);
+      if ("code" in tokenNetwork) {
+        return tokenNetwork;
+      }
+      return {
+        input,
+        config: matchingToken,
+        caipAsset: `eip155:${matchingToken.chainId}/erc20:${matchingToken.contractAddress}`,
+        network: tokenNetwork
+      };
+    }
+    const baseNetwork = resolveNetwork("base");
+    if ("code" in baseNetwork) {
+      return baseNetwork;
+    }
+    return {
+      input,
+      config: {
+        symbol: normalizedSymbol,
+        name: "USD Coin",
+        version: "2",
+        chainId: 8453,
+        contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6
+      },
+      caipAsset: baseNetwork.config.caipAssetId,
+      network: baseNetwork
+    };
+  }
+  return createError("UNKNOWN_TOKEN", `Invalid token identifier type: ${typeof input}`, { value: input });
+};
+var getAvailableTokens = () => {
+  const customTokens = getAllCustomTokens();
+  const symbols = new Set(customTokens.map((t) => t.symbol.toUpperCase()));
+  return Array.from(symbols);
+};
+var resolveFacilitator = (input, supportedNetworks, supportedTokens) => {
+  try {
+    new URL(input.url);
+  } catch {
+    return createError("VALIDATION_FAILED", `Invalid facilitator URL: ${input.url}`, { value: input.url });
+  }
+  const networks = [];
+  if (input.networks) {
+    for (const network of input.networks) {
+      const resolved = resolveNetwork(network);
+      if ("code" in resolved) {
+        return resolved;
+      }
+      networks.push(resolved);
+    }
+  } else if (supportedNetworks) {
+    networks.push(...supportedNetworks);
+  }
+  const tokens = [];
+  if (input.tokens) {
+    for (const token of input.tokens) {
+      for (const network of networks.length > 0 ? networks : supportedNetworks || []) {
+        const resolved = resolveToken(token, network);
+        if ("code" in resolved) {
+          continue;
+        }
+        tokens.push(resolved);
+        break;
+      }
+    }
+  } else if (supportedTokens) {
+    tokens.push(...supportedTokens);
+  }
+  return {
+    input,
+    url: input.url,
+    networks,
+    tokens
+  };
+};
+var checkFacilitatorSupport = (facilitator, network, token) => {
+  if (facilitator.networks.length > 0) {
+    const networkSupported = facilitator.networks.some(
+      (n) => n.config.chainId === network.config.chainId
+    );
+    if (!networkSupported) {
+      const supportedNames = facilitator.networks.map((n) => n.config.name);
+      return createError(
+        "FACILITATOR_NO_NETWORK_SUPPORT",
+        `Facilitator "${facilitator.url}" does not support network "${network.config.name}" (chain ${network.config.chainId}). Supported: ${supportedNames.join(", ")}`,
+        {
+          value: { facilitator: facilitator.url, network: network.config.name },
+          validOptions: supportedNames
+        }
+      );
+    }
+  }
+  if (facilitator.tokens.length > 0) {
+    const tokenSupported = facilitator.tokens.some(
+      (t) => t.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase() && t.network.config.chainId === token.network.config.chainId
+    );
+    if (!tokenSupported) {
+      const supportedTokens = facilitator.tokens.map((t) => `${t.config.symbol} (${t.network.config.name})`);
+      return createError(
+        "FACILITATOR_NO_TOKEN_SUPPORT",
+        `Facilitator "${facilitator.url}" does not support token "${token.config.symbol}" on "${token.network.config.name}". Supported: ${supportedTokens.join(", ")}`,
+        {
+          value: { facilitator: facilitator.url, token: token.config.symbol, network: token.network.config.name },
+          validOptions: supportedTokens
+        }
+      );
+    }
+  }
+  return { supported: true };
+};
+var validatePaymentConfig = (network, token, facilitators, payTo = "0x0000000000000000000000000000000000000000", amount = "1.0") => {
+  const resolvedNetwork = resolveNetwork(network);
+  if ("code" in resolvedNetwork) {
+    return resolvedNetwork;
+  }
+  const resolvedToken = resolveToken(token, resolvedNetwork);
+  if ("code" in resolvedToken) {
+    return resolvedToken;
+  }
+  const resolvedFacilitators = [];
+  if (facilitators) {
+    const facilitatorArray = Array.isArray(facilitators) ? facilitators : [facilitators];
+    for (const facilitator of facilitatorArray) {
+      const resolved = resolveFacilitator(facilitator, [resolvedNetwork], [resolvedToken]);
+      if ("code" in resolved) {
+        return resolved;
+      }
+      const supportCheck = checkFacilitatorSupport(resolved, resolvedNetwork, resolvedToken);
+      if ("code" in supportCheck) {
+        return supportCheck;
+      }
+      resolvedFacilitators.push(resolved);
+    }
+  }
+  return {
+    network: resolvedNetwork,
+    token: resolvedToken,
+    facilitators: resolvedFacilitators,
+    version: "auto",
+    payTo,
+    amount
+  };
+};
+var validateAcceptConfig = (options, payTo, amount) => {
+  const { networks: networkInputs, tokens: tokenInputs, facilitators, version = "auto" } = options;
+  const networkIds = networkInputs?.length ? networkInputs : Object.keys(NETWORKS);
+  const tokenIds = tokenInputs?.length ? tokenInputs : ["usdc"];
+  const networks = [];
+  for (const networkId of networkIds) {
+    const resolved = resolveNetwork(networkId);
+    if ("code" in resolved) {
+      return { success: false, error: resolved };
+    }
+    networks.push(resolved);
+  }
+  const tokens = [];
+  for (const tokenId of tokenIds) {
+    let found = false;
+    for (const network of networks) {
+      const resolved = resolveToken(tokenId, network);
+      if ("code" in resolved) {
+        continue;
+      }
+      tokens.push(resolved);
+      found = true;
+      break;
+    }
+    if (!found) {
+      return {
+        success: false,
+        error: createError(
+          "TOKEN_NOT_ON_NETWORK",
+          `Token "${String(tokenId)}" not found on any of the specified networks`,
+          { value: tokenId, validOptions: networks.map((n) => n.config.name) }
+        )
+      };
+    }
+  }
+  const facilitatorArray = facilitators ? Array.isArray(facilitators) ? facilitators : [facilitators] : [];
+  const resolvedFacilitators = [];
+  for (const facilitator of facilitatorArray) {
+    const resolved = resolveFacilitator(facilitator, networks, tokens);
+    if ("code" in resolved) {
+      return { success: false, error: resolved };
+    }
+    resolvedFacilitators.push(resolved);
+  }
+  const configs = [];
+  for (const network of networks) {
+    for (const token of tokens) {
+      if (token.network.config.chainId === network.config.chainId) {
+        configs.push({
+          network,
+          token,
+          facilitators: resolvedFacilitators,
+          version,
+          payTo,
+          amount
+        });
+      }
+    }
+  }
+  return { success: true, config: configs };
+};
+var isValidationError = (value) => {
+  return typeof value === "object" && value !== null && "code" in value;
+};
+var isResolvedNetwork = (value) => {
+  return typeof value === "object" && value !== null && "config" in value && "caip2" in value;
+};
+var isResolvedToken = (value) => {
+  return typeof value === "object" && value !== null && "config" in value && "caipAsset" in value;
+};
+export {
+  EIP712_TYPES,
+  ERC20_ABI,
+  NETWORKS,
+  USDC_DOMAIN,
+  V1_HEADERS,
+  V2_HEADERS,
+  checkFacilitatorSupport,
+  createEIP712Domain,
+  createError,
+  createTransferWithAuthorization,
+  decodePayment,
+  decodePaymentPayload,
+  decodePaymentV1,
+  decodePaymentV2,
+  decodeSettlement,
+  decodeSettlementResponse,
+  decodeSettlementV1,
+  decodeSettlementV2,
+  detectPaymentVersion,
+  encodePaymentPayload,
+  encodePaymentV1,
+  encodePaymentV2,
+  encodeSettlementResponse,
+  encodeSettlementV1,
+  encodeSettlementV2,
+  getAllCustomTokens,
+  getAvailableNetworks,
+  getAvailableTokens,
+  getCustomToken,
+  getMainnets,
+  getNetworkByChainId,
+  getNetworkConfig,
+  getPaymentHeaderName,
+  getPaymentRequiredHeaderName,
+  getPaymentResponseHeaderName,
+  getPaymentVersion as getPaymentVersionFromPayload,
+  getRequirementsVersion,
+  getSettlementVersion,
+  getTestnets,
+  getTxHash,
+  isAddress,
+  isCAIP2ChainId,
+  isCAIPAssetId,
+  isCustomToken,
+  isPaymentV1,
+  isPaymentV2,
+  isResolvedNetwork,
+  isResolvedToken,
+  isSettlementSuccessful,
+  isSettlementV1,
+  isSettlementV2,
+  isV1,
+  isV2,
+  isValidationError,
+  registerToken,
+  resolveFacilitator,
+  resolveNetwork,
+  resolveToken,
+  unregisterToken,
+  validateAcceptConfig,
+  validatePaymentConfig,
+  validateTransferWithAuthorization
+};

package/dist/types/networks.d.ts

@@ -0,0 +1,26 @@
+export interface NetworkConfig {
+    name: string;
+    chainId: number;
+    usdcAddress: `0x${string}`;
+    rpcUrl: string;
+    caip2Id: string;
+    caipAssetId: string;
+}
+export interface CustomToken {
+    symbol: string;
+    name: string;
+    version: string;
+    contractAddress: `0x${string}`;
+    chainId: 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 getCustomToken: (chainId: number, contractAddress: string) => CustomToken | undefined;
+export declare const getAllCustomTokens: () => CustomToken[];
+export declare const unregisterToken: (chainId: number, contractAddress: string) => boolean;
+export declare const isCustomToken: (chainId: number, contractAddress: string) => boolean;

package/dist/types/protocol.d.ts

@@ -0,0 +1,15 @@
+import type { PaymentPayloadV1, PaymentRequirementsV1, SettlementResponseV1 } from "./v1";
+import type { PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2 } from "./v2";
+export type PaymentPayload = PaymentPayloadV1 | PaymentPayloadV2;
+export type PaymentRequirements = PaymentRequirementsV1 | PaymentRequirementsV2;
+export type SettlementResponse = SettlementResponseV1 | SettlementResponseV2;
+export declare const isV1: (payload: PaymentPayload) => payload is PaymentPayloadV1;
+export declare const isV2: (payload: PaymentPayload) => payload is PaymentPayloadV2;
+export declare const getPaymentVersion: (payload: PaymentPayload) => 1 | 2;
+export declare const getRequirementsVersion: (requirements: PaymentRequirements) => 1 | 2;
+export declare const getSettlementVersion: (response: SettlementResponse) => 1 | 2;
+export declare const getPaymentHeaderName: (version: 1 | 2) => string;
+export declare const getPaymentResponseHeaderName: (version: 1 | 2) => string;
+export declare const getPaymentRequiredHeaderName: (version: 1 | 2) => string;
+export declare const isSettlementSuccessful: (response: SettlementResponse) => boolean;
+export declare const getTxHash: (response: SettlementResponse) => string | undefined;

package/dist/types/simple.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Simple, developer-friendly API types for Armory
+ * Focuses on DX/UX - "everything just magically works"
+ */
+import type { Address, CAIPAssetId } from "./v2";
+import type { NetworkConfig, CustomToken } from "./networks";
+/**
+ * Network identifier - flexible input that resolves to a chain
+ * - Network name: "base", "ethereum", "skale-base"
+ * - CAIP-2: "eip155:8453"
+ * - Chain ID: 8453
+ */
+export type NetworkId = string | number;
+/**
+ * Token identifier - flexible input that resolves to a token
+ * - Symbol: "usdc", "eurc", "usdt" (case-insensitive)
+ * - CAIP Asset ID: "eip155:8453/erc20:0x..."
+ * - Full token config object
+ */
+export type TokenId = string | CustomToken;
+/**
+ * Facilitator configuration
+ */
+export interface FacilitatorConfig {
+    /** Facilitator URL for verification/settlement */
+    url: string;
+    /** Optional authentication headers */
+    headers?: () => Record<string, string>;
+    /** Networks this facilitator supports (auto-detected if not provided) */
+    networks?: NetworkId[];
+    /** Tokens this facilitator supports (optional) */
+    tokens?: TokenId[];
+}
+/**
+ * Payment accept options for merchants (v2 multi-support)
+ */
+export interface AcceptPaymentOptions {
+    /** Networks to accept payments on */
+    networks?: NetworkId[];
+    /** Tokens to accept (defaults to ["usdc"]) */
+    tokens?: TokenId[];
+    /** Facilitator(s) for payment verification/settlement */
+    facilitators?: FacilitatorConfig | FacilitatorConfig[];
+    /** Protocol version (default: auto-detect) */
+    version?: 1 | 2 | "auto";
+}
+/**
+ * Result of a payment attempt
+ */
+export interface PaymentResult<T = unknown> {
+    /** Payment successful */
+    success: true;
+    /** Response data */
+    data: T;
+    /** Transaction hash (if settled) */
+    txHash?: string;
+}
+/**
+ * Payment error result
+ */
+export interface PaymentError {
+    /** Payment failed */
+    success: false;
+    /** Error code */
+    code: PaymentErrorCode;
+    /** Human-readable error message */
+    message: string;
+    /** Underlying error details */
+    details?: unknown;
+}
+/**
+ * Payment error codes
+ */
+export type PaymentErrorCode = "UNKNOWN_NETWORK" | "UNKNOWN_TOKEN" | "TOKEN_NOT_ON_NETWORK" | "FACILITATOR_UNSUPPORTED" | "FACILITATOR_NO_NETWORK_SUPPORT" | "FACILITATOR_NO_TOKEN_SUPPORT" | "INVALID_CAIP_FORMAT" | "CHAIN_MISMATCH" | "PAYMENT_REQUIRED" | "PAYMENT_DECLINED" | "SIGNING_FAILED" | "NETWORK_ERROR" | "VALIDATION_FAILED";
+/**
+ * Combined payment result type
+ */
+export type ArmoryPaymentResult<T = unknown> = PaymentResult<T> | PaymentError;
+/**
+ * Fully resolved network configuration
+ */
+export interface ResolvedNetwork {
+    /** Original input */
+    input: NetworkId;
+    /** Network config */
+    config: NetworkConfig;
+    /** CAIP-2 ID */
+    caip2: `eip155:${string}`;
+}
+/**
+ * Fully resolved token configuration
+ */
+export interface ResolvedToken {
+    /** Original input */
+    input: TokenId;
+    /** Token config */
+    config: CustomToken;
+    /** CAIP Asset ID */
+    caipAsset: CAIPAssetId;
+    /** Network this token is on */
+    network: ResolvedNetwork;
+}
+/**
+ * Fully resolved facilitator configuration
+ */
+export interface ResolvedFacilitator {
+    /** Original input */
+    input: FacilitatorConfig;
+    /** URL */
+    url: string;
+    /** Supported networks (resolved) */
+    networks: ResolvedNetwork[];
+    /** Supported tokens (resolved) */
+    tokens: ResolvedToken[];
+}
+/**
+ * Fully resolved payment configuration
+ */
+export interface ResolvedPaymentConfig {
+    /** Network to use */
+    network: ResolvedNetwork;
+    /** Token to use */
+    token: ResolvedToken;
+    /** Facilitator(s) to use */
+    facilitators: ResolvedFacilitator[];
+    /** Protocol version */
+    version: 1 | 2 | "auto";
+    /** Recipient address */
+    payTo: Address;
+    /** Amount to charge */
+    amount: string;
+}
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+    /** Error code */
+    code: PaymentErrorCode;
+    /** Error message */
+    message: string;
+    /** Path to the invalid value */
+    path?: string;
+    /** Invalid value */
+    value?: unknown;
+    /** Valid options */
+    validOptions?: string[];
+}

package/dist/types/v1.d.ts

@@ -0,0 +1,34 @@
+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 PaymentRequirementsV1 {
+    amount: string;
+    network: string;
+    contractAddress: string;
+    payTo: string;
+    expiry: number;
+}
+export interface SettlementResponseV1 {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+    timestamp: number;
+}
+export declare const V1_HEADERS: {
+    readonly PAYMENT: "X-PAYMENT";
+    readonly PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE";
+};
+export declare function encodePaymentPayload(payload: PaymentPayloadV1): string;
+export declare function decodePaymentPayload(encoded: string): PaymentPayloadV1;
+export declare function encodeSettlementResponse(response: SettlementResponseV1): string;
+export declare function decodeSettlementResponse(encoded: string): SettlementResponseV1;

package/dist/types/v2.d.ts

@@ -0,0 +1,50 @@
+export type CAIP2ChainId = `eip155:${string}`;
+export type CAIPAssetId = `eip155:${string}/erc20:${string}`;
+export type Address = `0x${string}`;
+export interface Signature {
+    v: number;
+    r: string;
+    s: string;
+}
+export type PayToV2 = Address | {
+    role?: string;
+    callback?: string;
+};
+export interface Extensions {
+    [key: string]: unknown;
+}
+export interface PaymentPayloadV2 {
+    from: Address;
+    to: PayToV2;
+    amount: string;
+    nonce: string;
+    expiry: number;
+    signature: Signature;
+    chainId: CAIP2ChainId;
+    assetId: CAIPAssetId;
+    extensions?: Extensions;
+}
+export interface PaymentRequirementsV2 {
+    amount: string;
+    to: PayToV2;
+    chainId: CAIP2ChainId;
+    assetId: CAIPAssetId;
+    nonce: string;
+    expiry: number;
+    extensions?: Extensions;
+}
+export interface SettlementResponseV2 {
+    status: "success" | "pending" | "failed";
+    txHash?: string;
+    txId?: string;
+    timestamp: number;
+    extensions?: Extensions;
+}
+export declare const V2_HEADERS: {
+    readonly PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE";
+    readonly PAYMENT_REQUIRED: "PAYMENT-REQUIRED";
+    readonly PAYMENT_RESPONSE: "PAYMENT-RESPONSE";
+};
+export declare function isCAIP2ChainId(value: string): value is CAIP2ChainId;
+export declare function isCAIPAssetId(value: string): value is CAIPAssetId;
+export declare function isAddress(value: string): value is Address;

package/dist/validation.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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";
+export declare const createError: (code: PaymentErrorCode, message: string, details?: Partial<ValidationError>) => ValidationError;
+/**
+ * Resolve a network identifier to a network config
+ */
+export declare const resolveNetwork: (input: NetworkId) => ResolvedNetwork | ValidationError;
+/**
+ * Get all available network names
+ */
+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 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[];
+    facilitators?: FacilitatorConfig | FacilitatorConfig[];
+    version?: 1 | 2 | "auto";
+}, payTo: string, amount: string) => {
+    success: true;
+    config: ResolvedPaymentConfig[];
+} | {
+    success: false;
+    error: ValidationError;
+};
+export declare const isValidationError: (value: unknown) => value is ValidationError;
+export declare const isResolvedNetwork: (value: unknown) => value is ResolvedNetwork;
+export declare const isResolvedToken: (value: unknown) => value is ResolvedToken;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@armory-sh/base",
+  "version": "0.2.0",
+  "license": "MIT",
+  "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thegreataxios/armory.git",
+    "directory": "packages/core"
+  },
+  "dependencies": {
+    "viem": "2.45.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.1",
+    "bun-types": "latest",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly",
+    "test": "bun test"
+  }
+}