@armory-sh/client-web3 0.2.14 → 0.2.16

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
-import { NetworkConfig, CustomToken, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2 } from '@armory-sh/base';
+import { NetworkConfig, CustomToken, PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
 export { EIP3009Authorization, PaymentPayloadV2, PaymentRequirementsV2, SchemePayloadV2, SettlementResponseV2 } from '@armory-sh/base';
 
 type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>;
@@ -7,7 +7,7 @@ type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>
 type Token = CustomToken;
 interface Web3ClientConfig {
     account: Web3Account;
-    network: NetworkConfig | string;
+    network?: NetworkConfig | string;
     version?: 2;
     rpcUrl?: string;
     /** Pre-configured token object (overrides individual fields below) */
@@ -44,7 +44,7 @@ interface X402Transport {
 interface Web3X402Client {
     fetch(url: string | Request, init?: RequestInit): Promise<Response>;
     getAccount(): Web3Account;
-    getNetwork(): NetworkConfig;
+    getNetwork(): NetworkConfig | undefined;
     getVersion(): 2;
     signPayment(options: PaymentSignOptions): Promise<PaymentSignatureResult>;
     createPaymentHeaders(options: PaymentSignOptions): Promise<Headers>;
@@ -95,4 +95,114 @@ declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domai
     s: string;
 }>;
 
-export { adjustVForChainId, concatenateSignature, createEIP712Domain, createTransferWithAuthorization, createX402Client, createX402Transport, parseSignature, signTypedData, signWithPrivateKey, validateTransferWithAuthorization };
+/**
+ * Simple one-line payment API for Armory (Web3)
+ * Focus on DX/UX - "everything just magically works"
+ */
+
+/**
+ * Simple wallet input - accepts wallet directly or wrapped for backward compatibility
+ */
+type SimpleWalletInput = Web3Account | {
+    account: Web3Account;
+};
+/**
+ * Normalized wallet (internal use)
+ */
+type NormalizedWallet = Web3Account;
+/**
+ * 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;
+}) => 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) => 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 (Web3)
+ * 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, type HttpMethod, type NormalizedWallet, type PaymentOptions, type SimpleWalletInput, adjustVForChainId, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, concatenateSignature, createArmory, createEIP712Domain, createTransferWithAuthorization, createX402Client, createX402Transport, getNetworks, getTokens, getWalletAddress, normalizeWallet, parseSignature, signTypedData, signWithPrivateKey, validateNetwork, validateToken, validateTransferWithAuthorization };

package/dist/index.js

@@ -1,7 +1,15 @@
+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/client.ts
 import { Web3 } from "web3";
 import {
   getNetworkConfig,
+  getNetworkByChainId,
   encodePaymentV2,
   networkToCaip2,
   combineSignatureV2,
@@ -181,15 +189,15 @@ var extractDomainConfig = (config) => {
   };
 };
 var createClientState = (config) => {
-  const network = typeof config.network === "string" ? getNetworkConfig(config.network) ?? (() => {
+  const network = config.network ? typeof config.network === "string" ? getNetworkConfig(config.network) ?? (() => {
     throw new Error(`Unknown network: ${config.network}`);
-  })() : config.network;
+  })() : config.network : void 0;
   const { domainName, domainVersion } = extractDomainConfig(config);
   return {
     account: config.account,
     version: config.version ?? 2,
     network,
-    web3: new Web3(config.rpcUrl ?? network.rpcUrl),
+    web3: config.rpcUrl ? new Web3(config.rpcUrl) : network ? new Web3(network.rpcUrl) : new Web3(),
     domainName,
     domainVersion
   };
@@ -231,9 +239,9 @@ var signTypedDataWrapper = async (account, domain, message) => {
   }
   throw new Error("Account does not support EIP-712 signing.");
 };
-var signPaymentV2 = async (state, params) => {
+var signPaymentV2 = async (state, network, params) => {
   const { from, to, amount, nonce, expiry, accepted } = params;
-  const { network, domainName, domainVersion } = state;
+  const { domainName, domainVersion } = state;
   const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
   const message = createTransferWithAuthorization({
     from,
@@ -273,6 +281,19 @@ var signPaymentV2 = async (state, params) => {
     payload: x402Payload
   };
 };
+var extractNetworkFromRequirements = (requirements) => {
+  const caip2Network = requirements.network;
+  const match = caip2Network.match(/^eip155:(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid CAIP-2 network format: ${caip2Network}`);
+  }
+  const chainId = parseInt(match[1], 10);
+  const network = getNetworkByChainId(chainId);
+  if (!network) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return network;
+};
 var createX402Client = (config) => {
   const state = createClientState(config);
   const fetch2 = async (url, init) => {
@@ -287,7 +308,8 @@ var createX402Client = (config) => {
       const from = getAddress(state.account);
       const req = selectedRequirements;
       const to = typeof req.payTo === "string" ? req.payTo : "0x0000000000000000000000000000000000000000";
-      const result = await signPaymentV2(state, {
+      const network = extractNetworkFromRequirements(req);
+      const result = await signPaymentV2(state, network, {
         from,
         to,
         amount: req.amount,
@@ -307,20 +329,26 @@ var createX402Client = (config) => {
     getNetwork: () => state.network,
     getVersion: () => state.version,
     signPayment: async (options) => {
+      const network = state.network ?? (() => {
+        throw new Error("Network must be configured for manual payment signing");
+      })();
       const from = getAddress(state.account);
       const to = options.to;
       const amount = options.amount.toString();
       const nonce = options.nonce ?? crypto.randomUUID();
       const expiry = options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS;
-      return signPaymentV2(state, { from, to, amount, nonce, expiry });
+      return signPaymentV2(state, network, { from, to, amount, nonce, expiry });
     },
     createPaymentHeaders: async (options) => {
+      const network = state.network ?? (() => {
+        throw new Error("Network must be configured for manual payment signing");
+      })();
       const from = getAddress(state.account);
       const to = options.to;
       const amount = options.amount.toString();
       const nonce = options.nonce ?? crypto.randomUUID();
       const expiry = options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS;
-      const result = await signPaymentV2(state, { from, to, amount, nonce, expiry });
+      const result = await signPaymentV2(state, network, { from, to, amount, nonce, expiry });
       const headers = new Headers();
       headers.set("PAYMENT-SIGNATURE", encodePaymentV2(result.payload));
       return headers;
@@ -328,7 +356,8 @@ var createX402Client = (config) => {
     handlePaymentRequired: async (requirements) => {
       const from = getAddress(state.account);
       const to = typeof requirements.payTo === "string" ? requirements.payTo : "0x0000000000000000000000000000000000000000";
-      return signPaymentV2(state, {
+      const network = extractNetworkFromRequirements(requirements);
+      return signPaymentV2(state, network, {
         from,
         to,
         amount: requirements.amount,
@@ -411,15 +440,216 @@ var createX402Transport = (options) => {
     }
   };
 };
+
+// src/payment-api.ts
+import {
+  resolveNetwork,
+  resolveToken,
+  validatePaymentConfig,
+  isValidationError
+} from "@armory-sh/base";
+var normalizeWallet = (wallet) => {
+  if (typeof wallet === "object" && wallet !== null && "account" in wallet) {
+    return wallet.account;
+  }
+  return wallet;
+};
+var armoryPay = async (wallet, url, network, token, options) => {
+  try {
+    const account = normalizeWallet(wallet);
+    const config = validatePaymentConfig(network, token);
+    if (isValidationError(config)) {
+      return {
+        success: false,
+        code: config.code,
+        message: config.message,
+        details: config
+      };
+    }
+    const client = createX402Client({
+      account,
+      network: config.network.config.name,
+      version: options?.version ?? 2,
+      token: config.token.config
+    });
+    const method = options?.method ?? "GET";
+    const headers = new Headers(options?.headers ?? {});
+    let response;
+    if (method === "GET") {
+      response = await client.fetch(url, { method, headers });
+    } else {
+      response = await client.fetch(url, {
+        method,
+        headers,
+        body: JSON.stringify(options?.body)
+      });
+    }
+    if (response.status === 402) {
+      return {
+        success: false,
+        code: "PAYMENT_REQUIRED",
+        message: "Payment required but could not be completed automatically"
+      };
+    }
+    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 = (wallet) => {
+  const account = normalizeWallet(wallet);
+  if ("address" in account) return account.address;
+  if (Array.isArray(account) && account[0]) return account[0].address;
+  throw new Error("Unable to get address from account");
+};
+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
+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 makeRequest = async (url, method, body) => {
+    try {
+      const headers = new Headers();
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      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 {
   adjustVForChainId,
+  armoryDelete,
+  armoryGet,
+  armoryPatch,
+  armoryPay,
+  armoryPost,
+  armoryPut,
   concatenateSignature,
+  createArmory,
   createEIP712Domain,
   createTransferWithAuthorization,
   createX402Client,
   createX402Transport,
+  getNetworks,
+  getTokens,
+  getWalletAddress,
+  normalizeWallet,
   parseSignature,
   signTypedData,
   signWithPrivateKey,
+  validateNetwork,
+  validateToken,
   validateTransferWithAuthorization
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-web3",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -27,7 +27,7 @@
     "directory": "packages/client-web3"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.18",
+    "@armory-sh/base": "^0.2.20",
     "web3": "4.16.0",
     "web3-types": "1.10.0"
   },