@springmint/x402-payment 1.0.1 → 1.0.3

package/dist/cli/{743.index.js → 618.index.js}

@@ -1,5 +1,5 @@
-export const id = 743;
-export const ids = [743];
+export const id = 618;
+export const ids = [618];
 export const modules = {
 
 /***/ 1491:
@@ -37689,7 +37689,7 @@ function randomBytes(bytesLength = 32) {
 
 /***/ }),
 
-/***/ 3743:
+/***/ 8618:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 
@@ -37703,14 +37703,14 @@ __webpack_require__.d(__webpack_exports__, {
   ExactPermitTronClientMechanism: () => (/* reexport */ ExactPermitTronClientMechanism),
   ExactTronClientMechanism: () => (/* reexport */ ExactTronClientMechanism),
   o6: () => (/* reexport */ InsufficientAllowanceError),
-  uF: () => (/* reexport */ KIND_MAP),
-  N3: () => (/* reexport */ PAYMENT_PERMIT_TYPES),
   Px: () => (/* reexport */ config_PAYMENT_REQUIRED_HEADER),
   g7: () => (/* reexport */ config_PAYMENT_SIGNATURE_HEADER),
+  gG: () => (/* reexport */ PERMIT402_TYPES),
+  uz: () => (/* reexport */ PTYPE_MAP),
   fL: () => (/* reexport */ PermitValidationError),
+  dz: () => (/* reexport */ setting_SCHEMES),
   e$: () => (/* reexport */ SignatureCreationError),
   SufficientBalancePolicy: () => (/* reexport */ SufficientBalancePolicy),
-  P5: () => (/* reexport */ TRON_RPC_URLS),
   KT: () => (/* reexport */ TRON_ZERO_ADDRESS),
   qR: () => (/* reexport */ TronAddressConverter),
   TronClientSigner: () => (/* reexport */ TronClientSigner),
@@ -37720,12 +37720,12 @@ __webpack_require__.d(__webpack_exports__, {
   hV: () => (/* reexport */ encoding_decodePaymentPayload),
   Py: () => (/* reexport */ encoding_encodePaymentPayload),
   TH: () => (/* reexport */ getChainId),
-  kv: () => (/* reexport */ getPaymentPermitAddress),
-  Ff: () => (/* reexport */ resolveRpcUrl),
+  e5: () => (/* reexport */ getPermit402Address),
+  AB: () => (/* reexport */ resolveRpcUrls),
   ld: () => (/* reexport */ toEvmHex)
 });
 
-// UNUSED EXPORTS: AllowanceError, CHAIN_IDS, CheapestTokenSelectionStrategy, ConfigurationError, DefaultTokenSelectionStrategy, EIP712_DOMAIN_TYPE, ERC20_ABI, EVM_RPC_URLS, Facilitator, FacilitatorFetchError, FacilitatorSettleError, FacilitatorVerifyError, JSON_CONTENT_TYPE, NETWORKS, PAYMENT_ONLY, PAYMENT_PERMIT_ADDRESSES, PAYMENT_PERMIT_PRIMARY_TYPE, ResourceConfig, ResponseError, SCHEME_EXACT, SignatureError, TRANSFER_AUTH_EIP712_TYPES, TRANSFER_AUTH_PRIMARY_TYPE, ValidationError, X402Error, X402Middleware, X402Server, ZERO_ADDRESS_HEX, buildEip712Domain, buildEip712Message, bytesToHex, createNonce, createValidityWindow, decodeBase64, decodeBase64ToBytes, decodeJSON, encodeBase64, encodeJSON, findByAddress, getNetworkTokens, getToken, getZeroAddress, hexToBytes, isEvmNetwork, isTronNetwork, paymentIdToBytes, registerToken, toBase58, x402_protected
+// UNUSED EXPORTS: AllowanceError, CHAIN_IDS, CheapestTokenSelectionStrategy, ConfigurationError, DefaultTokenSelectionStrategy, EIP712_DOMAIN_TYPE, ERC20_ABI, EVM_RPC_URLS, FACILITATOR_ENDPOINTS, Facilitator, FacilitatorFetchError, FacilitatorSettleError, FacilitatorVerifyError, JSON_CONTENT_TYPE, NETWORKS, PAYMENT_ONLY, PERMIT402_ADDRESSES, PERMIT402_PRIMARY_TYPE, ResourceConfig, ResponseError, SignatureError, TRANSFER_AUTH_EIP712_TYPES, TRANSFER_AUTH_PRIMARY_TYPE, TRON_RPC_URLS, ValidationError, X402Error, X402Middleware, X402Server, ZERO_ADDRESS_HEX, buildEip712Domain, buildEip712Message, bytesToHex, createNonce, createValidityWindow, decodeBase64, decodeBase64ToBytes, decodeJSON, encodeBase64, encodeJSON, findByAddress, getNetworkTokens, getToken, getZeroAddress, hexToBytes, isEvmNetwork, isTronNetwork, paymentIdToBytes, registerToken, resolveRpcUrl, toBase58, x402_protected
 
 // NAMESPACE OBJECT: ./node_modules/tronweb/lib/esm/utils/bytes.js
 var bytes_namespaceObject = {};
@@ -38388,11 +38388,6 @@ class X402Client {
  *
  * Policies are applied in order after mechanism filtering and before token selection.
  */
-
-function policies_getDecimals(req) {
-    const token = findByAddress(req.network, req.asset);
-    return token?.decimals ?? 6;
-}
 /**
  * Policy that filters out requirements with insufficient balance.
  *
@@ -38431,31 +38426,16 @@ class SufficientBalancePolicy {
             try {
                 balance = await signer.checkBalance(req.asset, req.network);
             }
-            catch {
-                // Signer cannot query this network; keep the requirement.
-                affordable.push(req);
-                continue;
+            catch (error) {
+                throw new Error(`Failed to query balance via RPC for ${req.scheme} on ${req.network}: ${error instanceof Error ? error.message : String(error)}`);
             }
             let needed = BigInt(req.amount);
             if (req.extra?.fee?.feeAmount) {
                 needed += BigInt(req.extra.fee.feeAmount);
             }
-            const decimals = policies_getDecimals(req);
-            const token = findByAddress(req.network, req.asset);
-            const symbol = token?.symbol ?? req.asset.slice(0, 8);
-            const divisor = 10 ** decimals;
-            const hBalance = (Number(balance) / divisor).toFixed(decimals);
-            const hNeeded = (Number(needed) / divisor).toFixed(decimals);
             if (balance >= needed) {
-                console.log(`[x402] ${symbol} on ${req.network}: balance=${hBalance} >= needed=${hNeeded} (OK)`);
                 affordable.push(req);
             }
-            else {
-                console.log(`[x402] ${symbol} on ${req.network}: balance=${hBalance} < needed=${hNeeded} (skipped)`);
-            }
-        }
-        if (affordable.length === 0) {
-            console.error("[x402] All payment requirements filtered: insufficient balance");
         }
         return affordable;
     }
@@ -38587,8 +38567,8 @@ function paymentIdToBytes(paymentId) {
  * ABI and EIP-712 type definitions for x402 protocol
  * Shared across all mechanisms
  */
-/** EIP-712 Primary Type for Permit402 (matches contract Permit402Details) */
-const PAYMENT_PERMIT_PRIMARY_TYPE = "Permit402Details";
+/** EIP-712 Primary Type for Permit402 */
+const PERMIT402_PRIMARY_TYPE = "Permit402Details";
 /**
  * EIP-712 Domain Type
  * Based on contract: keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
@@ -38601,9 +38581,9 @@ const EIP712_DOMAIN_TYPE = [
 ];
 /**
  * EIP-712 type definitions for Permit402
- * Matches IPermit402.sol and PermitHash.sol - struct has meta, buyer, payment, fee (no caller)
+ * Based on PermitHash.sol from the contract
  */
-const PAYMENT_PERMIT_TYPES = {
+const PERMIT402_TYPES = {
     PermitMeta: [
         { name: "ptype", type: "uint8" },
         { name: "paymentId", type: "bytes16" },
@@ -38627,8 +38607,8 @@ const PAYMENT_PERMIT_TYPES = {
         { name: "fee", type: "Fee" },
     ],
 };
-/** Kind mapping for EIP-712 (string to numeric) */
-const KIND_MAP = {
+/** Ptype mapping for EIP-712 (string to numeric) */
+const PTYPE_MAP = {
     PAYMENT_ONLY: 0,
 };
 /** ERC20 ABI for allowance/approve calls */
@@ -38683,18 +38663,18 @@ const NETWORKS = {
     BSC_MAINNET: "eip155:56",
     BSC_TESTNET: "eip155:97",
 };
-/** PaymentPermit contract addresses */
-const PAYMENT_PERMIT_ADDRESSES = {
-    "tron:mainnet": "TT8rEWbCoNX7vpEUauxb7rWJsTgs8vDLAn",
-    "tron:shasta": "TR2XninQ3jsvRRLGTifFyUHTBysffooUjt",
-    "tron:nile": "TFxDcGvS7zfQrS1YzcCMp673ta2NHHzsiH",
-    "eip155:97": "0x84084692ea4E1BeEE56668b80D13902426fc3917",
-    "eip155:56": "0x84084692ea4E1BeEE56668b80D13902426fc3917",
+/** Permit402 contract addresses */
+const PERMIT402_ADDRESSES = {
+    "tron:mainnet": "TK5kfgbNK5B5sFWSbtDs2HyCaSUuEzfN2B",
+    "tron:shasta": "TSNfGRDkyyDY4dHsWzQ6rWWG63p9iczz1k",
+    "tron:nile": "TRK2rYmbyFZKcPTDREEF36rEsLfDWZXnjA",
+    "eip155:97": "",
+    "eip155:56": "0x105a6f4613a1d1c17ef35d4d5f053fa2e659a958",
 };
 /** Default RPC URLs for EVM networks */
 const EVM_RPC_URLS = {
-    "eip155:97": "https://data-seed-prebsc-2-s2.bnbchain.org:8545",
-    "eip155:56": "https://bsc-dataseed.binance.org",
+    "eip155:97": ["https://data-seed-prebsc-2-s2.bnbchain.org:8545", "https://bsc-testnet-rpc.publicnode.com"],
+    "eip155:56": ["https://bsc-dataseed.binance.org", "https://rpc-bsc.48.club"],
     // 'eip155:1': 'https://eth.llamarpc.com',
 };
 /** Default TronGrid hosts for TRON networks */
@@ -38703,12 +38683,38 @@ const TRON_RPC_URLS = {
     "tron:shasta": "https://api.shasta.trongrid.io",
     "tron:nile": "https://nile.trongrid.io",
 };
+/** Normalize any RPC URL input into a de-duplicated array */
+function normalizeRpcUrls(input) {
+    if (!input)
+        return [];
+    const values = Array.isArray(input) ? input : [input];
+    const unique = [];
+    for (const value of values) {
+        const url = value.trim();
+        if (!url)
+            continue;
+        if (!unique.includes(url)) {
+            unique.push(url);
+        }
+    }
+    return unique;
+}
+/**
+ * Resolve all available RPC URLs for a network.
+ * Priority: caller overrides first, built-in defaults second.
+ */
+function resolveRpcUrls(network, overrides) {
+    const customUrls = normalizeRpcUrls(overrides?.[network]);
+    const defaultUrl = EVM_RPC_URLS[network] ?? TRON_RPC_URLS[network];
+    const defaultUrls = normalizeRpcUrls(defaultUrl);
+    return [...customUrls, ...defaultUrls.filter((url) => !customUrls.includes(url))];
+}
 /**
  * Resolve a network identifier to an RPC URL.
  * Returns the URL from the built-in map, or undefined if not configured.
  */
 function resolveRpcUrl(network) {
-    return EVM_RPC_URLS[network] ?? TRON_RPC_URLS[network];
+    return resolveRpcUrls(network)[0];
 }
 /** Zero address for TRON */
 const TRON_ZERO_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
@@ -38733,10 +38739,10 @@ function getChainId(network) {
     return chainId;
 }
 /**
- * Get PaymentPermit contract address for network
+ * Get Permit402 contract address for network
  */
-function getPaymentPermitAddress(network) {
-    const addr = PAYMENT_PERMIT_ADDRESSES[network];
+function getPermit402Address(network) {
+    const addr = PERMIT402_ADDRESSES[network];
     if (addr)
         return addr;
     // EVM fallback: zero address (not yet deployed)
@@ -38770,6 +38776,17 @@ const config_PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
 const config_PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
 const config_JSON_CONTENT_TYPE = "application/json";
 //# sourceMappingURL=config.js.map
+;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/setting.js
+// facilitator configure
+const FACILITATOR_ENDPOINTS = {
+    popular: "https://www.cppay.finance/api/x402/facilitator",
+};
+// sheme exact
+const setting_SCHEMES = {
+    erc3009: "transfer_auth",
+    permit402: "permit402",
+};
+//# sourceMappingURL=setting.js.map
 ;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/address.js
 /**
  * Address conversion utilities for x402 protocol
@@ -38875,7 +38892,7 @@ function toEvmHex(addr) {
         return base58ToEvmHex(addr);
     }
     // Invalid format, return zero address
-    console.warn(`[toEvmHex] Invalid address format: ${addr}, returning zero address`);
+    // Invalid format, return zero address
     return ZERO_ADDRESS_HEX;
 }
 /**
@@ -38890,7 +38907,7 @@ function base58ToEvmHex(addr) {
     for (const char of addr) {
         const value = alphabetMap[char];
         if (value === undefined) {
-            console.warn(`[toEvmHex] Invalid Base58 character: ${char} in address: ${addr}`);
+            // Invalid Base58 character
             return ZERO_ADDRESS_HEX;
         }
         num = num * BigInt(58) + BigInt(value);
@@ -39005,12 +39022,6 @@ class X402FetchClient {
     }
 }
 //# sourceMappingURL=client.js.map
-;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/setting.js
-// facilitator configure
-const FACILITATOR_ENDPOINTS = {
-    popular: "https://www.cppay.finance/api/x402/facilitator",
-};
-//# sourceMappingURL=setting.js.map
 ;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/server/facilitator.js
 var _a;
 
@@ -39028,7 +39039,7 @@ class Facilitator {
     }
     async #request(url, init) {
         try {
-            const fullUrl = new URL(url, this.endpoint);
+            const fullUrl = new URL(`${this.endpoint}${url}`);
             const response = await fetch(fullUrl, {
                 ...init,
                 headers: { ...init?.headers, [_a.apikey_header]: this.apikey },
@@ -39046,10 +39057,23 @@ class Facilitator {
         }
     }
     async feeQuote(accepts, context) {
-        return await this.#request("/fee/quote", {
+        const response = await this.#request("/fee/quote", {
             method: "POST",
-            body: JSON.stringify({ accepts, paymentPermitContext: context }),
+            body: JSON.stringify({ accepts, permit402Context: context }),
         });
+        if (response == null) {
+            return [];
+        }
+        if (Array.isArray(response)) {
+            return response;
+        }
+        if (Array.isArray(response.quotes)) {
+            return response.quotes;
+        }
+        if (Array.isArray(response.data)) {
+            return response.data;
+        }
+        throw new FacilitatorFetchError('Request "/fee/quote" failed, invalid response format');
     }
     async supported() {
         return await this.#request("/supported", { method: "GET" });
@@ -39075,6 +39099,7 @@ var external_node_crypto_ = __webpack_require__(7598);
 var external_node_crypto_namespaceObject = /*#__PURE__*/__webpack_require__.t(external_node_crypto_, 2);
 ;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/server/x402Server.js
 
+
 const x402Server_PAYMENT_ONLY = "PAYMENT_ONLY";
 class x402Server_ResourceConfig {
     scheme;
@@ -39150,13 +39175,16 @@ class X402Server {
         if (!this.facilitator) {
             throw new Error("Facilitator is not set");
         }
-        const permitReqs = requirementsList.filter((r) => r.scheme !== "transfer_auth");
-        const exactReqs = requirementsList.filter((r) => r.scheme === "transfer_auth");
+        const permitReqs = requirementsList.filter((r) => r.scheme !== SCHEMES.erc3009);
+        const exactReqs = requirementsList.filter((r) => r.scheme === SCHEMES.erc3009);
         const supported = [...exactReqs];
         if (permitReqs.length === 0) {
             return supported;
         }
         const feeQuotes = await this.facilitator.feeQuote(permitReqs);
+        if (!Array.isArray(feeQuotes)) {
+            throw new Error("Facilitator feeQuote returned invalid response");
+        }
         const quoteMap = new Map();
         for (const quote of feeQuotes) {
             quoteMap.set(`${quote.scheme}|${quote.network}|${quote.asset}`.toLowerCase(), quote);
@@ -39172,7 +39200,6 @@ class X402Server {
                 facilitatorId: this.facilitator.facilitatorId,
                 feeTo: feeQuote.fee.feeTo,
                 feeAmount: feeQuote.fee.feeAmount,
-                caller: feeQuote.fee.feeTo,
             };
             supported.push(req);
         }
@@ -39189,9 +39216,9 @@ class X402Server {
             resource: resourceInfo,
             accepts: requirements,
             extensions: {
-                paymentPermitContext: {
+                permit402Context: {
                     meta: {
-                        kind: x402Server_PAYMENT_ONLY,
+                        ptype: x402Server_PAYMENT_ONLY,
                         paymentId: paymentId ?? this.generatePaymentId(),
                         nonce: nonce ?? this.generateNonce(),
                         validAfter: validAfter ?? now,
@@ -39210,7 +39237,7 @@ class X402Server {
         }
         const mechanism = this.findMechanism(requirements.network, requirements.scheme);
         if (mechanism?.verifySignature) {
-            const isValid = await mechanism.verifySignature(payload.payload.paymentPermit, payload.payload.signature, requirements.network);
+            const isValid = await mechanism.verifySignature(payload.payload.permit402, payload.payload.signature, requirements.network);
             if (!isValid) {
                 return { isValid: false, invalidReason: "invalid_signature_server" };
             }
@@ -39243,7 +39270,7 @@ class X402Server {
         return networkMechanisms[scheme] ?? null;
     }
     validatePayloadMatchesRequirements(payload, requirements) {
-        const permit = payload.payload.paymentPermit;
+        const permit = payload.payload.permit402;
         if (permit.payment.payToken.toLowerCase() !== requirements.asset.toLowerCase()) {
             return false;
         }
@@ -39492,13 +39519,13 @@ function x402_protected(server, prices, schemes, network, pay_to, options) {
 //# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/mechanisms/exact.js
 /**
- * ExactPermitTronClientMechanism - TRON client mechanism for "payment_permit" payment scheme
+ * ExactPermitTronClientMechanism - TRON client mechanism for "permit402" payment scheme
  *
- * Uses TIP-712 (TRON's EIP-712 implementation) for signing PaymentPermit.
+ * Uses TIP-712 (TRON's EIP-712 implementation) for signing Permit402.
  */
 
 /**
- * TRON client mechanism for "payment_permit" payment scheme
+ * TRON client mechanism for "permit402" payment scheme
  */
 class ExactPermitTronClientMechanism {
     signer;
@@ -39510,25 +39537,24 @@ class ExactPermitTronClientMechanism {
         return this.signer;
     }
     scheme() {
-        return "payment_permit";
+        return setting_SCHEMES.permit402;
     }
     async createPaymentPayload(requirements, resource, extensions) {
-        const context = extensions?.paymentPermitContext;
+        const context = extensions?.permit402Context;
         if (!context) {
-            throw new PermitValidationError("missing_context", "paymentPermitContext is required");
+            throw new PermitValidationError("missing_context", "permit402Context is required");
         }
         const buyerAddress = this.signer.getAddress();
-        const zeroAddress = TRON_ZERO_ADDRESS; // Use TRON zero address for consistency with Python
+        const zeroAddress = TRON_ZERO_ADDRESS;
         const permit = {
             meta: {
-                kind: context.meta.kind,
+                ptype: context.meta.ptype,
                 paymentId: context.meta.paymentId,
                 nonce: context.meta.nonce,
                 validAfter: context.meta.validAfter,
                 validBefore: context.meta.validBefore,
             },
             buyer: buyerAddress,
-            caller: requirements.extra?.fee?.caller || zeroAddress,
             payment: {
                 payToken: requirements.asset,
                 payAmount: requirements.amount,
@@ -39542,19 +39568,18 @@ class ExactPermitTronClientMechanism {
         // Ensure allowance
         const totalAmount = BigInt(permit.payment.payAmount) + BigInt(permit.fee.feeAmount);
         await this.signer.ensureAllowance(permit.payment.payToken, totalAmount, requirements.network);
-        // Build EIP-712 domain - must match contract (name: "Permit402")
-        const permitAddress = getPaymentPermitAddress(requirements.network);
+        // Build EIP-712 domain (no version field per contract spec)
+        const permitAddress = getPermit402Address(requirements.network);
         const domain = {
             name: "Permit402",
             chainId: getChainId(requirements.network),
             verifyingContract: this.addressConverter.toEvmFormat(permitAddress),
         };
-        // Convert permit to EIP-712 format matching Permit402Details (meta, buyer, payment, fee - no caller)
-        const ptype = KIND_MAP[permit.meta.kind] ?? 0;
+        // Convert permit to EIP-712 compatible format
         const permitForSigning = {
             meta: {
-                ptype,
-                paymentId: permit.meta.paymentId.startsWith("0x") ? permit.meta.paymentId : `0x${permit.meta.paymentId}`,
+                ptype: PTYPE_MAP[permit.meta.ptype],
+                paymentId: permit.meta.paymentId,
                 nonce: BigInt(permit.meta.nonce),
                 validAfter: BigInt(permit.meta.validAfter),
                 validBefore: BigInt(permit.meta.validBefore),
@@ -39570,29 +39595,14 @@ class ExactPermitTronClientMechanism {
                 feeAmount: BigInt(permit.fee.feeAmount),
             },
         };
-        // Debug: log exact message being signed
-        console.log("[SIGN] Domain:", JSON.stringify(domain));
-        console.log("[SIGN] Message:", JSON.stringify(permitForSigning, (key, value) => {
-            if (value instanceof Uint8Array) {
-                return ("0x" +
-                    Array.from(value)
-                        .map((b) => b.toString(16).padStart(2, "0"))
-                        .join(""));
-            }
-            if (typeof value === "bigint") {
-                return value.toString();
-            }
-            return value;
-        }));
-        const signature = await this.signer.signTypedData(domain, PAYMENT_PERMIT_TYPES, permitForSigning);
-        console.log("[SIGN] Signature:", signature);
+        const signature = await this.signer.signTypedData(domain, PERMIT402_TYPES, permitForSigning);
         return {
             x402Version: 2,
             resource: { url: resource },
             accepted: requirements,
             payload: {
                 signature,
-                paymentPermit: permit,
+                permit402: permit,
             },
             extensions: {},
         };
@@ -39601,11 +39611,11 @@ class ExactPermitTronClientMechanism {
 //# sourceMappingURL=exact.js.map
 ;// CONCATENATED MODULE: ./node_modules/@springmint/x402/dist/mechanisms/exactEvm.js
 /**
- * ExactPermitEvmClientMechanism - EVM client mechanism for "payment_permit" payment scheme
+ * ExactPermitEvmClientMechanism - EVM client mechanism for "permit402" payment scheme
  */
 
 /**
- * EVM client mechanism for "payment_permit" payment scheme
+ * EVM client mechanism for "permit402" payment scheme
  */
 class ExactPermitEvmClientMechanism {
     signer;
@@ -39617,25 +39627,24 @@ class ExactPermitEvmClientMechanism {
         return this.signer;
     }
     scheme() {
-        return "payment_permit";
+        return setting_SCHEMES.permit402;
     }
     async createPaymentPayload(requirements, resource, extensions) {
-        const context = extensions?.paymentPermitContext;
+        const context = extensions?.permit402Context;
         if (!context) {
-            throw new PermitValidationError("missing_context", "paymentPermitContext is required");
+            throw new PermitValidationError("missing_context", "permit402Context is required");
         }
         const buyerAddress = this.signer.getAddress();
         const zeroAddress = EVM_ZERO_ADDRESS;
         const permit = {
             meta: {
-                kind: context.meta.kind,
+                ptype: context.meta.ptype,
                 paymentId: context.meta.paymentId,
                 nonce: context.meta.nonce,
                 validAfter: context.meta.validAfter,
                 validBefore: context.meta.validBefore,
             },
             buyer: buyerAddress,
-            caller: requirements.extra?.fee?.caller || zeroAddress,
             payment: {
                 payToken: requirements.asset,
                 payAmount: requirements.amount,
@@ -39649,22 +39658,22 @@ class ExactPermitEvmClientMechanism {
         // Ensure allowance
         const totalAmount = BigInt(permit.payment.payAmount) + BigInt(permit.fee.feeAmount);
         await this.signer.ensureAllowance(permit.payment.payToken, totalAmount, requirements.network);
-        // Build EIP-712 domain - must match contract EIP712.sol (name: "Permit402")
-        const permitAddress = getPaymentPermitAddress(requirements.network);
+        // Build EIP-712 domain
+        const permitAddress = getPermit402Address(requirements.network);
         const domain = {
             name: "Permit402",
             chainId: getChainId(requirements.network),
             verifyingContract: this.addressConverter.toEvmFormat(permitAddress),
         };
         // Convert permit to EIP-712 format matching Permit402Details (meta, buyer, payment, fee - no caller)
-        const ptype = KIND_MAP[permit.meta.kind] ?? 0;
-        const paymentIdBytes = permit.meta.paymentId.startsWith("0x")
-            ? permit.meta.paymentId
-            : `0x${permit.meta.paymentId}`;
+        // const ptype = KIND_MAP[permit.meta.kind] ?? 0;
+        // const paymentIdBytes = permit.meta.paymentId.startsWith("0x")
+        //   ? permit.meta.paymentId
+        //   : `0x${permit.meta.paymentId}`;
         const permitForSigning = {
             meta: {
-                ptype,
-                paymentId: paymentIdBytes,
+                ptype: PTYPE_MAP[permit.meta.ptype],
+                paymentId: permit.meta.paymentId,
                 nonce: BigInt(permit.meta.nonce),
                 validAfter: BigInt(permit.meta.validAfter),
                 validBefore: BigInt(permit.meta.validBefore),
@@ -39680,14 +39689,14 @@ class ExactPermitEvmClientMechanism {
                 feeAmount: BigInt(permit.fee.feeAmount),
             },
         };
-        const signature = await this.signer.signTypedData(domain, PAYMENT_PERMIT_TYPES, permitForSigning);
+        const signature = await this.signer.signTypedData(domain, PERMIT402_TYPES, permitForSigning);
         return {
             x402Version: 2,
             resource: { url: resource },
             accepted: requirements,
             payload: {
                 signature,
-                paymentPermit: permit,
+                permit402: permit,
             },
             extensions: {},
         };
@@ -39699,15 +39708,13 @@ class ExactPermitEvmClientMechanism {
  * Shared types and helpers for transfer_auth mechanism.
  *
  * transfer_auth uses ERC-3009 TransferWithAuthorization for direct token transfers
- * without going through a PaymentPermit contract.
+ * without going through a Permit402 contract.
  */
-/** Scheme name */
-const SCHEME_EXACT = "transfer_auth";
 /** Default validity period (1 hour) */
 const DEFAULT_VALIDITY_SECONDS = 3600;
 /**
  * EIP-712 type definitions for TransferWithAuthorization
- * Note: domain includes "version" field (unlike PaymentPermit)
+ * Note: domain includes "version" field (unlike Permit402)
  */
 const TRANSFER_AUTH_EIP712_TYPES = {
     TransferWithAuthorization: [
@@ -39787,7 +39794,7 @@ class ExactTronClientMechanism {
         return this.signer;
     }
     scheme() {
-        return SCHEME_EXACT;
+        return setting_SCHEMES.erc3009;
     }
     async createPaymentPayload(requirements, resource) {
         const converter = this.addressConverter;
@@ -39817,7 +39824,7 @@ class ExactTronClientMechanism {
             accepted: requirements,
             payload: {
                 signature,
-                paymentPermit: undefined,
+                permit402: undefined,
             },
             extensions: {
                 transferAuthorization: authorization,
@@ -39849,7 +39856,7 @@ class ExactEvmClientMechanism {
         return this.signer;
     }
     scheme() {
-        return SCHEME_EXACT;
+        return setting_SCHEMES.erc3009;
     }
     async createPaymentPayload(requirements, resource) {
         const converter = this.addressConverter;
@@ -39879,7 +39886,7 @@ class ExactEvmClientMechanism {
             accepted: requirements,
             payload: {
                 signature,
-                paymentPermit: undefined,
+                permit402: undefined,
             },
             extensions: {
                 transferAuthorization: authorization,
@@ -39892,7 +39899,7 @@ class ExactEvmClientMechanism {
 /**
  * x402 Client Mechanisms
  */
-// payment_permit scheme
+// permit402 scheme
 
 
 // exact scheme
@@ -75010,37 +75017,73 @@ class TronClientSigner {
     privateKey;
     address; // Base58 format
     tronWebInstances = new Map();
-    constructor(privateKey) {
+    rpcUrl;
+    rpcUrls;
+    rpcByNetwork;
+    constructor(privateKey, options) {
         const cleanKey = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
         this.privateKey = cleanKey;
+        this.rpcUrl = options?.rpcUrl;
+        this.rpcUrls = options?.rpcUrls;
+        this.rpcByNetwork = options?.rpcByNetwork;
         // Derive address using a temporary TronWeb instance (pure crypto, no network needed)
-        const tw = this.createTronWeb("https://nile.trongrid.io");
+        const tw = this.getDefaultTronWeb();
         this.address = tw.address.fromPrivateKey(cleanKey);
     }
     /**
      * Get or create a TronWeb instance for the given network.
      */
     getTronWeb(network) {
-        const host = network ? TRON_RPC_URLS[network] : undefined;
-        const key = host ?? "__default__";
-        let tw = this.tronWebInstances.get(key);
-        if (!tw) {
-            if (!host) {
-                throw new errors_UnsupportedNetworkError(`No RPC URL configured for network: ${network}`);
-            }
-            tw = this.createTronWeb(host);
-            this.tronWebInstances.set(key, tw);
+        const host = this.getRpcCandidates(network)[0];
+        if (!host) {
+            throw new errors_UnsupportedNetworkError(`No RPC URL configured for network: ${network}`);
         }
-        return tw;
+        return this.getOrCreateTronWeb(host);
     }
     getDefaultTronWeb() {
-        let tw = this.tronWebInstances.get("__default__");
+        const host = this.getRpcCandidates("tron:nile")[0] ?? "https://nile.trongrid.io";
+        return this.getOrCreateTronWeb(host);
+    }
+    getOrCreateTronWeb(host) {
+        let tw = this.tronWebInstances.get(host);
         if (!tw) {
-            tw = this.createTronWeb("https://nile.trongrid.io");
-            this.tronWebInstances.set("__default__", tw);
+            tw = this.createTronWeb(host);
+            this.tronWebInstances.set(host, tw);
         }
         return tw;
     }
+    getRpcCandidates(network) {
+        if (!network) {
+            const global = this.rpcUrls?.length ? this.rpcUrls : this.rpcUrl ? [this.rpcUrl] : [];
+            const deduped = global.filter((url, index) => global.indexOf(url) === index);
+            return deduped.length > 0 ? deduped : ["https://nile.trongrid.io"];
+        }
+        const perNetwork = this.rpcByNetwork?.[network];
+        const perNetworkList = Array.isArray(perNetwork) ? perNetwork : perNetwork ? [perNetwork] : [];
+        const globalList = this.rpcUrls?.length ? this.rpcUrls : this.rpcUrl ? [this.rpcUrl] : [];
+        const overrides = {
+            ...(this.rpcByNetwork ?? {}),
+            [network]: [...perNetworkList, ...globalList],
+        };
+        return resolveRpcUrls(network, overrides);
+    }
+    async executeWithRpcFallback(network, action) {
+        const candidates = this.getRpcCandidates(network);
+        if (candidates.length === 0) {
+            throw new errors_UnsupportedNetworkError(`No RPC URL configured for network: ${network}`);
+        }
+        let lastError;
+        for (const host of candidates) {
+            const tw = this.getOrCreateTronWeb(host);
+            try {
+                return await action(tw);
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw new Error(`All RPC endpoints failed for ${network}: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+    }
     createTronWeb(fullHost) {
         const apiKey = typeof process !== "undefined" ? process.env?.TRON_GRID_API_KEY : undefined;
         const headers = apiKey ? { "TRON-PRO-API-KEY": apiKey } : undefined;
@@ -75080,25 +75123,20 @@ class TronClientSigner {
         return signFn.call(tw.trx, typedDomain, types, message, this.privateKey);
     }
     async checkBalance(token, network) {
-        try {
-            const ownerHex = toEvmHex(this.address);
-            const tw = this.getTronWeb(network);
+        const ownerHex = toEvmHex(this.address);
+        return this.executeWithRpcFallback(network, async (tw) => {
             const result = await tw.transactionBuilder.triggerConstantContract(token, "balanceOf(address)", {}, [{ type: "address", value: ownerHex }], this.address);
             if (result.result?.result && result.constant_result?.length) {
                 return BigInt("0x" + result.constant_result[0]);
             }
-        }
-        catch (error) {
-            console.error(`[TronClientSigner] Failed to check balance: ${error}`);
-        }
-        return BigInt(0);
+            throw new Error(`checkBalance failed for ${token} on ${network}: no result from RPC`);
+        });
     }
     async checkAllowance(token, _amount, network) {
-        const spender = getPaymentPermitAddress(network);
-        try {
-            const ownerHex = toEvmHex(this.address);
-            const spenderHex = toEvmHex(spender);
-            const tw = this.getTronWeb(network);
+        const spender = getPermit402Address(network);
+        const ownerHex = toEvmHex(this.address);
+        const spenderHex = toEvmHex(spender);
+        return this.executeWithRpcFallback(network, async (tw) => {
             const result = await tw.transactionBuilder.triggerConstantContract(token, ERC20_ALLOWANCE_SELECTOR, {}, [
                 { type: "address", value: ownerHex },
                 { type: "address", value: spenderHex },
@@ -75106,11 +75144,8 @@ class TronClientSigner {
             if (result.result?.result && result.constant_result?.length) {
                 return BigInt("0x" + result.constant_result[0]);
             }
-        }
-        catch (error) {
-            console.error(`[TronClientSigner] Failed to check allowance: ${error}`);
-        }
-        return BigInt(0);
+            throw new Error(`checkAllowance failed for ${token} on ${network}: no result from RPC`);
+        });
     }
     async ensureAllowance(token, amount, network, mode = "auto") {
         if (mode === "skip") {
@@ -75118,57 +75153,58 @@ class TronClientSigner {
         }
         const currentAllowance = await this.checkAllowance(token, amount, network);
         if (currentAllowance >= amount) {
-            console.log(`[ALLOWANCE] Sufficient allowance: ${currentAllowance} >= ${amount}`);
             return true;
         }
         if (mode === "interactive") {
             throw new InsufficientAllowanceError("Interactive approval not implemented - use wallet UI");
         }
         // Auto mode: send approve transaction
-        console.log(`[ALLOWANCE] Insufficient allowance: ${currentAllowance} < ${amount}, sending approve...`);
-        const spender = getPaymentPermitAddress(network);
+        const spender = getPermit402Address(network);
         const spenderHex = toEvmHex(spender);
         // Use maxUint160 (2^160 - 1) to avoid repeated approvals
         const maxUint160 = BigInt(2) ** BigInt(160) - BigInt(1);
         try {
-            // Build approve transaction
-            const tw = this.getTronWeb(network);
-            const tx = await tw.transactionBuilder.triggerSmartContract(token, ERC20_APPROVE_SELECTOR, {
-                feeLimit: 100_000_000,
-                callValue: 0,
-            }, [
-                { type: "address", value: spenderHex },
-                { type: "uint256", value: maxUint160.toString() },
-            ], this.address);
-            if (!tx.result?.result) {
-                throw new InsufficientAllowanceError("Failed to build approve transaction");
-            }
-            // Sign transaction
-            const signedTx = await tw.trx.sign(tx.transaction, this.privateKey);
-            // Broadcast transaction
-            const broadcast = await tw.trx.sendRawTransaction(signedTx);
-            if (!broadcast.result) {
-                throw new InsufficientAllowanceError(`Failed to broadcast approve transaction: ${JSON.stringify(broadcast)}`);
-            }
-            console.log(`[ALLOWANCE] Approve transaction sent: ${broadcast.txid}`);
-            // Wait for confirmation (poll for ~30 seconds)
-            const txid = broadcast.txid;
-            for (let i = 0; i < 10; i++) {
-                await new Promise((resolve) => setTimeout(resolve, 3000));
-                try {
-                    const info = await tw.trx.getTransactionInfo(txid);
-                    if (info && info.blockNumber) {
-                        const success = info.receipt?.result === "SUCCESS";
-                        console.log(`[ALLOWANCE] Approve confirmed: ${success ? "SUCCESS" : "FAILED"}`);
-                        return success;
-                    }
+            return await this.executeWithRpcFallback(network, async (tw) => {
+                // Build approve transaction
+                const tx = await tw.transactionBuilder.triggerSmartContract(token, ERC20_APPROVE_SELECTOR, {
+                    feeLimit: 100_000_000,
+                    callValue: 0,
+                }, [
+                    { type: "address", value: spenderHex },
+                    { type: "uint256", value: maxUint160.toString() },
+                ], this.address);
+                if (!tx.result?.result) {
+                    throw new InsufficientAllowanceError("Failed to build approve transaction");
                 }
-                catch {
-                    // Not confirmed yet, continue polling
+                // Sign transaction
+                const signedTx = await tw.trx.sign(tx.transaction, this.privateKey);
+                // Broadcast transaction
+                const broadcast = await tw.trx.sendRawTransaction(signedTx);
+                if (!broadcast.result) {
+                    throw new InsufficientAllowanceError(`Failed to broadcast approve transaction: ${JSON.stringify(broadcast)}`);
                 }
-            }
-            console.log("[ALLOWANCE] Approve transaction not confirmed within timeout, assuming success");
-            return true;
+                // Wait for confirmation (poll for ~30 seconds)
+                const txid = broadcast.txid;
+                for (let i = 0; i < 10; i++) {
+                    await new Promise((resolve) => setTimeout(resolve, 3000));
+                    try {
+                        const info = await tw.trx.getTransactionInfo(txid);
+                        if (info && info.blockNumber) {
+                            if (info.receipt?.result === "SUCCESS") {
+                                return true;
+                            }
+                            throw new InsufficientAllowanceError(`Approve transaction failed on-chain for tx ${txid}: ${info.receipt?.result ?? "UNKNOWN"}`);
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof InsufficientAllowanceError) {
+                            throw error;
+                        }
+                        // Not confirmed yet, continue polling
+                    }
+                }
+                throw new InsufficientAllowanceError(`Approve transaction not confirmed within timeout: ${txid}`);
+            });
         }
         catch (error) {
             if (error instanceof InsufficientAllowanceError)
@@ -90471,6 +90507,167 @@ function createPublicClient(parameters) {
     return client.extend(publicActions);
 }
 //# sourceMappingURL=createPublicClient.js.map
+;// CONCATENATED MODULE: ./node_modules/viem/_esm/clients/transports/fallback.js
+
+
+
+
+function fallback(transports_, config = {}) {
+    const { key = 'fallback', name = 'Fallback', rank = false, shouldThrow: shouldThrow_ = shouldThrow, retryCount, retryDelay, } = config;
+    return (({ chain, pollingInterval = 4_000, timeout, ...rest }) => {
+        let transports = transports_;
+        let onResponse = () => { };
+        const transport = createTransport({
+            key,
+            name,
+            async request({ method, params }) {
+                let includes;
+                const fetch = async (i = 0) => {
+                    const transport = transports[i]({
+                        ...rest,
+                        chain,
+                        retryCount: 0,
+                        timeout,
+                    });
+                    try {
+                        const response = await transport.request({
+                            method,
+                            params,
+                        });
+                        onResponse({
+                            method,
+                            params: params,
+                            response,
+                            transport,
+                            status: 'success',
+                        });
+                        return response;
+                    }
+                    catch (err) {
+                        onResponse({
+                            error: err,
+                            method,
+                            params: params,
+                            transport,
+                            status: 'error',
+                        });
+                        if (shouldThrow_(err))
+                            throw err;
+                        // If we've reached the end of the fallbacks, throw the error.
+                        if (i === transports.length - 1)
+                            throw err;
+                        // Check if at least one other transport includes the method
+                        includes ??= transports.slice(i + 1).some((transport) => {
+                            const { include, exclude } = transport({ chain }).config.methods || {};
+                            if (include)
+                                return include.includes(method);
+                            if (exclude)
+                                return !exclude.includes(method);
+                            return true;
+                        });
+                        if (!includes)
+                            throw err;
+                        // Otherwise, try the next fallback.
+                        return fetch(i + 1);
+                    }
+                };
+                return fetch();
+            },
+            retryCount,
+            retryDelay,
+            type: 'fallback',
+        }, {
+            onResponse: (fn) => (onResponse = fn),
+            transports: transports.map((fn) => fn({ chain, retryCount: 0 })),
+        });
+        if (rank) {
+            const rankOptions = (typeof rank === 'object' ? rank : {});
+            rankTransports({
+                chain,
+                interval: rankOptions.interval ?? pollingInterval,
+                onTransports: (transports_) => (transports = transports_),
+                ping: rankOptions.ping,
+                sampleCount: rankOptions.sampleCount,
+                timeout: rankOptions.timeout,
+                transports,
+                weights: rankOptions.weights,
+            });
+        }
+        return transport;
+    });
+}
+function shouldThrow(error) {
+    if ('code' in error && typeof error.code === 'number') {
+        if (error.code === TransactionRejectedRpcError.code ||
+            error.code === UserRejectedRequestError.code ||
+            error.code === WalletConnectSessionSettlementError.code ||
+            errors_node/* ExecutionRevertedError */.A7.nodeMessage.test(error.message) ||
+            error.code === 5000 // CAIP UserRejectedRequestError
+        )
+            return true;
+    }
+    return false;
+}
+/** @internal */
+function rankTransports({ chain, interval = 4_000, onTransports, ping, sampleCount = 10, timeout = 1_000, transports, weights = {}, }) {
+    const { stability: stabilityWeight = 0.7, latency: latencyWeight = 0.3 } = weights;
+    const samples = [];
+    const rankTransports_ = async () => {
+        // 1. Take a sample from each Transport.
+        const sample = await Promise.all(transports.map(async (transport) => {
+            const transport_ = transport({ chain, retryCount: 0, timeout });
+            const start = Date.now();
+            let end;
+            let success;
+            try {
+                await (ping
+                    ? ping({ transport: transport_ })
+                    : transport_.request({ method: 'net_listening' }));
+                success = 1;
+            }
+            catch {
+                success = 0;
+            }
+            finally {
+                end = Date.now();
+            }
+            const latency = end - start;
+            return { latency, success };
+        }));
+        // 2. Store the sample. If we have more than `sampleCount` samples, remove
+        // the oldest sample.
+        samples.push(sample);
+        if (samples.length > sampleCount)
+            samples.shift();
+        // 3. Calculate the max latency from samples.
+        const maxLatency = Math.max(...samples.map((sample) => Math.max(...sample.map(({ latency }) => latency))));
+        // 4. Calculate the score for each Transport.
+        const scores = transports
+            .map((_, i) => {
+            const latencies = samples.map((sample) => sample[i].latency);
+            const meanLatency = latencies.reduce((acc, latency) => acc + latency, 0) /
+                latencies.length;
+            const latencyScore = 1 - meanLatency / maxLatency;
+            const successes = samples.map((sample) => sample[i].success);
+            const stabilityScore = successes.reduce((acc, success) => acc + success, 0) /
+                successes.length;
+            if (stabilityScore === 0)
+                return [0, i];
+            return [
+                latencyWeight * latencyScore + stabilityWeight * stabilityScore,
+                i,
+            ];
+        })
+            .sort((a, b) => b[0] - a[0]);
+        // 5. Sort the Transports by score.
+        onTransports(scores.map(([, i]) => transports[i]));
+        // 6. Wait, and then rank again.
+        await wait(interval);
+        rankTransports_();
+    };
+    rankTransports_();
+}
+//# sourceMappingURL=fallback.js.map
 ;// CONCATENATED MODULE: ./node_modules/viem/_esm/accounts/toAccount.js
 // TODO(v3): Rename to `toLocalAccount` + add `source` property to define source (privateKey, mnemonic, hdKey, etc).
 
@@ -91189,9 +91386,15 @@ class EvmClientSigner {
     walletClient;
     publicClients = new Map();
     account;
-    constructor(privateKey) {
+    rpcUrl;
+    rpcUrls;
+    rpcByNetwork;
+    constructor(privateKey, options) {
         const hexKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
         this.account = privateKeyToAccount(hexKey);
+        this.rpcUrl = options?.rpcUrl;
+        this.rpcUrls = options?.rpcUrls;
+        this.rpcByNetwork = options?.rpcByNetwork;
         this.walletClient = createWalletClient({
             account: this.account,
             chain: mainnet,
@@ -91210,7 +91413,6 @@ class EvmClientSigner {
         });
     }
     async signTypedData(domain, types, message) {
-        // TODO: Add explicit primaryType to ClientSigner interface
         const primaryType = types.Permit402Details ? "Permit402Details" : Object.keys(types).pop();
         if (!primaryType) {
             throw new Error("No primary type found in types definition");
@@ -91225,35 +91427,23 @@ class EvmClientSigner {
     async checkBalance(token, network) {
         const chainId = this.parseNetworkToChainId(network);
         const client = this.getPublicClient(chainId, network);
-        try {
-            return await client.readContract({
-                address: token,
-                abi: evmSigner_ERC20_ABI,
-                functionName: "balanceOf",
-                args: [this.account.address],
-            });
-        }
-        catch (error) {
-            console.error(`[EvmClientSigner] checkBalance failed for ${token} on ${network}:`, error);
-            return 0n;
-        }
+        return await client.readContract({
+            address: token,
+            abi: evmSigner_ERC20_ABI,
+            functionName: "balanceOf",
+            args: [this.account.address],
+        });
     }
     async checkAllowance(token, _amount, network) {
         const chainId = this.parseNetworkToChainId(network);
         const client = this.getPublicClient(chainId, network);
-        const spender = getPaymentPermitAddress(network);
-        try {
-            return await client.readContract({
-                address: token,
-                abi: evmSigner_ERC20_ABI,
-                functionName: "allowance",
-                args: [this.account.address, spender],
-            });
-        }
-        catch (error) {
-            console.error(`[EvmClientSigner] checkAllowance failed for ${token} on ${network}:`, error);
-            return 0n;
-        }
+        const spender = getPermit402Address(network);
+        return await client.readContract({
+            address: token,
+            abi: evmSigner_ERC20_ABI,
+            functionName: "allowance",
+            args: [this.account.address, spender],
+        });
     }
     async ensureAllowance(token, amount, network, mode = "auto") {
         if (mode === "skip")
@@ -91266,14 +91456,14 @@ class EvmClientSigner {
         }
         const chainId = this.parseNetworkToChainId(network);
         const client = this.getPublicClient(chainId, network);
-        const spender = getPaymentPermitAddress(network);
+        const spender = getPermit402Address(network);
         const chain = this.getChain(chainId);
         try {
-            const rpcUrl = resolveRpcUrl(network);
+            const transport = this.createTransport(network);
             const walletClient = createWalletClient({
                 account: this.account,
                 chain: chain,
-                transport: http_http(rpcUrl),
+                transport,
             });
             const hash = await walletClient.writeContract({
                 address: token,
@@ -91282,29 +91472,44 @@ class EvmClientSigner {
                 args: [spender, BigInt(2) ** BigInt(256) - BigInt(1)],
             });
             const receipt = await client.waitForTransactionReceipt({ hash });
-            const success = receipt.status === "success";
-            if (success) {
-                console.info(`[EvmClientSigner] ERC20 approval confirmed for ${token}, tx: ${hash}`);
-            }
-            return success;
+            return receipt.status === "success";
         }
         catch (error) {
-            console.error(`[EvmClientSigner] ERC20 approval failed for ${token}:`, error);
             throw new InsufficientAllowanceError(`ERC20 approval transaction failed for ${token}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     getPublicClient(chainId, network) {
         let client = this.publicClients.get(chainId);
         if (!client) {
-            const rpcUrl = resolveRpcUrl(network);
+            const transport = this.createTransport(network);
             client = createPublicClient({
                 chain: this.getChain(chainId),
-                transport: http_http(rpcUrl),
+                transport,
             });
             this.publicClients.set(chainId, client);
         }
         return client;
     }
+    createTransport(network) {
+        const candidates = this.getRpcCandidates(network);
+        if (candidates.length === 0) {
+            throw new errors_UnsupportedNetworkError(`No RPC URL configured for network: ${network}`);
+        }
+        if (candidates.length === 1) {
+            return http_http(candidates[0]);
+        }
+        return fallback(candidates.map((url) => http_http(url)), { rank: false, retryCount: 1 });
+    }
+    getRpcCandidates(network) {
+        const perNetwork = this.rpcByNetwork?.[network];
+        const perNetworkList = Array.isArray(perNetwork) ? perNetwork : perNetwork ? [perNetwork] : [];
+        const globalList = this.rpcUrls?.length ? this.rpcUrls : this.rpcUrl ? [this.rpcUrl] : [];
+        const overrides = {
+            ...(this.rpcByNetwork ?? {}),
+            [network]: [...perNetworkList, ...globalList],
+        };
+        return resolveRpcUrls(network, overrides);
+    }
     getChain(chainId) {
         const chains = {
             1: mainnet,
@@ -91345,6 +91550,7 @@ class EvmClientSigner {
 
 
 
+
 // HTTP Client
 
 // Server helpers