viem 1.10.10 → 1.10.12

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

@@ -0,0 +1,43 @@
+export declare const arbitrum: import("../../types/utils.js").Assign<{
+    readonly id: 42161;
+    readonly name: "Arbitrum One";
+    readonly network: "arbitrum";
+    readonly nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly alchemy: {
+            readonly http: readonly ["https://arb-mainnet.g.alchemy.com/v2"];
+            readonly webSocket: readonly ["wss://arb-mainnet.g.alchemy.com/v2"];
+        };
+        readonly infura: {
+            readonly http: readonly ["https://arbitrum-mainnet.infura.io/v3"];
+            readonly webSocket: readonly ["wss://arbitrum-mainnet.infura.io/ws/v3"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+        };
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 7654707;
+        };
+    };
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=arbitrum.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+export declare const arbitrumGoerli: import("../../types/utils.js").Assign<{
+    readonly id: 421613;
+    readonly name: "Arbitrum Goerli";
+    readonly network: "arbitrum-goerli";
+    readonly nativeCurrency: {
+        readonly name: "Arbitrum Goerli Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly alchemy: {
+            readonly http: readonly ["https://arb-goerli.g.alchemy.com/v2"];
+            readonly webSocket: readonly ["wss://arb-goerli.g.alchemy.com/v2"];
+        };
+        readonly infura: {
+            readonly http: readonly ["https://arbitrum-goerli.infura.io/v3"];
+            readonly webSocket: readonly ["wss://arbitrum-goerli.infura.io/ws/v3"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://goerli-rollup.arbitrum.io/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://goerli-rollup.arbitrum.io/rpc"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Arbiscan";
+            readonly url: "https://goerli.arbiscan.io/";
+        };
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://goerli.arbiscan.io/";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 88114;
+        };
+    };
+    readonly testnet: true;
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=arbitrumGoerli.d.ts.map

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

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

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

@@ -0,0 +1,43 @@
+export declare const arbitrumNova: import("../../types/utils.js").Assign<{
+    readonly id: 42170;
+    readonly name: "Arbitrum Nova";
+    readonly network: "arbitrum-nova";
+    readonly nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly blast: {
+            readonly http: readonly ["https://arbitrum-nova.public.blastapi.io"];
+            readonly webSocket: readonly ["wss://arbitrum-nova.public.blastapi.io"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://nova.arbitrum.io/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://nova.arbitrum.io/rpc"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Arbiscan";
+            readonly url: "https://nova.arbiscan.io";
+        };
+        readonly blockScout: {
+            readonly name: "BlockScout";
+            readonly url: "https://nova-explorer.arbitrum.io/";
+        };
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://nova.arbiscan.io";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 1746963;
+        };
+    };
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=arbitrumNova.d.ts.map

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

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

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

