voltaire-effect 0.3.0 → 1.0.1

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { AddressType as AddressType$3 } from '@tevm/voltaire/Address';
 export { AddressType, BrandedAddress } from '@tevm/voltaire/Address';
-import { HexType } from '@tevm/voltaire/Hex';
 export { Hex as HexBrand, HexType, Sized } from '@tevm/voltaire/Hex';
 export { HashType } from '@tevm/voltaire/Hash';
 export { AbstractError, CryptoError, DecodingError, EncodingError, IntegerOverflowError, IntegerUnderflowError, InvalidChecksumError, InvalidFormatError, InvalidLengthError, InvalidPrivateKeyError, InvalidPublicKeyError, InvalidRangeError, InvalidSignatureError, InvalidSignerError, InvalidSizeError, InvalidTransactionTypeError, PrimitiveError, SerializationError, TransactionError, ValidationError } from '@tevm/voltaire/errors';
@@ -13,14 +12,14 @@ import * as S from 'effect/Schema';
 import { b as KeccakLive, K as KeccakService, d as KeccakServiceShape, c as KeccakTest, P as ProviderService } from './ProviderService-BZ5pqDrD.js';
 export { a as ProviderShape, T as TransportError } from './ProviderService-BZ5pqDrD.js';
 import { I as InvalidPrivateKeyError, a as InvalidPublicKeyError, b as InvalidRecoveryIdError, c as InvalidSignatureError, d as Secp256k1Error, e as Secp256k1Errors, S as Secp256k1Service, f as Secp256k1ServiceShape, g as SignOptions, m as mapToSecp256k1Error } from './Secp256k1Service-OxQ6hJFp.js';
-import { aN as hash, bn as Secp256k1Live, bo as Secp256k1Test, bm as recover, bp as sign, bq as verify, ae as EIP712Live, E as EIP712Service, af as EIP712ServiceShape, ag as EIP712Test, ah as hashDomain, ai as hashStruct, aj as hashTypedData, ak as recoverAddress, al as signTypedData, am as verifyTypedData, h as SignatureInput, s as Bip39Live, B as Bip39Service, t as Bip39ServiceShape, u as Bip39Test, br as MnemonicStrength, bs as WORD_COUNTS, v as generateMnemonic, w as getWordCount, x as mnemonicToSeed, y as mnemonicToSeedSync, z as validateMnemonic, D as Blake2Live, a as Blake2Service, F as Blake2Test, G as hash$1, J as Bls12381Live, b as Bls12381Service, L as Bls12381ServiceShape, I as aggregate, M as sign$1, N as verify$1, O as Bn254Error, Q as Bn254Live, c as Bn254Service, T as Bn254ServiceShape, U as Bn254Test, W as g1Add, X as g1Generator, Y as g1Mul, Z as g2Add, _ as g2Generator, $ as g2Mul, a0 as pairingCheck, bt as ChaCha20Poly1305Error, a1 as ChaCha20Poly1305Live, C as ChaCha20Poly1305Service, a2 as ChaCha20Poly1305ServiceShape, a3 as ChaCha20Poly1305Test, bu as InvalidKeyError, bv as InvalidNonceError, a4 as decrypt, a5 as encrypt, a6 as generateKey, a7 as generateNonce, a8 as Ed25519Live, d as Ed25519Service, a9 as Ed25519ServiceShape, aa as Ed25519Test, ab as getPublicKey, ac as sign$2, ad as verify$2, an as unwrapSignature, ao as verifySignature, ap as wrapSignature, ax as HDNode, ay as HDPath, az as HDWalletError, e as HDWalletService, aA as HDWalletServiceShape, aB as HDWalletTest, aw as HardenedDerivationError, aC as InvalidKeyError$1, aD as InvalidPathError, aE as InvalidSeedError, aq as derive, ar as fromMnemonic, as as fromSeed, at as generateMnemonic$1, au as getPrivateKey, av as getPublicKey$1, bw as mapToHDWalletError, aF as mnemonicToSeed$1, aG as withPrivateKey, aH as withSeed, aI as HMACLive, H as HMACService, aJ as HMACServiceShape, aK as HMACTest, aL as hmacSha256, aM as hmacSha512, aO as DecryptError, aR as KeystoreLive, K as KeystoreService, aS as KeystoreServiceShape, aT as KeystoreTest, aP as decrypt$1, aQ as encrypt$1, aU as withDecryptedKey, aV as blobToKzgCommitment, aW as computeBlobKzgProof, aX as verifyBlobKzgProof, aZ as ModExpLive, a_ as ModExpService, a$ as ModExpServiceShape, b0 as ModExpTest, aY as calculateGas, b1 as modexp, b2 as modexpBytes, b3 as P256Live, P as P256Service, b4 as P256ServiceShape, b5 as sign$3, b6 as verify$3, b8 as Ripemd160Live, R as Ripemd160Service, b9 as Ripemd160Test, b7 as hash$2, bb as SHA256Live, S as SHA256Service, bc as SHA256Test, ba as hash$3, bi as X25519Live, bj as X25519Service, bk as X25519ServiceShape, bl as X25519Test, bf as computeSecret, bg as generateKeyPair, bh as getPublicKey$2 } from './X25519Test-D5Q-5fL9.js';
-export { i as AesGcm, f as CryptoLive, g as CryptoTest } from './X25519Test-D5Q-5fL9.js';
-import { bm as SiweMessageType } from './index-3UKSP3cd.js';
-export { i as AccessList, a as AccountState, b as Address, c as Authorization, d as Balance, e as Base64, f as BaseFeePerGas, g as BeaconBlockRoot, h as BinaryTree, j as Blob, k as Block, l as BlockBody, m as BlockFilter, n as BlockHash, o as BlockHeader, p as BlockNumber, q as BloomFilter, r as BuilderBid, s as Bundle, t as BundleHash, u as Bundler, v as Bytecode, w as Bytes, x as Bytes32, y as CallData, z as CallTrace, A as Chain, B as ChainHead, C as ChainId, D as CompilerVersion, E as ContractCode, F as ContractResult, G as ContractSignature, H as DecodedData, I as Denomination, J as Domain, K as DomainSeparator, L as EffectiveGasPrice, M as EncodedData, N as Ens, O as EntryPoint, P as Epoch, Q as ErrorSignature, R as EventLog, S as EventSignature, T as FeeMarket, U as FeeOracle, V as FilterId, W as ForkId, X as ForwardRequest, Y as FunctionSignature, Z as Gas, _ as GasConstants, $ as GasCosts, a0 as GasEstimate, a1 as GasPrice, a2 as GasRefund, a3 as GasUsed, a4 as Hardfork, a5 as Hash, a6 as Hex, a7 as InitCode, ac as Int128, a9 as Int16, ad as Int256, aa as Int32, ab as Int64, a8 as Int8, ae as License, af as LogFilter, ag as LogIndex, ah as MaxFeePerGas, ai as MaxPriorityFeePerGas, aj as MemoryDump, ak as MerkleTree, al as Metadata, am as MultiTokenId, an as NetworkId, ao as NodeInfo, ap as Nonce, ar as OpStep, aq as Opcode, as as PackedUserOperation, at as Paymaster, au as PeerId, av as PeerInfo, aw as PendingTransactionFilter, ax as Permit, ay as PrivateKey, az as Proof, aA as ProtocolVersion, aB as Proxy, aC as PublicKey, aD as Receipt, aE as RelayData, aF as ReturnData, aG as RevertReason, aH as Rlp, aI as RuntimeCode, aJ as Selector, aK as Signature, aL as SignedData, aM as Siwe, aN as Slot, aO as SourceMap, aP as Ssz, aQ as State, aR as StateDiff, aS as StateProof, aT as StateRoot, aU as StealthAddress, aV as Storage, aW as StorageDiff, aX as StorageProof, aY as StorageValue, aZ as StructLog, a_ as SyncStatus, a$ as TokenBalance, b0 as TokenId, b1 as TopicFilter, b2 as TraceConfig, b3 as TraceResult, b4 as Transaction, b5 as TransactionHash, b6 as TransactionIndex, b7 as TransactionStatus, b8 as TransactionUrl, b9 as TypedData, ba as U256, bb as Uint, bg as Uint128, bd as Uint16, be as Uint32, bf as Uint64, bc as Uint8, bh as Uncle, bi as UserOperation, bj as ValidatorIndex, bk as Withdrawal, bl as WithdrawalIndex } from './index-3UKSP3cd.js';
+import { aN as hash, bv as Secp256k1Live, bw as Secp256k1Test, bu as recover, bx as sign, by as verify, ae as EIP712Live, E as EIP712Service, af as EIP712ServiceShape, ag as EIP712Test, ah as hashDomain, ai as hashStruct, aj as hashTypedData, ak as recoverAddress, al as signTypedData, am as verifyTypedData, h as SignatureInput, s as Bip39Live, B as Bip39Service, t as Bip39ServiceShape, u as Bip39Test, bz as MnemonicStrength, bA as WORD_COUNTS, v as generateMnemonic, w as getWordCount, x as mnemonicToSeed, y as mnemonicToSeedSync, z as validateMnemonic, D as Blake2Live, a as Blake2Service, F as Blake2Test, G as hash$1, J as Bls12381Live, b as Bls12381Service, L as Bls12381ServiceShape, I as aggregate, M as sign$1, N as verify$1, O as Bn254Error, Q as Bn254Live, c as Bn254Service, T as Bn254ServiceShape, U as Bn254Test, W as g1Add, X as g1Generator, Y as g1Mul, Z as g2Add, _ as g2Generator, $ as g2Mul, a0 as pairingCheck, bB as ChaCha20Poly1305Error, a1 as ChaCha20Poly1305Live, C as ChaCha20Poly1305Service, a2 as ChaCha20Poly1305ServiceShape, a3 as ChaCha20Poly1305Test, bC as InvalidKeyError, bD as InvalidNonceError, a4 as decrypt, a5 as encrypt, a6 as generateKey, a7 as generateNonce, a8 as Ed25519Live, d as Ed25519Service, a9 as Ed25519ServiceShape, aa as Ed25519Test, ab as getPublicKey, ac as sign$2, ad as verify$2, an as unwrapSignature, ao as verifySignature, ap as wrapSignature, ax as HDNode, ay as HDPath, az as HDWalletError, e as HDWalletService, aA as HDWalletServiceShape, aB as HDWalletTest, aw as HardenedDerivationError, aC as InvalidKeyError$1, aD as InvalidPathError, aE as InvalidSeedError, aq as derive, ar as fromMnemonic, as as fromSeed, at as generateMnemonic$1, au as getPrivateKey, av as getPublicKey$1, bE as mapToHDWalletError, aF as mnemonicToSeed$1, aG as withPrivateKey, aH as withSeed, aI as HMACLive, H as HMACService, aJ as HMACServiceShape, aK as HMACTest, aL as hmacSha256, aM as hmacSha512, aO as DecryptError, aR as KeystoreLive, K as KeystoreService, aS as KeystoreServiceShape, aT as KeystoreTest, aP as decrypt$1, aQ as encrypt$1, aU as withDecryptedKey, aV as blobToKzgCommitment, aW as computeBlobKzgProof, aX as verifyBlobKzgProof, aZ as ModExpLive, a_ as ModExpService, a$ as ModExpServiceShape, b0 as ModExpTest, aY as calculateGas, b1 as modexp, b2 as modexpBytes, b3 as P256Live, P as P256Service, b4 as P256ServiceShape, b5 as sign$3, b6 as verify$3, b8 as Ripemd160Live, R as Ripemd160Service, b9 as Ripemd160Test, b7 as hash$2, bb as SHA256Live, S as SHA256Service, bc as SHA256Test, ba as hash$3, bF as CryptoError, bG as InvalidPrivateKeyError$1, bi as Signer, bj as SignersLive, bk as SignersService, bl as SignersServiceShape, bm as SignersTest, bf as fromPrivateKey, bg as getAddress, bh as recoverTransactionAddress, bq as X25519Live, br as X25519Service, bs as X25519ServiceShape, bt as X25519Test, bn as computeSecret, bo as generateKeyPair, bp as getPublicKey$2 } from './X25519Test-avt1DUgp.js';
+export { i as AesGcm, f as CryptoLive, g as CryptoTest } from './X25519Test-avt1DUgp.js';
+import { bn as SiweMessageType } from './index-DxwZo3xo.js';
+export { i as Abi, a as AccessList, b as AccountState, c as Address, d as Authorization, e as Balance, f as Base64, g as BaseFeePerGas, h as BeaconBlockRoot, j as BinaryTree, k as Blob, l as Block, m as BlockBody, n as BlockFilter, o as BlockHash, p as BlockHeader, q as BlockNumber, r as BloomFilter, s as BuilderBid, t as Bundle, u as BundleHash, v as Bundler, w as Bytecode, x as Bytes, y as Bytes32, z as CallData, A as CallTrace, B as Chain, C as ChainHead, D as ChainId, E as CompilerVersion, F as ContractCode, G as ContractResult, H as ContractSignature, I as DecodedData, J as Denomination, K as Domain, L as DomainSeparator, M as EffectiveGasPrice, N as EncodedData, O as Ens, P as EntryPoint, Q as Epoch, R as ErrorSignature, S as EventLog, T as EventSignature, U as FeeMarket, V as FeeOracle, W as FilterId, X as ForkId, Y as ForwardRequest, Z as FunctionSignature, _ as Gas, $ as GasConstants, a0 as GasCosts, a1 as GasEstimate, a2 as GasPrice, a3 as GasRefund, a4 as GasUsed, a5 as Hardfork, a6 as Hash, a7 as Hex, a8 as InitCode, ad as Int128, aa as Int16, ae as Int256, ab as Int32, ac as Int64, a9 as Int8, af as License, ag as LogFilter, ah as LogIndex, ai as MaxFeePerGas, aj as MaxPriorityFeePerGas, ak as MemoryDump, al as MerkleTree, am as Metadata, an as MultiTokenId, ao as NetworkId, ap as NodeInfo, aq as Nonce, as as OpStep, ar as Opcode, at as PackedUserOperation, au as Paymaster, av as PeerId, aw as PeerInfo, ax as PendingTransactionFilter, ay as Permit, az as PrivateKey, aA as Proof, aB as ProtocolVersion, aC as Proxy, aD as PublicKey, aE as Receipt, aF as RelayData, aG as ReturnData, aH as RevertReason, aI as Rlp, aJ as RuntimeCode, aK as Selector, aL as Signature, aM as SignedData, aN as Siwe, aO as Slot, aP as SourceMap, aQ as Ssz, aR as State, aS as StateDiff, aT as StateProof, aU as StateRoot, aV as StealthAddress, aW as Storage, aX as StorageDiff, aY as StorageProof, aZ as StorageValue, a_ as StructLog, a$ as SyncStatus, b0 as TokenBalance, b1 as TokenId, b2 as TopicFilter, b3 as TraceConfig, b4 as TraceResult, b5 as Transaction, b6 as TransactionHash, b7 as TransactionIndex, b8 as TransactionStatus, b9 as TransactionUrl, ba as TypedData, bb as U256, bc as Uint, bh as Uint128, be as Uint16, bf as Uint32, bg as Uint64, bd as Uint8, bi as Uncle, bj as UserOperation, bk as ValidatorIndex, bl as Withdrawal, bm as WithdrawalIndex } from './index-DxwZo3xo.js';
 import { BlockInclude, RetryOptions, StreamBlock, LightBlock, BackfillOptions, BlockStream, BlockStreamConstructorOptions, BlockStreamEvent, BlockStreamMetadata, BlockStreamOptions, BlocksEvent, ReorgEvent, WatchOptions } from '@tevm/voltaire/block';
 export { BackfillOptions, BlockInclude, BlockStreamEvent, BlocksEvent, WatchOptions } from '@tevm/voltaire/block';
 import { TransportService } from './services/index.js';
-export { AbiDecodeError, AbiEncodeError, AbiEncoderService, AbiEncoderShape, AccessListInput, AccessListType, AccountError, AccountService, AccountShape, AccountStateOverride, AddressInput, ArbitrumFormatter, ArbitrumProvider, AssetChange, BackfillBlocksError, BalanceResolver, BaseProvider, BlockExplorerConfig, BlockExplorerService, BlockOverrides, BlockStream, BlockStreamError, BlockStreamService, BlockStreamShape, BlockTag, BlockType, BlockchainError, BlockchainHexInput, BlockchainService, BlockchainShape, BrowserProvider, BrowserTransport, CacheService, CacheShape, CallError, CallRequest, CcipError, CcipRequest, CcipService, CcipShape, ChainConfig, ChainContract, ChainService, ComposedServices, Contract, ContractAbi, ContractAbiItem, ContractBlockTag, ContractCall, ContractCallError, ContractDef, ContractError, ContractEventError, ContractFactory, ContractInstance, ContractRegistryBase, ContractRegistryConfig, ContractRegistryService, ContractRegistryShape, ContractWriteError, ContractsConfig, ContractsService, CreateAccessListError, CreateAccessListResult, CreateBlockFilterError, CreateEventFilterError, CreatePendingTransactionFilterError, CustomTransport, CustomTransportConfig, CustomTransportFromFn, Debug, DebugService, DebugShape, DebugTraceConfig, DecodedEvent, DefaultAbiEncoder, DefaultCcip, DefaultEns, DefaultFeeEstimator, DefaultFormatter, DefaultKzg, DefaultNonceManager, DefaultRateLimiter, DefaultTransactionSerializer, DeserializeError, EIP1193Provider, ENS_REGISTRY_ADDRESS, ENS_UNIVERSAL_RESOLVER_ADDRESS, EngineApi, EngineApiService, EngineApiShape, EnsError, EnsService, EnsShape, EstimateGasError, EthBlockNumber, EthCall, EthChainId, EthEstimateGas, EthGasPrice, EthGetBalance, EthGetBlockByHash, EthGetBlockByNumber, EthGetCode, EthGetLogs, EthGetStorageAt, EthGetTransactionByHash, EthGetTransactionCount, EthGetTransactionReceipt, EventFilter, FeeEstimationError, FeeEstimatorService, FeeEstimatorShape, FeeHistoryType, FeeValues, FeeValuesEIP1559, FeeValuesLegacy, FilterChanges, ForkBlockchain, ForkBlockchainOptions, FormatError, FormatterService, FormatterShape, GenericRpcRequest, GetAccountsError, GetBalance, GetBalanceError, GetBlobBaseFeeError, GetBlockArgs, GetBlockError, GetBlockNumberError, GetBlockReceiptsArgs, GetBlockReceiptsError, GetBlockTransactionCountArgs, GetBlockTransactionCountError, GetChainIdError, GetCodeError, GetCoinbaseError, GetEnsAddressParams, GetEnsAvatarParams, GetEnsNameParams, GetEnsResolverParams, GetEnsTextParams, GetFeeHistoryError, GetFilterChangesError, GetFilterLogsError, GetGasPriceError, GetHashrateError, GetLogsError, GetMaxPriorityFeePerGasError, GetMiningError, GetProofError, GetProtocolVersionError, GetStorageAtError, GetSyncingError, GetTransactionByBlockHashAndIndexError, GetTransactionByBlockNumberAndIndexError, GetTransactionConfirmationsError, GetTransactionCountError, GetTransactionError, GetTransactionReceiptError, GetUncleArgs, GetUncleCountArgs, GetUncleCountError, GetUncleError, GetWorkError, HashInput, HttpProvider, HttpProviderFetch, HttpTransport, IdGenerator, IdGeneratorLive, IdGeneratorShape, InMemoryBlockchain, InferContractRegistry, IpcProvider, JsonRpcAccount, KzgError, KzgService, KzgShape, LocalAccount, LogType, MULTICALL3_ADDRESS, MainnetFullProvider, MainnetProvider, MemoryCache, MemoryCacheOptions, MulticallCall, MulticallError, MulticallParams, MulticallResult, MulticallResults, NetVersionError, NonceError, NonceManagerService, NonceManagerShape, NoopCache, NoopCcip, NoopKzg, NoopRateLimiter, OptimismFormatter, OptimismProvider, PolygonProvider, ProofType, Provider, ProviderConfirmationsPendingError, ProviderError, ProviderNotFoundError, ProviderReceiptPendingError, ProviderResponseError, ProviderStepConfig, ProviderStreamError, ProviderTimeoutError, ProviderValidationError, RateLimitBehavior, RateLimitError, RateLimitedTransport, RateLimiterConfig, RateLimiterService, RateLimiterShape, RawProviderService, RawProviderShape, RawProviderTransport, RawRequestArguments, ReadContractError, ReadContractParams, ReceiptType, RpcBatch, RpcBatchService, RpcBatchShape, RpcRequest, RpcTransactionRequest, RpcUrlsConfig, SendRawTransactionError, SendTransactionError, SepoliaProvider, SerializeError, SignError, SignTransactionError, Signer, SignerError, SignerService, SignerShape, SimulateCallsError, SimulateCallsParams, SimulateContractError, SimulateContractParams, SimulateContractResult, SimulateV1BlockCall, SimulateV1BlockResult, SimulateV1CallResult, SimulateV1Error, SimulateV1Payload, SimulateV1Result, SimulateV2Error, SimulateV2Payload, SimulateV2Result, SimulationResult, StateOverride, StorageProofType, SubmitHashrateError, SubmitWorkError, SubscribeError, SyncingStatus, TestProvider, TestTransport, TransactionIndexInput, TransactionRequest, TransactionSerializerService, TransactionStream, TransactionStreamError, TransactionStreamService, TransactionStreamShape, TransactionType, TransportShape, UncleBlockType, UninstallFilterError, UnsignedTransaction, UnsubscribeError, WaitForTransactionReceiptArgs, WaitForTransactionReceiptError, WaitForTransactionReceiptOptions, WatchBlocksError, WebSocketProvider, WebSocketProviderConfig, WebSocketProviderGlobal, WebSocketTransport, WithdrawalType, ZkSyncFormatter, aggregate3, arbitrum, arbitrumBlockExplorers, arbitrumConfig, arbitrumContracts, backfillBlocks, base, baseBlockExplorers, baseConfig, baseContracts, bytesToHex, cacheEnabledRef, call, createAccessList, createBlockFilter, createEventFilter, createPendingTransactionFilter, createProvider, estimateGas, formatAccessList, formatCallRequest, formatLogFilterParams, formatTransactionRequest, getAccounts, getBalance, getBlobBaseFee, getBlock, getBlockNumber, getBlockReceipts, getBlockTransactionCount, getChainId, getCode, getCoinbase, getEnsAddress, getEnsAvatar, getEnsName, getEnsResolver, getEnsText, getFeeHistory, getFilterChanges, getFilterLogs, getGasPrice, getHashrate, getLogs, getMaxPriorityFeePerGas, getMining, getProof, getProtocolVersion, getStorageAt, getSyncing, getTransaction, getTransactionByBlockHashAndIndex, getTransactionByBlockNumberAndIndex, getTransactionConfirmations, getTransactionCount, getTransactionReceipt, getUncle, getUncleCount, mainnet, mainnetBlockExplorers, mainnetConfig, mainnetContracts, makeBlockStream, makeContractRegistry, makeFeeEstimator, makeIdGenerator, makeProviderPlan, makeRateLimiter, makeResilientProviderPlan, makeRpcResolver, makeTransactionStream, multicall, netVersion, nextId, optimism, optimismBlockExplorers, optimismConfig, optimismContracts, parseHexToBigInt, polygon, polygonBlockExplorers, polygonConfig, polygonContracts, readContract, retryScheduleRef, rpcUrlsByChainId, sendRawTransaction, sendTransaction, sepolia, sepoliaBlockExplorers, sepoliaConfig, sepoliaContracts, sign, signTransaction, simulateCalls, simulateContract, simulateV1, simulateV2, subscribe, timeoutRef, toAddressHex, toHashHex, tracingRef, uninstallFilter, unsubscribe, waitForTransactionReceipt, watchBlocks, withRetrySchedule, withTimeout, withTracing, withoutCache } from './services/index.js';
+export { AbiDecodeError, AbiEncodeError, AbiEncoderService, AbiEncoderShape, AbiResolution, AccessListInput, AccessListType, AccountError, AccountService, AccountShape, AccountStateOverride, AddressInput, ArbitrumFormatter, ArbitrumProvider, AssetChange, BackfillBlocksError, BalanceResolver, BaseProvider, BlockExplorerApi, BlockExplorerApiConfig, BlockExplorerApiError, BlockExplorerApiService, BlockExplorerApiShape, BlockExplorerConfig, BlockExplorerConfigError, BlockExplorerDecodeError, BlockExplorerNotFoundError, BlockExplorerProxyResolutionError, BlockExplorerRateLimitError, BlockExplorerResponseError, BlockExplorerService, BlockExplorerUnexpectedError, BlockOverrides, BlockStream, BlockStreamError, BlockStreamService, BlockStreamShape, BlockTag, BlockType, BlockchainError, BlockchainHexInput, BlockchainService, BlockchainShape, BrowserProvider, BrowserTransport, CacheService, CacheShape, CallError, CallRequest, CcipError, CcipRequest, CcipService, CcipShape, ChainConfig, ChainContract, ChainService, ComposedServices, Contract, ContractAbi, ContractAbiItem, ContractBlockTag, ContractCall, ContractCallError, ContractDef, ContractError, ContractEventError, ContractFactory, ContractInstance, ContractRegistryBase, ContractRegistryConfig, ContractRegistryService, ContractRegistryShape, ContractSourceFile, ContractWriteError, ContractsConfig, ContractsService, CreateAccessListError, CreateAccessListResult, CreateBlockFilterError, CreateEventFilterError, CreatePendingTransactionFilterError, CustomTransport, CustomTransportConfig, CustomTransportFromFn, Debug, DebugService, DebugShape, DebugTraceConfig, DecodedEvent, DefaultAbiEncoder, DefaultCcip, DefaultEns, DefaultFeeEstimator, DefaultFormatter, DefaultKzg, DefaultNonceManager, DefaultRateLimiter, DefaultTransactionSerializer, DeserializeError, EIP1193Provider, ENS_REGISTRY_ADDRESS, ENS_UNIVERSAL_RESOLVER_ADDRESS, EngineApi, EngineApiService, EngineApiShape, EnsError, EnsService, EnsShape, EstimateGasError, EthBlockNumber, EthCall, EthChainId, EthEstimateGas, EthGasPrice, EthGetBalance, EthGetBlockByHash, EthGetBlockByNumber, EthGetCode, EthGetLogs, EthGetStorageAt, EthGetTransactionByHash, EthGetTransactionCount, EthGetTransactionReceipt, EventFilter, ExplorerAbiItem, ExplorerContractInstance, ExplorerSourceId, FeeEstimationError, FeeEstimatorService, FeeEstimatorShape, FeeHistoryType, FeeValues, FeeValuesEIP1559, FeeValuesLegacy, FilterChanges, ForkBlockchain, ForkBlockchainOptions, FormatError, FormatterService, FormatterShape, GenericRpcRequest, GetAbiOptions, GetAccountsError, GetBalance, GetBalanceError, GetBlobBaseFeeError, GetBlockArgs, GetBlockError, GetBlockNumberError, GetBlockReceiptsArgs, GetBlockReceiptsError, GetBlockTransactionCountArgs, GetBlockTransactionCountError, GetChainIdError, GetCodeError, GetCoinbaseError, GetContractOptions, GetEnsAddressParams, GetEnsAvatarParams, GetEnsNameParams, GetEnsResolverParams, GetEnsTextParams, GetFeeHistoryError, GetFilterChangesError, GetFilterLogsError, GetGasPriceError, GetHashrateError, GetLogsError, GetMaxPriorityFeePerGasError, GetMiningError, GetProofError, GetProtocolVersionError, GetSourcesOptions, GetStorageAtError, GetSyncingError, GetTransactionByBlockHashAndIndexError, GetTransactionByBlockNumberAndIndexError, GetTransactionConfirmationsError, GetTransactionCountError, GetTransactionError, GetTransactionReceiptError, GetUncleArgs, GetUncleCountArgs, GetUncleCountError, GetUncleError, GetWorkError, HashInput, HttpProvider, HttpProviderFetch, HttpTransport, IdGenerator, IdGeneratorLive, IdGeneratorShape, InMemoryBlockchain, InferContractRegistry, IpcProvider, JsonRpcAccount, KzgError, KzgService, KzgShape, LocalAccount, LogType, MULTICALL3_ADDRESS, MainnetFullProvider, MainnetProvider, MemoryCache, MemoryCacheOptions, MulticallCall, MulticallError, MulticallParams, MulticallResult, MulticallResults, NetVersionError, NonceError, NonceManagerService, NonceManagerShape, NoopCache, NoopCcip, NoopKzg, NoopRateLimiter, OptimismFormatter, OptimismProvider, PolygonProvider, ProofType, Provider, ProviderConfirmationsPendingError, ProviderError, ProviderNotFoundError, ProviderReceiptPendingError, ProviderResponseError, ProviderStepConfig, ProviderStreamError, ProviderTimeoutError, ProviderValidationError, ProxyInfo, RateLimitBehavior, RateLimitError, RateLimitedTransport, RateLimiterConfig, RateLimiterService, RateLimiterShape, RawProviderService, RawProviderShape, RawProviderTransport, RawRequestArguments, ReadContractError, ReadContractParams, ReceiptType, ResolvedExplorerContract, RpcBatch, RpcBatchService, RpcBatchShape, RpcRequest, RpcTransactionRequest, RpcUrlsConfig, SendRawTransactionError, SendTransactionError, SepoliaProvider, SerializeError, SignError, SignTransactionError, Signer, SignerError, SignerService, SignerShape, SimulateCallsError, SimulateCallsParams, SimulateContractError, SimulateContractParams, SimulateContractResult, SimulateV1BlockCall, SimulateV1BlockResult, SimulateV1CallResult, SimulateV1Error, SimulateV1Payload, SimulateV1Result, SimulateV2Error, SimulateV2Payload, SimulateV2Result, SimulationResult, StateOverride, StorageProofType, SubmitHashrateError, SubmitWorkError, SubscribeError, SyncingStatus, TestProvider, TestTransport, TransactionIndexInput, TransactionRequest, TransactionSerializerService, TransactionStream, TransactionStreamError, TransactionStreamService, TransactionStreamShape, TransactionType, TransportShape, UncleBlockType, UninstallFilterError, UnsignedTransaction, UnsubscribeError, WaitForTransactionReceiptArgs, WaitForTransactionReceiptError, WaitForTransactionReceiptOptions, WatchBlocksError, WebSocketProvider, WebSocketProviderConfig, WebSocketProviderGlobal, WebSocketTransport, WithdrawalType, ZkSyncFormatter, aggregate3, arbitrum, arbitrumBlockExplorers, arbitrumConfig, arbitrumContracts, backfillBlocks, base, baseBlockExplorers, baseConfig, baseContracts, bytesToHex, cacheEnabledRef, call, createAccessList, createBlockFilter, createEventFilter, createPendingTransactionFilter, createProvider, estimateGas, formatAccessList, formatCallRequest, formatLogFilterParams, formatTransactionRequest, getAccounts, getBalance, getBlobBaseFee, getBlock, getBlockNumber, getBlockReceipts, getBlockTransactionCount, getChainId, getCode, getCoinbase, getEnsAddress, getEnsAvatar, getEnsName, getEnsResolver, getEnsText, getFeeHistory, getFilterChanges, getFilterLogs, getGasPrice, getHashrate, getLogs, getMaxPriorityFeePerGas, getMining, getProof, getProtocolVersion, getStorageAt, getSyncing, getTransaction, getTransactionByBlockHashAndIndex, getTransactionByBlockNumberAndIndex, getTransactionConfirmations, getTransactionCount, getTransactionReceipt, getUncle, getUncleCount, mainnet, mainnetBlockExplorers, mainnetConfig, mainnetContracts, makeBlockStream, makeContractRegistry, makeFeeEstimator, makeIdGenerator, makeProviderPlan, makeRateLimiter, makeResilientProviderPlan, makeRpcResolver, makeTransactionStream, multicall, netVersion, nextId, optimism, optimismBlockExplorers, optimismConfig, optimismContracts, parseHexToBigInt, polygon, polygonBlockExplorers, polygonConfig, polygonContracts, readContract, retryScheduleRef, rpcUrlsByChainId, sendRawTransaction, sendTransaction, sepolia, sepoliaBlockExplorers, sepoliaConfig, sepoliaContracts, sign, signTransaction, simulateCalls, simulateContract, simulateV1, simulateV2, subscribe, timeoutRef, toAddressHex, toHashHex, tracingRef, uninstallFilter, unsubscribe, waitForTransactionReceipt, watchBlocks, withRetrySchedule, withTimeout, withTracing, withoutCache } from './services/index.js';
 import * as Layer from 'effect/Layer';
 import { Keccak256Hash, BrandedAbi, BrandedAddress } from '@tevm/voltaire';
 import { EventStreamConstructorOptions, BackfillOptions as BackfillOptions$1, EventStreamResult, WatchOptions as WatchOptions$1 } from '@tevm/voltaire/contract';
@@ -28,8 +27,6 @@ import * as Context from 'effect/Context';
 import * as Stream from 'effect/Stream';
 import { a as KZGError, b as KZGLive, K as KZGService, c as KZGServiceShape, d as KZGTest } from './KZGService-B7PJerOb.js';
 import * as effect_SchemaAST from 'effect/SchemaAST';
-import * as _tevm_voltaire_Abi from '@tevm/voltaire/Abi';
-import { ItemType, AbiItemNotFoundError, AbiEncodingError, AbiParameterMismatchError, WrappedErrorType, AbiDecodingError, AbiInvalidSelectorError as AbiInvalidSelectorError$1, Error as Error$1, Event, Function, Item as Item$1, Abi as Abi$1 } from '@tevm/voltaire/Abi';
 import * as _tevm_voltaire_stream from '@tevm/voltaire/stream';
 import { BlockRangeTooLargeError, BlockStreamAbortedError, EventStreamAbortedError, StreamAbortedError, UnrecoverableReorgError } from '@tevm/voltaire/stream';
 import '@tevm/voltaire/Secp256k1';
@@ -43,6 +40,7 @@ import '@tevm/voltaire/P256';
 import '@tevm/voltaire/X25519';
 import '@tevm/voltaire/Siwe';
 import 'effect';
+import '@tevm/voltaire/Abi';
 import '@tevm/voltaire/AccessList';
 import '@tevm/voltaire/Bytes';
 import '@tevm/voltaire/functional';
@@ -700,17 +698,17 @@ declare class EventStreamError extends EventStreamError_base<{
  * @see {@link TransportService} - Required dependency
  */
 
-type EventType$1 = BrandedAbi.Event.EventType;
+type EventType = BrandedAbi.Event.EventType;
 
 /**
  * Options for backfill with address and event included
  */
-interface BackfillStreamOptions<TEvent extends EventType$1> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, BackfillOptions$1 {
+interface BackfillStreamOptions<TEvent extends EventType> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, BackfillOptions$1 {
 }
 /**
  * Options for watch with address and event included
  */
-interface WatchStreamOptions<TEvent extends EventType$1> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, WatchOptions$1 {
+interface WatchStreamOptions<TEvent extends EventType> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, WatchOptions$1 {
 }
 /**
  * Shape of the EventStream service.
@@ -737,7 +735,7 @@ type EventStreamShape = {
      * });
      * ```
      */
-    readonly backfill: <TEvent extends EventType$1>(options: BackfillStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
+    readonly backfill: <TEvent extends EventType>(options: BackfillStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
     /**
      * Watch for new events by polling.
      *
@@ -755,7 +753,7 @@ type EventStreamShape = {
      * });
      * ```
      */
-    readonly watch: <TEvent extends EventType$1>(options: WatchStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
+    readonly watch: <TEvent extends EventType>(options: WatchStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
 };
 declare const EventStreamService_base: Context.TagClass<EventStreamService, "EventStreamService", EventStreamShape>;
 /**
@@ -1524,6 +1522,51 @@ declare namespace index$d {
   export { index$d_SHA256Live as SHA256Live, index$d_SHA256Service as SHA256Service, index$d_SHA256Test as SHA256Test, hash$3 as hash };
 }
 
+/**
+ * @fileoverview Ethereum signers module for Effect.
+ * Provides cryptographic signing of messages, transactions, and typed data.
+ *
+ * @module Signers
+ * @since 0.0.1
+ *
+ * @description
+ * Signers handle cryptographic signing operations for Ethereum. Each signer
+ * encapsulates a private key and provides methods for:
+ *
+ * - Message signing (EIP-191 personal_sign)
+ * - Transaction signing
+ * - Typed data signing (EIP-712)
+ *
+ * @example
+ * ```typescript
+ * import { SignersService, SignersLive, fromPrivateKey, getAddress } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signer = yield* fromPrivateKey('0x...')
+ *   const address = yield* getAddress(signer)
+ *   const sig = yield* signer.signMessage('Hello World')
+ *   return { address, sig }
+ * }).pipe(Effect.provide(SignersLive))
+ * ```
+ *
+ * @see {@link https://eips.ethereum.org/EIPS/eip-191 | EIP-191}
+ * @see {@link https://eips.ethereum.org/EIPS/eip-712 | EIP-712}
+ */
+
+declare const index$c_CryptoError: typeof CryptoError;
+declare const index$c_Signer: typeof Signer;
+declare const index$c_SignersLive: typeof SignersLive;
+declare const index$c_SignersService: typeof SignersService;
+declare const index$c_SignersServiceShape: typeof SignersServiceShape;
+declare const index$c_SignersTest: typeof SignersTest;
+declare const index$c_fromPrivateKey: typeof fromPrivateKey;
+declare const index$c_getAddress: typeof getAddress;
+declare const index$c_recoverTransactionAddress: typeof recoverTransactionAddress;
+declare namespace index$c {
+  export { index$c_CryptoError as CryptoError, InvalidPrivateKeyError$1 as InvalidPrivateKeyError, index$c_Signer as Signer, index$c_SignersLive as SignersLive, index$c_SignersService as SignersService, index$c_SignersServiceShape as SignersServiceShape, index$c_SignersTest as SignersTest, index$c_fromPrivateKey as fromPrivateKey, index$c_getAddress as getAddress, getAddress as getSignerAddress, index$c_recoverTransactionAddress as recoverTransactionAddress };
+}
+
 /**
  * @fileoverview X25519 key exchange module for Effect.
  * Provides Curve25519 ECDH for secure shared secret generation.
@@ -1559,15 +1602,23 @@ declare namespace index$d {
  * @see {@link https://datatracker.ietf.org/doc/html/rfc7748 | RFC 7748}
  */
 
-declare const index$c_X25519Live: typeof X25519Live;
-declare const index$c_X25519Service: typeof X25519Service;
-declare const index$c_X25519ServiceShape: typeof X25519ServiceShape;
-declare const index$c_X25519Test: typeof X25519Test;
-declare const index$c_computeSecret: typeof computeSecret;
-declare const index$c_generateKeyPair: typeof generateKeyPair;
-declare namespace index$c {
-  export { index$c_X25519Live as X25519Live, index$c_X25519Service as X25519Service, index$c_X25519ServiceShape as X25519ServiceShape, index$c_X25519Test as X25519Test, index$c_computeSecret as computeSecret, index$c_generateKeyPair as generateKeyPair, getPublicKey$2 as getPublicKey };
+declare const index$b_X25519Live: typeof X25519Live;
+declare const index$b_X25519Service: typeof X25519Service;
+declare const index$b_X25519ServiceShape: typeof X25519ServiceShape;
+declare const index$b_X25519Test: typeof X25519Test;
+declare const index$b_computeSecret: typeof computeSecret;
+declare const index$b_generateKeyPair: typeof generateKeyPair;
+declare namespace index$b {
+  export { index$b_X25519Live as X25519Live, index$b_X25519Service as X25519Service, index$b_X25519ServiceShape as X25519ServiceShape, index$b_X25519Test as X25519Test, index$b_computeSecret as computeSecret, index$b_generateKeyPair as generateKeyPair, getPublicKey$2 as getPublicKey };
+}
+
+type IdCounterShape = {
+    readonly next: () => Effect.Effect<number>;
+};
+declare const IdCounterService_base: Context.TagClass<IdCounterService, "IdCounterService", IdCounterShape>;
+declare class IdCounterService extends IdCounterService_base {
 }
+declare const IdCounterLive: Layer.Layer<IdCounterService>;
 
 type JsonRpcIdType = number | string | null;
 type JsonRpcRequestType<TParams = unknown[]> = {
@@ -1582,70 +1633,70 @@ declare function from$4(input: {
     id?: JsonRpcIdType;
 }): JsonRpcRequestType;
 declare function isNotification(request: JsonRpcRequestType): boolean;
-declare function withParams<TParams>(request: JsonRpcRequestType): (params: TParams) => JsonRpcRequestType<TParams>;
+declare function withParams<TParams>(request: JsonRpcRequestType): (params: TParams) => Effect.Effect<JsonRpcRequestType<TParams>, never, IdCounterService>;
 declare const Request: {
     from: typeof from$4;
     isNotification: typeof isNotification;
     withParams: typeof withParams;
 };
 
-declare const MineRequest$3: (blocks?: number, interval?: number) => JsonRpcRequestType;
-declare const SetBalanceRequest$3: (address: string, balance: string) => JsonRpcRequestType;
-declare const SetCodeRequest$3: (address: string, code: string) => JsonRpcRequestType;
-declare const SetNonceRequest$3: (address: string, nonce: string) => JsonRpcRequestType;
-declare const SetStorageAtRequest$3: (address: string, slot: string, value: string) => JsonRpcRequestType;
-declare const ImpersonateAccountRequest$3: (address: string) => JsonRpcRequestType;
-declare const StopImpersonatingAccountRequest$3: (address: string) => JsonRpcRequestType;
+declare const MineRequest$3: (blocks?: number, interval?: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetBalanceRequest$3: (address: string, balance: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetCodeRequest$3: (address: string, code: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetNonceRequest$3: (address: string, nonce: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetStorageAtRequest$3: (address: string, slot: string, value: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ImpersonateAccountRequest$3: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const StopImpersonatingAccountRequest$3: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const ResetRequest$3: (options?: {
     forking?: {
         jsonRpcUrl: string;
         blockNumber?: number;
     };
-}) => JsonRpcRequestType;
-declare const SetRpcUrlRequest: (url: string) => JsonRpcRequestType;
-declare const SetCoinbaseRequest$1: (address: string) => JsonRpcRequestType;
-declare const DumpStateRequest: () => JsonRpcRequestType;
-declare const LoadStateRequest: (state: string) => JsonRpcRequestType;
-declare const SnapshotRequest$1: () => JsonRpcRequestType;
-declare const RevertRequest$1: (snapshotId: string) => JsonRpcRequestType;
-declare const IncreaseTimeRequest: (seconds: number) => JsonRpcRequestType;
-declare const SetNextBlockTimestampRequest$1: (timestamp: number) => JsonRpcRequestType;
-declare const SetBlockGasLimitRequest: (gasLimit: string) => JsonRpcRequestType;
-declare const SetMinGasPriceRequest$1: (gasPrice: string) => JsonRpcRequestType;
-declare const DropTransactionRequest$3: (hash: string) => JsonRpcRequestType;
-declare const GetAutomineRequest: () => JsonRpcRequestType;
-declare const SetAutomineRequest$1: (enabled: boolean) => JsonRpcRequestType;
-declare const SetIntervalMiningRequest: (interval: number) => JsonRpcRequestType;
-declare const EnableTracesRequest: () => JsonRpcRequestType;
+}) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetRpcUrlRequest: (url: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetCoinbaseRequest$1: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const DumpStateRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const LoadStateRequest: (state: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SnapshotRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const RevertRequest$1: (snapshotId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const IncreaseTimeRequest: (seconds: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetNextBlockTimestampRequest$1: (timestamp: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetBlockGasLimitRequest: (gasLimit: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetMinGasPriceRequest$1: (gasPrice: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const DropTransactionRequest$3: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetAutomineRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetAutomineRequest$1: (enabled: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetIntervalMiningRequest: (interval: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const EnableTracesRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Anvil: {
-    MineRequest: (blocks?: number, interval?: number) => JsonRpcRequestType;
-    SetBalanceRequest: (address: string, balance: string) => JsonRpcRequestType;
-    SetCodeRequest: (address: string, code: string) => JsonRpcRequestType;
-    SetNonceRequest: (address: string, nonce: string) => JsonRpcRequestType;
-    SetStorageAtRequest: (address: string, slot: string, value: string) => JsonRpcRequestType;
-    ImpersonateAccountRequest: (address: string) => JsonRpcRequestType;
-    StopImpersonatingAccountRequest: (address: string) => JsonRpcRequestType;
+    MineRequest: (blocks?: number, interval?: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetBalanceRequest: (address: string, balance: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetCodeRequest: (address: string, code: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetNonceRequest: (address: string, nonce: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetStorageAtRequest: (address: string, slot: string, value: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ImpersonateAccountRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    StopImpersonatingAccountRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
     ResetRequest: (options?: {
         forking?: {
             jsonRpcUrl: string;
             blockNumber?: number;
         };
-    }) => JsonRpcRequestType;
-    SetRpcUrlRequest: (url: string) => JsonRpcRequestType;
-    SetCoinbaseRequest: (address: string) => JsonRpcRequestType;
-    DumpStateRequest: () => JsonRpcRequestType;
-    LoadStateRequest: (state: string) => JsonRpcRequestType;
-    SnapshotRequest: () => JsonRpcRequestType;
-    RevertRequest: (snapshotId: string) => JsonRpcRequestType;
-    IncreaseTimeRequest: (seconds: number) => JsonRpcRequestType;
-    SetNextBlockTimestampRequest: (timestamp: number) => JsonRpcRequestType;
-    SetBlockGasLimitRequest: (gasLimit: string) => JsonRpcRequestType;
-    SetMinGasPriceRequest: (gasPrice: string) => JsonRpcRequestType;
-    DropTransactionRequest: (hash: string) => JsonRpcRequestType;
-    GetAutomineRequest: () => JsonRpcRequestType;
-    SetAutomineRequest: (enabled: boolean) => JsonRpcRequestType;
-    SetIntervalMiningRequest: (interval: number) => JsonRpcRequestType;
-    EnableTracesRequest: () => JsonRpcRequestType;
+    }) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetRpcUrlRequest: (url: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetCoinbaseRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    DumpStateRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    LoadStateRequest: (state: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SnapshotRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    RevertRequest: (snapshotId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    IncreaseTimeRequest: (seconds: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetNextBlockTimestampRequest: (timestamp: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetBlockGasLimitRequest: (gasLimit: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetMinGasPriceRequest: (gasPrice: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    DropTransactionRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetAutomineRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetAutomineRequest: (enabled: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetIntervalMiningRequest: (interval: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    EnableTracesRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Anvil$1_Anvil: typeof Anvil;
@@ -2114,13 +2165,13 @@ type JsonRpcErrorResponseType$1 = {
 };
 type JsonRpcResponseType<TResult = unknown> = JsonRpcSuccessResponseType<TResult> | JsonRpcErrorResponseType$1;
 declare function from$1<TResult = unknown>(raw: unknown): JsonRpcResponseType<TResult>;
-declare function parse$2<TResult = unknown>(raw: unknown): Effect.Effect<JsonRpcResponseType<TResult>, JsonRpcParseError>;
+declare function parse$1<TResult = unknown>(raw: unknown): Effect.Effect<JsonRpcResponseType<TResult>, JsonRpcParseError>;
 declare function isSuccess<TResult>(response: JsonRpcResponseType<TResult>): response is JsonRpcSuccessResponseType<TResult>;
 declare function isError<TResult>(response: JsonRpcResponseType<TResult>): response is JsonRpcErrorResponseType$1;
 declare function unwrap<TResult>(response: JsonRpcResponseType<TResult>): Effect.Effect<TResult, JsonRpcErrorResponse>;
 declare const Response: {
     from: typeof from$1;
-    parse: typeof parse$2;
+    parse: typeof parse$1;
     isSuccess: typeof isSuccess;
     isError: typeof isError;
     unwrap: typeof unwrap;
@@ -2128,121 +2179,121 @@ declare const Response: {
 
 type BatchResponseType = readonly JsonRpcResponseType[];
 declare function from(raw: unknown[]): BatchResponseType;
-declare function parse$1(raw: unknown): Effect.Effect<BatchResponseType, JsonRpcParseError>;
+declare function parse(raw: unknown): Effect.Effect<BatchResponseType, JsonRpcParseError>;
 declare function findById(batch: BatchResponseType): (id: JsonRpcIdType) => JsonRpcResponseType | undefined;
 declare function errors(batch: BatchResponseType): JsonRpcErrorResponseType$1[];
 declare function results(batch: BatchResponseType): JsonRpcResponseType[];
 declare const BatchResponse: {
     from: typeof from;
-    parse: typeof parse$1;
+    parse: typeof parse;
     findById: typeof findById;
     errors: typeof errors;
     results: typeof results;
 };
 
-declare const AccountsRequest$1: () => JsonRpcRequestType;
-declare const BlobBaseFeeRequest$1: () => JsonRpcRequestType;
-declare const BlockNumberRequest$1: () => JsonRpcRequestType;
-declare const CallRequest$1: (tx: unknown, blockTag?: string, stateOverride?: unknown, blockOverrides?: unknown) => JsonRpcRequestType;
-declare const ChainIdRequest$1: () => JsonRpcRequestType;
-declare const CoinbaseRequest$1: () => JsonRpcRequestType;
-declare const CreateAccessListRequest$1: (tx: unknown) => JsonRpcRequestType;
-declare const EstimateGasRequest$1: (tx: unknown, blockTag?: string, stateOverride?: unknown) => JsonRpcRequestType;
-declare const FeeHistoryRequest$1: (blockCount: number | string, newestBlock: string, rewardPercentiles: number[]) => JsonRpcRequestType;
-declare const GasPriceRequest$1: () => JsonRpcRequestType;
-declare const GetBalanceRequest$1: (address: string, blockTag?: string) => JsonRpcRequestType;
-declare const GetBlockByHashRequest$1: (hash: string, fullTx?: boolean) => JsonRpcRequestType;
-declare const GetBlockByNumberRequest$1: (blockNumber: string, fullTx?: boolean) => JsonRpcRequestType;
-declare const GetBlockReceiptsRequest$1: (blockId: string) => JsonRpcRequestType;
-declare const GetBlockTransactionCountByHashRequest$1: (hash: string) => JsonRpcRequestType;
-declare const GetBlockTransactionCountByNumberRequest$1: (blockNumber: string) => JsonRpcRequestType;
-declare const GetCodeRequest$1: (address: string, blockTag?: string) => JsonRpcRequestType;
-declare const GetFilterChangesRequest$1: (filterId: string) => JsonRpcRequestType;
-declare const GetFilterLogsRequest$1: (filterId: string) => JsonRpcRequestType;
-declare const GetLogsRequest$1: (filter: unknown) => JsonRpcRequestType;
-declare const GetProofRequest$1: (address: string, storageKeys: string[], blockTag?: string) => JsonRpcRequestType;
-declare const GetStorageAtRequest$1: (address: string, slot: string, blockTag?: string) => JsonRpcRequestType;
-declare const GetTransactionByBlockHashAndIndexRequest$1: (blockHash: string, index: string) => JsonRpcRequestType;
-declare const GetTransactionByBlockNumberAndIndexRequest$1: (blockNumber: string, index: string) => JsonRpcRequestType;
-declare const GetTransactionByHashRequest$1: (hash: string) => JsonRpcRequestType;
-declare const GetTransactionCountRequest$1: (address: string, blockTag?: string) => JsonRpcRequestType;
-declare const GetTransactionReceiptRequest$1: (hash: string) => JsonRpcRequestType;
-declare const GetUncleCountByBlockHashRequest$1: (hash: string) => JsonRpcRequestType;
-declare const GetUncleCountByBlockNumberRequest$1: (blockNumber: string) => JsonRpcRequestType;
-declare const GetUncleByBlockHashAndIndexRequest$1: (blockHash: string, index: string) => JsonRpcRequestType;
-declare const GetUncleByBlockNumberAndIndexRequest$1: (blockNumber: string, index: string) => JsonRpcRequestType;
-declare const MaxPriorityFeePerGasRequest$1: () => JsonRpcRequestType;
-declare const NewBlockFilterRequest$1: () => JsonRpcRequestType;
-declare const NewFilterRequest$1: (filter: unknown) => JsonRpcRequestType;
-declare const NewPendingTransactionFilterRequest$1: () => JsonRpcRequestType;
-declare const SendRawTransactionRequest$1: (signedTx: string) => JsonRpcRequestType;
-declare const SendTransactionRequest$1: (tx: unknown) => JsonRpcRequestType;
-declare const SignRequest$1: (address: string, message: string) => JsonRpcRequestType;
-declare const SignTransactionRequest$1: (tx: unknown) => JsonRpcRequestType;
-declare const SimulateV1Request: (calls: unknown[], blockTag?: string) => JsonRpcRequestType;
-declare const SimulateV2Request: (payload: unknown, blockTag?: string) => JsonRpcRequestType;
-declare const SyncingRequest$1: () => JsonRpcRequestType;
-declare const UninstallFilterRequest$1: (filterId: string) => JsonRpcRequestType;
-declare const SubscribeRequest$1: (...args: unknown[]) => JsonRpcRequestType;
-declare const UnsubscribeRequest$1: (subscriptionId: string) => JsonRpcRequestType;
-declare const GetWorkRequest$1: () => JsonRpcRequestType;
-declare const SubmitWorkRequest$1: (nonce: string, powHash: string, mixDigest: string) => JsonRpcRequestType;
-declare const SubmitHashrateRequest$1: (hashrate: string, id: string) => JsonRpcRequestType;
-declare const HashrateRequest$1: () => JsonRpcRequestType;
-declare const MiningRequest$1: () => JsonRpcRequestType;
-declare const ProtocolVersionRequest$1: () => JsonRpcRequestType;
+declare const AccountsRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const BlobBaseFeeRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const BlockNumberRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const CallRequest$1: (tx: unknown, blockTag?: string, stateOverride?: unknown, blockOverrides?: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ChainIdRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const CoinbaseRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const CreateAccessListRequest$1: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const EstimateGasRequest$1: (tx: unknown, blockTag?: string, stateOverride?: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const FeeHistoryRequest$1: (blockCount: number | string, newestBlock: string, rewardPercentiles: number[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GasPriceRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBalanceRequest$1: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBlockByHashRequest$1: (hash: string, fullTx?: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBlockByNumberRequest$1: (blockNumber: string, fullTx?: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBlockReceiptsRequest$1: (blockId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBlockTransactionCountByHashRequest$1: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetBlockTransactionCountByNumberRequest$1: (blockNumber: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetCodeRequest$1: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetFilterChangesRequest$1: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetFilterLogsRequest$1: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetLogsRequest$1: (filter: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetProofRequest$1: (address: string, storageKeys: string[], blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetStorageAtRequest$1: (address: string, slot: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetTransactionByBlockHashAndIndexRequest$1: (blockHash: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetTransactionByBlockNumberAndIndexRequest$1: (blockNumber: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetTransactionByHashRequest$1: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetTransactionCountRequest$1: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetTransactionReceiptRequest$1: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetUncleCountByBlockHashRequest$1: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetUncleCountByBlockNumberRequest$1: (blockNumber: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetUncleByBlockHashAndIndexRequest$1: (blockHash: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetUncleByBlockNumberAndIndexRequest$1: (blockNumber: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const MaxPriorityFeePerGasRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const NewBlockFilterRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const NewFilterRequest$1: (filter: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const NewPendingTransactionFilterRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SendRawTransactionRequest$1: (signedTx: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SendTransactionRequest$1: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SignRequest$1: (address: string, message: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SignTransactionRequest$1: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SimulateV1Request: (calls: unknown[], blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SimulateV2Request: (payload: unknown, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SyncingRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const UninstallFilterRequest$1: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SubscribeRequest$1: (...args: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const UnsubscribeRequest$1: (subscriptionId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetWorkRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SubmitWorkRequest$1: (nonce: string, powHash: string, mixDigest: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SubmitHashrateRequest$1: (hashrate: string, id: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const HashrateRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const MiningRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ProtocolVersionRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Eth: {
-    AccountsRequest: () => JsonRpcRequestType;
-    BlobBaseFeeRequest: () => JsonRpcRequestType;
-    BlockNumberRequest: () => JsonRpcRequestType;
-    CallRequest: (tx: unknown, blockTag?: string, stateOverride?: unknown, blockOverrides?: unknown) => JsonRpcRequestType;
-    ChainIdRequest: () => JsonRpcRequestType;
-    CoinbaseRequest: () => JsonRpcRequestType;
-    CreateAccessListRequest: (tx: unknown) => JsonRpcRequestType;
-    EstimateGasRequest: (tx: unknown, blockTag?: string, stateOverride?: unknown) => JsonRpcRequestType;
-    FeeHistoryRequest: (blockCount: number | string, newestBlock: string, rewardPercentiles: number[]) => JsonRpcRequestType;
-    GasPriceRequest: () => JsonRpcRequestType;
-    GetBalanceRequest: (address: string, blockTag?: string) => JsonRpcRequestType;
-    GetBlockByHashRequest: (hash: string, fullTx?: boolean) => JsonRpcRequestType;
-    GetBlockByNumberRequest: (blockNumber: string, fullTx?: boolean) => JsonRpcRequestType;
-    GetBlockReceiptsRequest: (blockId: string) => JsonRpcRequestType;
-    GetBlockTransactionCountByHashRequest: (hash: string) => JsonRpcRequestType;
-    GetBlockTransactionCountByNumberRequest: (blockNumber: string) => JsonRpcRequestType;
-    GetCodeRequest: (address: string, blockTag?: string) => JsonRpcRequestType;
-    GetFilterChangesRequest: (filterId: string) => JsonRpcRequestType;
-    GetFilterLogsRequest: (filterId: string) => JsonRpcRequestType;
-    GetLogsRequest: (filter: unknown) => JsonRpcRequestType;
-    GetProofRequest: (address: string, storageKeys: string[], blockTag?: string) => JsonRpcRequestType;
-    GetStorageAtRequest: (address: string, slot: string, blockTag?: string) => JsonRpcRequestType;
-    GetTransactionByBlockHashAndIndexRequest: (blockHash: string, index: string) => JsonRpcRequestType;
-    GetTransactionByBlockNumberAndIndexRequest: (blockNumber: string, index: string) => JsonRpcRequestType;
-    GetTransactionByHashRequest: (hash: string) => JsonRpcRequestType;
-    GetTransactionCountRequest: (address: string, blockTag?: string) => JsonRpcRequestType;
-    GetTransactionReceiptRequest: (hash: string) => JsonRpcRequestType;
-    GetUncleCountByBlockHashRequest: (hash: string) => JsonRpcRequestType;
-    GetUncleCountByBlockNumberRequest: (blockNumber: string) => JsonRpcRequestType;
-    GetUncleByBlockHashAndIndexRequest: (blockHash: string, index: string) => JsonRpcRequestType;
-    GetUncleByBlockNumberAndIndexRequest: (blockNumber: string, index: string) => JsonRpcRequestType;
-    MaxPriorityFeePerGasRequest: () => JsonRpcRequestType;
-    NewBlockFilterRequest: () => JsonRpcRequestType;
-    NewFilterRequest: (filter: unknown) => JsonRpcRequestType;
-    NewPendingTransactionFilterRequest: () => JsonRpcRequestType;
-    SendRawTransactionRequest: (signedTx: string) => JsonRpcRequestType;
-    SendTransactionRequest: (tx: unknown) => JsonRpcRequestType;
-    SignRequest: (address: string, message: string) => JsonRpcRequestType;
-    SignTransactionRequest: (tx: unknown) => JsonRpcRequestType;
-    SimulateV1Request: (calls: unknown[], blockTag?: string) => JsonRpcRequestType;
-    SimulateV2Request: (payload: unknown, blockTag?: string) => JsonRpcRequestType;
-    SyncingRequest: () => JsonRpcRequestType;
-    UninstallFilterRequest: (filterId: string) => JsonRpcRequestType;
-    SubscribeRequest: (...args: unknown[]) => JsonRpcRequestType;
-    UnsubscribeRequest: (subscriptionId: string) => JsonRpcRequestType;
-    GetWorkRequest: () => JsonRpcRequestType;
-    SubmitWorkRequest: (nonce: string, powHash: string, mixDigest: string) => JsonRpcRequestType;
-    SubmitHashrateRequest: (hashrate: string, id: string) => JsonRpcRequestType;
-    HashrateRequest: () => JsonRpcRequestType;
-    MiningRequest: () => JsonRpcRequestType;
-    ProtocolVersionRequest: () => JsonRpcRequestType;
+    AccountsRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    BlobBaseFeeRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    BlockNumberRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    CallRequest: (tx: unknown, blockTag?: string, stateOverride?: unknown, blockOverrides?: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ChainIdRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    CoinbaseRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    CreateAccessListRequest: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    EstimateGasRequest: (tx: unknown, blockTag?: string, stateOverride?: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    FeeHistoryRequest: (blockCount: number | string, newestBlock: string, rewardPercentiles: number[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GasPriceRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBalanceRequest: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBlockByHashRequest: (hash: string, fullTx?: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBlockByNumberRequest: (blockNumber: string, fullTx?: boolean) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBlockReceiptsRequest: (blockId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBlockTransactionCountByHashRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetBlockTransactionCountByNumberRequest: (blockNumber: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetCodeRequest: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetFilterChangesRequest: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetFilterLogsRequest: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetLogsRequest: (filter: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetProofRequest: (address: string, storageKeys: string[], blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetStorageAtRequest: (address: string, slot: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetTransactionByBlockHashAndIndexRequest: (blockHash: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetTransactionByBlockNumberAndIndexRequest: (blockNumber: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetTransactionByHashRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetTransactionCountRequest: (address: string, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetTransactionReceiptRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetUncleCountByBlockHashRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetUncleCountByBlockNumberRequest: (blockNumber: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetUncleByBlockHashAndIndexRequest: (blockHash: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetUncleByBlockNumberAndIndexRequest: (blockNumber: string, index: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    MaxPriorityFeePerGasRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    NewBlockFilterRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    NewFilterRequest: (filter: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    NewPendingTransactionFilterRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SendRawTransactionRequest: (signedTx: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SendTransactionRequest: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SignRequest: (address: string, message: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SignTransactionRequest: (tx: unknown) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SimulateV1Request: (calls: unknown[], blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SimulateV2Request: (payload: unknown, blockTag?: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SyncingRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    UninstallFilterRequest: (filterId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SubscribeRequest: (...args: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    UnsubscribeRequest: (subscriptionId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetWorkRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SubmitWorkRequest: (nonce: string, powHash: string, mixDigest: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SubmitHashrateRequest: (hashrate: string, id: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    HashrateRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    MiningRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ProtocolVersionRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Eth$1_Eth: typeof Eth;
@@ -2257,38 +2308,38 @@ declare const ResetRequest$2: (options?: {
         jsonRpcUrl: string;
         blockNumber?: number;
     };
-}) => JsonRpcRequestType;
-declare const SetBalanceRequest$2: (address: string, balance: string) => JsonRpcRequestType;
-declare const SetCodeRequest$2: (address: string, code: string) => JsonRpcRequestType;
-declare const SetNonceRequest$2: (address: string, nonce: string) => JsonRpcRequestType;
-declare const SetStorageAtRequest$2: (address: string, slot: string, value: string) => JsonRpcRequestType;
-declare const ImpersonateAccountRequest$2: (address: string) => JsonRpcRequestType;
-declare const StopImpersonatingAccountRequest$2: (address: string) => JsonRpcRequestType;
-declare const MineRequest$2: (blocks?: number, interval?: number) => JsonRpcRequestType;
-declare const DropTransactionRequest$2: (hash: string) => JsonRpcRequestType;
-declare const SetCoinbaseRequest: (address: string) => JsonRpcRequestType;
-declare const SetMinGasPriceRequest: (gasPrice: string) => JsonRpcRequestType;
-declare const SetNextBlockBaseFeePerGasRequest: (baseFee: string) => JsonRpcRequestType;
-declare const SetPrevRandaoRequest: (prevRandao: string) => JsonRpcRequestType;
+}) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetBalanceRequest$2: (address: string, balance: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetCodeRequest$2: (address: string, code: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetNonceRequest$2: (address: string, nonce: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetStorageAtRequest$2: (address: string, slot: string, value: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ImpersonateAccountRequest$2: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const StopImpersonatingAccountRequest$2: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const MineRequest$2: (blocks?: number, interval?: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const DropTransactionRequest$2: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetCoinbaseRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetMinGasPriceRequest: (gasPrice: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetNextBlockBaseFeePerGasRequest: (baseFee: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const SetPrevRandaoRequest: (prevRandao: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Hardhat: {
     ResetRequest: (options?: {
         forking?: {
             jsonRpcUrl: string;
             blockNumber?: number;
         };
-    }) => JsonRpcRequestType;
-    SetBalanceRequest: (address: string, balance: string) => JsonRpcRequestType;
-    SetCodeRequest: (address: string, code: string) => JsonRpcRequestType;
-    SetNonceRequest: (address: string, nonce: string) => JsonRpcRequestType;
-    SetStorageAtRequest: (address: string, slot: string, value: string) => JsonRpcRequestType;
-    ImpersonateAccountRequest: (address: string) => JsonRpcRequestType;
-    StopImpersonatingAccountRequest: (address: string) => JsonRpcRequestType;
-    MineRequest: (blocks?: number, interval?: number) => JsonRpcRequestType;
-    DropTransactionRequest: (hash: string) => JsonRpcRequestType;
-    SetCoinbaseRequest: (address: string) => JsonRpcRequestType;
-    SetMinGasPriceRequest: (gasPrice: string) => JsonRpcRequestType;
-    SetNextBlockBaseFeePerGasRequest: (baseFee: string) => JsonRpcRequestType;
-    SetPrevRandaoRequest: (prevRandao: string) => JsonRpcRequestType;
+    }) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetBalanceRequest: (address: string, balance: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetCodeRequest: (address: string, code: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetNonceRequest: (address: string, nonce: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetStorageAtRequest: (address: string, slot: string, value: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ImpersonateAccountRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    StopImpersonatingAccountRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    MineRequest: (blocks?: number, interval?: number) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    DropTransactionRequest: (hash: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetCoinbaseRequest: (address: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetMinGasPriceRequest: (gasPrice: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetNextBlockBaseFeePerGasRequest: (baseFee: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    SetPrevRandaoRequest: (prevRandao: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Hardhat$1_Hardhat: typeof Hardhat;
@@ -2300,16 +2351,13 @@ declare namespace Hardhat$1 {
   export { DropTransactionRequest$2 as DropTransactionRequest, Hardhat$1_Hardhat as Hardhat, ImpersonateAccountRequest$2 as ImpersonateAccountRequest, MineRequest$2 as MineRequest, ResetRequest$2 as ResetRequest, SetBalanceRequest$2 as SetBalanceRequest, SetCodeRequest$2 as SetCodeRequest, Hardhat$1_SetCoinbaseRequest as SetCoinbaseRequest, Hardhat$1_SetMinGasPriceRequest as SetMinGasPriceRequest, Hardhat$1_SetNextBlockBaseFeePerGasRequest as SetNextBlockBaseFeePerGasRequest, SetNonceRequest$2 as SetNonceRequest, Hardhat$1_SetPrevRandaoRequest as SetPrevRandaoRequest, SetStorageAtRequest$2 as SetStorageAtRequest, StopImpersonatingAccountRequest$2 as StopImpersonatingAccountRequest };
 }
 
-declare const nextId: () => number;
-declare const resetId: () => void;
-
-declare const VersionRequest$1: () => JsonRpcRequestType;
-declare const ListeningRequest$1: () => JsonRpcRequestType;
-declare const PeerCountRequest$1: () => JsonRpcRequestType;
+declare const VersionRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ListeningRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const PeerCountRequest$1: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Net: {
-    VersionRequest: () => JsonRpcRequestType;
-    ListeningRequest: () => JsonRpcRequestType;
-    PeerCountRequest: () => JsonRpcRequestType;
+    VersionRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ListeningRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    PeerCountRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Net$1_Net: typeof Net;
@@ -3313,40 +3361,40 @@ declare const AnvilMethodRequest: S.Union<[S.Struct<{
 /** Type for AnvilMethodRequest union */
 type AnvilMethodRequestType = S.Schema.Type<typeof AnvilMethodRequest>;
 
-declare const index$b_AnvilMethodRequest: typeof AnvilMethodRequest;
-type index$b_AnvilMethodRequestType = AnvilMethodRequestType;
-declare const index$b_RevertParams: typeof RevertParams;
-declare const index$b_RevertRequest: typeof RevertRequest;
-type index$b_RevertRequestType = RevertRequestType;
-declare const index$b_RevertResponse: typeof RevertResponse;
-type index$b_RevertResponseType = RevertResponseType;
-declare const index$b_RevertResult: typeof RevertResult;
-declare const index$b_SetAutomineParams: typeof SetAutomineParams;
-declare const index$b_SetAutomineRequest: typeof SetAutomineRequest;
-type index$b_SetAutomineRequestType = SetAutomineRequestType;
-declare const index$b_SetAutomineResponse: typeof SetAutomineResponse;
-type index$b_SetAutomineResponseType = SetAutomineResponseType;
-declare const index$b_SetAutomineResult: typeof SetAutomineResult;
-declare const index$b_SetBlockTimestampIntervalParams: typeof SetBlockTimestampIntervalParams;
-declare const index$b_SetBlockTimestampIntervalRequest: typeof SetBlockTimestampIntervalRequest;
-type index$b_SetBlockTimestampIntervalRequestType = SetBlockTimestampIntervalRequestType;
-declare const index$b_SetBlockTimestampIntervalResponse: typeof SetBlockTimestampIntervalResponse;
-type index$b_SetBlockTimestampIntervalResponseType = SetBlockTimestampIntervalResponseType;
-declare const index$b_SetBlockTimestampIntervalResult: typeof SetBlockTimestampIntervalResult;
-declare const index$b_SetNextBlockTimestampParams: typeof SetNextBlockTimestampParams;
-declare const index$b_SetNextBlockTimestampRequest: typeof SetNextBlockTimestampRequest;
-type index$b_SetNextBlockTimestampRequestType = SetNextBlockTimestampRequestType;
-declare const index$b_SetNextBlockTimestampResponse: typeof SetNextBlockTimestampResponse;
-type index$b_SetNextBlockTimestampResponseType = SetNextBlockTimestampResponseType;
-declare const index$b_SetNextBlockTimestampResult: typeof SetNextBlockTimestampResult;
-declare const index$b_SnapshotParams: typeof SnapshotParams;
-declare const index$b_SnapshotRequest: typeof SnapshotRequest;
-type index$b_SnapshotRequestType = SnapshotRequestType;
-declare const index$b_SnapshotResponse: typeof SnapshotResponse;
-type index$b_SnapshotResponseType = SnapshotResponseType;
-declare const index$b_SnapshotResult: typeof SnapshotResult;
-declare namespace index$b {
-  export { index$b_AnvilMethodRequest as AnvilMethodRequest, type index$b_AnvilMethodRequestType as AnvilMethodRequestType, DropTransactionParams$1 as DropTransactionParams, DropTransactionRequest$1 as DropTransactionRequest, type DropTransactionRequestType$1 as DropTransactionRequestType, DropTransactionResponse$1 as DropTransactionResponse, type DropTransactionResponseType$1 as DropTransactionResponseType, DropTransactionResult$1 as DropTransactionResult, ForkConfigSchema$1 as ForkConfigSchema, ImpersonateAccountParams$1 as ImpersonateAccountParams, ImpersonateAccountRequest$1 as ImpersonateAccountRequest, type ImpersonateAccountRequestType$1 as ImpersonateAccountRequestType, ImpersonateAccountResponse$1 as ImpersonateAccountResponse, type ImpersonateAccountResponseType$1 as ImpersonateAccountResponseType, ImpersonateAccountResult$1 as ImpersonateAccountResult, MineParams$1 as MineParams, MineRequest$1 as MineRequest, type MineRequestType$1 as MineRequestType, MineResponse$1 as MineResponse, type MineResponseType$1 as MineResponseType, MineResult$1 as MineResult, ResetParams$1 as ResetParams, ResetRequest$1 as ResetRequest, type ResetRequestType$1 as ResetRequestType, ResetResponse$1 as ResetResponse, type ResetResponseType$1 as ResetResponseType, ResetResult$1 as ResetResult, index$b_RevertParams as RevertParams, index$b_RevertRequest as RevertRequest, type index$b_RevertRequestType as RevertRequestType, index$b_RevertResponse as RevertResponse, type index$b_RevertResponseType as RevertResponseType, index$b_RevertResult as RevertResult, index$b_SetAutomineParams as SetAutomineParams, index$b_SetAutomineRequest as SetAutomineRequest, type index$b_SetAutomineRequestType as SetAutomineRequestType, index$b_SetAutomineResponse as SetAutomineResponse, type index$b_SetAutomineResponseType as SetAutomineResponseType, index$b_SetAutomineResult as SetAutomineResult, SetBalanceParams$1 as SetBalanceParams, SetBalanceRequest$1 as SetBalanceRequest, type SetBalanceRequestType$1 as SetBalanceRequestType, SetBalanceResponse$1 as SetBalanceResponse, type SetBalanceResponseType$1 as SetBalanceResponseType, SetBalanceResult$1 as SetBalanceResult, index$b_SetBlockTimestampIntervalParams as SetBlockTimestampIntervalParams, index$b_SetBlockTimestampIntervalRequest as SetBlockTimestampIntervalRequest, type index$b_SetBlockTimestampIntervalRequestType as SetBlockTimestampIntervalRequestType, index$b_SetBlockTimestampIntervalResponse as SetBlockTimestampIntervalResponse, type index$b_SetBlockTimestampIntervalResponseType as SetBlockTimestampIntervalResponseType, index$b_SetBlockTimestampIntervalResult as SetBlockTimestampIntervalResult, SetCodeParams$1 as SetCodeParams, SetCodeRequest$1 as SetCodeRequest, type SetCodeRequestType$1 as SetCodeRequestType, SetCodeResponse$1 as SetCodeResponse, type SetCodeResponseType$1 as SetCodeResponseType, SetCodeResult$1 as SetCodeResult, index$b_SetNextBlockTimestampParams as SetNextBlockTimestampParams, index$b_SetNextBlockTimestampRequest as SetNextBlockTimestampRequest, type index$b_SetNextBlockTimestampRequestType as SetNextBlockTimestampRequestType, index$b_SetNextBlockTimestampResponse as SetNextBlockTimestampResponse, type index$b_SetNextBlockTimestampResponseType as SetNextBlockTimestampResponseType, index$b_SetNextBlockTimestampResult as SetNextBlockTimestampResult, SetNonceParams$1 as SetNonceParams, SetNonceRequest$1 as SetNonceRequest, type SetNonceRequestType$1 as SetNonceRequestType, SetNonceResponse$1 as SetNonceResponse, type SetNonceResponseType$1 as SetNonceResponseType, SetNonceResult$1 as SetNonceResult, SetStorageAtParams$1 as SetStorageAtParams, SetStorageAtRequest$1 as SetStorageAtRequest, type SetStorageAtRequestType$1 as SetStorageAtRequestType, SetStorageAtResponse$1 as SetStorageAtResponse, type SetStorageAtResponseType$1 as SetStorageAtResponseType, SetStorageAtResult$1 as SetStorageAtResult, index$b_SnapshotParams as SnapshotParams, index$b_SnapshotRequest as SnapshotRequest, type index$b_SnapshotRequestType as SnapshotRequestType, index$b_SnapshotResponse as SnapshotResponse, type index$b_SnapshotResponseType as SnapshotResponseType, index$b_SnapshotResult as SnapshotResult, StopImpersonatingAccountParams$1 as StopImpersonatingAccountParams, StopImpersonatingAccountRequest$1 as StopImpersonatingAccountRequest, type StopImpersonatingAccountRequestType$1 as StopImpersonatingAccountRequestType, StopImpersonatingAccountResponse$1 as StopImpersonatingAccountResponse, type StopImpersonatingAccountResponseType$1 as StopImpersonatingAccountResponseType, StopImpersonatingAccountResult$1 as StopImpersonatingAccountResult };
+declare const index$a_AnvilMethodRequest: typeof AnvilMethodRequest;
+type index$a_AnvilMethodRequestType = AnvilMethodRequestType;
+declare const index$a_RevertParams: typeof RevertParams;
+declare const index$a_RevertRequest: typeof RevertRequest;
+type index$a_RevertRequestType = RevertRequestType;
+declare const index$a_RevertResponse: typeof RevertResponse;
+type index$a_RevertResponseType = RevertResponseType;
+declare const index$a_RevertResult: typeof RevertResult;
+declare const index$a_SetAutomineParams: typeof SetAutomineParams;
+declare const index$a_SetAutomineRequest: typeof SetAutomineRequest;
+type index$a_SetAutomineRequestType = SetAutomineRequestType;
+declare const index$a_SetAutomineResponse: typeof SetAutomineResponse;
+type index$a_SetAutomineResponseType = SetAutomineResponseType;
+declare const index$a_SetAutomineResult: typeof SetAutomineResult;
+declare const index$a_SetBlockTimestampIntervalParams: typeof SetBlockTimestampIntervalParams;
+declare const index$a_SetBlockTimestampIntervalRequest: typeof SetBlockTimestampIntervalRequest;
+type index$a_SetBlockTimestampIntervalRequestType = SetBlockTimestampIntervalRequestType;
+declare const index$a_SetBlockTimestampIntervalResponse: typeof SetBlockTimestampIntervalResponse;
+type index$a_SetBlockTimestampIntervalResponseType = SetBlockTimestampIntervalResponseType;
+declare const index$a_SetBlockTimestampIntervalResult: typeof SetBlockTimestampIntervalResult;
+declare const index$a_SetNextBlockTimestampParams: typeof SetNextBlockTimestampParams;
+declare const index$a_SetNextBlockTimestampRequest: typeof SetNextBlockTimestampRequest;
+type index$a_SetNextBlockTimestampRequestType = SetNextBlockTimestampRequestType;
+declare const index$a_SetNextBlockTimestampResponse: typeof SetNextBlockTimestampResponse;
+type index$a_SetNextBlockTimestampResponseType = SetNextBlockTimestampResponseType;
+declare const index$a_SetNextBlockTimestampResult: typeof SetNextBlockTimestampResult;
+declare const index$a_SnapshotParams: typeof SnapshotParams;
+declare const index$a_SnapshotRequest: typeof SnapshotRequest;
+type index$a_SnapshotRequestType = SnapshotRequestType;
+declare const index$a_SnapshotResponse: typeof SnapshotResponse;
+type index$a_SnapshotResponseType = SnapshotResponseType;
+declare const index$a_SnapshotResult: typeof SnapshotResult;
+declare namespace index$a {
+  export { index$a_AnvilMethodRequest as AnvilMethodRequest, type index$a_AnvilMethodRequestType as AnvilMethodRequestType, DropTransactionParams$1 as DropTransactionParams, DropTransactionRequest$1 as DropTransactionRequest, type DropTransactionRequestType$1 as DropTransactionRequestType, DropTransactionResponse$1 as DropTransactionResponse, type DropTransactionResponseType$1 as DropTransactionResponseType, DropTransactionResult$1 as DropTransactionResult, ForkConfigSchema$1 as ForkConfigSchema, ImpersonateAccountParams$1 as ImpersonateAccountParams, ImpersonateAccountRequest$1 as ImpersonateAccountRequest, type ImpersonateAccountRequestType$1 as ImpersonateAccountRequestType, ImpersonateAccountResponse$1 as ImpersonateAccountResponse, type ImpersonateAccountResponseType$1 as ImpersonateAccountResponseType, ImpersonateAccountResult$1 as ImpersonateAccountResult, MineParams$1 as MineParams, MineRequest$1 as MineRequest, type MineRequestType$1 as MineRequestType, MineResponse$1 as MineResponse, type MineResponseType$1 as MineResponseType, MineResult$1 as MineResult, ResetParams$1 as ResetParams, ResetRequest$1 as ResetRequest, type ResetRequestType$1 as ResetRequestType, ResetResponse$1 as ResetResponse, type ResetResponseType$1 as ResetResponseType, ResetResult$1 as ResetResult, index$a_RevertParams as RevertParams, index$a_RevertRequest as RevertRequest, type index$a_RevertRequestType as RevertRequestType, index$a_RevertResponse as RevertResponse, type index$a_RevertResponseType as RevertResponseType, index$a_RevertResult as RevertResult, index$a_SetAutomineParams as SetAutomineParams, index$a_SetAutomineRequest as SetAutomineRequest, type index$a_SetAutomineRequestType as SetAutomineRequestType, index$a_SetAutomineResponse as SetAutomineResponse, type index$a_SetAutomineResponseType as SetAutomineResponseType, index$a_SetAutomineResult as SetAutomineResult, SetBalanceParams$1 as SetBalanceParams, SetBalanceRequest$1 as SetBalanceRequest, type SetBalanceRequestType$1 as SetBalanceRequestType, SetBalanceResponse$1 as SetBalanceResponse, type SetBalanceResponseType$1 as SetBalanceResponseType, SetBalanceResult$1 as SetBalanceResult, index$a_SetBlockTimestampIntervalParams as SetBlockTimestampIntervalParams, index$a_SetBlockTimestampIntervalRequest as SetBlockTimestampIntervalRequest, type index$a_SetBlockTimestampIntervalRequestType as SetBlockTimestampIntervalRequestType, index$a_SetBlockTimestampIntervalResponse as SetBlockTimestampIntervalResponse, type index$a_SetBlockTimestampIntervalResponseType as SetBlockTimestampIntervalResponseType, index$a_SetBlockTimestampIntervalResult as SetBlockTimestampIntervalResult, SetCodeParams$1 as SetCodeParams, SetCodeRequest$1 as SetCodeRequest, type SetCodeRequestType$1 as SetCodeRequestType, SetCodeResponse$1 as SetCodeResponse, type SetCodeResponseType$1 as SetCodeResponseType, SetCodeResult$1 as SetCodeResult, index$a_SetNextBlockTimestampParams as SetNextBlockTimestampParams, index$a_SetNextBlockTimestampRequest as SetNextBlockTimestampRequest, type index$a_SetNextBlockTimestampRequestType as SetNextBlockTimestampRequestType, index$a_SetNextBlockTimestampResponse as SetNextBlockTimestampResponse, type index$a_SetNextBlockTimestampResponseType as SetNextBlockTimestampResponseType, index$a_SetNextBlockTimestampResult as SetNextBlockTimestampResult, SetNonceParams$1 as SetNonceParams, SetNonceRequest$1 as SetNonceRequest, type SetNonceRequestType$1 as SetNonceRequestType, SetNonceResponse$1 as SetNonceResponse, type SetNonceResponseType$1 as SetNonceResponseType, SetNonceResult$1 as SetNonceResult, SetStorageAtParams$1 as SetStorageAtParams, SetStorageAtRequest$1 as SetStorageAtRequest, type SetStorageAtRequestType$1 as SetStorageAtRequestType, SetStorageAtResponse$1 as SetStorageAtResponse, type SetStorageAtResponseType$1 as SetStorageAtResponseType, SetStorageAtResult$1 as SetStorageAtResult, index$a_SnapshotParams as SnapshotParams, index$a_SnapshotRequest as SnapshotRequest, type index$a_SnapshotRequestType as SnapshotRequestType, index$a_SnapshotResponse as SnapshotResponse, type index$a_SnapshotResponseType as SnapshotResponseType, index$a_SnapshotResult as SnapshotResult, StopImpersonatingAccountParams$1 as StopImpersonatingAccountParams, StopImpersonatingAccountRequest$1 as StopImpersonatingAccountRequest, type StopImpersonatingAccountRequestType$1 as StopImpersonatingAccountRequestType, StopImpersonatingAccountResponse$1 as StopImpersonatingAccountResponse, type StopImpersonatingAccountResponseType$1 as StopImpersonatingAccountResponseType, StopImpersonatingAccountResult$1 as StopImpersonatingAccountResult };
 }
 
 /**
@@ -7160,309 +7208,309 @@ declare const EthMethodRequest: S.Union<[S.Struct<{
 /** Type for EthMethodRequest union */
 type EthMethodRequestType = S.Schema.Type<typeof EthMethodRequest>;
 
-declare const index$a_AccountsParams: typeof AccountsParams;
-declare const index$a_AccountsRequest: typeof AccountsRequest;
-type index$a_AccountsRequestType = AccountsRequestType;
-declare const index$a_AccountsResponse: typeof AccountsResponse;
-type index$a_AccountsResponseType = AccountsResponseType;
-declare const index$a_AccountsResult: typeof AccountsResult;
-declare const index$a_BlobBaseFeeParams: typeof BlobBaseFeeParams;
-declare const index$a_BlobBaseFeeRequest: typeof BlobBaseFeeRequest;
-type index$a_BlobBaseFeeRequestType = BlobBaseFeeRequestType;
-declare const index$a_BlobBaseFeeResponse: typeof BlobBaseFeeResponse;
-type index$a_BlobBaseFeeResponseType = BlobBaseFeeResponseType;
-declare const index$a_BlobBaseFeeResult: typeof BlobBaseFeeResult;
-declare const index$a_BlockNumberParams: typeof BlockNumberParams;
-declare const index$a_BlockNumberRequest: typeof BlockNumberRequest;
-type index$a_BlockNumberRequestType = BlockNumberRequestType;
-declare const index$a_BlockNumberResponse: typeof BlockNumberResponse;
-type index$a_BlockNumberResponseType = BlockNumberResponseType;
-declare const index$a_BlockNumberResult: typeof BlockNumberResult;
-declare const index$a_CallParams: typeof CallParams;
-declare const index$a_CallRequest: typeof CallRequest;
-type index$a_CallRequestType = CallRequestType;
-declare const index$a_CallResponse: typeof CallResponse;
-type index$a_CallResponseType = CallResponseType;
-declare const index$a_CallResult: typeof CallResult;
-declare const index$a_ChainIdParams: typeof ChainIdParams;
-declare const index$a_ChainIdRequest: typeof ChainIdRequest;
-type index$a_ChainIdRequestType = ChainIdRequestType;
-declare const index$a_ChainIdResponse: typeof ChainIdResponse;
-type index$a_ChainIdResponseType = ChainIdResponseType;
-declare const index$a_ChainIdResult: typeof ChainIdResult;
-declare const index$a_CoinbaseParams: typeof CoinbaseParams;
-declare const index$a_CoinbaseRequest: typeof CoinbaseRequest;
-type index$a_CoinbaseRequestType = CoinbaseRequestType;
-declare const index$a_CoinbaseResponse: typeof CoinbaseResponse;
-type index$a_CoinbaseResponseType = CoinbaseResponseType;
-declare const index$a_CoinbaseResult: typeof CoinbaseResult;
-declare const index$a_CreateAccessListParams: typeof CreateAccessListParams;
-declare const index$a_CreateAccessListRequest: typeof CreateAccessListRequest;
-type index$a_CreateAccessListRequestType = CreateAccessListRequestType;
-declare const index$a_CreateAccessListResponse: typeof CreateAccessListResponse;
-type index$a_CreateAccessListResponseType = CreateAccessListResponseType;
-declare const index$a_CreateAccessListResult: typeof CreateAccessListResult;
-declare const index$a_EstimateGasParams: typeof EstimateGasParams;
-declare const index$a_EstimateGasRequest: typeof EstimateGasRequest;
-type index$a_EstimateGasRequestType = EstimateGasRequestType;
-declare const index$a_EstimateGasResponse: typeof EstimateGasResponse;
-type index$a_EstimateGasResponseType = EstimateGasResponseType;
-declare const index$a_EstimateGasResult: typeof EstimateGasResult;
-declare const index$a_EthMethodRequest: typeof EthMethodRequest;
-type index$a_EthMethodRequestType = EthMethodRequestType;
-declare const index$a_FeeHistoryParams: typeof FeeHistoryParams;
-declare const index$a_FeeHistoryRequest: typeof FeeHistoryRequest;
-type index$a_FeeHistoryRequestType = FeeHistoryRequestType;
-declare const index$a_FeeHistoryResponse: typeof FeeHistoryResponse;
-type index$a_FeeHistoryResponseType = FeeHistoryResponseType;
-declare const index$a_FeeHistoryResult: typeof FeeHistoryResult;
-declare const index$a_GasPriceParams: typeof GasPriceParams;
-declare const index$a_GasPriceRequest: typeof GasPriceRequest;
-type index$a_GasPriceRequestType = GasPriceRequestType;
-declare const index$a_GasPriceResponse: typeof GasPriceResponse;
-type index$a_GasPriceResponseType = GasPriceResponseType;
-declare const index$a_GasPriceResult: typeof GasPriceResult;
-declare const index$a_GetBalanceParams: typeof GetBalanceParams;
-declare const index$a_GetBalanceRequest: typeof GetBalanceRequest;
-type index$a_GetBalanceRequestType = GetBalanceRequestType;
-declare const index$a_GetBalanceResponse: typeof GetBalanceResponse;
-type index$a_GetBalanceResponseType = GetBalanceResponseType;
-declare const index$a_GetBalanceResult: typeof GetBalanceResult;
-declare const index$a_GetBlockByHashParams: typeof GetBlockByHashParams;
-declare const index$a_GetBlockByHashRequest: typeof GetBlockByHashRequest;
-type index$a_GetBlockByHashRequestType = GetBlockByHashRequestType;
-declare const index$a_GetBlockByHashResponse: typeof GetBlockByHashResponse;
-type index$a_GetBlockByHashResponseType = GetBlockByHashResponseType;
-declare const index$a_GetBlockByHashResult: typeof GetBlockByHashResult;
-declare const index$a_GetBlockByNumberParams: typeof GetBlockByNumberParams;
-declare const index$a_GetBlockByNumberRequest: typeof GetBlockByNumberRequest;
-type index$a_GetBlockByNumberRequestType = GetBlockByNumberRequestType;
-declare const index$a_GetBlockByNumberResponse: typeof GetBlockByNumberResponse;
-type index$a_GetBlockByNumberResponseType = GetBlockByNumberResponseType;
-declare const index$a_GetBlockByNumberResult: typeof GetBlockByNumberResult;
-declare const index$a_GetBlockReceiptsParams: typeof GetBlockReceiptsParams;
-declare const index$a_GetBlockReceiptsRequest: typeof GetBlockReceiptsRequest;
-type index$a_GetBlockReceiptsRequestType = GetBlockReceiptsRequestType;
-declare const index$a_GetBlockReceiptsResponse: typeof GetBlockReceiptsResponse;
-type index$a_GetBlockReceiptsResponseType = GetBlockReceiptsResponseType;
-declare const index$a_GetBlockReceiptsResult: typeof GetBlockReceiptsResult;
-declare const index$a_GetBlockTransactionCountByHashParams: typeof GetBlockTransactionCountByHashParams;
-declare const index$a_GetBlockTransactionCountByHashRequest: typeof GetBlockTransactionCountByHashRequest;
-type index$a_GetBlockTransactionCountByHashRequestType = GetBlockTransactionCountByHashRequestType;
-declare const index$a_GetBlockTransactionCountByHashResponse: typeof GetBlockTransactionCountByHashResponse;
-type index$a_GetBlockTransactionCountByHashResponseType = GetBlockTransactionCountByHashResponseType;
-declare const index$a_GetBlockTransactionCountByHashResult: typeof GetBlockTransactionCountByHashResult;
-declare const index$a_GetBlockTransactionCountByNumberParams: typeof GetBlockTransactionCountByNumberParams;
-declare const index$a_GetBlockTransactionCountByNumberRequest: typeof GetBlockTransactionCountByNumberRequest;
-type index$a_GetBlockTransactionCountByNumberRequestType = GetBlockTransactionCountByNumberRequestType;
-declare const index$a_GetBlockTransactionCountByNumberResponse: typeof GetBlockTransactionCountByNumberResponse;
-type index$a_GetBlockTransactionCountByNumberResponseType = GetBlockTransactionCountByNumberResponseType;
-declare const index$a_GetBlockTransactionCountByNumberResult: typeof GetBlockTransactionCountByNumberResult;
-declare const index$a_GetCodeParams: typeof GetCodeParams;
-declare const index$a_GetCodeRequest: typeof GetCodeRequest;
-type index$a_GetCodeRequestType = GetCodeRequestType;
-declare const index$a_GetCodeResponse: typeof GetCodeResponse;
-type index$a_GetCodeResponseType = GetCodeResponseType;
-declare const index$a_GetCodeResult: typeof GetCodeResult;
-declare const index$a_GetFilterChangesParams: typeof GetFilterChangesParams;
-declare const index$a_GetFilterChangesRequest: typeof GetFilterChangesRequest;
-type index$a_GetFilterChangesRequestType = GetFilterChangesRequestType;
-declare const index$a_GetFilterChangesResponse: typeof GetFilterChangesResponse;
-type index$a_GetFilterChangesResponseType = GetFilterChangesResponseType;
-declare const index$a_GetFilterChangesResult: typeof GetFilterChangesResult;
-declare const index$a_GetFilterLogsParams: typeof GetFilterLogsParams;
-declare const index$a_GetFilterLogsRequest: typeof GetFilterLogsRequest;
-type index$a_GetFilterLogsRequestType = GetFilterLogsRequestType;
-declare const index$a_GetFilterLogsResponse: typeof GetFilterLogsResponse;
-type index$a_GetFilterLogsResponseType = GetFilterLogsResponseType;
-declare const index$a_GetFilterLogsResult: typeof GetFilterLogsResult;
-declare const index$a_GetLogsParams: typeof GetLogsParams;
-declare const index$a_GetLogsRequest: typeof GetLogsRequest;
-type index$a_GetLogsRequestType = GetLogsRequestType;
-declare const index$a_GetLogsResponse: typeof GetLogsResponse;
-type index$a_GetLogsResponseType = GetLogsResponseType;
-declare const index$a_GetLogsResult: typeof GetLogsResult;
-declare const index$a_GetProofParams: typeof GetProofParams;
-declare const index$a_GetProofRequest: typeof GetProofRequest;
-type index$a_GetProofRequestType = GetProofRequestType;
-declare const index$a_GetProofResponse: typeof GetProofResponse;
-type index$a_GetProofResponseType = GetProofResponseType;
-declare const index$a_GetProofResult: typeof GetProofResult;
-declare const index$a_GetStorageAtParams: typeof GetStorageAtParams;
-declare const index$a_GetStorageAtRequest: typeof GetStorageAtRequest;
-type index$a_GetStorageAtRequestType = GetStorageAtRequestType;
-declare const index$a_GetStorageAtResponse: typeof GetStorageAtResponse;
-type index$a_GetStorageAtResponseType = GetStorageAtResponseType;
-declare const index$a_GetStorageAtResult: typeof GetStorageAtResult;
-declare const index$a_GetTransactionByBlockHashAndIndexParams: typeof GetTransactionByBlockHashAndIndexParams;
-declare const index$a_GetTransactionByBlockHashAndIndexRequest: typeof GetTransactionByBlockHashAndIndexRequest;
-type index$a_GetTransactionByBlockHashAndIndexRequestType = GetTransactionByBlockHashAndIndexRequestType;
-declare const index$a_GetTransactionByBlockHashAndIndexResponse: typeof GetTransactionByBlockHashAndIndexResponse;
-type index$a_GetTransactionByBlockHashAndIndexResponseType = GetTransactionByBlockHashAndIndexResponseType;
-declare const index$a_GetTransactionByBlockHashAndIndexResult: typeof GetTransactionByBlockHashAndIndexResult;
-declare const index$a_GetTransactionByBlockNumberAndIndexParams: typeof GetTransactionByBlockNumberAndIndexParams;
-declare const index$a_GetTransactionByBlockNumberAndIndexRequest: typeof GetTransactionByBlockNumberAndIndexRequest;
-type index$a_GetTransactionByBlockNumberAndIndexRequestType = GetTransactionByBlockNumberAndIndexRequestType;
-declare const index$a_GetTransactionByBlockNumberAndIndexResponse: typeof GetTransactionByBlockNumberAndIndexResponse;
-type index$a_GetTransactionByBlockNumberAndIndexResponseType = GetTransactionByBlockNumberAndIndexResponseType;
-declare const index$a_GetTransactionByBlockNumberAndIndexResult: typeof GetTransactionByBlockNumberAndIndexResult;
-declare const index$a_GetTransactionByHashParams: typeof GetTransactionByHashParams;
-declare const index$a_GetTransactionByHashRequest: typeof GetTransactionByHashRequest;
-type index$a_GetTransactionByHashRequestType = GetTransactionByHashRequestType;
-declare const index$a_GetTransactionByHashResponse: typeof GetTransactionByHashResponse;
-type index$a_GetTransactionByHashResponseType = GetTransactionByHashResponseType;
-declare const index$a_GetTransactionByHashResult: typeof GetTransactionByHashResult;
-declare const index$a_GetTransactionCountParams: typeof GetTransactionCountParams;
-declare const index$a_GetTransactionCountRequest: typeof GetTransactionCountRequest;
-type index$a_GetTransactionCountRequestType = GetTransactionCountRequestType;
-declare const index$a_GetTransactionCountResponse: typeof GetTransactionCountResponse;
-type index$a_GetTransactionCountResponseType = GetTransactionCountResponseType;
-declare const index$a_GetTransactionCountResult: typeof GetTransactionCountResult;
-declare const index$a_GetTransactionReceiptParams: typeof GetTransactionReceiptParams;
-declare const index$a_GetTransactionReceiptRequest: typeof GetTransactionReceiptRequest;
-type index$a_GetTransactionReceiptRequestType = GetTransactionReceiptRequestType;
-declare const index$a_GetTransactionReceiptResponse: typeof GetTransactionReceiptResponse;
-type index$a_GetTransactionReceiptResponseType = GetTransactionReceiptResponseType;
-declare const index$a_GetTransactionReceiptResult: typeof GetTransactionReceiptResult;
-declare const index$a_GetUncleByBlockHashAndIndexParams: typeof GetUncleByBlockHashAndIndexParams;
-declare const index$a_GetUncleByBlockHashAndIndexRequest: typeof GetUncleByBlockHashAndIndexRequest;
-type index$a_GetUncleByBlockHashAndIndexRequestType = GetUncleByBlockHashAndIndexRequestType;
-declare const index$a_GetUncleByBlockHashAndIndexResponse: typeof GetUncleByBlockHashAndIndexResponse;
-type index$a_GetUncleByBlockHashAndIndexResponseType = GetUncleByBlockHashAndIndexResponseType;
-declare const index$a_GetUncleByBlockHashAndIndexResult: typeof GetUncleByBlockHashAndIndexResult;
-declare const index$a_GetUncleByBlockNumberAndIndexParams: typeof GetUncleByBlockNumberAndIndexParams;
-declare const index$a_GetUncleByBlockNumberAndIndexRequest: typeof GetUncleByBlockNumberAndIndexRequest;
-type index$a_GetUncleByBlockNumberAndIndexRequestType = GetUncleByBlockNumberAndIndexRequestType;
-declare const index$a_GetUncleByBlockNumberAndIndexResponse: typeof GetUncleByBlockNumberAndIndexResponse;
-type index$a_GetUncleByBlockNumberAndIndexResponseType = GetUncleByBlockNumberAndIndexResponseType;
-declare const index$a_GetUncleByBlockNumberAndIndexResult: typeof GetUncleByBlockNumberAndIndexResult;
-declare const index$a_GetUncleCountByBlockHashParams: typeof GetUncleCountByBlockHashParams;
-declare const index$a_GetUncleCountByBlockHashRequest: typeof GetUncleCountByBlockHashRequest;
-type index$a_GetUncleCountByBlockHashRequestType = GetUncleCountByBlockHashRequestType;
-declare const index$a_GetUncleCountByBlockHashResponse: typeof GetUncleCountByBlockHashResponse;
-type index$a_GetUncleCountByBlockHashResponseType = GetUncleCountByBlockHashResponseType;
-declare const index$a_GetUncleCountByBlockHashResult: typeof GetUncleCountByBlockHashResult;
-declare const index$a_GetUncleCountByBlockNumberParams: typeof GetUncleCountByBlockNumberParams;
-declare const index$a_GetUncleCountByBlockNumberRequest: typeof GetUncleCountByBlockNumberRequest;
-type index$a_GetUncleCountByBlockNumberRequestType = GetUncleCountByBlockNumberRequestType;
-declare const index$a_GetUncleCountByBlockNumberResponse: typeof GetUncleCountByBlockNumberResponse;
-type index$a_GetUncleCountByBlockNumberResponseType = GetUncleCountByBlockNumberResponseType;
-declare const index$a_GetUncleCountByBlockNumberResult: typeof GetUncleCountByBlockNumberResult;
-declare const index$a_GetWorkParams: typeof GetWorkParams;
-declare const index$a_GetWorkRequest: typeof GetWorkRequest;
-type index$a_GetWorkRequestType = GetWorkRequestType;
-declare const index$a_GetWorkResponse: typeof GetWorkResponse;
-type index$a_GetWorkResponseType = GetWorkResponseType;
-declare const index$a_GetWorkResult: typeof GetWorkResult;
-declare const index$a_HashrateParams: typeof HashrateParams;
-declare const index$a_HashrateRequest: typeof HashrateRequest;
-type index$a_HashrateRequestType = HashrateRequestType;
-declare const index$a_HashrateResponse: typeof HashrateResponse;
-type index$a_HashrateResponseType = HashrateResponseType;
-declare const index$a_HashrateResult: typeof HashrateResult;
-declare const index$a_MaxPriorityFeePerGasParams: typeof MaxPriorityFeePerGasParams;
-declare const index$a_MaxPriorityFeePerGasRequest: typeof MaxPriorityFeePerGasRequest;
-type index$a_MaxPriorityFeePerGasRequestType = MaxPriorityFeePerGasRequestType;
-declare const index$a_MaxPriorityFeePerGasResponse: typeof MaxPriorityFeePerGasResponse;
-type index$a_MaxPriorityFeePerGasResponseType = MaxPriorityFeePerGasResponseType;
-declare const index$a_MaxPriorityFeePerGasResult: typeof MaxPriorityFeePerGasResult;
-declare const index$a_MiningParams: typeof MiningParams;
-declare const index$a_MiningRequest: typeof MiningRequest;
-type index$a_MiningRequestType = MiningRequestType;
-declare const index$a_MiningResponse: typeof MiningResponse;
-type index$a_MiningResponseType = MiningResponseType;
-declare const index$a_MiningResult: typeof MiningResult;
-declare const index$a_NewBlockFilterParams: typeof NewBlockFilterParams;
-declare const index$a_NewBlockFilterRequest: typeof NewBlockFilterRequest;
-type index$a_NewBlockFilterRequestType = NewBlockFilterRequestType;
-declare const index$a_NewBlockFilterResponse: typeof NewBlockFilterResponse;
-type index$a_NewBlockFilterResponseType = NewBlockFilterResponseType;
-declare const index$a_NewBlockFilterResult: typeof NewBlockFilterResult;
-declare const index$a_NewFilterParams: typeof NewFilterParams;
-declare const index$a_NewFilterRequest: typeof NewFilterRequest;
-type index$a_NewFilterRequestType = NewFilterRequestType;
-declare const index$a_NewFilterResponse: typeof NewFilterResponse;
-type index$a_NewFilterResponseType = NewFilterResponseType;
-declare const index$a_NewFilterResult: typeof NewFilterResult;
-declare const index$a_NewPendingTransactionFilterParams: typeof NewPendingTransactionFilterParams;
-declare const index$a_NewPendingTransactionFilterRequest: typeof NewPendingTransactionFilterRequest;
-type index$a_NewPendingTransactionFilterRequestType = NewPendingTransactionFilterRequestType;
-declare const index$a_NewPendingTransactionFilterResponse: typeof NewPendingTransactionFilterResponse;
-type index$a_NewPendingTransactionFilterResponseType = NewPendingTransactionFilterResponseType;
-declare const index$a_NewPendingTransactionFilterResult: typeof NewPendingTransactionFilterResult;
-declare const index$a_ProtocolVersionParams: typeof ProtocolVersionParams;
-declare const index$a_ProtocolVersionRequest: typeof ProtocolVersionRequest;
-type index$a_ProtocolVersionRequestType = ProtocolVersionRequestType;
-declare const index$a_ProtocolVersionResponse: typeof ProtocolVersionResponse;
-type index$a_ProtocolVersionResponseType = ProtocolVersionResponseType;
-declare const index$a_ProtocolVersionResult: typeof ProtocolVersionResult;
-declare const index$a_SendRawTransactionParams: typeof SendRawTransactionParams;
-declare const index$a_SendRawTransactionRequest: typeof SendRawTransactionRequest;
-type index$a_SendRawTransactionRequestType = SendRawTransactionRequestType;
-declare const index$a_SendRawTransactionResponse: typeof SendRawTransactionResponse;
-type index$a_SendRawTransactionResponseType = SendRawTransactionResponseType;
-declare const index$a_SendRawTransactionResult: typeof SendRawTransactionResult;
-declare const index$a_SendTransactionParams: typeof SendTransactionParams;
-declare const index$a_SendTransactionRequest: typeof SendTransactionRequest;
-type index$a_SendTransactionRequestType = SendTransactionRequestType;
-declare const index$a_SendTransactionResponse: typeof SendTransactionResponse;
-type index$a_SendTransactionResponseType = SendTransactionResponseType;
-declare const index$a_SendTransactionResult: typeof SendTransactionResult;
-declare const index$a_SignParams: typeof SignParams;
-declare const index$a_SignRequest: typeof SignRequest;
-type index$a_SignRequestType = SignRequestType;
-declare const index$a_SignResponse: typeof SignResponse;
-type index$a_SignResponseType = SignResponseType;
-declare const index$a_SignResult: typeof SignResult;
-declare const index$a_SignTransactionParams: typeof SignTransactionParams;
-declare const index$a_SignTransactionRequest: typeof SignTransactionRequest;
-type index$a_SignTransactionRequestType = SignTransactionRequestType;
-declare const index$a_SignTransactionResponse: typeof SignTransactionResponse;
-type index$a_SignTransactionResponseType = SignTransactionResponseType;
-declare const index$a_SignTransactionResult: typeof SignTransactionResult;
-declare const index$a_SubmitHashrateParams: typeof SubmitHashrateParams;
-declare const index$a_SubmitHashrateRequest: typeof SubmitHashrateRequest;
-type index$a_SubmitHashrateRequestType = SubmitHashrateRequestType;
-declare const index$a_SubmitHashrateResponse: typeof SubmitHashrateResponse;
-type index$a_SubmitHashrateResponseType = SubmitHashrateResponseType;
-declare const index$a_SubmitHashrateResult: typeof SubmitHashrateResult;
-declare const index$a_SubmitWorkParams: typeof SubmitWorkParams;
-declare const index$a_SubmitWorkRequest: typeof SubmitWorkRequest;
-type index$a_SubmitWorkRequestType = SubmitWorkRequestType;
-declare const index$a_SubmitWorkResponse: typeof SubmitWorkResponse;
-type index$a_SubmitWorkResponseType = SubmitWorkResponseType;
-declare const index$a_SubmitWorkResult: typeof SubmitWorkResult;
-declare const index$a_SubscribeLogsParamsNoFilter: typeof SubscribeLogsParamsNoFilter;
-declare const index$a_SubscribeLogsParamsWithFilter: typeof SubscribeLogsParamsWithFilter;
-declare const index$a_SubscribeNewHeadsParams: typeof SubscribeNewHeadsParams;
-declare const index$a_SubscribeNewPendingTransactionsParams: typeof SubscribeNewPendingTransactionsParams;
-declare const index$a_SubscribeParams: typeof SubscribeParams;
-declare const index$a_SubscribeRequest: typeof SubscribeRequest;
-type index$a_SubscribeRequestType = SubscribeRequestType;
-declare const index$a_SubscribeResponse: typeof SubscribeResponse;
-type index$a_SubscribeResponseType = SubscribeResponseType;
-declare const index$a_SubscribeResult: typeof SubscribeResult;
-declare const index$a_SubscribeSyncingParams: typeof SubscribeSyncingParams;
-declare const index$a_SyncingParams: typeof SyncingParams;
-declare const index$a_SyncingRequest: typeof SyncingRequest;
-type index$a_SyncingRequestType = SyncingRequestType;
-declare const index$a_SyncingResponse: typeof SyncingResponse;
-type index$a_SyncingResponseType = SyncingResponseType;
-declare const index$a_SyncingResult: typeof SyncingResult;
-declare const index$a_UninstallFilterParams: typeof UninstallFilterParams;
-declare const index$a_UninstallFilterRequest: typeof UninstallFilterRequest;
-type index$a_UninstallFilterRequestType = UninstallFilterRequestType;
-declare const index$a_UninstallFilterResponse: typeof UninstallFilterResponse;
-type index$a_UninstallFilterResponseType = UninstallFilterResponseType;
-declare const index$a_UninstallFilterResult: typeof UninstallFilterResult;
-declare const index$a_UnsubscribeParams: typeof UnsubscribeParams;
-declare const index$a_UnsubscribeRequest: typeof UnsubscribeRequest;
-type index$a_UnsubscribeRequestType = UnsubscribeRequestType;
-declare const index$a_UnsubscribeResponse: typeof UnsubscribeResponse;
-type index$a_UnsubscribeResponseType = UnsubscribeResponseType;
-declare const index$a_UnsubscribeResult: typeof UnsubscribeResult;
-declare namespace index$a {
-  export { index$a_AccountsParams as AccountsParams, index$a_AccountsRequest as AccountsRequest, type index$a_AccountsRequestType as AccountsRequestType, index$a_AccountsResponse as AccountsResponse, type index$a_AccountsResponseType as AccountsResponseType, index$a_AccountsResult as AccountsResult, index$a_BlobBaseFeeParams as BlobBaseFeeParams, index$a_BlobBaseFeeRequest as BlobBaseFeeRequest, type index$a_BlobBaseFeeRequestType as BlobBaseFeeRequestType, index$a_BlobBaseFeeResponse as BlobBaseFeeResponse, type index$a_BlobBaseFeeResponseType as BlobBaseFeeResponseType, index$a_BlobBaseFeeResult as BlobBaseFeeResult, index$a_BlockNumberParams as BlockNumberParams, index$a_BlockNumberRequest as BlockNumberRequest, type index$a_BlockNumberRequestType as BlockNumberRequestType, index$a_BlockNumberResponse as BlockNumberResponse, type index$a_BlockNumberResponseType as BlockNumberResponseType, index$a_BlockNumberResult as BlockNumberResult, index$a_CallParams as CallParams, index$a_CallRequest as CallRequest, type index$a_CallRequestType as CallRequestType, index$a_CallResponse as CallResponse, type index$a_CallResponseType as CallResponseType, index$a_CallResult as CallResult, index$a_ChainIdParams as ChainIdParams, index$a_ChainIdRequest as ChainIdRequest, type index$a_ChainIdRequestType as ChainIdRequestType, index$a_ChainIdResponse as ChainIdResponse, type index$a_ChainIdResponseType as ChainIdResponseType, index$a_ChainIdResult as ChainIdResult, index$a_CoinbaseParams as CoinbaseParams, index$a_CoinbaseRequest as CoinbaseRequest, type index$a_CoinbaseRequestType as CoinbaseRequestType, index$a_CoinbaseResponse as CoinbaseResponse, type index$a_CoinbaseResponseType as CoinbaseResponseType, index$a_CoinbaseResult as CoinbaseResult, index$a_CreateAccessListParams as CreateAccessListParams, index$a_CreateAccessListRequest as CreateAccessListRequest, type index$a_CreateAccessListRequestType as CreateAccessListRequestType, index$a_CreateAccessListResponse as CreateAccessListResponse, type index$a_CreateAccessListResponseType as CreateAccessListResponseType, index$a_CreateAccessListResult as CreateAccessListResult, index$a_EstimateGasParams as EstimateGasParams, index$a_EstimateGasRequest as EstimateGasRequest, type index$a_EstimateGasRequestType as EstimateGasRequestType, index$a_EstimateGasResponse as EstimateGasResponse, type index$a_EstimateGasResponseType as EstimateGasResponseType, index$a_EstimateGasResult as EstimateGasResult, index$a_EthMethodRequest as EthMethodRequest, type index$a_EthMethodRequestType as EthMethodRequestType, index$a_FeeHistoryParams as FeeHistoryParams, index$a_FeeHistoryRequest as FeeHistoryRequest, type index$a_FeeHistoryRequestType as FeeHistoryRequestType, index$a_FeeHistoryResponse as FeeHistoryResponse, type index$a_FeeHistoryResponseType as FeeHistoryResponseType, index$a_FeeHistoryResult as FeeHistoryResult, index$a_GasPriceParams as GasPriceParams, index$a_GasPriceRequest as GasPriceRequest, type index$a_GasPriceRequestType as GasPriceRequestType, index$a_GasPriceResponse as GasPriceResponse, type index$a_GasPriceResponseType as GasPriceResponseType, index$a_GasPriceResult as GasPriceResult, index$a_GetBalanceParams as GetBalanceParams, index$a_GetBalanceRequest as GetBalanceRequest, type index$a_GetBalanceRequestType as GetBalanceRequestType, index$a_GetBalanceResponse as GetBalanceResponse, type index$a_GetBalanceResponseType as GetBalanceResponseType, index$a_GetBalanceResult as GetBalanceResult, index$a_GetBlockByHashParams as GetBlockByHashParams, index$a_GetBlockByHashRequest as GetBlockByHashRequest, type index$a_GetBlockByHashRequestType as GetBlockByHashRequestType, index$a_GetBlockByHashResponse as GetBlockByHashResponse, type index$a_GetBlockByHashResponseType as GetBlockByHashResponseType, index$a_GetBlockByHashResult as GetBlockByHashResult, index$a_GetBlockByNumberParams as GetBlockByNumberParams, index$a_GetBlockByNumberRequest as GetBlockByNumberRequest, type index$a_GetBlockByNumberRequestType as GetBlockByNumberRequestType, index$a_GetBlockByNumberResponse as GetBlockByNumberResponse, type index$a_GetBlockByNumberResponseType as GetBlockByNumberResponseType, index$a_GetBlockByNumberResult as GetBlockByNumberResult, index$a_GetBlockReceiptsParams as GetBlockReceiptsParams, index$a_GetBlockReceiptsRequest as GetBlockReceiptsRequest, type index$a_GetBlockReceiptsRequestType as GetBlockReceiptsRequestType, index$a_GetBlockReceiptsResponse as GetBlockReceiptsResponse, type index$a_GetBlockReceiptsResponseType as GetBlockReceiptsResponseType, index$a_GetBlockReceiptsResult as GetBlockReceiptsResult, index$a_GetBlockTransactionCountByHashParams as GetBlockTransactionCountByHashParams, index$a_GetBlockTransactionCountByHashRequest as GetBlockTransactionCountByHashRequest, type index$a_GetBlockTransactionCountByHashRequestType as GetBlockTransactionCountByHashRequestType, index$a_GetBlockTransactionCountByHashResponse as GetBlockTransactionCountByHashResponse, type index$a_GetBlockTransactionCountByHashResponseType as GetBlockTransactionCountByHashResponseType, index$a_GetBlockTransactionCountByHashResult as GetBlockTransactionCountByHashResult, index$a_GetBlockTransactionCountByNumberParams as GetBlockTransactionCountByNumberParams, index$a_GetBlockTransactionCountByNumberRequest as GetBlockTransactionCountByNumberRequest, type index$a_GetBlockTransactionCountByNumberRequestType as GetBlockTransactionCountByNumberRequestType, index$a_GetBlockTransactionCountByNumberResponse as GetBlockTransactionCountByNumberResponse, type index$a_GetBlockTransactionCountByNumberResponseType as GetBlockTransactionCountByNumberResponseType, index$a_GetBlockTransactionCountByNumberResult as GetBlockTransactionCountByNumberResult, index$a_GetCodeParams as GetCodeParams, index$a_GetCodeRequest as GetCodeRequest, type index$a_GetCodeRequestType as GetCodeRequestType, index$a_GetCodeResponse as GetCodeResponse, type index$a_GetCodeResponseType as GetCodeResponseType, index$a_GetCodeResult as GetCodeResult, index$a_GetFilterChangesParams as GetFilterChangesParams, index$a_GetFilterChangesRequest as GetFilterChangesRequest, type index$a_GetFilterChangesRequestType as GetFilterChangesRequestType, index$a_GetFilterChangesResponse as GetFilterChangesResponse, type index$a_GetFilterChangesResponseType as GetFilterChangesResponseType, index$a_GetFilterChangesResult as GetFilterChangesResult, index$a_GetFilterLogsParams as GetFilterLogsParams, index$a_GetFilterLogsRequest as GetFilterLogsRequest, type index$a_GetFilterLogsRequestType as GetFilterLogsRequestType, index$a_GetFilterLogsResponse as GetFilterLogsResponse, type index$a_GetFilterLogsResponseType as GetFilterLogsResponseType, index$a_GetFilterLogsResult as GetFilterLogsResult, index$a_GetLogsParams as GetLogsParams, index$a_GetLogsRequest as GetLogsRequest, type index$a_GetLogsRequestType as GetLogsRequestType, index$a_GetLogsResponse as GetLogsResponse, type index$a_GetLogsResponseType as GetLogsResponseType, index$a_GetLogsResult as GetLogsResult, index$a_GetProofParams as GetProofParams, index$a_GetProofRequest as GetProofRequest, type index$a_GetProofRequestType as GetProofRequestType, index$a_GetProofResponse as GetProofResponse, type index$a_GetProofResponseType as GetProofResponseType, index$a_GetProofResult as GetProofResult, index$a_GetStorageAtParams as GetStorageAtParams, index$a_GetStorageAtRequest as GetStorageAtRequest, type index$a_GetStorageAtRequestType as GetStorageAtRequestType, index$a_GetStorageAtResponse as GetStorageAtResponse, type index$a_GetStorageAtResponseType as GetStorageAtResponseType, index$a_GetStorageAtResult as GetStorageAtResult, index$a_GetTransactionByBlockHashAndIndexParams as GetTransactionByBlockHashAndIndexParams, index$a_GetTransactionByBlockHashAndIndexRequest as GetTransactionByBlockHashAndIndexRequest, type index$a_GetTransactionByBlockHashAndIndexRequestType as GetTransactionByBlockHashAndIndexRequestType, index$a_GetTransactionByBlockHashAndIndexResponse as GetTransactionByBlockHashAndIndexResponse, type index$a_GetTransactionByBlockHashAndIndexResponseType as GetTransactionByBlockHashAndIndexResponseType, index$a_GetTransactionByBlockHashAndIndexResult as GetTransactionByBlockHashAndIndexResult, index$a_GetTransactionByBlockNumberAndIndexParams as GetTransactionByBlockNumberAndIndexParams, index$a_GetTransactionByBlockNumberAndIndexRequest as GetTransactionByBlockNumberAndIndexRequest, type index$a_GetTransactionByBlockNumberAndIndexRequestType as GetTransactionByBlockNumberAndIndexRequestType, index$a_GetTransactionByBlockNumberAndIndexResponse as GetTransactionByBlockNumberAndIndexResponse, type index$a_GetTransactionByBlockNumberAndIndexResponseType as GetTransactionByBlockNumberAndIndexResponseType, index$a_GetTransactionByBlockNumberAndIndexResult as GetTransactionByBlockNumberAndIndexResult, index$a_GetTransactionByHashParams as GetTransactionByHashParams, index$a_GetTransactionByHashRequest as GetTransactionByHashRequest, type index$a_GetTransactionByHashRequestType as GetTransactionByHashRequestType, index$a_GetTransactionByHashResponse as GetTransactionByHashResponse, type index$a_GetTransactionByHashResponseType as GetTransactionByHashResponseType, index$a_GetTransactionByHashResult as GetTransactionByHashResult, index$a_GetTransactionCountParams as GetTransactionCountParams, index$a_GetTransactionCountRequest as GetTransactionCountRequest, type index$a_GetTransactionCountRequestType as GetTransactionCountRequestType, index$a_GetTransactionCountResponse as GetTransactionCountResponse, type index$a_GetTransactionCountResponseType as GetTransactionCountResponseType, index$a_GetTransactionCountResult as GetTransactionCountResult, index$a_GetTransactionReceiptParams as GetTransactionReceiptParams, index$a_GetTransactionReceiptRequest as GetTransactionReceiptRequest, type index$a_GetTransactionReceiptRequestType as GetTransactionReceiptRequestType, index$a_GetTransactionReceiptResponse as GetTransactionReceiptResponse, type index$a_GetTransactionReceiptResponseType as GetTransactionReceiptResponseType, index$a_GetTransactionReceiptResult as GetTransactionReceiptResult, index$a_GetUncleByBlockHashAndIndexParams as GetUncleByBlockHashAndIndexParams, index$a_GetUncleByBlockHashAndIndexRequest as GetUncleByBlockHashAndIndexRequest, type index$a_GetUncleByBlockHashAndIndexRequestType as GetUncleByBlockHashAndIndexRequestType, index$a_GetUncleByBlockHashAndIndexResponse as GetUncleByBlockHashAndIndexResponse, type index$a_GetUncleByBlockHashAndIndexResponseType as GetUncleByBlockHashAndIndexResponseType, index$a_GetUncleByBlockHashAndIndexResult as GetUncleByBlockHashAndIndexResult, index$a_GetUncleByBlockNumberAndIndexParams as GetUncleByBlockNumberAndIndexParams, index$a_GetUncleByBlockNumberAndIndexRequest as GetUncleByBlockNumberAndIndexRequest, type index$a_GetUncleByBlockNumberAndIndexRequestType as GetUncleByBlockNumberAndIndexRequestType, index$a_GetUncleByBlockNumberAndIndexResponse as GetUncleByBlockNumberAndIndexResponse, type index$a_GetUncleByBlockNumberAndIndexResponseType as GetUncleByBlockNumberAndIndexResponseType, index$a_GetUncleByBlockNumberAndIndexResult as GetUncleByBlockNumberAndIndexResult, index$a_GetUncleCountByBlockHashParams as GetUncleCountByBlockHashParams, index$a_GetUncleCountByBlockHashRequest as GetUncleCountByBlockHashRequest, type index$a_GetUncleCountByBlockHashRequestType as GetUncleCountByBlockHashRequestType, index$a_GetUncleCountByBlockHashResponse as GetUncleCountByBlockHashResponse, type index$a_GetUncleCountByBlockHashResponseType as GetUncleCountByBlockHashResponseType, index$a_GetUncleCountByBlockHashResult as GetUncleCountByBlockHashResult, index$a_GetUncleCountByBlockNumberParams as GetUncleCountByBlockNumberParams, index$a_GetUncleCountByBlockNumberRequest as GetUncleCountByBlockNumberRequest, type index$a_GetUncleCountByBlockNumberRequestType as GetUncleCountByBlockNumberRequestType, index$a_GetUncleCountByBlockNumberResponse as GetUncleCountByBlockNumberResponse, type index$a_GetUncleCountByBlockNumberResponseType as GetUncleCountByBlockNumberResponseType, index$a_GetUncleCountByBlockNumberResult as GetUncleCountByBlockNumberResult, index$a_GetWorkParams as GetWorkParams, index$a_GetWorkRequest as GetWorkRequest, type index$a_GetWorkRequestType as GetWorkRequestType, index$a_GetWorkResponse as GetWorkResponse, type index$a_GetWorkResponseType as GetWorkResponseType, index$a_GetWorkResult as GetWorkResult, index$a_HashrateParams as HashrateParams, index$a_HashrateRequest as HashrateRequest, type index$a_HashrateRequestType as HashrateRequestType, index$a_HashrateResponse as HashrateResponse, type index$a_HashrateResponseType as HashrateResponseType, index$a_HashrateResult as HashrateResult, index$a_MaxPriorityFeePerGasParams as MaxPriorityFeePerGasParams, index$a_MaxPriorityFeePerGasRequest as MaxPriorityFeePerGasRequest, type index$a_MaxPriorityFeePerGasRequestType as MaxPriorityFeePerGasRequestType, index$a_MaxPriorityFeePerGasResponse as MaxPriorityFeePerGasResponse, type index$a_MaxPriorityFeePerGasResponseType as MaxPriorityFeePerGasResponseType, index$a_MaxPriorityFeePerGasResult as MaxPriorityFeePerGasResult, index$a_MiningParams as MiningParams, index$a_MiningRequest as MiningRequest, type index$a_MiningRequestType as MiningRequestType, index$a_MiningResponse as MiningResponse, type index$a_MiningResponseType as MiningResponseType, index$a_MiningResult as MiningResult, index$a_NewBlockFilterParams as NewBlockFilterParams, index$a_NewBlockFilterRequest as NewBlockFilterRequest, type index$a_NewBlockFilterRequestType as NewBlockFilterRequestType, index$a_NewBlockFilterResponse as NewBlockFilterResponse, type index$a_NewBlockFilterResponseType as NewBlockFilterResponseType, index$a_NewBlockFilterResult as NewBlockFilterResult, index$a_NewFilterParams as NewFilterParams, index$a_NewFilterRequest as NewFilterRequest, type index$a_NewFilterRequestType as NewFilterRequestType, index$a_NewFilterResponse as NewFilterResponse, type index$a_NewFilterResponseType as NewFilterResponseType, index$a_NewFilterResult as NewFilterResult, index$a_NewPendingTransactionFilterParams as NewPendingTransactionFilterParams, index$a_NewPendingTransactionFilterRequest as NewPendingTransactionFilterRequest, type index$a_NewPendingTransactionFilterRequestType as NewPendingTransactionFilterRequestType, index$a_NewPendingTransactionFilterResponse as NewPendingTransactionFilterResponse, type index$a_NewPendingTransactionFilterResponseType as NewPendingTransactionFilterResponseType, index$a_NewPendingTransactionFilterResult as NewPendingTransactionFilterResult, index$a_ProtocolVersionParams as ProtocolVersionParams, index$a_ProtocolVersionRequest as ProtocolVersionRequest, type index$a_ProtocolVersionRequestType as ProtocolVersionRequestType, index$a_ProtocolVersionResponse as ProtocolVersionResponse, type index$a_ProtocolVersionResponseType as ProtocolVersionResponseType, index$a_ProtocolVersionResult as ProtocolVersionResult, index$a_SendRawTransactionParams as SendRawTransactionParams, index$a_SendRawTransactionRequest as SendRawTransactionRequest, type index$a_SendRawTransactionRequestType as SendRawTransactionRequestType, index$a_SendRawTransactionResponse as SendRawTransactionResponse, type index$a_SendRawTransactionResponseType as SendRawTransactionResponseType, index$a_SendRawTransactionResult as SendRawTransactionResult, index$a_SendTransactionParams as SendTransactionParams, index$a_SendTransactionRequest as SendTransactionRequest, type index$a_SendTransactionRequestType as SendTransactionRequestType, index$a_SendTransactionResponse as SendTransactionResponse, type index$a_SendTransactionResponseType as SendTransactionResponseType, index$a_SendTransactionResult as SendTransactionResult, index$a_SignParams as SignParams, index$a_SignRequest as SignRequest, type index$a_SignRequestType as SignRequestType, index$a_SignResponse as SignResponse, type index$a_SignResponseType as SignResponseType, index$a_SignResult as SignResult, index$a_SignTransactionParams as SignTransactionParams, index$a_SignTransactionRequest as SignTransactionRequest, type index$a_SignTransactionRequestType as SignTransactionRequestType, index$a_SignTransactionResponse as SignTransactionResponse, type index$a_SignTransactionResponseType as SignTransactionResponseType, index$a_SignTransactionResult as SignTransactionResult, index$a_SubmitHashrateParams as SubmitHashrateParams, index$a_SubmitHashrateRequest as SubmitHashrateRequest, type index$a_SubmitHashrateRequestType as SubmitHashrateRequestType, index$a_SubmitHashrateResponse as SubmitHashrateResponse, type index$a_SubmitHashrateResponseType as SubmitHashrateResponseType, index$a_SubmitHashrateResult as SubmitHashrateResult, index$a_SubmitWorkParams as SubmitWorkParams, index$a_SubmitWorkRequest as SubmitWorkRequest, type index$a_SubmitWorkRequestType as SubmitWorkRequestType, index$a_SubmitWorkResponse as SubmitWorkResponse, type index$a_SubmitWorkResponseType as SubmitWorkResponseType, index$a_SubmitWorkResult as SubmitWorkResult, index$a_SubscribeLogsParamsNoFilter as SubscribeLogsParamsNoFilter, index$a_SubscribeLogsParamsWithFilter as SubscribeLogsParamsWithFilter, index$a_SubscribeNewHeadsParams as SubscribeNewHeadsParams, index$a_SubscribeNewPendingTransactionsParams as SubscribeNewPendingTransactionsParams, index$a_SubscribeParams as SubscribeParams, index$a_SubscribeRequest as SubscribeRequest, type index$a_SubscribeRequestType as SubscribeRequestType, index$a_SubscribeResponse as SubscribeResponse, type index$a_SubscribeResponseType as SubscribeResponseType, index$a_SubscribeResult as SubscribeResult, index$a_SubscribeSyncingParams as SubscribeSyncingParams, index$a_SyncingParams as SyncingParams, index$a_SyncingRequest as SyncingRequest, type index$a_SyncingRequestType as SyncingRequestType, index$a_SyncingResponse as SyncingResponse, type index$a_SyncingResponseType as SyncingResponseType, index$a_SyncingResult as SyncingResult, index$a_UninstallFilterParams as UninstallFilterParams, index$a_UninstallFilterRequest as UninstallFilterRequest, type index$a_UninstallFilterRequestType as UninstallFilterRequestType, index$a_UninstallFilterResponse as UninstallFilterResponse, type index$a_UninstallFilterResponseType as UninstallFilterResponseType, index$a_UninstallFilterResult as UninstallFilterResult, index$a_UnsubscribeParams as UnsubscribeParams, index$a_UnsubscribeRequest as UnsubscribeRequest, type index$a_UnsubscribeRequestType as UnsubscribeRequestType, index$a_UnsubscribeResponse as UnsubscribeResponse, type index$a_UnsubscribeResponseType as UnsubscribeResponseType, index$a_UnsubscribeResult as UnsubscribeResult };
+declare const index$9_AccountsParams: typeof AccountsParams;
+declare const index$9_AccountsRequest: typeof AccountsRequest;
+type index$9_AccountsRequestType = AccountsRequestType;
+declare const index$9_AccountsResponse: typeof AccountsResponse;
+type index$9_AccountsResponseType = AccountsResponseType;
+declare const index$9_AccountsResult: typeof AccountsResult;
+declare const index$9_BlobBaseFeeParams: typeof BlobBaseFeeParams;
+declare const index$9_BlobBaseFeeRequest: typeof BlobBaseFeeRequest;
+type index$9_BlobBaseFeeRequestType = BlobBaseFeeRequestType;
+declare const index$9_BlobBaseFeeResponse: typeof BlobBaseFeeResponse;
+type index$9_BlobBaseFeeResponseType = BlobBaseFeeResponseType;
+declare const index$9_BlobBaseFeeResult: typeof BlobBaseFeeResult;
+declare const index$9_BlockNumberParams: typeof BlockNumberParams;
+declare const index$9_BlockNumberRequest: typeof BlockNumberRequest;
+type index$9_BlockNumberRequestType = BlockNumberRequestType;
+declare const index$9_BlockNumberResponse: typeof BlockNumberResponse;
+type index$9_BlockNumberResponseType = BlockNumberResponseType;
+declare const index$9_BlockNumberResult: typeof BlockNumberResult;
+declare const index$9_CallParams: typeof CallParams;
+declare const index$9_CallRequest: typeof CallRequest;
+type index$9_CallRequestType = CallRequestType;
+declare const index$9_CallResponse: typeof CallResponse;
+type index$9_CallResponseType = CallResponseType;
+declare const index$9_CallResult: typeof CallResult;
+declare const index$9_ChainIdParams: typeof ChainIdParams;
+declare const index$9_ChainIdRequest: typeof ChainIdRequest;
+type index$9_ChainIdRequestType = ChainIdRequestType;
+declare const index$9_ChainIdResponse: typeof ChainIdResponse;
+type index$9_ChainIdResponseType = ChainIdResponseType;
+declare const index$9_ChainIdResult: typeof ChainIdResult;
+declare const index$9_CoinbaseParams: typeof CoinbaseParams;
+declare const index$9_CoinbaseRequest: typeof CoinbaseRequest;
+type index$9_CoinbaseRequestType = CoinbaseRequestType;
+declare const index$9_CoinbaseResponse: typeof CoinbaseResponse;
+type index$9_CoinbaseResponseType = CoinbaseResponseType;
+declare const index$9_CoinbaseResult: typeof CoinbaseResult;
+declare const index$9_CreateAccessListParams: typeof CreateAccessListParams;
+declare const index$9_CreateAccessListRequest: typeof CreateAccessListRequest;
+type index$9_CreateAccessListRequestType = CreateAccessListRequestType;
+declare const index$9_CreateAccessListResponse: typeof CreateAccessListResponse;
+type index$9_CreateAccessListResponseType = CreateAccessListResponseType;
+declare const index$9_CreateAccessListResult: typeof CreateAccessListResult;
+declare const index$9_EstimateGasParams: typeof EstimateGasParams;
+declare const index$9_EstimateGasRequest: typeof EstimateGasRequest;
+type index$9_EstimateGasRequestType = EstimateGasRequestType;
+declare const index$9_EstimateGasResponse: typeof EstimateGasResponse;
+type index$9_EstimateGasResponseType = EstimateGasResponseType;
+declare const index$9_EstimateGasResult: typeof EstimateGasResult;
+declare const index$9_EthMethodRequest: typeof EthMethodRequest;
+type index$9_EthMethodRequestType = EthMethodRequestType;
+declare const index$9_FeeHistoryParams: typeof FeeHistoryParams;
+declare const index$9_FeeHistoryRequest: typeof FeeHistoryRequest;
+type index$9_FeeHistoryRequestType = FeeHistoryRequestType;
+declare const index$9_FeeHistoryResponse: typeof FeeHistoryResponse;
+type index$9_FeeHistoryResponseType = FeeHistoryResponseType;
+declare const index$9_FeeHistoryResult: typeof FeeHistoryResult;
+declare const index$9_GasPriceParams: typeof GasPriceParams;
+declare const index$9_GasPriceRequest: typeof GasPriceRequest;
+type index$9_GasPriceRequestType = GasPriceRequestType;
+declare const index$9_GasPriceResponse: typeof GasPriceResponse;
+type index$9_GasPriceResponseType = GasPriceResponseType;
+declare const index$9_GasPriceResult: typeof GasPriceResult;
+declare const index$9_GetBalanceParams: typeof GetBalanceParams;
+declare const index$9_GetBalanceRequest: typeof GetBalanceRequest;
+type index$9_GetBalanceRequestType = GetBalanceRequestType;
+declare const index$9_GetBalanceResponse: typeof GetBalanceResponse;
+type index$9_GetBalanceResponseType = GetBalanceResponseType;
+declare const index$9_GetBalanceResult: typeof GetBalanceResult;
+declare const index$9_GetBlockByHashParams: typeof GetBlockByHashParams;
+declare const index$9_GetBlockByHashRequest: typeof GetBlockByHashRequest;
+type index$9_GetBlockByHashRequestType = GetBlockByHashRequestType;
+declare const index$9_GetBlockByHashResponse: typeof GetBlockByHashResponse;
+type index$9_GetBlockByHashResponseType = GetBlockByHashResponseType;
+declare const index$9_GetBlockByHashResult: typeof GetBlockByHashResult;
+declare const index$9_GetBlockByNumberParams: typeof GetBlockByNumberParams;
+declare const index$9_GetBlockByNumberRequest: typeof GetBlockByNumberRequest;
+type index$9_GetBlockByNumberRequestType = GetBlockByNumberRequestType;
+declare const index$9_GetBlockByNumberResponse: typeof GetBlockByNumberResponse;
+type index$9_GetBlockByNumberResponseType = GetBlockByNumberResponseType;
+declare const index$9_GetBlockByNumberResult: typeof GetBlockByNumberResult;
+declare const index$9_GetBlockReceiptsParams: typeof GetBlockReceiptsParams;
+declare const index$9_GetBlockReceiptsRequest: typeof GetBlockReceiptsRequest;
+type index$9_GetBlockReceiptsRequestType = GetBlockReceiptsRequestType;
+declare const index$9_GetBlockReceiptsResponse: typeof GetBlockReceiptsResponse;
+type index$9_GetBlockReceiptsResponseType = GetBlockReceiptsResponseType;
+declare const index$9_GetBlockReceiptsResult: typeof GetBlockReceiptsResult;
+declare const index$9_GetBlockTransactionCountByHashParams: typeof GetBlockTransactionCountByHashParams;
+declare const index$9_GetBlockTransactionCountByHashRequest: typeof GetBlockTransactionCountByHashRequest;
+type index$9_GetBlockTransactionCountByHashRequestType = GetBlockTransactionCountByHashRequestType;
+declare const index$9_GetBlockTransactionCountByHashResponse: typeof GetBlockTransactionCountByHashResponse;
+type index$9_GetBlockTransactionCountByHashResponseType = GetBlockTransactionCountByHashResponseType;
+declare const index$9_GetBlockTransactionCountByHashResult: typeof GetBlockTransactionCountByHashResult;
+declare const index$9_GetBlockTransactionCountByNumberParams: typeof GetBlockTransactionCountByNumberParams;
+declare const index$9_GetBlockTransactionCountByNumberRequest: typeof GetBlockTransactionCountByNumberRequest;
+type index$9_GetBlockTransactionCountByNumberRequestType = GetBlockTransactionCountByNumberRequestType;
+declare const index$9_GetBlockTransactionCountByNumberResponse: typeof GetBlockTransactionCountByNumberResponse;
+type index$9_GetBlockTransactionCountByNumberResponseType = GetBlockTransactionCountByNumberResponseType;
+declare const index$9_GetBlockTransactionCountByNumberResult: typeof GetBlockTransactionCountByNumberResult;
+declare const index$9_GetCodeParams: typeof GetCodeParams;
+declare const index$9_GetCodeRequest: typeof GetCodeRequest;
+type index$9_GetCodeRequestType = GetCodeRequestType;
+declare const index$9_GetCodeResponse: typeof GetCodeResponse;
+type index$9_GetCodeResponseType = GetCodeResponseType;
+declare const index$9_GetCodeResult: typeof GetCodeResult;
+declare const index$9_GetFilterChangesParams: typeof GetFilterChangesParams;
+declare const index$9_GetFilterChangesRequest: typeof GetFilterChangesRequest;
+type index$9_GetFilterChangesRequestType = GetFilterChangesRequestType;
+declare const index$9_GetFilterChangesResponse: typeof GetFilterChangesResponse;
+type index$9_GetFilterChangesResponseType = GetFilterChangesResponseType;
+declare const index$9_GetFilterChangesResult: typeof GetFilterChangesResult;
+declare const index$9_GetFilterLogsParams: typeof GetFilterLogsParams;
+declare const index$9_GetFilterLogsRequest: typeof GetFilterLogsRequest;
+type index$9_GetFilterLogsRequestType = GetFilterLogsRequestType;
+declare const index$9_GetFilterLogsResponse: typeof GetFilterLogsResponse;
+type index$9_GetFilterLogsResponseType = GetFilterLogsResponseType;
+declare const index$9_GetFilterLogsResult: typeof GetFilterLogsResult;
+declare const index$9_GetLogsParams: typeof GetLogsParams;
+declare const index$9_GetLogsRequest: typeof GetLogsRequest;
+type index$9_GetLogsRequestType = GetLogsRequestType;
+declare const index$9_GetLogsResponse: typeof GetLogsResponse;
+type index$9_GetLogsResponseType = GetLogsResponseType;
+declare const index$9_GetLogsResult: typeof GetLogsResult;
+declare const index$9_GetProofParams: typeof GetProofParams;
+declare const index$9_GetProofRequest: typeof GetProofRequest;
+type index$9_GetProofRequestType = GetProofRequestType;
+declare const index$9_GetProofResponse: typeof GetProofResponse;
+type index$9_GetProofResponseType = GetProofResponseType;
+declare const index$9_GetProofResult: typeof GetProofResult;
+declare const index$9_GetStorageAtParams: typeof GetStorageAtParams;
+declare const index$9_GetStorageAtRequest: typeof GetStorageAtRequest;
+type index$9_GetStorageAtRequestType = GetStorageAtRequestType;
+declare const index$9_GetStorageAtResponse: typeof GetStorageAtResponse;
+type index$9_GetStorageAtResponseType = GetStorageAtResponseType;
+declare const index$9_GetStorageAtResult: typeof GetStorageAtResult;
+declare const index$9_GetTransactionByBlockHashAndIndexParams: typeof GetTransactionByBlockHashAndIndexParams;
+declare const index$9_GetTransactionByBlockHashAndIndexRequest: typeof GetTransactionByBlockHashAndIndexRequest;
+type index$9_GetTransactionByBlockHashAndIndexRequestType = GetTransactionByBlockHashAndIndexRequestType;
+declare const index$9_GetTransactionByBlockHashAndIndexResponse: typeof GetTransactionByBlockHashAndIndexResponse;
+type index$9_GetTransactionByBlockHashAndIndexResponseType = GetTransactionByBlockHashAndIndexResponseType;
+declare const index$9_GetTransactionByBlockHashAndIndexResult: typeof GetTransactionByBlockHashAndIndexResult;
+declare const index$9_GetTransactionByBlockNumberAndIndexParams: typeof GetTransactionByBlockNumberAndIndexParams;
+declare const index$9_GetTransactionByBlockNumberAndIndexRequest: typeof GetTransactionByBlockNumberAndIndexRequest;
+type index$9_GetTransactionByBlockNumberAndIndexRequestType = GetTransactionByBlockNumberAndIndexRequestType;
+declare const index$9_GetTransactionByBlockNumberAndIndexResponse: typeof GetTransactionByBlockNumberAndIndexResponse;
+type index$9_GetTransactionByBlockNumberAndIndexResponseType = GetTransactionByBlockNumberAndIndexResponseType;
+declare const index$9_GetTransactionByBlockNumberAndIndexResult: typeof GetTransactionByBlockNumberAndIndexResult;
+declare const index$9_GetTransactionByHashParams: typeof GetTransactionByHashParams;
+declare const index$9_GetTransactionByHashRequest: typeof GetTransactionByHashRequest;
+type index$9_GetTransactionByHashRequestType = GetTransactionByHashRequestType;
+declare const index$9_GetTransactionByHashResponse: typeof GetTransactionByHashResponse;
+type index$9_GetTransactionByHashResponseType = GetTransactionByHashResponseType;
+declare const index$9_GetTransactionByHashResult: typeof GetTransactionByHashResult;
+declare const index$9_GetTransactionCountParams: typeof GetTransactionCountParams;
+declare const index$9_GetTransactionCountRequest: typeof GetTransactionCountRequest;
+type index$9_GetTransactionCountRequestType = GetTransactionCountRequestType;
+declare const index$9_GetTransactionCountResponse: typeof GetTransactionCountResponse;
+type index$9_GetTransactionCountResponseType = GetTransactionCountResponseType;
+declare const index$9_GetTransactionCountResult: typeof GetTransactionCountResult;
+declare const index$9_GetTransactionReceiptParams: typeof GetTransactionReceiptParams;
+declare const index$9_GetTransactionReceiptRequest: typeof GetTransactionReceiptRequest;
+type index$9_GetTransactionReceiptRequestType = GetTransactionReceiptRequestType;
+declare const index$9_GetTransactionReceiptResponse: typeof GetTransactionReceiptResponse;
+type index$9_GetTransactionReceiptResponseType = GetTransactionReceiptResponseType;
+declare const index$9_GetTransactionReceiptResult: typeof GetTransactionReceiptResult;
+declare const index$9_GetUncleByBlockHashAndIndexParams: typeof GetUncleByBlockHashAndIndexParams;
+declare const index$9_GetUncleByBlockHashAndIndexRequest: typeof GetUncleByBlockHashAndIndexRequest;
+type index$9_GetUncleByBlockHashAndIndexRequestType = GetUncleByBlockHashAndIndexRequestType;
+declare const index$9_GetUncleByBlockHashAndIndexResponse: typeof GetUncleByBlockHashAndIndexResponse;
+type index$9_GetUncleByBlockHashAndIndexResponseType = GetUncleByBlockHashAndIndexResponseType;
+declare const index$9_GetUncleByBlockHashAndIndexResult: typeof GetUncleByBlockHashAndIndexResult;
+declare const index$9_GetUncleByBlockNumberAndIndexParams: typeof GetUncleByBlockNumberAndIndexParams;
+declare const index$9_GetUncleByBlockNumberAndIndexRequest: typeof GetUncleByBlockNumberAndIndexRequest;
+type index$9_GetUncleByBlockNumberAndIndexRequestType = GetUncleByBlockNumberAndIndexRequestType;
+declare const index$9_GetUncleByBlockNumberAndIndexResponse: typeof GetUncleByBlockNumberAndIndexResponse;
+type index$9_GetUncleByBlockNumberAndIndexResponseType = GetUncleByBlockNumberAndIndexResponseType;
+declare const index$9_GetUncleByBlockNumberAndIndexResult: typeof GetUncleByBlockNumberAndIndexResult;
+declare const index$9_GetUncleCountByBlockHashParams: typeof GetUncleCountByBlockHashParams;
+declare const index$9_GetUncleCountByBlockHashRequest: typeof GetUncleCountByBlockHashRequest;
+type index$9_GetUncleCountByBlockHashRequestType = GetUncleCountByBlockHashRequestType;
+declare const index$9_GetUncleCountByBlockHashResponse: typeof GetUncleCountByBlockHashResponse;
+type index$9_GetUncleCountByBlockHashResponseType = GetUncleCountByBlockHashResponseType;
+declare const index$9_GetUncleCountByBlockHashResult: typeof GetUncleCountByBlockHashResult;
+declare const index$9_GetUncleCountByBlockNumberParams: typeof GetUncleCountByBlockNumberParams;
+declare const index$9_GetUncleCountByBlockNumberRequest: typeof GetUncleCountByBlockNumberRequest;
+type index$9_GetUncleCountByBlockNumberRequestType = GetUncleCountByBlockNumberRequestType;
+declare const index$9_GetUncleCountByBlockNumberResponse: typeof GetUncleCountByBlockNumberResponse;
+type index$9_GetUncleCountByBlockNumberResponseType = GetUncleCountByBlockNumberResponseType;
+declare const index$9_GetUncleCountByBlockNumberResult: typeof GetUncleCountByBlockNumberResult;
+declare const index$9_GetWorkParams: typeof GetWorkParams;
+declare const index$9_GetWorkRequest: typeof GetWorkRequest;
+type index$9_GetWorkRequestType = GetWorkRequestType;
+declare const index$9_GetWorkResponse: typeof GetWorkResponse;
+type index$9_GetWorkResponseType = GetWorkResponseType;
+declare const index$9_GetWorkResult: typeof GetWorkResult;
+declare const index$9_HashrateParams: typeof HashrateParams;
+declare const index$9_HashrateRequest: typeof HashrateRequest;
+type index$9_HashrateRequestType = HashrateRequestType;
+declare const index$9_HashrateResponse: typeof HashrateResponse;
+type index$9_HashrateResponseType = HashrateResponseType;
+declare const index$9_HashrateResult: typeof HashrateResult;
+declare const index$9_MaxPriorityFeePerGasParams: typeof MaxPriorityFeePerGasParams;
+declare const index$9_MaxPriorityFeePerGasRequest: typeof MaxPriorityFeePerGasRequest;
+type index$9_MaxPriorityFeePerGasRequestType = MaxPriorityFeePerGasRequestType;
+declare const index$9_MaxPriorityFeePerGasResponse: typeof MaxPriorityFeePerGasResponse;
+type index$9_MaxPriorityFeePerGasResponseType = MaxPriorityFeePerGasResponseType;
+declare const index$9_MaxPriorityFeePerGasResult: typeof MaxPriorityFeePerGasResult;
+declare const index$9_MiningParams: typeof MiningParams;
+declare const index$9_MiningRequest: typeof MiningRequest;
+type index$9_MiningRequestType = MiningRequestType;
+declare const index$9_MiningResponse: typeof MiningResponse;
+type index$9_MiningResponseType = MiningResponseType;
+declare const index$9_MiningResult: typeof MiningResult;
+declare const index$9_NewBlockFilterParams: typeof NewBlockFilterParams;
+declare const index$9_NewBlockFilterRequest: typeof NewBlockFilterRequest;
+type index$9_NewBlockFilterRequestType = NewBlockFilterRequestType;
+declare const index$9_NewBlockFilterResponse: typeof NewBlockFilterResponse;
+type index$9_NewBlockFilterResponseType = NewBlockFilterResponseType;
+declare const index$9_NewBlockFilterResult: typeof NewBlockFilterResult;
+declare const index$9_NewFilterParams: typeof NewFilterParams;
+declare const index$9_NewFilterRequest: typeof NewFilterRequest;
+type index$9_NewFilterRequestType = NewFilterRequestType;
+declare const index$9_NewFilterResponse: typeof NewFilterResponse;
+type index$9_NewFilterResponseType = NewFilterResponseType;
+declare const index$9_NewFilterResult: typeof NewFilterResult;
+declare const index$9_NewPendingTransactionFilterParams: typeof NewPendingTransactionFilterParams;
+declare const index$9_NewPendingTransactionFilterRequest: typeof NewPendingTransactionFilterRequest;
+type index$9_NewPendingTransactionFilterRequestType = NewPendingTransactionFilterRequestType;
+declare const index$9_NewPendingTransactionFilterResponse: typeof NewPendingTransactionFilterResponse;
+type index$9_NewPendingTransactionFilterResponseType = NewPendingTransactionFilterResponseType;
+declare const index$9_NewPendingTransactionFilterResult: typeof NewPendingTransactionFilterResult;
+declare const index$9_ProtocolVersionParams: typeof ProtocolVersionParams;
+declare const index$9_ProtocolVersionRequest: typeof ProtocolVersionRequest;
+type index$9_ProtocolVersionRequestType = ProtocolVersionRequestType;
+declare const index$9_ProtocolVersionResponse: typeof ProtocolVersionResponse;
+type index$9_ProtocolVersionResponseType = ProtocolVersionResponseType;
+declare const index$9_ProtocolVersionResult: typeof ProtocolVersionResult;
+declare const index$9_SendRawTransactionParams: typeof SendRawTransactionParams;
+declare const index$9_SendRawTransactionRequest: typeof SendRawTransactionRequest;
+type index$9_SendRawTransactionRequestType = SendRawTransactionRequestType;
+declare const index$9_SendRawTransactionResponse: typeof SendRawTransactionResponse;
+type index$9_SendRawTransactionResponseType = SendRawTransactionResponseType;
+declare const index$9_SendRawTransactionResult: typeof SendRawTransactionResult;
+declare const index$9_SendTransactionParams: typeof SendTransactionParams;
+declare const index$9_SendTransactionRequest: typeof SendTransactionRequest;
+type index$9_SendTransactionRequestType = SendTransactionRequestType;
+declare const index$9_SendTransactionResponse: typeof SendTransactionResponse;
+type index$9_SendTransactionResponseType = SendTransactionResponseType;
+declare const index$9_SendTransactionResult: typeof SendTransactionResult;
+declare const index$9_SignParams: typeof SignParams;
+declare const index$9_SignRequest: typeof SignRequest;
+type index$9_SignRequestType = SignRequestType;
+declare const index$9_SignResponse: typeof SignResponse;
+type index$9_SignResponseType = SignResponseType;
+declare const index$9_SignResult: typeof SignResult;
+declare const index$9_SignTransactionParams: typeof SignTransactionParams;
+declare const index$9_SignTransactionRequest: typeof SignTransactionRequest;
+type index$9_SignTransactionRequestType = SignTransactionRequestType;
+declare const index$9_SignTransactionResponse: typeof SignTransactionResponse;
+type index$9_SignTransactionResponseType = SignTransactionResponseType;
+declare const index$9_SignTransactionResult: typeof SignTransactionResult;
+declare const index$9_SubmitHashrateParams: typeof SubmitHashrateParams;
+declare const index$9_SubmitHashrateRequest: typeof SubmitHashrateRequest;
+type index$9_SubmitHashrateRequestType = SubmitHashrateRequestType;
+declare const index$9_SubmitHashrateResponse: typeof SubmitHashrateResponse;
+type index$9_SubmitHashrateResponseType = SubmitHashrateResponseType;
+declare const index$9_SubmitHashrateResult: typeof SubmitHashrateResult;
+declare const index$9_SubmitWorkParams: typeof SubmitWorkParams;
+declare const index$9_SubmitWorkRequest: typeof SubmitWorkRequest;
+type index$9_SubmitWorkRequestType = SubmitWorkRequestType;
+declare const index$9_SubmitWorkResponse: typeof SubmitWorkResponse;
+type index$9_SubmitWorkResponseType = SubmitWorkResponseType;
+declare const index$9_SubmitWorkResult: typeof SubmitWorkResult;
+declare const index$9_SubscribeLogsParamsNoFilter: typeof SubscribeLogsParamsNoFilter;
+declare const index$9_SubscribeLogsParamsWithFilter: typeof SubscribeLogsParamsWithFilter;
+declare const index$9_SubscribeNewHeadsParams: typeof SubscribeNewHeadsParams;
+declare const index$9_SubscribeNewPendingTransactionsParams: typeof SubscribeNewPendingTransactionsParams;
+declare const index$9_SubscribeParams: typeof SubscribeParams;
+declare const index$9_SubscribeRequest: typeof SubscribeRequest;
+type index$9_SubscribeRequestType = SubscribeRequestType;
+declare const index$9_SubscribeResponse: typeof SubscribeResponse;
+type index$9_SubscribeResponseType = SubscribeResponseType;
+declare const index$9_SubscribeResult: typeof SubscribeResult;
+declare const index$9_SubscribeSyncingParams: typeof SubscribeSyncingParams;
+declare const index$9_SyncingParams: typeof SyncingParams;
+declare const index$9_SyncingRequest: typeof SyncingRequest;
+type index$9_SyncingRequestType = SyncingRequestType;
+declare const index$9_SyncingResponse: typeof SyncingResponse;
+type index$9_SyncingResponseType = SyncingResponseType;
+declare const index$9_SyncingResult: typeof SyncingResult;
+declare const index$9_UninstallFilterParams: typeof UninstallFilterParams;
+declare const index$9_UninstallFilterRequest: typeof UninstallFilterRequest;
+type index$9_UninstallFilterRequestType = UninstallFilterRequestType;
+declare const index$9_UninstallFilterResponse: typeof UninstallFilterResponse;
+type index$9_UninstallFilterResponseType = UninstallFilterResponseType;
+declare const index$9_UninstallFilterResult: typeof UninstallFilterResult;
+declare const index$9_UnsubscribeParams: typeof UnsubscribeParams;
+declare const index$9_UnsubscribeRequest: typeof UnsubscribeRequest;
+type index$9_UnsubscribeRequestType = UnsubscribeRequestType;
+declare const index$9_UnsubscribeResponse: typeof UnsubscribeResponse;
+type index$9_UnsubscribeResponseType = UnsubscribeResponseType;
+declare const index$9_UnsubscribeResult: typeof UnsubscribeResult;
+declare namespace index$9 {
+  export { index$9_AccountsParams as AccountsParams, index$9_AccountsRequest as AccountsRequest, type index$9_AccountsRequestType as AccountsRequestType, index$9_AccountsResponse as AccountsResponse, type index$9_AccountsResponseType as AccountsResponseType, index$9_AccountsResult as AccountsResult, index$9_BlobBaseFeeParams as BlobBaseFeeParams, index$9_BlobBaseFeeRequest as BlobBaseFeeRequest, type index$9_BlobBaseFeeRequestType as BlobBaseFeeRequestType, index$9_BlobBaseFeeResponse as BlobBaseFeeResponse, type index$9_BlobBaseFeeResponseType as BlobBaseFeeResponseType, index$9_BlobBaseFeeResult as BlobBaseFeeResult, index$9_BlockNumberParams as BlockNumberParams, index$9_BlockNumberRequest as BlockNumberRequest, type index$9_BlockNumberRequestType as BlockNumberRequestType, index$9_BlockNumberResponse as BlockNumberResponse, type index$9_BlockNumberResponseType as BlockNumberResponseType, index$9_BlockNumberResult as BlockNumberResult, index$9_CallParams as CallParams, index$9_CallRequest as CallRequest, type index$9_CallRequestType as CallRequestType, index$9_CallResponse as CallResponse, type index$9_CallResponseType as CallResponseType, index$9_CallResult as CallResult, index$9_ChainIdParams as ChainIdParams, index$9_ChainIdRequest as ChainIdRequest, type index$9_ChainIdRequestType as ChainIdRequestType, index$9_ChainIdResponse as ChainIdResponse, type index$9_ChainIdResponseType as ChainIdResponseType, index$9_ChainIdResult as ChainIdResult, index$9_CoinbaseParams as CoinbaseParams, index$9_CoinbaseRequest as CoinbaseRequest, type index$9_CoinbaseRequestType as CoinbaseRequestType, index$9_CoinbaseResponse as CoinbaseResponse, type index$9_CoinbaseResponseType as CoinbaseResponseType, index$9_CoinbaseResult as CoinbaseResult, index$9_CreateAccessListParams as CreateAccessListParams, index$9_CreateAccessListRequest as CreateAccessListRequest, type index$9_CreateAccessListRequestType as CreateAccessListRequestType, index$9_CreateAccessListResponse as CreateAccessListResponse, type index$9_CreateAccessListResponseType as CreateAccessListResponseType, index$9_CreateAccessListResult as CreateAccessListResult, index$9_EstimateGasParams as EstimateGasParams, index$9_EstimateGasRequest as EstimateGasRequest, type index$9_EstimateGasRequestType as EstimateGasRequestType, index$9_EstimateGasResponse as EstimateGasResponse, type index$9_EstimateGasResponseType as EstimateGasResponseType, index$9_EstimateGasResult as EstimateGasResult, index$9_EthMethodRequest as EthMethodRequest, type index$9_EthMethodRequestType as EthMethodRequestType, index$9_FeeHistoryParams as FeeHistoryParams, index$9_FeeHistoryRequest as FeeHistoryRequest, type index$9_FeeHistoryRequestType as FeeHistoryRequestType, index$9_FeeHistoryResponse as FeeHistoryResponse, type index$9_FeeHistoryResponseType as FeeHistoryResponseType, index$9_FeeHistoryResult as FeeHistoryResult, index$9_GasPriceParams as GasPriceParams, index$9_GasPriceRequest as GasPriceRequest, type index$9_GasPriceRequestType as GasPriceRequestType, index$9_GasPriceResponse as GasPriceResponse, type index$9_GasPriceResponseType as GasPriceResponseType, index$9_GasPriceResult as GasPriceResult, index$9_GetBalanceParams as GetBalanceParams, index$9_GetBalanceRequest as GetBalanceRequest, type index$9_GetBalanceRequestType as GetBalanceRequestType, index$9_GetBalanceResponse as GetBalanceResponse, type index$9_GetBalanceResponseType as GetBalanceResponseType, index$9_GetBalanceResult as GetBalanceResult, index$9_GetBlockByHashParams as GetBlockByHashParams, index$9_GetBlockByHashRequest as GetBlockByHashRequest, type index$9_GetBlockByHashRequestType as GetBlockByHashRequestType, index$9_GetBlockByHashResponse as GetBlockByHashResponse, type index$9_GetBlockByHashResponseType as GetBlockByHashResponseType, index$9_GetBlockByHashResult as GetBlockByHashResult, index$9_GetBlockByNumberParams as GetBlockByNumberParams, index$9_GetBlockByNumberRequest as GetBlockByNumberRequest, type index$9_GetBlockByNumberRequestType as GetBlockByNumberRequestType, index$9_GetBlockByNumberResponse as GetBlockByNumberResponse, type index$9_GetBlockByNumberResponseType as GetBlockByNumberResponseType, index$9_GetBlockByNumberResult as GetBlockByNumberResult, index$9_GetBlockReceiptsParams as GetBlockReceiptsParams, index$9_GetBlockReceiptsRequest as GetBlockReceiptsRequest, type index$9_GetBlockReceiptsRequestType as GetBlockReceiptsRequestType, index$9_GetBlockReceiptsResponse as GetBlockReceiptsResponse, type index$9_GetBlockReceiptsResponseType as GetBlockReceiptsResponseType, index$9_GetBlockReceiptsResult as GetBlockReceiptsResult, index$9_GetBlockTransactionCountByHashParams as GetBlockTransactionCountByHashParams, index$9_GetBlockTransactionCountByHashRequest as GetBlockTransactionCountByHashRequest, type index$9_GetBlockTransactionCountByHashRequestType as GetBlockTransactionCountByHashRequestType, index$9_GetBlockTransactionCountByHashResponse as GetBlockTransactionCountByHashResponse, type index$9_GetBlockTransactionCountByHashResponseType as GetBlockTransactionCountByHashResponseType, index$9_GetBlockTransactionCountByHashResult as GetBlockTransactionCountByHashResult, index$9_GetBlockTransactionCountByNumberParams as GetBlockTransactionCountByNumberParams, index$9_GetBlockTransactionCountByNumberRequest as GetBlockTransactionCountByNumberRequest, type index$9_GetBlockTransactionCountByNumberRequestType as GetBlockTransactionCountByNumberRequestType, index$9_GetBlockTransactionCountByNumberResponse as GetBlockTransactionCountByNumberResponse, type index$9_GetBlockTransactionCountByNumberResponseType as GetBlockTransactionCountByNumberResponseType, index$9_GetBlockTransactionCountByNumberResult as GetBlockTransactionCountByNumberResult, index$9_GetCodeParams as GetCodeParams, index$9_GetCodeRequest as GetCodeRequest, type index$9_GetCodeRequestType as GetCodeRequestType, index$9_GetCodeResponse as GetCodeResponse, type index$9_GetCodeResponseType as GetCodeResponseType, index$9_GetCodeResult as GetCodeResult, index$9_GetFilterChangesParams as GetFilterChangesParams, index$9_GetFilterChangesRequest as GetFilterChangesRequest, type index$9_GetFilterChangesRequestType as GetFilterChangesRequestType, index$9_GetFilterChangesResponse as GetFilterChangesResponse, type index$9_GetFilterChangesResponseType as GetFilterChangesResponseType, index$9_GetFilterChangesResult as GetFilterChangesResult, index$9_GetFilterLogsParams as GetFilterLogsParams, index$9_GetFilterLogsRequest as GetFilterLogsRequest, type index$9_GetFilterLogsRequestType as GetFilterLogsRequestType, index$9_GetFilterLogsResponse as GetFilterLogsResponse, type index$9_GetFilterLogsResponseType as GetFilterLogsResponseType, index$9_GetFilterLogsResult as GetFilterLogsResult, index$9_GetLogsParams as GetLogsParams, index$9_GetLogsRequest as GetLogsRequest, type index$9_GetLogsRequestType as GetLogsRequestType, index$9_GetLogsResponse as GetLogsResponse, type index$9_GetLogsResponseType as GetLogsResponseType, index$9_GetLogsResult as GetLogsResult, index$9_GetProofParams as GetProofParams, index$9_GetProofRequest as GetProofRequest, type index$9_GetProofRequestType as GetProofRequestType, index$9_GetProofResponse as GetProofResponse, type index$9_GetProofResponseType as GetProofResponseType, index$9_GetProofResult as GetProofResult, index$9_GetStorageAtParams as GetStorageAtParams, index$9_GetStorageAtRequest as GetStorageAtRequest, type index$9_GetStorageAtRequestType as GetStorageAtRequestType, index$9_GetStorageAtResponse as GetStorageAtResponse, type index$9_GetStorageAtResponseType as GetStorageAtResponseType, index$9_GetStorageAtResult as GetStorageAtResult, index$9_GetTransactionByBlockHashAndIndexParams as GetTransactionByBlockHashAndIndexParams, index$9_GetTransactionByBlockHashAndIndexRequest as GetTransactionByBlockHashAndIndexRequest, type index$9_GetTransactionByBlockHashAndIndexRequestType as GetTransactionByBlockHashAndIndexRequestType, index$9_GetTransactionByBlockHashAndIndexResponse as GetTransactionByBlockHashAndIndexResponse, type index$9_GetTransactionByBlockHashAndIndexResponseType as GetTransactionByBlockHashAndIndexResponseType, index$9_GetTransactionByBlockHashAndIndexResult as GetTransactionByBlockHashAndIndexResult, index$9_GetTransactionByBlockNumberAndIndexParams as GetTransactionByBlockNumberAndIndexParams, index$9_GetTransactionByBlockNumberAndIndexRequest as GetTransactionByBlockNumberAndIndexRequest, type index$9_GetTransactionByBlockNumberAndIndexRequestType as GetTransactionByBlockNumberAndIndexRequestType, index$9_GetTransactionByBlockNumberAndIndexResponse as GetTransactionByBlockNumberAndIndexResponse, type index$9_GetTransactionByBlockNumberAndIndexResponseType as GetTransactionByBlockNumberAndIndexResponseType, index$9_GetTransactionByBlockNumberAndIndexResult as GetTransactionByBlockNumberAndIndexResult, index$9_GetTransactionByHashParams as GetTransactionByHashParams, index$9_GetTransactionByHashRequest as GetTransactionByHashRequest, type index$9_GetTransactionByHashRequestType as GetTransactionByHashRequestType, index$9_GetTransactionByHashResponse as GetTransactionByHashResponse, type index$9_GetTransactionByHashResponseType as GetTransactionByHashResponseType, index$9_GetTransactionByHashResult as GetTransactionByHashResult, index$9_GetTransactionCountParams as GetTransactionCountParams, index$9_GetTransactionCountRequest as GetTransactionCountRequest, type index$9_GetTransactionCountRequestType as GetTransactionCountRequestType, index$9_GetTransactionCountResponse as GetTransactionCountResponse, type index$9_GetTransactionCountResponseType as GetTransactionCountResponseType, index$9_GetTransactionCountResult as GetTransactionCountResult, index$9_GetTransactionReceiptParams as GetTransactionReceiptParams, index$9_GetTransactionReceiptRequest as GetTransactionReceiptRequest, type index$9_GetTransactionReceiptRequestType as GetTransactionReceiptRequestType, index$9_GetTransactionReceiptResponse as GetTransactionReceiptResponse, type index$9_GetTransactionReceiptResponseType as GetTransactionReceiptResponseType, index$9_GetTransactionReceiptResult as GetTransactionReceiptResult, index$9_GetUncleByBlockHashAndIndexParams as GetUncleByBlockHashAndIndexParams, index$9_GetUncleByBlockHashAndIndexRequest as GetUncleByBlockHashAndIndexRequest, type index$9_GetUncleByBlockHashAndIndexRequestType as GetUncleByBlockHashAndIndexRequestType, index$9_GetUncleByBlockHashAndIndexResponse as GetUncleByBlockHashAndIndexResponse, type index$9_GetUncleByBlockHashAndIndexResponseType as GetUncleByBlockHashAndIndexResponseType, index$9_GetUncleByBlockHashAndIndexResult as GetUncleByBlockHashAndIndexResult, index$9_GetUncleByBlockNumberAndIndexParams as GetUncleByBlockNumberAndIndexParams, index$9_GetUncleByBlockNumberAndIndexRequest as GetUncleByBlockNumberAndIndexRequest, type index$9_GetUncleByBlockNumberAndIndexRequestType as GetUncleByBlockNumberAndIndexRequestType, index$9_GetUncleByBlockNumberAndIndexResponse as GetUncleByBlockNumberAndIndexResponse, type index$9_GetUncleByBlockNumberAndIndexResponseType as GetUncleByBlockNumberAndIndexResponseType, index$9_GetUncleByBlockNumberAndIndexResult as GetUncleByBlockNumberAndIndexResult, index$9_GetUncleCountByBlockHashParams as GetUncleCountByBlockHashParams, index$9_GetUncleCountByBlockHashRequest as GetUncleCountByBlockHashRequest, type index$9_GetUncleCountByBlockHashRequestType as GetUncleCountByBlockHashRequestType, index$9_GetUncleCountByBlockHashResponse as GetUncleCountByBlockHashResponse, type index$9_GetUncleCountByBlockHashResponseType as GetUncleCountByBlockHashResponseType, index$9_GetUncleCountByBlockHashResult as GetUncleCountByBlockHashResult, index$9_GetUncleCountByBlockNumberParams as GetUncleCountByBlockNumberParams, index$9_GetUncleCountByBlockNumberRequest as GetUncleCountByBlockNumberRequest, type index$9_GetUncleCountByBlockNumberRequestType as GetUncleCountByBlockNumberRequestType, index$9_GetUncleCountByBlockNumberResponse as GetUncleCountByBlockNumberResponse, type index$9_GetUncleCountByBlockNumberResponseType as GetUncleCountByBlockNumberResponseType, index$9_GetUncleCountByBlockNumberResult as GetUncleCountByBlockNumberResult, index$9_GetWorkParams as GetWorkParams, index$9_GetWorkRequest as GetWorkRequest, type index$9_GetWorkRequestType as GetWorkRequestType, index$9_GetWorkResponse as GetWorkResponse, type index$9_GetWorkResponseType as GetWorkResponseType, index$9_GetWorkResult as GetWorkResult, index$9_HashrateParams as HashrateParams, index$9_HashrateRequest as HashrateRequest, type index$9_HashrateRequestType as HashrateRequestType, index$9_HashrateResponse as HashrateResponse, type index$9_HashrateResponseType as HashrateResponseType, index$9_HashrateResult as HashrateResult, index$9_MaxPriorityFeePerGasParams as MaxPriorityFeePerGasParams, index$9_MaxPriorityFeePerGasRequest as MaxPriorityFeePerGasRequest, type index$9_MaxPriorityFeePerGasRequestType as MaxPriorityFeePerGasRequestType, index$9_MaxPriorityFeePerGasResponse as MaxPriorityFeePerGasResponse, type index$9_MaxPriorityFeePerGasResponseType as MaxPriorityFeePerGasResponseType, index$9_MaxPriorityFeePerGasResult as MaxPriorityFeePerGasResult, index$9_MiningParams as MiningParams, index$9_MiningRequest as MiningRequest, type index$9_MiningRequestType as MiningRequestType, index$9_MiningResponse as MiningResponse, type index$9_MiningResponseType as MiningResponseType, index$9_MiningResult as MiningResult, index$9_NewBlockFilterParams as NewBlockFilterParams, index$9_NewBlockFilterRequest as NewBlockFilterRequest, type index$9_NewBlockFilterRequestType as NewBlockFilterRequestType, index$9_NewBlockFilterResponse as NewBlockFilterResponse, type index$9_NewBlockFilterResponseType as NewBlockFilterResponseType, index$9_NewBlockFilterResult as NewBlockFilterResult, index$9_NewFilterParams as NewFilterParams, index$9_NewFilterRequest as NewFilterRequest, type index$9_NewFilterRequestType as NewFilterRequestType, index$9_NewFilterResponse as NewFilterResponse, type index$9_NewFilterResponseType as NewFilterResponseType, index$9_NewFilterResult as NewFilterResult, index$9_NewPendingTransactionFilterParams as NewPendingTransactionFilterParams, index$9_NewPendingTransactionFilterRequest as NewPendingTransactionFilterRequest, type index$9_NewPendingTransactionFilterRequestType as NewPendingTransactionFilterRequestType, index$9_NewPendingTransactionFilterResponse as NewPendingTransactionFilterResponse, type index$9_NewPendingTransactionFilterResponseType as NewPendingTransactionFilterResponseType, index$9_NewPendingTransactionFilterResult as NewPendingTransactionFilterResult, index$9_ProtocolVersionParams as ProtocolVersionParams, index$9_ProtocolVersionRequest as ProtocolVersionRequest, type index$9_ProtocolVersionRequestType as ProtocolVersionRequestType, index$9_ProtocolVersionResponse as ProtocolVersionResponse, type index$9_ProtocolVersionResponseType as ProtocolVersionResponseType, index$9_ProtocolVersionResult as ProtocolVersionResult, index$9_SendRawTransactionParams as SendRawTransactionParams, index$9_SendRawTransactionRequest as SendRawTransactionRequest, type index$9_SendRawTransactionRequestType as SendRawTransactionRequestType, index$9_SendRawTransactionResponse as SendRawTransactionResponse, type index$9_SendRawTransactionResponseType as SendRawTransactionResponseType, index$9_SendRawTransactionResult as SendRawTransactionResult, index$9_SendTransactionParams as SendTransactionParams, index$9_SendTransactionRequest as SendTransactionRequest, type index$9_SendTransactionRequestType as SendTransactionRequestType, index$9_SendTransactionResponse as SendTransactionResponse, type index$9_SendTransactionResponseType as SendTransactionResponseType, index$9_SendTransactionResult as SendTransactionResult, index$9_SignParams as SignParams, index$9_SignRequest as SignRequest, type index$9_SignRequestType as SignRequestType, index$9_SignResponse as SignResponse, type index$9_SignResponseType as SignResponseType, index$9_SignResult as SignResult, index$9_SignTransactionParams as SignTransactionParams, index$9_SignTransactionRequest as SignTransactionRequest, type index$9_SignTransactionRequestType as SignTransactionRequestType, index$9_SignTransactionResponse as SignTransactionResponse, type index$9_SignTransactionResponseType as SignTransactionResponseType, index$9_SignTransactionResult as SignTransactionResult, index$9_SubmitHashrateParams as SubmitHashrateParams, index$9_SubmitHashrateRequest as SubmitHashrateRequest, type index$9_SubmitHashrateRequestType as SubmitHashrateRequestType, index$9_SubmitHashrateResponse as SubmitHashrateResponse, type index$9_SubmitHashrateResponseType as SubmitHashrateResponseType, index$9_SubmitHashrateResult as SubmitHashrateResult, index$9_SubmitWorkParams as SubmitWorkParams, index$9_SubmitWorkRequest as SubmitWorkRequest, type index$9_SubmitWorkRequestType as SubmitWorkRequestType, index$9_SubmitWorkResponse as SubmitWorkResponse, type index$9_SubmitWorkResponseType as SubmitWorkResponseType, index$9_SubmitWorkResult as SubmitWorkResult, index$9_SubscribeLogsParamsNoFilter as SubscribeLogsParamsNoFilter, index$9_SubscribeLogsParamsWithFilter as SubscribeLogsParamsWithFilter, index$9_SubscribeNewHeadsParams as SubscribeNewHeadsParams, index$9_SubscribeNewPendingTransactionsParams as SubscribeNewPendingTransactionsParams, index$9_SubscribeParams as SubscribeParams, index$9_SubscribeRequest as SubscribeRequest, type index$9_SubscribeRequestType as SubscribeRequestType, index$9_SubscribeResponse as SubscribeResponse, type index$9_SubscribeResponseType as SubscribeResponseType, index$9_SubscribeResult as SubscribeResult, index$9_SubscribeSyncingParams as SubscribeSyncingParams, index$9_SyncingParams as SyncingParams, index$9_SyncingRequest as SyncingRequest, type index$9_SyncingRequestType as SyncingRequestType, index$9_SyncingResponse as SyncingResponse, type index$9_SyncingResponseType as SyncingResponseType, index$9_SyncingResult as SyncingResult, index$9_UninstallFilterParams as UninstallFilterParams, index$9_UninstallFilterRequest as UninstallFilterRequest, type index$9_UninstallFilterRequestType as UninstallFilterRequestType, index$9_UninstallFilterResponse as UninstallFilterResponse, type index$9_UninstallFilterResponseType as UninstallFilterResponseType, index$9_UninstallFilterResult as UninstallFilterResult, index$9_UnsubscribeParams as UnsubscribeParams, index$9_UnsubscribeRequest as UnsubscribeRequest, type index$9_UnsubscribeRequestType as UnsubscribeRequestType, index$9_UnsubscribeResponse as UnsubscribeResponse, type index$9_UnsubscribeResponseType as UnsubscribeResponseType, index$9_UnsubscribeResult as UnsubscribeResult };
 }
 
 /**
@@ -7882,65 +7930,65 @@ declare const HardhatMethodRequest: S.Union<[S.Struct<{
 /** Type for HardhatMethodRequest union */
 type HardhatMethodRequestType = S.Schema.Type<typeof HardhatMethodRequest>;
 
-declare const index$9_DropTransactionParams: typeof DropTransactionParams;
-declare const index$9_DropTransactionRequest: typeof DropTransactionRequest;
-type index$9_DropTransactionRequestType = DropTransactionRequestType;
-declare const index$9_DropTransactionResponse: typeof DropTransactionResponse;
-type index$9_DropTransactionResponseType = DropTransactionResponseType;
-declare const index$9_DropTransactionResult: typeof DropTransactionResult;
-declare const index$9_ForkConfigSchema: typeof ForkConfigSchema;
-declare const index$9_HardhatMethodRequest: typeof HardhatMethodRequest;
-type index$9_HardhatMethodRequestType = HardhatMethodRequestType;
-declare const index$9_ImpersonateAccountParams: typeof ImpersonateAccountParams;
-declare const index$9_ImpersonateAccountRequest: typeof ImpersonateAccountRequest;
-type index$9_ImpersonateAccountRequestType = ImpersonateAccountRequestType;
-declare const index$9_ImpersonateAccountResponse: typeof ImpersonateAccountResponse;
-type index$9_ImpersonateAccountResponseType = ImpersonateAccountResponseType;
-declare const index$9_ImpersonateAccountResult: typeof ImpersonateAccountResult;
-declare const index$9_MineParams: typeof MineParams;
-declare const index$9_MineRequest: typeof MineRequest;
-type index$9_MineRequestType = MineRequestType;
-declare const index$9_MineResponse: typeof MineResponse;
-type index$9_MineResponseType = MineResponseType;
-declare const index$9_MineResult: typeof MineResult;
-declare const index$9_ResetParams: typeof ResetParams;
-declare const index$9_ResetRequest: typeof ResetRequest;
-type index$9_ResetRequestType = ResetRequestType;
-declare const index$9_ResetResponse: typeof ResetResponse;
-type index$9_ResetResponseType = ResetResponseType;
-declare const index$9_ResetResult: typeof ResetResult;
-declare const index$9_SetBalanceParams: typeof SetBalanceParams;
-declare const index$9_SetBalanceRequest: typeof SetBalanceRequest;
-type index$9_SetBalanceRequestType = SetBalanceRequestType;
-declare const index$9_SetBalanceResponse: typeof SetBalanceResponse;
-type index$9_SetBalanceResponseType = SetBalanceResponseType;
-declare const index$9_SetBalanceResult: typeof SetBalanceResult;
-declare const index$9_SetCodeParams: typeof SetCodeParams;
-declare const index$9_SetCodeRequest: typeof SetCodeRequest;
-type index$9_SetCodeRequestType = SetCodeRequestType;
-declare const index$9_SetCodeResponse: typeof SetCodeResponse;
-type index$9_SetCodeResponseType = SetCodeResponseType;
-declare const index$9_SetCodeResult: typeof SetCodeResult;
-declare const index$9_SetNonceParams: typeof SetNonceParams;
-declare const index$9_SetNonceRequest: typeof SetNonceRequest;
-type index$9_SetNonceRequestType = SetNonceRequestType;
-declare const index$9_SetNonceResponse: typeof SetNonceResponse;
-type index$9_SetNonceResponseType = SetNonceResponseType;
-declare const index$9_SetNonceResult: typeof SetNonceResult;
-declare const index$9_SetStorageAtParams: typeof SetStorageAtParams;
-declare const index$9_SetStorageAtRequest: typeof SetStorageAtRequest;
-type index$9_SetStorageAtRequestType = SetStorageAtRequestType;
-declare const index$9_SetStorageAtResponse: typeof SetStorageAtResponse;
-type index$9_SetStorageAtResponseType = SetStorageAtResponseType;
-declare const index$9_SetStorageAtResult: typeof SetStorageAtResult;
-declare const index$9_StopImpersonatingAccountParams: typeof StopImpersonatingAccountParams;
-declare const index$9_StopImpersonatingAccountRequest: typeof StopImpersonatingAccountRequest;
-type index$9_StopImpersonatingAccountRequestType = StopImpersonatingAccountRequestType;
-declare const index$9_StopImpersonatingAccountResponse: typeof StopImpersonatingAccountResponse;
-type index$9_StopImpersonatingAccountResponseType = StopImpersonatingAccountResponseType;
-declare const index$9_StopImpersonatingAccountResult: typeof StopImpersonatingAccountResult;
-declare namespace index$9 {
-  export { index$9_DropTransactionParams as DropTransactionParams, index$9_DropTransactionRequest as DropTransactionRequest, type index$9_DropTransactionRequestType as DropTransactionRequestType, index$9_DropTransactionResponse as DropTransactionResponse, type index$9_DropTransactionResponseType as DropTransactionResponseType, index$9_DropTransactionResult as DropTransactionResult, index$9_ForkConfigSchema as ForkConfigSchema, index$9_HardhatMethodRequest as HardhatMethodRequest, type index$9_HardhatMethodRequestType as HardhatMethodRequestType, index$9_ImpersonateAccountParams as ImpersonateAccountParams, index$9_ImpersonateAccountRequest as ImpersonateAccountRequest, type index$9_ImpersonateAccountRequestType as ImpersonateAccountRequestType, index$9_ImpersonateAccountResponse as ImpersonateAccountResponse, type index$9_ImpersonateAccountResponseType as ImpersonateAccountResponseType, index$9_ImpersonateAccountResult as ImpersonateAccountResult, index$9_MineParams as MineParams, index$9_MineRequest as MineRequest, type index$9_MineRequestType as MineRequestType, index$9_MineResponse as MineResponse, type index$9_MineResponseType as MineResponseType, index$9_MineResult as MineResult, index$9_ResetParams as ResetParams, index$9_ResetRequest as ResetRequest, type index$9_ResetRequestType as ResetRequestType, index$9_ResetResponse as ResetResponse, type index$9_ResetResponseType as ResetResponseType, index$9_ResetResult as ResetResult, index$9_SetBalanceParams as SetBalanceParams, index$9_SetBalanceRequest as SetBalanceRequest, type index$9_SetBalanceRequestType as SetBalanceRequestType, index$9_SetBalanceResponse as SetBalanceResponse, type index$9_SetBalanceResponseType as SetBalanceResponseType, index$9_SetBalanceResult as SetBalanceResult, index$9_SetCodeParams as SetCodeParams, index$9_SetCodeRequest as SetCodeRequest, type index$9_SetCodeRequestType as SetCodeRequestType, index$9_SetCodeResponse as SetCodeResponse, type index$9_SetCodeResponseType as SetCodeResponseType, index$9_SetCodeResult as SetCodeResult, index$9_SetNonceParams as SetNonceParams, index$9_SetNonceRequest as SetNonceRequest, type index$9_SetNonceRequestType as SetNonceRequestType, index$9_SetNonceResponse as SetNonceResponse, type index$9_SetNonceResponseType as SetNonceResponseType, index$9_SetNonceResult as SetNonceResult, index$9_SetStorageAtParams as SetStorageAtParams, index$9_SetStorageAtRequest as SetStorageAtRequest, type index$9_SetStorageAtRequestType as SetStorageAtRequestType, index$9_SetStorageAtResponse as SetStorageAtResponse, type index$9_SetStorageAtResponseType as SetStorageAtResponseType, index$9_SetStorageAtResult as SetStorageAtResult, index$9_StopImpersonatingAccountParams as StopImpersonatingAccountParams, index$9_StopImpersonatingAccountRequest as StopImpersonatingAccountRequest, type index$9_StopImpersonatingAccountRequestType as StopImpersonatingAccountRequestType, index$9_StopImpersonatingAccountResponse as StopImpersonatingAccountResponse, type index$9_StopImpersonatingAccountResponseType as StopImpersonatingAccountResponseType, index$9_StopImpersonatingAccountResult as StopImpersonatingAccountResult };
+declare const index$8_DropTransactionParams: typeof DropTransactionParams;
+declare const index$8_DropTransactionRequest: typeof DropTransactionRequest;
+type index$8_DropTransactionRequestType = DropTransactionRequestType;
+declare const index$8_DropTransactionResponse: typeof DropTransactionResponse;
+type index$8_DropTransactionResponseType = DropTransactionResponseType;
+declare const index$8_DropTransactionResult: typeof DropTransactionResult;
+declare const index$8_ForkConfigSchema: typeof ForkConfigSchema;
+declare const index$8_HardhatMethodRequest: typeof HardhatMethodRequest;
+type index$8_HardhatMethodRequestType = HardhatMethodRequestType;
+declare const index$8_ImpersonateAccountParams: typeof ImpersonateAccountParams;
+declare const index$8_ImpersonateAccountRequest: typeof ImpersonateAccountRequest;
+type index$8_ImpersonateAccountRequestType = ImpersonateAccountRequestType;
+declare const index$8_ImpersonateAccountResponse: typeof ImpersonateAccountResponse;
+type index$8_ImpersonateAccountResponseType = ImpersonateAccountResponseType;
+declare const index$8_ImpersonateAccountResult: typeof ImpersonateAccountResult;
+declare const index$8_MineParams: typeof MineParams;
+declare const index$8_MineRequest: typeof MineRequest;
+type index$8_MineRequestType = MineRequestType;
+declare const index$8_MineResponse: typeof MineResponse;
+type index$8_MineResponseType = MineResponseType;
+declare const index$8_MineResult: typeof MineResult;
+declare const index$8_ResetParams: typeof ResetParams;
+declare const index$8_ResetRequest: typeof ResetRequest;
+type index$8_ResetRequestType = ResetRequestType;
+declare const index$8_ResetResponse: typeof ResetResponse;
+type index$8_ResetResponseType = ResetResponseType;
+declare const index$8_ResetResult: typeof ResetResult;
+declare const index$8_SetBalanceParams: typeof SetBalanceParams;
+declare const index$8_SetBalanceRequest: typeof SetBalanceRequest;
+type index$8_SetBalanceRequestType = SetBalanceRequestType;
+declare const index$8_SetBalanceResponse: typeof SetBalanceResponse;
+type index$8_SetBalanceResponseType = SetBalanceResponseType;
+declare const index$8_SetBalanceResult: typeof SetBalanceResult;
+declare const index$8_SetCodeParams: typeof SetCodeParams;
+declare const index$8_SetCodeRequest: typeof SetCodeRequest;
+type index$8_SetCodeRequestType = SetCodeRequestType;
+declare const index$8_SetCodeResponse: typeof SetCodeResponse;
+type index$8_SetCodeResponseType = SetCodeResponseType;
+declare const index$8_SetCodeResult: typeof SetCodeResult;
+declare const index$8_SetNonceParams: typeof SetNonceParams;
+declare const index$8_SetNonceRequest: typeof SetNonceRequest;
+type index$8_SetNonceRequestType = SetNonceRequestType;
+declare const index$8_SetNonceResponse: typeof SetNonceResponse;
+type index$8_SetNonceResponseType = SetNonceResponseType;
+declare const index$8_SetNonceResult: typeof SetNonceResult;
+declare const index$8_SetStorageAtParams: typeof SetStorageAtParams;
+declare const index$8_SetStorageAtRequest: typeof SetStorageAtRequest;
+type index$8_SetStorageAtRequestType = SetStorageAtRequestType;
+declare const index$8_SetStorageAtResponse: typeof SetStorageAtResponse;
+type index$8_SetStorageAtResponseType = SetStorageAtResponseType;
+declare const index$8_SetStorageAtResult: typeof SetStorageAtResult;
+declare const index$8_StopImpersonatingAccountParams: typeof StopImpersonatingAccountParams;
+declare const index$8_StopImpersonatingAccountRequest: typeof StopImpersonatingAccountRequest;
+type index$8_StopImpersonatingAccountRequestType = StopImpersonatingAccountRequestType;
+declare const index$8_StopImpersonatingAccountResponse: typeof StopImpersonatingAccountResponse;
+type index$8_StopImpersonatingAccountResponseType = StopImpersonatingAccountResponseType;
+declare const index$8_StopImpersonatingAccountResult: typeof StopImpersonatingAccountResult;
+declare namespace index$8 {
+  export { index$8_DropTransactionParams as DropTransactionParams, index$8_DropTransactionRequest as DropTransactionRequest, type index$8_DropTransactionRequestType as DropTransactionRequestType, index$8_DropTransactionResponse as DropTransactionResponse, type index$8_DropTransactionResponseType as DropTransactionResponseType, index$8_DropTransactionResult as DropTransactionResult, index$8_ForkConfigSchema as ForkConfigSchema, index$8_HardhatMethodRequest as HardhatMethodRequest, type index$8_HardhatMethodRequestType as HardhatMethodRequestType, index$8_ImpersonateAccountParams as ImpersonateAccountParams, index$8_ImpersonateAccountRequest as ImpersonateAccountRequest, type index$8_ImpersonateAccountRequestType as ImpersonateAccountRequestType, index$8_ImpersonateAccountResponse as ImpersonateAccountResponse, type index$8_ImpersonateAccountResponseType as ImpersonateAccountResponseType, index$8_ImpersonateAccountResult as ImpersonateAccountResult, index$8_MineParams as MineParams, index$8_MineRequest as MineRequest, type index$8_MineRequestType as MineRequestType, index$8_MineResponse as MineResponse, type index$8_MineResponseType as MineResponseType, index$8_MineResult as MineResult, index$8_ResetParams as ResetParams, index$8_ResetRequest as ResetRequest, type index$8_ResetRequestType as ResetRequestType, index$8_ResetResponse as ResetResponse, type index$8_ResetResponseType as ResetResponseType, index$8_ResetResult as ResetResult, index$8_SetBalanceParams as SetBalanceParams, index$8_SetBalanceRequest as SetBalanceRequest, type index$8_SetBalanceRequestType as SetBalanceRequestType, index$8_SetBalanceResponse as SetBalanceResponse, type index$8_SetBalanceResponseType as SetBalanceResponseType, index$8_SetBalanceResult as SetBalanceResult, index$8_SetCodeParams as SetCodeParams, index$8_SetCodeRequest as SetCodeRequest, type index$8_SetCodeRequestType as SetCodeRequestType, index$8_SetCodeResponse as SetCodeResponse, type index$8_SetCodeResponseType as SetCodeResponseType, index$8_SetCodeResult as SetCodeResult, index$8_SetNonceParams as SetNonceParams, index$8_SetNonceRequest as SetNonceRequest, type index$8_SetNonceRequestType as SetNonceRequestType, index$8_SetNonceResponse as SetNonceResponse, type index$8_SetNonceResponseType as SetNonceResponseType, index$8_SetNonceResult as SetNonceResult, index$8_SetStorageAtParams as SetStorageAtParams, index$8_SetStorageAtRequest as SetStorageAtRequest, type index$8_SetStorageAtRequestType as SetStorageAtRequestType, index$8_SetStorageAtResponse as SetStorageAtResponse, type index$8_SetStorageAtResponseType as SetStorageAtResponseType, index$8_SetStorageAtResult as SetStorageAtResult, index$8_StopImpersonatingAccountParams as StopImpersonatingAccountParams, index$8_StopImpersonatingAccountRequest as StopImpersonatingAccountRequest, type index$8_StopImpersonatingAccountRequestType as StopImpersonatingAccountRequestType, index$8_StopImpersonatingAccountResponse as StopImpersonatingAccountResponse, type index$8_StopImpersonatingAccountResponseType as StopImpersonatingAccountResponseType, index$8_StopImpersonatingAccountResult as StopImpersonatingAccountResult };
 }
 
 /**
@@ -8086,28 +8134,28 @@ declare const NetMethodRequest: S.Union<[S.Struct<{
 /** Type for NetMethodRequest union */
 type NetMethodRequestType = S.Schema.Type<typeof NetMethodRequest>;
 
-declare const index$8_ListeningParams: typeof ListeningParams;
-declare const index$8_ListeningRequest: typeof ListeningRequest;
-type index$8_ListeningRequestType = ListeningRequestType;
-declare const index$8_ListeningResponse: typeof ListeningResponse;
-type index$8_ListeningResponseType = ListeningResponseType;
-declare const index$8_ListeningResult: typeof ListeningResult;
-declare const index$8_NetMethodRequest: typeof NetMethodRequest;
-type index$8_NetMethodRequestType = NetMethodRequestType;
-declare const index$8_PeerCountParams: typeof PeerCountParams;
-declare const index$8_PeerCountRequest: typeof PeerCountRequest;
-type index$8_PeerCountRequestType = PeerCountRequestType;
-declare const index$8_PeerCountResponse: typeof PeerCountResponse;
-type index$8_PeerCountResponseType = PeerCountResponseType;
-declare const index$8_PeerCountResult: typeof PeerCountResult;
-declare const index$8_VersionParams: typeof VersionParams;
-declare const index$8_VersionRequest: typeof VersionRequest;
-type index$8_VersionRequestType = VersionRequestType;
-declare const index$8_VersionResponse: typeof VersionResponse;
-type index$8_VersionResponseType = VersionResponseType;
-declare const index$8_VersionResult: typeof VersionResult;
-declare namespace index$8 {
-  export { index$8_ListeningParams as ListeningParams, index$8_ListeningRequest as ListeningRequest, type index$8_ListeningRequestType as ListeningRequestType, index$8_ListeningResponse as ListeningResponse, type index$8_ListeningResponseType as ListeningResponseType, index$8_ListeningResult as ListeningResult, index$8_NetMethodRequest as NetMethodRequest, type index$8_NetMethodRequestType as NetMethodRequestType, index$8_PeerCountParams as PeerCountParams, index$8_PeerCountRequest as PeerCountRequest, type index$8_PeerCountRequestType as PeerCountRequestType, index$8_PeerCountResponse as PeerCountResponse, type index$8_PeerCountResponseType as PeerCountResponseType, index$8_PeerCountResult as PeerCountResult, index$8_VersionParams as VersionParams, index$8_VersionRequest as VersionRequest, type index$8_VersionRequestType as VersionRequestType, index$8_VersionResponse as VersionResponse, type index$8_VersionResponseType as VersionResponseType, index$8_VersionResult as VersionResult };
+declare const index$7_ListeningParams: typeof ListeningParams;
+declare const index$7_ListeningRequest: typeof ListeningRequest;
+type index$7_ListeningRequestType = ListeningRequestType;
+declare const index$7_ListeningResponse: typeof ListeningResponse;
+type index$7_ListeningResponseType = ListeningResponseType;
+declare const index$7_ListeningResult: typeof ListeningResult;
+declare const index$7_NetMethodRequest: typeof NetMethodRequest;
+type index$7_NetMethodRequestType = NetMethodRequestType;
+declare const index$7_PeerCountParams: typeof PeerCountParams;
+declare const index$7_PeerCountRequest: typeof PeerCountRequest;
+type index$7_PeerCountRequestType = PeerCountRequestType;
+declare const index$7_PeerCountResponse: typeof PeerCountResponse;
+type index$7_PeerCountResponseType = PeerCountResponseType;
+declare const index$7_PeerCountResult: typeof PeerCountResult;
+declare const index$7_VersionParams: typeof VersionParams;
+declare const index$7_VersionRequest: typeof VersionRequest;
+type index$7_VersionRequestType = VersionRequestType;
+declare const index$7_VersionResponse: typeof VersionResponse;
+type index$7_VersionResponseType = VersionResponseType;
+declare const index$7_VersionResult: typeof VersionResult;
+declare namespace index$7 {
+  export { index$7_ListeningParams as ListeningParams, index$7_ListeningRequest as ListeningRequest, type index$7_ListeningRequestType as ListeningRequestType, index$7_ListeningResponse as ListeningResponse, type index$7_ListeningResponseType as ListeningResponseType, index$7_ListeningResult as ListeningResult, index$7_NetMethodRequest as NetMethodRequest, type index$7_NetMethodRequestType as NetMethodRequestType, index$7_PeerCountParams as PeerCountParams, index$7_PeerCountRequest as PeerCountRequest, type index$7_PeerCountRequestType as PeerCountRequestType, index$7_PeerCountResponse as PeerCountResponse, type index$7_PeerCountResponseType as PeerCountResponseType, index$7_PeerCountResult as PeerCountResult, index$7_VersionParams as VersionParams, index$7_VersionRequest as VersionRequest, type index$7_VersionRequestType as VersionRequestType, index$7_VersionResponse as VersionResponse, type index$7_VersionResponseType as VersionResponseType, index$7_VersionResult as VersionResult };
 }
 
 /**
@@ -8448,29 +8496,29 @@ declare const TxpoolMethodRequest: S.Union<[S.Struct<{
 /** Type for TxpoolMethodRequest union */
 type TxpoolMethodRequestType = S.Schema.Type<typeof TxpoolMethodRequest>;
 
-declare const index$7_ContentParams: typeof ContentParams;
-type index$7_ContentRequestType = ContentRequestType;
-declare const index$7_ContentResponse: typeof ContentResponse;
-type index$7_ContentResponseType = ContentResponseType;
-declare const index$7_ContentResult: typeof ContentResult;
-declare const index$7_InspectParams: typeof InspectParams;
-type index$7_InspectRequestType = InspectRequestType;
-declare const index$7_InspectResponse: typeof InspectResponse;
-type index$7_InspectResponseType = InspectResponseType;
-declare const index$7_InspectResult: typeof InspectResult;
-declare const index$7_StatusParams: typeof StatusParams;
-type index$7_StatusRequestType = StatusRequestType;
-declare const index$7_StatusResponse: typeof StatusResponse;
-type index$7_StatusResponseType = StatusResponseType;
-declare const index$7_StatusResult: typeof StatusResult;
-declare const index$7_TransactionSummaryByAddressSchema: typeof TransactionSummaryByAddressSchema;
-declare const index$7_TransactionSummaryByNonceSchema: typeof TransactionSummaryByNonceSchema;
-declare const index$7_TransactionsByAddressSchema: typeof TransactionsByAddressSchema;
-declare const index$7_TransactionsByNonceSchema: typeof TransactionsByNonceSchema;
-declare const index$7_TxpoolMethodRequest: typeof TxpoolMethodRequest;
-type index$7_TxpoolMethodRequestType = TxpoolMethodRequestType;
-declare namespace index$7 {
-  export { index$7_ContentParams as ContentParams, ContentRequest$1 as ContentRequest, type index$7_ContentRequestType as ContentRequestType, index$7_ContentResponse as ContentResponse, type index$7_ContentResponseType as ContentResponseType, index$7_ContentResult as ContentResult, index$7_InspectParams as InspectParams, InspectRequest$1 as InspectRequest, type index$7_InspectRequestType as InspectRequestType, index$7_InspectResponse as InspectResponse, type index$7_InspectResponseType as InspectResponseType, index$7_InspectResult as InspectResult, index$7_StatusParams as StatusParams, StatusRequest$1 as StatusRequest, type index$7_StatusRequestType as StatusRequestType, index$7_StatusResponse as StatusResponse, type index$7_StatusResponseType as StatusResponseType, index$7_StatusResult as StatusResult, index$7_TransactionSummaryByAddressSchema as TransactionSummaryByAddressSchema, index$7_TransactionSummaryByNonceSchema as TransactionSummaryByNonceSchema, index$7_TransactionsByAddressSchema as TransactionsByAddressSchema, index$7_TransactionsByNonceSchema as TransactionsByNonceSchema, index$7_TxpoolMethodRequest as TxpoolMethodRequest, type index$7_TxpoolMethodRequestType as TxpoolMethodRequestType };
+declare const index$6_ContentParams: typeof ContentParams;
+type index$6_ContentRequestType = ContentRequestType;
+declare const index$6_ContentResponse: typeof ContentResponse;
+type index$6_ContentResponseType = ContentResponseType;
+declare const index$6_ContentResult: typeof ContentResult;
+declare const index$6_InspectParams: typeof InspectParams;
+type index$6_InspectRequestType = InspectRequestType;
+declare const index$6_InspectResponse: typeof InspectResponse;
+type index$6_InspectResponseType = InspectResponseType;
+declare const index$6_InspectResult: typeof InspectResult;
+declare const index$6_StatusParams: typeof StatusParams;
+type index$6_StatusRequestType = StatusRequestType;
+declare const index$6_StatusResponse: typeof StatusResponse;
+type index$6_StatusResponseType = StatusResponseType;
+declare const index$6_StatusResult: typeof StatusResult;
+declare const index$6_TransactionSummaryByAddressSchema: typeof TransactionSummaryByAddressSchema;
+declare const index$6_TransactionSummaryByNonceSchema: typeof TransactionSummaryByNonceSchema;
+declare const index$6_TransactionsByAddressSchema: typeof TransactionsByAddressSchema;
+declare const index$6_TransactionsByNonceSchema: typeof TransactionsByNonceSchema;
+declare const index$6_TxpoolMethodRequest: typeof TxpoolMethodRequest;
+type index$6_TxpoolMethodRequestType = TxpoolMethodRequestType;
+declare namespace index$6 {
+  export { index$6_ContentParams as ContentParams, ContentRequest$1 as ContentRequest, type index$6_ContentRequestType as ContentRequestType, index$6_ContentResponse as ContentResponse, type index$6_ContentResponseType as ContentResponseType, index$6_ContentResult as ContentResult, index$6_InspectParams as InspectParams, InspectRequest$1 as InspectRequest, type index$6_InspectRequestType as InspectRequestType, index$6_InspectResponse as InspectResponse, type index$6_InspectResponseType as InspectResponseType, index$6_InspectResult as InspectResult, index$6_StatusParams as StatusParams, StatusRequest$1 as StatusRequest, type index$6_StatusRequestType as StatusRequestType, index$6_StatusResponse as StatusResponse, type index$6_StatusResponseType as StatusResponseType, index$6_StatusResult as StatusResult, index$6_TransactionSummaryByAddressSchema as TransactionSummaryByAddressSchema, index$6_TransactionSummaryByNonceSchema as TransactionSummaryByNonceSchema, index$6_TransactionsByAddressSchema as TransactionsByAddressSchema, index$6_TransactionsByNonceSchema as TransactionsByNonceSchema, index$6_TxpoolMethodRequest as TxpoolMethodRequest, type index$6_TxpoolMethodRequestType as TxpoolMethodRequestType };
 }
 
 /**
@@ -9327,99 +9375,99 @@ declare const WalletMethodRequest: S.Union<[S.Struct<{
 /** Type for WalletMethodRequest union */
 type WalletMethodRequestType = S.Schema.Type<typeof WalletMethodRequest>;
 
-declare const index$6_AddEthereumChainParameter: typeof AddEthereumChainParameter;
-type index$6_AddEthereumChainParameterType = AddEthereumChainParameterType;
-declare const index$6_AddEthereumChainParams: typeof AddEthereumChainParams;
-type index$6_AddEthereumChainRequestType = AddEthereumChainRequestType;
-declare const index$6_AddEthereumChainResponse: typeof AddEthereumChainResponse;
-type index$6_AddEthereumChainResponseType = AddEthereumChainResponseType;
-declare const index$6_AddEthereumChainResult: typeof AddEthereumChainResult;
-declare const index$6_CallReceipt: typeof CallReceipt;
-type index$6_CallReceiptType = CallReceiptType;
-declare const index$6_CallsStatus: typeof CallsStatus;
-type index$6_CallsStatusType = CallsStatusType;
-declare const index$6_CapabilityValue: typeof CapabilityValue;
-declare const index$6_ChainCapabilities: typeof ChainCapabilities;
-type index$6_ChainCapabilitiesType = ChainCapabilitiesType;
-declare const index$6_GetCallsStatusParams: typeof GetCallsStatusParams;
-declare const index$6_GetCallsStatusRequest: typeof GetCallsStatusRequest;
-type index$6_GetCallsStatusRequestType = GetCallsStatusRequestType;
-declare const index$6_GetCallsStatusResponse: typeof GetCallsStatusResponse;
-type index$6_GetCallsStatusResponseType = GetCallsStatusResponseType;
-declare const index$6_GetCallsStatusResult: typeof GetCallsStatusResult;
-declare const index$6_GetCapabilitiesParams: typeof GetCapabilitiesParams;
-declare const index$6_GetCapabilitiesRequest: typeof GetCapabilitiesRequest;
-type index$6_GetCapabilitiesRequestType = GetCapabilitiesRequestType;
-declare const index$6_GetCapabilitiesResponse: typeof GetCapabilitiesResponse;
-type index$6_GetCapabilitiesResponseType = GetCapabilitiesResponseType;
-declare const index$6_GetCapabilitiesResult: typeof GetCapabilitiesResult;
-type index$6_GetCapabilitiesResultType = GetCapabilitiesResultType;
-declare const index$6_GetPermissionsParams: typeof GetPermissionsParams;
-type index$6_GetPermissionsRequestType = GetPermissionsRequestType;
-declare const index$6_GetPermissionsResponse: typeof GetPermissionsResponse;
-type index$6_GetPermissionsResponseType = GetPermissionsResponseType;
-declare const index$6_GetPermissionsResult: typeof GetPermissionsResult;
-declare const index$6_NativeCurrencySchema: typeof NativeCurrencySchema;
-declare const index$6_Permission: typeof Permission;
-declare const index$6_PermissionCaveat: typeof PermissionCaveat;
-type index$6_PermissionCaveatType = PermissionCaveatType;
-type index$6_PermissionType = PermissionType;
-declare const index$6_PermissionsToRevoke: typeof PermissionsToRevoke;
-type index$6_PermissionsToRevokeType = PermissionsToRevokeType;
-declare const index$6_RegisterOnboardingParams: typeof RegisterOnboardingParams;
-declare const index$6_RegisterOnboardingRequest: typeof RegisterOnboardingRequest;
-type index$6_RegisterOnboardingRequestType = RegisterOnboardingRequestType;
-declare const index$6_RegisterOnboardingResponse: typeof RegisterOnboardingResponse;
-type index$6_RegisterOnboardingResponseType = RegisterOnboardingResponseType;
-declare const index$6_RegisterOnboardingResult: typeof RegisterOnboardingResult;
-declare const index$6_RequestPermissionsParams: typeof RequestPermissionsParams;
-type index$6_RequestPermissionsRequestType = RequestPermissionsRequestType;
-declare const index$6_RequestPermissionsResponse: typeof RequestPermissionsResponse;
-type index$6_RequestPermissionsResponseType = RequestPermissionsResponseType;
-declare const index$6_RequestPermissionsResult: typeof RequestPermissionsResult;
-declare const index$6_RequestedPermissions: typeof RequestedPermissions;
-type index$6_RequestedPermissionsType = RequestedPermissionsType;
-declare const index$6_RevokePermissionsParams: typeof RevokePermissionsParams;
-type index$6_RevokePermissionsRequestType = RevokePermissionsRequestType;
-declare const index$6_RevokePermissionsResponse: typeof RevokePermissionsResponse;
-type index$6_RevokePermissionsResponseType = RevokePermissionsResponseType;
-declare const index$6_RevokePermissionsResult: typeof RevokePermissionsResult;
-declare const index$6_SendCallsParameter: typeof SendCallsParameter;
-type index$6_SendCallsParameterType = SendCallsParameterType;
-declare const index$6_SendCallsParams: typeof SendCallsParams;
-declare const index$6_SendCallsRequest: typeof SendCallsRequest;
-type index$6_SendCallsRequestType = SendCallsRequestType;
-declare const index$6_SendCallsResponse: typeof SendCallsResponse;
-type index$6_SendCallsResponseType = SendCallsResponseType;
-declare const index$6_SendCallsResult: typeof SendCallsResult;
-declare const index$6_ShowCallsStatusParams: typeof ShowCallsStatusParams;
-declare const index$6_ShowCallsStatusRequest: typeof ShowCallsStatusRequest;
-type index$6_ShowCallsStatusRequestType = ShowCallsStatusRequestType;
-declare const index$6_ShowCallsStatusResponse: typeof ShowCallsStatusResponse;
-type index$6_ShowCallsStatusResponseType = ShowCallsStatusResponseType;
-declare const index$6_ShowCallsStatusResult: typeof ShowCallsStatusResult;
-declare const index$6_SwitchEthereumChainParameter: typeof SwitchEthereumChainParameter;
-type index$6_SwitchEthereumChainParameterType = SwitchEthereumChainParameterType;
-declare const index$6_SwitchEthereumChainParams: typeof SwitchEthereumChainParams;
-type index$6_SwitchEthereumChainRequestType = SwitchEthereumChainRequestType;
-declare const index$6_SwitchEthereumChainResponse: typeof SwitchEthereumChainResponse;
-type index$6_SwitchEthereumChainResponseType = SwitchEthereumChainResponseType;
-declare const index$6_SwitchEthereumChainResult: typeof SwitchEthereumChainResult;
-declare const index$6_WalletCall: typeof WalletCall;
-type index$6_WalletCallType = WalletCallType;
-declare const index$6_WalletMethodRequest: typeof WalletMethodRequest;
-type index$6_WalletMethodRequestType = WalletMethodRequestType;
-declare const index$6_WatchAssetOptions: typeof WatchAssetOptions;
-type index$6_WatchAssetOptionsType = WatchAssetOptionsType;
-declare const index$6_WatchAssetParameter: typeof WatchAssetParameter;
-type index$6_WatchAssetParameterType = WatchAssetParameterType;
-declare const index$6_WatchAssetParams: typeof WatchAssetParams;
-type index$6_WatchAssetRequestType = WatchAssetRequestType;
-declare const index$6_WatchAssetResponse: typeof WatchAssetResponse;
-type index$6_WatchAssetResponseType = WatchAssetResponseType;
-declare const index$6_WatchAssetResult: typeof WatchAssetResult;
-declare namespace index$6 {
-  export { index$6_AddEthereumChainParameter as AddEthereumChainParameter, type index$6_AddEthereumChainParameterType as AddEthereumChainParameterType, index$6_AddEthereumChainParams as AddEthereumChainParams, AddEthereumChainRequest$1 as AddEthereumChainRequest, type index$6_AddEthereumChainRequestType as AddEthereumChainRequestType, index$6_AddEthereumChainResponse as AddEthereumChainResponse, type index$6_AddEthereumChainResponseType as AddEthereumChainResponseType, index$6_AddEthereumChainResult as AddEthereumChainResult, index$6_CallReceipt as CallReceipt, type index$6_CallReceiptType as CallReceiptType, index$6_CallsStatus as CallsStatus, type index$6_CallsStatusType as CallsStatusType, index$6_CapabilityValue as CapabilityValue, index$6_ChainCapabilities as ChainCapabilities, type index$6_ChainCapabilitiesType as ChainCapabilitiesType, index$6_GetCallsStatusParams as GetCallsStatusParams, index$6_GetCallsStatusRequest as GetCallsStatusRequest, type index$6_GetCallsStatusRequestType as GetCallsStatusRequestType, index$6_GetCallsStatusResponse as GetCallsStatusResponse, type index$6_GetCallsStatusResponseType as GetCallsStatusResponseType, index$6_GetCallsStatusResult as GetCallsStatusResult, index$6_GetCapabilitiesParams as GetCapabilitiesParams, index$6_GetCapabilitiesRequest as GetCapabilitiesRequest, type index$6_GetCapabilitiesRequestType as GetCapabilitiesRequestType, index$6_GetCapabilitiesResponse as GetCapabilitiesResponse, type index$6_GetCapabilitiesResponseType as GetCapabilitiesResponseType, index$6_GetCapabilitiesResult as GetCapabilitiesResult, type index$6_GetCapabilitiesResultType as GetCapabilitiesResultType, index$6_GetPermissionsParams as GetPermissionsParams, GetPermissionsRequest$1 as GetPermissionsRequest, type index$6_GetPermissionsRequestType as GetPermissionsRequestType, index$6_GetPermissionsResponse as GetPermissionsResponse, type index$6_GetPermissionsResponseType as GetPermissionsResponseType, index$6_GetPermissionsResult as GetPermissionsResult, index$6_NativeCurrencySchema as NativeCurrencySchema, index$6_Permission as Permission, index$6_PermissionCaveat as PermissionCaveat, type index$6_PermissionCaveatType as PermissionCaveatType, type index$6_PermissionType as PermissionType, index$6_PermissionsToRevoke as PermissionsToRevoke, type index$6_PermissionsToRevokeType as PermissionsToRevokeType, index$6_RegisterOnboardingParams as RegisterOnboardingParams, index$6_RegisterOnboardingRequest as RegisterOnboardingRequest, type index$6_RegisterOnboardingRequestType as RegisterOnboardingRequestType, index$6_RegisterOnboardingResponse as RegisterOnboardingResponse, type index$6_RegisterOnboardingResponseType as RegisterOnboardingResponseType, index$6_RegisterOnboardingResult as RegisterOnboardingResult, index$6_RequestPermissionsParams as RequestPermissionsParams, RequestPermissionsRequest$1 as RequestPermissionsRequest, type index$6_RequestPermissionsRequestType as RequestPermissionsRequestType, index$6_RequestPermissionsResponse as RequestPermissionsResponse, type index$6_RequestPermissionsResponseType as RequestPermissionsResponseType, index$6_RequestPermissionsResult as RequestPermissionsResult, index$6_RequestedPermissions as RequestedPermissions, type index$6_RequestedPermissionsType as RequestedPermissionsType, index$6_RevokePermissionsParams as RevokePermissionsParams, RevokePermissionsRequest$1 as RevokePermissionsRequest, type index$6_RevokePermissionsRequestType as RevokePermissionsRequestType, index$6_RevokePermissionsResponse as RevokePermissionsResponse, type index$6_RevokePermissionsResponseType as RevokePermissionsResponseType, index$6_RevokePermissionsResult as RevokePermissionsResult, index$6_SendCallsParameter as SendCallsParameter, type index$6_SendCallsParameterType as SendCallsParameterType, index$6_SendCallsParams as SendCallsParams, index$6_SendCallsRequest as SendCallsRequest, type index$6_SendCallsRequestType as SendCallsRequestType, index$6_SendCallsResponse as SendCallsResponse, type index$6_SendCallsResponseType as SendCallsResponseType, index$6_SendCallsResult as SendCallsResult, index$6_ShowCallsStatusParams as ShowCallsStatusParams, index$6_ShowCallsStatusRequest as ShowCallsStatusRequest, type index$6_ShowCallsStatusRequestType as ShowCallsStatusRequestType, index$6_ShowCallsStatusResponse as ShowCallsStatusResponse, type index$6_ShowCallsStatusResponseType as ShowCallsStatusResponseType, index$6_ShowCallsStatusResult as ShowCallsStatusResult, index$6_SwitchEthereumChainParameter as SwitchEthereumChainParameter, type index$6_SwitchEthereumChainParameterType as SwitchEthereumChainParameterType, index$6_SwitchEthereumChainParams as SwitchEthereumChainParams, SwitchEthereumChainRequest$1 as SwitchEthereumChainRequest, type index$6_SwitchEthereumChainRequestType as SwitchEthereumChainRequestType, index$6_SwitchEthereumChainResponse as SwitchEthereumChainResponse, type index$6_SwitchEthereumChainResponseType as SwitchEthereumChainResponseType, index$6_SwitchEthereumChainResult as SwitchEthereumChainResult, index$6_WalletCall as WalletCall, type index$6_WalletCallType as WalletCallType, index$6_WalletMethodRequest as WalletMethodRequest, type index$6_WalletMethodRequestType as WalletMethodRequestType, index$6_WatchAssetOptions as WatchAssetOptions, type index$6_WatchAssetOptionsType as WatchAssetOptionsType, index$6_WatchAssetParameter as WatchAssetParameter, type index$6_WatchAssetParameterType as WatchAssetParameterType, index$6_WatchAssetParams as WatchAssetParams, WatchAssetRequest$1 as WatchAssetRequest, type index$6_WatchAssetRequestType as WatchAssetRequestType, index$6_WatchAssetResponse as WatchAssetResponse, type index$6_WatchAssetResponseType as WatchAssetResponseType, index$6_WatchAssetResult as WatchAssetResult };
+declare const index$5_AddEthereumChainParameter: typeof AddEthereumChainParameter;
+type index$5_AddEthereumChainParameterType = AddEthereumChainParameterType;
+declare const index$5_AddEthereumChainParams: typeof AddEthereumChainParams;
+type index$5_AddEthereumChainRequestType = AddEthereumChainRequestType;
+declare const index$5_AddEthereumChainResponse: typeof AddEthereumChainResponse;
+type index$5_AddEthereumChainResponseType = AddEthereumChainResponseType;
+declare const index$5_AddEthereumChainResult: typeof AddEthereumChainResult;
+declare const index$5_CallReceipt: typeof CallReceipt;
+type index$5_CallReceiptType = CallReceiptType;
+declare const index$5_CallsStatus: typeof CallsStatus;
+type index$5_CallsStatusType = CallsStatusType;
+declare const index$5_CapabilityValue: typeof CapabilityValue;
+declare const index$5_ChainCapabilities: typeof ChainCapabilities;
+type index$5_ChainCapabilitiesType = ChainCapabilitiesType;
+declare const index$5_GetCallsStatusParams: typeof GetCallsStatusParams;
+declare const index$5_GetCallsStatusRequest: typeof GetCallsStatusRequest;
+type index$5_GetCallsStatusRequestType = GetCallsStatusRequestType;
+declare const index$5_GetCallsStatusResponse: typeof GetCallsStatusResponse;
+type index$5_GetCallsStatusResponseType = GetCallsStatusResponseType;
+declare const index$5_GetCallsStatusResult: typeof GetCallsStatusResult;
+declare const index$5_GetCapabilitiesParams: typeof GetCapabilitiesParams;
+declare const index$5_GetCapabilitiesRequest: typeof GetCapabilitiesRequest;
+type index$5_GetCapabilitiesRequestType = GetCapabilitiesRequestType;
+declare const index$5_GetCapabilitiesResponse: typeof GetCapabilitiesResponse;
+type index$5_GetCapabilitiesResponseType = GetCapabilitiesResponseType;
+declare const index$5_GetCapabilitiesResult: typeof GetCapabilitiesResult;
+type index$5_GetCapabilitiesResultType = GetCapabilitiesResultType;
+declare const index$5_GetPermissionsParams: typeof GetPermissionsParams;
+type index$5_GetPermissionsRequestType = GetPermissionsRequestType;
+declare const index$5_GetPermissionsResponse: typeof GetPermissionsResponse;
+type index$5_GetPermissionsResponseType = GetPermissionsResponseType;
+declare const index$5_GetPermissionsResult: typeof GetPermissionsResult;
+declare const index$5_NativeCurrencySchema: typeof NativeCurrencySchema;
+declare const index$5_Permission: typeof Permission;
+declare const index$5_PermissionCaveat: typeof PermissionCaveat;
+type index$5_PermissionCaveatType = PermissionCaveatType;
+type index$5_PermissionType = PermissionType;
+declare const index$5_PermissionsToRevoke: typeof PermissionsToRevoke;
+type index$5_PermissionsToRevokeType = PermissionsToRevokeType;
+declare const index$5_RegisterOnboardingParams: typeof RegisterOnboardingParams;
+declare const index$5_RegisterOnboardingRequest: typeof RegisterOnboardingRequest;
+type index$5_RegisterOnboardingRequestType = RegisterOnboardingRequestType;
+declare const index$5_RegisterOnboardingResponse: typeof RegisterOnboardingResponse;
+type index$5_RegisterOnboardingResponseType = RegisterOnboardingResponseType;
+declare const index$5_RegisterOnboardingResult: typeof RegisterOnboardingResult;
+declare const index$5_RequestPermissionsParams: typeof RequestPermissionsParams;
+type index$5_RequestPermissionsRequestType = RequestPermissionsRequestType;
+declare const index$5_RequestPermissionsResponse: typeof RequestPermissionsResponse;
+type index$5_RequestPermissionsResponseType = RequestPermissionsResponseType;
+declare const index$5_RequestPermissionsResult: typeof RequestPermissionsResult;
+declare const index$5_RequestedPermissions: typeof RequestedPermissions;
+type index$5_RequestedPermissionsType = RequestedPermissionsType;
+declare const index$5_RevokePermissionsParams: typeof RevokePermissionsParams;
+type index$5_RevokePermissionsRequestType = RevokePermissionsRequestType;
+declare const index$5_RevokePermissionsResponse: typeof RevokePermissionsResponse;
+type index$5_RevokePermissionsResponseType = RevokePermissionsResponseType;
+declare const index$5_RevokePermissionsResult: typeof RevokePermissionsResult;
+declare const index$5_SendCallsParameter: typeof SendCallsParameter;
+type index$5_SendCallsParameterType = SendCallsParameterType;
+declare const index$5_SendCallsParams: typeof SendCallsParams;
+declare const index$5_SendCallsRequest: typeof SendCallsRequest;
+type index$5_SendCallsRequestType = SendCallsRequestType;
+declare const index$5_SendCallsResponse: typeof SendCallsResponse;
+type index$5_SendCallsResponseType = SendCallsResponseType;
+declare const index$5_SendCallsResult: typeof SendCallsResult;
+declare const index$5_ShowCallsStatusParams: typeof ShowCallsStatusParams;
+declare const index$5_ShowCallsStatusRequest: typeof ShowCallsStatusRequest;
+type index$5_ShowCallsStatusRequestType = ShowCallsStatusRequestType;
+declare const index$5_ShowCallsStatusResponse: typeof ShowCallsStatusResponse;
+type index$5_ShowCallsStatusResponseType = ShowCallsStatusResponseType;
+declare const index$5_ShowCallsStatusResult: typeof ShowCallsStatusResult;
+declare const index$5_SwitchEthereumChainParameter: typeof SwitchEthereumChainParameter;
+type index$5_SwitchEthereumChainParameterType = SwitchEthereumChainParameterType;
+declare const index$5_SwitchEthereumChainParams: typeof SwitchEthereumChainParams;
+type index$5_SwitchEthereumChainRequestType = SwitchEthereumChainRequestType;
+declare const index$5_SwitchEthereumChainResponse: typeof SwitchEthereumChainResponse;
+type index$5_SwitchEthereumChainResponseType = SwitchEthereumChainResponseType;
+declare const index$5_SwitchEthereumChainResult: typeof SwitchEthereumChainResult;
+declare const index$5_WalletCall: typeof WalletCall;
+type index$5_WalletCallType = WalletCallType;
+declare const index$5_WalletMethodRequest: typeof WalletMethodRequest;
+type index$5_WalletMethodRequestType = WalletMethodRequestType;
+declare const index$5_WatchAssetOptions: typeof WatchAssetOptions;
+type index$5_WatchAssetOptionsType = WatchAssetOptionsType;
+declare const index$5_WatchAssetParameter: typeof WatchAssetParameter;
+type index$5_WatchAssetParameterType = WatchAssetParameterType;
+declare const index$5_WatchAssetParams: typeof WatchAssetParams;
+type index$5_WatchAssetRequestType = WatchAssetRequestType;
+declare const index$5_WatchAssetResponse: typeof WatchAssetResponse;
+type index$5_WatchAssetResponseType = WatchAssetResponseType;
+declare const index$5_WatchAssetResult: typeof WatchAssetResult;
+declare namespace index$5 {
+  export { index$5_AddEthereumChainParameter as AddEthereumChainParameter, type index$5_AddEthereumChainParameterType as AddEthereumChainParameterType, index$5_AddEthereumChainParams as AddEthereumChainParams, AddEthereumChainRequest$1 as AddEthereumChainRequest, type index$5_AddEthereumChainRequestType as AddEthereumChainRequestType, index$5_AddEthereumChainResponse as AddEthereumChainResponse, type index$5_AddEthereumChainResponseType as AddEthereumChainResponseType, index$5_AddEthereumChainResult as AddEthereumChainResult, index$5_CallReceipt as CallReceipt, type index$5_CallReceiptType as CallReceiptType, index$5_CallsStatus as CallsStatus, type index$5_CallsStatusType as CallsStatusType, index$5_CapabilityValue as CapabilityValue, index$5_ChainCapabilities as ChainCapabilities, type index$5_ChainCapabilitiesType as ChainCapabilitiesType, index$5_GetCallsStatusParams as GetCallsStatusParams, index$5_GetCallsStatusRequest as GetCallsStatusRequest, type index$5_GetCallsStatusRequestType as GetCallsStatusRequestType, index$5_GetCallsStatusResponse as GetCallsStatusResponse, type index$5_GetCallsStatusResponseType as GetCallsStatusResponseType, index$5_GetCallsStatusResult as GetCallsStatusResult, index$5_GetCapabilitiesParams as GetCapabilitiesParams, index$5_GetCapabilitiesRequest as GetCapabilitiesRequest, type index$5_GetCapabilitiesRequestType as GetCapabilitiesRequestType, index$5_GetCapabilitiesResponse as GetCapabilitiesResponse, type index$5_GetCapabilitiesResponseType as GetCapabilitiesResponseType, index$5_GetCapabilitiesResult as GetCapabilitiesResult, type index$5_GetCapabilitiesResultType as GetCapabilitiesResultType, index$5_GetPermissionsParams as GetPermissionsParams, GetPermissionsRequest$1 as GetPermissionsRequest, type index$5_GetPermissionsRequestType as GetPermissionsRequestType, index$5_GetPermissionsResponse as GetPermissionsResponse, type index$5_GetPermissionsResponseType as GetPermissionsResponseType, index$5_GetPermissionsResult as GetPermissionsResult, index$5_NativeCurrencySchema as NativeCurrencySchema, index$5_Permission as Permission, index$5_PermissionCaveat as PermissionCaveat, type index$5_PermissionCaveatType as PermissionCaveatType, type index$5_PermissionType as PermissionType, index$5_PermissionsToRevoke as PermissionsToRevoke, type index$5_PermissionsToRevokeType as PermissionsToRevokeType, index$5_RegisterOnboardingParams as RegisterOnboardingParams, index$5_RegisterOnboardingRequest as RegisterOnboardingRequest, type index$5_RegisterOnboardingRequestType as RegisterOnboardingRequestType, index$5_RegisterOnboardingResponse as RegisterOnboardingResponse, type index$5_RegisterOnboardingResponseType as RegisterOnboardingResponseType, index$5_RegisterOnboardingResult as RegisterOnboardingResult, index$5_RequestPermissionsParams as RequestPermissionsParams, RequestPermissionsRequest$1 as RequestPermissionsRequest, type index$5_RequestPermissionsRequestType as RequestPermissionsRequestType, index$5_RequestPermissionsResponse as RequestPermissionsResponse, type index$5_RequestPermissionsResponseType as RequestPermissionsResponseType, index$5_RequestPermissionsResult as RequestPermissionsResult, index$5_RequestedPermissions as RequestedPermissions, type index$5_RequestedPermissionsType as RequestedPermissionsType, index$5_RevokePermissionsParams as RevokePermissionsParams, RevokePermissionsRequest$1 as RevokePermissionsRequest, type index$5_RevokePermissionsRequestType as RevokePermissionsRequestType, index$5_RevokePermissionsResponse as RevokePermissionsResponse, type index$5_RevokePermissionsResponseType as RevokePermissionsResponseType, index$5_RevokePermissionsResult as RevokePermissionsResult, index$5_SendCallsParameter as SendCallsParameter, type index$5_SendCallsParameterType as SendCallsParameterType, index$5_SendCallsParams as SendCallsParams, index$5_SendCallsRequest as SendCallsRequest, type index$5_SendCallsRequestType as SendCallsRequestType, index$5_SendCallsResponse as SendCallsResponse, type index$5_SendCallsResponseType as SendCallsResponseType, index$5_SendCallsResult as SendCallsResult, index$5_ShowCallsStatusParams as ShowCallsStatusParams, index$5_ShowCallsStatusRequest as ShowCallsStatusRequest, type index$5_ShowCallsStatusRequestType as ShowCallsStatusRequestType, index$5_ShowCallsStatusResponse as ShowCallsStatusResponse, type index$5_ShowCallsStatusResponseType as ShowCallsStatusResponseType, index$5_ShowCallsStatusResult as ShowCallsStatusResult, index$5_SwitchEthereumChainParameter as SwitchEthereumChainParameter, type index$5_SwitchEthereumChainParameterType as SwitchEthereumChainParameterType, index$5_SwitchEthereumChainParams as SwitchEthereumChainParams, SwitchEthereumChainRequest$1 as SwitchEthereumChainRequest, type index$5_SwitchEthereumChainRequestType as SwitchEthereumChainRequestType, index$5_SwitchEthereumChainResponse as SwitchEthereumChainResponse, type index$5_SwitchEthereumChainResponseType as SwitchEthereumChainResponseType, index$5_SwitchEthereumChainResult as SwitchEthereumChainResult, index$5_WalletCall as WalletCall, type index$5_WalletCallType as WalletCallType, index$5_WalletMethodRequest as WalletMethodRequest, type index$5_WalletMethodRequestType as WalletMethodRequestType, index$5_WatchAssetOptions as WatchAssetOptions, type index$5_WatchAssetOptionsType as WatchAssetOptionsType, index$5_WatchAssetParameter as WatchAssetParameter, type index$5_WatchAssetParameterType as WatchAssetParameterType, index$5_WatchAssetParams as WatchAssetParams, WatchAssetRequest$1 as WatchAssetRequest, type index$5_WatchAssetRequestType as WatchAssetRequestType, index$5_WatchAssetResponse as WatchAssetResponse, type index$5_WatchAssetResponseType as WatchAssetResponseType, index$5_WatchAssetResult as WatchAssetResult };
 }
 
 /**
@@ -9522,20 +9570,20 @@ declare const Web3MethodRequest: S.Union<[S.Struct<{
 /** Type for Web3MethodRequest union */
 type Web3MethodRequestType = S.Schema.Type<typeof Web3MethodRequest>;
 
-declare const index$5_ClientVersionParams: typeof ClientVersionParams;
-type index$5_ClientVersionRequestType = ClientVersionRequestType;
-declare const index$5_ClientVersionResponse: typeof ClientVersionResponse;
-type index$5_ClientVersionResponseType = ClientVersionResponseType;
-declare const index$5_ClientVersionResult: typeof ClientVersionResult;
-declare const index$5_Sha3Params: typeof Sha3Params;
-type index$5_Sha3RequestType = Sha3RequestType;
-declare const index$5_Sha3Response: typeof Sha3Response;
-type index$5_Sha3ResponseType = Sha3ResponseType;
-declare const index$5_Sha3Result: typeof Sha3Result;
-declare const index$5_Web3MethodRequest: typeof Web3MethodRequest;
-type index$5_Web3MethodRequestType = Web3MethodRequestType;
-declare namespace index$5 {
-  export { index$5_ClientVersionParams as ClientVersionParams, ClientVersionRequest$1 as ClientVersionRequest, type index$5_ClientVersionRequestType as ClientVersionRequestType, index$5_ClientVersionResponse as ClientVersionResponse, type index$5_ClientVersionResponseType as ClientVersionResponseType, index$5_ClientVersionResult as ClientVersionResult, index$5_Sha3Params as Sha3Params, Sha3Request$1 as Sha3Request, type index$5_Sha3RequestType as Sha3RequestType, index$5_Sha3Response as Sha3Response, type index$5_Sha3ResponseType as Sha3ResponseType, index$5_Sha3Result as Sha3Result, index$5_Web3MethodRequest as Web3MethodRequest, type index$5_Web3MethodRequestType as Web3MethodRequestType };
+declare const index$4_ClientVersionParams: typeof ClientVersionParams;
+type index$4_ClientVersionRequestType = ClientVersionRequestType;
+declare const index$4_ClientVersionResponse: typeof ClientVersionResponse;
+type index$4_ClientVersionResponseType = ClientVersionResponseType;
+declare const index$4_ClientVersionResult: typeof ClientVersionResult;
+declare const index$4_Sha3Params: typeof Sha3Params;
+type index$4_Sha3RequestType = Sha3RequestType;
+declare const index$4_Sha3Response: typeof Sha3Response;
+type index$4_Sha3ResponseType = Sha3ResponseType;
+declare const index$4_Sha3Result: typeof Sha3Result;
+declare const index$4_Web3MethodRequest: typeof Web3MethodRequest;
+type index$4_Web3MethodRequestType = Web3MethodRequestType;
+declare namespace index$4 {
+  export { index$4_ClientVersionParams as ClientVersionParams, ClientVersionRequest$1 as ClientVersionRequest, type index$4_ClientVersionRequestType as ClientVersionRequestType, index$4_ClientVersionResponse as ClientVersionResponse, type index$4_ClientVersionResponseType as ClientVersionResponseType, index$4_ClientVersionResult as ClientVersionResult, index$4_Sha3Params as Sha3Params, Sha3Request$1 as Sha3Request, type index$4_Sha3RequestType as Sha3RequestType, index$4_Sha3Response as Sha3Response, type index$4_Sha3ResponseType as Sha3ResponseType, index$4_Sha3Result as Sha3Result, index$4_Web3MethodRequest as Web3MethodRequest, type index$4_Web3MethodRequestType as Web3MethodRequestType };
 }
 
 /**
@@ -11286,82 +11334,82 @@ declare const isErrorResponse: (response: GenericJsonRpcResponseType) => respons
  */
 declare const isSuccessResponse: (response: GenericJsonRpcResponseType) => response is S.Schema.Type<typeof GenericJsonRpcSuccessResponse>;
 
-declare const index$4_AccessListItemRpcSchema: typeof AccessListItemRpcSchema;
-type index$4_AccessListResultRpc = AccessListResultRpc;
-declare const index$4_AccessListResultRpcSchema: typeof AccessListResultRpcSchema;
-type index$4_AccountProofRpc = AccountProofRpc;
-declare const index$4_AccountProofRpcSchema: typeof AccountProofRpcSchema;
-declare const index$4_AccountStateOverrideSchema: typeof AccountStateOverrideSchema;
-type index$4_AddressHex = AddressHex;
-declare const index$4_AddressHexSchema: typeof AddressHexSchema;
-type index$4_BlockOverride = BlockOverride;
-declare const index$4_BlockOverrideSchema: typeof BlockOverrideSchema;
-type index$4_BlockRpc = BlockRpc;
-declare const index$4_BlockRpcSchema: typeof BlockRpcSchema;
-type index$4_BlockTag = BlockTag;
-declare const index$4_BlockTagSchema: typeof BlockTagSchema;
-type index$4_Bytes32Hex = Bytes32Hex;
-declare const index$4_Bytes32HexSchema: typeof Bytes32HexSchema;
-type index$4_FeeHistoryRpc = FeeHistoryRpc;
-declare const index$4_FeeHistoryRpcSchema: typeof FeeHistoryRpcSchema;
-declare const index$4_GenericJsonRpcRequest: typeof GenericJsonRpcRequest;
-type index$4_GenericJsonRpcRequestType = GenericJsonRpcRequestType;
-declare const index$4_GenericJsonRpcResponse: typeof GenericJsonRpcResponse;
-type index$4_GenericJsonRpcResponseType = GenericJsonRpcResponseType;
-declare const index$4_GenericJsonRpcSuccessResponse: typeof GenericJsonRpcSuccessResponse;
-type index$4_Hex = Hex;
-declare const index$4_HexSchema: typeof HexSchema;
-declare const index$4_JsonRpcBatchRequest: typeof JsonRpcBatchRequest;
-type index$4_JsonRpcBatchRequestType = JsonRpcBatchRequestType;
-declare const index$4_JsonRpcBatchResponse: typeof JsonRpcBatchResponse;
-type index$4_JsonRpcBatchResponseType = JsonRpcBatchResponseType;
-declare const index$4_JsonRpcErrorResponseSchema: typeof JsonRpcErrorResponseSchema;
-type index$4_JsonRpcErrorResponseType = JsonRpcErrorResponseType;
-declare const index$4_JsonRpcErrorSchema: typeof JsonRpcErrorSchema;
-type index$4_JsonRpcErrorType = JsonRpcErrorType;
-type index$4_JsonRpcId = JsonRpcId;
-declare const index$4_JsonRpcIdSchema: typeof JsonRpcIdSchema;
-declare const index$4_JsonRpcMethodRequest: typeof JsonRpcMethodRequest;
-type index$4_JsonRpcMethodRequestType = JsonRpcMethodRequestType;
-declare const index$4_JsonRpcVersionSchema: typeof JsonRpcVersionSchema;
-type index$4_LogFilter = LogFilter;
-declare const index$4_LogFilterSchema: typeof LogFilterSchema;
-type index$4_LogRpc = LogRpc;
-declare const index$4_LogRpcSchema: typeof LogRpcSchema;
-type index$4_MethodResult<M extends keyof typeof methodResultSchemas> = MethodResult<M>;
-type index$4_QuantityHex = QuantityHex;
-declare const index$4_QuantityHexSchema: typeof QuantityHexSchema;
-type index$4_ReceiptRpc = ReceiptRpc;
-declare const index$4_ReceiptRpcSchema: typeof ReceiptRpcSchema;
-type index$4_StateOverrideSet = StateOverrideSet;
-declare const index$4_StateOverrideSetSchema: typeof StateOverrideSetSchema;
-type index$4_SyncStatusRpc = SyncStatusRpc;
-declare const index$4_SyncStatusRpcSchema: typeof SyncStatusRpcSchema;
-declare const index$4_TopicFilterValueSchema: typeof TopicFilterValueSchema;
-type index$4_TransactionRequest = TransactionRequest;
-declare const index$4_TransactionRequestSchema: typeof TransactionRequestSchema;
-type index$4_TransactionRpc = TransactionRpc;
-declare const index$4_TransactionRpcSchema: typeof TransactionRpcSchema;
-type index$4_WithdrawalRpc = WithdrawalRpc;
-declare const index$4_WithdrawalRpcSchema: typeof WithdrawalRpcSchema;
-declare const index$4_decodeRequest: typeof decodeRequest;
-declare const index$4_decodeResponse: typeof decodeResponse;
-declare const index$4_isErrorResponse: typeof isErrorResponse;
-declare const index$4_isSuccessResponse: typeof isSuccessResponse;
-declare const index$4_isValidRequest: typeof isValidRequest;
-declare const index$4_isValidResponse: typeof isValidResponse;
-declare const index$4_methodResultSchemas: typeof methodResultSchemas;
-declare namespace index$4 {
-  export { index$4_AccessListItemRpcSchema as AccessListItemRpcSchema, type index$4_AccessListResultRpc as AccessListResultRpc, index$4_AccessListResultRpcSchema as AccessListResultRpcSchema, type index$4_AccountProofRpc as AccountProofRpc, index$4_AccountProofRpcSchema as AccountProofRpcSchema, index$4_AccountStateOverrideSchema as AccountStateOverrideSchema, type index$4_AddressHex as AddressHex, index$4_AddressHexSchema as AddressHexSchema, index$b as Anvil, type index$4_BlockOverride as BlockOverride, index$4_BlockOverrideSchema as BlockOverrideSchema, type index$4_BlockRpc as BlockRpc, index$4_BlockRpcSchema as BlockRpcSchema, type index$4_BlockTag as BlockTag, index$4_BlockTagSchema as BlockTagSchema, type index$4_Bytes32Hex as Bytes32Hex, index$4_Bytes32HexSchema as Bytes32HexSchema, index$a as Eth, type index$4_FeeHistoryRpc as FeeHistoryRpc, index$4_FeeHistoryRpcSchema as FeeHistoryRpcSchema, index$4_GenericJsonRpcRequest as GenericJsonRpcRequest, type index$4_GenericJsonRpcRequestType as GenericJsonRpcRequestType, index$4_GenericJsonRpcResponse as GenericJsonRpcResponse, type index$4_GenericJsonRpcResponseType as GenericJsonRpcResponseType, index$4_GenericJsonRpcSuccessResponse as GenericJsonRpcSuccessResponse, index$9 as Hardhat, type index$4_Hex as Hex, index$4_HexSchema as HexSchema, index$4_JsonRpcBatchRequest as JsonRpcBatchRequest, type index$4_JsonRpcBatchRequestType as JsonRpcBatchRequestType, index$4_JsonRpcBatchResponse as JsonRpcBatchResponse, type index$4_JsonRpcBatchResponseType as JsonRpcBatchResponseType, index$4_JsonRpcErrorResponseSchema as JsonRpcErrorResponseSchema, type index$4_JsonRpcErrorResponseType as JsonRpcErrorResponseType, index$4_JsonRpcErrorSchema as JsonRpcErrorSchema, type index$4_JsonRpcErrorType as JsonRpcErrorType, type index$4_JsonRpcId as JsonRpcId, index$4_JsonRpcIdSchema as JsonRpcIdSchema, index$4_JsonRpcMethodRequest as JsonRpcMethodRequest, type index$4_JsonRpcMethodRequestType as JsonRpcMethodRequestType, index$4_JsonRpcVersionSchema as JsonRpcVersionSchema, type index$4_LogFilter as LogFilter, index$4_LogFilterSchema as LogFilterSchema, type index$4_LogRpc as LogRpc, index$4_LogRpcSchema as LogRpcSchema, type index$4_MethodResult as MethodResult, index$8 as Net, type index$4_QuantityHex as QuantityHex, index$4_QuantityHexSchema as QuantityHexSchema, type index$4_ReceiptRpc as ReceiptRpc, index$4_ReceiptRpcSchema as ReceiptRpcSchema, type index$4_StateOverrideSet as StateOverrideSet, index$4_StateOverrideSetSchema as StateOverrideSetSchema, type index$4_SyncStatusRpc as SyncStatusRpc, index$4_SyncStatusRpcSchema as SyncStatusRpcSchema, index$4_TopicFilterValueSchema as TopicFilterValueSchema, type index$4_TransactionRequest as TransactionRequest, index$4_TransactionRequestSchema as TransactionRequestSchema, type index$4_TransactionRpc as TransactionRpc, index$4_TransactionRpcSchema as TransactionRpcSchema, index$7 as Txpool, index$6 as Wallet, index$5 as Web3, type index$4_WithdrawalRpc as WithdrawalRpc, index$4_WithdrawalRpcSchema as WithdrawalRpcSchema, index$4_decodeRequest as decodeRequest, index$4_decodeResponse as decodeResponse, index$4_isErrorResponse as isErrorResponse, index$4_isSuccessResponse as isSuccessResponse, index$4_isValidRequest as isValidRequest, index$4_isValidResponse as isValidResponse, index$4_methodResultSchemas as methodResultSchemas };
+declare const index$3_AccessListItemRpcSchema: typeof AccessListItemRpcSchema;
+type index$3_AccessListResultRpc = AccessListResultRpc;
+declare const index$3_AccessListResultRpcSchema: typeof AccessListResultRpcSchema;
+type index$3_AccountProofRpc = AccountProofRpc;
+declare const index$3_AccountProofRpcSchema: typeof AccountProofRpcSchema;
+declare const index$3_AccountStateOverrideSchema: typeof AccountStateOverrideSchema;
+type index$3_AddressHex = AddressHex;
+declare const index$3_AddressHexSchema: typeof AddressHexSchema;
+type index$3_BlockOverride = BlockOverride;
+declare const index$3_BlockOverrideSchema: typeof BlockOverrideSchema;
+type index$3_BlockRpc = BlockRpc;
+declare const index$3_BlockRpcSchema: typeof BlockRpcSchema;
+type index$3_BlockTag = BlockTag;
+declare const index$3_BlockTagSchema: typeof BlockTagSchema;
+type index$3_Bytes32Hex = Bytes32Hex;
+declare const index$3_Bytes32HexSchema: typeof Bytes32HexSchema;
+type index$3_FeeHistoryRpc = FeeHistoryRpc;
+declare const index$3_FeeHistoryRpcSchema: typeof FeeHistoryRpcSchema;
+declare const index$3_GenericJsonRpcRequest: typeof GenericJsonRpcRequest;
+type index$3_GenericJsonRpcRequestType = GenericJsonRpcRequestType;
+declare const index$3_GenericJsonRpcResponse: typeof GenericJsonRpcResponse;
+type index$3_GenericJsonRpcResponseType = GenericJsonRpcResponseType;
+declare const index$3_GenericJsonRpcSuccessResponse: typeof GenericJsonRpcSuccessResponse;
+type index$3_Hex = Hex;
+declare const index$3_HexSchema: typeof HexSchema;
+declare const index$3_JsonRpcBatchRequest: typeof JsonRpcBatchRequest;
+type index$3_JsonRpcBatchRequestType = JsonRpcBatchRequestType;
+declare const index$3_JsonRpcBatchResponse: typeof JsonRpcBatchResponse;
+type index$3_JsonRpcBatchResponseType = JsonRpcBatchResponseType;
+declare const index$3_JsonRpcErrorResponseSchema: typeof JsonRpcErrorResponseSchema;
+type index$3_JsonRpcErrorResponseType = JsonRpcErrorResponseType;
+declare const index$3_JsonRpcErrorSchema: typeof JsonRpcErrorSchema;
+type index$3_JsonRpcErrorType = JsonRpcErrorType;
+type index$3_JsonRpcId = JsonRpcId;
+declare const index$3_JsonRpcIdSchema: typeof JsonRpcIdSchema;
+declare const index$3_JsonRpcMethodRequest: typeof JsonRpcMethodRequest;
+type index$3_JsonRpcMethodRequestType = JsonRpcMethodRequestType;
+declare const index$3_JsonRpcVersionSchema: typeof JsonRpcVersionSchema;
+type index$3_LogFilter = LogFilter;
+declare const index$3_LogFilterSchema: typeof LogFilterSchema;
+type index$3_LogRpc = LogRpc;
+declare const index$3_LogRpcSchema: typeof LogRpcSchema;
+type index$3_MethodResult<M extends keyof typeof methodResultSchemas> = MethodResult<M>;
+type index$3_QuantityHex = QuantityHex;
+declare const index$3_QuantityHexSchema: typeof QuantityHexSchema;
+type index$3_ReceiptRpc = ReceiptRpc;
+declare const index$3_ReceiptRpcSchema: typeof ReceiptRpcSchema;
+type index$3_StateOverrideSet = StateOverrideSet;
+declare const index$3_StateOverrideSetSchema: typeof StateOverrideSetSchema;
+type index$3_SyncStatusRpc = SyncStatusRpc;
+declare const index$3_SyncStatusRpcSchema: typeof SyncStatusRpcSchema;
+declare const index$3_TopicFilterValueSchema: typeof TopicFilterValueSchema;
+type index$3_TransactionRequest = TransactionRequest;
+declare const index$3_TransactionRequestSchema: typeof TransactionRequestSchema;
+type index$3_TransactionRpc = TransactionRpc;
+declare const index$3_TransactionRpcSchema: typeof TransactionRpcSchema;
+type index$3_WithdrawalRpc = WithdrawalRpc;
+declare const index$3_WithdrawalRpcSchema: typeof WithdrawalRpcSchema;
+declare const index$3_decodeRequest: typeof decodeRequest;
+declare const index$3_decodeResponse: typeof decodeResponse;
+declare const index$3_isErrorResponse: typeof isErrorResponse;
+declare const index$3_isSuccessResponse: typeof isSuccessResponse;
+declare const index$3_isValidRequest: typeof isValidRequest;
+declare const index$3_isValidResponse: typeof isValidResponse;
+declare const index$3_methodResultSchemas: typeof methodResultSchemas;
+declare namespace index$3 {
+  export { index$3_AccessListItemRpcSchema as AccessListItemRpcSchema, type index$3_AccessListResultRpc as AccessListResultRpc, index$3_AccessListResultRpcSchema as AccessListResultRpcSchema, type index$3_AccountProofRpc as AccountProofRpc, index$3_AccountProofRpcSchema as AccountProofRpcSchema, index$3_AccountStateOverrideSchema as AccountStateOverrideSchema, type index$3_AddressHex as AddressHex, index$3_AddressHexSchema as AddressHexSchema, index$a as Anvil, type index$3_BlockOverride as BlockOverride, index$3_BlockOverrideSchema as BlockOverrideSchema, type index$3_BlockRpc as BlockRpc, index$3_BlockRpcSchema as BlockRpcSchema, type index$3_BlockTag as BlockTag, index$3_BlockTagSchema as BlockTagSchema, type index$3_Bytes32Hex as Bytes32Hex, index$3_Bytes32HexSchema as Bytes32HexSchema, index$9 as Eth, type index$3_FeeHistoryRpc as FeeHistoryRpc, index$3_FeeHistoryRpcSchema as FeeHistoryRpcSchema, index$3_GenericJsonRpcRequest as GenericJsonRpcRequest, type index$3_GenericJsonRpcRequestType as GenericJsonRpcRequestType, index$3_GenericJsonRpcResponse as GenericJsonRpcResponse, type index$3_GenericJsonRpcResponseType as GenericJsonRpcResponseType, index$3_GenericJsonRpcSuccessResponse as GenericJsonRpcSuccessResponse, index$8 as Hardhat, type index$3_Hex as Hex, index$3_HexSchema as HexSchema, index$3_JsonRpcBatchRequest as JsonRpcBatchRequest, type index$3_JsonRpcBatchRequestType as JsonRpcBatchRequestType, index$3_JsonRpcBatchResponse as JsonRpcBatchResponse, type index$3_JsonRpcBatchResponseType as JsonRpcBatchResponseType, index$3_JsonRpcErrorResponseSchema as JsonRpcErrorResponseSchema, type index$3_JsonRpcErrorResponseType as JsonRpcErrorResponseType, index$3_JsonRpcErrorSchema as JsonRpcErrorSchema, type index$3_JsonRpcErrorType as JsonRpcErrorType, type index$3_JsonRpcId as JsonRpcId, index$3_JsonRpcIdSchema as JsonRpcIdSchema, index$3_JsonRpcMethodRequest as JsonRpcMethodRequest, type index$3_JsonRpcMethodRequestType as JsonRpcMethodRequestType, index$3_JsonRpcVersionSchema as JsonRpcVersionSchema, type index$3_LogFilter as LogFilter, index$3_LogFilterSchema as LogFilterSchema, type index$3_LogRpc as LogRpc, index$3_LogRpcSchema as LogRpcSchema, type index$3_MethodResult as MethodResult, index$7 as Net, type index$3_QuantityHex as QuantityHex, index$3_QuantityHexSchema as QuantityHexSchema, type index$3_ReceiptRpc as ReceiptRpc, index$3_ReceiptRpcSchema as ReceiptRpcSchema, type index$3_StateOverrideSet as StateOverrideSet, index$3_StateOverrideSetSchema as StateOverrideSetSchema, type index$3_SyncStatusRpc as SyncStatusRpc, index$3_SyncStatusRpcSchema as SyncStatusRpcSchema, index$3_TopicFilterValueSchema as TopicFilterValueSchema, type index$3_TransactionRequest as TransactionRequest, index$3_TransactionRequestSchema as TransactionRequestSchema, type index$3_TransactionRpc as TransactionRpc, index$3_TransactionRpcSchema as TransactionRpcSchema, index$6 as Txpool, index$5 as Wallet, index$4 as Web3, type index$3_WithdrawalRpc as WithdrawalRpc, index$3_WithdrawalRpcSchema as WithdrawalRpcSchema, index$3_decodeRequest as decodeRequest, index$3_decodeResponse as decodeResponse, index$3_isErrorResponse as isErrorResponse, index$3_isSuccessResponse as isSuccessResponse, index$3_isValidRequest as isValidRequest, index$3_isValidResponse as isValidResponse, index$3_methodResultSchemas as methodResultSchemas };
 }
 
-declare const StatusRequest: () => JsonRpcRequestType;
-declare const ContentRequest: () => JsonRpcRequestType;
-declare const InspectRequest: () => JsonRpcRequestType;
+declare const StatusRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const ContentRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const InspectRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Txpool: {
-    StatusRequest: () => JsonRpcRequestType;
-    ContentRequest: () => JsonRpcRequestType;
-    InspectRequest: () => JsonRpcRequestType;
+    StatusRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    ContentRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    InspectRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Txpool$1_ContentRequest: typeof ContentRequest;
@@ -11372,7 +11420,7 @@ declare namespace Txpool$1 {
   export { Txpool$1_ContentRequest as ContentRequest, Txpool$1_InspectRequest as InspectRequest, Txpool$1_StatusRequest as StatusRequest, Txpool$1_Txpool as Txpool };
 }
 
-declare const SwitchEthereumChainRequest: (chainId: string) => JsonRpcRequestType;
+declare const SwitchEthereumChainRequest: (chainId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const AddEthereumChainRequest: (chainParams: {
     chainId: string;
     chainName: string;
@@ -11383,7 +11431,7 @@ declare const AddEthereumChainRequest: (chainParams: {
     };
     rpcUrls?: string[];
     blockExplorerUrls?: string[];
-}) => JsonRpcRequestType;
+}) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const WatchAssetRequest: (asset: {
     type: string;
     options: {
@@ -11392,12 +11440,12 @@ declare const WatchAssetRequest: (asset: {
         decimals: number;
         image?: string;
     };
-}) => JsonRpcRequestType;
-declare const RequestPermissionsRequest: (permissions: unknown[]) => JsonRpcRequestType;
-declare const GetPermissionsRequest: () => JsonRpcRequestType;
-declare const RevokePermissionsRequest: (permissions: unknown[]) => JsonRpcRequestType;
+}) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const RequestPermissionsRequest: (permissions: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const GetPermissionsRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const RevokePermissionsRequest: (permissions: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Wallet: {
-    SwitchEthereumChainRequest: (chainId: string) => JsonRpcRequestType;
+    SwitchEthereumChainRequest: (chainId: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
     AddEthereumChainRequest: (chainParams: {
         chainId: string;
         chainName: string;
@@ -11408,7 +11456,7 @@ declare const Wallet: {
         };
         rpcUrls?: string[];
         blockExplorerUrls?: string[];
-    }) => JsonRpcRequestType;
+    }) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
     WatchAssetRequest: (asset: {
         type: string;
         options: {
@@ -11417,10 +11465,10 @@ declare const Wallet: {
             decimals: number;
             image?: string;
         };
-    }) => JsonRpcRequestType;
-    RequestPermissionsRequest: (permissions: unknown[]) => JsonRpcRequestType;
-    GetPermissionsRequest: () => JsonRpcRequestType;
-    RevokePermissionsRequest: (permissions: unknown[]) => JsonRpcRequestType;
+    }) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    RequestPermissionsRequest: (permissions: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    GetPermissionsRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    RevokePermissionsRequest: (permissions: unknown[]) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Wallet$1_AddEthereumChainRequest: typeof AddEthereumChainRequest;
@@ -11434,11 +11482,11 @@ declare namespace Wallet$1 {
   export { Wallet$1_AddEthereumChainRequest as AddEthereumChainRequest, Wallet$1_GetPermissionsRequest as GetPermissionsRequest, Wallet$1_RequestPermissionsRequest as RequestPermissionsRequest, Wallet$1_RevokePermissionsRequest as RevokePermissionsRequest, Wallet$1_SwitchEthereumChainRequest as SwitchEthereumChainRequest, Wallet$1_Wallet as Wallet, Wallet$1_WatchAssetRequest as WatchAssetRequest };
 }
 
-declare const ClientVersionRequest: () => JsonRpcRequestType;
-declare const Sha3Request: (data: string) => JsonRpcRequestType;
+declare const ClientVersionRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+declare const Sha3Request: (data: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 declare const Web3: {
-    ClientVersionRequest: () => JsonRpcRequestType;
-    Sha3Request: (data: string) => JsonRpcRequestType;
+    ClientVersionRequest: () => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
+    Sha3Request: (data: string) => Effect.Effect<JsonRpcRequestType, never, IdCounterService>;
 };
 
 declare const Web3$1_ClientVersionRequest: typeof ClientVersionRequest;
@@ -11448,2256 +11496,102 @@ declare namespace Web3$1 {
   export { Web3$1_ClientVersionRequest as ClientVersionRequest, Web3$1_Sha3Request as Sha3Request, Web3$1_Web3 as Web3 };
 }
 
-declare const index$3_BatchRequest: typeof BatchRequest;
-type index$3_BatchRequestType = BatchRequestType;
-declare const index$3_BatchResponse: typeof BatchResponse;
-type index$3_BatchResponseType = BatchResponseType;
-declare const index$3_CHAIN_DISCONNECTED: typeof CHAIN_DISCONNECTED;
-type index$3_ChainDisconnectedError = ChainDisconnectedError;
-declare const index$3_ChainDisconnectedError: typeof ChainDisconnectedError;
-declare const index$3_DISCONNECTED: typeof DISCONNECTED;
-type index$3_DisconnectedError = DisconnectedError;
-declare const index$3_DisconnectedError: typeof DisconnectedError;
-declare const index$3_EXECUTION_REVERTED: typeof EXECUTION_REVERTED;
-type index$3_ExecutionRevertedError = ExecutionRevertedError;
-declare const index$3_ExecutionRevertedError: typeof ExecutionRevertedError;
-declare const index$3_INSUFFICIENT_FUNDS: typeof INSUFFICIENT_FUNDS;
-declare const index$3_INTERNAL_ERROR: typeof INTERNAL_ERROR;
-declare const index$3_INVALID_INPUT: typeof INVALID_INPUT;
-declare const index$3_INVALID_PARAMS: typeof INVALID_PARAMS;
-declare const index$3_INVALID_REQUEST: typeof INVALID_REQUEST;
-type index$3_InsufficientFundsError = InsufficientFundsError;
-declare const index$3_InsufficientFundsError: typeof InsufficientFundsError;
-type index$3_InternalError = InternalError;
-declare const index$3_InternalError: typeof InternalError;
-type index$3_InvalidInputError = InvalidInputError;
-declare const index$3_InvalidInputError: typeof InvalidInputError;
-type index$3_InvalidParamsError = InvalidParamsError;
-declare const index$3_InvalidParamsError: typeof InvalidParamsError;
-type index$3_InvalidRequestError = InvalidRequestError;
-declare const index$3_InvalidRequestError: typeof InvalidRequestError;
-declare const index$3_JSON_RPC_VERSION_NOT_SUPPORTED: typeof JSON_RPC_VERSION_NOT_SUPPORTED;
-declare const index$3_JsonRpcError: typeof JsonRpcError;
-type index$3_JsonRpcErrorResponse = JsonRpcErrorResponse;
-declare const index$3_JsonRpcErrorResponse: typeof JsonRpcErrorResponse;
-type index$3_JsonRpcIdType = JsonRpcIdType;
-type index$3_JsonRpcParseError = JsonRpcParseError;
-declare const index$3_JsonRpcParseError: typeof JsonRpcParseError;
-type index$3_JsonRpcRequestType<TParams = unknown[]> = JsonRpcRequestType<TParams>;
-type index$3_JsonRpcResponseType<TResult = unknown> = JsonRpcResponseType<TResult>;
-type index$3_JsonRpcSuccessResponseType<TResult = unknown> = JsonRpcSuccessResponseType<TResult>;
-declare const index$3_LIMIT_EXCEEDED: typeof LIMIT_EXCEEDED;
-type index$3_LimitExceededError = LimitExceededError;
-declare const index$3_LimitExceededError: typeof LimitExceededError;
-declare const index$3_METHOD_NOT_FOUND: typeof METHOD_NOT_FOUND;
-declare const index$3_METHOD_NOT_SUPPORTED: typeof METHOD_NOT_SUPPORTED;
-type index$3_MethodNotFoundError = MethodNotFoundError;
-declare const index$3_MethodNotFoundError: typeof MethodNotFoundError;
-type index$3_MethodNotSupportedError = MethodNotSupportedError;
-declare const index$3_MethodNotSupportedError: typeof MethodNotSupportedError;
-declare const index$3_NONCE_TOO_HIGH: typeof NONCE_TOO_HIGH;
-declare const index$3_NONCE_TOO_LOW: typeof NONCE_TOO_LOW;
-type index$3_NonceTooHighError = NonceTooHighError;
-declare const index$3_NonceTooHighError: typeof NonceTooHighError;
-type index$3_NonceTooLowError = NonceTooLowError;
-declare const index$3_NonceTooLowError: typeof NonceTooLowError;
-declare const index$3_PARSE_ERROR: typeof PARSE_ERROR;
-type index$3_ParseError = ParseError;
-declare const index$3_ParseError: typeof ParseError;
-declare const index$3_RESOURCE_NOT_FOUND: typeof RESOURCE_NOT_FOUND;
-declare const index$3_RESOURCE_UNAVAILABLE: typeof RESOURCE_UNAVAILABLE;
-declare const index$3_Request: typeof Request;
-type index$3_ResourceNotFoundError = ResourceNotFoundError;
-declare const index$3_ResourceNotFoundError: typeof ResourceNotFoundError;
-type index$3_ResourceUnavailableError = ResourceUnavailableError;
-declare const index$3_ResourceUnavailableError: typeof ResourceUnavailableError;
-declare const index$3_Response: typeof Response;
-type index$3_RpcError = RpcError;
-type index$3_RpcErrorCode = RpcErrorCode;
-declare const index$3_TRANSACTION_REJECTED: typeof TRANSACTION_REJECTED;
-type index$3_TransactionRejectedError = TransactionRejectedError;
-declare const index$3_TransactionRejectedError: typeof TransactionRejectedError;
-declare const index$3_UNAUTHORIZED: typeof UNAUTHORIZED;
-declare const index$3_UNSUPPORTED_METHOD: typeof UNSUPPORTED_METHOD;
-declare const index$3_USER_REJECTED_REQUEST: typeof USER_REJECTED_REQUEST;
-type index$3_UnauthorizedError = UnauthorizedError;
-declare const index$3_UnauthorizedError: typeof UnauthorizedError;
-type index$3_UnsupportedMethodError = UnsupportedMethodError;
-declare const index$3_UnsupportedMethodError: typeof UnsupportedMethodError;
-type index$3_UserRejectedRequestError = UserRejectedRequestError;
-declare const index$3_UserRejectedRequestError: typeof UserRejectedRequestError;
-declare const index$3_findById: typeof findById;
-declare const index$3_isDisconnected: typeof isDisconnected;
-declare const index$3_isError: typeof isError;
-declare const index$3_isExecutionReverted: typeof isExecutionReverted;
-declare const index$3_isInsufficientFunds: typeof isInsufficientFunds;
-declare const index$3_isNonceError: typeof isNonceError;
-declare const index$3_isNotification: typeof isNotification;
-declare const index$3_isProviderError: typeof isProviderError;
-declare const index$3_isSuccess: typeof isSuccess;
-declare const index$3_isUserRejected: typeof isUserRejected;
-declare const index$3_nextId: typeof nextId;
-declare const index$3_parseErrorCode: typeof parseErrorCode;
-declare const index$3_resetId: typeof resetId;
-declare const index$3_unwrap: typeof unwrap;
-declare const index$3_withParams: typeof withParams;
-declare namespace index$3 {
-  export { Anvil$1 as Anvil, index$3_BatchRequest as BatchRequest, type index$3_BatchRequestType as BatchRequestType, index$3_BatchResponse as BatchResponse, type index$3_BatchResponseType as BatchResponseType, index$3_CHAIN_DISCONNECTED as CHAIN_DISCONNECTED, index$3_ChainDisconnectedError as ChainDisconnectedError, index$3_DISCONNECTED as DISCONNECTED, index$3_DisconnectedError as DisconnectedError, index$3_EXECUTION_REVERTED as EXECUTION_REVERTED, Eth$1 as Eth, index$3_ExecutionRevertedError as ExecutionRevertedError, Hardhat$1 as Hardhat, index$3_INSUFFICIENT_FUNDS as INSUFFICIENT_FUNDS, index$3_INTERNAL_ERROR as INTERNAL_ERROR, index$3_INVALID_INPUT as INVALID_INPUT, index$3_INVALID_PARAMS as INVALID_PARAMS, index$3_INVALID_REQUEST as INVALID_REQUEST, index$3_InsufficientFundsError as InsufficientFundsError, index$3_InternalError as InternalError, index$3_InvalidInputError as InvalidInputError, index$3_InvalidParamsError as InvalidParamsError, index$3_InvalidRequestError as InvalidRequestError, index$3_JSON_RPC_VERSION_NOT_SUPPORTED as JSON_RPC_VERSION_NOT_SUPPORTED, index$3_JsonRpcError as JsonRpcError, index$3_JsonRpcErrorResponse as JsonRpcErrorResponse, type JsonRpcErrorResponseType$1 as JsonRpcErrorResponseType, type JsonRpcErrorType$1 as JsonRpcErrorType, type index$3_JsonRpcIdType as JsonRpcIdType, index$3_JsonRpcParseError as JsonRpcParseError, type index$3_JsonRpcRequestType as JsonRpcRequestType, type index$3_JsonRpcResponseType as JsonRpcResponseType, type index$3_JsonRpcSuccessResponseType as JsonRpcSuccessResponseType, index$3_LIMIT_EXCEEDED as LIMIT_EXCEEDED, index$3_LimitExceededError as LimitExceededError, index$3_METHOD_NOT_FOUND as METHOD_NOT_FOUND, index$3_METHOD_NOT_SUPPORTED as METHOD_NOT_SUPPORTED, index$3_MethodNotFoundError as MethodNotFoundError, index$3_MethodNotSupportedError as MethodNotSupportedError, index$3_NONCE_TOO_HIGH as NONCE_TOO_HIGH, index$3_NONCE_TOO_LOW as NONCE_TOO_LOW, Net$1 as Net, index$3_NonceTooHighError as NonceTooHighError, index$3_NonceTooLowError as NonceTooLowError, index$3_PARSE_ERROR as PARSE_ERROR, index$3_ParseError as ParseError, index$3_RESOURCE_NOT_FOUND as RESOURCE_NOT_FOUND, index$3_RESOURCE_UNAVAILABLE as RESOURCE_UNAVAILABLE, index$3_Request as Request, index$3_ResourceNotFoundError as ResourceNotFoundError, index$3_ResourceUnavailableError as ResourceUnavailableError, index$3_Response as Response, type index$3_RpcError as RpcError, type index$3_RpcErrorCode as RpcErrorCode, index$4 as Schemas, index$3_TRANSACTION_REJECTED as TRANSACTION_REJECTED, index$3_TransactionRejectedError as TransactionRejectedError, Txpool$1 as Txpool, index$3_UNAUTHORIZED as UNAUTHORIZED, index$3_UNSUPPORTED_METHOD as UNSUPPORTED_METHOD, index$3_USER_REJECTED_REQUEST as USER_REJECTED_REQUEST, index$3_UnauthorizedError as UnauthorizedError, index$3_UnsupportedMethodError as UnsupportedMethodError, index$3_UserRejectedRequestError as UserRejectedRequestError, Wallet$1 as Wallet, Web3$1 as Web3, add as batchAdd, errors as batchErrors, from$3 as batchRequestFrom, from as batchResponseFrom, parse$1 as batchResponseParse, results as batchResults, size as batchSize, from$2 as errorFrom, toString as errorToString, index$3_findById as findById, index$3_isDisconnected as isDisconnected, index$3_isError as isError, index$3_isExecutionReverted as isExecutionReverted, index$3_isInsufficientFunds as isInsufficientFunds, index$3_isNonceError as isNonceError, index$3_isNotification as isNotification, index$3_isProviderError as isProviderError, index$3_isSuccess as isSuccess, index$3_isUserRejected as isUserRejected, index$3_nextId as nextId, index$3_parseErrorCode as parseErrorCode, from$4 as requestFrom, index$3_resetId as resetId, from$1 as responseFrom, parse$2 as responseParse, index$3_unwrap as unwrap, index$3_withParams as withParams };
-}
-
-/**
- * Local abitype configuration with Uint8Array for bytes types
- *
- * This file provides scoped abitype configuration that uses Uint8Array for bytes
- * instead of `0x${string}`. This declaration merging is scoped to this module and
- * does not affect downstream users who import abitype directly.
- *
- * @internal
- */
-declare module "abitype" {
-    interface Register {
-        bytesType: {
-            inputs: Uint8Array;
-            outputs: Uint8Array;
-        };
-        intType: bigint;
-    }
-}
-//# sourceMappingURL=abitype-uint8array.d.ts.map
-
-type AbiType = "uint" | "uint8" | "uint16" | "uint24" | "uint32" | "uint40" | "uint48" | "uint56" | "uint64" | "uint72" | "uint80" | "uint88" | "uint96" | "uint104" | "uint112" | "uint120" | "uint128" | "uint136" | "uint144" | "uint152" | "uint160" | "uint168" | "uint176" | "uint184" | "uint192" | "uint200" | "uint208" | "uint216" | "uint224" | "uint232" | "uint240" | "uint248" | "uint256" | "int" | "int8" | "int16" | "int24" | "int32" | "int40" | "int48" | "int56" | "int64" | "int72" | "int80" | "int88" | "int96" | "int104" | "int112" | "int120" | "int128" | "int136" | "int144" | "int152" | "int160" | "int168" | "int176" | "int184" | "int192" | "int200" | "int208" | "int216" | "int224" | "int232" | "int240" | "int248" | "int256" | "address" | "bool" | "string" | "bytes" | "bytes1" | "bytes2" | "bytes3" | "bytes4" | "bytes5" | "bytes6" | "bytes7" | "bytes8" | "bytes9" | "bytes10" | "bytes11" | "bytes12" | "bytes13" | "bytes14" | "bytes15" | "bytes16" | "bytes17" | "bytes18" | "bytes19" | "bytes20" | "bytes21" | "bytes22" | "bytes23" | "bytes24" | "bytes25" | "bytes26" | "bytes27" | "bytes28" | "bytes29" | "bytes30" | "bytes31" | "bytes32" | "tuple" | `${string}[]` | `${string}[${number}]`;
-
-type Parameter<TType extends AbiType = AbiType, TName extends string = string, TInternalType extends string = string> = {
-    readonly type: TType;
-    readonly name?: TName;
-    readonly internalType?: TInternalType;
-    readonly indexed?: boolean;
-    readonly components?: readonly Parameter[];
-};
-
-type EventType<TName extends string = string, TInputs extends readonly Parameter[] = readonly Parameter[]> = {
-    type: "event";
-    name: TName;
-    inputs: TInputs;
-    anonymous?: boolean;
-};
-
-type StateMutability = "pure" | "view" | "nonpayable" | "payable";
-
-/**
- * Type definition for Constructor (data only)
- */
-type ConstructorType<TStateMutability extends StateMutability = StateMutability, TInputs extends readonly Parameter[] = readonly Parameter[]> = {
-    type: "constructor";
-    stateMutability: TStateMutability;
-    inputs: TInputs;
-};
-
-/**
- * Function ABI item type
- *
- * @template TName - Function name
- * @template TStateMutability - State mutability (pure | view | nonpayable | payable)
- * @template TInputs - Input parameters
- * @template TOutputs - Output parameters
- */
-type FunctionType<TName extends string = string, TStateMutability extends StateMutability = StateMutability, TInputs extends readonly Parameter[] = readonly Parameter[], TOutputs extends readonly Parameter[] = readonly Parameter[]> = {
-    type: "function";
-    name: TName;
-    stateMutability: TStateMutability;
-    inputs: TInputs;
-    outputs: TOutputs;
-};
-
-type Fallback<TStateMutability extends StateMutability = StateMutability> = {
-    type: "fallback";
-    stateMutability: TStateMutability;
-};
-type Receive = {
-    type: "receive";
-    stateMutability: "payable";
-};
-
-type ParameterType<TType extends AbiType = AbiType, TName extends string = string, TInternalType extends string = string> = {
-    readonly type: TType;
-    readonly name?: TName;
-    readonly internalType?: TInternalType;
-    readonly indexed?: boolean;
-    readonly components?: readonly ParameterType[];
-};
-
-type ErrorType<TName extends string = string, TInputs extends readonly ParameterType[] = readonly ParameterType[]> = {
-    type: "error";
-    name: TName;
-    inputs: TInputs;
-};
-
-/**
- * Single ABI item (function, event, error, constructor, fallback, or receive)
- */
-type Item = FunctionType | EventType | ErrorType | ConstructorType | Fallback | Receive;
-
-/**
- * Abi class interface
- *
- * Array-like class for working with contract ABIs, extending Array with ABI-specific methods
- */
-interface Abi<TItems extends readonly Item[] = readonly Item[]> extends Array<TItems[number]> {
-    getItem(name: string, type: "function" | "event" | "error"): Item | undefined;
-    format(): string[];
-    formatWithArgs(args: Record<string, any>): string[];
-    encode(functionName: string, args: any[]): Uint8Array;
-    decode(functionName: string, data: Uint8Array): any[];
-    decodeData(data: Uint8Array): {
-        item: Item;
-        decoded: any[];
-    };
-    parseLogs(logs: any[]): any[];
-    getFunction(name: string): FunctionType | undefined;
-    getEvent(name: string): EventType | undefined;
-    getError(name: string): ErrorType | undefined;
-    getConstructor(): ConstructorType | undefined;
-    getFallback(): any;
-    getReceive(): any;
-}
-
-/**
- * Schema for Solidity state mutability.
- *
- * @since 0.1.0
- */
-declare const StateMutabilitySchema: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-/**
- * Schema for Solidity type strings.
- * Uses S.String for flexibility with array types like "uint256[]" and "address[10]".
- *
- * @since 0.1.0
- */
-declare const AbiTypeSchema: typeof S.String;
-/**
- * Internal interface for ABI parameters.
- * @internal
- */
-interface ParameterInternal {
-    readonly type: string;
-    readonly name?: string;
-    readonly internalType?: string;
-    readonly indexed?: boolean;
-    readonly components?: readonly ParameterInternal[];
-}
-/**
- * Schema for ABI parameters (recursive for tuple types).
- *
- * @since 0.1.0
- */
-declare const ParameterSchema: S.Schema<ParameterInternal>;
-/**
- * Internal schema for function ABI items.
- * @internal
- */
-declare const FunctionSchemaInternal: S.Struct<{
-    type: S.Literal<["function"]>;
-    name: typeof S.String;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    outputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>;
-/**
- * Type for function items.
- * @internal
- */
-type FunctionItem = {
-    readonly type: "function";
-    readonly name: string;
-    readonly stateMutability: "pure" | "view" | "nonpayable" | "payable";
-    readonly inputs: readonly ParameterInternal[];
-    readonly outputs: readonly ParameterInternal[];
-};
-/**
- * Schema for function ABI items.
- *
- * @since 0.1.0
- */
-declare const FunctionSchema: S.Schema<FunctionItem, S.Schema.Encoded<typeof FunctionSchemaInternal>>;
-/**
- * Internal schema for event ABI items.
- * @internal
- */
-declare const EventSchemaInternal: S.Struct<{
-    type: S.Literal<["event"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    anonymous: S.optional<typeof S.Boolean>;
-}>;
-/**
- * Type for event items.
- * @internal
- */
-type EventItem = {
-    readonly type: "event";
-    readonly name: string;
-    readonly inputs: readonly ParameterInternal[];
-    readonly anonymous?: boolean;
-};
-/**
- * Schema for event ABI items.
- *
- * @since 0.1.0
- */
-declare const EventSchema: S.Schema<EventItem, S.Schema.Encoded<typeof EventSchemaInternal>>;
-/**
- * Internal schema for error ABI items.
- * @internal
- */
-declare const ErrorSchemaInternal: S.Struct<{
-    type: S.Literal<["error"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>;
-/**
- * Type for error items.
- * @internal
- */
-type ErrorItem = {
-    readonly type: "error";
-    readonly name: string;
-    readonly inputs: readonly ParameterInternal[];
-};
-/**
- * Schema for error ABI items.
- *
- * @since 0.1.0
- */
-declare const ErrorSchema: S.Schema<ErrorItem, S.Schema.Encoded<typeof ErrorSchemaInternal>>;
-/**
- * Internal schema for constructor ABI items.
- * @internal
- */
-declare const ConstructorSchemaInternal: S.Struct<{
-    type: S.Literal<["constructor"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>;
-/**
- * Type for constructor items.
- * @internal
- */
-type ConstructorItem = {
-    readonly type: "constructor";
-    readonly stateMutability: "pure" | "view" | "nonpayable" | "payable";
-    readonly inputs: readonly ParameterInternal[];
-};
-/**
- * Schema for constructor ABI items.
- *
- * @since 0.1.0
- */
-declare const ConstructorSchema: S.Schema<ConstructorItem, S.Schema.Encoded<typeof ConstructorSchemaInternal>>;
-/**
- * Internal schema for fallback ABI items.
- * @internal
- */
-declare const FallbackSchemaInternal: S.Struct<{
-    type: S.Literal<["fallback"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-}>;
-/**
- * Type for fallback items.
- * @internal
- */
-type FallbackItem = {
-    readonly type: "fallback";
-    readonly stateMutability: "pure" | "view" | "nonpayable" | "payable";
-};
-/**
- * Schema for fallback ABI items.
- *
- * @since 0.1.0
- */
-declare const FallbackSchema: S.Schema<FallbackItem, S.Schema.Encoded<typeof FallbackSchemaInternal>>;
-/**
- * Internal schema for receive ABI items.
- * @internal
- */
-declare const ReceiveSchemaInternal: S.Struct<{
-    type: S.Literal<["receive"]>;
-    stateMutability: S.Literal<["payable"]>;
-}>;
-/**
- * Type for receive items.
- * @internal
- */
-type ReceiveItem = {
-    readonly type: "receive";
-    readonly stateMutability: "payable";
-};
-/**
- * Schema for receive ABI items.
- *
- * @since 0.1.0
- */
-declare const ReceiveSchema: S.Schema<ReceiveItem, S.Schema.Encoded<typeof ReceiveSchemaInternal>>;
-/**
- * Internal union schema for all ABI item types.
- * @internal
- */
-declare const ItemSchemaInternal: S.Union<[S.Struct<{
-    type: S.Literal<["function"]>;
-    name: typeof S.String;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    outputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["event"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    anonymous: S.optional<typeof S.Boolean>;
-}>, S.Struct<{
-    type: S.Literal<["error"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["constructor"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["fallback"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-}>, S.Struct<{
-    type: S.Literal<["receive"]>;
-    stateMutability: S.Literal<["payable"]>;
-}>]>;
-/**
- * Type for any ABI item.
- * @internal
- */
-type AbiItemInternal = FunctionItem | EventItem | ErrorItem | ConstructorItem | FallbackItem | ReceiveItem;
-/**
- * Schema for any ABI item (function, event, error, constructor, fallback, receive).
- *
- * @since 0.1.0
- */
-declare const ItemSchema: S.Schema<AbiItemInternal, S.Schema.Encoded<typeof ItemSchemaInternal>>;
-/**
- * Schema for validated Abi instances.
- * Use this schema to check if a value is already an Abi.
- *
- * @since 0.1.0
- */
-declare const AbiSchema: S.declare<Abi<readonly _tevm_voltaire_Abi.ItemType[]>, Abi<readonly _tevm_voltaire_Abi.ItemType[]>, readonly [], never>;
-/**
- * Schema that parses raw ABI arrays into Abi instances.
- * Use this to validate and construct Abi from unknown input.
- *
- * @example
- * ```typescript
- * import * as Abi from 'voltaire-effect/primitives/Abi'
- * import * as S from 'effect/Schema'
- *
- * const abi = S.decodeUnknownSync(Abi.fromArray)([
- *   { type: 'function', name: 'transfer', stateMutability: 'nonpayable',
- *     inputs: [{ type: 'address', name: 'to' }, { type: 'uint256', name: 'amount' }],
- *     outputs: [{ type: 'bool' }] }
- * ])
- * ```
- *
- * @since 0.1.0
- */
-declare const fromArray: S.transformOrFail<S.Array$<S.Union<[S.Struct<{
-    type: S.Literal<["function"]>;
-    name: typeof S.String;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    outputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["event"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-    anonymous: S.optional<typeof S.Boolean>;
-}>, S.Struct<{
-    type: S.Literal<["error"]>;
-    name: typeof S.String;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["constructor"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-    inputs: S.Array$<S.Schema<ParameterInternal, ParameterInternal, never>>;
-}>, S.Struct<{
-    type: S.Literal<["fallback"]>;
-    stateMutability: S.Union<[S.Literal<["pure"]>, S.Literal<["view"]>, S.Literal<["nonpayable"]>, S.Literal<["payable"]>]>;
-}>, S.Struct<{
-    type: S.Literal<["receive"]>;
-    stateMutability: S.Literal<["payable"]>;
-}>]>>, S.declare<Abi<readonly _tevm_voltaire_Abi.ItemType[]>, Abi<readonly _tevm_voltaire_Abi.ItemType[]>, readonly [], never>, never>;
-
-/**
- * @fileoverview Encodes function call data from ABI by function name.
- * Provides Effect-based wrapper around the branded ABI encode method.
- *
- * @module Abi/encode
- * @since 0.0.1
- */
-
-type AbiInput$k = readonly ItemType[];
-/**
- * Encodes function call data from ABI by function name.
- *
- * @description
- * Creates encoded calldata for invoking a contract function.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} functionName - The function name to encode.
- * @param {readonly unknown[]} args - The function arguments.
- * @returns {Effect.Effect<Uint8Array, AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding encoded calldata as bytes.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encode } from 'voltaire-effect/primitives/Abi'
- *
- * const calldata = await Effect.runPromise(
- *   encode(abi, 'transfer', [to, amount])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encode: (abi: AbiInput$k, functionName: string, args: readonly unknown[]) => Effect.Effect<Uint8Array, AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview ABI encodePacked - compact encoding without padding.
- * Provides Effect-based wrapper for packed encoding.
- *
- * @module Abi/encodePacked
- * @since 0.0.1
- */
-
-/**
- * Encodes values in packed format (no padding).
- *
- * @description
- * Performs ABI encoding without padding, used for creating hashes
- * where standard ABI encoding would waste space.
- *
- * @param {readonly string[]} types - Array of Solidity type strings.
- * @param {readonly unknown[]} values - Array of values to encode.
- * @returns {Effect.Effect<HexType, AbiParameterMismatchError | AbiEncodingError>}
- *   Effect yielding encoded hex string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodePacked } from 'voltaire-effect/primitives/Abi'
- *
- * const encoded = await Effect.runPromise(
- *   encodePacked(['address', 'uint256'], [address, amount])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encodePacked: (types: readonly string[], values: readonly unknown[]) => Effect.Effect<HexType, AbiParameterMismatchError | AbiEncodingError>;
-
-/**
- * @fileoverview Encodes ERC-7751 wrapped error data.
- * Provides Effect-based wrapper for wrapped error encoding.
- *
- * @module Abi/encodeWrappedError
- * @since 0.0.1
- */
-
-/**
- * Wrapped error input structure (ERC-7751).
- */
-type WrappedErrorInput = WrappedErrorType;
-/**
- * Encodes ERC-7751 wrapped error data.
- *
- * @description
- * Creates encoded error data following the ERC-7751 specification:
- * `error WrappedError(address target, bytes4 selector, bytes reason, bytes details)`
- *
- * @param {WrappedErrorInput} wrappedError - Wrapped error data.
- * @returns {Effect.Effect<Uint8Array, AbiEncodingError>}
- *   Effect yielding encoded error data (selector + ABI-encoded params).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeWrappedError } from 'voltaire-effect/primitives/Abi'
- * import * as Address from '@tevm/voltaire/Address'
- * import * as Selector from '@tevm/voltaire/Selector'
- *
- * const encoded = await Effect.runPromise(
- *   encodeWrappedError({
- *     target: Address.from('0x1234...'),
- *     selector: Selector.fromHex('0xabcd1234'),
- *     reason: new Uint8Array([...]),
- *     details: new Uint8Array([...])
- *   })
- * )
- * ```
- *
- * @see https://eips.ethereum.org/EIPS/eip-7751
- * @since 0.0.1
- */
-declare const encodeWrappedError: (wrappedError: WrappedErrorInput) => Effect.Effect<Uint8Array, AbiEncodingError>;
-
-/**
- * @fileoverview Decodes function return values from ABI by function name.
- * Provides Effect-based wrapper around the branded ABI decode method.
- *
- * @module Abi/decode
- * @since 0.0.1
- */
-
-type AbiInput$j = readonly ItemType[];
-/**
- * Decodes function return values from ABI by function name.
- *
- * @description
- * Decodes the return data from a contract call using the function's output types.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} functionName - The function name whose outputs to decode.
- * @param {Uint8Array} data - The encoded return data.
- * @returns {Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError>}
- *   Effect yielding decoded return values.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decode } from 'voltaire-effect/primitives/Abi'
- *
- * const result = await Effect.runPromise(
- *   decode(abi, 'balanceOf', returnData)
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const decode: (abi: AbiInput$j, functionName: string, data: Uint8Array) => Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError>;
-
-/**
- * @fileoverview Decodes function call data and identifies the function.
- * Provides Effect-based wrapper around the branded ABI decodeData method.
- *
- * @module Abi/decodeData
- * @since 0.0.1
- */
-
-type AbiInput$i = readonly ItemType[];
-/**
- * Decodes function call data and identifies the function.
- *
- * @description
- * Parses encoded calldata to extract the function name and decoded arguments.
- * The data must start with a 4-byte function selector.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {Uint8Array} data - The encoded function call data.
- * @returns {Effect.Effect<{ functionName: string; args: readonly unknown[] }, AbiItemNotFoundError | AbiInvalidSelectorError | AbiDecodingError>}
- *   Effect yielding the function name and decoded arguments.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeData } from 'voltaire-effect/primitives/Abi'
- *
- * const decoded = await Effect.runPromise(
- *   decodeData(abi, calldata)
- * )
- * console.log(decoded.functionName) // 'transfer'
- * console.log(decoded.args) // ['0x...', 100n]
- * ```
- *
- * @since 0.0.1
- */
-declare const decodeData: (abi: AbiInput$i, data: Uint8Array) => Effect.Effect<{
-    functionName: string;
-    args: readonly unknown[];
-}, AbiItemNotFoundError | AbiInvalidSelectorError$1 | AbiDecodingError>;
-
-/**
- * @fileoverview Decodes event log data using ABI.
- * Provides Effect-based wrapper for parsing log entries.
- *
- * @module Abi/decodeLog
- * @since 0.0.1
- */
-
-type AbiInput$h = readonly ItemType[];
-/**
- * Log input structure.
- */
-interface LogInput$1 {
-    data: HexType | Uint8Array;
-    topics: readonly (HexType | Uint8Array)[];
-}
-/**
- * Decodes event log data using ABI.
- *
- * @description
- * Parses a log entry to extract the event name and decoded parameters.
- * Supports both regular events (matched by topic0) and anonymous events.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {LogInput} log - The log object with data and topics.
- * @returns {Effect.Effect<{ event: string; params: Record<string, unknown> }, AbiItemNotFoundError | AbiDecodingError>}
- *   Effect yielding the event name and decoded parameters.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeLog } from 'voltaire-effect/primitives/Abi'
- *
- * const decoded = await Effect.runPromise(
- *   decodeLog(abi, { data: '0x...', topics: ['0x...', ...] })
- * )
- * console.log(decoded.event) // 'Transfer'
- * console.log(decoded.params) // { from: '0x...', to: '0x...', value: 100n }
- * ```
- *
- * @since 0.0.1
- */
-declare const decodeLog: (abi: AbiInput$h, log: LogInput$1) => Effect.Effect<{
-    event: string;
-    params: Record<string, unknown>;
-}, AbiItemNotFoundError | AbiDecodingError>;
-
-/**
- * @fileoverview Decodes ERC-7751 wrapped error data.
- * Provides Effect-based wrapper for wrapped error decoding.
- *
- * @module Abi/decodeWrappedError
- * @since 0.0.1
- */
-
-/**
- * Decoded wrapped error structure (ERC-7751).
- */
-type WrappedErrorResult = WrappedErrorType;
-/**
- * Decodes ERC-7751 wrapped error data.
- *
- * @description
- * Decodes a WrappedError from encoded bytes following the ERC-7751 specification.
- * Expects data to start with the WrappedError selector (0x90bfb865).
- *
- * @param {Uint8Array} data - Encoded error data (selector + ABI-encoded params).
- * @returns {Effect.Effect<WrappedErrorResult, AbiDecodingError | AbiInvalidSelectorError>}
- *   Effect yielding decoded wrapped error.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeWrappedError } from 'voltaire-effect/primitives/Abi'
- *
- * const decoded = await Effect.runPromise(
- *   decodeWrappedError(errorData)
- * )
- * console.log(decoded.target) // Address of failing contract
- * console.log(decoded.selector) // Function selector
- * ```
- *
- * @see https://eips.ethereum.org/EIPS/eip-7751
- * @since 0.0.1
- */
-declare const decodeWrappedError: (data: Uint8Array) => Effect.Effect<WrappedErrorResult, AbiDecodingError | AbiInvalidSelectorError$1>;
-
-/**
- * @fileoverview Decodes error data using ABI.
- * Provides Effect-based wrapper for decoding error parameters.
- *
- * @module Abi/decodeError
- * @since 0.0.1
- */
-
-type AbiInvalidSelectorError = Error & {
-    code: string;
-};
-/**
- * Represents a single ABI item.
- * @internal
- */
-type AbiItem$4 = {
-    type: string;
-    name?: string;
-};
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$g = readonly AbiItem$4[];
-/**
- * Decodes error data using ABI.
- *
- * @description
- * Decodes error data by matching the 4-byte selector and decoding parameters.
- * Returns the error name and decoded parameters.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} errorName - The error name to decode as.
- * @param {HexType | Uint8Array} data - The encoded error data.
- * @returns {Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError | AbiInvalidSelectorError>}
- *   Effect yielding the decoded error parameters.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeError } from 'voltaire-effect/primitives/Abi'
- *
- * const params = await Effect.runPromise(
- *   decodeError(abi, 'InsufficientBalance', '0x...')
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const decodeError: (abi: AbiInput$g, errorName: string, data: HexType | Uint8Array) => Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError | AbiInvalidSelectorError>;
-
-/**
- * @fileoverview Encodes error data with selector.
- * Provides Effect-based wrapper for encoding error parameters.
- *
- * @module Abi/encodeError
- * @since 0.0.1
- */
-
-/**
- * Represents a single ABI item.
- * @internal
- */
-type AbiItem$3 = {
-    type: string;
-    name?: string;
-};
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$f = readonly AbiItem$3[];
-/**
- * Encodes error data with selector.
- *
- * @description
- * Encodes error parameters with a 4-byte selector prefix.
- * The selector is the first 4 bytes of keccak256(signature).
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} errorName - The error name.
- * @param {readonly unknown[]} args - The error parameters.
- * @returns {Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding the encoded error data.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeError } from 'voltaire-effect/primitives/Abi'
- *
- * const encoded = await Effect.runPromise(
- *   encodeError(abi, 'InsufficientBalance', [100n])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encodeError: (abi: AbiInput$f, errorName: string, args: readonly unknown[]) => Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview Decodes Ethereum event logs using ABI definitions.
- * Provides Effect-based wrapper for decoding log data and topics into
- * structured event information with typed parameters.
- *
- * @module Abi/decodeEventLog
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input accepted by the decoder.
- * @internal
- */
-type AbiInput$e = readonly ItemType[];
-/**
- * Input structure for decoding event logs.
- * Represents the raw log data emitted during transaction execution.
- *
- * @description
- * Contains the log data payload and topics array from an Ethereum event.
- * The first topic (topics[0]) is typically the event signature hash,
- * while subsequent topics contain indexed event parameters.
- *
- * @since 0.0.1
- *
- * @example
- * ```typescript
- * const log: LogInput = {
- *   data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
- *   topics: [
- *     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', // Transfer signature
- *     '0x000000000000000000000000sender...',  // indexed from
- *     '0x000000000000000000000000recipient...' // indexed to
- *   ]
- * }
- * ```
- */
-interface LogInput {
-    /**
-     * The log data as hex string or bytes.
-     * Contains non-indexed event parameters ABI-encoded.
-     */
-    data: HexType | Uint8Array;
-    /**
-     * Array of log topics as hex strings or bytes.
-     * First topic is event signature, rest are indexed params.
-     */
-    topics: readonly (HexType | Uint8Array)[];
-}
-/**
- * Decodes an event log using the provided ABI.
- *
- * @description
- * Parses raw log data and topics into a structured object containing
- * the event name and decoded parameters. Uses the first topic to identify
- * the event by its signature hash, then decodes remaining topics and data
- * according to the event's ABI definition.
- *
- * This function never throws exceptions. Instead, it returns an Effect
- * that may fail with an `AbiItemNotFoundError` if no matching event
- * is found in the provided ABI, or an `AbiDecodingError` if the log
- * data cannot be decoded.
- *
- * @param {AbiInput} abi - The contract ABI containing event definitions.
- *   Can be a JSON ABI array or parsed ABI object.
- * @param {LogInput} log - The log data with topics to decode.
- *   Must include at least one topic (the event signature).
- *
- * @returns {Effect.Effect<{ event: string; params: Record<string, unknown> }, AbiItemNotFoundError | AbiDecodingError>}
- *   Effect yielding an object with:
- *   - `event`: The name of the matched event
- *   - `params`: Record of parameter names to decoded values
- *   Or failing with `AbiItemNotFoundError` if event not found.
- *
- * @throws {AbiItemNotFoundError} When no event in the ABI matches the log's topic signature.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeEventLog } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'event',
- *     name: 'Transfer',
- *     inputs: [
- *       { name: 'from', type: 'address', indexed: true },
- *       { name: 'to', type: 'address', indexed: true },
- *       { name: 'value', type: 'uint256', indexed: false }
- *     ]
- *   }
- * ]
- *
- * const result = await Effect.runPromise(decodeEventLog(erc20Abi, {
- *   data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
- *   topics: [
- *     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
- *     '0x000000000000000000000000abc...',
- *     '0x000000000000000000000000def...'
- *   ]
- * }))
- *
- * console.log(result.event) // 'Transfer'
- * console.log(result.params) // { from: '0xabc...', to: '0xdef...', value: 1000000000000000000n }
- * ```
- *
- * @example
- * ```typescript
- * // Handle unknown events gracefully
- * const decoded = await Effect.runPromise(
- *   decodeEventLog(abi, log).pipe(
- *     Effect.catchTag('AbiItemNotFoundError', (e) =>
- *       Effect.succeed({ event: 'Unknown', params: {} })
- *     )
- *   )
- * )
- * ```
- *
- * @since 0.0.1
- * @see {@link getEvent} for retrieving event definitions by name
- */
-declare const decodeEventLog: (abi: AbiInput$e, log: LogInput) => Effect.Effect<{
-    event: string;
-    params: Record<string, unknown>;
-}, AbiItemNotFoundError | AbiDecodingError>;
-
-/**
- * @fileoverview Encodes event log topics.
- * Provides Effect-based wrapper for encoding event topics.
- *
- * @module Abi/encodeEventLog
- * @since 0.0.1
- */
-
-/**
- * Represents a single ABI item.
- * @internal
- */
-type AbiItem$2 = {
-    type: string;
-    name?: string;
-};
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$d = readonly AbiItem$2[];
-/**
- * Encodes event log topics.
- *
- * @description
- * Encodes indexed event parameters as topics for filtering logs.
- * Returns the event selector as topic0 followed by encoded indexed parameters.
- * Null topics indicate a wildcard match in log filters.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} eventName - The event name.
- * @param {readonly unknown[]} indexedArgs - The indexed parameter values.
- * @returns {Effect.Effect<readonly (HexType | null)[], AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding the encoded topics array.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeEventLog } from 'voltaire-effect/primitives/Abi'
- *
- * const topics = await Effect.runPromise(
- *   encodeEventLog(abi, 'Transfer', [from, to])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encodeEventLog: (abi: AbiInput$d, eventName: string, indexedArgs: readonly unknown[]) => Effect.Effect<readonly (HexType | null)[], AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview Decodes function call data using ABI.
- * Provides Effect-based wrapper for parsing encoded calldata.
- *
- * @module Abi/decodeFunction
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$c = readonly ItemType[];
-/**
- * Decodes function call data using ABI.
- *
- * @description
- * Parses encoded calldata to extract the function name and decoded parameters.
- * The data must start with a 4-byte function selector.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {HexType | Uint8Array} data - The encoded function call data.
- * @returns {Effect.Effect<{ name: string; params: readonly unknown[] }, AbiItemNotFoundError | AbiInvalidSelectorError | AbiDecodingError>}
- *   Effect yielding the function name and decoded parameters.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeFunction } from 'voltaire-effect/primitives/Abi'
- *
- * const decoded = await Effect.runPromise(
- *   decodeFunction(abi, '0xa9059cbb...')
- * )
- * console.log(decoded.name) // 'transfer'
- * console.log(decoded.params) // ['0x...', 100n]
- * ```
- *
- * @since 0.0.1
- */
-declare const decodeFunction: (abi: AbiInput$c, data: HexType | Uint8Array) => Effect.Effect<{
-    name: string;
-    params: readonly unknown[];
-}, AbiItemNotFoundError | AbiInvalidSelectorError$1 | AbiDecodingError>;
-
-/**
- * @fileoverview Decodes Ethereum function call data (calldata) using ABI definitions.
- * Provides Effect-based wrapper for parsing calldata into function name and parameters.
- *
- * @module Abi/decodeFunctionData
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input accepted by the decoder.
- * @internal
- */
-type AbiInput$b = readonly ItemType[];
-/**
- * Decodes function call data using the provided ABI.
- *
- * @description
- * Parses encoded calldata to extract the function name and decoded parameters.
- * The calldata consists of a 4-byte function selector followed by ABI-encoded
- * arguments. This function identifies the function by its selector and decodes
- * the arguments according to the function's input types.
- *
- * This function never throws exceptions. Instead, it returns an Effect that
- * may fail with one of several error types depending on what went wrong.
- *
- * @param {AbiInput} abi - The contract ABI containing function definitions.
- *   Can be a JSON ABI array or parsed ABI object.
- * @param {HexType | Uint8Array} data - The encoded function calldata as hex string or bytes.
- *   Must be at least 4 bytes (the selector).
- *
- * @returns {Effect.Effect<{ name: string; params: readonly unknown[] }, AbiItemNotFoundError | AbiInvalidSelectorError | AbiDecodingError>}
- *   Effect yielding an object with:
- *   - `name`: The name of the matched function
- *   - `params`: Array of decoded parameter values in order
- *   Or failing with one of:
- *   - `AbiItemNotFoundError`: No function matches the selector
- *   - `AbiInvalidSelectorError`: Invalid or malformed selector
- *   - `AbiDecodingError`: Failed to decode the parameters
- *
- * @throws {AbiItemNotFoundError} When no function in the ABI matches the calldata selector.
- * @throws {AbiInvalidSelectorError} When the calldata is too short or has invalid selector.
- * @throws {AbiDecodingError} When parameter decoding fails (wrong types, insufficient data).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeFunctionData } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'function',
- *     name: 'transfer',
- *     inputs: [
- *       { name: 'to', type: 'address' },
- *       { name: 'amount', type: 'uint256' }
- *     ],
- *     outputs: [{ type: 'bool' }]
- *   }
- * ]
- *
- * // Decode a transfer call
- * const result = await Effect.runPromise(
- *   decodeFunctionData(erc20Abi, '0xa9059cbb000000000000000000000000...')
- * )
- * console.log(result.name)   // 'transfer'
- * console.log(result.params) // ['0x...recipient', 1000000n]
- * ```
- *
- * @example
- * ```typescript
- * // Handle decoding errors
- * const decoded = await Effect.runPromise(
- *   decodeFunctionData(abi, calldata).pipe(
- *     Effect.catchTags({
- *       AbiItemNotFoundError: () => Effect.succeed({ name: 'unknown', params: [] }),
- *       AbiInvalidSelectorError: () => Effect.fail(new Error('Invalid calldata')),
- *       AbiDecodingError: (e) => Effect.fail(new Error(`Decode failed: ${e.message}`))
- *     })
- *   )
- * )
- * ```
- *
- * @since 0.0.1
- * @see {@link encodeFunctionData} for encoding function calls
- * @see {@link getFunction} for retrieving function definitions by name
- */
-declare const decodeFunctionData: (abi: AbiInput$b, data: HexType | Uint8Array) => Effect.Effect<{
-    name: string;
-    params: readonly unknown[];
-}, AbiItemNotFoundError | AbiInvalidSelectorError$1 | AbiDecodingError>;
-
-/**
- * @fileoverview Decodes Ethereum function return data using ABI definitions.
- * Provides Effect-based wrapper for parsing function call return values.
- *
- * @module Abi/decodeFunctionResult
- * @since 0.0.1
- */
-
-/**
- * Represents a single ABI item with type and optional name.
- * @internal
- */
-type AbiItem$1 = {
-    type: string;
-    name?: string;
-};
-/**
- * Type alias for ABI input accepted by the decoder.
- * @internal
- */
-type AbiInput$a = readonly AbiItem$1[];
-/**
- * Decodes the return value of a function call using the provided ABI.
- *
- * @description
- * Parses the ABI-encoded return data from a contract call into an array of
- * decoded values. The function looks up the named function in the ABI to
- * determine the expected output types, then decodes the data accordingly.
- *
- * This is typically used after making an `eth_call` or similar RPC request
- * to interpret the raw bytes returned by the contract.
- *
- * This function never throws exceptions. Instead, it returns an Effect that
- * may fail with typed errors.
- *
- * @param {AbiInput} abi - The contract ABI containing function definitions.
- *   Must be an array of ABI items including the target function.
- * @param {string} functionName - The name of the function whose result to decode.
- *   Must exactly match a function name in the ABI.
- * @param {HexType | Uint8Array} data - The encoded return data as hex string or bytes.
- *   This is the raw data returned from the contract call.
- *
- * @returns {Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError>}
- *   Effect yielding an array of decoded return values in order.
- *   For functions with single return value, array has one element.
- *   For functions with multiple returns, array has multiple elements.
- *   Or failing with:
- *   - `AbiItemNotFoundError`: Function not found in ABI
- *   - `AbiDecodingError`: Failed to decode the return data
- *
- * @throws {AbiItemNotFoundError} When the function name is not found in the ABI.
- * @throws {AbiDecodingError} When return data decoding fails (wrong types, insufficient data).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { decodeFunctionResult } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'function',
- *     name: 'balanceOf',
- *     inputs: [{ name: 'account', type: 'address' }],
- *     outputs: [{ type: 'uint256' }]
- *   }
- * ]
- *
- * // Decode balanceOf return value
- * const returnData = '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000'
- * const result = await Effect.runPromise(
- *   decodeFunctionResult(erc20Abi, 'balanceOf', returnData)
- * )
- * console.log(result[0]) // 1000000000000000000n (1 ETH in wei)
- * ```
- *
- * @example
- * ```typescript
- * // Function with multiple return values
- * const pairAbi = [
- *   {
- *     type: 'function',
- *     name: 'getReserves',
- *     inputs: [],
- *     outputs: [
- *       { name: 'reserve0', type: 'uint112' },
- *       { name: 'reserve1', type: 'uint112' },
- *       { name: 'blockTimestampLast', type: 'uint32' }
- *     ]
- *   }
- * ]
- *
- * const result = await Effect.runPromise(
- *   decodeFunctionResult(pairAbi, 'getReserves', returnData)
- * )
- * const [reserve0, reserve1, timestamp] = result
- * ```
- *
- * @example
- * ```typescript
- * // Handle errors gracefully
- * const decoded = await Effect.runPromise(
- *   decodeFunctionResult(abi, 'unknownFn', data).pipe(
- *     Effect.catchTag('AbiItemNotFoundError', () =>
- *       Effect.fail(new Error('Function not in ABI'))
- *     )
- *   )
- * )
- * ```
- *
- * @since 0.0.1
- * @see {@link decodeFunctionData} for decoding function calldata
- * @see {@link encodeFunctionData} for encoding function calls
- */
-declare const decodeFunctionResult: (abi: AbiInput$a, functionName: string, data: HexType | Uint8Array) => Effect.Effect<readonly unknown[], AbiItemNotFoundError | AbiDecodingError>;
-
-/**
- * @fileoverview Encodes function call data from ABI by function name.
- * Provides Effect-based wrapper for creating encoded calldata.
- *
- * @module Abi/encodeFunction
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$9 = readonly ItemType[];
-/**
- * Encodes function call data from ABI by function name.
- *
- * @description
- * Creates encoded calldata for invoking a contract function. The result
- * is a hex string consisting of a 4-byte function selector followed by
- * ABI-encoded arguments.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} functionName - The function name to encode.
- * @param {readonly unknown[]} args - The function arguments.
- * @returns {Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding encoded calldata as hex string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeFunction } from 'voltaire-effect/primitives/Abi'
- *
- * const calldata = await Effect.runPromise(
- *   encodeFunction(abi, 'transfer', [to, amount])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encodeFunction: (abi: AbiInput$9, functionName: string, args: readonly unknown[]) => Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview Encodes Ethereum function call data (calldata) using ABI definitions.
- * Provides Effect-based wrapper for creating encoded calldata for contract calls.
- *
- * @module Abi/encodeFunctionData
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input accepted by the encoder.
- * @internal
- */
-type AbiInput$8 = readonly ItemType[];
-/**
- * Encodes function call data using the provided ABI.
- *
- * @description
- * Creates encoded calldata for invoking a contract function. The result
- * is a hex string consisting of a 4-byte function selector followed by
- * ABI-encoded arguments. This calldata can be used directly in a transaction
- * or `eth_call` request.
- *
- * This function never throws exceptions. Instead, it returns an Effect that
- * may fail with typed errors if the function is not found or arguments
- * cannot be encoded.
- *
- * @param {AbiInput} abi - The contract ABI containing function definitions.
- *   Can be a JSON ABI array or parsed ABI object.
- * @param {string} functionName - The name of the function to encode.
- *   Must exactly match a function name in the ABI.
- * @param {readonly unknown[]} args - The function arguments to encode.
- *   Must match the function's input types in order.
- *
- * @returns {Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding encoded calldata as hex string starting with '0x'.
- *   Or failing with:
- *   - `AbiItemNotFoundError`: Function not found in ABI
- *   - `AbiEncodingError`: Failed to encode the arguments
- *
- * @throws {AbiItemNotFoundError} When the function name is not found in the ABI.
- * @throws {AbiEncodingError} When argument encoding fails (wrong types, invalid values).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeFunctionData } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'function',
- *     name: 'transfer',
- *     inputs: [
- *       { name: 'to', type: 'address' },
- *       { name: 'amount', type: 'uint256' }
- *     ],
- *     outputs: [{ type: 'bool' }]
- *   }
- * ]
- *
- * // Encode a transfer call
- * const calldata = await Effect.runPromise(
- *   encodeFunctionData(erc20Abi, 'transfer', [
- *     '0x742d35Cc6634C0532925a3b844Bc9e7595f251e3',
- *     1000000000000000000n // 1 token
- *   ])
- * )
- * // Returns: 0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc9e7595f251e3...
- * ```
- *
- * @example
- * ```typescript
- * // Handle encoding errors
- * const calldata = await Effect.runPromise(
- *   encodeFunctionData(abi, 'unknownFn', []).pipe(
- *     Effect.catchTag('AbiItemNotFoundError', () =>
- *       Effect.fail(new Error('Function not found'))
- *     ),
- *     Effect.catchTag('AbiEncodingError', (e) =>
- *       Effect.fail(new Error(`Encoding failed: ${e.message}`))
- *     )
- *   )
- * )
- * ```
- *
- * @example
- * ```typescript
- * // Use with transaction sending
- * const calldata = await Effect.runPromise(
- *   encodeFunctionData(abi, 'approve', [spender, amount])
- * )
- * const tx = { to: tokenAddress, data: calldata }
- * ```
- *
- * @since 0.0.1
- * @see {@link decodeFunctionData} for decoding function calldata
- * @see {@link decodeFunctionResult} for decoding return values
- * @see {@link getFunction} for retrieving function definitions by name
- */
-declare const encodeFunctionData: (abi: AbiInput$8, functionName: string, args: readonly unknown[]) => Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview Encodes function return values.
- * Provides Effect-based wrapper for encoding function output data.
- *
- * @module Abi/encodeFunctionResult
- * @since 0.0.1
- */
-
-/**
- * Represents a single ABI item.
- * @internal
- */
-type AbiItem = {
-    type: string;
-    name?: string;
-};
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$7 = readonly AbiItem[];
-/**
- * Encodes function return values.
- *
- * @description
- * Encodes values as function return data according to the function's
- * output specification in the ABI.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} functionName - The function name.
- * @param {readonly unknown[]} values - The values to encode.
- * @returns {Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>}
- *   Effect yielding the encoded return data.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { encodeFunctionResult } from 'voltaire-effect/primitives/Abi'
- *
- * const encoded = await Effect.runPromise(
- *   encodeFunctionResult(abi, 'balanceOf', [1000n])
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const encodeFunctionResult: (abi: AbiInput$7, functionName: string, values: readonly unknown[]) => Effect.Effect<HexType, AbiItemNotFoundError | AbiEncodingError>;
-
-/**
- * @fileoverview Finds an error in an ABI by name.
- * Provides Effect-based wrapper for looking up errors.
- *
- * @module Abi/findError
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$6 = readonly ItemType[];
-/**
- * Finds an error in an ABI by name.
- *
- * @description
- * Searches the ABI for an error with the given name.
- * Returns the error definition or undefined if not found.
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} name - The error name to find.
- * @returns {Effect.Effect<AbiError.ErrorType | undefined, never>}
- *   Effect yielding the error or undefined.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { findError } from 'voltaire-effect/primitives/Abi'
- *
- * const err = Effect.runSync(findError(abi, 'InsufficientBalance'))
- * if (err) {
- *   console.log(err.inputs)
- * }
- * ```
- *
- * @since 0.0.1
- */
-declare const findError: (abi: AbiInput$6, name: string) => Effect.Effect<Error$1.ErrorType | undefined, never>;
-
-/**
- * @fileoverview Finds an event in an ABI by name.
- * Provides Effect-based wrapper for looking up events.
- *
- * @module Abi/findEvent
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$5 = readonly ItemType[];
-/**
- * Finds an event in an ABI by name.
- *
- * @description
- * Searches the ABI for an event with the given name.
- * Returns the event definition or undefined if not found.
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} name - The event name to find.
- * @returns {Effect.Effect<Event.EventType | undefined, never>}
- *   Effect yielding the event or undefined.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { findEvent } from 'voltaire-effect/primitives/Abi'
- *
- * const evt = Effect.runSync(findEvent(abi, 'Transfer'))
- * if (evt) {
- *   console.log(evt.inputs)
- * }
- * ```
- *
- * @since 0.0.1
- */
-declare const findEvent: (abi: AbiInput$5, name: string) => Effect.Effect<Event.EventType | undefined, never>;
-
-/**
- * @fileoverview Finds a function in an ABI by name.
- * Provides Effect-based wrapper for looking up functions.
- *
- * @module Abi/findFunction
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input.
- * @internal
- */
-type AbiInput$4 = readonly ItemType[];
-/**
- * Finds a function in an ABI by name.
- *
- * @description
- * Searches the ABI for a function with the given name.
- * Returns the function definition or undefined if not found.
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {string} name - The function name to find.
- * @returns {Effect.Effect<AbiFunction.FunctionType | undefined, never>}
- *   Effect yielding the function or undefined.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { findFunction } from 'voltaire-effect/primitives/Abi'
- *
- * const fn = Effect.runSync(findFunction(abi, 'transfer'))
- * if (fn) {
- *   console.log(fn.inputs)
- * }
- * ```
- *
- * @since 0.0.1
- */
-declare const findFunction: (abi: AbiInput$4, name: string) => Effect.Effect<Function.FunctionType | undefined, never>;
-
-/**
- * @fileoverview Finds function selector collisions in an ABI.
- * Provides Effect-based wrapper for collision detection.
- *
- * @module Abi/findSelectorCollisions
- * @since 0.0.1
- */
-
-type AbiInput$3 = readonly ItemType[];
-/**
- * Selector collision information.
- */
-interface SelectorCollision {
-    selector: HexType;
-    functions: readonly ItemType[];
-}
-/**
- * Finds function selector collisions in an ABI.
- *
- * @description
- * Detects when multiple functions in an ABI share the same 4-byte selector.
- * This can happen due to the birthday paradox with 4-byte hashes.
- *
- * @param {AbiInput} abi - The contract ABI to check.
- * @returns {Effect.Effect<readonly SelectorCollision[], never>}
- *   Effect yielding array of collisions (empty if none).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { findSelectorCollisions } from 'voltaire-effect/primitives/Abi'
- *
- * const collisions = await Effect.runPromise(
- *   findSelectorCollisions(abi)
- * )
- * if (collisions.length > 0) {
- *   console.warn('Selector collisions detected:', collisions)
- * }
- * ```
- *
- * @since 0.0.1
- */
-declare const findSelectorCollisions: (abi: AbiInput$3) => Effect.Effect<readonly SelectorCollision[], never>;
-/**
- * Checks if an ABI has any function selector collisions.
- *
- * @description
- * Quick check for the presence of selector collisions.
- *
- * @param {AbiInput} abi - The contract ABI to check.
- * @returns {Effect.Effect<boolean, never>}
- *   Effect yielding true if collisions exist.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { hasSelectorCollisions } from 'voltaire-effect/primitives/Abi'
- *
- * const hasCollisions = await Effect.runPromise(
- *   hasSelectorCollisions(abi)
- * )
- * ```
- *
- * @since 0.0.1
- */
-declare const hasSelectorCollisions: (abi: AbiInput$3) => Effect.Effect<boolean, never>;
-
-/**
- * @fileoverview Formats ABI item as human-readable string.
- * Provides Effect-based wrapper for ABI formatting.
- *
- * @module Abi/format
- * @since 0.0.1
- */
-
-/**
- * Formats an ABI item as a human-readable string.
- *
- * @description
- * Converts an ABI item to its canonical human-readable representation,
- * e.g., "function transfer(address to, uint256 amount) returns (bool)".
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {object} item - The ABI item to format.
- * @returns {Effect.Effect<string, never>}
- *   Effect yielding the formatted string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { format } from 'voltaire-effect/primitives/Abi'
- *
- * const fn = { type: 'function', name: 'transfer', inputs: [...], outputs: [...] }
- * const formatted = Effect.runSync(format(fn))
- * // 'function transfer(address to, uint256 amount) returns (bool)'
- * ```
- *
- * @since 0.0.1
- */
-declare const format: (item: Parameters<typeof Item$1.format>[0]) => Effect.Effect<string, never>;
-
-/**
- * @fileoverview Formats ABI item with argument values.
- * Provides Effect-based wrapper for ABI formatting with args.
- *
- * @module Abi/formatWithArgs
- * @since 0.0.1
- */
-
-/**
- * Formats an ABI item with argument values.
- *
- * @description
- * Converts an ABI item to its human-readable representation with
- * actual argument values substituted, e.g.,
- * "function transfer(0x123..., 1000)".
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {object} item - The ABI item to format.
- * @param {readonly unknown[]} args - The argument values.
- * @returns {Effect.Effect<string, never>}
- *   Effect yielding the formatted string with args.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { formatWithArgs } from 'voltaire-effect/primitives/Abi'
- *
- * const fn = { type: 'function', name: 'transfer', inputs: [...] }
- * const formatted = Effect.runSync(formatWithArgs(fn, ['0x123...', 1000n]))
- * // 'function transfer(0x123..., 1000)'
- * ```
- *
- * @since 0.0.1
- */
-declare const formatWithArgs: (item: Parameters<typeof Item$1.formatWithArgs>[0], args: readonly unknown[]) => Effect.Effect<string, never>;
-
-/**
- * @fileoverview Gets the canonical signature of an error.
- * Provides Effect-based wrapper for getting error signatures.
- *
- * @module Abi/getErrorSignature
- * @since 0.0.1
- */
-
-/**
- * Gets the canonical signature of an error.
- *
- * @description
- * Returns the canonical string representation of an error signature,
- * e.g., "InsufficientBalance(uint256)".
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {AbiError.ErrorType} error - The error ABI item.
- * @returns {Effect.Effect<string, never>}
- *   Effect yielding the error signature string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getErrorSignature } from 'voltaire-effect/primitives/Abi'
- *
- * const err = { type: 'error', name: 'InsufficientBalance', inputs: [...] }
- * const sig = Effect.runSync(getErrorSignature(err))
- * // 'InsufficientBalance(uint256)'
- * ```
- *
- * @since 0.0.1
- */
-declare const getErrorSignature: (error: Error$1.ErrorType) => Effect.Effect<string, never>;
-
-/**
- * @fileoverview Retrieves event definitions from Ethereum ABI.
- * Provides Effect-based wrapper for looking up event ABI items by name.
- *
- * @module Abi/getEvent
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input accepted by the lookup function.
- * @internal
- */
-type AbiInput$2 = readonly ItemType[];
-/**
- * Retrieves an event definition from an ABI by name.
- *
- * @description
- * Looks up an event in the provided ABI by its name and returns the full
- * event definition including input parameters, indexed flags, and other
- * metadata. This is useful for programmatically working with events,
- * such as building log filters or decoding event parameters.
- *
- * This function never throws exceptions. Instead, it returns an Effect
- * that may fail with `AbiItemNotFoundError` if no event with the given
- * name exists in the ABI.
- *
- * @param {AbiInput} abi - The contract ABI containing event definitions.
- *   Can be a JSON ABI array or parsed ABI object.
- * @param {string} name - The name of the event to retrieve.
- *   Must exactly match an event name in the ABI (case-sensitive).
- *
- * @returns {Effect.Effect<AbiEvent.EventType, AbiItemNotFoundError>}
- *   Effect yielding the event definition object containing:
- *   - `type`: 'event'
- *   - `name`: The event name
- *   - `inputs`: Array of input parameters with types and indexed flags
- *   Or failing with `AbiItemNotFoundError` if event not found.
- *
- * @throws {AbiItemNotFoundError} When no event with the given name exists in the ABI.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getEvent } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'event',
- *     name: 'Transfer',
- *     inputs: [
- *       { name: 'from', type: 'address', indexed: true },
- *       { name: 'to', type: 'address', indexed: true },
- *       { name: 'value', type: 'uint256', indexed: false }
- *     ]
- *   }
- * ]
- *
- * const transferEvent = await Effect.runPromise(getEvent(erc20Abi, 'Transfer'))
- * console.log(transferEvent.inputs)
- * // [{ name: 'from', type: 'address', indexed: true }, ...]
- * ```
- *
- * @example
- * ```typescript
- * // Build a log filter from event definition
- * const event = await Effect.runPromise(getEvent(abi, 'Transfer'))
- * const signature = keccak256(
- *   `${event.name}(${event.inputs.map(i => i.type).join(',')})`
- * )
- * ```
- *
- * @example
- * ```typescript
- * // Handle missing events
- * const event = await Effect.runPromise(
- *   getEvent(abi, 'MaybeEvent').pipe(
- *     Effect.catchTag('AbiItemNotFoundError', () =>
- *       Effect.succeed(null)
- *     )
- *   )
- * )
- * ```
- *
- * @since 0.0.1
- * @see {@link decodeEventLog} for decoding event log data
- * @see {@link getFunction} for retrieving function definitions
- */
-declare const getEvent: (abi: AbiInput$2, name: string) => Effect.Effect<Event.EventType, AbiItemNotFoundError>;
-
-/**
- * @fileoverview Gets the canonical signature of an event.
- * Provides Effect-based wrapper for getting event signatures.
- *
- * @module Abi/getEventSignature
- * @since 0.0.1
- */
-
-/**
- * Gets the canonical signature of an event.
- *
- * @description
- * Returns the canonical string representation of an event signature,
- * e.g., "Transfer(address,address,uint256)".
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {Event.EventType} event - The event ABI item.
- * @returns {Effect.Effect<string, never>}
- *   Effect yielding the event signature string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getEventSignature } from 'voltaire-effect/primitives/Abi'
- *
- * const evt = { type: 'event', name: 'Transfer', inputs: [...] }
- * const sig = Effect.runSync(getEventSignature(evt))
- * // 'Transfer(address,address,uint256)'
- * ```
- *
- * @since 0.0.1
- */
-declare const getEventSignature: (event: Event.EventType) => Effect.Effect<string, never>;
-
-/**
- * @fileoverview Retrieves function definitions from Ethereum ABI.
- * Provides Effect-based wrapper for looking up function ABI items by name.
- *
- * @module Abi/getFunction
- * @since 0.0.1
- */
-
-/**
- * Type alias for ABI input accepted by the lookup function.
- * @internal
- */
-type AbiInput$1 = readonly ItemType[];
-/**
- * Retrieves a function definition from an ABI by name.
- *
- * @description
- * Looks up a function in the provided ABI by its name and returns the full
- * function definition including input parameters, output parameters, and
- * state mutability. This is useful for programmatically working with functions,
- * such as building transaction data or validating call parameters.
- *
- * This function never throws exceptions. Instead, it returns an Effect
- * that may fail with `AbiItemNotFoundError` if no function with the given
- * name exists in the ABI.
- *
- * @param {AbiInput} abi - The contract ABI containing function definitions.
- *   Can be a JSON ABI array or parsed ABI object.
- * @param {string} name - The name of the function to retrieve.
- *   Must exactly match a function name in the ABI (case-sensitive).
- *
- * @returns {Effect.Effect<AbiFunction.FunctionType, AbiItemNotFoundError>}
- *   Effect yielding the function definition object containing:
- *   - `type`: 'function'
- *   - `name`: The function name
- *   - `inputs`: Array of input parameter definitions
- *   - `outputs`: Array of output parameter definitions
- *   - `stateMutability`: 'pure' | 'view' | 'nonpayable' | 'payable'
- *   Or failing with `AbiItemNotFoundError` if function not found.
- *
- * @throws {AbiItemNotFoundError} When no function with the given name exists in the ABI.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getFunction } from 'voltaire-effect/primitives/Abi'
- *
- * const erc20Abi = [
- *   {
- *     type: 'function',
- *     name: 'transfer',
- *     inputs: [
- *       { name: 'to', type: 'address' },
- *       { name: 'amount', type: 'uint256' }
- *     ],
- *     outputs: [{ type: 'bool' }],
- *     stateMutability: 'nonpayable'
- *   }
- * ]
- *
- * const transferFn = await Effect.runPromise(getFunction(erc20Abi, 'transfer'))
- * console.log(transferFn.inputs)  // [{ name: 'to', type: 'address' }, ...]
- * console.log(transferFn.outputs) // [{ type: 'bool' }]
- * ```
- *
- * @example
- * ```typescript
- * // Check if function is view/pure (read-only)
- * const fn = await Effect.runPromise(getFunction(abi, 'balanceOf'))
- * const isReadOnly = fn.stateMutability === 'view' || fn.stateMutability === 'pure'
- * ```
- *
- * @example
- * ```typescript
- * // Handle missing functions
- * const fn = await Effect.runPromise(
- *   getFunction(abi, 'maybeExists').pipe(
- *     Effect.catchTag('AbiItemNotFoundError', () =>
- *       Effect.succeed(null)
- *     )
- *   )
- * )
- * ```
- *
- * @since 0.0.1
- * @see {@link encodeFunctionData} for encoding function calls
- * @see {@link decodeFunctionData} for decoding function calldata
- * @see {@link decodeFunctionResult} for decoding function return values
- * @see {@link getEvent} for retrieving event definitions
- */
-declare const getFunction: (abi: AbiInput$1, name: string) => Effect.Effect<Function.FunctionType, AbiItemNotFoundError>;
-
-/**
- * @fileoverview Gets the canonical signature of a function.
- * Provides Effect-based wrapper for getting function signatures.
- *
- * @module Abi/getFunctionSignature
- * @since 0.0.1
- */
-
-/**
- * Gets the canonical signature of a function.
- *
- * @description
- * Returns the canonical string representation of a function signature,
- * e.g., "transfer(address,uint256)".
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {AbiFunction.FunctionType} fn - The function ABI item.
- * @returns {Effect.Effect<string, never>}
- *   Effect yielding the function signature string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getFunctionSignature } from 'voltaire-effect/primitives/Abi'
- *
- * const fn = { type: 'function', name: 'transfer', inputs: [...] }
- * const sig = Effect.runSync(getFunctionSignature(fn))
- * // 'transfer(address,uint256)'
- * ```
- *
- * @since 0.0.1
- */
-declare const getFunctionSignature: (fn: Function.FunctionType) => Effect.Effect<string, never>;
-
-/**
- * @fileoverview Gets function/event/error selector.
- * Provides Effect-based wrapper for computing selectors.
- *
- * @module Abi/getSelector
- * @since 0.0.1
- */
-
-/**
- * Gets the selector for a function, event, or error ABI item.
- *
- * @description
- * Computes the selector (first 4 bytes of keccak256 for functions/errors,
- * full 32 bytes for events) from an ABI item.
- *
- * This is an infallible operation that always succeeds.
- *
- * @param {object} item - The ABI item (function, event, or error).
- * @returns {Effect.Effect<HexType, never>}
- *   Effect yielding the selector as hex string.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { getSelector } from 'voltaire-effect/primitives/Abi'
- *
- * const fn = { type: 'function', name: 'transfer', inputs: [...] }
- * const selector = Effect.runSync(getSelector(fn))
- * // '0xa9059cbb'
- * ```
- *
- * @since 0.0.1
- */
-declare const getSelector: (item: {
-    type: string;
-    name?: string;
-    inputs?: readonly unknown[];
-}) => Effect.Effect<HexType, never>;
-
-declare const AbiParseError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "AbiParseError";
-} & Readonly<A>;
-/**
- * Error thrown when JSON parsing fails.
- */
-declare class AbiParseError extends AbiParseError_base<{
-    readonly message: string;
-    readonly code?: number;
-    readonly context?: Record<string, unknown>;
-    readonly cause?: unknown;
-}> {
-}
-/**
- * Parses a JSON string to an ABI array.
- *
- * @description
- * Parses a JSON string representing an Ethereum ABI into a structured
- * ABI array that can be used with other ABI functions.
- *
- * @param {string} jsonString - The JSON string to parse.
- * @returns {Effect.Effect<ReturnType<typeof Abi>, AbiParseError>}
- *   Effect yielding the parsed ABI array.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { parse } from 'voltaire-effect/primitives/Abi'
- *
- * const abiJson = '[{"type":"function","name":"transfer",...}]'
- * const abi = await Effect.runPromise(parse(abiJson))
- * ```
- *
- * @since 0.0.1
- */
-declare const parse: (jsonString: string) => Effect.Effect<ReturnType<typeof Abi$1>, AbiParseError>;
-
-declare const AbiItemParseError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "AbiItemParseError";
-} & Readonly<A>;
-/**
- * Error thrown when ABI item parsing fails.
- */
-declare class AbiItemParseError extends AbiItemParseError_base<{
-    readonly message: string;
-    readonly code?: number;
-    readonly context?: Record<string, unknown>;
-    readonly cause?: unknown;
-}> {
-}
-/**
- * Parses a JSON string to a single ABI item.
- *
- * @description
- * Parses a JSON string representing a single Ethereum ABI item (function,
- * event, error, etc.) into a structured ABI item object.
- *
- * @param {string} jsonString - The JSON string to parse.
- * @returns {Effect.Effect<Item.ItemType, AbiItemParseError>}
- *   Effect yielding the parsed ABI item.
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { parseItem } from 'voltaire-effect/primitives/Abi'
- *
- * const itemJson = '{"type":"function","name":"transfer","inputs":[],"outputs":[]}'
- * const item = await Effect.runPromise(parseItem(itemJson))
- * ```
- *
- * @since 0.0.1
- */
-declare const parseItem: (jsonString: string) => Effect.Effect<Item$1.ItemType, AbiItemParseError>;
-
-/**
- * @fileoverview Parses multiple event logs using ABI.
- * Provides Effect-based wrapper for batch log parsing.
- *
- * @module Abi/parseLogs
- * @since 0.0.1
- */
-
-type AbiInput = readonly ItemType[];
-/**
- * Log input structure for parseLogs.
- */
-interface ParseLogsInput {
-    data: Uint8Array | string;
-    topics: readonly (Uint8Array | string)[];
-}
-/**
- * Parsed log result.
- */
-interface ParsedLog {
-    eventName: string;
-    args: Record<string, unknown>;
-}
-/**
- * Parses multiple event logs using ABI.
- *
- * @description
- * Parses an array of log entries, returning successfully decoded logs.
- * Logs that don't match any event in the ABI are silently filtered out.
- *
- * @param {AbiInput} abi - The contract ABI.
- * @param {readonly ParseLogsInput[]} logs - Array of log objects.
- * @returns {Effect.Effect<readonly ParsedLog[], never>}
- *   Effect yielding array of parsed logs (never fails).
- *
- * @example
- * ```typescript
- * import * as Effect from 'effect/Effect'
- * import { parseLogs } from 'voltaire-effect/primitives/Abi'
- *
- * const parsed = await Effect.runPromise(
- *   parseLogs(abi, logs)
- * )
- * // [{ eventName: 'Transfer', args: { from, to, value } }]
- * ```
- *
- * @since 0.0.1
- */
-declare const parseLogs: (abi: AbiInput, logs: readonly ParseLogsInput[]) => Effect.Effect<readonly ParsedLog[], never>;
-
-/**
- * @fileoverview Abi module for encoding and decoding Ethereum ABI data.
- * Provides Effect-based wrappers around voltaire's ABI utilities with
- * type-safe error handling through Effect's error channel.
- *
- * @module Abi
- * @since 0.0.1
- */
-
-type index$2_AbiItemParseError = AbiItemParseError;
-declare const index$2_AbiItemParseError: typeof AbiItemParseError;
-type index$2_AbiParseError = AbiParseError;
-declare const index$2_AbiParseError: typeof AbiParseError;
-declare const index$2_AbiSchema: typeof AbiSchema;
-declare const index$2_AbiTypeSchema: typeof AbiTypeSchema;
-declare const index$2_ConstructorSchema: typeof ConstructorSchema;
-declare const index$2_ErrorSchema: typeof ErrorSchema;
-declare const index$2_EventSchema: typeof EventSchema;
-declare const index$2_FallbackSchema: typeof FallbackSchema;
-declare const index$2_FunctionSchema: typeof FunctionSchema;
-declare const index$2_ItemSchema: typeof ItemSchema;
-declare const index$2_ParameterSchema: typeof ParameterSchema;
-type index$2_ParseLogsInput = ParseLogsInput;
-type index$2_ParsedLog = ParsedLog;
-declare const index$2_ReceiveSchema: typeof ReceiveSchema;
-type index$2_SelectorCollision = SelectorCollision;
-declare const index$2_StateMutabilitySchema: typeof StateMutabilitySchema;
-type index$2_WrappedErrorInput = WrappedErrorInput;
-type index$2_WrappedErrorResult = WrappedErrorResult;
-declare const index$2_decode: typeof decode;
-declare const index$2_decodeData: typeof decodeData;
-declare const index$2_decodeError: typeof decodeError;
-declare const index$2_decodeEventLog: typeof decodeEventLog;
-declare const index$2_decodeFunction: typeof decodeFunction;
-declare const index$2_decodeFunctionData: typeof decodeFunctionData;
-declare const index$2_decodeFunctionResult: typeof decodeFunctionResult;
-declare const index$2_decodeLog: typeof decodeLog;
-declare const index$2_decodeWrappedError: typeof decodeWrappedError;
-declare const index$2_encode: typeof encode;
-declare const index$2_encodeError: typeof encodeError;
-declare const index$2_encodeEventLog: typeof encodeEventLog;
-declare const index$2_encodeFunction: typeof encodeFunction;
-declare const index$2_encodeFunctionData: typeof encodeFunctionData;
-declare const index$2_encodeFunctionResult: typeof encodeFunctionResult;
-declare const index$2_encodePacked: typeof encodePacked;
-declare const index$2_encodeWrappedError: typeof encodeWrappedError;
-declare const index$2_findError: typeof findError;
-declare const index$2_findEvent: typeof findEvent;
-declare const index$2_findFunction: typeof findFunction;
-declare const index$2_findSelectorCollisions: typeof findSelectorCollisions;
-declare const index$2_format: typeof format;
-declare const index$2_formatWithArgs: typeof formatWithArgs;
-declare const index$2_fromArray: typeof fromArray;
-declare const index$2_getErrorSignature: typeof getErrorSignature;
-declare const index$2_getEvent: typeof getEvent;
-declare const index$2_getEventSignature: typeof getEventSignature;
-declare const index$2_getFunction: typeof getFunction;
-declare const index$2_getFunctionSignature: typeof getFunctionSignature;
-declare const index$2_getSelector: typeof getSelector;
-declare const index$2_hasSelectorCollisions: typeof hasSelectorCollisions;
-declare const index$2_parse: typeof parse;
-declare const index$2_parseItem: typeof parseItem;
-declare const index$2_parseLogs: typeof parseLogs;
+declare const index$2_BatchRequest: typeof BatchRequest;
+type index$2_BatchRequestType = BatchRequestType;
+declare const index$2_BatchResponse: typeof BatchResponse;
+type index$2_BatchResponseType = BatchResponseType;
+declare const index$2_CHAIN_DISCONNECTED: typeof CHAIN_DISCONNECTED;
+type index$2_ChainDisconnectedError = ChainDisconnectedError;
+declare const index$2_ChainDisconnectedError: typeof ChainDisconnectedError;
+declare const index$2_DISCONNECTED: typeof DISCONNECTED;
+type index$2_DisconnectedError = DisconnectedError;
+declare const index$2_DisconnectedError: typeof DisconnectedError;
+declare const index$2_EXECUTION_REVERTED: typeof EXECUTION_REVERTED;
+type index$2_ExecutionRevertedError = ExecutionRevertedError;
+declare const index$2_ExecutionRevertedError: typeof ExecutionRevertedError;
+declare const index$2_INSUFFICIENT_FUNDS: typeof INSUFFICIENT_FUNDS;
+declare const index$2_INTERNAL_ERROR: typeof INTERNAL_ERROR;
+declare const index$2_INVALID_INPUT: typeof INVALID_INPUT;
+declare const index$2_INVALID_PARAMS: typeof INVALID_PARAMS;
+declare const index$2_INVALID_REQUEST: typeof INVALID_REQUEST;
+declare const index$2_IdCounterLive: typeof IdCounterLive;
+type index$2_IdCounterService = IdCounterService;
+declare const index$2_IdCounterService: typeof IdCounterService;
+type index$2_InsufficientFundsError = InsufficientFundsError;
+declare const index$2_InsufficientFundsError: typeof InsufficientFundsError;
+type index$2_InternalError = InternalError;
+declare const index$2_InternalError: typeof InternalError;
+type index$2_InvalidInputError = InvalidInputError;
+declare const index$2_InvalidInputError: typeof InvalidInputError;
+type index$2_InvalidParamsError = InvalidParamsError;
+declare const index$2_InvalidParamsError: typeof InvalidParamsError;
+type index$2_InvalidRequestError = InvalidRequestError;
+declare const index$2_InvalidRequestError: typeof InvalidRequestError;
+declare const index$2_JSON_RPC_VERSION_NOT_SUPPORTED: typeof JSON_RPC_VERSION_NOT_SUPPORTED;
+declare const index$2_JsonRpcError: typeof JsonRpcError;
+type index$2_JsonRpcErrorResponse = JsonRpcErrorResponse;
+declare const index$2_JsonRpcErrorResponse: typeof JsonRpcErrorResponse;
+type index$2_JsonRpcIdType = JsonRpcIdType;
+type index$2_JsonRpcParseError = JsonRpcParseError;
+declare const index$2_JsonRpcParseError: typeof JsonRpcParseError;
+type index$2_JsonRpcRequestType<TParams = unknown[]> = JsonRpcRequestType<TParams>;
+type index$2_JsonRpcResponseType<TResult = unknown> = JsonRpcResponseType<TResult>;
+type index$2_JsonRpcSuccessResponseType<TResult = unknown> = JsonRpcSuccessResponseType<TResult>;
+declare const index$2_LIMIT_EXCEEDED: typeof LIMIT_EXCEEDED;
+type index$2_LimitExceededError = LimitExceededError;
+declare const index$2_LimitExceededError: typeof LimitExceededError;
+declare const index$2_METHOD_NOT_FOUND: typeof METHOD_NOT_FOUND;
+declare const index$2_METHOD_NOT_SUPPORTED: typeof METHOD_NOT_SUPPORTED;
+type index$2_MethodNotFoundError = MethodNotFoundError;
+declare const index$2_MethodNotFoundError: typeof MethodNotFoundError;
+type index$2_MethodNotSupportedError = MethodNotSupportedError;
+declare const index$2_MethodNotSupportedError: typeof MethodNotSupportedError;
+declare const index$2_NONCE_TOO_HIGH: typeof NONCE_TOO_HIGH;
+declare const index$2_NONCE_TOO_LOW: typeof NONCE_TOO_LOW;
+type index$2_NonceTooHighError = NonceTooHighError;
+declare const index$2_NonceTooHighError: typeof NonceTooHighError;
+type index$2_NonceTooLowError = NonceTooLowError;
+declare const index$2_NonceTooLowError: typeof NonceTooLowError;
+declare const index$2_PARSE_ERROR: typeof PARSE_ERROR;
+type index$2_ParseError = ParseError;
+declare const index$2_ParseError: typeof ParseError;
+declare const index$2_RESOURCE_NOT_FOUND: typeof RESOURCE_NOT_FOUND;
+declare const index$2_RESOURCE_UNAVAILABLE: typeof RESOURCE_UNAVAILABLE;
+declare const index$2_Request: typeof Request;
+type index$2_ResourceNotFoundError = ResourceNotFoundError;
+declare const index$2_ResourceNotFoundError: typeof ResourceNotFoundError;
+type index$2_ResourceUnavailableError = ResourceUnavailableError;
+declare const index$2_ResourceUnavailableError: typeof ResourceUnavailableError;
+declare const index$2_Response: typeof Response;
+type index$2_RpcError = RpcError;
+type index$2_RpcErrorCode = RpcErrorCode;
+declare const index$2_TRANSACTION_REJECTED: typeof TRANSACTION_REJECTED;
+type index$2_TransactionRejectedError = TransactionRejectedError;
+declare const index$2_TransactionRejectedError: typeof TransactionRejectedError;
+declare const index$2_UNAUTHORIZED: typeof UNAUTHORIZED;
+declare const index$2_UNSUPPORTED_METHOD: typeof UNSUPPORTED_METHOD;
+declare const index$2_USER_REJECTED_REQUEST: typeof USER_REJECTED_REQUEST;
+type index$2_UnauthorizedError = UnauthorizedError;
+declare const index$2_UnauthorizedError: typeof UnauthorizedError;
+type index$2_UnsupportedMethodError = UnsupportedMethodError;
+declare const index$2_UnsupportedMethodError: typeof UnsupportedMethodError;
+type index$2_UserRejectedRequestError = UserRejectedRequestError;
+declare const index$2_UserRejectedRequestError: typeof UserRejectedRequestError;
+declare const index$2_findById: typeof findById;
+declare const index$2_isDisconnected: typeof isDisconnected;
+declare const index$2_isError: typeof isError;
+declare const index$2_isExecutionReverted: typeof isExecutionReverted;
+declare const index$2_isInsufficientFunds: typeof isInsufficientFunds;
+declare const index$2_isNonceError: typeof isNonceError;
+declare const index$2_isNotification: typeof isNotification;
+declare const index$2_isProviderError: typeof isProviderError;
+declare const index$2_isSuccess: typeof isSuccess;
+declare const index$2_isUserRejected: typeof isUserRejected;
+declare const index$2_parseErrorCode: typeof parseErrorCode;
+declare const index$2_unwrap: typeof unwrap;
+declare const index$2_withParams: typeof withParams;
 declare namespace index$2 {
-  export { index$2_AbiItemParseError as AbiItemParseError, index$2_AbiParseError as AbiParseError, index$2_AbiSchema as AbiSchema, index$2_AbiTypeSchema as AbiTypeSchema, index$2_ConstructorSchema as ConstructorSchema, index$2_ErrorSchema as ErrorSchema, index$2_EventSchema as EventSchema, index$2_FallbackSchema as FallbackSchema, index$2_FunctionSchema as FunctionSchema, index$2_ItemSchema as ItemSchema, type LogInput$1 as LogInput, index$2_ParameterSchema as ParameterSchema, type index$2_ParseLogsInput as ParseLogsInput, type index$2_ParsedLog as ParsedLog, index$2_ReceiveSchema as ReceiveSchema, type index$2_SelectorCollision as SelectorCollision, index$2_StateMutabilitySchema as StateMutabilitySchema, type index$2_WrappedErrorInput as WrappedErrorInput, type index$2_WrappedErrorResult as WrappedErrorResult, index$2_decode as decode, index$2_decodeData as decodeData, index$2_decodeError as decodeError, index$2_decodeEventLog as decodeEventLog, index$2_decodeFunction as decodeFunction, index$2_decodeFunctionData as decodeFunctionData, index$2_decodeFunctionResult as decodeFunctionResult, index$2_decodeLog as decodeLog, index$2_decodeWrappedError as decodeWrappedError, index$2_encode as encode, index$2_encodeError as encodeError, index$2_encodeEventLog as encodeEventLog, index$2_encodeFunction as encodeFunction, index$2_encodeFunctionData as encodeFunctionData, index$2_encodeFunctionResult as encodeFunctionResult, index$2_encodePacked as encodePacked, index$2_encodeWrappedError as encodeWrappedError, index$2_findError as findError, index$2_findEvent as findEvent, index$2_findFunction as findFunction, index$2_findSelectorCollisions as findSelectorCollisions, index$2_format as format, index$2_formatWithArgs as formatWithArgs, index$2_fromArray as fromArray, index$2_getErrorSignature as getErrorSignature, index$2_getEvent as getEvent, index$2_getEventSignature as getEventSignature, index$2_getFunction as getFunction, index$2_getFunctionSignature as getFunctionSignature, index$2_getSelector as getSelector, index$2_hasSelectorCollisions as hasSelectorCollisions, index$2_parse as parse, index$2_parseItem as parseItem, index$2_parseLogs as parseLogs };
+  export { Anvil$1 as Anvil, index$2_BatchRequest as BatchRequest, type index$2_BatchRequestType as BatchRequestType, index$2_BatchResponse as BatchResponse, type index$2_BatchResponseType as BatchResponseType, index$2_CHAIN_DISCONNECTED as CHAIN_DISCONNECTED, index$2_ChainDisconnectedError as ChainDisconnectedError, index$2_DISCONNECTED as DISCONNECTED, index$2_DisconnectedError as DisconnectedError, index$2_EXECUTION_REVERTED as EXECUTION_REVERTED, Eth$1 as Eth, index$2_ExecutionRevertedError as ExecutionRevertedError, Hardhat$1 as Hardhat, index$2_INSUFFICIENT_FUNDS as INSUFFICIENT_FUNDS, index$2_INTERNAL_ERROR as INTERNAL_ERROR, index$2_INVALID_INPUT as INVALID_INPUT, index$2_INVALID_PARAMS as INVALID_PARAMS, index$2_INVALID_REQUEST as INVALID_REQUEST, index$2_IdCounterLive as IdCounterLive, index$2_IdCounterService as IdCounterService, index$2_InsufficientFundsError as InsufficientFundsError, index$2_InternalError as InternalError, index$2_InvalidInputError as InvalidInputError, index$2_InvalidParamsError as InvalidParamsError, index$2_InvalidRequestError as InvalidRequestError, index$2_JSON_RPC_VERSION_NOT_SUPPORTED as JSON_RPC_VERSION_NOT_SUPPORTED, index$2_JsonRpcError as JsonRpcError, index$2_JsonRpcErrorResponse as JsonRpcErrorResponse, type JsonRpcErrorResponseType$1 as JsonRpcErrorResponseType, type JsonRpcErrorType$1 as JsonRpcErrorType, type index$2_JsonRpcIdType as JsonRpcIdType, index$2_JsonRpcParseError as JsonRpcParseError, type index$2_JsonRpcRequestType as JsonRpcRequestType, type index$2_JsonRpcResponseType as JsonRpcResponseType, type index$2_JsonRpcSuccessResponseType as JsonRpcSuccessResponseType, index$2_LIMIT_EXCEEDED as LIMIT_EXCEEDED, index$2_LimitExceededError as LimitExceededError, index$2_METHOD_NOT_FOUND as METHOD_NOT_FOUND, index$2_METHOD_NOT_SUPPORTED as METHOD_NOT_SUPPORTED, index$2_MethodNotFoundError as MethodNotFoundError, index$2_MethodNotSupportedError as MethodNotSupportedError, index$2_NONCE_TOO_HIGH as NONCE_TOO_HIGH, index$2_NONCE_TOO_LOW as NONCE_TOO_LOW, Net$1 as Net, index$2_NonceTooHighError as NonceTooHighError, index$2_NonceTooLowError as NonceTooLowError, index$2_PARSE_ERROR as PARSE_ERROR, index$2_ParseError as ParseError, index$2_RESOURCE_NOT_FOUND as RESOURCE_NOT_FOUND, index$2_RESOURCE_UNAVAILABLE as RESOURCE_UNAVAILABLE, index$2_Request as Request, index$2_ResourceNotFoundError as ResourceNotFoundError, index$2_ResourceUnavailableError as ResourceUnavailableError, index$2_Response as Response, type index$2_RpcError as RpcError, type index$2_RpcErrorCode as RpcErrorCode, index$3 as Schemas, index$2_TRANSACTION_REJECTED as TRANSACTION_REJECTED, index$2_TransactionRejectedError as TransactionRejectedError, Txpool$1 as Txpool, index$2_UNAUTHORIZED as UNAUTHORIZED, index$2_UNSUPPORTED_METHOD as UNSUPPORTED_METHOD, index$2_USER_REJECTED_REQUEST as USER_REJECTED_REQUEST, index$2_UnauthorizedError as UnauthorizedError, index$2_UnsupportedMethodError as UnsupportedMethodError, index$2_UserRejectedRequestError as UserRejectedRequestError, Wallet$1 as Wallet, Web3$1 as Web3, add as batchAdd, errors as batchErrors, from$3 as batchRequestFrom, from as batchResponseFrom, parse as batchResponseParse, results as batchResults, size as batchSize, from$2 as errorFrom, toString as errorToString, index$2_findById as findById, index$2_isDisconnected as isDisconnected, index$2_isError as isError, index$2_isExecutionReverted as isExecutionReverted, index$2_isInsufficientFunds as isInsufficientFunds, index$2_isNonceError as isNonceError, index$2_isNotification as isNotification, index$2_isProviderError as isProviderError, index$2_isSuccess as isSuccess, index$2_isUserRejected as isUserRejected, index$2_parseErrorCode as parseErrorCode, from$4 as requestFrom, from$1 as responseFrom, parse$1 as responseParse, index$2_unwrap as unwrap, index$2_withParams as withParams };
 }
 
 declare const StandardsError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
@@ -14178,4 +12072,4 @@ declare namespace index {
   export { index_UnitError as UnitError, index_formatEther as formatEther, index_formatGwei as formatGwei, index_formatUnits as formatUnits, index_parseEther as parseEther, index_parseGwei as parseGwei, index_parseUnits as parseUnits };
 }
 
-export { index$2 as Abi, index$t as Auth, type BackfillStreamOptions, index$r as Bip39, index$q as Blake2, index$s as BlockUtils, index$p as Bls12381, index$o as Bn254, index$n as ChaCha20Poly1305, index$u as EIP712, ERC1155, ERC165, ERC20, index$l as ERC6492, ERC721, index$m as Ed25519, EventStream, EventStreamError, EventStreamService, type EventStreamShape, index$k as HDWallet, index$j as HMAC, index$3 as JsonRpc, index$h as KZG, index$w as Keccak256, index$i as Keystore, index$g as ModExp, index$f as P256, ProviderService, index$e as Ripemd160, index$d as SHA256, index$v as Secp256k1, StandardsError, index$1 as Stream, TransportService, index as Unit, type WatchStreamOptions, index$c as X25519, makeEventStream };
+export { index$t as Auth, type BackfillStreamOptions, index$r as Bip39, index$q as Blake2, index$s as BlockUtils, index$p as Bls12381, index$o as Bn254, index$n as ChaCha20Poly1305, index$u as EIP712, ERC1155, ERC165, ERC20, index$l as ERC6492, ERC721, index$m as Ed25519, EventStream, EventStreamError, EventStreamService, type EventStreamShape, index$k as HDWallet, index$j as HMAC, index$2 as JsonRpc, index$h as KZG, index$w as Keccak256, index$i as Keystore, index$g as ModExp, index$f as P256, ProviderService, index$e as Ripemd160, index$d as SHA256, index$v as Secp256k1, index$c as Signers, StandardsError, index$1 as Stream, TransportService, index as Unit, type WatchStreamOptions, index$b as X25519, makeEventStream };