viem 2.24.2 → 2.25.0

package/_types/chains/definitions/swellchainTestnet.d.ts

@@ -0,0 +1,285 @@
+export declare const swellchainTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Swellchain Testnet Explorer";
+            readonly url: "https://swell-testnet-explorer.alt.technology";
+            readonly apiUrl: "https://swell-testnet-explorer.alt.technology/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 1;
+        };
+        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: 1924;
+    name: "Swellchain Testnet";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://swell-testnet.alt.technology"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").OpStackRpcBlock) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: import("../../index.js").Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: import("abitype").Address;
+                mixHash: import("../../index.js").Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: import("../../index.js").Hash;
+                receiptsRoot: import("../../index.js").Hex;
+                sealFields: import("../../index.js").Hex[];
+                sha3Uncles: import("../../index.js").Hash;
+                size: bigint;
+                stateRoot: import("../../index.js").Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | import("../index.js").OpStackTransaction<boolean>[];
+                transactionsRoot: import("../../index.js").Hash;
+                uncles: import("../../index.js").Hash[];
+                withdrawals?: import("../../index.js").Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").OpStackRpcTransaction) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                nonce: number;
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                to: import("abitype").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: import("../../index.js").Hex;
+                type: "deposit";
+            } | {
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                v: bigint;
+                to: import("abitype").Address | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                nonce: number;
+                value: bigint;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                nonce: number;
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                to: import("abitype").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("../../index.js").AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                nonce: number;
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                to: import("abitype").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("../../index.js").AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                nonce: number;
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                to: import("abitype").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("../../index.js").AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly import("../../index.js").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("abitype").Address;
+                gas: bigint;
+                hash: import("../../index.js").Hash;
+                input: import("../../index.js").Hex;
+                nonce: number;
+                r: import("../../index.js").Hex;
+                s: import("../../index.js").Hex;
+                to: import("abitype").Address | null;
+                transactionIndex: number | null;
+                typeHex: import("../../index.js").Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: import("../../index.js").AccessList;
+                authorizationList: import("../../index.js").SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").OpStackRpcTransactionReceipt) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: import("../../index.js").Hash;
+                blockNumber: bigint;
+                contractAddress: import("abitype").Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: import("abitype").Address;
+                gasUsed: bigint;
+                logs: import("../../index.js").Log<bigint, number, false>[];
+                logsBloom: import("../../index.js").Hex;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: import("abitype").Address | null;
+                transactionHash: import("../../index.js").Hash;
+                transactionIndex: number;
+                type: import("../../index.js").TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("../index.js").serializeTransactionOpStack;
+    };
+};
+//# sourceMappingURL=swellchainTestnet.d.ts.map

package/_types/chains/definitions/swellchainTestnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swellchainTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/swellchainTestnet.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB5B,CAAA"}

package/_types/chains/definitions/swissdlt.d.ts

@@ -14,6 +14,7 @@ export declare const swissdlt: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 94;
     name: "SwissDLT Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/swissdlt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swissdlt.d.ts","sourceRoot":"","sources":["../../../chains/definitions/swissdlt.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBnB,CAAA"}
