@armory-sh/client-viem 0.2.18 → 0.2.19

package/dist/index.d.ts

@@ -1,6 +1,41 @@
-import { Address, Account, WalletClient, Transport } from 'viem';
-import { CustomToken, PaymentPayloadV2, PaymentRequirementsV2, NetworkId, TokenId, ArmoryPaymentResult, ValidationError } from '@armory-sh/base';
+import { Account, Address, WalletClient, Transport } from 'viem';
+import { PaymentRequirementsV2, HookConfig, HookRegistry, PaymentPayloadContext, CustomToken, PaymentPayloadV2, PaymentRequiredContext, Extensions, NetworkId, TokenId, ArmoryPaymentResult, ValidationError, Address as Address$1, PaymentRequiredV2 } from '@armory-sh/base';
 export { ArmoryPaymentResult, EIP3009Authorization, FacilitatorConfig, NetworkId, PaymentPayloadV2, PaymentRequiredV2, PaymentRequirementsV2, ResourceInfo, SchemePayloadV2, SettlementResponseV2, TokenId, V2_HEADERS } from '@armory-sh/base';
+import { BazaarExtensionInfo, SIWxExtensionInfo } from '@armory-sh/extensions';
+
+/**
+ * X402 Protocol Implementation for Viem Client (V2 Only)
+ *
+ * Handles parsing x402 V2 PAYMENT-REQUIRED headers
+ * and generating x402 V2 PAYMENT-SIGNATURE payloads
+ */
+
+type X402Wallet$1 = {
+    type: "account";
+    account: Account;
+} | {
+    type: "walletClient";
+    walletClient: {
+        account: Account;
+    };
+};
+type X402Version = 2;
+declare function detectX402Version(_response: Response): X402Version;
+type ParsedPaymentRequirements = PaymentRequirementsV2;
+declare function parsePaymentRequired(response: Response): ParsedPaymentRequirements;
+
+/**
+ * Viem-Specific Hook Types
+ *
+ * Extends the base hook types with viem-specific wallet context.
+ * Provides type-safe hook registration for client-viem.
+ */
+
+interface ViemPaymentPayloadContext extends PaymentPayloadContext {
+    wallet: X402Wallet$1;
+}
+type ViemHookConfig = HookConfig<X402Wallet$1>;
+type ViemHookRegistry = HookRegistry<X402Wallet$1>;
 
 /**
  * X402 Client Types - V2 Only
@@ -28,6 +63,8 @@ interface X402ClientConfig {
     domainName?: string;
     /** Override EIP-712 domain version for custom tokens */
     domainVersion?: string;
