@x402x/extensions 2.0.0 → 2.1.0

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { Chain, Address as Address$1 } from 'viem';
-import { PaymentRequirements, ResourceServerExtension, Network, SchemeNetworkFacilitator, PaymentPayload } from '@x402/core/types';
+import { Network, PaymentRequirements, ResourceServerExtension, SchemeNetworkFacilitator, PaymentPayload, SchemeNetworkClient } from '@x402/core/types';
 export { Network, PaymentPayload, PaymentRequirements } from '@x402/core/types';
+import { Chain, Address as Address$1 } from 'viem';
 import { x402ResourceServer } from '@x402/core/server';
+import { x402Client } from '@x402/core/client';
 
 /**
  * Type definitions for @x402x/extensions
@@ -316,69 +317,100 @@ declare function validateCommitmentParams(params: CommitmentParams): void;
  * Network configuration for x402x
  *
  * Contains deployed contract addresses and configuration for each supported network.
- * Uses official x402 v2 CAIP-2 network identifiers.
+ * Uses official x402 v2 CAIP-2 network identifiers as keys.
  */
 
 /**
  * Network configurations for all supported networks
  *
- * Uses getNetworkId() and getDefaultAsset() to ensure consistency
- * with CAIP-2 network identifiers.
+ * Uses CAIP-2 format as keys for consistency with x402 v2 protocol.
+ * This ensures compatibility across different ecosystems and simplifies
+ * adding new networks (only need chain ID).
  */
-declare const networks: Record<string, NetworkConfig>;
+declare const networks: Record<Network, NetworkConfig>;
 /**
- * Get network configuration by network name
+ * Get network configuration by network identifier
+ *
+ * Accepts both CAIP-2 format (preferred) and human-readable network names (legacy).
+ * This provides backward compatibility while encouraging migration to CAIP-2.
  *
- * @param network - Network name (e.g., 'base-sepolia', 'skale-base-sepolia')
+ * @param network - Network identifier, accepts either:
+ *   - CAIP-2 format (preferred): 'eip155:84532', 'eip155:8453'
+ *   - Human-readable name (legacy): 'base-sepolia', 'base'
  * @returns Network configuration
  * @throws Error if network is not supported
  *
  * @example
  * ```typescript
- * const config = getNetworkConfig('base-sepolia');
+ * // Preferred: CAIP-2 format
+ * const config = getNetworkConfig('eip155:84532');
+ *
+ * // Legacy: human-readable name
+ * const config2 = getNetworkConfig('base-sepolia');
+ *
  * console.log(config.settlementRouter);
  * ```
  */
-declare function getNetworkConfig(network: string): NetworkConfig;
+declare function getNetworkConfig(network: string | Network): NetworkConfig;
 /**
  * Check if a network is supported
  *
- * @param network - Network name to check
+ * Accepts both CAIP-2 format and human-readable network names.
+ *
+ * @param network - Network identifier (CAIP-2 or human-readable name)
  * @returns True if network is supported
  *
  * @example
  * ```typescript
- * if (isNetworkSupported('base-sepolia')) {
+ * if (isNetworkSupported('eip155:84532')) {
  *   // proceed...
  * }
+ *
+ * if (isNetworkSupported('base-sepolia')) {
+ *   // also works...
+ * }
  * ```
  */
-declare function isNetworkSupported(network: string): boolean;
+declare function isNetworkSupported(network: string | Network): boolean;
 /**
- * Get list of all supported network names (human-readable identifiers)
+ * Get list of all supported network aliases (v1 configuration names)
  *
- * Returns user-friendly network names like "base-sepolia", "base", etc.
+ * Returns user-friendly network aliases like "base-sepolia", "base", etc.
+ * These aliases are used for configuration files and backward compatibility.
  * Use this for UI display, configuration, and user-facing operations.
  *
- * @returns Array of supported network names
+ * This function provides backward compatibility by returning v1 aliases
+ * even though the internal storage uses CAIP-2 format.
+ *
+ * @returns Array of v1 network aliases
  *
  * @example
  * ```typescript
- * const networks = getSupportedNetworkNames();
+ * const aliases = getSupportedNetworkAliases();
  * // => ['base-sepolia', 'base', 'x-layer-testnet', ...]
  *
  * // For UI dropdown
  * <select>
- *   {networks.map(name => <option key={name}>{name}</option>)}
+ *   {aliases.map(alias => <option key={alias}>{alias}</option>)}
  * </select>
  * ```
  */