+{"version":3,"file":"swissdlt.d.ts","sourceRoot":"","sources":["../../../chains/definitions/swissdlt.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBnB,CAAA"}

package/_types/chains/definitions/syscoin.d.ts

@@ -12,6 +12,7 @@ export declare const syscoin: {
             readonly blockCreated: 287139;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 57;
     name: "Syscoin Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/syscoin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syscoin.d.ts","sourceRoot":"","sources":["../../../chains/definitions/syscoin.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAA"}
+{"version":3,"file":"syscoin.d.ts","sourceRoot":"","sources":["../../../chains/definitions/syscoin.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAA"}

package/_types/chains/definitions/syscoinTestnet.d.ts

@@ -11,6 +11,7 @@ export declare const syscoinTestnet: {
             readonly blockCreated: 271288;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 5700;
     name: "Syscoin Tanenbaum Testnet";
     nativeCurrency: {

package/_types/chains/definitions/syscoinTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syscoinTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/syscoinTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzB,CAAA"}
+{"version":3,"file":"syscoinTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/syscoinTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzB,CAAA"}

package/_types/chains/definitions/taiko.d.ts

@@ -11,6 +11,7 @@ export declare const taiko: {
             readonly address: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D";
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 167000;
     name: "Taiko Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/taiko.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taiko.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taiko.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAA"}
+{"version":3,"file":"taiko.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taiko.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAA"}

package/_types/chains/definitions/taikoHekla.d.ts

@@ -11,6 +11,7 @@ export declare const taikoHekla: {
             readonly blockCreated: 59757;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 167009;
     name: "Taiko Hekla L2";
     nativeCurrency: {

package/_types/chains/definitions/taikoHekla.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taikoHekla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoHekla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBrB,CAAA"}
+{"version":3,"file":"taikoHekla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoHekla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBrB,CAAA"}

package/_types/chains/definitions/taikoJolnir.d.ts

@@ -11,6 +11,7 @@ export declare const taikoJolnir: {
             readonly blockCreated: 732706;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 167007;
     name: "Taiko Jolnir (Alpha-5 Testnet)";
     nativeCurrency: {

package/_types/chains/definitions/taikoJolnir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taikoJolnir.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoJolnir.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBtB,CAAA"}
+{"version":3,"file":"taikoJolnir.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoJolnir.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBtB,CAAA"}

package/_types/chains/definitions/taikoKatla.d.ts

@@ -14,6 +14,7 @@ export declare const taikoKatla: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 167008;
     name: "Taiko Katla (Alpha-6 Testnet)";
     nativeCurrency: {

package/_types/chains/definitions/taikoKatla.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taikoKatla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoKatla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBrB,CAAA"}
+{"version":3,"file":"taikoKatla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoKatla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBrB,CAAA"}

package/_types/chains/definitions/taikoTestnetSepolia.d.ts

@@ -14,6 +14,7 @@ export declare const taikoTestnetSepolia: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 167005;
     name: "Taiko (Alpha-3 Testnet)";
     nativeCurrency: {

package/_types/chains/definitions/taikoTestnetSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taikoTestnetSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoTestnetSepolia.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe9B,CAAA"}
+{"version":3,"file":"taikoTestnetSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoTestnetSepolia.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe9B,CAAA"}

package/_types/chains/definitions/taraxa.d.ts

@@ -14,6 +14,7 @@ export declare const taraxa: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 841;
     name: "Taraxa Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/taraxa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taraxa.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taraxa.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAejB,CAAA"}
+{"version":3,"file":"taraxa.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taraxa.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAejB,CAAA"}

package/_types/chains/definitions/taraxaTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const taraxaTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 842;
     name: "Taraxa Testnet";
     nativeCurrency: {

package/_types/chains/definitions/taraxaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taraxaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taraxaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBxB,CAAA"}
+{"version":3,"file":"taraxaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taraxaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBxB,CAAA"}

package/_types/chains/definitions/telcoinTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const telcoinTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 2017;
     name: "Telcoin Adiri Testnet";
     nativeCurrency: {

package/_types/chains/definitions/telcoinTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telcoinTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telcoinTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBzB,CAAA"}
+{"version":3,"file":"telcoinTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telcoinTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBzB,CAAA"}

package/_types/chains/definitions/telos.d.ts

@@ -11,6 +11,7 @@ export declare const telos: {
             readonly blockCreated: 246530709;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 40;
     name: "Telos";
     nativeCurrency: {

package/_types/chains/definitions/telos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telos.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telos.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBhB,CAAA"}
+{"version":3,"file":"telos.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telos.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBhB,CAAA"}

package/_types/chains/definitions/telosTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const telosTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 41;
     name: "Telos";
     nativeCurrency: {

package/_types/chains/definitions/telosTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telosTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telosTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBvB,CAAA"}
+{"version":3,"file":"telosTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/telosTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBvB,CAAA"}

package/_types/chains/definitions/tenet.d.ts

@@ -15,6 +15,7 @@ export declare const tenet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 1559;
     name: "Tenet";
     nativeCurrency: {

package/_types/chains/definitions/tenet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tenet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tenet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBhB,CAAA"}
+{"version":3,"file":"tenet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tenet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBhB,CAAA"}

package/_types/chains/definitions/ternoa.d.ts

@@ -14,6 +14,7 @@ export declare const ternoa: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 752025;
     name: "Ternoa";
     nativeCurrency: {

package/_types/chains/definitions/ternoa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ternoa.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ternoa.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBjB,CAAA"}
+{"version":3,"file":"ternoa.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ternoa.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBjB,CAAA"}

package/_types/chains/definitions/thaiChain.d.ts

@@ -12,6 +12,7 @@ export declare const thaiChain: {
             readonly blockCreated: 4806386;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 7;
     name: "ThaiChain";
     nativeCurrency: {

package/_types/chains/definitions/thaiChain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thaiChain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thaiChain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBpB,CAAA"}
+{"version":3,"file":"thaiChain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thaiChain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBpB,CAAA"}

package/_types/chains/definitions/that.d.ts

@@ -14,6 +14,7 @@ export declare const that: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 8428;
     name: "THAT Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/that.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"that.d.ts","sourceRoot":"","sources":["../../../chains/definitions/that.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBf,CAAA"}
+{"version":3,"file":"that.d.ts","sourceRoot":"","sources":["../../../chains/definitions/that.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBf,CAAA"}

package/_types/chains/definitions/theta.d.ts

@@ -14,6 +14,7 @@ export declare const theta: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 361;
     name: "Theta Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/theta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theta.d.ts","sourceRoot":"","sources":["../../../chains/definitions/theta.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhB,CAAA"}
+{"version":3,"file":"theta.d.ts","sourceRoot":"","sources":["../../../chains/definitions/theta.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhB,CAAA"}

package/_types/chains/definitions/thetaTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const thetaTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 365;
     name: "Theta Testnet";
     nativeCurrency: {

package/_types/chains/definitions/thetaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thetaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thetaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBvB,CAAA"}
+{"version":3,"file":"thetaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thetaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBvB,CAAA"}

package/_types/chains/definitions/thunderCore.d.ts

@@ -11,6 +11,7 @@ export declare const thunderCore: {
             readonly blockCreated: 0;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 108;
     name: "ThunderCore Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/thunderCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thunderCore.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thunderCore.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBtB,CAAA"}
+{"version":3,"file":"thunderCore.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thunderCore.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBtB,CAAA"}

package/_types/chains/definitions/thunderTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const thunderTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 997;
     name: "5ireChain Thunder Testnet";
     nativeCurrency: {

package/_types/chains/definitions/thunderTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thunderTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thunderTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBzB,CAAA"}
+{"version":3,"file":"thunderTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/thunderTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBzB,CAAA"}

package/_types/chains/definitions/tiktrixTestnet.d.ts

@@ -14,6 +14,7 @@ export declare const tiktrixTestnet: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 62092;
     name: "TikTrix Testnet";
     nativeCurrency: {

package/_types/chains/definitions/tiktrixTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiktrixTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tiktrixTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBzB,CAAA"}
+{"version":3,"file":"tiktrixTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tiktrixTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBzB,CAAA"}

package/_types/chains/definitions/tomb.d.ts

@@ -14,6 +14,7 @@ export declare const tomb: {
         multicall3?: import("../../index.js").ChainContract | undefined;
         universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
     } | undefined;
+    ensTlds?: readonly string[] | undefined;
     id: 6969;
     name: "Tomb Mainnet";
     nativeCurrency: {

package/_types/chains/definitions/tomb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tomb.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tomb.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBf,CAAA"}
+{"version":3,"file":"tomb.d.ts","sourceRoot":"","sources":["../../../chains/definitions/tomb.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBf,CAAA"}

package/_types/chains/definitions/treasure.d.ts

@@ -11,6 +11,7 @@ export declare const treasure: {
             readonly blockCreated: 101;
         };
     };
+    ensTlds?: readonly string[] | undefined;
     id: 61166;
     name: "Treasure";
     nativeCurrency: {