viem 2.21.15 → 2.21.17

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

@@ -1,21 +1,61 @@
 export declare const soneiumMinato: {
     blockExplorers: {
         readonly default: {
-            readonly name: "Minato Explorer";
+            readonly name: "Blockscout";
             readonly url: "https://explorer-testnet.soneium.org";
-            readonly apiUrl: "https://explorer-testnet.soneium.org/api/";
+            readonly apiUrl: "https://explorer-testnet.soneium.org/api";
         };
     };
     contracts: {
+        readonly disputeGameFactory: {
+            readonly 11155111: {
+                readonly address: "0xF69dB6cA559C52d9A4BB6e2B2901f490Ca35Fbf6";
+            };
+        };
+        readonly l2OutputOracle: {
+            readonly 11155111: {
+                readonly address: "0x710e5286C746eC38beeB7538d0146f60D27be343";
+            };
+        };
+        readonly portal: {
+            readonly 11155111: {
+                readonly address: "0x65ea1489741A5D72fFdD8e6485B216bBdcC15Af3";
+                readonly blockCreated: 6466136;
+            };
+        };
+        readonly l1StandardBridge: {
+            readonly 11155111: {
+                readonly address: "0x5f5a404A5edabcDD80DB05E8e54A78c9EBF000C2";
+                readonly blockCreated: 6466136;
+            };
+        };
         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";
+        };
     };
     id: 1946;
-    name: "Soneium Minato";
+    name: "Soneium Minato Testnet";
     nativeCurrency: {
-        readonly name: "Ether";
+        readonly name: "Sepolia Ether";
         readonly symbol: "ETH";
         readonly decimals: 18;
     };
@@ -24,11 +64,243 @@ export declare const soneiumMinato: {
             readonly http: readonly ["https://rpc.minato.soneium.org"];
         };
     };
-    sourceId?: number | undefined;
+    sourceId: 11155111;
     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;
+    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?: 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").OpStackTransaction<boolean>[];
+                transactionsRoot: import("../../index.js").Hash;
+                uncles: import("../../index.js").Hash[];
+                withdrawals?: import("../../index.js").Withdrawal[] | undefined;
+                withdrawalsRoot?: import("../../index.js").Hex | 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;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | 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;
+                authorizationList?: undefined;
+                blobVersionedHashes?: undefined;
+                chainId?: number | undefined;
+                yParity?: undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: 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;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas?: undefined;
+                maxPriorityFeePerGas?: undefined;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: 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;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: 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;
+                blobVersionedHashes: readonly import("../../index.js").Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: 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("../../experimental/index.js").SignedAuthorizationList;
+                blobVersionedHashes?: undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined;
+                maxFeePerBlobGas?: undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined;
+                mint?: undefined;
+                sourceHash?: 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?: import("../../index.js").Hash | 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=soneiumMinato.d.ts.map

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

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

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

@@ -0,0 +1,36 @@
+export declare const viction: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "VIC Scan";
+            readonly url: "https://vicscan.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: 88;
+    name: "Viction";
+    nativeCurrency: {
+        readonly name: "Viction";
+        readonly symbol: "VIC";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.viction.xyz"];
+        };
+    };
+    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;
+};
+//# sourceMappingURL=viction.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+export declare const victionTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "VIC Scan";
+            readonly url: "https://testnet.vicscan.xyz";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 12170179;
+        };
+    };
+    id: 89;
+    name: "Viction Testnet";
+    nativeCurrency: {
+        readonly name: "Viction";
+        readonly symbol: "VIC";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-testnet.viction.xyz"];
+        };
+    };
+    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=victionTestnet.d.ts.map

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

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

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

@@ -0,0 +1,36 @@
+export declare const vision: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Vision Scan";
+            readonly url: "https://visionscan.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;
+    }> | undefined;
+    id: 888888;
+    name: "Vision";
+    nativeCurrency: {
+        readonly name: "VISION";
+        readonly symbol: "VS";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://infragrid.v.network/ethereum/compatible"];
+        };
+    };
+    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;
+};
+//# sourceMappingURL=vision.d.ts.map

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

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

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

@@ -0,0 +1,36 @@
+export declare const visionTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Vision Scan";
+            readonly url: "https://visionscan.org/?chain=vpioneer";
+        };
+    };
+    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: 666666;
+    name: "Vision Testnet";
+    nativeCurrency: {
+        readonly name: "VISION";
+        readonly symbol: "VS";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://vpioneer.infragrid.v.network/ethereum/compatible"];
+        };
+    };
+    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=visionTestnet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"visionTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/visionTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;mBAiB+7B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CADpkC,CAAA"}

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

@@ -0,0 +1,36 @@
+export declare const weaveVMAlphanet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "WeaveVM Alphanet Explorer";
+            readonly url: "https://explorer.wvm.dev";
+        };
+    };
+    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: 9496;
+    name: "WeaveVM Alphanet";
+    nativeCurrency: {
+        readonly name: "Testnet WeaveVM";
+        readonly symbol: "tWVM";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://testnet-rpc.wvm.dev"];
+        };
+    };
+    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=weavevmAlphanet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weavevmAlphanet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/weavevmAlphanet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;mBAew9B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;;;;;;;;;;;;;;;;;;;;CAD/lC,CAAA"}

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