-declare function getSupportedNetworkNames(): string[];
+declare function getSupportedNetworkAliases(): string[];
 /**
- * @deprecated Use getSupportedNetworkNames() instead for clarity
- * Get list of all supported networks
+ * Get list of all supported networks (CAIP-2 format)
+ *
+ * Returns network identifiers in CAIP-2 format (e.g., "eip155:84532").
+ * This is the canonical format used internally and in x402 v2.
+ *
+ * @returns Array of CAIP-2 network identifiers
+ *
+ * @example
+ * ```typescript
+ * const networks = getSupportedNetworks();
+ * // => ['eip155:84532', 'eip155:8453', 'eip155:1952', ...]
+ * ```
  */
-declare function getSupportedNetworks(): string[];
+declare function getSupportedNetworks(): Network[];
 
 /**
  * Chain definitions for x402x supported networks
@@ -388,24 +420,27 @@ declare function getSupportedNetworks(): string[];
  */
 
 /**
- * Get viem chain configuration for a network name
+ * Get viem chain configuration for a network
  *
+ * Accepts both CAIP-2 format (preferred) and human-readable network names (legacy).
  * Checks custom chains first, then falls back to viem's standard chains.
  *
- * @param network - Network name (e.g., "base-sepolia", "x-layer-testnet")
+ * @param network - Network identifier (CAIP-2 or human-readable name)
  * @returns Viem chain configuration
  * @throws Error if network is not supported
  *
  * @example
  * ```typescript
- * const chain = getChain("x-layer-testnet");
+ * // Preferred: CAIP-2 format
+ * const chain = getChain("eip155:1952");
  * // => { id: 1952, name: "X Layer Testnet", ... }
  *
+ * // Legacy: human-readable name
  * const baseChain = getChain("base-sepolia");
  * // => { id: 84532, name: "Base Sepolia", ... }
  * ```
  */
-declare function getChain(network: string): Chain;
+declare function getChain(network: string | Network): Chain;
 /**
  * Get viem chain configuration by chain ID
  *
@@ -536,17 +571,24 @@ declare namespace TransferHook {
     /**
      * Get TransferHook address for a specific network
      *
-     * @param network - Network name (e.g., 'base-sepolia')
+     * Accepts both CAIP-2 format (preferred) and human-readable network names (legacy).
+     *
+     * @param network - Network identifier (CAIP-2 or human-readable name)
      * @returns TransferHook contract address
      * @throws Error if network is not supported
      *
      * @example
      * ```typescript
-     * const address = TransferHook.getAddress('base-sepolia');
+     * // Preferred: CAIP-2 format
+     * const address = TransferHook.getAddress('eip155:84532');
+     * // => '0x4DE234059C6CcC94B8fE1eb1BD24804794083569'
+     *
+     * // Legacy: human-readable name
+     * const address2 = TransferHook.getAddress('base-sepolia');
      * // => '0x4DE234059C6CcC94B8fE1eb1BD24804794083569'
      * ```
      */
-    function getAddress(network: string): string;
+    function getAddress(network: string | Network): string;
 }
 
 /**
@@ -577,21 +619,24 @@ declare namespace NFTMintHook {
     /**
      * Get NFTMintHook contract address for a specific network
      *
-     * @param network - Network identifier (e.g., 'base-sepolia', 'skale-base-sepolia')
+     * Accepts both CAIP-2 format and human-readable network names.
+     *
+     * @param network - Network identifier (CAIP-2 or human-readable name)
      * @returns The contract address for the specified network
      * @throws Error if demo hooks are not configured for the network
      */
-    function getAddress(network: string): `0x${string}`;
+    function getAddress(network: string | Network): `0x${string}`;
     /**
      * Get the NFT contract address for a specific network
      *
      * This is the address of the ERC721 contract that will be minted from.
+     * Accepts both CAIP-2 format and human-readable network names.
      *
-     * @param network - Network identifier (e.g., 'base-sepolia', 'skale-base-sepolia')
+     * @param network - Network identifier (CAIP-2 or human-readable name)
      * @returns The NFT contract address for the specified network
      * @throws Error if demo hooks are not configured for the network
      */
-    function getNFTContractAddress(network: string): `0x${string}`;
+    function getNFTContractAddress(network: string | Network): `0x${string}`;
     /**
      * Encode MintConfig into hookData for NFTMintHook
      *
@@ -610,21 +655,24 @@ declare namespace RewardHook {
     /**
      * Get RewardHook contract address for a specific network
      *
-     * @param network - Network identifier (e.g., 'base-sepolia', 'skale-base-sepolia')
+     * Accepts both CAIP-2 format and human-readable network names.
+     *
+     * @param network - Network identifier (CAIP-2 or human-readable name)
      * @returns The contract address for the specified network
      * @throws Error if demo hooks are not configured for the network
      */
