@armory-sh/base 0.2.9 → 0.2.10

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 export type { Address as X402Address, Hex, X402Version, Scheme, Network as X402Network, ExactEvmAuthorization, ExactEvmPayload, PaymentPayload as X402PaymentPayload, UnsignedPaymentPayload as X402UnsignedPaymentPayload, PaymentRequirements as X402PaymentRequirements, SettlementResponse as X402SettlementResponse, VerifyResponse, X402Response, PaymentPayloadV1 as X402PayloadV1, PaymentPayloadV2 as X402PayloadV2, LegacyPaymentPayload as X402LegacyPayload, } from "./types/x402";
 export { X402_VERSION, SCHEMES, isPaymentPayload, isExactEvmPayload, legacyToPaymentPayload, } from "./types/x402";
 export { safeBase64Encode, safeBase64Decode, encodePayment, decodePayment, encodeSettlementResponse, decodeSettlementResponse, encodeX402Response, decodeX402Response, X402_HEADERS, detectPaymentVersion, extractPaymentFromHeaders, createPaymentRequiredHeaders, createSettlementHeaders, isLegacyV1, isLegacyV2, } from "./encoding/x402";
-export { createNonce, toAtomicUnits, fromAtomicUnits, parseSignature, combineSignature, caip2ToNetwork, networkToCaip2, getCurrentTimestamp, isValidAddress, normalizeAddress, } from "./utils/x402";
-export type { PaymentPayloadV1, PaymentRequirementsV1, SettlementResponseV1, } from "./types/v1";
-export { V1_HEADERS, encodePaymentPayload, decodePaymentPayload, encodeSettlementResponse as encodeSettlementResponseV1, decodeSettlementResponse as decodeSettlementResponseV1, } 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, getRequirementsVersion, getSettlementVersion, getPaymentHeaderName, getPaymentResponseHeaderName, getPaymentRequiredHeaderName, isSettlementSuccessful, getTxHash, } from "./types/protocol";
+export { createNonce, toAtomicUnits, fromAtomicUnits, caip2ToNetwork, networkToCaip2, getCurrentTimestamp, isValidAddress, normalizeAddress, } from "./utils/x402";
+export type { PaymentPayloadV1, PaymentRequirementsV1, SettlementResponseV1, X402PaymentPayloadV1, X402PaymentRequiredV1, X402PaymentRequirementsV1, X402SettlementResponseV1, X402SchemePayloadV1, EIP3009AuthorizationV1, LegacyPaymentPayloadV1, LegacyPaymentRequirementsV1, LegacySettlementResponseV1, } from "./types/v1";
+export { V1_HEADERS, encodeX402PaymentRequiredV1, decodeX402PaymentRequiredV1, encodeX402PaymentPayloadV1, decodeX402PaymentPayloadV1, encodeX402SettlementResponseV1, decodeX402SettlementResponseV1, isX402PaymentRequiredV1, isX402PaymentPayloadV1, isLegacyPaymentPayloadV1, encodePaymentPayloadLegacy, decodePaymentPayloadLegacy, encodeSettlementResponseLegacy, decodeSettlementResponseLegacy, } from "./types/v1";
+export { encodePaymentPayloadLegacy as encodePaymentPayload, decodePaymentPayloadLegacy as decodePaymentPayload } from "./types/v1";
+export type { CAIP2Network as CAIP2ChainId, CAIPAssetId, Address, Signature, PayToV2, Extensions, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, PaymentRequiredV2, ResourceInfo, EIP3009Authorization, SchemePayloadV2, } from "./types/v2";
+export { V2_HEADERS, isCAIP2ChainId, isCAIPAssetId, isAddress, isPaymentRequiredV2, isPaymentPayloadV2, assetIdToAddress, addressToAssetId, parseSignature as parseSignatureV2, combineSignature as combineSignatureV2, } from "./types/v2";
+export type { PaymentPayload, PaymentRequirements, SettlementResponse, PaymentRequired, } from "./types/protocol";
+export { isV1, isV2, isX402V1Payload, isX402V2Payload, isLegacyV1Payload, isX402V1Requirements, isX402V2Requirements, isX402V1Settlement, isX402V2Settlement, isX402V1PaymentRequired, isX402V2PaymentRequired, getPaymentVersion, getRequirementsVersion, getSettlementVersion, getPaymentRequiredVersion, 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";

package/dist/index.js

@@ -239,19 +239,6 @@ function fromAtomicUnits(amount, decimals = 6) {
   }
   return `${whole}.${fractional}`;
 }