@@ -0,0 +1,32 @@
+export declare const zircuit: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Zircuit Explorer";
+            readonly url: "https://explorer.zircuit.com";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        };
+    };
+    id: 48900;
+    name: "Zircuit Mainnet";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://zircuit1-mainnet.p2pify.com", "https://zircuit1-mainnet.liquify.com", "https://zircuit-mainnet.drpc.org"];
+        };
+    };
+    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;
+};
+//# sourceMappingURL=zircuit.d.ts.map

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

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

package/_types/chains/index.d.ts

@@ -10,6 +10,7 @@ export { apexTestnet } from './definitions/apexTestnet.js';
 export { arbitrum } from './definitions/arbitrum.js';
 export { arbitrumGoerli } from './definitions/arbitrumGoerli.js';
 export { arbitrumNova } from './definitions/arbitrumNova.js';
+export { assetChain } from './definitions/assetChain.js';
 export { assetChainTestnet } from './definitions/assetChainTestnet.js';
 export { astar } from './definitions/astar.js';
 export { astarZkEVM } from './definitions/astarZkEVM.js';
@@ -48,6 +49,8 @@ export { bobSepolia } from './definitions/bobSepolia.js';
 export { boba } from './definitions/boba.js';
 export { bobaSepolia } from './definitions/bobaSepolia.js';
 export { botanixTestnet } from './definitions/botanixTestnet.js';
+export { bounceBit } from './definitions/bounceBit.js';
+export { bounceBitTestnet } from './definitions/bounceBitTestnet.js';
 export { bronos } from './definitions/bronos.js';
 export { bronosTestnet } from './definitions/bronosTestnet.js';
 export { bsc } from './definitions/bsc.js';
@@ -126,6 +129,8 @@ export { funkiMainnet } from './definitions/funkiMainnet.js';
 export { funkiSepolia } from './definitions/funkiSepolia.js';
 export { fuse } from './definitions/fuse.js';
 export { fuseSparknet } from './definitions/fuseSparknet.js';
+export { fusion } from './definitions/fusion.js';
+export { fusionTestnet } from './definitions/fusionTestnet.js';
 export { iotex } from './definitions/iotex.js';
 export { iotexTestnet } from './definitions/iotexTestnet.js';
 export { jbc } from './definitions/jbc.js';
@@ -147,6 +152,8 @@ export { hedera } from './definitions/hedera.js';
 export { hederaTestnet } from './definitions/hederaTestnet.js';
 export { hederaPreviewnet } from './definitions/hederaPreviewnet.js';
 export { holesky } from './definitions/holesky.js';
+export { hychain } from './definitions/hychain.js';
+export { hychainTestnet } from './definitions/hychainTestnet.js';
 export { immutableZkEvm } from './definitions/immutableZkEvm.js';
 export { immutableZkEvmTestnet } from './definitions/immutableZkEvmTestnet.js';
 export { inEVM } from './definitions/inEVM.js';
@@ -330,8 +337,13 @@ export { uniqueQuartz } from './definitions/uniqueQuartz.js';
 export { uniqueOpal } from './definitions/uniqueOpal.js';
 export { unreal } from './definitions/unreal.js';
 export { vechain } from './definitions/vechain.js';
+export { viction } from './definitions/viction.js';
+export { victionTestnet } from './definitions/victionTestnet.js';
+export { vision } from './definitions/vision.js';
+export { visionTestnet } from './definitions/visionTestnet.js';
 export { wanchain } from './definitions/wanchain.js';
 export { wanchainTestnet } from './definitions/wanchainTestnet.js';
+export { weaveVMAlphanet } from './definitions/weavevmAlphanet.js';
 export { wemix } from './definitions/wemix.js';
 export { wemixTestnet } from './definitions/wemixTestnet.js';
 export { worldchain } from './definitions/worldchain.js';
@@ -371,6 +383,7 @@ zksyncSepoliaTestnet as zkSyncSepoliaTestnet, zksyncSepoliaTestnet, } from './de
 export { zora } from './definitions/zora.js';
 export { zoraSepolia } from './definitions/zoraSepolia.js';
 export { zoraTestnet } from './definitions/zoraTestnet.js';
+export { zircuit } from './definitions/zircuit.js';
 export { zircuitTestnet } from './definitions/zircuitTestnet.js';
 export type { Assign, Omit, PartialBy, Prettify, UnionLooseOmit, } from '../types/utils.js';
 export type { SerializeTransactionCIP64ReturnType, assertTransactionCIP42 as assertTransactionCIP42Celo, assertTransactionCIP64 as assertTransactionCIP64Celo, serializeTransaction as serializeTransactionCelo, serializers as serializersCelo, } from '../celo/serializers.js';