-    function getAddress(network: string): `0x${string}`;
+    function getAddress(network: string | Network): `0x${string}`;
     /**
      * Get the reward token (ERC20) address for a specific network
      *
      * This is the address of the ERC20 contract that will be distributed as rewards.
+     * Accepts both CAIP-2 format and human-readable network names.
      *
-     * @param network - Network identifier (e.g., 'base-sepolia', 'skale-base-sepolia')
+     * @param network - Network identifier (CAIP-2 or human-readable name)
      * @returns The reward token contract address for the specified network
      * @throws Error if demo hooks are not configured for the network
      */
-    function getTokenAddress(network: string): `0x${string}`;
+    function getTokenAddress(network: string | Network): `0x${string}`;
     /**
      * Encode RewardConfig into hookData for RewardHook
      *
@@ -725,6 +773,7 @@ interface RouterSettlementExtension {
  * @param params - Extension parameters
  * @param params.description - Optional description of the extension
  * @param params.schema - Optional JSON schema for validation
+ * @param params.salt - Optional salt (will be auto-generated by enrichDeclaration if not provided)
  * @param params.settlementRouter - Settlement router contract address
  * @param params.hook - Hook contract address
  * @param params.hookData - Encoded hook parameters
@@ -740,7 +789,8 @@ interface RouterSettlementExtension {
  *   hook: "0x...",
  *   hookData: "0x",
  *   finalPayTo: "0x...",
- *   facilitatorFee: "0"
+ *   facilitatorFee: "0",
+ *   salt: "0x..." // Optional, will be auto-generated if not provided
  * });
  *
  * const paymentRequired = {
@@ -756,6 +806,7 @@ interface RouterSettlementExtension {
 declare function createRouterSettlementExtension(params?: {
     description?: string;
     schema?: Record<string, unknown>;
+    salt?: string;
     settlementRouter?: string;
     hook?: string;
     hookData?: string;
@@ -820,7 +871,8 @@ declare const routerSettlementServerExtension: ResourceServerExtension;
  *       hook: "0x...",
  *       hookData: "0x",
  *       finalPayTo: "0x...",
- *       facilitatorFee: "0"
+ *       facilitatorFee: "0",
+ *       salt: "0x..." // Optional, will be auto-generated if not provided
  *     })
  *   }
  * };
@@ -834,6 +886,7 @@ declare function createExtensionDeclaration(params?: {
     hookData?: string;
     finalPayTo?: string;
     facilitatorFee?: string;
+    salt?: string;
 }): Record<string, unknown>;
 
 /**
@@ -842,6 +895,8 @@ declare function createExtensionDeclaration(params?: {
  * Provides utilities for creating route configurations with router settlement support.
  * This module bridges the gap between x402 v2 official SDK's RoutesConfig and x402x
  * settlement requirements.
+ *
+ * Key Design: Use AssetAmount with x402x default assets to bypass official SDK's hardcoded default asset table.
  */
 
 /**
@@ -865,15 +920,25 @@ interface SettlementRouteConfig {
 }
 /**
  * Payment option from @x402/core
+ * Enhanced to support dynamic price generation with x402x assets
  */
 interface SettlementPaymentOption {
     scheme: string;
     network: string;
     payTo: string | ((context: unknown) => string | Promise<string>);
-    price: string | ((context: unknown) => string | Promise<string>);
+    price: string | number | AssetAmount | ((context: unknown) => string | number | AssetAmount | Promise<string | number | AssetAmount>);
     maxTimeoutSeconds?: number;
     extra?: Record<string, unknown>;
 }
+/**
+ * AssetAmount type from @x402/core
+ * Represents explicit asset/amount specification bypassing default asset lookup
+ */
+interface AssetAmount {
+    asset: string;
+    amount: string;
+    extra?: Record<string, unknown>;
+}
 /**
  * Settlement options for route configuration
  */