@@ -0,0 +1,32 @@
+export declare const aurora: import("../../types/utils.js").Assign<{
+    readonly id: 1313161554;
+    readonly name: "Aurora";
+    readonly network: "aurora";
+    readonly nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    readonly rpcUrls: {
+        readonly infura: {
+            readonly http: readonly ["https://aurora-mainnet.infura.io/v3"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://mainnet.aurora.dev"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://mainnet.aurora.dev"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Aurorascan";
+            readonly url: "https://aurorascan.dev";
+        };
+        readonly default: {
+            readonly name: "Aurorascan";
+            readonly url: "https://aurorascan.dev";
+        };
+    };
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=aurora.d.ts.map

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

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

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

@@ -0,0 +1,33 @@
+export declare const auroraTestnet: import("../../types/utils.js").Assign<{
+    readonly id: 1313161555;
+    readonly name: "Aurora Testnet";
+    readonly network: "aurora-testnet";
+    readonly nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    readonly rpcUrls: {
+        readonly infura: {
+            readonly http: readonly ["https://aurora-testnet.infura.io/v3"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://testnet.aurora.dev"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://testnet.aurora.dev"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "Aurorascan";
+            readonly url: "https://testnet.aurorascan.dev";
+        };
+        readonly default: {
+            readonly name: "Aurorascan";
+            readonly url: "https://testnet.aurorascan.dev";
+        };
+    };
+    readonly testnet: true;
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=auroraTestnet.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+export declare const avalanche: import("../../types/utils.js").Assign<{
+    readonly id: 43114;
+    readonly name: "Avalanche";
+    readonly network: "avalanche";
+    readonly nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Avalanche";
+        readonly symbol: "AVAX";
+    };
+    readonly rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "SnowTrace";
+            readonly url: "https://snowtrace.io";
+        };
+        readonly default: {
+            readonly name: "SnowTrace";
+            readonly url: "https://snowtrace.io";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 11907934;
+        };
+    };
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=avalanche.d.ts.map

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

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

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

@@ -0,0 +1,36 @@
+export declare const avalancheFuji: import("../../types/utils.js").Assign<{
+    readonly id: 43113;
+    readonly name: "Avalanche Fuji";
+    readonly network: "avalanche-fuji";
+    readonly nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Avalanche Fuji";
+        readonly symbol: "AVAX";
+    };
+    readonly rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.avax-test.network/ext/bc/C/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.avax-test.network/ext/bc/C/rpc"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly etherscan: {
+            readonly name: "SnowTrace";
+            readonly url: "https://testnet.snowtrace.io";
+        };
+        readonly default: {
+            readonly name: "SnowTrace";
+            readonly url: "https://testnet.snowtrace.io";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 7096959;
+        };
+    };
+    readonly testnet: true;
+}, import("../../types/chain.js").ChainConfig<import("../../index.js").ChainFormatters>>;
+//# sourceMappingURL=avalancheFuji.d.ts.map

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

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

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

