@armory-sh/client-ethers 0.2.18 → 0.2.20-alpha.3.11

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PaymentRequirementsV2, Address, PaymentPayloadV2, CustomToken } from '@armory-sh/base';
+import { PaymentRequirementsV2, Address, PaymentPayloadV2, CustomToken, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
 export { Address, BalanceOfParams, CAIP2ChainId, CAIPAssetId, EIP712_TYPES, ERC20_ABI, Extensions, NETWORKS, NetworkConfig, PayToV2, PaymentPayload, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV2, SettlementResponse, SettlementResponseV2, Signature, TransferWithAuthorizationParams, V2_HEADERS, createEIP712Domain, createTransferWithAuthorization, decodePayment, decodePaymentV2, decodeSettlementV2, detectPaymentVersion, encodePaymentV2, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getTestnets, getTxHash, isCAIP2ChainId, isCAIPAssetId, isPaymentV2, isSettlementSuccessful, isSettlementV2, isX402V2PaymentRequired, safeBase64Decode, validateTransferWithAuthorization } from '@armory-sh/base';
 import { Signer, Provider } from 'ethers';
 export { Provider, Signer } from 'ethers';
@@ -198,4 +198,116 @@ declare function createX402Client(config: X402ClientConfig & SignerClientConfig
 }): X402Client;
 declare function createX402Client(config: X402ClientConfig & ProviderClientConfig): X402Client;
 
-export { AuthorizationError, type ClientConfig, type ParsedPaymentRequirements, PaymentError, ProviderRequiredError, SignerRequiredError, SigningError, type X402Client, type X402ClientConfig, X402ClientError, type X402RequestInit, type X402Transport, type X402TransportConfig, createX402Client, createX402Payment, createX402Transport, detectX402Version, encodeX402Payment, getPaymentHeaderName, parsePaymentRequired, recoverEIP3009Signer, signEIP3009, signEIP3009WithDomain, signPayment };
+/**
+ * Simple one-line payment API for Armory (Ethers)
+ * Focus on DX/UX - "everything just magically works"
+ */
+
+/**
+ * Simple wallet input - accepts wallet directly or wrapped for backward compatibility
+ */
+type SimpleWalletInput = Signer | {
+    signer: Signer;
+};
+/**
+ * Normalized wallet (internal use)
+ */
+type NormalizedWallet = Signer;
+/**
+ * Normalize wallet input to internal format
+ */
+declare const normalizeWallet: (wallet: SimpleWalletInput) => NormalizedWallet;
+/**
+ * Make a payment-protected API request with one line of code
+ */
+declare const armoryPay: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, options?: {
+    /** Request method (default: GET) */
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    /** Request body (for POST/PUT/PATCH) */
+    body?: unknown;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Protocol version (V2 only) */
+    version?: 2;
+    /** Payment amount in token units (default: from 402 header) */
+    amount?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Make a GET request with payment
+ */
+declare const armoryGet: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, options?: Omit<Parameters<typeof armoryPay>[4], "method">) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Make a POST request with payment
+ */
+declare const armoryPost: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, body?: unknown, options?: Omit<Parameters<typeof armoryPay>[4], "method" | "body">) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Make a PUT request with payment
+ */
+declare const armoryPut: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, body?: unknown, options?: Omit<Parameters<typeof armoryPay>[4], "method" | "body">) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Make a DELETE request with payment
+ */
+declare const armoryDelete: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, options?: Omit<Parameters<typeof armoryPay>[4], "method">) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Make a PATCH request with payment
+ */
+declare const armoryPatch: <T = unknown>(wallet: SimpleWalletInput, url: string, network: NetworkId, token: TokenId, body?: unknown, options?: Omit<Parameters<typeof armoryPay>[4], "method" | "body">) => Promise<ArmoryPaymentResult<T>>;
+/**
+ * Get the wallet address from a SimpleWalletInput
+ */
+declare const getWalletAddress: (wallet: SimpleWalletInput) => Promise<string>;
+/**
+ * Validate a network identifier without making a request
+ */
+declare const validateNetwork: (network: NetworkId) => ValidationError | {
+    success: true;
+    network: string;
+};
+/**
+ * Validate a token identifier without making a request
+ */
+declare const validateToken: (token: TokenId, network?: NetworkId) => ValidationError | {
+    success: true;
+    token: string;
+    network: string;
+};
+/**
+ * Get list of available networks
+ */
+declare const getNetworks: () => string[];
+/**
+ * Get list of available tokens
+ */
+declare const getTokens: () => string[];
+
+/**
+ * Armory API - Simplified payment interface (Ethers)
+ * Provides a configurable object with method-based payment functions
+ */
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+interface ArmoryConfig {
+    wallet: SimpleWalletInput;
+    methods?: HttpMethod[] | HttpMethod;
+    tokens?: TokenId[] | TokenId;
+    chains?: NetworkId[] | NetworkId;
+    debug?: boolean;
+}
+interface PaymentOptions {
+    method?: HttpMethod;
+    body?: unknown;
+}
+interface ArmoryInstance {
+    get<T>(url: string, body?: unknown): Promise<ArmoryPaymentResult<T>>;
+    post<T>(url: string, body?: unknown): Promise<ArmoryPaymentResult<T>>;
+    put<T>(url: string, body?: unknown): Promise<ArmoryPaymentResult<T>>;
+    delete<T>(url: string): Promise<ArmoryPaymentResult<T>>;
+    patch<T>(url: string, body?: unknown): Promise<ArmoryPaymentResult<T>>;
+    pay<T>(url: string, options?: PaymentOptions): Promise<ArmoryPaymentResult<T>>;
+    call<T>(url: string): Promise<ArmoryPaymentResult<T>>;
+}
+declare const createArmory: (config: ArmoryConfig) => ArmoryInstance;
+
+export { type ArmoryConfig, type ArmoryInstance, AuthorizationError, type ClientConfig, type HttpMethod, type NormalizedWallet, type ParsedPaymentRequirements, PaymentError, type PaymentOptions, ProviderRequiredError, SignerRequiredError, SigningError, type SimpleWalletInput, type X402Client, type X402ClientConfig, X402ClientError, type X402RequestInit, type X402Transport, type X402TransportConfig, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, createArmory, createX402Client, createX402Payment, createX402Transport, detectX402Version, encodeX402Payment, getNetworks, getPaymentHeaderName, getTokens, getWalletAddress, normalizeWallet, parsePaymentRequired, recoverEIP3009Signer, signEIP3009, signEIP3009WithDomain, signPayment, validateNetwork, validateToken };

