viem 2.20.1 → 2.21.1

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

@@ -16,7 +16,7 @@ export declare const sophonTestnet: {
     nativeCurrency: {
         readonly decimals: 18;
         readonly name: "Sophon";
-        readonly symbol: "ETH";
+        readonly symbol: "SOPH";
     };
     rpcUrls: {
         readonly default: {
@@ -26,9 +26,379 @@ export declare const sophonTestnet: {
     };
     sourceId?: number | undefined;
     testnet: true;
-    custom?: Record<string, unknown> | undefined;
+    custom: {
+        readonly getEip712Domain: import("../../zksync/index.js").EIP712DomainFn<import("../index.js").ZkSyncTransactionSerializable, import("../index.js").ZkSyncEIP712TransactionSignable>;
+    };
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").ZkSyncRpcBlock) => {
+                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;
+                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").ZkSyncTransaction<boolean>[];
+                transactionsRoot: import("../../index.js").Hash;
+                uncles: import("../../index.js").Hash[];
+                withdrawals?: import("../../index.js").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("../../index.js").Hex | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTimestamp: bigint | null;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").ZkSyncRpcTransaction) => ({
+                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;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("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;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("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;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("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;
+                blobVersionedHashes: readonly import("../../index.js").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("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("../../experimental/index.js").SignedAuthorizationList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+            } | {
+                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;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "priority";
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: import("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;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                type: "eip712" | "priority";
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("../index.js").ZkSyncRpcTransactionReceipt) => {
+                type: import("../index.js").ZkSyncTransactionType;
+                to: import("abitype").Address | null;
+                from: import("abitype").Address;
+                blockHash: import("../../index.js").Hash;
+                blockNumber: bigint;
+                transactionIndex: number;
+                status: "success" | "reverted";
+                contractAddress: import("abitype").Address | null | undefined;
+                logsBloom: import("../../index.js").Hex;
+                blobGasUsed?: bigint | undefined;
+                gasUsed: bigint;
+                transactionHash: import("../../index.js").Hash;
+                blobGasPrice?: bigint | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                root?: import("../../index.js").Hash | undefined;
+                l1BatchNumber: bigint | null;
+                l1BatchTxIndex: bigint | null;
+                logs: import("../index.js").ZkSyncLog[];
+                l2ToL1Logs: import("../index.js").ZkSyncL2ToL1Log[];
+            } & {};
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: ("paymaster" | "gasPerPubdata" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+            format: (args: import("../index.js").ZkSyncTransactionRequest) => ({
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("abitype").Address | null | undefined;
+                type?: "0x0" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                blobs?: undefined;
+                accessList?: undefined;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("abitype").Address | null | undefined;
+                type?: "0x1" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                accessList?: import("../../index.js").AccessList | undefined;
+                blobs?: undefined;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("abitype").Address | null | undefined;
+                type?: "0x2" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: import("../../index.js").AccessList | undefined;
+                blobs?: undefined;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                type?: "0x3" | undefined;
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                gasPrice?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                maxFeePerBlobGas: `0x${string}`;
+                accessList?: import("../../index.js").AccessList | undefined;
+                blobs: readonly import("../../index.js").Hex[] | readonly import("../../index.js").ByteArray[];
+                blobVersionedHashes?: readonly import("../../index.js").Hex[] | undefined;
+                kzg?: import("../../index.js").Kzg | undefined;
+                sidecars?: readonly import("../../index.js").BlobSidecar<import("../../index.js").Hex>[] | undefined;
+                authorizationList?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                type?: "0x4" | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                to?: import("abitype").Address | null | undefined;
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: import("../../index.js").AccessList | undefined;
+                authorizationList?: import("../../experimental/index.js").RpcAuthorizationList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                eip712Meta?: undefined;
+            } | {
+                data?: import("../../index.js").Hex | undefined;
+                from: import("abitype").Address;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: import("abitype").Address | null | undefined;
+                type: "0xff" | "0x71";
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                eip712Meta: import("../index.js").ZkSyncEip712Meta;
+            }) & {
+                paymaster: never;
+                gasPerPubdata: never;
+                factoryDeps: never;
+                paymasterInput: never;
+                customSignature: never;
+            };
+            type: "transactionRequest";
+        };
+    };
+    serializers: {
+        readonly transaction: typeof import("../../zksync/serializers.js").serializeTransaction;
+    };
 };
 //# sourceMappingURL=sophonTestnet.d.ts.map

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

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

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

@@ -6,14 +6,15 @@ export declare const spicy: {
             readonly apiUrl: "http://spicy-explorer.chiliz.com/api";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | undefined;
     id: 88882;
     name: "Chiliz Spicy Testnet";
     nativeCurrency: {

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

@@ -1 +1 @@
-{"version":3,"file":"spicy.d.ts","sourceRoot":"","sources":["../../../chains/definitions/spicy.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhB,CAAA"}
+{"version":3,"file":"spicy.d.ts","sourceRoot":"","sources":["../../../chains/definitions/spicy.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;mBA8BusB,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;;;CADp0B,CAAA"}

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

@@ -0,0 +1,36 @@
+export declare const storyTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Story Testnet Explorer";
+            readonly url: "https://testnet.storyscan.xyz";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 1513;
+    name: "Story Testnet";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "IP";
+        readonly symbol: "IP";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://testnet.storyrpc.io"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=storyTestnet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storyTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/storyTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;mBAmB+9B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CADnmC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const stratis: {
             readonly url: "https://explorer.stratisevm.com";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | undefined;
     id: 105105;
     name: "Stratis Mainnet";
     nativeCurrency: {

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

@@ -1 +1 @@
-{"version":3,"file":"stratis.d.ts","sourceRoot":"","sources":["../../../chains/definitions/stratis.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBlB,CAAA"}
+{"version":3,"file":"stratis.d.ts","sourceRoot":"","sources":["../../../chains/definitions/stratis.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;mBAqBk9B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;;CADjlC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const taikoHekla: {
             readonly url: "https://hekla.taikoscan.network";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBrB,CAAA"}
+{"version":3,"file":"taikoHekla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoHekla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;mBAiB0+B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CAD5mC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const taikoKatla: {
             readonly url: "https://explorer.katla.taiko.xyz";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBrB,CAAA"}
+{"version":3,"file":"taikoKatla.d.ts","sourceRoot":"","sources":["../../../chains/definitions/taikoKatla.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;mBAoBi5B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CADnhC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const taikoTestnetSepolia: {
             readonly url: "https://explorer.test.taiko.xyz";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;mBAgBi+B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CAD5mC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const taraxa: {
             readonly url: "https://explorer.mainnet.taraxa.io";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;mBAgB4/B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CAD1nC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const taraxaTestnet: {
             readonly url: "https://explorer.testnet.taraxa.io";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;mBAiB69B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CADlmC,CAAA"}

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

@@ -5,14 +5,15 @@ export declare const telcoinTestnet: {
             readonly url: "https://telscan.io";
         };
     };
-    contracts?: {
-        [x: string]: import("../../index.js").ChainContract | {
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
             [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
+    } & {
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
         multicall3?: import("../../index.js").ChainContract | undefined;
-    } | undefined;
+    }> | 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;;;;;;;;;;;;mBAiB2+B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CADjnC,CAAA"}