-function parseSignature(signature) {
-  const hex = signature.startsWith("0x") ? signature.slice(2) : signature;
-  const r = `0x${hex.slice(0, 64)}`;
-  const s = `0x${hex.slice(64, 128)}`;
-  const v = parseInt(hex.slice(128, 130) || "1c", 16);
-  return { r, s, v };
-}
-function combineSignature(r, s, v) {
-  const rHex = r.startsWith("0x") ? r.slice(2) : r;
-  const sHex = s.startsWith("0x") ? s.slice(2) : s;
-  const vHex = v.toString(16).padStart(2, "0");
-  return `0x${rHex}${sHex}${vHex}`;
-}
 function caip2ToNetwork(caip2Id) {
   const match = caip2Id.match(/^eip155:(\d+)$/);
   if (!match) {
@@ -305,20 +292,48 @@ function normalizeAddress(address) {
 // src/types/v1.ts
 var V1_HEADERS = {
   PAYMENT: "X-PAYMENT",
-  PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE"
+  PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE",
+  PAYMENT_REQUIRED: "X-PAYMENT-REQUIRED"
 };
-function encodePaymentPayload(payload) {
+function encodeX402PaymentRequiredV1(data) {
+  return Buffer.from(JSON.stringify(data)).toString("base64");
+}
+function decodeX402PaymentRequiredV1(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+}
+function encodeX402PaymentPayloadV1(data) {
+  return Buffer.from(JSON.stringify(data)).toString("base64");
+}
+function decodeX402PaymentPayloadV1(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+}
+function encodeX402SettlementResponseV1(data) {
+  return Buffer.from(JSON.stringify(data)).toString("base64");
+}
+function decodeX402SettlementResponseV1(encoded) {
+  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+}
+function encodePaymentPayloadLegacy(payload) {
   return Buffer.from(JSON.stringify(payload)).toString("base64");
 }
-function decodePaymentPayload(encoded) {
+function decodePaymentPayloadLegacy(encoded) {
   return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
 }
-function encodeSettlementResponse2(response) {
+function encodeSettlementResponseLegacy(response) {
   return Buffer.from(JSON.stringify(response)).toString("base64");
 }
-function decodeSettlementResponse2(encoded) {
+function decodeSettlementResponseLegacy(encoded) {
   return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
 }
+function isX402PaymentRequiredV1(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "accepts" in obj && Array.isArray(obj.accepts);
+}
+function isX402PaymentPayloadV1(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "scheme" in obj && "network" in obj && "payload" in obj;
+}
+function isLegacyPaymentPayloadV1(obj) {
+  return typeof obj === "object" && obj !== null && "v" in obj && "r" in obj && "s" in obj && "chainId" in obj && "contractAddress" in obj;
+}
 
 // src/types/v2.ts
 var V2_HEADERS = {
@@ -335,18 +350,116 @@ function isCAIPAssetId(value) {
 function isAddress(value) {
   return /^0x[a-fA-F0-9]{40}$/.test(value);
 }
+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;
+}
+function assetIdToAddress(assetId) {
+  const match = assetId.match(/\/erc20:(0x[a-fA-F0-9]{40})$/);
+  if (!match) throw new Error(`Invalid CAIP asset ID: ${assetId}`);
+  return match[1];
+}
+function addressToAssetId(address, chainId) {
+  const chain = typeof chainId === "number" ? `eip155:${chainId}` : chainId;
+  if (!isCAIP2ChainId(chain)) throw new Error(`Invalid chain ID: ${chain}`);
+  return `${chain}/erc20:${address}`;
+}
+function parseSignature(signature) {
+  const sig = signature.slice(2);
+  return {
+    r: `0x${sig.slice(0, 64)}`,
+    s: `0x${sig.slice(64, 128)}`,
+    v: parseInt(sig.slice(128, 130), 16)
+  };
+}
+function combineSignature(v, r, s) {
+  const rClean = r.startsWith("0x") ? r.slice(2) : r;
+  const sClean = s.startsWith("0x") ? s.slice(2) : s;
+  const vHex = v.toString(16).padStart(2, "0");
+  return `0x${rClean}${sClean}${vHex}`;
+}
 
 // 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;
+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;
+}
+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);
+}
+function isLegacyV2Payload(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const record = obj;
+  const signature = record.signature;
+  return "signature" in record && typeof signature === "object" && signature !== null && "v" in signature && "chainId" in record && typeof record.chainId === "string" && record.chainId.startsWith("eip155:") && "assetId" in record && !("x402Version" in record);
+}
+function getPaymentVersion(payload) {
+  if (isX402V1Payload(payload)) return 1;
+  if (isX402V2Payload(payload)) return 2;
+  return 1;
+}
+function isX402V1Requirements(obj) {
+  return typeof obj === "object" && obj !== null && "scheme" in obj && "network" in obj && typeof obj.network === "string" && !obj.network.includes(":") && // Not CAIP-2 format
+  "maxAmountRequired" in obj;
+}
+function isX402V2Requirements(obj) {
+  return typeof obj === "object" && obj !== null && "scheme" in obj && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:") && // CAIP-2 format
+  "amount" in obj;
+}
+function getRequirementsVersion(requirements) {
+  if (isX402V1Requirements(requirements)) return 1;
+  if (isX402V2Requirements(requirements)) return 2;
+  return 1;
+}
+function isX402V1Settlement(obj) {
+  return typeof obj === "object" && obj !== null && "success" in obj && "network" in obj && typeof obj.network === "string" && !obj.network.includes(":");
+}
+function isX402V2Settlement(obj) {
+  return typeof obj === "object" && obj !== null && "success" in obj && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:");
+}
+function getSettlementVersion(response) {
+  if (isX402V1Settlement(response)) return 1;
+  if (isX402V2Settlement(response)) return 2;
+  return 1;
+}
+function isX402V1PaymentRequired(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "accepts" in obj;
+}
+function isX402V2PaymentRequired(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj;
+}
+function getPaymentRequiredVersion(obj) {
+  if (isX402V1PaymentRequired(obj)) return 1;
+  if (isX402V2PaymentRequired(obj)) return 2;
+  return 1;
+}
+function getPaymentHeaderName(version) {
+  return version === 1 ? "X-PAYMENT" : "PAYMENT-SIGNATURE";
+}
+function getPaymentResponseHeaderName(version) {
+  return version === 1 ? "X-PAYMENT-RESPONSE" : "PAYMENT-RESPONSE";
+}
+function getPaymentRequiredHeaderName(version) {
+  return version === 1 ? "X-PAYMENT-REQUIRED" : "PAYMENT-REQUIRED";
+}
+function isSettlementSuccessful(response) {
+  return "success" in response ? response.success : false;
+}
+function getTxHash(response) {
+  if ("transaction" in response) return response.transaction;
+  if ("txHash" in response) return response.txHash;
+  return void 0;
+}
+function isV1(obj) {
+  return isX402V1Payload(obj) || isLegacyV1Payload(obj);
+}
+function isV2(obj) {
+  return isX402V2Payload(obj) || isLegacyV2Payload(obj);
+}
 
 // src/types/networks.ts
 var tokenRegistry = /* @__PURE__ */ new Map();
@@ -978,9 +1091,11 @@ export {
   V2_HEADERS,
   X402_HEADERS,
   X402_VERSION,
+  addressToAssetId,
+  assetIdToAddress,
   caip2ToNetwork,
   checkFacilitatorSupport,
-  combineSignature,
+  combineSignature as combineSignatureV2,
   createEIP712Domain,
   createError,
   createNonce,
@@ -989,26 +1104,34 @@ export {
   createTransferWithAuthorization,
   decodePayment,
   decodePayment2 as decodePaymentLegacy,
-  decodePaymentPayload,
+  decodePaymentPayloadLegacy as decodePaymentPayload,
+  decodePaymentPayloadLegacy,
   decodePaymentV1,
   decodePaymentV2,
   decodeSettlement as decodeSettlementLegacy,
   decodeSettlementResponse,
-  decodeSettlementResponse2 as decodeSettlementResponseV1,
+  decodeSettlementResponseLegacy,
   decodeSettlementV1,
   decodeSettlementV2,
+  decodeX402PaymentPayloadV1,
+  decodeX402PaymentRequiredV1,
   decodeX402Response,
+  decodeX402SettlementResponseV1,
   detectPaymentVersion,
   detectPaymentVersion2 as detectPaymentVersionLegacy,
   encodePayment,
-  encodePaymentPayload,
+  encodePaymentPayloadLegacy as encodePaymentPayload,
+  encodePaymentPayloadLegacy,
   encodePaymentV1,
   encodePaymentV2,
   encodeSettlementResponse,
-  encodeSettlementResponse2 as encodeSettlementResponseV1,
+  encodeSettlementResponseLegacy,
   encodeSettlementV1,
   encodeSettlementV2,
+  encodeX402PaymentPayloadV1,
+  encodeX402PaymentRequiredV1,
   encodeX402Response,
+  encodeX402SettlementResponseV1,
   extractPaymentFromHeaders,
   fromAtomicUnits,
   getAllCustomTokens,
@@ -1021,6 +1144,7 @@ export {
   getNetworkConfig,
   getPaymentHeaderName,
   getPaymentRequiredHeaderName,
+  getPaymentRequiredVersion,
   getPaymentResponseHeaderName,
   getPaymentVersion,
   getRequirementsVersion,
@@ -1032,9 +1156,13 @@ export {
   isCAIPAssetId,
   isCustomToken,
   isExactEvmPayload,
+  isLegacyPaymentPayloadV1,
   isLegacyV1,
+  isLegacyV1Payload,
   isLegacyV2,
   isPaymentPayload,
+  isPaymentPayloadV2,
+  isPaymentRequiredV2,
   isPaymentV1,
   isPaymentV2,
   isResolvedNetwork,
@@ -1046,11 +1174,21 @@ export {
   isV2,
   isValidAddress,
   isValidationError,
+  isX402PaymentPayloadV1,
+  isX402PaymentRequiredV1,
+  isX402V1Payload,
+  isX402V1PaymentRequired,
+  isX402V1Requirements,
+  isX402V1Settlement,
+  isX402V2Payload,
+  isX402V2PaymentRequired,
+  isX402V2Requirements,
+  isX402V2Settlement,
   legacyToPaymentPayload,
   networkToCaip2,
   normalizeAddress,
   normalizeNetworkName,
-  parseSignature,
+  parseSignature as parseSignatureV2,
   registerToken,
   resolveFacilitator,
   resolveNetwork,

package/dist/types/protocol.d.ts

@@ -1,15 +1,107 @@
-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;
+/**
+ * Protocol Union Types and Version Detection
+ *
+ * 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";
+/**
+ * All x402 compatible payment payload types
+ */
+export type PaymentPayload = X402PaymentPayloadV1 | PaymentPayloadV2 | LegacyPaymentPayloadV1;
+/**
+ * All x402 compatible payment requirements types
+ */
+export type PaymentRequirements = X402PaymentRequirementsV1 | PaymentRequirementsV2 | LegacyPaymentRequirementsV1;
+/**
+ * All x402 compatible settlement response types
+ */
+export type SettlementResponse = X402SettlementResponseV1 | SettlementResponseV2 | LegacySettlementResponseV1;
+/**
+ * All x402 compatible payment required response types
+ */
+export type PaymentRequired = X402PaymentRequiredV1 | PaymentRequiredV2;
+/**
+ * Check if payload is x402 V1 format
+ */
+export declare function isX402V1Payload(obj: unknown): obj is X402PaymentPayloadV1;
+/**
+ * Check if payload is x402 V2 format
+ */
+export declare function isX402V2Payload(obj: unknown): obj is PaymentPayloadV2;
+/**
+ * Check if payload is legacy Armory V1 format
+ */
+export declare function isLegacyV1Payload(obj: unknown): obj is LegacyPaymentPayloadV1;
+/**
+ * Check if payload is legacy Armory V2 format
+ */
+export declare function isLegacyV2Payload(obj: unknown): boolean;
+/**
+ * Get x402 version from payload
+ */
+export declare function getPaymentVersion(payload: PaymentPayload): 1 | 2;
+/**
+ * Check if requirements is x402 V1 format
+ */
+export declare function isX402V1Requirements(obj: unknown): obj is X402PaymentRequirementsV1;
+/**
+ * Check if requirements is x402 V2 format
+ */
+export declare function isX402V2Requirements(obj: unknown): obj is PaymentRequirementsV2;
+/**
+ * Get x402 version from requirements
+ */
+export declare function getRequirementsVersion(requirements: PaymentRequirements): 1 | 2;
+/**
+ * Check if settlement response is x402 V1 format
+ */
+export declare function isX402V1Settlement(obj: unknown): obj is X402SettlementResponseV1;
+/**
+ * Check if settlement response is x402 V2 format
+ */
+export declare function isX402V2Settlement(obj: unknown): obj is SettlementResponseV2;
+/**
+ * Get x402 version from settlement response
+ */
+export declare function getSettlementVersion(response: SettlementResponse): 1 | 2;
+/**
+ * Check if payment required is x402 V1 format
+ */
+export declare function isX402V1PaymentRequired(obj: unknown): obj is X402PaymentRequiredV1;
+/**
+ * Check if payment required is x402 V2 format
+ */
+export declare function isX402V2PaymentRequired(obj: unknown): obj is PaymentRequiredV2;
+/**
+ * Get x402 version from payment required
+ */
+export declare function getPaymentRequiredVersion(obj: PaymentRequired): 1 | 2;
+/**
+ * Get payment header name for version
+ */
+export declare function getPaymentHeaderName(version: 1 | 2): string;
+/**
+ * Get payment response header name for version
+ */
+export declare function getPaymentResponseHeaderName(version: 1 | 2): string;
+/**
+ * Get payment required header name for version
+ */
+export declare function getPaymentRequiredHeaderName(version: 1 | 2): string;
+/**
+ * Check if settlement was successful
+ */
+export declare function isSettlementSuccessful(response: SettlementResponse): boolean;
+/**
+ * Get transaction hash from settlement response
+ */
+export declare function getTxHash(response: SettlementResponse): string | undefined;
+/**
+ * @deprecated Use isX402V1Payload or isLegacyV1Payload instead
+ */
+export declare function isV1(obj: unknown): boolean;
+/**
+ * @deprecated Use isX402V2Payload or isLegacyV2Payload instead
+ */
+export declare function isV2(obj: unknown): boolean;

package/dist/types/v1.d.ts

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

package/dist/types/v2.d.ts

@@ -1,4 +1,12 @@
-export type CAIP2ChainId = `eip155:${string}`;
+/**
+ * Armory V2 Types - x402 Protocol V2 Compatible
+ *
+ * These types match the Coinbase x402 V2 specification for full interoperability.
+ * No conversion needed - this is the native format.
+ *
+ * Specification: https://github.com/coinbase/x402
+ */
+export type CAIP2Network = `eip155:${string}`;
 export type CAIPAssetId = `eip155:${string}/erc20:${string}`;
 export type Address = `0x${string}`;
 export interface Signature {
@@ -13,31 +21,112 @@ export type PayToV2 = Address | {
 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;
+/**
+ * Resource information describing the protected resource
+ */
+export interface ResourceInfo {
+    /** URL of the protected resource */
+    url: string;
+    /** Human-readable description of the resource */
+    description?: string;
+    /** MIME type of the expected response */
+    mimeType?: string;
 }
+/**
+ * Payment requirements for a specific payment method
+ * Matches x402 V2 PaymentRequirements spec
+ */
 export interface PaymentRequirementsV2 {
+    /** Payment scheme identifier (e.g., "exact") */
+    scheme: "exact";
+    /** Blockchain network identifier in CAIP-2 format */
+    network: CAIP2Network;
+    /** Required payment amount in atomic token units */
     amount: string;
-    to: PayToV2;
-    chainId: CAIP2ChainId;
-    assetId: CAIPAssetId;
-    nonce: string;
-    expiry: number;
+    /** Token contract address (extracted from CAIP asset ID) */
+    asset: Address;
+    /** Recipient wallet address or role constant */
+    payTo: Address;
+    /** Maximum time allowed for payment completion */
+    maxTimeoutSeconds: number;
+    /** Scheme-specific additional information (token name, version, etc.) */
+    extra?: Extensions;
+}
+/**
+ * Payment required response (PAYMENT-REQUIRED header)
+ * Matches x402 V2 PaymentRequired spec
+ */
+export interface PaymentRequiredV2 {
+    /** Protocol version identifier (must be 2) */
+    x402Version: 2;
+    /** Human-readable error message */
+    error?: string;
+    /** Resource being accessed */
+    resource: ResourceInfo;
+    /** Array of acceptable payment methods */
+    accepts: PaymentRequirementsV2[];
+    /** Protocol extensions data */
+    extensions?: Extensions;
+}
+/**
+ * EIP-3009 TransferWithAuthorization authorization data
+ * Matches x402 V2 spec for exact scheme
+ */
+export interface EIP3009Authorization {
+    /** Payer's wallet address */
+    from: Address;
+    /** Recipient's wallet address */
+    to: Address;
+    /** Payment amount in atomic units */
+    value: string;
+    /** Unix timestamp when authorization becomes valid */
+    validAfter: string;
+    /** Unix timestamp when authorization expires */
+    validBefore: string;
+    /** 32-byte random nonce (bytes32 hex string) */
+    nonce: `0x${string}`;
+}
+/**
+ * Scheme-specific payment payload data
+ */
+export interface SchemePayloadV2 {
+    /** Signature for the authorization (0x-prefixed 65-byte hex) */
+    signature: `0x${string}`;
+    /** EIP-3009 authorization */
+    authorization: EIP3009Authorization;
+}
+/**
+ * Payment payload sent by client
+ * Matches x402 V2 PaymentPayload spec
+ */
+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;
+    /** Scheme-specific payment data */
+    payload: SchemePayloadV2;
+    /** Protocol extensions data */
     extensions?: Extensions;
 }
+/**
+ * Settlement response after payment settlement
+ * Matches x402 V2 SettlementResponse spec
+ */
 export interface SettlementResponseV2 {
-    status: "success" | "pending" | "failed";
-    txHash?: string;
-    txId?: string;
-    timestamp: number;
+    /** Whether settlement was successful */
+    success: boolean;
+    /** Error reason if settlement failed */
+    errorReason?: string;
+    /** Address of the payer's wallet */
+    payer?: Address;
+    /** Blockchain transaction hash (empty if failed) */
+    transaction: string;
+    /** Blockchain network identifier in CAIP-2 format */
+    network: CAIP2Network;
+    /** Protocol extensions data */
     extensions?: Extensions;
 }
 export declare const V2_HEADERS: {
@@ -45,6 +134,24 @@ export declare const V2_HEADERS: {
     readonly PAYMENT_REQUIRED: "PAYMENT-REQUIRED";
     readonly PAYMENT_RESPONSE: "PAYMENT-RESPONSE";
 };
-export declare function isCAIP2ChainId(value: string): value is CAIP2ChainId;
+export declare function isCAIP2ChainId(value: string): value is CAIP2Network;
 export declare function isCAIPAssetId(value: string): value is CAIPAssetId;
 export declare function isAddress(value: string): value is Address;
+export declare function isPaymentRequiredV2(obj: unknown): obj is PaymentRequiredV2;
+export declare function isPaymentPayloadV2(obj: unknown): obj is PaymentPayloadV2;
+/**
+ * Extract token address from CAIP asset ID
+ */
+export declare function assetIdToAddress(assetId: CAIPAssetId): Address;
+/**
+ * Create CAIP asset ID from token address and chain ID
+ */
+export declare function addressToAssetId(address: Address, chainId: string | number): CAIPAssetId;
+/**
+ * Parse combined signature (0x + r + s + v) into components
+ */
+export declare function parseSignature(signature: `0x${string}`): Signature;
+/**
+ * Combine signature components into 65-byte hex string
+ */
+export declare function combineSignature(v: number, r: string, s: string): `0x${string}`;

package/package.json

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