@@ -882,12 +947,22 @@ interface SettlementOptions {
     hook?: string;
     /** Encoded hook data (optional, defaults to TransferHook.encode()) */
     hookData?: string;
-    /** Facilitator fee amount (optional, will be dynamically calculated if not provided) */
+    /**
+     * Facilitator fee amount (optional).
+     * - If not provided, will be dynamically calculated by calling facilitator /calculate-fee endpoint
+     * - If provided, will be used as fixed fee for all networks
+     */
     facilitatorFee?: string;
-    /** Final recipient address (the actual merchant/payee) */
-    finalPayTo: string;
+    /** Final recipient address (optional, defaults to original option.payTo before settlementRouter override) */
+    finalPayTo?: string;
     /** Optional description for the extension */
     description?: string;
+    /**
+     * Facilitator service URL for dynamic fee calculation (optional)
+     * Defaults to https://facilitator.x402x.dev
+     * Only used when facilitatorFee is not explicitly provided
+     */
+    facilitatorUrl?: string;
 }
 /**
  * Configuration for settlement hooks
@@ -904,35 +979,59 @@ interface SettlementHooksConfig {
  * This helper wraps the standard x402 RouteConfig and adds settlement-specific
  * configuration including hooks, settlement router address, and dynamic extensions.
  *
- * The key insight: We add settlement info to the `extra` field of PaymentRequirements,
- * which gets passed through verify/settle. The extension generates dynamic salt per request.
+ * Key Design (v2 + x402x + dynamic fee):
+ * - Uses DynamicPrice to enable probe-quote-replay flow:
+ *   - First request (no payment): generates salt + queries facilitator fee → returns AssetAmount
+ *   - Retry (with payment): decodes paymentPayload.accepted and replays it → ensures deepEqual match
+ * - Converts Money price to AssetAmount using x402x default asset config per network
+ * - Embeds EIP-712 domain + x402x settlement info into price.extra
+ * - This bypasses official SDK's hardcoded getDefaultAsset() and allows x402x to define assets for all networks
  *
- * @param baseConfig - Base route configuration
- * @param settlementOptions - Settlement-specific options
- * @returns Enhanced route configuration with settlement support
+ * @param baseConfig - Base route configuration (accepts can use Money price like "$1.00")
+ * @param settlementOptions - Settlement-specific options (all fields optional with sensible defaults)
+ * @returns Enhanced route configuration with dynamic AssetAmount prices containing full x402x context
  *
- * @example
+ * @example Minimal usage (all defaults, dynamic fee from facilitator)
  * ```typescript
- * import { createSettlementRouteConfig, TransferHook } from "@x402x/extensions";
- *
  * const routes = {
  *   "POST /api/purchase": createSettlementRouteConfig({
- *     accepts: {
+ *     accepts: supportedNetworks.map(network => ({
  *       scheme: "exact",
- *       network: "eip155:84532",
- *       payTo: "0x...", // Will be overridden with settlementRouter
+ *       network,
+ *       payTo: merchantAddress, // Used as finalPayTo, overridden to settlementRouter
  *       price: "$1.00",
- *     },
+ *     })),
+ *     description: "Purchase endpoint",
+ *   })
+ *   // settlementOptions omitted: uses DEFAULT_FACILITATOR_URL for fee query
+ * };
+ * ```
+ *
+ * @example With custom facilitator URL
+ * ```typescript
+ * const routes = {
+ *   "POST /api/purchase": createSettlementRouteConfig({
+ *     accepts: [...],
+ *     description: "Purchase endpoint",
+ *   }, {
+ *     facilitatorUrl: "https://custom-facilitator.example.com",
+ *   })
+ * };
+ * ```
+ *
+ * @example With fixed facilitator fee (no dynamic query)
+ * ```typescript
+ * const routes = {
+ *   "POST /api/purchase": createSettlementRouteConfig({
+ *     accepts: [...],
  *     description: "Purchase endpoint",
  *   }, {
- *     hook: TransferHook.getAddress("base-sepolia"),
- *     hookData: TransferHook.encode(),
- *     finalPayTo: "0xMerchantAddress",
+ *     facilitatorFee: "1000", // Fixed fee, skips dynamic calculation
  *   })
  * };
  * ```
  */
