@funkit/chains 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,3790 @@
+export declare const DYDX_MAINNET_CHAIN_ID = 1511490300;
+export declare const dydxChain: {
+    id: number;
+    name: string;
+    nativeCurrency: {
+        symbol: string;
+        decimals: number;
+        name: string;
+    };
+    rpcUrls: {
+        default: {
+            http: string[];
+        };
+    };
+    blockExplorers: {
+        default: {
+            name: string;
+            url: string;
+            apiUrl: string;
+        };
+    };
+    contracts: {
+        ensRegistry: {
+            address: `0x${string}`;
+        };
+        ensUniversalResolver: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+        multicall3: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+    };
+};
+/**
+ * Info on the supported chains of FunkitConnect
+ * Added into coresdk because it is used in here too.
+ *
+ * fallbackRpcUrl: see https://chainlist.org/ for more public RPC endpoints
+ */
+export declare const FUNKIT_CONNECT_SUPPORTED_CHAINS_INFO: {
+    [x: string]: {
+        name: "Ethereum";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            contracts: {
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+                    readonly blockCreated: 19258213;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://cloudflare-eth.com"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem" /** MAINNETS **/).ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+        coreToken?: undefined;
+    } | {
+        name: "Base";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Basescan";
+                    readonly url: "https://basescan.org";
+                    readonly apiUrl: "https://api.basescan.org/api";
+                };
+            };
+            contracts: {
+                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";
+                };
+            };
+            id: 8453;
+            name: "Base";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.base.org"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcBlock) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: import("viem").Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: import("viem").Address;
+                        mixHash: import("viem").Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentHash: import("viem").Hash;
+                        receiptsRoot: import("viem").Hex;
+                        sealFields: import("viem").Hex[];
+                        sha3Uncles: import("viem").Hash;
+                        size: bigint;
+                        stateRoot: import("viem").Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                        transactionsRoot: import("viem").Hash;
+                        uncles: import("viem").Hash[];
+                        withdrawals?: import("viem").Withdrawal[] | undefined;
+                        withdrawalsRoot?: import("viem").Hex | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined;
+                        sourceHash: import("viem").Hex;
+                        type: "deposit";
+                    } | {
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        v: bigint;
+                        to: import("viem").Address | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        accessList?: undefined;
+                        blobVersionedHashes?: undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes: readonly import("viem").Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: import("viem").Hash;
+                        blockNumber: bigint;
+                        contractAddress: import("viem").Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: import("viem").Address;
+                        gasUsed: bigint;
+                        logs: import("viem").Log<bigint, number, false>[];
+                        logsBloom: import("viem").Hex;
+                        root?: import("viem").Hash | undefined;
+                        status: "success" | "reverted";
+                        to: import("viem").Address | null;
+                        transactionHash: import("viem").Hash;
+                        transactionIndex: number;
+                        type: import("viem").TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            serializers: {
+                readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+            };
+        };
+        explorerInfo: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+            readonly apiUrl: "https://api.basescan.org/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+        coreToken?: undefined;
+    } | {
+        name: "Polygon";
+        nativeCurrency: {
+            symbol: "MATIC";
+            decimals: 18;
+            name: "MATIC";
+        };
+        coreToken: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "PolygonScan";
+                    readonly url: "https://polygonscan.com";
+                    readonly apiUrl: "https://api.polygonscan.com/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 25770160;
+                };
+            };
+            id: 137;
+            name: "Polygon";
+            nativeCurrency: {
+                readonly name: "MATIC";
+                readonly symbol: "MATIC";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://polygon-rpc.com"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "PolygonScan";
+            readonly url: "https://polygonscan.com";
+            readonly apiUrl: "https://api.polygonscan.com/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+    } | {
+        name: string;
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        coreToken: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Arbiscan";
+                    readonly url: "https://arbiscan.io";
+                    readonly apiUrl: "https://api.arbiscan.io/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 7654707;
+                };
+            };
+            id: 42161;
+            name: "Arbitrum One";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+            readonly apiUrl: "https://api.arbiscan.io/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+    } | {
+        name: "OP Mainnet";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        coreToken: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Optimism Explorer";
+                    readonly url: "https://optimistic.etherscan.io";
+                    readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+                };
+            };
+            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";
+                };
+            };
+            id: 10;
+            name: "OP Mainnet";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.optimism.io"];
+                };
+            };
+            sourceId: 1;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcBlock) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: import("viem").Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: import("viem").Address;
+                        mixHash: import("viem").Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentHash: import("viem").Hash;
+                        receiptsRoot: import("viem").Hex;
+                        sealFields: import("viem").Hex[];
+                        sha3Uncles: import("viem").Hash;
+                        size: bigint;
+                        stateRoot: import("viem").Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                        transactionsRoot: import("viem").Hash;
+                        uncles: import("viem").Hash[];
+                        withdrawals?: import("viem").Withdrawal[] | undefined;
+                        withdrawalsRoot?: import("viem").Hex | undefined;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: boolean;
+                        mint?: bigint | undefined;
+                        sourceHash: import("viem").Hex;
+                        type: "deposit";
+                    } | {
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        v: bigint;
+                        to: import("viem").Address | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        accessList?: undefined;
+                        blobVersionedHashes?: undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes: readonly import("viem").Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        isSystemTx?: undefined;
+                        mint?: undefined;
+                        sourceHash?: undefined;
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                        blobGasPrice?: bigint | undefined;
+                        blobGasUsed?: bigint | undefined;
+                        blockHash: import("viem").Hash;
+                        blockNumber: bigint;
+                        contractAddress: import("viem").Address | null | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        from: import("viem").Address;
+                        gasUsed: bigint;
+                        logs: import("viem").Log<bigint, number, false>[];
+                        logsBloom: import("viem").Hex;
+                        root?: import("viem").Hash | undefined;
+                        status: "success" | "reverted";
+                        to: import("viem").Address | null;
+                        transactionHash: import("viem").Hash;
+                        transactionIndex: number;
+                        type: import("viem").TransactionType;
+                        l1GasPrice: bigint | null;
+                        l1GasUsed: bigint | null;
+                        l1Fee: bigint | null;
+                        l1FeeScalar: number | null;
+                    } & {};
+                    type: "transactionReceipt";
+                };
+            };
+            serializers: {
+                readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+            };
+        };
+        explorerInfo: {
+            readonly name: "Optimism Explorer";
+            readonly url: "https://optimistic.etherscan.io";
+            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: never[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+    } | {
+        name: string;
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        coreToken: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://era.zksync.network/";
+                    readonly apiUrl: "https://api-era.zksync.network/api";
+                };
+                readonly native: {
+                    readonly name: "zkSync Explorer";
+                    readonly url: "https://explorer.zksync.io/";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+                };
+            };
+            id: 324;
+            name: "zkSync Era";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.era.zksync.io"];
+                    readonly webSocket: readonly ["wss://mainnet.era.zksync.io/ws"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom: {
+                readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
+            };
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").ZkSyncRpcBlock) => {
+                        baseFeePerGas: bigint | null;
+                        blobGasUsed: bigint;
+                        difficulty: bigint;
+                        excessBlobGas: bigint;
+                        extraData: import("viem").Hex;
+                        gasLimit: bigint;
+                        gasUsed: bigint;
+                        hash: `0x${string}` | null;
+                        logsBloom: `0x${string}` | null;
+                        miner: import("viem").Address;
+                        mixHash: import("viem").Hash;
+                        nonce: `0x${string}` | null;
+                        number: bigint | null;
+                        parentHash: import("viem").Hash;
+                        receiptsRoot: import("viem").Hex;
+                        sealFields: import("viem").Hex[];
+                        sha3Uncles: import("viem").Hash;
+                        size: bigint;
+                        stateRoot: import("viem").Hash;
+                        timestamp: bigint;
+                        totalDifficulty: bigint | null;
+                        transactions: `0x${string}`[] | import("viem/chains").ZkSyncTransaction<boolean>[];
+                        transactionsRoot: import("viem").Hash;
+                        uncles: import("viem").Hash[];
+                        withdrawals?: import("viem").Withdrawal[] | undefined;
+                        withdrawalsRoot?: import("viem").Hex | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTimestamp: bigint | null;
+                    } & {};
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").ZkSyncRpcTransaction) => ({
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        v: bigint;
+                        to: import("viem").Address | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        nonce: number;
+                        value: bigint;
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        accessList?: undefined;
+                        blobVersionedHashes?: undefined;
+                        chainId?: number | undefined;
+                        yParity?: undefined;
+                        type: "legacy";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip2930";
+                        gasPrice: bigint;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes?: undefined;
+                        chainId: number;
+                        type: "eip1559";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        accessList: import("viem").AccessList;
+                        blobVersionedHashes: readonly import("viem").Hex[];
+                        chainId: number;
+                        type: "eip4844";
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas: bigint;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        type: "priority";
+                    } | {
+                        blockHash: `0x${string}` | null;
+                        blockNumber: bigint | null;
+                        from: import("viem").Address;
+                        gas: bigint;
+                        hash: import("viem").Hash;
+                        input: import("viem").Hex;
+                        nonce: number;
+                        r: import("viem").Hex;
+                        s: import("viem").Hex;
+                        to: import("viem").Address | null;
+                        transactionIndex: number | null;
+                        typeHex: import("viem").Hex | null;
+                        v: bigint;
+                        value: bigint;
+                        yParity: number;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas: bigint;
+                        maxPriorityFeePerGas: bigint;
+                        type: "eip712" | "priority";
+                    }) & {};
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/_types/zksync/types/transaction").ZkSyncRpcTransactionReceipt) => {
+                        type: import("viem/chains").ZkSyncTransactionType;
+                        to: import("viem").Address | null;
+                        from: import("viem").Address;
+                        blockHash: import("viem").Hash;
+                        blockNumber: bigint;
+                        transactionIndex: number;
+                        status: "success" | "reverted";
+                        logsBloom: import("viem").Hex;
+                        blobGasUsed?: bigint | undefined;
+                        gasUsed: bigint;
+                        contractAddress: import("viem").Address | null | undefined;
+                        transactionHash: import("viem").Hash;
+                        blobGasPrice?: bigint | undefined;
+                        cumulativeGasUsed: bigint;
+                        effectiveGasPrice: bigint;
+                        root?: import("viem").Hash | undefined;
+                        l1BatchNumber: bigint | null;
+                        l1BatchTxIndex: bigint | null;
+                        logs: import("viem/chains").ZkSyncLog[];
+                        l2ToL1Logs: import("viem/chains").ZkSyncL2ToL1Log[];
+                    } & {};
+                    type: "transactionReceipt";
+                };
+                readonly transactionRequest: {
+                    exclude: ("gasPerPubdata" | "paymaster" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+                    format: (args: import("viem/chains").ZkSyncTransactionRequest) => ({
+                        data?: import("viem").Hex | undefined;
+                        from: import("viem").Address;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: import("viem").Address | null | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: undefined;
+                        blobs?: undefined;
+                        type?: "0x0" | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        eip712Meta?: undefined;
+                    } | {
+                        data?: import("viem").Hex | undefined;
+                        from: import("viem").Address;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: import("viem").Address | null | undefined;
+                        value?: `0x${string}` | undefined;
+                        accessList?: import("viem").AccessList | undefined;
+                        blobs?: undefined;
+                        type?: "0x1" | undefined;
+                        gasPrice?: `0x${string}` | undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: undefined;
+                        maxPriorityFeePerGas?: undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        eip712Meta?: undefined;
+                    } | {
+                        data?: import("viem").Hex | undefined;
+                        from: import("viem").Address;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: import("viem").Address | null | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        accessList?: import("viem").AccessList | undefined;
+                        blobs?: undefined;
+                        type?: "0x2" | undefined;
+                        blobVersionedHashes?: undefined;
+                        kzg?: undefined;
+                        sidecars?: undefined;
+                        eip712Meta?: undefined;
+                    } | {
+                        data?: import("viem").Hex | undefined;
+                        from: import("viem").Address;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        value?: `0x${string}` | undefined;
+                        to: `0x${string}` | null;
+                        accessList?: import("viem").AccessList | undefined;
+                        blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
+                        blobVersionedHashes?: readonly import("viem").Hex[] | undefined;
+                        kzg?: import("viem").Kzg | undefined;
+                        sidecars?: readonly import("viem").BlobSidecar<import("viem").Hex>[] | undefined;
+                        type?: "0x3" | undefined;
+                        gasPrice?: undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        maxFeePerBlobGas: `0x${string}`;
+                        eip712Meta?: undefined;
+                    } | {
+                        data?: import("viem").Hex | undefined;
+                        from: import("viem").Address;
+                        gas?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | undefined;
+                        to?: import("viem").Address | null | undefined;
+                        value?: `0x${string}` | undefined;
+                        gasPrice?: undefined;
+                        maxFeePerBlobGas?: undefined;
+                        maxFeePerGas?: `0x${string}` | undefined;
+                        maxPriorityFeePerGas?: `0x${string}` | undefined;
+                        eip712Meta: import("viem/chains").ZkSyncEip712Meta;
+                        type: "0x71" | "0xff";
+                    }) & {
+                        gasPerPubdata: never;
+                        paymaster: never;
+                        factoryDeps: never;
+                        paymasterInput: never;
+                        customSignature: never;
+                    };
+                    type: "transactionRequest";
+                };
+            };
+            serializers: {
+                readonly transaction: typeof import("viem/zksync").serializeTransaction;
+            };
+            readonly network: "zksync-era";
+        };
+        explorerInfo: {
+            readonly name: "Etherscan";
+            readonly url: "https://era.zksync.network/";
+            readonly apiUrl: "https://api-era.zksync.network/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+    } | {
+        name: "Mantle";
+        nativeCurrency: {
+            symbol: "MNT";
+            decimals: 18;
+            name: "MNT";
+        };
+        coreToken: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Mantle Explorer";
+                    readonly url: "https://mantlescan.xyz/";
+                    readonly apiUrl: "https://api.mantlescan.xyz/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 304717;
+                };
+            };
+            id: 5000;
+            name: "Mantle";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "MNT";
+                readonly symbol: "MNT";
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.mantle.xyz"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "Mantle Explorer";
+            readonly url: "https://mantlescan.xyz/";
+            readonly apiUrl: "https://api.mantlescan.xyz/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+    } | {
+        name: string;
+        nativeCurrency: {
+            symbol: string;
+            decimals: number;
+            name: string;
+        };
+        chainInfo: {
+            id: number;
+            name: string;
+            nativeCurrency: {
+                symbol: string;
+                decimals: number;
+                name: string;
+            };
+            rpcUrls: {
+                default: {
+                    http: string[];
+                };
+            };
+            blockExplorers: {
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl: string;
+                };
+            };
+            contracts: {
+                ensRegistry: {
+                    address: `0x${string}`;
+                };
+                ensUniversalResolver: {
+                    address: `0x${string}`;
+                    blockCreated: number;
+                };
+                multicall3: {
+                    address: `0x${string}`;
+                    blockCreated: number;
+                };
+            };
+        };
+        explorerInfo: {
+            name: string;
+            url: string;
+            apiUrl: string;
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: never[];
+        coreToken?: undefined;
+    } | {
+        name: "Scroll";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Ether";
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Scrollscan";
+                    readonly url: "https://scrollscan.com";
+                    readonly apiUrl: "https://api.scrollscan.com/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14;
+                };
+            };
+            id: 534352;
+            name: "Scroll";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.scroll.io"];
+                    readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "Scrollscan";
+            readonly url: "https://scrollscan.com";
+            readonly apiUrl: "https://api.scrollscan.com/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: string;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: string[];
+        coreToken?: undefined;
+    } | {
+        name: "Goerli";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Goerli Ether";
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://goerli.etherscan.io";
+                    readonly apiUrl: "https://api-goerli.etherscan.io/api";
+                };
+            };
+            contracts: {
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1";
+                    readonly blockCreated: 10339206;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 6507670;
+                };
+            };
+            id: 5;
+            name: "Goerli";
+            nativeCurrency: {
+                readonly name: "Goerli Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.ankr.com/eth_goerli"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet: true;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            readonly name: "Etherscan";
+            readonly url: "https://goerli.etherscan.io";
+            readonly apiUrl: "https://api-goerli.etherscan.io/api";
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: null;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: never[];
+        coreToken?: undefined;
+    } | {
+        name: "Arbitrum Sepolia";
+        nativeCurrency: {
+            symbol: "ETH";
+            decimals: 18;
+            name: "Arbitrum Sepolia Ether";
+        };
+        chainInfo: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Arbiscan";
+                    readonly url: "https://sepolia.arbiscan.io";
+                    readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 81930;
+                };
+            };
+            id: 421614;
+            name: "Arbitrum Sepolia";
+            nativeCurrency: {
+                readonly name: "Arbitrum Sepolia Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet: true;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        };
+        explorerInfo: {
+            name: string;
+            url: string;
+        };
+        isCheckoutSupported: boolean;
+        checkoutAssetWhitelist: string[];
+        isFunWalletSupported: boolean;
+        isMainnet: boolean;
+        moonpayChainName: null;
+        pickPriority: number;
+        isStandardEvmAddress: boolean;
+        fallbackRpcUrls: never[];
+        coreToken?: undefined;
+    };
+};
+export declare const FUNKIT_CONNECT_SUPPORTED_CHAINS_ID_LIST: string[];
+export declare const FUNKIT_CONNECT_SUPPORTED_CHAINS_INFO_LIST: ({
+    id: number;
+    name: string;
+    nativeCurrency: {
+        symbol: string;
+        decimals: number;
+        name: string;
+    };
+    rpcUrls: {
+        default: {
+            http: string[];
+        };
+    };
+    blockExplorers: {
+        default: {
+            name: string;
+            url: string;
+            apiUrl: string;
+        };
+    };
+    contracts: {
+        ensRegistry: {
+            address: `0x${string}`;
+        };
+        ensUniversalResolver: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+        multicall3: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    contracts: {
+        readonly ensRegistry: {
+            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+            readonly blockCreated: 19258213;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://cloudflare-eth.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem" /** MAINNETS **/).ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+            readonly apiUrl: "https://api.basescan.org/api";
+        };
+    };
+    contracts: {
+        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";
+        };
+    };
+    id: 8453;
+    name: "Base";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.base.org"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined;
+                sourceHash: import("viem").Hex;
+                type: "deposit";
+            } | {
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: import("viem").Address;
+                gasUsed: bigint;
+                logs: import("viem").Log<bigint, number, false>[];
+                logsBloom: import("viem").Hex;
+                root?: import("viem").Hash | undefined;
+                status: "success" | "reverted";
+                to: import("viem").Address | null;
+                transactionHash: import("viem").Hash;
+                transactionIndex: number;
+                type: import("viem").TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PolygonScan";
+            readonly url: "https://polygonscan.com";
+            readonly apiUrl: "https://api.polygonscan.com/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 25770160;
+        };
+    };
+    id: 137;
+    name: "Polygon";
+    nativeCurrency: {
+        readonly name: "MATIC";
+        readonly symbol: "MATIC";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://polygon-rpc.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+            readonly apiUrl: "https://api.arbiscan.io/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 7654707;
+        };
+    };
+    id: 42161;
+    name: "Arbitrum One";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Optimism Explorer";
+            readonly url: "https://optimistic.etherscan.io";
+            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+        };
+    };
+    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";
+        };
+    };
+    id: 10;
+    name: "OP Mainnet";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.optimism.io"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined;
+                sourceHash: import("viem").Hex;
+                type: "deposit";
+            } | {
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: import("viem").Address;
+                gasUsed: bigint;
+                logs: import("viem").Log<bigint, number, false>[];
+                logsBloom: import("viem").Hex;
+                root?: import("viem").Hash | undefined;
+                status: "success" | "reverted";
+                to: import("viem").Address | null;
+                transactionHash: import("viem").Hash;
+                transactionIndex: number;
+                type: import("viem").TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://era.zksync.network/";
+            readonly apiUrl: "https://api-era.zksync.network/api";
+        };
+        readonly native: {
+            readonly name: "zkSync Explorer";
+            readonly url: "https://explorer.zksync.io/";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+        };
+    };
+    id: 324;
+    name: "zkSync Era";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.era.zksync.io"];
+            readonly webSocket: readonly ["wss://mainnet.era.zksync.io/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom: {
+        readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").ZkSyncRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").ZkSyncTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTimestamp: bigint | null;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").ZkSyncRpcTransaction) => ({
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "priority";
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "eip712" | "priority";
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/_types/zksync/types/transaction").ZkSyncRpcTransactionReceipt) => {
+                type: import("viem/chains").ZkSyncTransactionType;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                transactionIndex: number;
+                status: "success" | "reverted";
+                logsBloom: import("viem").Hex;
+                blobGasUsed?: bigint | undefined;
+                gasUsed: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                transactionHash: import("viem").Hash;
+                blobGasPrice?: bigint | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                root?: import("viem").Hash | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                logs: import("viem/chains").ZkSyncLog[];
+                l2ToL1Logs: import("viem/chains").ZkSyncL2ToL1Log[];
+            } & {};
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: ("gasPerPubdata" | "paymaster" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+            format: (args: import("viem/chains").ZkSyncTransactionRequest) => ({
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: undefined;
+                blobs?: undefined;
+                type?: "0x0" | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: import("viem").AccessList | undefined;
+                blobs?: undefined;
+                type?: "0x1" | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: import("viem").AccessList | undefined;
+                blobs?: undefined;
+                type?: "0x2" | undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                accessList?: import("viem").AccessList | undefined;
+                blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
+                blobVersionedHashes?: readonly import("viem").Hex[] | undefined;
+                kzg?: import("viem").Kzg | undefined;
+                sidecars?: readonly import("viem").BlobSidecar<import("viem").Hex>[] | undefined;
+                type?: "0x3" | undefined;
+                gasPrice?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                maxFeePerBlobGas: `0x${string}`;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                eip712Meta: import("viem/chains").ZkSyncEip712Meta;
+                type: "0x71" | "0xff";
+            }) & {
+                gasPerPubdata: never;
+                paymaster: never;
+                factoryDeps: never;
+                paymasterInput: never;
+                customSignature: never;
+            };
+            type: "transactionRequest";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/zksync").serializeTransaction;
+    };
+    readonly network: "zksync-era";
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Mantle Explorer";
+            readonly url: "https://mantlescan.xyz/";
+            readonly apiUrl: "https://api.mantlescan.xyz/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 304717;
+        };
+    };
+    id: 5000;
+    name: "Mantle";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "MNT";
+        readonly symbol: "MNT";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.mantle.xyz"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Scrollscan";
+            readonly url: "https://scrollscan.com";
+            readonly apiUrl: "https://api.scrollscan.com/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14;
+        };
+    };
+    id: 534352;
+    name: "Scroll";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.scroll.io"];
+            readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://goerli.etherscan.io";
+            readonly apiUrl: "https://api-goerli.etherscan.io/api";
+        };
+    };
+    contracts: {
+        readonly ensRegistry: {
+            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1";
+            readonly blockCreated: 10339206;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 6507670;
+        };
+    };
+    id: 5;
+    name: "Goerli";
+    nativeCurrency: {
+        readonly name: "Goerli Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.ankr.com/eth_goerli"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://sepolia.arbiscan.io";
+            readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 81930;
+        };
+    };
+    id: 421614;
+    name: "Arbitrum Sepolia";
+    nativeCurrency: {
+        readonly name: "Arbitrum Sepolia Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+})[];
+export declare const FUNKIT_CONNECT_SUPPORTED_CHECKOUT_CHAINS_INFO_LIST: ({
+    id: number;
+    name: string;
+    nativeCurrency: {
+        symbol: string;
+        decimals: number;
+        name: string;
+    };
+    rpcUrls: {
+        default: {
+            http: string[];
+        };
+    };
+    blockExplorers: {
+        default: {
+            name: string;
+            url: string;
+            apiUrl: string;
+        };
+    };
+    contracts: {
+        ensRegistry: {
+            address: `0x${string}`;
+        };
+        ensUniversalResolver: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+        multicall3: {
+            address: `0x${string}`;
+            blockCreated: number;
+        };
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    contracts: {
+        readonly ensRegistry: {
+            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+            readonly blockCreated: 19258213;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://cloudflare-eth.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+            readonly apiUrl: "https://api.basescan.org/api";
+        };
+    };
+    contracts: {
+        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";
+        };
+    };
+    id: 8453;
+    name: "Base";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.base.org"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined;
+                sourceHash: import("viem").Hex;
+                type: "deposit";
+            } | {
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: import("viem").Address;
+                gasUsed: bigint;
+                logs: import("viem").Log<bigint, number, false>[];
+                logsBloom: import("viem").Hex;
+                root?: import("viem").Hash | undefined;
+                status: "success" | "reverted";
+                to: import("viem").Address | null;
+                transactionHash: import("viem").Hash;
+                transactionIndex: number;
+                type: import("viem").TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PolygonScan";
+            readonly url: "https://polygonscan.com";
+            readonly apiUrl: "https://api.polygonscan.com/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 25770160;
+        };
+    };
+    id: 137;
+    name: "Polygon";
+    nativeCurrency: {
+        readonly name: "MATIC";
+        readonly symbol: "MATIC";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://polygon-rpc.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+            readonly apiUrl: "https://api.arbiscan.io/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 7654707;
+        };
+    };
+    id: 42161;
+    name: "Arbitrum One";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Optimism Explorer";
+            readonly url: "https://optimistic.etherscan.io";
+            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+        };
+    };
+    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";
+        };
+    };
+    id: 10;
+    name: "OP Mainnet";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.optimism.io"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined;
+                sourceHash: import("viem").Hex;
+                type: "deposit";
+            } | {
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: import("viem").Address;
+                gasUsed: bigint;
+                logs: import("viem").Log<bigint, number, false>[];
+                logsBloom: import("viem").Hex;
+                root?: import("viem").Hash | undefined;
+                status: "success" | "reverted";
+                to: import("viem").Address | null;
+                transactionHash: import("viem").Hash;
+                transactionIndex: number;
+                type: import("viem").TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+    };
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://era.zksync.network/";
+            readonly apiUrl: "https://api-era.zksync.network/api";
+        };
+        readonly native: {
+            readonly name: "zkSync Explorer";
+            readonly url: "https://explorer.zksync.io/";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+        };
+    };
+    id: 324;
+    name: "zkSync Era";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.era.zksync.io"];
+            readonly webSocket: readonly ["wss://mainnet.era.zksync.io/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom: {
+        readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").ZkSyncRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("viem").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("viem").Address;
+                mixHash: import("viem").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentHash: import("viem").Hash;
+                receiptsRoot: import("viem").Hex;
+                sealFields: import("viem").Hex[];
+                sha3Uncles: import("viem").Hash;
+                size: bigint;
+                stateRoot: import("viem").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("viem/chains").ZkSyncTransaction<boolean>[];
+                transactionsRoot: import("viem").Hash;
+                uncles: import("viem").Hash[];
+                withdrawals?: import("viem").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("viem").Hex | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTimestamp: bigint | null;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("viem/chains").ZkSyncRpcTransaction) => ({
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                v: bigint;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                accessList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("viem").AccessList;
+                blobVersionedHashes: readonly import("viem").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "priority";
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("viem").Address;
+                gas: bigint;
+                hash: import("viem").Hash;
+                input: import("viem").Hex;
+                nonce: number;
+                r: import("viem").Hex;
+                s: import("viem").Hex;
+                to: import("viem").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("viem").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "eip712" | "priority";
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/_types/zksync/types/transaction").ZkSyncRpcTransactionReceipt) => {
+                type: import("viem/chains").ZkSyncTransactionType;
+                to: import("viem").Address | null;
+                from: import("viem").Address;
+                blockHash: import("viem").Hash;
+                blockNumber: bigint;
+                transactionIndex: number;
+                status: "success" | "reverted";
+                logsBloom: import("viem").Hex;
+                blobGasUsed?: bigint | undefined;
+                gasUsed: bigint;
+                contractAddress: import("viem").Address | null | undefined;
+                transactionHash: import("viem").Hash;
+                blobGasPrice?: bigint | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                root?: import("viem").Hash | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                logs: import("viem/chains").ZkSyncLog[];
+                l2ToL1Logs: import("viem/chains").ZkSyncL2ToL1Log[];
+            } & {};
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: ("gasPerPubdata" | "paymaster" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+            format: (args: import("viem/chains").ZkSyncTransactionRequest) => ({
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: undefined;
+                blobs?: undefined;
+                type?: "0x0" | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: import("viem").AccessList | undefined;
+                blobs?: undefined;
+                type?: "0x1" | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: import("viem").AccessList | undefined;
+                blobs?: undefined;
+                type?: "0x2" | undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                accessList?: import("viem").AccessList | undefined;
+                blobs: readonly import("viem").Hex[] | readonly import("viem").ByteArray[];
+                blobVersionedHashes?: readonly import("viem").Hex[] | undefined;
+                kzg?: import("viem").Kzg | undefined;
+                sidecars?: readonly import("viem").BlobSidecar<import("viem").Hex>[] | undefined;
+                type?: "0x3" | undefined;
+                gasPrice?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                maxFeePerBlobGas: `0x${string}`;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("viem").Hex | undefined;
+                from: import("viem").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("viem").Address | null | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                eip712Meta: import("viem/chains").ZkSyncEip712Meta;
+                type: "0x71" | "0xff";
+            }) & {
+                gasPerPubdata: never;
+                paymaster: never;
+                factoryDeps: never;
+                paymasterInput: never;
+                customSignature: never;
+            };
+            type: "transactionRequest";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("viem/zksync").serializeTransaction;
+    };
+    readonly network: "zksync-era";
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Mantle Explorer";
+            readonly url: "https://mantlescan.xyz/";
+            readonly apiUrl: "https://api.mantlescan.xyz/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 304717;
+        };
+    };
+    id: 5000;
+    name: "Mantle";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "MNT";
+        readonly symbol: "MNT";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.mantle.xyz"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Scrollscan";
+            readonly url: "https://scrollscan.com";
+            readonly apiUrl: "https://api.scrollscan.com/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14;
+        };
+    };
+    id: 534352;
+    name: "Scroll";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.scroll.io"];
+            readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://goerli.etherscan.io";
+            readonly apiUrl: "https://api-goerli.etherscan.io/api";
+        };
+    };
+    contracts: {
+        readonly ensRegistry: {
+            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xfc4AC75C46C914aF5892d6d3eFFcebD7917293F1";
+            readonly blockCreated: 10339206;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 6507670;
+        };
+    };
+    id: 5;
+    name: "Goerli";
+    nativeCurrency: {
+        readonly name: "Goerli Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.ankr.com/eth_goerli"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://sepolia.arbiscan.io";
+            readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 81930;
+        };
+    };
+    id: 421614;
+    name: "Arbitrum Sepolia";
+    nativeCurrency: {
+        readonly name: "Arbitrum Sepolia Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+})[];
+export declare const FUNKIT_CONNECT_CHECKOUT_NATIVE_CURRENCY_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+//# sourceMappingURL=index.d.ts.map