web3-tools-mcp 3.1.0 → 3.2.0

package/dist/chains.d.ts

@@ -8,13 +8,18 @@ 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. */
+    /** False where Alchemy serves the RPC but not its token API, which `get_portfolio` needs. */
+    alchemyTokenApi?: false;
+    /** Used when no Alchemy key is configured, or Alchemy has no endpoint. */
     fallback: string;
     /** Block explorer domain, for links. Absent where there is nothing to link to. */
     explorer?: string;
     hypersync?: string;
+    /** DefiLlama's two names for the chain: the prefix of a coin id, and the `chain` of a yield pool. */
+    llama?: {
+        coins: string;
+        yields: string;
+    };
 }
 declare const TABLE: {
     readonly mainnet: {
@@ -71,10 +76,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "ethereum";
+            readonly yields: "Ethereum";
+        };
     };
     readonly arbitrum: {
         readonly chain: {
@@ -126,10 +134,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "arbitrum";
+            readonly yields: "Arbitrum";
+        };
     };
     readonly avalanche: {
         readonly chain: {
@@ -181,10 +192,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "avax";
+            readonly yields: "Avalanche";
+        };
     };
     readonly base: {
         readonly chain: {
@@ -297,6 +311,10 @@ declare const TABLE: {
         readonly fallback: "https://mainnet.base.org";
         readonly explorer: "basescan.org";
         readonly hypersync: "https://base.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "base";
+            readonly yields: "Base";
+        };
     };
     readonly bnb: {
         readonly chain: {
@@ -348,10 +366,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "bsc";
+            readonly yields: "BSC";
+        };
     };
     readonly gnosis: {
         readonly chain: {
@@ -407,59 +428,10 @@ declare const TABLE: {
         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 llama: {
+            readonly coins: "xdai";
+            readonly yields: "Gnosis";
         };
-        readonly alchemy: "sonic-mainnet";
-        readonly fallback: "https://rpc.soniclabs.com";
-        readonly explorer: "sonicscan.org";
-        readonly hypersync: "https://sonic.hypersync.xyz";
     };
     readonly optimism: {
         readonly chain: {
@@ -567,10 +539,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "optimism";
+            readonly yields: "OP Mainnet";
+        };
     };
     readonly polygon: {
         readonly chain: {
@@ -622,10 +597,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "polygon";
+            readonly yields: "Polygon";
+        };
     };
     readonly zksync: {
         readonly chain: {
@@ -714,10 +692,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "era";
+            readonly yields: "ZKsync Era";
+        };
     };
     readonly linea: {
         readonly chain: {
@@ -781,10 +762,13 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "linea";
+            readonly yields: "Linea";
+        };
     };
     readonly unichain: {
         readonly chain: {
@@ -887,10 +871,568 @@ declare const TABLE: {
             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 llama: {
+            readonly coins: "unichain";
+            readonly yields: "Unichain";
+        };
+    };
+    readonly monad: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Monadscan";
+                    readonly url: "https://monadscan.com";
+                    readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
+                };
+                readonly monadvision: {
+                    readonly name: "MonadVision";
+                    readonly url: "https://monadvision.com";
+                };
+            };
+            blockTime: 400;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 9248132;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 143;
+            name: "Monad";
+            nativeCurrency: {
+                readonly name: "Monad";
+                readonly symbol: "MON";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
+                    readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
+                };
+            };
+            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: "monad-mainnet";
+        readonly fallback: "https://rpc.monad.xyz";
+        readonly explorer: "monadscan.com";
+        readonly hypersync: "https://monad.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "monad";
+            readonly yields: "Monad";
+        };
+    };
+    readonly robinhood: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Blockscout";
+                    readonly url: "https://robinhoodchain.blockscout.com";
+                    readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
+                };
+            };
+            blockTime: 100;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 4663;
+            name: "Robinhood Chain";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com", "https://rpc.ordofi.network"];
+                    readonly webSocket: readonly ["wss://rpc.ordofi.network"];
+                };
+            };
+            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: "robinhood-mainnet";
+        readonly fallback: "https://rpc.mainnet.chain.robinhood.com";
+        readonly explorer: "robinhoodchain.blockscout.com";
+        readonly hypersync: "https://robinhood.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "robinhood";
+            readonly yields: "Robinhood Chain";
+        };
+    };
+    readonly arc: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Arc Explorer";
+                    readonly url: "https://explorer.arc.io";
+                    readonly apiUrl: "https://explorer.arc.io/api/v2";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 0;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 5042;
+            name: "Arc";
+            nativeCurrency: {
+                readonly name: "USDC";
+                readonly symbol: "USDC";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.mainnet.arc.io", "https://rpc.blockdaemon.mainnet.arc.io", "https://rpc.drpc.mainnet.arc.io", "https://rpc.quicknode.mainnet.arc.io"];
+                };
+            };
+            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: "arc-mainnet";
+        readonly fallback: "https://rpc.mainnet.arc.io";
+        readonly explorer: "explorer.arc.io";
+        readonly hypersync: "https://arc.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "arc";
+            readonly yields: "Arc";
+        };
+    };
+    readonly plasma: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "PlasmaScan";
+                    readonly url: "https://plasmascan.to";
+                };
+            };
+            blockTime: 1000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 0;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 9745;
+            name: "Plasma";
+            nativeCurrency: {
+                readonly name: "Plasma";
+                readonly symbol: "XPL";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.plasma.to"];
+                };
+            };
+            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: "plasma-mainnet";
+        readonly alchemyTokenApi: false;
+        readonly fallback: "https://rpc.plasma.to";
+        readonly explorer: "plasmascan.to";
+        readonly hypersync: "https://plasma.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "plasma";
+            readonly yields: "Plasma";
+        };
+    };
+    readonly ink: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Blockscout";
+                    readonly url: "https://explorer.inkonchain.com";
+                    readonly apiUrl: "https://explorer.inkonchain.com/api/v2";
+                };
+            };
+            blockTime: 2000;
+            contracts: {
+                readonly disputeGameFactory: {
+                    readonly 1: {
+                        readonly address: "0x10d7b35078d3baabb96dd45a9143b94be65b12cd";
+                    };
+                };
+                readonly portal: {
+                    readonly 1: {
+                        readonly address: "0x5d66c1782664115999c47c9fa5cd031f495d3e4f";
+                    };
+                };
+                readonly l1StandardBridge: {
+                    readonly 1: {
+                        readonly address: "0x88ff1e5b602916615391f55854588efcbb7663f0";
+                    };
+                };
+                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";
+                };
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 0;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 57073;
+            name: "Ink";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc-gel.inkonchain.com", "https://rpc-qnd.inkonchain.com"];
+                    readonly webSocket: readonly ["wss://rpc-gel.inkonchain.com", "wss://rpc-qnd.inkonchain.com"];
+                };
+            };
+            sourceId: 1;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet: false;
+            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: "ink-mainnet";
+        readonly fallback: "https://rpc-gel.inkonchain.com";
+        readonly explorer: "explorer.inkonchain.com";
+        readonly hypersync: "https://ink.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "ink";
+            readonly yields: "Ink";
+        };
+    };
+    readonly mantle: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Mantle Explorer";
+                    readonly url: "https://mantlescan.xyz/";
+                    readonly apiUrl: "https://api.mantlescan.xyz/api";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 304717;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 5000;
+            name: "Mantle";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "MNT";
+                readonly symbol: "MNT";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.mantle.xyz"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            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: "mantle-mainnet";
+        readonly alchemyTokenApi: false;
+        readonly fallback: "https://rpc.mantle.xyz";
+        readonly explorer: "mantlescan.xyz";
+        readonly hypersync: "https://mantle.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "mantle";
+            readonly yields: "Mantle";
+        };
+    };
+    readonly celo: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Celo Explorer";
+                    readonly url: "https://celoscan.io";
+                    readonly apiUrl: "https://api.celoscan.io/api";
+                };
+            };
+            blockTime: 1000;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 13112599;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 42220;
+            name: "Celo";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "CELO";
+                readonly symbol: "CELO";
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://forno.celo.org"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+            testnet: false;
+            custom?: Record<string, unknown> | undefined;
+            extendSchema?: Record<string, unknown> | undefined;
+            fees: import("viem").ChainFees<{
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloRpcBlock, action?: string | undefined) => import("viem/chains").CeloBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloRpcTransaction, action?: string | undefined) => import("viem/chains").CeloTransaction;
+                    type: "transaction";
+                };
+                readonly transactionRequest: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloTransactionRequest, action?: string | undefined) => import("viem/chains").CeloRpcTransactionRequest;
+                    type: "transactionRequest";
+                };
+            }>;
+            formatters: {
+                readonly block: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloRpcBlock, action?: string | undefined) => import("viem/chains").CeloBlock;
+                    type: "block";
+                };
+                readonly transaction: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloRpcTransaction, action?: string | undefined) => import("viem/chains").CeloTransaction;
+                    type: "transaction";
+                };
+                readonly transactionRequest: {
+                    exclude: [] | undefined;
+                    format: (args: import("viem/chains").CeloTransactionRequest, action?: string | undefined) => import("viem/chains").CeloRpcTransactionRequest;
+                    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/chains").serializeTransactionCelo;
+            };
+            verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+        };
+        readonly alchemy: "celo-mainnet";
+        readonly fallback: "https://forno.celo.org";
+        readonly explorer: "celoscan.io";
+        readonly hypersync: "https://celo.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "celo";
+            readonly yields: "Celo";
+        };
+    };
+    readonly hyperevm: {
+        readonly chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "HyperEVMScan";
+                    readonly url: "https://hyperevmscan.io";
+                };
+            };
+            blockTime?: number | undefined | undefined;
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 13051;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 999;
+            name: "HyperEVM";
+            nativeCurrency: {
+                readonly name: "HYPE";
+                readonly symbol: "HYPE";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
+                };
+            };
+            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: "hyperliquid-mainnet";
+        readonly fallback: "https://rpc.hyperliquid.xyz/evm";
+        readonly explorer: "hyperevmscan.io";
+        readonly hypersync: "https://hyperliquid.hypersync.xyz";
+        readonly llama: {
+            readonly coins: "hyperliquid";
+            readonly yields: "Hyperliquid L1";
+        };
     };
     readonly localhost: {
         readonly chain: {
@@ -912,7 +1454,9 @@ declare const TABLE: {
                     [sourceId: number]: import("viem").ChainContract | undefined;
                 } | undefined;
                 ensRegistry?: import("viem").ChainContract | undefined;
-                ensUniversalResolver?: import("viem").ChainContract | undefined;
+                ensUniversalResolver
+                /** False where Alchemy serves the RPC but not its token API, which `get_portfolio` needs. */
+                ? /** False where Alchemy serves the RPC but not its token API, which `get_portfolio` needs. */: import("viem").ChainContract | undefined;
                 multicall3?: import("viem").ChainContract | undefined;
                 erc6492Verifier?: import("viem").ChainContract | undefined;
             } | undefined;