-declare function createSettlementRouteConfig(baseConfig: SettlementRouteConfig, settlementOptions: SettlementOptions): SettlementRouteConfig;
+declare function createSettlementRouteConfig(baseConfig: SettlementRouteConfig, settlementOptions?: SettlementOptions): SettlementRouteConfig;
 /**
  * Register settlement-specific hooks with the resource server
  *
@@ -1651,103 +1750,6 @@ declare const SETTLEMENT_ROUTER_ABI: readonly [{
     readonly stateMutability: "nonpayable";
 }];
 
-/**
- * Legacy compatibility types and stubs for x402x v2 middleware
- *
- * These provide compatibility shims for patterns from x402 v1 that are not
- * part of the v2 API but are needed by x402x middleware implementations.
- */
-
-/**
- * Supported EVM networks (legacy v1 pattern)
- * In v2, networks use CAIP-2 format (e.g., 'eip155:84532')
- */
-declare const SupportedEVMNetworks: Network[];
-/**
- * Money schema validator (legacy v1 pattern)
- * In v2, validation is typically done through zod schemas in @x402/core
- */
-declare const moneySchema: {
-    parse: (value: unknown) => string | number;
-};
-/**
- * Settle response header name (legacy v1 pattern)
- * In v2, this is typically handled by x402HTTPResourceServer
- */
-declare const settleResponseHeader = "X-Payment-Response";
-/**
- * EVM utilities placeholder (legacy v1 pattern)
- * In v2, EVM functionality is provided by @x402/evm package
- */
-declare const evm: {
-    /**
-     * Check if a value is a valid EVM address
-     */
-    isAddress: (value: unknown) => boolean;
-};
-/**
- * Payment scheme stub (legacy v1 pattern)
- * In v2, schemes are implemented as classes extending SchemeNetworkClient/Server
- */
-declare const exact: {
-    name: "exact";
-};
-/**
- * Chain ID to network mapping (legacy v1 pattern)
- */
-declare const ChainIdToNetwork: Record<number, Network>;
-/**
- * Check if a signer is a multi-network signer
- */
-declare function isMultiNetworkSigner(signer: unknown): boolean;
-/**
- * Check if a signer is an SVM (Solana) signer wallet
- */
-declare function isSvmSignerWallet(signer: unknown): boolean;
-/**
- * Multi-network signer interface (legacy v1 pattern)
- */
-interface MultiNetworkSigner {
-    address?: string;
-    signTransaction?: (tx: unknown) => Promise<unknown>;
-    [key: string]: unknown;
-}
-/**
- * X402 configuration interface (legacy v1 pattern)
- */
-interface X402Config {
-    signer?: MultiNetworkSigner;
-    [key: string]: unknown;
-}
-/**
- * Payment requirements selector type (legacy v1 pattern)
- */
-type PaymentRequirementsSelector = (requirements: unknown[]) => unknown;
-/**
- * Create payment header (legacy v1 stub)
- * In v2, this is handled by x402Client.createPaymentPayload()
- */
-declare function createPaymentHeader(_requirements: unknown, _signer: unknown): Promise<string>;
-/**
- * Select payment requirements (legacy v1 stub)
- * In v2, this is handled by x402Client.createPaymentPayload()
- */
-declare function selectPaymentRequirements(_requirements: unknown[], _selector?: PaymentRequirementsSelector): unknown;
-/**
- * Decode X-Payment-Response header (legacy v1 stub)
- * In v2, response handling is done through x402HTTPClient
- */
-declare function decodeXPaymentResponse(_header: string): unknown;
-/**
- * Use facilitator for verification (legacy v1 stub)
- * In v2, this is handled through FacilitatorClient
- */
-declare function useFacilitator(_config: unknown): void;
-/**
- * Create a signer instance (legacy v1 stub)
- */
-declare function createSigner(_config: unknown): unknown;
-
 /**
  * Network utility functions for x402x core_v2
  *
@@ -1767,31 +1769,39 @@ interface AssetInfo {
     };
 }
 /**
- * Get CAIP-2 network ID from network name
+ * Primary mapping from human-readable network names to CAIP-2 identifiers
  *
- * @param networkName - Network name (e.g., 'base-sepolia', 'base')
- * @returns CAIP-2 network identifier (e.g., 'eip155:84532')
- * @throws Error if network name is not supported
+ * This is the SINGLE SOURCE OF TRUTH for network name mappings.
+ * When adding a new network, only update this mapping and the corresponding
+ * entries in networks.ts and DEFAULT_ASSETS.
+ */
+declare const NETWORK_ALIASES_V1_TO_V2: Record<string, Network>;
+/**
+ * CAIP-2 network ID to network alias mapping (reverse lookup)
  *
- * @example
- * ```typescript
- * const networkId = getNetworkId('base-sepolia'); // 'eip155:84532'
- * ```
+ * Maps CAIP-2 identifiers to v1 configuration aliases (e.g., "eip155:84532" → "base-sepolia").
+ * These aliases are used in configuration files and for backward compatibility.
+ *
+ * Automatically generated from NETWORK_ALIASES_V1_TO_V2.
+ * DO NOT edit this manually - it will be regenerated.
  */
-declare function getNetworkId(networkName: string): Network;
+declare const NETWORK_ALIASES: Record<Network, string>;
 /**
- * Get network name from CAIP-2 network ID
+ * Get network alias from CAIP-2 network ID
+ *
+ * Returns the v1 configuration alias (e.g., "base-sepolia") for a given CAIP-2 identifier.
+ * These aliases are used in configuration files and for backward compatibility.
  *
  * @param network - CAIP-2 network identifier (e.g., 'eip155:84532')
- * @returns Network name (e.g., 'base-sepolia')
+ * @returns Network alias (e.g., 'base-sepolia')
  * @throws Error if network ID is not supported
  *
  * @example
  * ```typescript
- * const networkName = getNetworkName('eip155:84532'); // 'base-sepolia'
+ * const alias = getNetworkAlias('eip155:84532'); // 'base-sepolia'
  * ```
  */
