@piprail/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4578 @@
+import * as viem_zksync from 'viem/zksync';
+import * as abitype from 'abitype';
+import * as viem_chains from 'viem/chains';
+import * as viem from 'viem';
+import { Chain, Account, Hex } from 'viem';
+
+/**
+ * The on-the-wire payment protocol. Self-contained — it runs entirely
+ * between the agent and your server, with nothing hosted in between.
+ *
+ * Lowercase headers, no `X-` prefix:
+ *   - payment-required   (server → client, base64 JSON challenge)
+ *   - payment-signature  (client → server, base64 JSON proof)
+ *   - payment-response   (server → client, base64 JSON receipt on 200)
+ *
+ * Scheme is `onchain-proof`: the agent pays on-chain and hands back a proof
+ * reference (an EVM tx hash, a Solana signature, …); the server verifies
+ * that transaction itself, locally, against its own RPC. No third party.
+ *
+ * This file is CHAIN-AGNOSTIC. Identifiers are plain strings in CAIP-2 /
+ * base-unit form so any family (EVM, Solana, …) round-trips through the same
+ * envelopes. Each PaymentDriver interprets them for its own chain.
+ *
+ * Wire format targets x402 v2 — github.com/coinbase/x402, specs/x402-specification-v2.md
+ * (v2.0, 2025-12-9) + specs/transports-v2/http.md. The ENVELOPE is v2-conformant
+ * (PaymentPayload carries `accepted`; SettlementResponse has `success` + `transaction`).
+ * The SETTLEMENT SCHEME is our own `onchain-proof` (client pays on-chain first, proves
+ * with a tx ref, server verifies locally) — permitted by spec §6 (a scheme owns its
+ * `payload`) + §7 (self-hosted verification), but it does NOT interoperate with the
+ * built-in `exact` scheme (which is signature + facilitator-broadcast). Deliberate.
+ */
+/** A CAIP-2 network id, e.g. `eip155:8453` or `solana:5eykt4Us…`. */
+type Caip2 = `${string}:${string}`;
+/** An asset id — chain-specific: an EVM `0x…` address, a Solana base58 mint, a
+ * TON jetton master, a Stellar `CODE:ISSUER`, or `'native'`. */
+type AssetId = string;
+/** An account id — chain-specific: an EVM `0x…` address, a Solana base58 pubkey,
+ * a TON address, or a Stellar `G…` account. */
+type AddressId = string;
+interface X402ResourceObject {
+    url: string;
+    description?: string;
+}
+interface X402AcceptEntry {
+    scheme: 'onchain-proof';
+    network: Caip2;
+    /** Amount in the token's base units (already scaled by decimals). */
+    amount: string;
+    /** ERC-20 address / SPL mint, or 'native' for the chain's native coin. */
+    asset: AssetId;
+    payTo: AddressId;
+    /** Payment is only accepted if mined within this many seconds of now. */
+    maxTimeoutSeconds: number;
+    extra: {
+        /** Single-use id echoed back in the proof. */
+        nonce: string;
+        /** Token decimals, so the client can render the amount. */
+        decimals: number;
+        /** Confirmations the client should wait before retrying. */
+        minConfirmations: number;
+        /** Human-readable amount, e.g. "0.05". */
+        amountFormatted: string;
+        symbol?: string;
+    };
+}
+interface X402Challenge {
+    x402Version: 2;
+    error: string | null;
+    resource: X402ResourceObject;
+    accepts: X402AcceptEntry[];
+}
+interface X402PaymentSignature {
+    x402Version: 2;
+    /**
+     * x402 v2 PaymentPayload: the full PaymentRequirements entry the client chose
+     * (carries `scheme` + `network`), echoed back from the challenge's `accepts[]`.
+     */
+    accepted: X402AcceptEntry;
+    /**
+     * Scheme-defined payload. For `onchain-proof`: the challenge nonce + the proof
+     * ref (`txHash` — a chain-specific id: an EVM tx hash, a Solana signature, a
+     * TON locator, or a Stellar tx hash).
+     */
+    payload: {
+        nonce: string;
+        txHash: string;
+    };
+}
+interface X402Receipt {
+    scheme: 'onchain-proof';
+    /**
+     * x402 v2 SettlementResponse: settlement succeeded. Always `true` here — a
+     * failed verification returns a 402, never a receipt.
+     */
+    success: true;
+    network: Caip2;
+    /**
+     * x402 v2 SettlementResponse: the on-chain transaction id of the SETTLED
+     * payment — a chain-specific id (an EVM/Tron/Stellar/XRPL/NEAR tx hash, a
+     * Solana signature, or a Sui digest). This is the verified tx itself, NOT the
+     * submit-time proof ref in `payload.txHash` (which can be a composite locator
+     * on TON/NEAR). (Was `txHash` before v2 envelope conformance.)
+     */
+    transaction: string;
+    asset: AssetId;
+    amount: string;
+    payer: AddressId;
+    payTo: AddressId;
+    verifiedAt: string;
+}
+/**
+ * Why a verification failed — a closed, chain-agnostic vocabulary. Every code a
+ * driver returns is in this union; a client/agent branches on it rather than
+ * parsing prose. Surfaced to the agent in the 402 body's `error` field with a
+ * human-readable `detail`. Some codes are family-specific (annotated below):
+ * e.g. account-watch chains (TON, Stellar) can't distinguish "wrong recipient"
+ * from "no payment", so both collapse to `transfer_not_found`.
+ *
+ * `transient` = the proof may simply not have propagated to the server's RPC
+ * node yet; `definitive` = retrying won't change it. These labels are
+ * informational for consumers — the built-in client retries EVERY code up to
+ * `maxPaymentRetries` (a short backoff absorbs RPC lag); it does not branch on
+ * the code.
+ */
+type VerifyErrorCode = 'tx_not_found' | 'insufficient_confirmations' | 'tx_reverted' | 'no_meta' | 'wrong_recipient' | 'amount_too_low' | 'transfer_not_found' | 'payment_expired' | 'tx_already_used';
+/** The shape every driver's `verify()` returns. Shared by drivers + protocol. */
+type VerifyResult = {
+    ok: true;
+    receipt: X402Receipt;
+} | {
+    ok: false;
+    error: VerifyErrorCode;
+    detail: string;
+};
+declare function buildChallengeHeader(challenge: X402Challenge): string;
+declare function buildReceiptHeader(receipt: X402Receipt): string;
+declare function buildSignatureHeader(signature: X402PaymentSignature): string;
+/**
+ * Parse the PAYMENT-REQUIRED challenge from a 402 response. Prefers the
+ * `payment-required` header, falls back to the JSON body.
+ */
+declare function parseChallenge(response: Response): Promise<X402Challenge | null>;
+/** Parse the PAYMENT-RESPONSE receipt header on a 200 settlement. */
+declare function parseReceipt(response: Response): X402Receipt | null;
+/** Parse a PAYMENT-SIGNATURE header value (server side). */
+declare function parseSignatureHeader(value: string): X402PaymentSignature | null;
+/**
+ * Pick the first accepts[] entry on the `onchain-proof` scheme whose network
+ * satisfies `matches` (any chain family). Returns null if none match.
+ */
+declare function pickAccept(challenge: X402Challenge, matches: (network: string) => boolean): X402AcceptEntry | null;
+
+/**
+ * ── EVM SECTION: chains ──
+ * Chains are a parameter, and the popular ones are built in.
+ *
+ * The easy path — name a built-in chain:
+ *   requirePayment({ chain: 'base', amount: '0.05', payTo })   // USDC on Base
+ *
+ * The exotic path — ANY EVM chain we don't ship, by viem `Chain` or a bare
+ * `{ id, rpcUrl }`, plus the token you want paid in:
+ *   requirePayment({ chain: someViemChain, token: { address, decimals }, … })
+ *   requirePayment({ chain: { id: 1313161554, rpcUrl: 'https://mainnet.aurora.dev' },
+ *                    token: { address: '0x…', decimals: 6 }, … })
+ *
+ * If viem can reach the RPC, PipRail works on it — there is no allowlist.
+ */
+interface TokenInfo {
+    address: `0x${string}`;
+    decimals: number;
+    symbol: string;
+}
+interface ChainPreset {
+    /** The underlying viem chain (id, name, native coin, default RPCs). */
+    chain: Chain;
+    /**
+     * Override the default RPC used when the caller passes no `rpcUrl`. Set only
+     * where viem's bundled default is unreliable. Public RPCs are rate-limited —
+     * production callers should always pass their own `rpcUrl`.
+     */
+    defaultRpc?: string;
+    /** Well-known tokens on this chain, keyed by UPPERCASE symbol. */
+    tokens: Record<string, TokenInfo>;
+}
+/**
+ * Built-in EVM mainnets, each with canonical USDC (decimals included)
+ * pre-filled so a developer never pastes a token address. Add a chain = one
+ * entry here.
+ */
+declare const CHAINS: {
+    ethereum: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            blockTime: 12000;
+            contracts: {
+                readonly ensUniversalResolver: {
+                    readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                    readonly blockCreated: 23085558;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://eth.merkle.io"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        defaultRpc: string;
+        tokens: {
+            USDC: {
+                address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    base: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Basescan";
+                    readonly url: "https://basescan.org";
+                    readonly apiUrl: "https://api.basescan.org/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 5022;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 8453;
+            name: "Base";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.base.org"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: abitype.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: abitype.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: abitype.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    arbitrum: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Arbiscan";
+                    readonly url: "https://arbiscan.io";
+                    readonly apiUrl: "https://api.arbiscan.io/api";
+                };
+            };
+            blockTime: 250;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 7654707;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 42161;
+            name: "Arbitrum One";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    optimism: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Optimism Explorer";
+                    readonly url: "https://optimistic.etherscan.io";
+                    readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 4286263;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 10;
+            name: "OP Mainnet";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.optimism.io"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash? /** Display name. Defaults to `EVM <id>`. */: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: abitype.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: abitype.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: abitype.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    polygon: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "PolygonScan";
+                    readonly url: "https://polygonscan.com";
+                    readonly apiUrl: "https://api.etherscan.io/v2/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 25770160;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 137;
+            name: "Polygon";
+            nativeCurrency: {
+                readonly name: "POL";
+                readonly symbol: "POL";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://polygon.drpc.org"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    bnb: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "BscScan";
+                    readonly url: "https://bscscan.com";
+                    readonly apiUrl: "https://api.bscscan.com/api";
+                };
+            };
+            blockTime: 750;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 15921452;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 56;
+            name: "BNB Smart Chain";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "BNB";
+                readonly symbol: "BNB";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://56.rpc.thirdweb.com"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x55d398326f99059fF775485246999027B3197955";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    avalanche: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "SnowTrace";
+                    readonly url: "https://snowtrace.io";
+                    readonly apiUrl: "https://api.snowtrace.io";
+                };
+            };
+            blockTime: 1700;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 11907934;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 43114;
+            name: "Avalanche";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Avalanche";
+                readonly symbol: "AVAX";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    mantle: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Mantle Explorer";
+                    readonly url: "https://mantlescan.xyz/";
+                    readonly apiUrl: "https://api.mantlescan.xyz/api";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 304717;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 5000;
+            name: "Mantle";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "MNT";
+                readonly symbol: "MNT";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.mantle.xyz"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    sonic: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Sonic Explorer";
+                    readonly url: "https://sonicscan.org";
+                };
+            };
+            blockTime: 630;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 60;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 146;
+            name: "Sonic";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Sonic";
+                readonly symbol: "S";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.soniclabs.com"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x6047828dc181963ba44974801FF68e538dA5eaF9";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    linea: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://lineascan.build";
+                    readonly apiUrl: "https://api.lineascan.build/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 42;
+                };
+                readonly ensRegistry: {
+                    readonly address: "0x50130b669B28C339991d8676FA73CF122a121267";
+                    readonly blockCreated: 6682888;
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0x4D41762915F83c76EcaF6776d9b08076aA32b492";
+                    readonly blockCreated: 22222151;
+                };
+            };
+            ensTlds: readonly [".linea.eth"];
+            id: 59144;
+            name: "Linea Mainnet";
+            nativeCurrency: {
+                readonly name: "Linea Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.linea.build"];
+                    readonly webSocket: readonly ["wss://rpc.linea.build"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees: {
+                readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<viem.ChainEstimateFeesPerGasFn>[0]) => ReturnType<viem.ChainEstimateFeesPerGasFn>;
+                readonly maxPriorityFeePerGas: ({ block, client, request }: viem.ChainFeesFnParameters<viem.ChainFormatters | undefined>) => Promise<bigint | null>;
+            };
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0xA219439258ca9da29E9Cc4cE5596924745e12B93";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    scroll: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Scrollscan";
+                    readonly url: "https://scrollscan.com";
+                    readonly apiUrl: "https://api.scrollscan.com/api";
+                };
+            };
+            blockTime: 3000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 534352;
+            name: "Scroll";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.scroll.io"];
+                    readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x06eFdBFf2a14a7c8E15944D1F4A48F9F95F663A4";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0xf55BEC9cafDbE8730f096Aa55dad6D22d44099Df";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    celo: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Celo Explorer";
+                    readonly url: "https://celoscan.io";
+                    readonly apiUrl: "https://api.celoscan.io/api";
+                };
+            };
+            blockTime: 1000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 13112599;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 42220;
+            name: "Celo";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "CELO";
+                readonly symbol: "CELO";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://forno.celo.org"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees: viem.ChainFees<{
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.CeloTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloRpcTransaction, action?: string | undefined) => ({
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas
+                        /** Native coin metadata. Defaults to 18-decimal ETH. */
+                        ? /** Native coin metadata. Defaults to 18-decimal ETH. */: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        accessList: viem.AccessList;
+                        chainId: number;
+                        feeCurrency: abitype.Address | null;
+                        gatewayFee: bigint | null;
+                        gatewayFeeRecipient: abitype.Address | null;
+                        type: "cip42";
+                        blobVersionedHashes?: undefined;
+                        authorizationList?: undefined;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        accessList: viem.AccessList;
+                        chainId: number;
+                        feeCurrency: abitype.Address | null;
+                        type: "cip64";
+                        blobVersionedHashes?: undefined;
+                        authorizationList?: undefined;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                        blobVersionedHashes?: undefined;
+                        accessList?: undefined;
+                        authorizationList?: undefined;
+                        chainId?: undefined;
+                        feeCurrency?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionRequest: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloTransactionRequest, action?: string | undefined) => ({
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x0" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        accessList?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x1" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x2" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs?: readonly `0x${string}`[] | readonly viem.ByteArray[] | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        kzg?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs: readonly viem.Hex[] | readonly viem.ByteArray[];
+                        blobVersionedHashes?: readonly `0x${string}`[] | undefined;
+                        kzg?: viem.Kzg | undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x4" | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        authorizationList?: viem.RpcAuthorizationList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x7b" | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                    }) & {};
+                    type: "transactionRequest";
+                };
+            }>;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.CeloTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloRpcTransaction, action?: string | undefined) => ({
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        feeCurrency: abitype.Address | null;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        accessList: viem.AccessList;
+                        chainId: number;
+                        feeCurrency: abitype.Address | null;
+                        gatewayFee: bigint | null;
+                        gatewayFeeRecipient: abitype.Address | null;
+                        type: "cip42";
+                        blobVersionedHashes?: undefined;
+                        authorizationList?: undefined;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        accessList: viem.AccessList;
+                        chainId: number;
+                        feeCurrency: abitype.Address | null;
+                        type: "cip64";
+                        blobVersionedHashes?: undefined;
+                        authorizationList?: undefined;
+                        mint?: undefined;
+                        isSystemTx?: undefined;
+                        sourceHash?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                        blobVersionedHashes?: undefined;
+                        accessList?: undefined;
+                        authorizationList?: undefined;
+                        chainId?: undefined;
+                        feeCurrency?: undefined;
+                        gatewayFee?: undefined;
+                        gatewayFeeRecipient?: undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionRequest: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.CeloTransactionRequest, action?: string | undefined) => ({
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x0" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        accessList?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x1" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x2" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs?: readonly `0x${string}`[] | readonly viem.ByteArray[] | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        kzg?: undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs: readonly viem.Hex[] | readonly viem.ByteArray[];
+                        blobVersionedHashes?: readonly `0x${string}`[] | undefined;
+                        kzg?: viem.Kzg | undefined;
+                        authorizationList?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        type?: "0x4" | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        authorizationList?: viem.RpcAuthorizationList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x7b" | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        feeCurrency?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                    }) & {};
+                    type: "transactionRequest";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionCelo;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    zksync: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "ZKsync Explorer";
+                    readonly url: "https://explorer.zksync.io/";
+                    readonly apiUrl: "https://block-explorer-api.mainnet.zksync.io/api";
+                };
+            };
+            blockTime: 200;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+                    readonly blockCreated: 3908235;
+                };
+                readonly erc6492Verifier: {
+                    readonly address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C";
+                    readonly blockCreated: 45659388;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 324;
+            name: "ZKsync Era";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.era.zksync.io"];
+                    readonly webSocket: readonly ["wss://mainnet.era.zksync.io/ws"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom: {
+                readonly getEip712Domain: viem_zksync.EIP712DomainFn<viem_zksync.ZkSyncTransactionSerializable, viem_zksync.ZkSyncEIP712TransactionSignable>;
+            };
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_zksync.ZkSyncRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_zksync.ZkSyncTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTimestamp: bigint | null;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_zksync.ZkSyncRpcTransaction, action?: string | undefined) => ({
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        type: "priority";
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        type: "eip712" | "priority";
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_zksync.ZkSyncRpcTransactionReceipt, action?: string | undefined) => {
+                        type: viem_zksync.ZkSyncTransactionType;
+                        contractAddress: abitype.Address | null | undefined;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        transactionIndex: number;
+                        status: "success" | "reverted";
+                        transactionHash: viem.Hash;
+                        logsBloom: viem.Hex;
+                        blobGasUsed?: bigint | undefined;
+                        gasUsed: bigint;
+                        blobGasPrice?: bigint | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        root?: `0x${string}` | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        logs: viem_zksync.ZkSyncLog[];
+                        l2ToL1Logs: viem_zksync.ZkSyncL2ToL1Log[];
+                    } & {};
+                    type: "transactionReceipt";
+                };
+                readonly transactionRequest: {
+                    exclude: ("paymaster" | "gasPerPubdata" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+                    format: (args: viem_zksync.ZkSyncTransactionRequest, action?: string | undefined) => ({
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x0" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        accessList?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x1" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type?: "0x2" | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        authorizationList?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs?: readonly `0x${string}`[] | readonly viem.ByteArray[] | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        kzg?: undefined;
+                        authorizationList?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        type?: "0x3" | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: `0x${string}` | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                        blobs: readonly viem.Hex[] | readonly viem.ByteArray[];
+                        blobVersionedHashes?: readonly `0x${string}`[] | undefined;
+                        kzg?: viem.Kzg | undefined;
+                        authorizationList?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        type?: "0x4" | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: viem.AccessList | undefined;
+                        authorizationList?: viem.RpcAuthorizationList | undefined;
+                        blobs?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        eip712Meta?: undefined | undefined;
+                    } | {
+                        data?: `0x${string}` | undefined;
+                        from?: `0x${string}` | undefined;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: `0x${string}` | null | undefined;
+                        type: "0xff" | "0x71";
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        eip712Meta: viem_zksync.ZkSyncEip712Meta;
+                    }) & {
+                        paymaster: never;
+                        gasPerPubdata: never;
+                        factoryDeps: never;
+                        paymasterInput: never;
+                        customSignature: never;
+                    };
+                    type: "transactionRequest";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_zksync.serializeTransaction;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+            readonly network: "zksync-era";
+        };
+        tokens: {
+            USDC: {
+                address: "0x1d17CBcF0D6D143135aE902365D2E5e2A16538D4";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x493257fD37EDB34451f62EDf8D2a0C418852bA4C";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    unichain: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Uniscan";
+                    readonly url: "https://uniscan.xyz";
+                    readonly apiUrl: "https://api.uniscan.xyz/api";
+                };
+            };
+            blockTime: 1000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 0;
+                };
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
+                    };
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 130;
+            name: "Unichain";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.unichain.org/"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: abitype.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: abitype.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: abitype.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0x078D782b760474a361dDA0AF3839290b0EF57AD6";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x9151434b16b9763660705744891fA906F660EcC5";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    worldchain: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Worldscan";
+                    readonly url: "https://worldscan.org";
+                    readonly apiUrl: "https://api.worldscan.org/api";
+                };
+                readonly blockscout: {
+                    readonly name: "Blockscout";
+                    readonly url: "https://worldchain-mainnet.explorer.alchemy.com";
+                    readonly apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 0;
+                };
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x069c4c579671f8c120b1327a73217D01Ea2EC5ea";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0x19A6d1E9034596196295CF148509796978343c5D";
+                    };
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x470458C91978D2d929704489Ad730DC3E3001113";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 480;
+            name: "World Chain";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://worldchain-mainnet.g.alchemy.com/public"];
+                };
+            };
+            sourceId: 1;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: viem.Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: abitype.Address;
+                        mixHash: viem.Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentBeaconBlockRoot?: `0x${string}` | undefined;
+                        parentHash: viem.Hash;
+                        receiptsRoot: viem.Hex;
+                        sealFields: viem.Hex[];
+                        sha3Uncles: viem.Hash;
+                        size: bigint;
+                        stateRoot: viem.Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                        transactionsRoot: viem.Hash;
+                        uncles: viem.Hash[];
+                        withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined | undefined;
+                        sourceHash: viem.Hex;
+                        type: "deposit";
+                    } | {
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        v: bigint;
+                        to: abitype.Address | null;
+                        from: abitype.Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        accessList?: undefined | undefined;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined | undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas
+                        /** JSON-RPC endpoint. */
+                        ? /** JSON-RPC endpoint. */: undefined | undefined;
+                        maxFeePerGas? /** Display name. Defaults to `EVM <id>`. */: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas?: undefined | undefined;
+                        maxPriorityFeePerGas?: undefined | undefined;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList?: undefined | undefined;
+                        blobVersionedHashes: readonly viem.Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        blockTimestamp?: bigint | undefined;
+                        from: abitype.Address;
+                        gas: bigint;
+                        hash: viem.Hash;
+                        input: viem.Hex;
+                        nonce: number;
+                        r: viem.Hex;
+                        s: viem.Hex;
+                        to: abitype.Address | null;
+                        transactionIndex: number | null;
+                        typeHex: viem.Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: viem.AccessList;
+                        authorizationList: viem.SignedAuthorizationList;
+                        blobVersionedHashes?: undefined | undefined;
+                        chainId: number;
+                        type: "eip7702";
+                        gasPrice?: undefined | undefined;
+                        maxFeePerBlobGas?: undefined | undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined | undefined;
+                        mint?: undefined | undefined;
+                        sourceHash?: undefined | undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: viem.Hash;
+                        blockNumber: bigint;
+                        blockTimestamp?: bigint | undefined;
+                        contractAddress: abitype.Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: abitype.Address;
+                        gasUsed: bigint;
+                        logs: viem.Log<bigint, number, false>[];
+                        logsBloom: viem.Hex;
+                        root?: `0x${string}` | undefined;
+                        status: "success" | "reverted";
+                        to: abitype.Address | null;
+                        transactionHash: viem.Hash;
+                        transactionIndex: number;
+                        type: viem.TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+            readonly network: "worldchain";
+        };
+        tokens: {
+            USDC: {
+                address: "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    sei: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Seiscan";
+                    readonly url: "https://seiscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/v2/api";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1329;
+            name: "Sei Network";
+            nativeCurrency: {
+                readonly name: "Sei";
+                readonly symbol: "SEI";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://evm-rpc.sei-apis.com/"];
+                    readonly webSocket: readonly ["wss://evm-ws.sei-apis.com/"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+    injective: {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Injective Explorer";
+                    readonly url: "https://blockscout.injective.network";
+                    readonly apiUrl: "https://blockscout.injective.network/api";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts?: {
+                [x: string]: viem.ChainContract | {
+                    [sourceId: number]: viem.ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: viem.ChainContract | undefined;
+                ensUniversalResolver?: viem.ChainContract | undefined;
+                multicall3?: viem.ChainContract | undefined;
+                erc6492Verifier?: viem.ChainContract | undefined;
+            } | undefined;
+            ensTlds?: readonly string[] | undefined;
+            id: 1776;
+            name: "Injective";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Injective";
+                readonly symbol: "INJ";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://sentry.evm-rpc.injective.network"];
+                    readonly webSocket: readonly ["wss://sentry.evm-ws.injective.network"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+                client: viem.Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+            verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        };
+        tokens: {
+            USDC: {
+                address: "0xa00C59fF5a080D2b954d0c75e46E22a0c371235a";
+                decimals: number;
+                symbol: string;
+            };
+            USDT: {
+                address: "0x88f7F2b685F9692caf8c478f5BADF09eE9B1Cc13";
+                decimals: number;
+                symbol: string;
+            };
+        };
+    };
+};
+/** A built-in EVM chain name. */
+type ChainName = keyof typeof CHAINS;
+type ChainInput = ChainName | Chain | {
+    /** EVM chain id, e.g. 5000 for Mantle. */
+    id: number;
+    /** JSON-RPC endpoint. */
+    rpcUrl: string;
+    /** Display name. Defaults to `EVM <id>`. */
+    name?: string;
+    /** Native coin metadata. Defaults to 18-decimal ETH. */
+    nativeCurrency?: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+};
+interface ResolvedChain {
+    chain: Chain;
+    chainId: number;
+    rpcUrl: string;
+    /** Known tokens on this chain (empty for unknown custom chains). */
+    tokens: Record<string, TokenInfo>;
+}
+/**
+ * Normalise a `ChainInput` (+ optional rpc override) into the
+ * `{ chain, chainId, rpcUrl, tokens }` the wallet and verifier need.
+ */
+declare function resolveChain(input: ChainInput, rpcUrlOverride?: string): ResolvedChain;
+
+/**
+ * The PaymentDriver contract. Every chain-family section (EVM, Solana, …)
+ * implements this and nothing else; the protocol layer (server/client/x402)
+ * depends on THIS file only — zero `viem`, zero `@solana/web3.js`.
+ *
+ * Convention used throughout the driver layer:
+ *   `chain`   = the developer-supplied selector ('base', { id, rpcUrl }, …)
+ *   `network` = the resolved CAIP-2 id it maps to ('eip155:8453', 'solana:…')
+ *
+ * Identifiers cross this boundary as plain strings (CAIP-2 networks, base-unit
+ * amounts, `0x…`/base58 addresses). `_native` on a WalletHandle is the single
+ * intentional `unknown`: each driver stashes its own wallet object there.
+ */
+
+/** The chain families the SDK knows about. */
+type ChainFamily = 'evm' | 'solana' | 'ton' | 'stellar' | 'xrpl' | 'tron' | 'sui' | 'near';
+/** What chain to use: an EVM name/Chain/{id,rpcUrl}, or a non-EVM family name. */
+type ChainSelector = ChainInput | 'solana' | 'ton' | 'stellar' | 'xrpl' | 'tron' | 'sui' | 'near';
+/** An EVM ERC-20 token, by contract address. */
+interface EvmToken {
+    address: `0x${string}`;
+    decimals: number;
+    symbol?: string;
+}
+/** A Solana SPL token, by mint. */
+interface SolanaToken {
+    mint: string;
+    decimals: number;
+    symbol?: string;
+}
+/** A TON jetton, by master address. */
+interface TonToken {
+    master: string;
+    decimals: number;
+    symbol?: string;
+}
+/** A Stellar classic asset, by issuer + code. */
+interface StellarToken {
+    issuer: string;
+    code: string;
+    decimals: number;
+    symbol?: string;
+}
+/** An XRP Ledger issued currency, by issuer + 160-bit currency code (hex). */
+interface XrplToken {
+    issuer: string;
+    /** The currency: a 3-char ASCII code, or the 40-char 160-bit hex for 4+ chars. */
+    currencyHex: string;
+    decimals: number;
+    symbol?: string;
+}
+/** A Tron TRC-20 token, by contract address (Base58 T…). */
+interface TronToken {
+    address: string;
+    decimals: number;
+    symbol?: string;
+}
+/** A Sui coin, by its fully-qualified coin type (`package::module::TYPE`). */
+interface SuiToken {
+    coinType: string;
+    decimals: number;
+    symbol?: string;
+}
+/** A NEAR NEP-141 token, by its contract account id. */
+interface NearToken {
+    contractId: string;
+    decimals: number;
+    symbol?: string;
+}
+/**
+ * What to be paid in. Each driver validates the forms it accepts:
+ *   - 'native'        the chain's native coin (ETH, BNB, SOL, TON, XLM, XRP)
+ *   - 'USDC' (string) a symbol resolved against the chosen chain
+ *   - EvmToken        any ERC-20         (EVM chains)
+ *   - SolanaToken     any SPL token      (Solana)
+ *   - TonToken        any jetton         (TON)
+ *   - StellarToken    any classic asset  (Stellar)
+ *   - XrplToken       any issued currency (XRPL)
+ *   - TronToken       any TRC-20         (Tron)
+ *   - SuiToken        any coin           (Sui)
+ *   - NearToken       any NEP-141        (NEAR)
+ */
+type TokenInput = 'native' | (string & {}) | EvmToken | SolanaToken | TonToken | StellarToken | XrplToken | TronToken | SuiToken | NearToken;
+/** What a driver resolves a TokenInput into. `asset`: 0x | base58 mint | 'native'. */
+interface ResolvedToken {
+    asset: string;
+    decimals: number;
+    symbol?: string;
+}
+/**
+ * A best-effort estimate of the on-chain NETWORK FEE (gas) a payment will cost
+ * the payer — denominated in the chain's NATIVE coin, which is distinct from the
+ * payment token (you pay in USDC but burn ETH / SOL / TRX / … for gas). Lets an
+ * agent learn the gas cost BEFORE it pays, so it can keep enough native coin on
+ * hand. Built uniformly by the shared `nativeCost()` helper, so every family's
+ * shape is identical. Converting to fiat needs the caller's own price source —
+ * PipRail stays backendless and never calls an oracle.
+ */
+interface CostEstimate {
+    /** The native fee coin's ticker — ETH, BNB, SOL, TON, XLM, XRP, TRX, … */
+    feeSymbol: string;
+    /** The native coin's decimals (18 EVM, 9 Solana/TON, 7 Stellar, 6 XRPL/Tron). */
+    feeDecimals: number;
+    /** Estimated fee in the native coin's base units (a non-negative integer string). */
+    fee: string;
+    /** Human-readable fee, e.g. '0.000021'. */
+    feeFormatted: string;
+    /** 'estimated' = derived from a live RPC read; 'heuristic' = a typical-cost constant. */
+    basis: 'estimated' | 'heuristic';
+    /** Short human note on what's included (e.g. 'gas ~21000 @ 12 gwei'). */
+    detail?: string;
+}
+/** Opaque per-driver wallet handle — `_native` holds the driver's own object. */
+interface WalletHandle {
+    readonly _native: unknown;
+}
+interface ConfirmInfo {
+    /** Block number (EVM) or slot (Solana) as a string — numeric-agnostic. */
+    height: string;
+}
+/**
+ * A driver bound to one concrete network — what the gate and client hold. Each
+ * method's error behaviour is fixed by the SDK error standard (see ERRORS.md §5):
+ * `resolveToken`/`assertValidPayTo`/`bindWallet` throw `WrongFamilyError` /
+ * `UnknownTokenError`; `send` maps affordability to `InsufficientFundsError`;
+ * `verify` RETURNS a `VerifyResult` (and never throws for an RPC hiccup —
+ * transient reads become `tx_not_found`); `confirm` throws `ConfirmationTimeoutError`.
+ */
+interface ResolvedNetwork {
+    readonly family: ChainFamily;
+    /** The resolved CAIP-2 id: 'eip155:8453' | 'solana:<genesis>' | … */
+    readonly network: Caip2;
+    /** Does this bound network handle the given CAIP-2 network string? */
+    supports(network: string): boolean;
+    /** Turn a TokenInput into { asset, decimals, symbol } for this network. */
+    resolveToken(token: TokenInput): ResolvedToken;
+    /**
+     * Trusted metadata for a resolved on-chain `asset` id on THIS network — the
+     * SDK's OWN decimals/symbol for a built-in token or the native coin, or `null`
+     * if the SDK doesn't recognise the asset (a custom token it can't safely
+     * price). Pure/synchronous — a built-in-map + native lookup, never an RPC call.
+     *
+     * The client uses it to enforce a spend budget against the token's TRUE
+     * decimals (so a server can't understate a price by lying about
+     * `extra.decimals`) and to flag when a challenge's stated symbol disagrees
+     * with the real one. The inverse of `resolveToken` for known assets.
+     */
+    describeAsset(asset: string): {
+        symbol?: string;
+        decimals: number;
+    } | null;
+    /** Throw if `payTo` isn't a valid address for this family. */
+    assertValidPayTo(payTo: string): void;
+    /** Validate + wrap the user's wallet config for this family. */
+    bindWallet(wallet: unknown): WalletHandle;
+    /** Broadcast payment for `accept`; return the proof ref (tx hash / signature). */
+    send(wallet: WalletHandle, accept: X402AcceptEntry): Promise<string>;
+    /** Wait until `ref` reaches minConfirmations (or finality). */
+    confirm(ref: string, minConfirmations: number): Promise<ConfirmInfo>;
+    /**
+     * Best-effort estimate of the network fee (gas) to settle `accept`, in the
+     * chain's NATIVE coin (see {@link CostEstimate}). Async (may read RPC) but
+     * never throws for a transient RPC issue — it falls back to a 'heuristic'
+     * constant. `opts.from` (the payer's address) sharpens chains whose fee
+     * depends on the sender (notably Tron energy); omit it for a typical estimate.
+     * Payer-side + informational — the gate never calls this.
+     */
+    estimateCost(accept: X402AcceptEntry, opts?: {
+        from?: string;
+    }): Promise<CostEstimate>;
+    /** Verify `ref` satisfies `accept`, RPC-only, in-process. */
+    verify(ref: string, accept: X402AcceptEntry): Promise<VerifyResult>;
+}
+interface ResolveOptions {
+    /** The developer-supplied `chain` selector. */
+    chain: unknown;
+    rpcUrl?: string;
+}
+/** A stateless family driver. The registry calls resolve() to bind a network. */
+interface PaymentDriver {
+    readonly family: ChainFamily;
+    /** Recognise + bind the chain input, or return null to let another try. */
+    resolve(opts: ResolveOptions): ResolvedNetwork | null;
+}
+
+interface PaymentPolicy {
+    /** Per-payment ceiling, human-readable (e.g. '0.10'). Compared using the
+     *  token's TRUE decimals, so a server can't understate the price. */
+    maxAmount?: string;
+    /** Lifetime ceiling for this client, PER DISTINCT ASSET (network+asset).
+     *  Summing across different tokens is unit-meaningless without a price
+     *  oracle (which the SDK deliberately doesn't add), so each token gets its
+     *  own running cap. Pair with `tokens: ['USDC']` for a single-currency budget. */
+    maxTotal?: string;
+    /** Allowlist of chains the agent may pay on. A 402 on any other chain is
+     *  declined. Strings match the configured selector; objects match by id. */
+    chains?: ChainSelector[];
+    /** Allowlist of token symbols (matched against the TRUE symbol). An asset the
+     *  SDK can't recognise never satisfies this list. */
+    tokens?: string[];
+    /** Allowlist of hosts. Exact (`api.example.com`) or wildcard (`*.example.com`). */
+    hosts?: string[];
+    /** Pay an asset the SDK can't price (custom/unknown token)? Default false —
+     *  declined, because its true decimals can't be verified. When true, the
+     *  server-stated decimals are trusted (the explicit, opt-in risk). */
+    allowUnknownTokens?: boolean;
+}
+/** What the policy reasons over — built by the client from the chosen accept. */
+interface PaymentIntent {
+    /** Host of the gated URL (for the `hosts` allowlist). */
+    host: string;
+    /** The selector the client is configured with (for the `chains` allowlist). */
+    chain: ChainSelector;
+    network: Caip2;
+    asset: string;
+    /** Server-stated base units — what actually transfers on-chain. */
+    amountBase: bigint;
+    /** TRUE decimals if the asset is recognised, else the server-stated value. */
+    decimals: number;
+    /** TRUE symbol if recognised, else the server-stated value (may be undefined). */
+    symbol?: string;
+    /** Did the driver's `describeAsset` recognise this asset? */
+    recognized: boolean;
+}
+interface PolicyDecision {
+    allowed: boolean;
+    /** Why it was refused (only when `allowed === false`). */
+    reason?: string;
+}
+/**
+ * Evaluate a payment against the policy. `spentForAssetBase` is the running
+ * total already spent on THIS (network, asset) — supplied by the client's
+ * ledger — and powers the per-asset `maxTotal` cap.
+ *
+ * Checks run cheapest-first; the first failure wins so the reason is specific.
+ */
+declare function evaluatePolicy(intent: PaymentIntent, policy: PaymentPolicy | undefined, spentForAssetBase: bigint): PolicyDecision;
+
+interface SpendRecord {
+    url: string;
+    host: string;
+    network: Caip2;
+    asset: string;
+    /** Base units paid (already scaled by decimals). */
+    amountBase: string;
+    /** Human-readable amount, e.g. '0.05'. */
+    amountFormatted: string;
+    symbol?: string;
+    /** Proof ref (EVM tx hash, Solana signature, TON locator, Stellar tx hash). */
+    ref: string;
+    /** ISO timestamp of settlement. */
+    at: string;
+}
+interface SpendAssetTotal {
+    network: Caip2;
+    asset: string;
+    symbol?: string;
+    decimals: number;
+    totalBase: string;
+    totalFormatted: string;
+    count: number;
+}
+interface SpendSummary {
+    /** Total number of settled payments. */
+    count: number;
+    /** Cumulative spend per distinct (network, asset). */
+    byAsset: SpendAssetTotal[];
+    /** Every settled payment, in order. */
+    records: SpendRecord[];
+}
+
+/** Observability events. `ref` is the proof — a chain-specific id (EVM tx hash, Solana signature, TON locator, Stellar tx hash). */
+type PipRailEvent = {
+    kind: 'payment-required';
+    challenge: X402Challenge;
+    accept: X402AcceptEntry;
+} | {
+    kind: 'payment-broadcast';
+    ref: string;
+} | {
+    kind: 'payment-confirmed';
+    ref: string;
+    blockNumber: bigint;
+} | {
+    kind: 'payment-settled';
+    receipt: X402Receipt | null;
+} | {
+    kind: 'payment-failed';
+    reason: string;
+};
+/**
+ * Wallet for the chosen chain family (the `chain` selector routes; each driver
+ * validates its own key format):
+ *   - EVM     → `{ privateKey }` (0x… hex) or a viem `{ walletClient }`
+ *   - Tron    → `{ privateKey }` (32-byte hex — secp256k1, like EVM)
+ *   - Sui     → `{ privateKey }` (suiprivkey1… bech32) or a ready `{ keypair }`
+ *   - Solana  → `{ secretKey }` (Uint8Array | base58) or `{ signer }`
+ *   - TON     → `{ mnemonic }` (24 words) or a ready `{ keyPair }`
+ *   - Stellar → `{ secret }` (S… seed) or a ready `{ keypair }`
+ *   - XRPL    → `{ seed }` (s… seed) or a ready `{ wallet }`
+ *   - NEAR    → `{ accountId, privateKey }` (privateKey = ed25519:… secret)
+ */
+type WalletInput = {
+    privateKey: string;
+} | {
+    walletClient: unknown;
+} | {
+    secretKey: Uint8Array | string;
+} | {
+    signer: unknown;
+} | {
+    mnemonic: string | string[];
+    version?: 'v4' | 'v5r1';
+} | {
+    keyPair: unknown;
+    version?: 'v4' | 'v5r1';
+} | {
+    secret: string;
+} | {
+    keypair: unknown;
+} | {
+    seed: string;
+} | {
+    wallet: unknown;
+} | {
+    accountId: string;
+    privateKey: string;
+};
+/**
+ * A priced payment requirement — what `client.quote(url)` returns and what an
+ * `onBeforePay` hook receives, so an agent can decide BEFORE any funds move.
+ * `amount`/`decimals`/`symbol` reflect the TRUE token (the SDK's, via
+ * `describeAsset`) when recognised, falling back to the server's stated values.
+ */
+interface PipRailQuote {
+    /** The gated URL. */
+    url: string;
+    /** The chain the client is configured for. */
+    chain: ChainSelector;
+    network: Caip2;
+    /** On-chain asset id (0x… / mint / jetton master / CODE:ISSUER / 'native'). */
+    asset: string;
+    /** Amount in base units (what actually transfers). */
+    amount: string;
+    /** Human-readable amount, e.g. '0.05'. */
+    amountFormatted: string;
+    decimals: number;
+    symbol?: string;
+    payTo: string;
+    description?: string;
+    maxTimeoutSeconds: number;
+    /** Did the SDK recognise the asset (and so trust its decimals/symbol)? */
+    recognized: boolean;
+    /** True if the challenge's stated symbol disagrees with the SDK's real one — a
+     *  red flag worth surfacing to the agent. */
+    symbolMismatch: boolean;
+    /** Would the configured `policy` allow paying this? (true when no policy set.) */
+    withinPolicy: boolean;
+    /** Why the policy would refuse it (only when `withinPolicy === false`). */
+    policyReason?: string;
+}
+/**
+ * What `client.estimateCost(url)` returns: the priced payment requirement plus
+ * the estimated NETWORK FEE (gas) to settle it, in the chain's native coin.
+ * Two distinct numbers an agent weighs before paying — `quote.amountFormatted`
+ * is what leaves the wallet as payment; `cost.feeFormatted` is the native-coin
+ * gas burned to send it (you pay USDC but spend ETH/SOL/TRX/… on gas).
+ */
+interface PipRailCostQuote {
+    /** The priced payment requirement (amount/token/chain/recipient/policy). */
+    quote: PipRailQuote;
+    /** Estimated network fee (gas) in the chain's native coin. */
+    cost: CostEstimate;
+}
+interface PipRailClientOptions {
+    /** Wallet for the chosen chain family. */
+    wallet: WalletInput;
+    /** Which chain to pay on. EVM ('bnb'|'base'|…), 'solana', 'ton', 'stellar',
+     *  'xrpl', 'tron', 'sui', or 'near'. */
+    chain: ChainSelector;
+    /** Override the chain's default RPC URL (recommended in production). */
+    rpcUrl?: string;
+    /**
+     * Spend guardrails for autonomous payment — per-payment + lifetime ceilings
+     * and chain/token/host allowlists. A 402 that violates the policy is refused
+     * with {@link PaymentDeclinedError} BEFORE any on-chain send. Omit for the
+     * (unguarded) default. See {@link PaymentPolicy}.
+     */
+    policy?: PaymentPolicy;
+    /**
+     * Final approval hook, called with the {@link PipRailQuote} after the policy
+     * passes but before paying. Return `false` (or a rejected promise resolving
+     * false) to refuse — the client throws {@link PaymentDeclinedError} and no
+     * funds move. Use for human-in-the-loop or custom per-payment logic.
+     */
+    onBeforePay?: (quote: PipRailQuote) => boolean | Promise<boolean>;
+    /**
+     * After paying, how many times to re-send the request with proof before
+     * giving up. Default 3, with a short backoff between attempts — this
+     * absorbs RPC propagation lag (the server's node briefly trailing the
+     * client's, so it hasn't seen the confirmation yet). If the server still
+     * returns 402 on the last attempt the SDK throws `MaxRetriesExceededError`.
+     */
+    maxPaymentRetries?: number;
+    /** Timeout (ms) for the retry leg after broadcast. Default 30_000. */
+    retryTimeoutMs?: number;
+    /** Logger hook. Default no-op. */
+    onEvent?: (event: PipRailEvent) => void;
+}
+declare class PipRailClient {
+    private readonly opts;
+    private readonly maxRetries;
+    private readonly retryTimeoutMs;
+    private readonly onEvent;
+    private readonly ledger;
+    private bound?;
+    constructor(opts: PipRailClientOptions);
+    /** Emit an observability event, never letting a throwing handler break the
+     * payment flow (mirrors the server gate's `onPaid` isolation). */
+    private safeEmit;
+    /** Auto-mount the chain's driver, resolve the network, and bind the wallet — once. */
+    private ensure;
+    /** GET that auto-handles 402. Pass a full URL to any x402-gated endpoint. */
+    get(url: string, init?: RequestInit): Promise<Response>;
+    /**
+     * POST that auto-handles 402.
+     *
+     * `body` can be a string/FormData/URLSearchParams/ArrayBuffer/Blob (sent
+     * as-is) or a plain object (serialised as JSON).
+     */
+    post(url: string, body?: BodyInit | object | undefined, init?: RequestInit): Promise<Response>;
+    /**
+     * Price a gated URL WITHOUT paying. Does the initial request, and if it's a
+     * 402, returns a {@link PipRailQuote} — the amount (in the token's TRUE
+     * decimals), token, chain, recipient, and whether the configured `policy`
+     * would allow it. Returns `null` when the URL isn't payment-gated (no 402).
+     *
+     * This is what lets an agent (or its planner) decide *before* spending —
+     * "0.05 USDC on Base, within budget → pay it." No funds move.
+     */
+    quote(url: string, init?: RequestInit): Promise<PipRailQuote | null>;
+    /**
+     * Estimate the network fee (gas) to pay a gated URL — WITHOUT paying. Returns
+     * the {@link PipRailQuote} (what the payment is) plus a {@link CostEstimate}
+     * (the gas it will burn, in the chain's NATIVE coin), so an agent can budget
+     * the *total* — payment + gas — before any funds move. Returns `null` when the
+     * URL isn't payment-gated (no 402).
+     *
+     * The estimate is best-effort and labelled (`cost.basis`): live-RPC ('estimated')
+     * where cheap (EVM gas price, XRPL fee), a typical-cost constant ('heuristic')
+     * otherwise. It never throws for a transient RPC issue. Gas is in the native
+     * coin (ETH/SOL/TON/XLM/XRP/TRX), distinct from the payment token — most useful
+     * on Tron, where a USD₮ transfer can cost real TRX.
+     */
+    estimateCost(url: string, init?: RequestInit): Promise<PipRailCostQuote | null>;
+    /** Aggregated snapshot of every payment this client has settled — total
+     *  count, cumulative spend per token, and the individual records. */
+    spent(): SpendSummary;
+    /**
+     * Lower-level: drive any HTTP method through the 402 flow.
+     *
+     * `init.body` (if any) must be replayable — the SDK may send the request
+     * twice (once to fetch the 402, once with the proof attached). One-shot
+     * streams throw `NonReplayableBodyError`.
+     */
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    /**
+     * From a confirmed-402 response: parse the challenge, mount + bind the
+     * network, pick the accept the client can pay, and build its quote. Shared by
+     * `quote()` (read-only) and `fetch()` (which then authorises + pays).
+     */
+    private resolveChallenge;
+    /** Build the agent-facing quote for an accept: TRUE decimals/symbol (via the
+     *  driver's describeAsset) + the policy verdict + a symbol-mismatch flag. */
+    private buildQuote;
+    /** Enforce the spend policy and the onBeforePay hook — both refuse by
+     *  throwing PaymentDeclinedError, before any funds move. */
+    private authorize;
+    /** Record a settled payment in the ledger (true decimals for the running total). */
+    private recordSpend;
+    private payAndConfirm;
+    private retryWithProof;
+}
+
+/** A framework-agnostic tool definition an agent runtime can register. */
+interface AgentTool {
+    /** Unique tool name (snake_case, namespaced `piprail_…`). */
+    name: string;
+    /** What the tool does — written for an LLM to read. */
+    description: string;
+    /** JSON Schema (draft-07 object) describing the arguments. */
+    parameters: Record<string, unknown>;
+    /** Execute the tool. Returns a JSON-serialisable result. */
+    invoke: (args: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Two tools wrapping a configured {@link PipRailClient}:
+ *   - `piprail_quote_payment(url)` — price a gated URL WITHOUT paying.
+ *   - `piprail_pay_request(url, method?, body?)` — pay if needed and return the result.
+ *
+ * A policy/approval refusal comes back as a structured `{ declined: true, reason }`
+ * (not a thrown error), so the model can reason about it instead of crashing.
+ */
+declare function paymentTools(client: PipRailClient): AgentTool[];
+
+/**
+ * The accept side: gate any endpoint behind a payment with one function.
+ *
+ *   import { requirePayment } from '@piprail/sdk'
+ *
+ *   app.get('/report',
+ *     requirePayment({ chain: 'base', amount: '0.05', payTo: '0xMerchant…' }),
+ *     (req, res) => res.json({ secret: 42 })
+ *   )
+ *
+ * One parameter picks the chain family: 'base'/'bnb'/… → EVM, 'solana' →
+ * Solana, 'ton' → TON. Non-EVM drivers auto-mount on first use — no setup
+ * call. The payment is verified against the chain's RPC, in-process — no
+ * backend, no database.
+ *
+ * Replay protection is an in-memory used-tx set scoped to the gate —
+ * single-process by design; pass your own `isUsed`/`markUsed` to share it.
+ */
+
+/**
+ * One payment option a gate offers. Pass several to `requirePayment({ accept:
+ * [...] })` and the challenge offers them all in `accepts[]` — the agent pays on
+ * whichever chain it holds funds for (USDC on Base OR Solana OR …). `payTo`/
+ * `rpcUrl` fall back to the top-level option when omitted (per-family payTo is
+ * usually given here, since address shapes differ across chains).
+ */
+interface AcceptOption {
+    /** Which chain. EVM ('bnb'|'base'|…), 'solana', 'ton', 'stellar', 'xrpl',
+     *  'tron', 'near', or 'sui'. */
+    chain: ChainSelector;
+    /** Token to be paid in (symbol / 'native' / custom descriptor). */
+    token: TokenInput;
+    /** Human-readable amount for THIS option, e.g. "0.05". */
+    amount: string;
+    /** Recipient for this chain (defaults to the top-level `payTo`). */
+    payTo?: AddressId;
+    /** RPC override for this chain (defaults to the top-level `rpcUrl`). */
+    rpcUrl?: string;
+}
+interface RequirePaymentOptions {
+    /**
+     * Single-chain form: which chain to accept payment on. EVM ('bnb'|'base'|…),
+     * 'solana', 'ton', 'stellar', 'xrpl', 'tron', 'near', or 'sui'. Provide
+     * `chain` + `token` + `amount`, OR use the multi-chain `accept` array below.
+     */
+    chain?: ChainSelector;
+    /** Override the chain's default RPC URL (recommended in production). */
+    rpcUrl?: string;
+    /**
+     * What to be paid in (single-chain form). Use a symbol the chain ships
+     * (`'USDC'` / `'USDT'`), the chain's coin (`'native'`), or a custom token:
+     * `{ address, decimals }` on EVM/Tron, `{ mint, decimals }` on Solana,
+     * `{ master, decimals }` on TON, `{ issuer, code, decimals }` on Stellar,
+     * `{ issuer, currencyHex, decimals }` on XRPL, `{ contractId, decimals }` on
+     * NEAR, `{ coinType, decimals }` on Sui. You name the token; the SDK fills in
+     * the contract + decimals for built-in symbols. (Note: native USDC doesn't
+     * exist on TON/Tron — USDT does; NEAR is FT-only, so `'native'` is rejected.)
+     */
+    token?: TokenInput;
+    /** Human-readable amount, e.g. "0.05" (single-chain form). */
+    amount?: string;
+    /**
+     * Multi-chain form: offer several payment options in ONE challenge. The agent
+     * picks the chain/token it can pay. Mutually exclusive with the single-chain
+     * `chain`/`token`/`amount` fields above; provide one form or the other.
+     */
+    accept?: AcceptOption[];
+    /** Address that receives the payment (0x… EVM/Sui, base58 Solana, EQ…/UQ… TON,
+     *  G… Stellar, r… XRPL, T… Tron, account id on NEAR). Required for the single
+     *  form; the per-option fallback for the multi form. */
+    payTo?: AddressId;
+    /** Shown to the agent in the challenge. */
+    description?: string;
+    /** Confirmations required before access is granted. Default 1. */
+    minConfirmations?: number;
+    /** Max age of an accepted payment, in seconds. Default 600. */
+    maxTimeoutSeconds?: number;
+    /** Nonce generator. Default `crypto.randomUUID()`. */
+    generateNonce?: () => string;
+    /** Replay hook — return true if this proof was already redeemed. */
+    isUsed?: (ref: string) => boolean | Promise<boolean>;
+    /** Replay hook — record a redeemed proof. */
+    markUsed?: (ref: string) => void | Promise<void>;
+    /** Fired when a payment verifies successfully. */
+    onPaid?: (receipt: X402Receipt) => void;
+}
+type VerifyPaymentResult = {
+    kind: 'paid';
+    receipt: X402Receipt;
+    receiptHeader: string;
+} | {
+    kind: 'challenge';
+    challenge: X402Challenge;
+    requiredHeader: string;
+    statusCode: 402;
+} | {
+    kind: 'invalid';
+    error: string;
+    detail: string;
+    statusCode: 402;
+};
+/** The canonical x402 v2 JSON body for a rejected proof (a 402 'invalid'). */
+interface X402InvalidBody {
+    x402Version: 2;
+    status: 'invalid';
+    error: string;
+    detail: string;
+}
+/**
+ * Build the canonical 402 'invalid' body. Use this in EVERY framework adapter
+ * (Express, Hono, Fastify, Workers, …) so a rejected proof returns the IDENTICAL
+ * envelope everywhere — `verify()` produces the reason, this shapes the body.
+ */
+declare function toInvalidBody(result: {
+    error: string;
+    detail: string;
+}): X402InvalidBody;
+interface PaymentGate {
+    /** Build a fresh 402 challenge (new nonce) for a resource URL. */
+    challenge(resourceUrl?: string): Promise<{
+        challenge: X402Challenge;
+        requiredHeader: string;
+    }>;
+    /** Verify an incoming `payment-signature` header value. */
+    verify(paymentSignature: string | string[] | undefined): Promise<VerifyPaymentResult>;
+}
+/**
+ * Framework-agnostic core. Build one gate per gated resource and reuse it
+ * — its in-memory used-tx set is what stops the same proof being redeemed
+ * twice. Wrap it for Express with `requirePayment`, or call it directly
+ * from Hono / Fastify / Adonis / Workers / etc.
+ *
+ * The chain's driver is resolved lazily on first `challenge()`/`verify()`,
+ * which is what lets Solana (and future families) auto-mount with no setup.
+ */
+declare function createPaymentGate(options: RequirePaymentOptions): PaymentGate;
+interface ExpressLikeRequest {
+    headers: Record<string, string | string[] | undefined>;
+    originalUrl?: string;
+    url?: string;
+}
+interface ExpressLikeResponse {
+    setHeader: (name: string, value: string) => void;
+    status: (code: number) => unknown;
+    json: (body: unknown) => unknown;
+}
+type ExpressLikeNext = (err?: unknown) => void;
+type ExpressLikeMiddleware = (req: ExpressLikeRequest, res: ExpressLikeResponse, next: ExpressLikeNext) => Promise<void> | void;
+/**
+ * Express/Connect-style middleware. The 80% case — drop it in front of a
+ * route handler and the route is paid-only. The driver auto-mounts on the
+ * first request; config/driver errors are forwarded to `next(err)`.
+ */
+declare function requirePayment(options: RequirePaymentOptions): ExpressLikeMiddleware;
+
+/**
+ * The driver registry — the ONLY place the families meet. Routing decides a
+ * family from the `chain` value (synchronously), then asks that family's
+ * driver to bind the network. Add a family = register a driver here.
+ */
+
+declare function registerDriver(driver: PaymentDriver): void;
+
+/**
+ * ── The PipRail error model (the SDK-wide standard) ───────────────────────
+ * Full standard: `sdk/ERRORS.md`. In short, errors surface through exactly two
+ * channels, both chain-agnostic — an EVM, Solana, TON or Stellar failure looks
+ * identical to the caller:
+ *
+ *   1. THROWN — a typed {@link PipRailError} subclass, each with a stable
+ *      SCREAMING_SNAKE `.code`. For config / flow / wallet / registry problems
+ *      the caller can act on (wrong-family wallet, missing driver, insufficient
+ *      funds, retries exhausted, …). Catch with `err instanceof PipRailError`.
+ *   2. RETURNED — `verify()` returns a `VerifyResult` `{ ok: false, error,
+ *      detail }`, where `error` is a closed `VerifyErrorCode` (see x402.ts).
+ *      This is how server-side proof verification rejects; the gate turns it
+ *      into a 402 body `{ status: 'invalid', error, detail }` (built once by
+ *      {@link toInvalidBody}), and the client relays that reason to the agent.
+ *
+ * Affordability ("wallet can't pay") always converges on ONE typed
+ * {@link InsufficientFundsError}, by two mechanisms: message-regex drivers
+ * (Solana, TON) call {@link toInsufficientFundsError}; structured-error drivers
+ * (EVM via viem's `BaseError` walk, Stellar via Horizon `result_codes`) detect
+ * it from typed data — but every one throws the same InsufficientFundsError.
+ *
+ * So whoever hits an error — a human, the merchant server, or an AI agent —
+ * gets a typed `.code` (thrown) or a `VerifyErrorCode` (returned) plus a
+ * human-readable message, never an opaque chain-library error.
+ *
+ * Base class: every error the SDK throws extends this, so consumers can filter
+ * SDK-originated errors from arbitrary ones with:
+ *
+ *   catch (err) {
+ *     if (err instanceof PipRailError) ...
+ *   }
+ */
+declare abstract class PipRailError extends Error {
+    abstract readonly code: string;
+    constructor(message: string, options?: ErrorOptions);
+}
+/** Wallet balance too low for the quoted amount + gas. */
+declare class InsufficientFundsError extends PipRailError {
+    readonly code = "INSUFFICIENT_FUNDS";
+}
+/**
+ * Best-effort: turn a chain library's "wallet can't afford it" error into the
+ * SDK's typed {@link InsufficientFundsError}, by matching its message. Drivers
+ * WITHOUT structured error data (Solana, TON) call this in their `send()` catch
+ * and rethrow the original on a miss:
+ *
+ *   catch (err) { throw toInsufficientFundsError(err) ?? err }
+ *
+ * Drivers WITH structured data (EVM via viem `BaseError.walk`, Stellar via
+ * Horizon `result_codes`) detect affordability from that data but still throw
+ * the SAME InsufficientFundsError, and fall through to this as a message-level
+ * backstop so the two paths can't drift. A miss returns null, so the original
+ * (still descriptive) error propagates unchanged — never swallowed.
+ */
+declare function toInsufficientFundsError(err: unknown): InsufficientFundsError | null;
+/** Paywall is on chain X, client wallet is on chain Y. */
+declare class WrongChainError extends PipRailError {
+    readonly code = "WRONG_CHAIN";
+}
+/**
+ * Broadcast confirmed on-chain but server didn't return 200 within timeout.
+ * The user got their tokens debited but the gated content is unreachable —
+ * retry manually with the receipt nonce.
+ */
+declare class PaymentTimeoutError extends PipRailError {
+    readonly code = "PAYMENT_TIMEOUT";
+}
+/** Paid, retried, still got 402. Means the server rejected our proof. */
+declare class MaxRetriesExceededError extends PipRailError {
+    readonly code = "MAX_RETRIES_EXCEEDED";
+}
+/**
+ * The client refused to pay BEFORE any on-chain send — the quoted payment
+ * exceeded the configured {@link PaymentPolicy} (amount/total ceiling, or a
+ * chain/token/host outside the allowlist), or an `onBeforePay` hook returned
+ * `false`. No funds moved. The message names which guard fired; inspect the
+ * `quote` via `client.quote(url)` to see the full breakdown.
+ */
+declare class PaymentDeclinedError extends PipRailError {
+    readonly code = "PAYMENT_DECLINED";
+}
+/**
+ * The payment broadcast but didn't confirm within the driver's polling window
+ * (EVM: minConfirmations; Solana: commitment; TON: seqno; Stellar: ledger
+ * visibility). The tx may still confirm — re-check the proof ref. Distinct from
+ * {@link PaymentTimeoutError}, which is the SERVER not responding *after* a
+ * confirmed payment.
+ */
+declare class ConfirmationTimeoutError extends PipRailError {
+    readonly code = "CONFIRMATION_TIMEOUT";
+}
+/** Server returned 402 but the PAYMENT-REQUIRED envelope was missing or malformed. */
+declare class InvalidEnvelopeError extends PipRailError {
+    readonly code = "INVALID_ENVELOPE";
+}
+/**
+ * The envelope didn't include any accepts[] entry compatible with the
+ * client's chain id (or all entries used unsupported schemes).
+ */
+declare class NoCompatibleAcceptError extends PipRailError {
+    readonly code = "NO_COMPATIBLE_ACCEPT";
+}
+/** init.body was provided but isn't replayable (e.g. a one-shot ReadableStream). */
+declare class NonReplayableBodyError extends PipRailError {
+    readonly code = "NON_REPLAYABLE_BODY";
+}
+/**
+ * The chosen chain belongs to one family (EVM, Solana, TON, Stellar, XRPL, Tron,
+ * Sui, NEAR) but the wallet, payTo, or token was given in another family's form
+ * (e.g. an `0x…` payTo on Solana, or a `{ mint }` token on a Stellar chain).
+ */
+declare class WrongFamilyError extends PipRailError {
+    readonly code = "WRONG_FAMILY";
+}
+/**
+ * A built-in token symbol was requested that the chosen chain doesn't ship
+ * (e.g. `token: 'DOGE'`). Use a symbol the chain ships, `'native'`, or pass the
+ * token by full descriptor ({ address, decimals } EVM/Tron · { mint, decimals }
+ * Solana · { master, decimals } TON · { issuer, code, decimals } Stellar ·
+ * { issuer, currencyHex, decimals } XRPL · { coinType, decimals } Sui ·
+ * { contractId, decimals } NEAR).
+ */
+declare class UnknownTokenError extends PipRailError {
+    readonly code = "UNKNOWN_TOKEN";
+}
+/**
+ * The requested chain family couldn't be mounted. Drivers auto-mount on first
+ * use, so this means its optional peer deps aren't installed — Solana:
+ * `npm install @solana/web3.js @solana/spl-token bs58`; TON:
+ * `npm install @ton/ton @ton/core @ton/crypto`; Stellar:
+ * `npm install @stellar/stellar-sdk`; XRPL: `npm install xrpl`; Tron:
+ * `npm install tronweb`; Sui: `npm install @mysten/sui`; NEAR:
+ * `npm install near-api-js`.
+ */
+declare class MissingDriverError extends PipRailError {
+    readonly code = "MISSING_DRIVER";
+}
+/** No registered driver recognised the given `chain` value. */
+declare class UnsupportedNetworkError extends PipRailError {
+    readonly code = "UNSUPPORTED_NETWORK";
+}
+
+/**
+ * ── EVM SECTION: x402 `exact` scheme (interop building block) ──────────────
+ *
+ * EXPERIMENTAL / ADVANCED. PipRail's own gates use the `onchain-proof` scheme
+ * (client pays first, proves with a tx ref, server verifies locally — no
+ * facilitator). This module is the opposite end: the building blocks to PAY a
+ * server that speaks the mainstream x402 `exact` scheme (Coinbase-style), where
+ * the client signs an EIP-3009 `transferWithAuthorization` and a third-party
+ * facilitator broadcasts it. It lets a PipRail agent buy from `exact` servers
+ * too — making PipRail a *universal* x402 client — while our servers stay
+ * backendless.
+ *
+ * What's here is the deterministic, unit-testable core: parse an `exact`
+ * requirement, build + EIP-712-sign the authorization, and encode the
+ * `X-PAYMENT` header. It is intentionally NOT wired into `PipRailClient.fetch`'s
+ * default flow: `exact` is a cross-vendor wire protocol whose live acceptance
+ * can only be confirmed against a real facilitator, and bolting a second
+ * payment protocol into the core would cut against PipRail's keep-it-simple
+ * design. Use these helpers to hand-roll an `exact` payment, and validate
+ * against your target facilitator before production. See
+ * `.claude/plans/agent-readiness/04-universal-exact.md`.
+ *
+ * EVM + EIP-3009 only (USDC and kin). Uses the existing `viem` peer — no new dep.
+ */
+
+/** x402 network slug → EVM chain id, for the chains PipRail ships with EIP-3009
+ *  USDC. Extend as needed; an unknown slug just won't be selected. */
+declare const EXACT_NETWORK_SLUGS: Readonly<Record<string, number>>;
+/** Resolve an x402 `exact` network slug (e.g. "base") to its EVM chain id. */
+declare function chainIdForExactNetwork(slug: string): number | null;
+/** A parsed x402 `exact` PaymentRequirements entry (the fields we consume). */
+interface ExactAccept {
+    scheme: 'exact';
+    network: string;
+    /** Amount in base units (x402 names this `maxAmountRequired`). */
+    maxAmountRequired: string;
+    /** EIP-3009 token contract. */
+    asset: `0x${string}`;
+    payTo: `0x${string}`;
+    maxTimeoutSeconds: number;
+    /** EIP-712 domain of the token (USDC: name 'USD Coin', version '2'). */
+    extra?: {
+        name?: string;
+        version?: string;
+    };
+    description?: string;
+    resource?: string;
+}
+/** The EIP-3009 authorization the payer signs. */
+interface ExactAuthorization {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: Hex;
+}
+/** EIP-712 type set for `transferWithAuthorization` (EIP-3009). */
+declare const EIP3009_TYPES: {
+    readonly TransferWithAuthorization: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }];
+};
+/**
+ * Parse a standard x402 challenge body into its `exact` requirements. Tolerant
+ * of x402Version 1 or 2 and of the `maxAmountRequired`/`amount` field name.
+ * Returns `[]` when there are no `exact` entries, `null` when the body isn't a
+ * recognisable x402 challenge.
+ */
+declare function parseExactRequirements(body: unknown): ExactAccept[] | null;
+interface BuildExactParams {
+    /** A viem account able to sign EIP-712 typed data. */
+    account: Account;
+    accept: ExactAccept;
+    /** EVM chain id (must match the token's deployment / EIP-712 domain). */
+    chainId: number;
+    /** Unix seconds 'now' — injectable for deterministic tests. */
+    now: number;
+    /** 32-byte hex authorization nonce — injectable for deterministic tests
+     *  (use a CSPRNG value in production). */
+    nonce: Hex;
+}
+/**
+ * Build + EIP-712-sign an EIP-3009 `transferWithAuthorization` for an `exact`
+ * requirement. Returns the authorization and its signature; pass both to
+ * {@link encodeXPaymentHeader} to produce the `X-PAYMENT` header value.
+ */
+declare function buildExactAuthorization(params: BuildExactParams): Promise<{
+    authorization: ExactAuthorization;
+    signature: Hex;
+}>;
+/** Encode an x402 `exact` PaymentPayload into an `X-PAYMENT` header value. */
+declare function encodeXPaymentHeader(input: {
+    network: string;
+    authorization: ExactAuthorization;
+    signature: Hex;
+    /** x402 envelope version (Coinbase's reference uses 1). */
+    x402Version?: number;
+}): string;
+
+export { type AcceptOption, type AddressId, type AgentTool, type AssetId, type BuildExactParams, CHAINS, type Caip2, type ChainFamily, type ChainInput, type ChainName, type ChainPreset, type ChainSelector, type ConfirmInfo, ConfirmationTimeoutError, type CostEstimate, EIP3009_TYPES, EXACT_NETWORK_SLUGS, type EvmToken, type ExactAccept, type ExactAuthorization, type ExpressLikeMiddleware, type ExpressLikeNext, type ExpressLikeRequest, type ExpressLikeResponse, InsufficientFundsError, InvalidEnvelopeError, MaxRetriesExceededError, MissingDriverError, type NearToken, NoCompatibleAcceptError, NonReplayableBodyError, PaymentDeclinedError, type PaymentDriver, type PaymentGate, type PaymentIntent, type PaymentPolicy, PaymentTimeoutError, PipRailClient, type PipRailClientOptions, type PipRailCostQuote, PipRailError, type PipRailEvent, type PipRailQuote, type PolicyDecision, type RequirePaymentOptions, type ResolveOptions, type ResolvedChain, type ResolvedNetwork, type ResolvedToken, type SolanaToken, type SpendAssetTotal, type SpendRecord, type SpendSummary, type StellarToken, type SuiToken, type TokenInfo, type TokenInput, type TonToken, type TronToken, UnknownTokenError, UnsupportedNetworkError, type VerifyErrorCode, type VerifyPaymentResult, type VerifyResult, type WalletHandle, type WalletInput, WrongChainError, WrongFamilyError, type X402AcceptEntry, type X402Challenge, type X402InvalidBody, type X402PaymentSignature, type X402Receipt, type X402ResourceObject, type XrplToken, buildChallengeHeader, buildExactAuthorization, buildReceiptHeader, buildSignatureHeader, chainIdForExactNetwork, createPaymentGate, encodeXPaymentHeader, evaluatePolicy, parseChallenge, parseExactRequirements, parseReceipt, parseSignatureHeader, paymentTools, pickAccept, registerDriver, requirePayment, resolveChain, toInsufficientFundsError, toInvalidBody };