viem 2.22.13 → 2.22.15

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

@@ -0,0 +1,413 @@
+export declare const abstract: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://abscan.org";
+        };
+        readonly native: {
+            readonly name: "Abstract Explorer";
+            readonly url: "https://explorer.mainnet.abs.xyz";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xAa4De41dba0Ca5dCBb288b7cC6b708F3aaC759E7";
+            readonly blockCreated: 5288;
+        };
+        readonly universalSignatureVerifier: {
+            readonly address: "0xfB688330379976DA81eB64Fe4BF50d7401763B9C";
+            readonly blockCreated: 5263;
+        };
+    };
+    id: 2741;
+    name: "Abstract";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "ETH";
+        readonly symbol: "ETH";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.mainnet.abs.xyz"];
+            readonly webSocket: readonly ["wss://api.mainnet.abs.xyz/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | 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: {
+        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;
+                parentBeaconBlockRoot?: import("../../index.js").Hex | 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").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 | undefined;
+                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 | undefined;
+                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 | undefined;
+                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 | undefined;
+                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 | undefined;
+                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 | undefined;
+                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=abstract.d.ts.map

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

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

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

@@ -1,9 +1,13 @@
 export declare const abstractTestnet: {
     blockExplorers: {
         readonly default: {
-            readonly name: "Abstract Block Explorer";
+            readonly name: "Etherscan";
             readonly url: "https://sepolia.abscan.org";
         };
+        readonly native: {
+            readonly name: "Abstract Explorer";
+            readonly url: "https://explorer.testnet.abs.xyz";
+        };
     };
     contracts: {
         readonly multicall3: {

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

@@ -1 +1 @@
-{"version":3,"file":"abstractTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B1B,CAAA"}
+{"version":3,"file":"abstractTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/abstractTestnet.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1B,CAAA"}

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

@@ -5,16 +5,12 @@ export declare const cronoszkEVM: {
             readonly url: "https://explorer.zkevm.cronos.org";
         };
     };
-    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;
-        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
-    }> | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x06f4487d7c4a5983d2660db965cc6d2565e4cfaa";
+            readonly blockCreated: 72;
+        };
+    };
     id: 388;
     name: "Cronos zkEVM Mainnet";
     nativeCurrency: {

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

@@ -1 +1 @@
-{"version":3,"file":"cronoszkEVM.d.ts","sourceRoot":"","sources":["../../../chains/definitions/cronoszkEVM.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;mBAkBm8B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CADvoC,CAAA"}
+{"version":3,"file":"cronoszkEVM.d.ts","sourceRoot":"","sources":["../../../chains/definitions/cronoszkEVM.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBtB,CAAA"}

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

@@ -0,0 +1,38 @@
+export declare const hemi: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "blockscout";
+            readonly url: "https://explorer.hemi.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;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 43111;
+    name: "Hemi";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.hemi.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: false;
+    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;
+    readonly network: "Hemi";
+};
+//# sourceMappingURL=hemi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hemi.d.ts","sourceRoot":"","sources":["../../../chains/definitions/hemi.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;mBAsBm+B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;;CADhqC,CAAA"}

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

@@ -0,0 +1,37 @@
+export declare const premiumBlockTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PremiumBlocks Explorer";
+            readonly url: "https://scan.premiumblock.org";
+        };
+    };
+    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;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 23023;
+    name: "PremiumBlock Testnet";
+    nativeCurrency: {
+        readonly name: "Premium Block";
+        readonly symbol: "PBLK";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.premiumblock.org"];
+        };
+    };
+    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=premiumBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"premiumBlock.d.ts","sourceRoot":"","sources":["../../../chains/definitions/premiumBlock.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;mBAiB87B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD1oC,CAAA"}

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

@@ -0,0 +1,37 @@
+export declare const ultra: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Ultra EVM Explorer";
+            readonly url: "https://evmexplorer.ultra.io";
+        };
+    };
+    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;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 19991;
+    name: "Ultra EVM";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ultra Token";
+        readonly symbol: "UOS";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://evm.ultra.eosusa.io"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    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=ultra.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ultra.d.ts","sourceRoot":"","sources":["../../../chains/definitions/ultra.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;mBAkB4/B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD1rC,CAAA"}

package/_types/chains/index.d.ts

@@ -1,5 +1,6 @@
 export type { Chain } from '../types/chain.js';
 export { abey } from './definitions/abey.js';
+export { abstract } from './definitions/abstract.js';
 export { abstractTestnet } from './definitions/abstractTestnet.js';
 export { acala } from './definitions/acala.js';
 export { acria } from './definitions/acria.js';
@@ -202,6 +203,7 @@ export { hedera } from './definitions/hedera.js';
 export { hederaPreviewnet } from './definitions/hederaPreviewnet.js';
 export { hederaTestnet } from './definitions/hederaTestnet.js';
 export { hela } from './definitions/hela.js';
+export { hemi } from './definitions/hemi.js';
 export { hemiSepolia } from './definitions/hemiSepolia.js';
 export { holesky } from './definitions/holesky.js';
 export { hpb } from './definitions/hpb.js';
@@ -350,6 +352,7 @@ export { polygonZkEvm } from './definitions/polygonZkEvm.js';
 export { polygonZkEvmCardona } from './definitions/polygonZkEvmCardona.js';
 /** @deprecated Use `polygonZkEvmCardona` instead. */
 export { polygonZkEvmTestnet } from './definitions/polygonZkEvmTestnet.js';
+export { premiumBlockTestnet } from './definitions/premiumBlock.js';
 export { pulsechain } from './definitions/pulsechain.js';
 export { pulsechainV4 } from './definitions/pulsechainV4.js';
 export { ql1 } from './definitions/ql1.js';
@@ -462,6 +465,7 @@ export { treasure } from './definitions/treasure.js';
 export { treasureTopaz } from './definitions/treasureTopaz.js';
 export { tron } from './definitions/tron.js';
 export { ubiq } from './definitions/ubiq.js';
+export { ultra } from './definitions/ultra.js';
 export { ultraTestnet } from './definitions/ultraTestnet.js';
 export { ultron } from './definitions/ultron.js';
 export { ultronTestnet } from './definitions/ultronTestnet.js';