-declare function getNetworkName(network: Network): string;
+declare function getNetworkAlias(network: Network): string;
 /**
  * Get default asset (USDC) information for a network
  *
@@ -1827,11 +1837,6 @@ declare function processPriceToAtomicAmount(price: string | number, network: Net
 } | {
     error: string;
 };
-/**
- * Alias mapping from v1 network names to v2 CAIP-2 identifiers
- * This provides backward compatibility for v1 network names
- */
-declare const NETWORK_ALIASES_V1_TO_V2: Record<string, Network>;
 /**
  * Get list of all supported network IDs (CAIP-2 identifiers)
  *
@@ -1852,11 +1857,6 @@ declare const NETWORK_ALIASES_V1_TO_V2: Record<string, Network>;
  * ```
  */
 declare function getSupportedNetworkIds(): Network[];
-/**
- * @deprecated Use getSupportedNetworkIds() instead for clarity
- * Get list of all supported networks using v2 CAIP-2 identifiers
- */
-declare function getSupportedNetworksV2(): Network[];
 /**
  * Get the alias mapping from v1 network names to v2 CAIP-2 identifiers
  *
@@ -1888,4 +1888,183 @@ declare function getNetworkAliasesV1ToV2(): Record<string, Network>;
  */
 declare function toCanonicalNetworkKey(network: string): Network;
 