@@ -0,0 +1,338 @@
+export declare const base: import("../../types/utils.js").Assign<{
+    readonly id: 8453;
+    readonly network: "base";
+    readonly name: "Base";
+    readonly nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    readonly rpcUrls: {
+        readonly alchemy: {
+            readonly http: readonly ["https://base-mainnet.g.alchemy.com/v2"];
+            readonly webSocket: readonly ["wss://base-mainnet.g.alchemy.com/v2"];
+        };
+        readonly default: {
+            readonly http: readonly ["https://mainnet.base.org"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://mainnet.base.org"];
+        };
+    };
+    readonly blockExplorers: {
+        readonly blockscout: {
+            readonly name: "Basescout";
+            readonly url: "https://base.blockscout.com";
+        };
+        readonly default: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+        };
+        readonly etherscan: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+        };
+    };
+    readonly contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 5022;
+        };
+    };
+}, import("../../types/chain.js").ChainConfig<{
+    readonly block: {
+        exclude: [] | undefined;
+        format: (args: import("../../types/utils.js").Assign<Partial<import("../../index.js").RpcBlock>, import("../optimism/types.js").OptimismRpcBlockOverrides & {
+            transactions: `0x${string}`[] | import("../optimism/types.js").OptimismRpcTransaction[];
+        }>) => {
+            baseFeePerGas: bigint | null;
+            difficulty: bigint;
+            extraData: `0x${string}`;
+            gasLimit: bigint;
+            gasUsed: bigint;
+            hash: `0x${string}` | null;
+            logsBloom: `0x${string}` | null;
+            miner: `0x${string}`;
+            mixHash: `0x${string}`;
+            nonce: `0x${string}` | null;
+            number: bigint | null;
+            parentHash: `0x${string}`;
+            receiptsRoot: `0x${string}`;
+            sealFields: `0x${string}`[];
+            sha3Uncles: `0x${string}`;
+            size: bigint;
+            stateRoot: `0x${string}`;
+            timestamp: bigint;
+            totalDifficulty: bigint | null;
+            transactions: `0x${string}`[] | import("../optimism/types.js").OptimismTransaction[];
+            transactionsRoot: `0x${string}`;
+            uncles: `0x${string}`[];
+        } & {};
+        type: "block";
+    };
+    readonly transaction: {
+        exclude: [] | undefined;
+        format: (args: (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean>, "typeHex"> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            isSystemTx?: boolean | undefined;
+            mint?: `0x${string}` | undefined;
+            sourceHash: `0x${string}`;
+            type: "0x7e";
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean>, "typeHex"> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            isSystemTx?: boolean | undefined;
+            mint?: `0x${string}` | undefined;
+            sourceHash: `0x${string}`;
+            type: "0x7e";
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionLegacy<`0x${string}`, `0x${string}`, boolean, "0x0">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionEIP2930<`0x${string}`, `0x${string}`, boolean, "0x1">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex"> & {
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        }) | (import("../../types/utils.js").Assign_<Partial<Omit<import("../../index.js").TransactionEIP1559<`0x${string}`, `0x${string}`, boolean, "0x2">, "typeHex">>, import("../optimism/types.js").OptimismRpcTransaction> & Omit<import("../../index.js").TransactionBase<`0x${string}`, `0x${string}`, boolean>, "typeHex"> & import("../../index.js").FeeValuesEIP1559<`0x${string}`> & {
+            isSystemTx?: boolean | undefined;
+            mint?: `0x${string}` | undefined;
+            sourceHash: `0x${string}`;
+            type: "0x7e";
+        })) => ({
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: bigint;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            accessList?: undefined;
+            chainId?: number | undefined;
+            type: "legacy";
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList?: undefined;
+            chainId?: number | undefined;
+            type: "deposit";
+            isSystemTx?: boolean | undefined;
+            mint?: bigint | undefined;
+            sourceHash: `0x${string}`;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: bigint;
+            maxFeePerGas?: undefined;
+            maxPriorityFeePerGas?: undefined;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "eip2930";
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "eip1559";
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "deposit";
+            isSystemTx?: boolean | undefined;
+            mint?: bigint | undefined;
+            sourceHash: `0x${string}`;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice: bigint;
+            maxFeePerGas: undefined;
+            maxPriorityFeePerGas: undefined;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "eip2930";
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "eip1559";
+            isSystemTx?: undefined;
+            mint?: undefined;
+            sourceHash?: undefined;
+        } | {
+            blockHash: `0x${string}` | null;
+            blockNumber: bigint | null;
+            from: `0x${string}`;
+            gas: bigint;
+            hash: `0x${string}`;
+            input: `0x${string}`;
+            nonce: number;
+            r: `0x${string}`;
+            s: `0x${string}`;
+            to: `0x${string}` | null;
+            transactionIndex: number | null;
+            typeHex: `0x${string}` | null;
+            v: bigint;
+            value: bigint;
+            gasPrice?: undefined;
+            maxFeePerGas: bigint;
+            maxPriorityFeePerGas: bigint;
+            accessList: import("../../index.js").AccessList;
+            chainId: number;
+            type: "deposit";
+            isSystemTx?: boolean | undefined;
+            mint?: bigint | undefined;
+            sourceHash: `0x${string}`;
+        }) & {};
+        type: "transaction";
+    };
+    readonly transactionReceipt: {
+        exclude: [] | undefined;
+        format: (args: import("../../types/utils.js").Assign<Partial<import("../../index.js").RpcTransactionReceipt>, import("../optimism/types.js").OptimismRpcTransactionReceiptOverrides>) => {
+            blockHash: `0x${string}`;
+            blockNumber: bigint;
+            contractAddress: `0x${string}` | null;
+            cumulativeGasUsed: bigint;
+            effectiveGasPrice: bigint;
+            from: `0x${string}`;
+            gasUsed: bigint;
+            logs: import("../../index.js").Log<bigint, number>[];
+            logsBloom: `0x${string}`;
+            status: "success" | "reverted";
+            to: `0x${string}` | null;
+            transactionHash: `0x${string}`;
+            transactionIndex: number;
+            type: import("../../index.js").TransactionType;
+            l1GasPrice: bigint | null;
+            l1GasUsed: bigint | null;
+            l1Fee: bigint | null;
+            l1FeeScalar: number | null;
+        } & {};
+        type: "transactionReceipt";
+    };
+}>>;
+//# sourceMappingURL=base.d.ts.map

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

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