web3-tools-mcp 1.5.0 → 2.0.0

package/dist/chains.d.ts

@@ -0,0 +1,960 @@
+import type { Chain } from 'viem';
+/**
+ * Every chain this server knows, in one table. Adding one here is the whole change: the
+ * `ChainName` union, the tool schemas, RPC selection, explorer links, Hypersync routing and
+ * the `--help` listing are all derived from it.
+ */
+interface ChainInfo {
+    chain: Chain;
+    /** Subdomain under g.alchemy.com; absent where Alchemy has no endpoint. */
+    alchemy?: string;
+    /** Subdomain under infura.io; absent where Infura has no endpoint. */
+    infura?: string;
+    /** Used when no provider key is configured. */
+    fallback: string;
+    /** Block explorer domain, for links. Absent where there is nothing to link to. */
+    explorer?: string;
+    hypersync?: string;
+}
+declare const TABLE: {
+    readonly mainnet: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            blockTime: 12000;
+            contracts: {
+                readonly ensUniversalResolver: {
+                    readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                    readonly blockCreated: 23085558;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://ethereum.reth.rs/rpc"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "eth-mainnet";
+        readonly infura: "mainnet";
+        readonly fallback: "https://ethereum-rpc.publicnode.com";
+        readonly explorer: "etherscan.io";
+        readonly hypersync: "https://eth.hypersync.xyz";
+    };
+    readonly arbitrum: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Arbiscan";
+                    readonly url: "https://arbiscan.io";
+                    readonly apiUrl: "https://api.arbiscan.io/api";
+                };
+            };
+            blockTime: 250;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 7654707;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 42161;
+            name: "Arbitrum One";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "arb-mainnet";
+        readonly infura: "arbitrum-mainnet";
+        readonly fallback: "https://arb1.arbitrum.io/rpc";
+        readonly explorer: "arbiscan.io";
+        readonly hypersync: "https://arbitrum.hypersync.xyz";
+    };
+    readonly avalanche: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "SnowTrace";
+                    readonly url: "https://snowtrace.io";
+                    readonly apiUrl: "https://api.snowtrace.io";
+                };
+            };
+            blockTime: 1700;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 11907934;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 43114;
+            name: "Avalanche";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Avalanche";
+                readonly symbol: "AVAX";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "avax-mainnet";
+        readonly infura: "avalanche-mainnet";
+        readonly fallback: "https://api.avax.network/ext/bc/C/rpc";
+        readonly explorer: "snowtrace.io";
+        readonly hypersync: "https://avalanche.hypersync.xyz";
+    };
+    readonly base: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Basescan";
+                    readonly url: "https://basescan.org";
+                    readonly apiUrl: "https://api.basescan.org/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 5022;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                        readonly blockCreated: 17482143;
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 8453;
+            name: "Base";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.base.org"];
+                };
+            };
+            sourceId: 1;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => import("viem/chains").OpStackBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => import("viem/chains").OpStackTransaction;
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => import("viem/chains").OpStackTransactionReceipt;
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "base-mainnet";
+        readonly fallback: "https://mainnet.base.org";
+        readonly explorer: "basescan.org";
+        readonly hypersync: "https://base.hypersync.xyz";
+    };
+    readonly bnb: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "BscScan";
+                    readonly url: "https://bscscan.com";
+                    readonly apiUrl: "https://api.bscscan.com/api";
+                };
+            };
+            blockTime: 750;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 15921452;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 56;
+            name: "BNB Smart Chain";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "BNB";
+                readonly symbol: "BNB";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://56.rpc.thirdweb.com"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "bnb-mainnet";
+        readonly infura: "bsc-mainnet";
+        readonly fallback: "https://bsc-dataseed.bnbchain.org";
+        readonly explorer: "bscscan.com";
+        readonly hypersync: "https://bsc.hypersync.xyz";
+    };
+    readonly gnosis: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Gnosisscan";
+                    readonly url: "https://gnosisscan.io";
+                    readonly apiUrl: "https://api.gnosisscan.io/api";
+                };
+            };
+            blockTime: 5000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 21022491;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 100;
+            name: "Gnosis";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "xDAI";
+                readonly symbol: "XDAI";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.gnosischain.com"];
+                    readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "gnosis-mainnet";
+        readonly fallback: "https://rpc.gnosischain.com";
+        readonly explorer: "gnosisscan.io";
+        readonly hypersync: "https://gnosis.hypersync.xyz";
+    };
+    readonly sonic: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Sonic Explorer";
+                    readonly url: "https://sonicscan.org";
+                };
+            };
+            blockTime: 630;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 60;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 146;
+            name: "Sonic";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Sonic";
+                readonly symbol: "S";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.soniclabs.com"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "sonic-mainnet";
+        readonly fallback: "https://rpc.soniclabs.com";
+        readonly explorer: "sonicscan.org";
+        readonly hypersync: "https://sonic.hypersync.xyz";
+    };
+    readonly optimism: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Optimism Explorer";
+                    readonly url: "https://optimistic.etherscan.io";
+                    readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+                    };
+                };
+                readonly l2OutputOracle: {
+                    readonly 1: {
+                        readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+                    };
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 4286263;
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 10;
+            name: "OP Mainnet";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.optimism.io"];
+                };
+            };
+            sourceId: 1;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => import("viem/chains").OpStackBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => import("viem/chains").OpStackTransaction;
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => import("viem/chains").OpStackTransactionReceipt;
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "opt-mainnet";
+        readonly infura: "optimism-mainnet";
+        readonly fallback: "https://mainnet.optimism.io";
+        readonly explorer: "optimistic.etherscan.io";
+        readonly hypersync: "https://optimism.hypersync.xyz";
+    };
+    readonly polygon: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "PolygonScan";
+                    readonly url: "https://polygonscan.com";
+                    readonly apiUrl: "https://api.etherscan.io/v2/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 25770160;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 137;
+            name: "Polygon";
+            nativeCurrency: {
+                readonly name: "POL";
+                readonly symbol: "POL";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://polygon.drpc.org"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "polygon-mainnet";
+        readonly infura: "polygon-mainnet";
+        readonly fallback: "https://polygon-bor-rpc.publicnode.com";
+        readonly explorer: "polygonscan.com";
+        readonly hypersync: "https://polygon.hypersync.xyz";
+    };
+    readonly zksync: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "ZKsync Explorer";
+                    readonly url: "https://explorer.zksync.io/";
+                    readonly apiUrl: "https://block-explorer-api.mainnet.zksync.io/api";
+                };
+            };
+            blockTime: 200;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xF9cda624FBC7e059355ce98a31693d299FACd963";
+                    readonly blockCreated: 3908235;
+                };
+                readonly erc6492Verifier: {
+                    readonly address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C";
+                    readonly blockCreated: 45659388;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 324;
+            name: "ZKsync Era";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.era.zksync.io"];
+                    readonly webSocket: readonly ["wss://mainnet.era.zksync.io/ws"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom: {
+                readonly getEip712Domain: import("viem/zksync").EIP712DomainFn<import("viem/chains").ZkSyncTransactionSerializable, import("viem/chains").ZkSyncEIP712TransactionSignable>;
+            };
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").ZkSyncRpcBlock, action?: string | undefined) => import("viem/chains").ZkSyncBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").ZkSyncRpcTransaction, action?: string | undefined) => import("viem/chains").ZkSyncTransaction;
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").ZkSyncRpcTransactionReceipt, action?: string | undefined) => import("viem/chains").ZkSyncTransactionReceipt;
+                    type: "transactionReceipt";
+                };
+                readonly transactionRequest: {
+                    exclude: ("paymaster" | "gasPerPubdata" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+                    format: (args: import("viem/chains").ZkSyncTransactionRequest, action?: string | undefined) => import("viem/chains").ZkSyncRpcTransactionRequest & {
+                        paymaster: never;
+                        gasPerPubdata: never;
+                        factoryDeps: never;
+                        paymasterInput: never;
+                        customSignature: never;
+                    };
+                    type: "transactionRequest";
+                };
+            };
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof import("viem/zksync").serializeTransaction;
+            };
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+            readonly network: "zksync-era";
+        };
+        readonly alchemy: "zksync-mainnet";
+        readonly infura: "zksync-mainnet";
+        readonly fallback: "https://mainnet.era.zksync.io";
+        readonly explorer: "era.zksync.network";
+        readonly hypersync: "https://zksync.hypersync.xyz";
+    };
+    readonly linea: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://lineascan.build";
+                    readonly apiUrl: "https://api.lineascan.build/api";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 42;
+                };
+                readonly ensRegistry: {
+                    readonly address: "0x50130b669B28C339991d8676FA73CF122a121267";
+                    readonly blockCreated: 6682888;
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0x4D41762915F83c76EcaF6776d9b08076aA32b492";
+                    readonly blockCreated: 22222151;
+                };
+            };
+            ensTlds: readonly [".linea.eth"];
+            id: 59144;
+            name: "Linea Mainnet";
+            nativeCurrency: {
+                readonly name: "Linea Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.linea.build"];
+                    readonly webSocket: readonly ["wss://rpc.linea.build"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees: {
+                readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<import("viem").ChainEstimateFeesPerGasFn>[0]) => ReturnType<import("viem").ChainEstimateFeesPerGasFn>;
+                readonly maxPriorityFeePerGas: ({ block, client, request }: import("viem").ChainFeesFnParameters<import("viem").ChainFormatters | undefined>) => Promise<bigint | null>;
+            };
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "linea-mainnet";
+        readonly infura: "linea-mainnet";
+        readonly fallback: "https://rpc.linea.build";
+        readonly explorer: "lineascan.build";
+        readonly hypersync: "https://linea.hypersync.xyz";
+    };
+    readonly unichain: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Uniscan";
+                    readonly url: "https://uniscan.xyz";
+                    readonly apiUrl: "https://api.uniscan.xyz/api";
+                };
+            };
+            blockTime: 1000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 0;
+                };
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
+                    };
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
+                    };
+                };
+                readonly gasPriceOracle: {
+                    readonly address: "0x420000000000000000000000000000000000000F";
+                };
+                readonly l1Block: {
+                    readonly address: "0x4200000000000000000000000000000000000015";
+                };
+                readonly l2CrossDomainMessenger: {
+                    readonly address: "0x4200000000000000000000000000000000000007";
+                };
+                readonly l2Erc721Bridge: {
+                    readonly address: "0x4200000000000000000000000000000000000014";
+                };
+                readonly l2StandardBridge: {
+                    readonly address: "0x4200000000000000000000000000000000000010";
+                };
+                readonly l2ToL1MessagePasser: {
+                    readonly address: "0x4200000000000000000000000000000000000016";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 130;
+            name: "Unichain";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://mainnet.unichain.org/"];
+                };
+            };
+            sourceId: 1;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => import("viem/chains").OpStackBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => import("viem/chains").OpStackTransaction;
+                    type: "transaction";
+                };
+                readonly transactionReceipt: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => import("viem/chains").OpStackTransactionReceipt;
+                    type: "transactionReceipt";
+                };
+            };
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers: {
+                readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+            };
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "unichain-mainnet";
+        readonly infura: "unichain-mainnet";
+        readonly fallback: "https://mainnet.unichain.org";
+        readonly explorer: "uniscan.xyz";
+        readonly hypersync: "https://unichain.hypersync.xyz";
+    };
+    readonly localhost: {
+        readonly chain: {
+            blockExplorers?: {
+                [key: string]: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+            } | undefined | undefined;
+            blockTime?: number | undefined | undefined;
+            contracts?: {
+                [x: string]: import("viem").ChainContract | {
+                    [sourceId: number]: import("viem").ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: import("viem").ChainContract | undefined;
+                ensUniversalResolver?: import("viem").ChainContract | undefined;
+                multicall3?: import("viem").ChainContract | undefined;
+                erc6492Verifier?: import("viem").ChainContract | undefined;
+            } | undefined;
+            ensTlds?: readonly string[] | undefined;
+            id: 1337;
+            name: "Localhost";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["http://127.0.0.1:8545"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+                client: import("viem").Client;
+                phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+            }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+                runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+            }] | undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly fallback: "http://localhost:8545";
+    };
+};
+export type ChainName = keyof typeof TABLE;
+export declare const CHAINS: Record<ChainName, ChainInfo>;
+/** Tuple rather than array, because `z.enum` needs a non-empty literal list. */
+export declare const SUPPORTED_CHAINS: [ChainName, ...ChainName[]];
+export {};
+//# sourceMappingURL=chains.d.ts.map