-export { type Address, AmountError, ChainIdToNetwork, type CommitmentParams, type DemoHooks, type FacilitatorConfig, type SettleResponse$1 as FacilitatorSettleResponse, FacilitatorValidationError, type VerifyResponse$1 as FacilitatorVerifyResponse, type FeeCalculationResult, type RouteConfig as LegacyRouteConfig, type MintConfig, type Money, type MultiNetworkSigner, NETWORK_ALIASES_V1_TO_V2, NFTMintHook, type NetworkConfig, type PaymentRequirementsSelector, ROUTER_SETTLEMENT_KEY, type Resource, type RewardConfig, RewardHook, type RoutePattern, type RouterSettlementExtension, type RouterSettlementExtensionInfo, type RoutesConfig, SETTLEMENT_ROUTER_ABI, type SettleResponse, type SettlementExtra, type SettlementExtraCore, SettlementExtraError, type SettlementHooksConfig, type SettlementOptions, type SettlementPaymentOption, type SettlementRouteConfig, SettlementRouterError, type SettlementRouterParams, type Signer, SupportedEVMNetworks, TransferHook, type ValidationResult, type VerifyResponse, type WithRouterSettlementOptions, type X402Config, addSettlementExtra, assertValidSettlementExtra, calculateCommitment, calculateFacilitatorFee, clearFeeCache, computeRoutePatterns, createExtensionDeclaration, createPaymentHeader, createRouterSettlementExtension, createSettlementRouteConfig, createSigner, createX402xFacilitator, decodeXPaymentResponse, evm, exact, findMatchingPaymentRequirements, findMatchingRoute, formatDefaultAssetAmount, generateSalt, getChain, getChainById, getCustomChains, getDefaultAsset, getNetworkAliasesV1ToV2, getNetworkConfig, getNetworkId, getNetworkName, getRouterSettlementExtensionKey, getSupportedNetworkIds, getSupportedNetworkNames, getSupportedNetworks, getSupportedNetworksV2, isCustomChain, isMultiNetworkSigner, isNetworkSupported, isRouterSettlement, isSettlementMode, isSvmSignerWallet, isValid32ByteHex, isValidAddress, isValidHex, isValidNumericString, moneySchema, networks, parseDefaultAssetAmount, parseSettlementExtra, processPriceToAtomicAmount, registerRouterSettlement, registerSettlementHooks, routerSettlementServerExtension, selectPaymentRequirements, settle, settleResponseHeader, toCanonicalNetworkKey, toJsonSafe, useFacilitator, validateCommitmentParams, validateSettlementExtra, verify, withRouterSettlement };
+/**
+ * x402x EVM Client Scheme with Router Settlement
+ *
+ * This scheme extends the standard EVM exact scheme to support x402x router settlement.
+ * The key difference is using a commitment hash (binding all settlement parameters)
+ * as the EIP-3009 nonce instead of a random value.
+ */
+
+/**
+ * Client EVM signer interface
+ * Compatible with viem WalletClient and LocalAccount
+ */
+type ClientEvmSigner = {
+    readonly address: `0x${string}`;
+    signTypedData(message: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    }): Promise<`0x${string}`>;
+};
+/**
+ * EVM client implementation for the Exact payment scheme with x402x router settlement.
+ *
+ * This scheme uses a commitment hash as the EIP-3009 nonce to cryptographically bind
+ * all settlement parameters (salt, hook, hookData, etc.) to the user's signature,
+ * preventing parameter tampering attacks.
+ *
+ * @example
+ * ```typescript
+ * import { ExactEvmSchemeWithRouterSettlement } from '@x402x/extensions/client';
+ * import { x402Client } from '@x402/core/client';
+ *
+ * const signer = { address, signTypedData }; // viem WalletClient or LocalAccount
+ * const scheme = new ExactEvmSchemeWithRouterSettlement(signer);
+ *
+ * const client = new x402Client()
+ *   .register('eip155:84532', scheme);
+ * ```
+ */
+declare class ExactEvmSchemeWithRouterSettlement implements SchemeNetworkClient {
+    private readonly signer;
+    readonly scheme = "exact";
+    /**
+     * Per-request router settlement extension (typically sourced from PaymentRequired.extensions).
+     *
+     * IMPORTANT: We do NOT put this on `paymentRequirements.extra`, because for x402 v2 the
+     * server matches paid requests by deep-equality between `paymentPayload.accepted` and the
+     * server-side `accepts[]`. Mutating `accepted` will cause "No matching payment requirements".
+     */
+    private routerSettlementFromPaymentRequired?;
+    /**
+     * Creates a new ExactEvmSchemeWithRouterSettlement instance.
+     *
+     * @param signer - The EVM signer for client operations (viem WalletClient or LocalAccount)
+     */
+    constructor(signer: ClientEvmSigner);
+    /**
+     * Set router-settlement extension data for the next payment payload creation.
+     *
+     * Intended to be called from an `x402Client.onBeforePaymentCreation` hook, which has access
+     * to `paymentRequired.extensions`.
+     */
+    setRouterSettlementExtensionFromPaymentRequired(ext: unknown | undefined): void;
+    /**
+     * Creates a payment payload for the Exact scheme with router settlement.
+     *
+     * This method:
+     * 1. Extracts settlement parameters from PaymentRequired.extensions
+     * 2. Calculates a commitment hash binding all parameters
+     * 3. Uses the commitment as the EIP-3009 nonce
+     * 4. Signs with settlementRouter as the 'to' address
+     *
+     * @param x402Version - The x402 protocol version (must be 2)
+     * @param paymentRequirements - The payment requirements from the server
+     * @returns Promise resolving to a payment payload
+     *
+     * @throws Error if x402Version is not 2
+     * @throws Error if x402x-router-settlement extension is missing
+     * @throws Error if required settlement parameters are missing
+     */
+    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+    /**
+     * Sign the EIP-3009 authorization using EIP-712
+     *
+     * @param authorization - The authorization to sign
+     * @param requirements - The payment requirements
+     * @param chainId - The chain ID
+     * @returns Promise resolving to the signature
+     */
+    private signAuthorization;
+}
+
+/**
+ * x402x Extension Handler
+ *
+ * Provides utilities to integrate x402x router settlement with official x402 SDK.
+ *
+ * The challenge: x402 v2 spec places extensions at root level in PaymentRequired,
+ * but x402x scheme needs settlement parameters from PaymentRequirements.extra.
+ *
+ * Solution: Provide two-layer API:
+ * 1. High-level: registerX402xScheme() - one line setup (recommended)
+ * 2. Low-level: injectX402xExtensionHandler() - flexible configuration
+ */
+
+/**
+ * Injects x402x extension handler into x402Client (Low-level API).
+ *
+ * IMPORTANT (x402 v2 + x402x multi-network):
+ * - Server returns per-option x402x info in `accepts[i].extra["x402x-router-settlement"]`
+ * - x402Client only passes `PaymentRequirements` to scheme (no root extensions)
+ * - Facilitator v2 reads from `paymentPayload.extensions["x402x-router-settlement"]`
+ *
+ * Solution: Copy the selected option's x402x info from `selectedRequirements.extra`
+ * into `paymentRequired.extensions` so it gets included in `paymentPayload.extensions`.
+ *
+ * This does NOT mutate `selectedRequirements` (which becomes `paymentPayload.accepted`),
+ * so v2 deepEqual matching still works.
+ *
+ * @param client - x402Client instance to inject handler into
+ * @param onRouterSettlementExtension - Callback to receive the per-request extension object
+ * @returns The same client instance for chaining
+ *
+ * @example Low-level API (for advanced users)
+ * ```typescript
+ * import { x402Client } from '@x402/core/client';
+ * import {
+ *   injectX402xExtensionHandler,
+ *   ExactEvmSchemeWithRouterSettlement
+ * } from '@x402x/extensions';
+ *
+ * const client = new x402Client();
+ * const scheme = new ExactEvmSchemeWithRouterSettlement(signer);
+ * injectX402xExtensionHandler(client, (ext) => scheme.setRouterSettlementExtensionFromPaymentRequired(ext))
+ *   .register('eip155:84532', scheme);
+ * ```
+ */
+declare function injectX402xExtensionHandler(client: x402Client, onRouterSettlementExtension?: (extension: unknown | undefined) => void): x402Client;
+/**
+ * Register x402x router settlement scheme with automatic extension handling (High-level API).
+ *
+ * This is the recommended way to set up x402x payments. It combines:
+ * 1. Extension handler injection (injectX402xExtensionHandler)
+ * 2. Scheme registration (ExactEvmSchemeWithRouterSettlement)
+ *
+ * Use this for the simplest integration - just provide your signer and network.
+ *
+ * @param client - x402Client instance
+ * @param network - Network identifier in CAIP-2 format (e.g., "eip155:84532")
+ * @param signer - EVM signer with address and signTypedData method
+ * @returns The client instance for chaining
+ *
+ * @example High-level API (recommended)
+ * ```typescript
+ * import { x402Client } from '@x402/core/client';
+ * import { registerX402xScheme } from '@x402x/extensions';
+ * import { useWalletClient } from 'wagmi';
+ *
+ * const { data: walletClient } = useWalletClient();
+ *
+ * const client = new x402Client();
+ * registerX402xScheme(client, 'eip155:84532', {
+ *   address: walletClient.account.address,
+ *   signTypedData: walletClient.signTypedData,
+ * });
+ *
+ * // That's it! Client is ready for x402x payments
+ * ```
+ *
+ * @example Multiple networks
+ * ```typescript
+ * const client = new x402Client();
+ * registerX402xScheme(client, 'eip155:84532', signer); // Base Sepolia
+ * registerX402xScheme(client, 'eip155:8453', signer);  // Base Mainnet
+ * ```
+ */
+declare function registerX402xScheme(client: x402Client, network: Network, signer: ClientEvmSigner): x402Client;
+
+export { type Address, AmountError, type ClientEvmSigner, type CommitmentParams, type DemoHooks, ExactEvmSchemeWithRouterSettlement, type FacilitatorConfig, type SettleResponse$1 as FacilitatorSettleResponse, FacilitatorValidationError, type VerifyResponse$1 as FacilitatorVerifyResponse, type FeeCalculationResult, type RouteConfig as LegacyRouteConfig, type MintConfig, type Money, NETWORK_ALIASES, NETWORK_ALIASES_V1_TO_V2, NFTMintHook, type NetworkConfig, ROUTER_SETTLEMENT_KEY, type Resource, type RewardConfig, RewardHook, type RoutePattern, type RouterSettlementExtension, type RouterSettlementExtensionInfo, type RoutesConfig, SETTLEMENT_ROUTER_ABI, type SettleResponse, type SettlementExtra, type SettlementExtraCore, SettlementExtraError, type SettlementHooksConfig, type SettlementOptions, type SettlementPaymentOption, type SettlementRouteConfig, SettlementRouterError, type SettlementRouterParams, type Signer, TransferHook, type ValidationResult, type VerifyResponse, type WithRouterSettlementOptions, addSettlementExtra, assertValidSettlementExtra, calculateCommitment, calculateFacilitatorFee, clearFeeCache, computeRoutePatterns, createExtensionDeclaration, createRouterSettlementExtension, createSettlementRouteConfig, createX402xFacilitator, findMatchingPaymentRequirements, findMatchingRoute, formatDefaultAssetAmount, generateSalt, getChain, getChainById, getCustomChains, getDefaultAsset, getNetworkAlias, getNetworkAliasesV1ToV2, getNetworkConfig, getRouterSettlementExtensionKey, getSupportedNetworkAliases, getSupportedNetworkIds, getSupportedNetworks, injectX402xExtensionHandler, isCustomChain, isNetworkSupported, isRouterSettlement, isSettlementMode, isValid32ByteHex, isValidAddress, isValidHex, isValidNumericString, networks, parseDefaultAssetAmount, parseSettlementExtra, processPriceToAtomicAmount, registerRouterSettlement, registerSettlementHooks, registerX402xScheme, routerSettlementServerExtension, settle, toCanonicalNetworkKey, toJsonSafe, validateCommitmentParams, validateSettlementExtra, verify, withRouterSettlement };