package/dist/index.js

@@ -1,47 +1,13 @@
-// src/index.ts
-import {
-  V2_HEADERS as V2_HEADERS3,
-  isSettlementSuccessful as isSettlementSuccessful2,
-  getTxHash,
-  NETWORKS,
-  getNetworkConfig as getNetworkConfig2,
-  getNetworkByChainId as getNetworkByChainId2,
-  getMainnets,
-  getTestnets,
-  ERC20_ABI,
-  encodePaymentV2,
-  decodePaymentV2,
-  encodeSettlementV2,
-  decodeSettlementV2 as decodeSettlementV22,
-  detectPaymentVersion,
-  decodePayment,
-  isPaymentV2,
-  isSettlementV2,
-  isX402V2PaymentRequired as isX402V2PaymentRequired2,
-  EIP712_TYPES as EIP712_TYPES2,
-  createEIP712Domain as createEIP712Domain3,
-  createTransferWithAuthorization as createTransferWithAuthorization2,
-  validateTransferWithAuthorization,
-  isCAIP2ChainId,
-  isCAIPAssetId,
-  safeBase64Decode
-} from "@armory-sh/base";
+import { createEIP712Domain, V2_HEADERS, isX402V2PaymentRequired, validatePaymentConfig, isValidationError, resolveNetwork, resolveToken, getNetworkConfig, normalizeNetworkName, decodeSettlementV2 } from '@armory-sh/base';
+export { EIP712_TYPES, ERC20_ABI, NETWORKS, V2_HEADERS, createEIP712Domain, createTransferWithAuthorization, decodePayment, decodePaymentV2, decodeSettlementV2, detectPaymentVersion, encodePaymentV2, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getTestnets, getTxHash, isCAIP2ChainId, isCAIPAssetId, isPaymentV2, isSettlementSuccessful, isSettlementV2, isX402V2PaymentRequired, safeBase64Decode, validateTransferWithAuthorization } from '@armory-sh/base';
+import { ethers } from 'ethers';
 