+    /** Extension hooks for handling protocol extensions */
+    hooks?: ViemHookRegistry;
 }
 interface X402Client {
     fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
@@ -48,6 +85,8 @@ interface X402TransportConfig {
     domainName?: string;
     /** Override EIP-712 domain version */
     domainVersion?: string;
+    /** Extension hooks for handling protocol extensions */
+    hooks?: ViemHookRegistry;
 }
 interface PaymentResult {
     success: boolean;
@@ -73,6 +112,16 @@ interface UnsignedPaymentPayload {
 declare const createX402Client: (config: X402ClientConfig) => X402Client;
 declare const createX402Transport: (config: X402TransportConfig) => ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>);
 
+/**
+ * Hook Execution Engine
+ *
+ * Executes hooks in priority order and handles errors gracefully.
+ * Hooks are sorted by priority (higher priority runs first).
+ */
+
+declare function executeHooks(hooks: HookRegistry, context: PaymentRequiredContext | PaymentPayloadContext): Promise<void>;
+declare function mergeExtensions(baseExtensions: Extensions | undefined, hookExtensions: Record<string, unknown>): Extensions;
+
 declare class X402ClientError extends Error {
     readonly cause?: unknown;
     constructor(message: string, cause?: unknown);
@@ -84,32 +133,33 @@ declare class PaymentError extends X402ClientError {
     constructor(message: string, cause?: unknown);
 }
 
-/**
- * X402 Protocol Implementation for Viem Client (V2 Only)
- *
- * Handles parsing x402 V2 PAYMENT-REQUIRED headers
- * and generating x402 V2 PAYMENT-SIGNATURE payloads
- */
-
-type X402Version = 2;
-declare function detectX402Version(_response: Response): X402Version;
-type ParsedPaymentRequirements = PaymentRequirementsV2;
-declare function parsePaymentRequired(response: Response): ParsedPaymentRequirements;
-
 /**
  * Simple one-line payment API for Armory
  * Focus on DX/UX - "everything just magically works"
  */
 
 /**
- * Simple wallet configuration
- * Pass a viem Account or WalletClient directly
+ * Simple wallet input - accepts wallet directly or wrapped for backward compatibility
+ */
+type SimpleWalletInput = Account | WalletClient | {
+    account: Account;
+} | {
+    walletClient: WalletClient;
+};
+/**
+ * Normalized wallet (internal use)
  */
-type SimpleWallet = {
+type NormalizedWallet = {
+    type: "account";
     account: Account;
 } | {
+    type: "walletClient";
     walletClient: WalletClient;
 };
+/**
+ * Normalize wallet input to internal format
+ */
+declare const normalizeWallet: (wallet: SimpleWalletInput) => NormalizedWallet;
 /**
  * Make a payment-protected API request with one line of code
  *
@@ -129,7 +179,7 @@ type SimpleWallet = {
  * }
  * ```
  */
-declare const armoryPay: <T = unknown>(wallet: SimpleWallet, url: string, network: NetworkId, token: TokenId, options?: {
+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) */
@@ -146,15 +196,27 @@ declare const armoryPay: <T = unknown>(wallet: SimpleWallet, url: string, networ
 /**
  * Make a GET request with payment
  */
-declare const armoryGet: <T = unknown>(wallet: SimpleWallet, url: string, network: NetworkId, token: TokenId, options?: Omit<Parameters<typeof armoryPay>[4], "method">) => Promise<ArmoryPaymentResult<T>>;
+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: SimpleWallet, url: string, network: NetworkId, token: TokenId, body?: unknown, options?: Omit<Parameters<typeof armoryPay>[4], "method" | "body">) => Promise<ArmoryPaymentResult<T>>;
+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>>;
 /**
- * Get the wallet address from a SimpleWallet
+ * Make a DELETE request with payment
  */
-declare const getWalletAddress: (wallet: SimpleWallet) => Address;
+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) => Address;
 /**
  * Validate a network identifier without making a request
  */
@@ -179,4 +241,49 @@ declare const getNetworks: () => string[];
  */
 declare const getTokens: () => string[];
 
-export { type ParsedPaymentRequirements, PaymentError, type PaymentResult, SigningError, type SimpleWallet, type Token, type X402Client, type X402ClientConfig, X402ClientError, type X402ProtocolVersion, type X402TransportConfig, type X402Wallet, armoryGet, armoryPay, armoryPost, createX402Client, createX402Transport, detectX402Version, getNetworks, getTokens, getWalletAddress, parsePaymentRequired, validateNetwork, validateToken };
+/**
+ * Armory API - Simplified payment interface
+ * 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;
+
+/**
+ * Client-side extension handling for x402
+ * Integrates with @armory-sh/extensions package
+ */
+
+interface ClientExtensionContext {
+    bazaar?: BazaarExtensionInfo;
+    signInWithX?: SIWxExtensionInfo;
+}
+declare function parseExtensions(paymentRequired: PaymentRequiredV2): ClientExtensionContext;
+declare function extractExtension<T>(extensions: Extensions | undefined, key: string): T | null;
+declare function createSIWxProof(challenge: SIWxExtensionInfo, wallet: X402Wallet$1, nonce: string, expirationSeconds?: number): Promise<{
+    header: string;
+    address: Address$1;
+}>;
+declare function addExtensionsToPayload(payload: PaymentPayloadV2, extensions?: Extensions): PaymentPayloadV2;
+
+export { type ArmoryConfig, type ArmoryInstance, type ClientExtensionContext, type HttpMethod, type NormalizedWallet, type ParsedPaymentRequirements, PaymentError, type PaymentOptions, type PaymentResult, SigningError, type SimpleWalletInput, type Token, type ViemHookConfig, type ViemHookRegistry, type ViemPaymentPayloadContext, type X402Client, type X402ClientConfig, X402ClientError, type X402ProtocolVersion, type X402TransportConfig, type X402Wallet, addExtensionsToPayload, armoryDelete, armoryGet, armoryPatch, armoryPay, armoryPost, armoryPut, createArmory, createSIWxProof, createX402Client, createX402Transport, detectX402Version, executeHooks, extractExtension, getNetworks, getTokens, getWalletAddress, mergeExtensions, normalizeWallet, parseExtensions, parsePaymentRequired, validateNetwork, validateToken };

package/dist/index.js

@@ -82,6 +82,28 @@ async function createX402Payment(wallet, requirements, from, nonce = `0x${Date.n
   };
 }
 
+// src/hooks-engine.ts
+async function executeHooks(hooks, context) {
+  const sortedHooks = Object.entries(hooks).sort(([, a], [, b]) => {
+    const priorityA = a.priority ?? 0;
+    const priorityB = b.priority ?? 0;
+    return priorityB - priorityA;
+  });
+  for (const [key, config] of sortedHooks) {
+    try {
+      await config.hook(context);
+    } catch (error) {
+      console.warn(`[X402] Hook "${key}" failed:`, error);
+    }
+  }
+}
+function mergeExtensions(baseExtensions, hookExtensions) {
+  return {
+    ...baseExtensions ?? {},
+    ...hookExtensions
+  };
+}
+
 // src/client.ts
 var DEFAULT_EXPIRY = 3600;
 var toCaip2Id = (chainId) => `eip155:${chainId}`;
@@ -119,7 +141,7 @@ var checkSettlement = (response) => {
 var createFetch = (wallet, config) => {
   const protocolWallet = toProtocolWallet(wallet);
   const getAddress = () => getWalletAddress(protocolWallet);
-  const { defaultExpiry, nonceGenerator, debug, domainName, domainVersion } = config;
+  const { defaultExpiry, nonceGenerator, debug, domainName, domainVersion, hooks } = config;
   return async (input, init) => {
     let response = await fetch(input, init);
     if (response.status === 402) {
@@ -133,6 +155,18 @@ var createFetch = (wallet, config) => {
       const fromAddress = getAddress();
       const nonce = generateNonce(nonceGenerator);
       const validBefore = Math.floor(Date.now() / 1e3) + defaultExpiry;
+      const paymentRequiredContext = {
+        url: input,
+        requestInit: init,
+        requirements: parsed,
+        serverExtensions: parsed.extra,
+        fromAddress,
+        nonce,
+        validBefore
+      };
+      if (hooks) {
+        await executeHooks(hooks, paymentRequiredContext);
+      }
       const payment = await createX402Payment(
         protocolWallet,
         parsed,
@@ -145,6 +179,15 @@ var createFetch = (wallet, config) => {
       if (debug) {
         console.log("[X402] Created payment payload");
       }
+      if (hooks) {
+        const paymentPayloadContext = {
+          payload: payment,
+          requirements: parsed,
+          wallet: protocolWallet,
+          paymentContext: paymentRequiredContext
+        };
+        await executeHooks(hooks, paymentPayloadContext);
+      }
       const headers = new Headers(init?.headers);
       addPaymentHeader(headers, payment);
       response = await fetch(input, { ...init, headers });
@@ -157,7 +200,7 @@ var createFetch = (wallet, config) => {
   };
 };
 var createX402Client = (config) => {
-  const { wallet, version = 2, defaultExpiry = DEFAULT_EXPIRY, nonceGenerator } = config;
+  const { wallet, version = 2, defaultExpiry = DEFAULT_EXPIRY, nonceGenerator, hooks } = config;
   const { domainName, domainVersion } = extractDomainConfig(config);
   const protocolWallet = toProtocolWallet(wallet);
   const getAddress = () => getWalletAddress(protocolWallet);
@@ -167,7 +210,8 @@ var createX402Client = (config) => {
     nonceGenerator,
     debug: config.debug,
     domainName,
-    domainVersion
+    domainVersion,
+    hooks
   });
   return {
     fetch: fetchFn,
@@ -215,7 +259,8 @@ var createX402Transport = (config) => {
     debug: config.debug,
     token: config.token,
     domainName: config.domainName,
-    domainVersion: config.domainVersion
+    domainVersion: config.domainVersion,
+    hooks: config.hooks
   });
   return client.fetch;
 };
@@ -229,9 +274,30 @@ import {
   getAvailableNetworks,
   getAvailableTokens
 } from "@armory-sh/base";
+var normalizeWallet = (wallet) => {
+  if (typeof wallet === "object" && wallet !== null) {
+    if ("account" in wallet && "type" in wallet) {
+      return wallet;
+    }
+    if ("account" in wallet) {
+      return { type: "account", account: wallet.account };
+    }
+    if ("walletClient" in wallet) {
+      return { type: "walletClient", walletClient: wallet.walletClient };
+    }
+  }
+  if ("address" in wallet && "type" in wallet) {
+    return { type: "account", account: wallet };
+  }
+  if ("account" in wallet) {
+    return { type: "walletClient", walletClient: wallet };
+  }
+  throw new Error("Invalid wallet input");
+};
 var armoryPay = async (wallet, url, network, token, options) => {
   try {
-    const x402Wallet = "account" in wallet ? { type: "account", account: wallet.account } : { type: "walletClient", walletClient: wallet.walletClient };
+    const normalized = normalizeWallet(wallet);
+    const x402Wallet = normalized.type === "account" ? { type: "account", account: normalized.account } : { type: "walletClient", walletClient: normalized.walletClient };
     const config = validatePaymentConfig(network, token);
     if (isValidationError(config)) {
       return {
@@ -296,8 +362,18 @@ var armoryGet = (wallet, url, network, token, options) => {
 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 getWalletAddress2 = (wallet) => {
-  return "account" in wallet ? wallet.account.address : wallet.walletClient.account.address;
+  const normalized = normalizeWallet(wallet);
+  return normalized.type === "account" ? normalized.account.address : normalized.walletClient.account.address;
 };
 var validateNetwork = (network) => {
   const resolved = resolveNetwork(network);
@@ -332,22 +408,338 @@ var getTokens = () => {
   return getAvailableTokens();
 };
 
+// src/armory-api.ts
+import {
+  resolveNetwork as resolveNetwork2,
+  resolveToken as resolveToken2,
+  getNetworkByChainId as getNetworkByChainId2
+} 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 scorePaymentOption = (option, allowedTokens, allowedChains) => {
+  let score = 0;
+  const chainId = parseInt(option.network.split(":")[1], 10);
+  const tokenAddress = option.asset.toLowerCase();
+  for (const chain of allowedChains) {
+    const resolved = resolveNetwork2(chain);
+    if (!("code" in resolved) && resolved.config.chainId === chainId) {
+      score += 10;
+      break;
+    }
+  }
+  for (const token of allowedTokens) {
+    const resolved = resolveToken2(token);
+    if (!("code" in resolved) && resolved.config.contractAddress.toLowerCase() === tokenAddress) {
+      score += 5;
+      break;
+    }
+  }
+  if (chainId === 8453) score += 2;
+  if (tokenAddress === "0x833589fcd6edb6e08f4c7c32d4f71b54bdA02913") {
+    score += 1;
+  }
+  const amount = parseInt(option.amount, 10);
+  if (amount < 1e6) score += 1;
+  return score;
+};
+var selectPaymentOption = (accepts, allowedTokens, allowedChains, allowedMethods) => {
+  const validOptions = accepts.filter((option) => {
+    const chainId = parseInt(option.network.split(":")[1], 10);
+    for (const chain of allowedChains) {
+      const resolved = resolveNetwork2(chain);
+      if (!("code" in resolved) && resolved.config.chainId === chainId) {
+        for (const token of allowedTokens) {
+          const resolvedToken = resolveToken2(token, resolved);
+          if (!("code" in resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === option.asset.toLowerCase()) {
+            return true;
+          }
+        }
+      }
+    }
+    if (allowedChains.length === 0 && allowedTokens.length === 0) {
+      return true;
+    }
+    return false;
+  });
+  if (validOptions.length === 0) return null;
+  if (validOptions.length === 1) return validOptions[0];
+  return validOptions.sort(
+    (a, b) => scorePaymentOption(b, allowedTokens, allowedChains) - scorePaymentOption(a, allowedTokens, allowedChains)
+  )[0];
+};
+var createArmory = (config) => {
+  const internal = normalizeArmoryConfig(config);
+  const x402Wallet = internal.wallet.type === "account" ? { type: "account", account: internal.wallet.account } : { type: "walletClient", walletClient: internal.wallet.walletClient };
+  const makeRequest = async (url, method, body) => {
+    try {
+      const headers = new Headers();
+      let response = await fetch(url, { method, headers });
+      if (response.status === 402) {
+        const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+        if (!paymentRequiredHeader) {
+          return {
+            success: false,
+            code: "PAYMENT_REQUIRED",
+            message: "Payment required but no PAYMENT-REQUIRED header found"
+          };
+        }
+        const decoded = Buffer.from(paymentRequiredHeader, "base64").toString("utf-8");
+        const paymentRequired = JSON.parse(decoded);
+        if (paymentRequired.x402Version !== 2 || !paymentRequired.accepts) {
+          return {
+            success: false,
+            code: "PAYMENT_REQUIRED",
+            message: "Invalid payment required format"
+          };
+        }
+        const selectedOption = selectPaymentOption(
+          paymentRequired.accepts,
+          internal.allowedTokens,
+          internal.allowedChains,
+          internal.allowedMethods
+        );
+        if (!selectedOption) {
+          return {
+            success: false,
+            code: "PAYMENT_REQUIRED",
+            message: "No compatible payment option found"
+          };
+        }
+        const chainId = parseInt(selectedOption.network.split(":")[1], 10);
+        const networkConfig = getNetworkByChainId2(chainId) ?? {
+          chainId,
+          name: "Unknown",
+          rpcUrl: "",
+          usdcAddress: selectedOption.asset,
+          caip2Id: selectedOption.network,
+          caipAssetId: `${selectedOption.network}/erc20:${selectedOption.asset}`
+        };
+        const client = createX402Client({
+          wallet: x402Wallet,
+          version: 2,
+          token: {
+            symbol: "CUSTOM",
+            name: "Payment Token",
+            version: "1",
+            chainId,
+            contractAddress: selectedOption.asset,
+            decimals: 6
+          },
+          debug: internal.debug
+        });
+        const fromAddress = internal.wallet.type === "account" ? internal.wallet.account.address : internal.wallet.walletClient.account.address;
+        const nonce = `0x${Date.now().toString(16).padStart(64, "0")}`;
+        const validBefore = Math.floor(Date.now() / 1e3) + 3600;
+        const payment = await client.createPayment(
+          selectedOption.amount,
+          selectedOption.payTo,
+          selectedOption.asset,
+          chainId,
+          validBefore
+        );
+        const signatureHeader = Buffer.from(JSON.stringify(payment)).toString("base64");
+        headers.set("PAYMENT-SIGNATURE", signatureHeader);
+        response = await fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        if (internal.debug) {
+          console.log("[Armory] Payment completed, status:", response.status);
+        }
+      } else {
+        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")
+  };
+};
+
 // src/index.ts
 import { V2_HEADERS as V2_HEADERS3 } from "@armory-sh/base";
+
+// src/extensions.ts
+function parseExtensions(paymentRequired) {
+  const extensions = paymentRequired.extensions || {};
+  const result = {};
+  if (extensions.bazaar) {
+    const bazaarExt = extensions.bazaar;
+    if (bazaarExt && typeof bazaarExt === "object" && "info" in bazaarExt) {
+      result.bazaar = bazaarExt.info;
+    }
+  }
+  if (extensions["sign-in-with-x"]) {
+    const siwxExt = extensions["sign-in-with-x"];
+    if (siwxExt && typeof siwxExt === "object" && "info" in siwxExt) {
+      result.signInWithX = siwxExt.info;
+    }
+  }
+  return result;
+}
+function extractExtension(extensions, key) {
+  if (!extensions || typeof extensions !== "object") {
+    return null;
+  }
+  const extension = extensions[key];
+  if (!extension || typeof extension !== "object") {
+    return null;
+  }
+  const ext = extension;
+  return ext.info || null;
+}
+async function createSIWxProof(challenge, wallet, nonce, expirationSeconds = 3600) {
+  const getDefaultDomain = () => {
+    if (typeof window !== "undefined" && window.location) {
+      return window.location.hostname;
+    }
+    return "localhost";
+  };
+  const address = getWalletAddress(wallet);
+  const now = /* @__PURE__ */ new Date();
+  const expiration = new Date(now.getTime() + expirationSeconds * 1e3);
+  const payload = {
+    domain: challenge.domain || getDefaultDomain(),
+    resourceUri: challenge.resourceUri,
+    address,
+    statement: challenge.statement,
+    version: challenge.version || "1",
+    chainId: challenge.network,
+    nonce,
+    issuedAt: now.toISOString(),
+    expirationTime: expiration.toISOString()
+  };
+  const message = createSIWxMessage(payload);
+  let signature;
+  if (wallet.type === "account") {
+    if (!wallet.account.signTypedData) {
+      throw new Error("Wallet does not support signing");
+    }
+    signature = await wallet.account.signMessage({ message });
+  } else {
+    if (!wallet.walletClient.account.signTypedData) {
+      throw new Error("Wallet does not support signing");
+    }
+    signature = await wallet.walletClient.account.signMessage({ message });
+  }
+  payload.signature = signature;
+  const header = encodeSIWxHeader(payload);
+  return { header, address };
+}
+function base64UrlEncode(str) {
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function createSIWxMessage(payload) {
+  const lines = [];
+  lines.push(`${payload.domain} wants you to sign in`);
+  if (payload.statement) {
+    lines.push("");
+    lines.push(payload.statement);
+  }
+  lines.push("");
+  if (payload.resourceUri) {
+    lines.push(`URI: ${payload.resourceUri}`);
+  }
+  if (payload.version) {
+    lines.push(`Version: ${payload.version}`);
+  }
+  if (payload.nonce) {
+    lines.push(`Nonce: ${payload.nonce}`);
+  }
+  if (payload.issuedAt) {
+    lines.push(`Issued At: ${payload.issuedAt}`);
+  }
+  if (payload.expirationTime) {
+    lines.push(`Expiration Time: ${payload.expirationTime}`);
+  }
+  if (payload.chainId) {
+    const chains = Array.isArray(payload.chainId) ? payload.chainId.join(", ") : payload.chainId;
+    lines.push(`Chain ID(s): ${chains}`);
+  }
+  return lines.join("\n");
+}
+function encodeSIWxHeader(payload) {
+  const payloadStr = JSON.stringify(payload);
+  const encoded = base64UrlEncode(payloadStr);
+  return `siwx-v1-${encoded}`;
+}
+function addExtensionsToPayload(payload, extensions) {
+  if (!extensions || Object.keys(extensions).length === 0) {
+    return payload;
+  }
+  return {
+    ...payload,
+    extensions
+  };
+}
 export {
   PaymentError,
   SigningError,
   V2_HEADERS3 as V2_HEADERS,
   X402ClientError,
+  addExtensionsToPayload,
+  armoryDelete,
   armoryGet,
+  armoryPatch,
   armoryPay,
   armoryPost,
+  armoryPut,
+  createArmory,
+  createSIWxProof,
   createX402Client,
   createX402Transport,
   detectX402Version,
+  executeHooks,
+  extractExtension,
   getNetworks,
   getTokens,
   getWalletAddress2 as getWalletAddress,
+  mergeExtensions,
+  normalizeWallet,
+  parseExtensions,
   parsePaymentRequired,
   validateNetwork,
   validateToken

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/client-viem",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -12,6 +12,11 @@
       "bun": "./src/index.ts",
       "default": "./dist/index.js"
     },
+    "./extensions": {
+      "types": "./dist/extensions.d.ts",
+      "bun": "./src/extensions.ts",
+      "default": "./dist/extensions.js"
+    },
     "./dist/*": "./dist/*.js"
   },
   "files": [
@@ -27,7 +32,8 @@
     "directory": "packages/client-viem"
   },
   "dependencies": {
-    "@armory-sh/base": "^0.2.19",
+    "@armory-sh/base": "^0.2.20",
+    "@armory-sh/extensions": "0.1.1",
     "viem": "2.45.0"
   },
   "devDependencies": {