@armory-sh/client-ethers 0.2.18 → 0.2.19

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,3 +1,10 @@
+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/index.ts
 import {
   V2_HEADERS as V2_HEADERS3,
@@ -5,7 +12,7 @@ import {
   getTxHash,
   NETWORKS,
   getNetworkConfig as getNetworkConfig2,
-  getNetworkByChainId as getNetworkByChainId2,
+  getNetworkByChainId as getNetworkByChainId3,
   getMainnets,
   getTestnets,
   ERC20_ABI,
@@ -394,6 +401,200 @@ function createX402Client(config) {
     getSigner: () => transport.getSigner()
   };
 }
+
+// src/payment-api.ts
+import {
+  resolveNetwork,
+  resolveToken,
+  validatePaymentConfig,
+  isValidationError
+} from "@armory-sh/base";
+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();
+};
+
+// src/armory-api.ts
+import {
+  resolveNetwork as resolveNetwork2,
+  resolveToken as resolveToken2
+} from "@armory-sh/base";
+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,
   EIP712_TYPES2 as EIP712_TYPES,
@@ -405,6 +606,13 @@ export {
   SigningError,
   V2_HEADERS3 as V2_HEADERS,
   X402ClientError,
+  armoryDelete,
+  armoryGet,
+  armoryPatch,
+  armoryPay,
+  armoryPost,
+  armoryPut,
+  createArmory,
   createEIP712Domain3 as createEIP712Domain,
   createTransferWithAuthorization2 as createTransferWithAuthorization,
   createX402Client,
@@ -419,22 +627,28 @@ export {
   encodeSettlementV2,
   encodeX402Payment,
   getMainnets,
-  getNetworkByChainId2 as getNetworkByChainId,
+  getNetworkByChainId3 as getNetworkByChainId,
   getNetworkConfig2 as getNetworkConfig,
+  getNetworks,
   getPaymentHeaderName,
   getTestnets,
+  getTokens,
   getTxHash,
+  getWalletAddress,
   isCAIP2ChainId,
   isCAIPAssetId,
   isPaymentV2,
   isSettlementSuccessful2 as isSettlementSuccessful,
   isSettlementV2,
   isX402V2PaymentRequired2 as isX402V2PaymentRequired,
+  normalizeWallet,
   parsePaymentRequired,
   recoverEIP3009Signer,
   safeBase64Decode,
   signEIP3009,
   signEIP3009WithDomain,
   signPayment,
+  validateNetwork,
+  validateToken,
   validateTransferWithAuthorization
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-ethers",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,7 +27,7 @@
     "directory": "packages/client-ethers"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.19",
+    "@armory-sh/base": "^0.2.20",
     "ethers": "6.16.0"
   },
   "devDependencies": {