viem 2.0.0-beta.1 → 2.0.0-beta.11

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

@@ -0,0 +1,40 @@
+export declare const sapphireTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Oasis Sapphire Testnet Explorer";
+            readonly url: "https://testnet.explorer.sapphire.oasis.dev";
+        };
+    };
+    contracts?: {
+        [x: 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: 23295;
+    name: "Oasis Sapphire Testnet";
+    nativeCurrency: {
+        readonly name: "Sapphire Test Rose";
+        readonly symbol: "TEST";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://testnet.sapphire.oasis.dev"];
+            readonly webSocket: readonly ["wss://testnet.sapphire.oasis.dev/ws"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://testnet.sapphire.oasis.dev"];
+            readonly webSocket: readonly ["wss://testnet.sapphire.oasis.dev/ws"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    readonly network: "sapphire-testnet";
+};
+//# sourceMappingURL=sapphireTestnet.d.ts.map

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

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

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

@@ -7,7 +7,7 @@ export declare const scrollTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const shardeumSphinx: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -0,0 +1,40 @@
+export declare const shibarium: {
+    blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Blockscout";
+            readonly url: "https://shibariumscan.io";
+        };
+        readonly default: {
+            readonly name: "Blockscout";
+            readonly url: "https://shibariumscan.io";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x864Bf681ADD6052395188A89101A1B37d3B4C961";
+            readonly blockCreated: 265900;
+        };
+    };
+    id: 109;
+    name: "Shibarium";
+    nativeCurrency: {
+        readonly name: "Bone";
+        readonly symbol: "BONE";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.shibrpc.com"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://rpc.shibrpc.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    readonly network: "shibarium";
+};
+//# sourceMappingURL=shibarium.d.ts.map

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

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

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

@@ -0,0 +1,38 @@
+export declare const shimmer: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Shimmer Network Explorer";
+            readonly url: "https://explorer.evm.shimmer.network";
+        };
+    };
+    contracts?: {
+        [x: 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: 148;
+    name: "Shimmer";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Shimmer";
+        readonly symbol: "SMR";
+    };
+    rpcUrls: {
+        readonly public: {
+            readonly http: readonly ["https://json-rpc.evm.shimmer.network"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://json-rpc.evm.shimmer.network"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    readonly network: "shimmer";
+};
+//# sourceMappingURL=shimmer.d.ts.map

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

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

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

@@ -0,0 +1,38 @@
+export declare const shimmerTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Shimmer Network Explorer";
+            readonly url: "https://explorer.evm.testnet.shimmer.network";
+        };
+    };
+    contracts?: {
+        [x: 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: 1073;
+    name: "Shimmer Testnet";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Shimmer";
+        readonly symbol: "SMR";
+    };
+    rpcUrls: {
+        readonly public: {
+            readonly http: readonly ["https://json-rpc.evm.testnet.shimmer.network"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://json-rpc.evm.testnet.shimmer.network"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    readonly network: "shimmer-testnet";
+};
+//# sourceMappingURL=shimmerTestnet.d.ts.map

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

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

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

@@ -7,7 +7,7 @@ export declare const songbird: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const songbirdTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -0,0 +1,36 @@
+export declare const spicy: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Chiliz Explorer";
+            readonly url: "http://spicy-explorer.chiliz.com";
+        };
+    };
+    contracts?: {
+        [x: 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: 88882;
+    name: "Chiliz Spicy Testnet";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "CHZ";
+        readonly symbol: "CHZ";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://spicy-rpc.chiliz.com", "https://chiliz-spicy.publicnode.com"];
+            readonly webSocket: readonly ["wss://spicy-rpc-ws.chiliz.com", "wss://chiliz-spicy.publicnode.com"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    readonly network: "chiliz-spicy-Testnet";
+};
+//# sourceMappingURL=spicy.d.ts.map

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

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

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

@@ -7,7 +7,7 @@ export declare const taikoJolnir: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const taikoTestnetSepolia: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const taraxa: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const taraxaTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const telosTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const tenet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const thunderTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -11,7 +11,7 @@ export declare const vechain: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -11,7 +11,7 @@ export declare const xdc: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -11,7 +11,7 @@ export declare const xdcTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const zetachainAthensTestnet: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -7,7 +7,7 @@ export declare const zhejiang: {
     };
     contracts?: {
         [x: string]: import("../../index.js").ChainContract | {
-            [chainId: number]: import("../../index.js").ChainContract | undefined;
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
         } | undefined;
         ensRegistry?: import("../../index.js").ChainContract | undefined;
         ensUniversalResolver?: import("../../index.js").ChainContract | undefined;

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

@@ -28,8 +28,8 @@ export declare const zkSync: {
     formatters: {
         readonly block: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcBlock>, import("../utils.js").ZkSyncRpcBlockOverrides & {
-                transactions: `0x${string}`[] | import("../utils.js").ZkSyncRpcTransaction[];
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcBlock>, import("../zksync/types.js").ZkSyncRpcBlockOverrides & {
+                transactions: `0x${string}`[] | import("../zksync/types.js").ZkSyncRpcTransaction[];
             }>) => {
                 baseFeePerGas: bigint | null;
                 difficulty: bigint;
@@ -50,7 +50,7 @@ export declare const zkSync: {
                 stateRoot: `0x${string}`;
                 timestamp: bigint;
                 totalDifficulty: bigint | null;
-                transactions: `0x${string}`[] | import("../utils.js").ZkSyncTransaction[];
+                transactions: `0x${string}`[] | import("../zksync/types.js").ZkSyncTransaction[];
                 transactionsRoot: `0x${string}`;
                 uncles: `0x${string}`[];
                 withdrawals?: import("../../index.js").Withdrawal[] | undefined;
@@ -62,7 +62,7 @@ export declare const zkSync: {
         };
         readonly transaction: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransaction>, import("../utils.js").ZkSyncRpcTransaction>) => ({
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransaction>, import("../zksync/types.js").ZkSyncRpcTransaction>) => ({
                 blockHash: `0x${string}` | null;
                 blockNumber: bigint | null;
                 from: `0x${string}`;
@@ -82,6 +82,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas?: undefined;
                 accessList?: undefined;
                 chainId?: number | undefined;
+                yParity?: undefined;
                 type: "legacy";
                 l1BatchNumber: bigint | null;
                 l1BatchTxIndex: bigint | null;
@@ -105,6 +106,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas: bigint;
                 accessList?: undefined;
                 chainId?: number | undefined;
+                yParity: number;
                 type: "priority";
                 l1BatchNumber: bigint | null;
                 l1BatchTxIndex: bigint | null;
@@ -128,6 +130,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas: bigint;
                 accessList?: undefined;
                 chainId?: number | undefined;
+                yParity: number;
                 type: "priority" | "eip712";
                 l1BatchNumber: bigint | null;
                 l1BatchTxIndex: bigint | null;
@@ -146,6 +149,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice: bigint;
                 maxFeePerGas?: undefined;
                 maxPriorityFeePerGas?: undefined;
@@ -169,6 +173,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -192,6 +197,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -215,6 +221,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -238,6 +245,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice: bigint;
                 maxFeePerGas: undefined;
                 maxPriorityFeePerGas: undefined;
@@ -261,6 +269,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice?: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -284,6 +293,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice?: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -307,6 +317,7 @@ export declare const zkSync: {
                 typeHex: `0x${string}` | null;
                 v: bigint;
                 value: bigint;
+                yParity: number;
                 gasPrice?: undefined;
                 maxFeePerGas: bigint;
                 maxPriorityFeePerGas: bigint;
@@ -320,7 +331,7 @@ export declare const zkSync: {
         };
         readonly transactionReceipt: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransactionReceipt>, import("../utils.js").ZkSyncRpcTransactionReceiptOverrides>) => {
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransactionReceipt>, import("../zksync/types.js").ZkSyncRpcTransactionReceiptOverrides>) => {
                 blockHash: `0x${string}`;
                 blockNumber: bigint;
                 contractAddress: `0x${string}` | null;
@@ -328,22 +339,22 @@ export declare const zkSync: {
                 effectiveGasPrice: bigint;
                 from: `0x${string}`;
                 gasUsed: bigint;
-                logs: import("../utils.js").ZkSyncLog<bigint, number, boolean, undefined, undefined, undefined, undefined>[];
+                logs: import("../zksync/types.js").ZkSyncLog<bigint, number, boolean, undefined, undefined, undefined, undefined>[];
                 logsBloom: `0x${string}`;
                 status: "success" | "reverted";
                 to: `0x${string}` | null;
                 transactionHash: `0x${string}`;
                 transactionIndex: number;
-                type: import("../utils.js").ZkSyncTransactionType;
+                type: import("../zksync/types.js").ZkSyncTransactionType;
                 l1BatchNumber: bigint | null;
                 l1BatchTxIndex: bigint | null;
-                l2ToL1Logs: import("../utils.js").ZkSyncL2ToL1Log[];
+                l2ToL1Logs: import("../zksync/types.js").ZkSyncL2ToL1Log[];
             } & {};
             type: "transactionReceipt";
         };
         readonly transactionRequest: {
             exclude: ("customSignature" | "factoryDeps" | "gasPerPubdata" | "paymaster" | "paymasterInput")[] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").TransactionRequest>, import("../utils.js").ZkSyncTransactionRequest>) => ({
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").TransactionRequest>, import("../zksync/types.js").ZkSyncTransactionRequest>) => ({
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
                 gas?: `0x${string}` | undefined;
@@ -394,7 +405,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("../utils.js").ZkSyncEip712Meta;
+                eip712Meta: import("../zksync/types.js").ZkSyncEip712Meta;
             } | {
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
@@ -446,7 +457,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: import("../../index.js").AccessList | undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("../utils.js").ZkSyncEip712Meta;
+                eip712Meta: import("../zksync/types.js").ZkSyncEip712Meta;
             } | {
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
@@ -498,7 +509,7 @@ export declare const zkSync: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: import("../../index.js").AccessList | undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("../utils.js").ZkSyncEip712Meta;
+                eip712Meta: import("../zksync/types.js").ZkSyncEip712Meta;
             }) & {
                 customSignature: never;
                 factoryDeps: never;
@@ -510,7 +521,7 @@ export declare const zkSync: {
         };
     };
     serializers: {
-        readonly transaction: import("../../index.js").SerializeTransactionFn<import("../utils.js").ZkSyncTransactionSerializable>;
+        readonly transaction: import("../../index.js").SerializeTransactionFn<import("../zksync/types.js").ZkSyncTransactionSerializable>;
     };
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     readonly network: "zksync-era";

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

@@ -1 +1 @@
-{"version":3,"file":"zkSync.d.ts","sourceRoot":"","sources":["../../../chains/definitions/zkSync.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BjB,CAAA"}
+{"version":3,"file":"zkSync.d.ts","sourceRoot":"","sources":["../../../chains/definitions/zkSync.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BjB,CAAA"}