-// src/protocol.ts
-import {
-  V2_HEADERS,
-  isX402V2PaymentRequired,
-  getNetworkByChainId,
-  getNetworkConfig,
-  createEIP712Domain as createEIP712Domain2,
-  normalizeNetworkName
-} from "@armory-sh/base";
-
-// src/eip3009.ts
-import { ethers } from "ethers";
-import {
-  createEIP712Domain
-} from "@armory-sh/base";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/errors.ts
 var X402ClientError = class extends Error {
@@ -199,7 +165,7 @@ function createNonce() {
 async function createX402V2Payment(signer, requirements, fromAddress, nonce, validBefore, domainName, domainVersion) {
   const contractAddress = requirements.asset;
   const chainId = extractChainId(requirements.network);
-  const domain = createEIP712Domain2(chainId, contractAddress);
+  const domain = createEIP712Domain(chainId, contractAddress);
   const customDomain = domainName || domainVersion ? { ...domain, name: domainName ?? domain.name, version: domainVersion ?? domain.version } : domain;
   const authorization = {
     from: fromAddress,
@@ -246,12 +212,6 @@ async function createX402Payment(signer, parsed, fromAddress, nonce, validBefore
 function encodeX402Payment(payload) {
   return Buffer.from(JSON.stringify(payload)).toString("base64");
 }
-
-// src/transport.ts
-import {
-  decodeSettlementV2,
-  V2_HEADERS as V2_HEADERS2
-} from "@armory-sh/base";
 var defaultConfig = {
   baseURL: "",
   headers: {},
@@ -302,7 +262,7 @@ var handlePaymentRequired = async (state, response) => {
       },
       state.config.timeout
     );
-    const settlement = decodeSettlementV2(paymentResponse.headers.get(V2_HEADERS2.PAYMENT_RESPONSE) || "");
+    const settlement = decodeSettlementV2(paymentResponse.headers.get(V2_HEADERS.PAYMENT_RESPONSE) || "");
     return { success: true, settlement };
   } catch (error) {
     return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
@@ -394,47 +354,185 @@ function createX402Client(config) {
     getSigner: () => transport.getSigner()
   };
 }
-export {
-  AuthorizationError,
-  EIP712_TYPES2 as EIP712_TYPES,
-  ERC20_ABI,
-  NETWORKS,
-  PaymentError,
-  ProviderRequiredError,
-  SignerRequiredError,
-  SigningError,
-  V2_HEADERS3 as V2_HEADERS,
-  X402ClientError,
-  createEIP712Domain3 as createEIP712Domain,
-  createTransferWithAuthorization2 as createTransferWithAuthorization,
-  createX402Client,
-  createX402Payment,
-  createX402Transport,
-  decodePayment,
-  decodePaymentV2,
-  decodeSettlementV22 as decodeSettlementV2,
-  detectPaymentVersion,
-  detectX402Version,
-  encodePaymentV2,
-  encodeSettlementV2,
-  encodeX402Payment,
-  getMainnets,
-  getNetworkByChainId2 as getNetworkByChainId,
-  getNetworkConfig2 as getNetworkConfig,
-  getPaymentHeaderName,
-  getTestnets,
-  getTxHash,
-  isCAIP2ChainId,
-  isCAIPAssetId,
-  isPaymentV2,
-  isSettlementSuccessful2 as isSettlementSuccessful,
-  isSettlementV2,
-  isX402V2PaymentRequired2 as isX402V2PaymentRequired,
-  parsePaymentRequired,
-  recoverEIP3009Signer,
-  safeBase64Decode,
-  signEIP3009,
-  signEIP3009WithDomain,
-  signPayment,
-  validateTransferWithAuthorization
+var normalizeWallet = (wallet) => {
+  if (typeof wallet === "object" && wallet !== null && "signer" in wallet) {
+    return wallet.signer;
+  }
+  return wallet;
+};
+var armoryPay = async (wallet, url, network, token, options) => {
+  try {
+    const signer = normalizeWallet(wallet);
+    const config = validatePaymentConfig(network, token);
+    if (isValidationError(config)) {
+      return {
+        success: false,
+        code: config.code,
+        message: config.message,
+        details: config
+      };
+    }
+    const transport = createX402Transport();
+    transport.setSigner(signer);
+    const method = options?.method ?? "GET";
+    const headers = { ...options?.headers };
+    let response;
+    if (method === "GET") {
+      response = await transport.get(url, { headers });
+    } else if (method === "POST") {
+      response = await transport.post(url, options?.body, { headers });
+    } else if (method === "PUT") {
+      response = await transport.put(url, options?.body, { headers });
+    } else if (method === "DELETE") {
+      response = await transport.del(url, { headers });
+    } else if (method === "PATCH") {
+      response = await transport.patch(url, options?.body, { headers });
+    } else {
+      response = await transport.fetch(url, { method, headers });
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      return {
+        success: false,
+        code: "PAYMENT_DECLINED",
+        message: `Request failed: ${response.status} ${error}`
+      };
+    }
+    const data = await response.json();
+    const txHash = response.headers.get("X-PAYMENT-RESPONSE") || response.headers.get("PAYMENT-RESPONSE");
+    return {
+      success: true,
+      data,
+      ...txHash && { txHash }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      code: "NETWORK_ERROR",
+      message: error instanceof Error ? error.message : "Unknown error occurred",
+      details: error
+    };
+  }
+};
+var armoryGet = (wallet, url, network, token, options) => {
+  return armoryPay(wallet, url, network, token, { ...options, method: "GET" });
+};
+var armoryPost = (wallet, url, network, token, body, options) => {
+  return armoryPay(wallet, url, network, token, { ...options, method: "POST", body });
+};
+var armoryPut = (wallet, url, network, token, body, options) => {
+  return armoryPay(wallet, url, network, token, { ...options, method: "PUT", body });
+};
+var armoryDelete = (wallet, url, network, token, options) => {
+  return armoryPay(wallet, url, network, token, { ...options, method: "DELETE" });
+};
+var armoryPatch = (wallet, url, network, token, body, options) => {
+  return armoryPay(wallet, url, network, token, { ...options, method: "PATCH", body });
+};
+var getWalletAddress = async (wallet) => {
+  const signer = normalizeWallet(wallet);
+  return signer.getAddress();
 };
+var validateNetwork = (network) => {
+  const resolved = resolveNetwork(network);
+  if (isValidationError(resolved)) {
+    return resolved;
+  }
+  return { success: true, network: resolved.config.name };
+};
+var validateToken = (token, network) => {
+  let resolvedNetwork = void 0;
+  if (network) {
+    const networkResult = resolveNetwork(network);
+    if (isValidationError(networkResult)) {
+      return networkResult;
+    }
+    resolvedNetwork = networkResult;
+  }
+  const resolved = resolveToken(token, resolvedNetwork);
+  if (isValidationError(resolved)) {
+    return resolved;
+  }
+  return {
+    success: true,
+    token: resolved.config.symbol,
+    network: resolved.network.config.name
+  };
+};
+var getNetworks = () => {
+  const { getAvailableNetworks } = __require("@armory-sh/base");
+  return getAvailableNetworks();
+};
+var getTokens = () => {
+  const { getAvailableTokens } = __require("@armory-sh/base");
+  return getAvailableTokens();
+};
+var ALL_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+var arrayify = (value) => {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+};
+var normalizeArmoryConfig = (config) => ({
+  wallet: normalizeWallet(config.wallet),
+  allowedMethods: config.methods ? new Set(arrayify(config.methods)) : ALL_METHODS,
+  allowedTokens: arrayify(config.tokens) ?? [],
+  allowedChains: arrayify(config.chains) ?? [],
+  debug: config.debug ?? false
+});
+var createArmory = (config) => {
+  const internal = normalizeArmoryConfig(config);
+  const transport = createX402Transport();
+  transport.setSigner(internal.wallet);
+  const makeRequest = async (url, method, body) => {
+    try {
+      let response;
+      const headers = {};
+      if (method === "GET") {
+        response = await transport.get(url, { headers });
+      } else if (method === "POST") {
+        response = await transport.post(url, body, { headers });
+      } else if (method === "PUT") {
+        response = await transport.put(url, body, { headers });
+      } else if (method === "DELETE") {
+        response = await transport.del(url, { headers });
+      } else if (method === "PATCH") {
+        response = await transport.patch(url, body, { headers });
+      } else {
+        response = await transport.fetch(url, { method, headers });
+      }
+      if (!response.ok) {
+        const error = await response.text();
+        return {
+          success: false,
+          code: "PAYMENT_DECLINED",
+          message: `Request failed: ${response.status} ${error}`
+        };
+      }
+      const data = await response.json();
+      const txHash = response.headers.get("X-PAYMENT-RESPONSE") || response.headers.get("PAYMENT-RESPONSE");
+      return {
+        success: true,
+        data,
+        ...txHash && { txHash }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        code: "NETWORK_ERROR",
+        message: error instanceof Error ? error.message : "Unknown error occurred",
+        details: error
+      };
+    }
+  };
+  return {
+    get: (url, body) => makeRequest(url, "GET", body),
+    post: (url, body) => makeRequest(url, "POST", body),
+    put: (url, body) => makeRequest(url, "PUT", body),
+    delete: (url) => makeRequest(url, "DELETE"),
+    patch: (url, body) => makeRequest(url, "PATCH", body),
+    pay: (url, options) => makeRequest(url, options?.method ?? "GET", options?.body),
+    call: (url) => makeRequest(url, "GET")
+  };
+};
+
+export { AuthorizationError, PaymentError, ProviderRequiredError, SignerRequiredError, SigningError, X402ClientError, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, createArmory, createX402Client, createX402Payment, createX402Transport, detectX402Version, encodeX402Payment, getNetworks, getPaymentHeaderName, getTokens, getWalletAddress, normalizeWallet, parsePaymentRequired, recoverEIP3009Signer, signEIP3009, signEIP3009WithDomain, signPayment, validateNetwork, validateToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-ethers",
-  "version": "0.2.18",
+  "version": "0.2.20-alpha.3.11",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -23,11 +23,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/thegreataxios/armory.git",
+    "url": "https://github.com/TheGreatAxios/armory",
     "directory": "packages/client-ethers"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.19",
+    "@armory-sh/base": "^0.2.21",
     "ethers": "6.16.0"
   },
   "devDependencies": {