voltaire-effect 0.2.23 → 0.2.25

package/dist/index.d.ts

@@ -1,31 +1,37 @@
+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';
 import * as effect_Cause from 'effect/Cause';
 import * as effect_Types from 'effect/Types';
-import { AddressType as AddressType$3 } from '@tevm/voltaire/Address';
 import * as Effect from 'effect/Effect';
 import * as effect_ParseResult from 'effect/ParseResult';
 import { ParseError as ParseError$1 } from 'effect/ParseResult';
 import * as S from 'effect/Schema';
-import { an as KeccakLive, am as KeccakService, as as KeccakServiceShape, ao as KeccakTest, P as ProviderService } from './AccountService-BetXokad.js';
-export { A as AccessListType, B as BackfillBlocksError, f as BlockType, c as BlocksService, d as BlocksShape, C as CallError, g as CallRequest, h as CreateAccessListError, i as CreateBlockFilterError, j as CreateEventFilterError, k as CreatePendingTransactionFilterError, E as EstimateGasError, m as EventsService, n as EventsShape, F as FeeHistoryType, G as GetBalanceError, q as GetBlobBaseFeeError, r as GetBlockError, s as GetBlockNumberError, t as GetBlockTransactionCountError, u as GetChainIdError, v as GetCodeError, w as GetFeeHistoryError, x as GetFilterChangesError, y as GetFilterLogsError, z as GetGasPriceError, D as GetLogsError, H as GetMaxPriorityFeePerGasError, I as GetProofError, J as GetStorageAtError, K as GetTransactionConfirmationsError, L as GetTransactionCountError, M as GetTransactionError, N as GetTransactionReceiptError, O as GetUncleError, R as LogType, S as NetworkService, U as NetworkShape, a as ProviderAccountService, b as ProviderAccountShape, e as ProviderBlockTag, V as ProviderConfirmationsPendingError, W as ProviderError, l as ProviderEventFilter, o as ProviderFilterChanges, p as ProviderFilterId, Q as ProviderLogFilter, X as ProviderNotFoundError, Y as ProviderReceiptPendingError, Z as ProviderResponseError, _ as ProviderShape, $ as ProviderStreamError, a0 as ProviderTimeoutError, a1 as ProviderValidationError, a2 as ReceiptType, a3 as SendRawTransactionError, a4 as SimulateV1BlockResult, a5 as SimulateV1CallResult, a6 as SimulateV1Payload, a7 as SimulateV1Result, a8 as SimulateV2Payload, a9 as SimulateV2Result, aa as SimulationService, ab as SimulationShape, ac as StreamingService, ad as StreamingShape, ae as SyncingStatus, T as TransactionService, af as TransactionShape, ag as TransactionType, al as TransportError, ah as UninstallFilterError, ai as WaitForTransactionReceiptError, aj as WatchBlocksError, ak as WorkResult } from './AccountService-BetXokad.js';
+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 { aO as hash, bs as Secp256k1Live, bt as Secp256k1Test, br as recover, bu as sign, bv as verify, af as EIP712Live, E as EIP712Service, ag as EIP712ServiceShape, ah as EIP712Test, ai as hashDomain, aj as hashStruct, ak as hashTypedData, al as recoverAddress, am as signTypedData, an as verifyTypedData, j as SignatureInput, t as Bip39Live, B as Bip39Service, u as Bip39ServiceShape, v as Bip39Test, bw as MnemonicStrength, bx as WORD_COUNTS, w as generateMnemonic, x as getWordCount, y as mnemonicToSeed, z as mnemonicToSeedSync, D as validateMnemonic, F as Blake2Live, a as Blake2Service, G as Blake2Test, I as hash$1, L as Bls12381Live, b as Bls12381Service, M as Bls12381ServiceShape, J as aggregate, N as sign$1, O as verify$1, Q as Bn254Error, T as Bn254Live, c as Bn254Service, U as Bn254ServiceShape, W as Bn254Test, X as g1Add, Y as g1Generator, Z as g1Mul, _ as g2Add, $ as g2Generator, a0 as g2Mul, a1 as pairingCheck, by as ChaCha20Poly1305Error, a2 as ChaCha20Poly1305Live, C as ChaCha20Poly1305Service, a3 as ChaCha20Poly1305ServiceShape, a4 as ChaCha20Poly1305Test, bz as InvalidKeyError, bA as InvalidNonceError, a5 as decrypt, a6 as encrypt, a7 as generateKey, a8 as generateNonce, a9 as Ed25519Live, d as Ed25519Service, aa as Ed25519ServiceShape, ab as Ed25519Test, ac as getPublicKey, ad as sign$2, ae as verify$2, ao as unwrapSignature, ap as verifySignature, aq as wrapSignature, ay as HDNode, az as HDPath, aA as HDWalletError, f as HDWalletService, aB as HDWalletServiceShape, aC as HDWalletTest, ax as HardenedDerivationError, aD as InvalidKeyError$1, aE as InvalidPathError, aF as InvalidSeedError, ar as derive, as as fromMnemonic, at as fromSeed, au as generateMnemonic$1, av as getPrivateKey, aw as getPublicKey$1, bB as mapToHDWalletError, aG as mnemonicToSeed$1, aH as withPrivateKey, aI as withSeed, aJ as HMACLive, H as HMACService, aK as HMACServiceShape, aL as HMACTest, aM as hmacSha256, aN as hmacSha512, aP as DecryptError, aS as KeystoreLive, K as KeystoreService, aT as KeystoreServiceShape, aU as KeystoreTest, aQ as decrypt$1, aR as encrypt$1, aV as withDecryptedKey, aY as KZGError, aZ as KZGLive, e as KZGService, a_ as KZGServiceShape, a$ as KZGTest, aW as blobToKzgCommitment, aX as computeBlobKzgProof, b0 as verifyBlobKzgProof, b2 as ModExpLive, b3 as ModExpService, b4 as ModExpServiceShape, b5 as ModExpTest, b1 as calculateGas, b6 as modexp, b7 as modexpBytes, b8 as P256Live, P as P256Service, b9 as P256ServiceShape, ba as sign$3, bb as verify$3, bd as Ripemd160Live, R as Ripemd160Service, be as Ripemd160Test, bc as hash$2, bg as SHA256Live, S as SHA256Service, bh as SHA256Test, bf as hash$3, bn as X25519Live, bo as X25519Service, bp as X25519ServiceShape, bq as X25519Test, bk as computeSecret, bl as generateKeyPair, bm as getPublicKey$2 } from './X25519Test-DGsk1V9o.js';
-export { i as AesGcm, g as CryptoLive, h as CryptoTest } from './X25519Test-DGsk1V9o.js';
-import { bm as SiweMessageType } from './index-IgkEHjBe.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-IgkEHjBe.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-BCOuszKZ.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-BCOuszKZ.js';
 import { BlockInclude, RetryOptions, StreamBlock, LightBlock, BackfillOptions, BlockStream, BlockStreamConstructorOptions, BlockStreamEvent, BlockStreamMetadata, BlockStreamOptions, BlocksEvent, ReorgEvent, WatchOptions } from '@tevm/voltaire/block';
-import { cs as TransportService } from './RpcResolver-BpvqybjD.js';
-export { A as AbiDecodeError, h as AbiEncodeError, i as AbiEncoderService, j as AbiEncoderShape, k as AccountError, l as AccountService, n as AccountShape, aZ as ArbitrumFormatter, br as ArbitrumProvider, ba as BalanceResolver, bs as BaseProvider, Q as BlockExplorerConfig, R as BlockExplorerService, o as BlockStream, p as BlockStreamError, q as BlockStreamService, r as BlockStreamShape, a as BlockchainError, H as BlockchainHexInput, b as BlockchainService, c as BlockchainShape, bl as Blocks, cd as BrowserTransport, C as CacheService, t as CacheShape, v as CcipError, w as CcipRequest, x as CcipService, y as CcipShape, Y as ChainConfig, Z as ChainContract, _ as ChainService, bt as ComposedServices, am as Contract, aj as ContractAbi, ak as ContractAbiItem, al as ContractBlockTag, an as ContractCallError, ao as ContractError, ap as ContractEventError, aq as ContractInstance, ar as ContractWriteError, $ as ContractsConfig, a0 as ContractsService, ce as CustomTransport, cf as CustomTransportConfig, cg as CustomTransportFromFn, au as Debug, av as DebugService, aw as DebugShape, ax as DebugTraceConfig, as as DecodedEvent, D as DefaultAbiEncoder, z as DefaultCcip, aB as DefaultEns, aR as DefaultFeeEstimator, a_ as DefaultFormatter, b4 as DefaultKzg, bg as DefaultNonceManager, bA as DefaultRateLimiter, c9 as DefaultTransactionSerializer, ca as DeserializeError, ci as EIP1193Provider, aC as ENS_REGISTRY_ADDRESS, aD as ENS_UNIVERSAL_RESOLVER_ADDRESS, ay as EngineApi, az as EngineApiService, aA as EngineApiShape, aE as EnsError, aF as EnsService, aG as EnsShape, bM as EthBlockNumber, bN as EthCall, bO as EthChainId, bP as EthEstimateGas, bQ as EthGasPrice, bR as EthGetBalance, bS as EthGetBlockByHash, bT as EthGetBlockByNumber, bU as EthGetCode, bV as EthGetLogs, bW as EthGetStorageAt, bX as EthGetTransactionByHash, bY as EthGetTransactionCount, bZ as EthGetTransactionReceipt, at as EventFilter, bm as Events, aS as FeeEstimationError, aT as FeeEstimatorService, aU as FeeEstimatorShape, aV as FeeValues, aW as FeeValuesEIP1559, aX as FeeValuesLegacy, F as ForkBlockchain, d as ForkBlockchainOptions, a$ as FormatError, b0 as FormatterService, b1 as FormatterShape, b_ as GenericRpcRequest, bb as GetBalance, aH as GetEnsAddressParams, aI as GetEnsAvatarParams, aJ as GetEnsNameParams, aK as GetEnsResolverParams, aL as GetEnsTextParams, cj as HttpTransport, ck as IdGenerator, cl as IdGeneratorLive, cm as IdGeneratorShape, I as InMemoryBlockchain, J as JsonRpcAccount, b5 as KzgError, b6 as KzgService, b7 as KzgShape, L as LocalAccount, bc as MULTICALL3_ADDRESS, bv as MainnetFullProvider, bw as MainnetProvider, M as MemoryCache, u as MemoryCacheOptions, bd as MulticallCall, be as MulticallError, bf as MulticallResult, bn as Network, bh as NonceError, bi as NonceManagerService, bj as NonceManagerShape, N as NoopCache, E as NoopCcip, b8 as NoopKzg, bC as NoopRateLimiter, b2 as OptimismFormatter, bx as OptimismProvider, by as PolygonProvider, bo as Provider, bk as ProviderAccount, bD as RateLimitBehavior, bE as RateLimitError, cp as RateLimitedTransport, bF as RateLimiterConfig, bG as RateLimiterService, bH as RateLimiterShape, bI as RawProviderService, bJ as RawProviderShape, bK as RawProviderTransport, bL as RawRequestArguments, c0 as RpcBatch, c1 as RpcBatchService, c2 as RpcBatchShape, c3 as RpcRequest, ad as RpcUrlsConfig, bz as SepoliaProvider, cb as SerializeError, c4 as Signer, c5 as SignerError, c6 as SignerService, c7 as SignerShape, bp as Simulation, bq as Streaming, cr as TestTransport, c8 as TransactionRequest, cc as TransactionSerializerService, T as TransactionStream, e as TransactionStreamError, f as TransactionStreamService, g as TransactionStreamShape, ct as TransportShape, U as UnsignedTransaction, cw as WebSocketTransport, b3 as ZkSyncFormatter, b9 as aggregate3, G as arbitrum, K as arbitrumBlockExplorers, O as arbitrumConfig, P as arbitrumContracts, S as base, V as baseBlockExplorers, W as baseConfig, X as baseContracts, ch as cacheEnabledRef, bu as createProvider, aM as getEnsAddress, aN as getEnsAvatar, aO as getEnsName, aP as getEnsResolver, aQ as getEnsText, a1 as mainnet, a2 as mainnetBlockExplorers, a3 as mainnetConfig, a4 as mainnetContracts, s as makeBlockStream, aY as makeFeeEstimator, cn as makeIdGenerator, bB as makeRateLimiter, b$ as makeRpcResolver, m as makeTransactionStream, co as nextId, a5 as optimism, a6 as optimismBlockExplorers, a7 as optimismConfig, a8 as optimismContracts, a9 as polygon, aa as polygonBlockExplorers, ab as polygonConfig, ac as polygonContracts, cq as retryScheduleRef, ae as rpcUrlsByChainId, af as sepolia, ag as sepoliaBlockExplorers, ah as sepoliaConfig, ai as sepoliaContracts, cu as timeoutRef, cv as tracingRef, cy as withRetrySchedule, cz as withTimeout, cA as withTracing, cx as withoutCache } from './RpcResolver-BpvqybjD.js';
+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, BrowserTransport, CacheService, CacheShape, CallError, CallRequest, CcipError, CcipRequest, CcipService, CcipShape, ChainConfig, ChainContract, ChainService, ComposedServices, Contract, ContractAbi, ContractAbiItem, ContractBlockTag, ContractCall, ContractCallError, ContractError, ContractEventError, ContractInstance, 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, HttpTransport, IdGenerator, IdGeneratorLive, IdGeneratorShape, InMemoryBlockchain, 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, 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, TestTransport, TransactionIndexInput, TransactionRequest, TransactionSerializerService, TransactionStream, TransactionStreamError, TransactionStreamService, TransactionStreamShape, TransactionType, TransportShape, UncleBlockType, UninstallFilterError, UnsignedTransaction, UnsubscribeError, WaitForTransactionReceiptArgs, WaitForTransactionReceiptError, WaitForTransactionReceiptOptions, WatchBlocksError, 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, makeFeeEstimator, makeIdGenerator, makeRateLimiter, 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 { BrandedAbi, BrandedAddress } from '@tevm/voltaire';
+import { Keccak256Hash, BrandedAbi, BrandedAddress } from '@tevm/voltaire';
 import { EventStreamConstructorOptions, BackfillOptions as BackfillOptions$1, EventStreamResult, WatchOptions as WatchOptions$1 } from '@tevm/voltaire/contract';
 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/Hex';
-import '@tevm/voltaire/Hash';
 import '@tevm/voltaire/Secp256k1';
 import '@tevm/voltaire/EIP712';
 import '@tevm/voltaire/Signature';
@@ -35,32 +41,88 @@ import '@tevm/voltaire/HMAC';
 import '@tevm/voltaire/Keystore';
 import '@tevm/voltaire/P256';
 import '@tevm/voltaire/X25519';
+import '@tevm/voltaire/Siwe';
+import 'effect';
 import '@tevm/voltaire/AccessList';
 import '@tevm/voltaire/Bytes';
+import '@tevm/voltaire/functional';
 import '@tevm/voltaire/Uint';
 import '@tevm/voltaire/Authorization';
 import '@tevm/voltaire/Base64';
 import '@tevm/voltaire/Blob';
+import '@tevm/voltaire/BloomFilter';
 import '@tevm/voltaire/Bytecode';
+import '@tevm/voltaire/Ens';
 import '@tevm/voltaire/EventLog';
 import '@tevm/voltaire/GasConstants';
 import '@tevm/voltaire/Hardfork';
 import '@tevm/voltaire/InitCode';
 import '@tevm/voltaire/LogFilter';
+import '@tevm/voltaire/Opcode';
 import '@tevm/voltaire/PrivateKey';
 import '@tevm/voltaire/PublicKey';
 import '@tevm/voltaire/Rlp';
 import '@tevm/voltaire/Transaction';
+import 'effect/Option';
 import '@tevm/voltaire/transaction';
+import 'effect/RequestResolver';
+import 'effect/Request';
+import 'effect/Scope';
+import 'effect/RateLimiter';
 import 'effect/Duration';
 import 'effect/FiberRef';
 import 'effect/Schedule';
 import '@effect/platform/HttpClient';
 import '@effect/platform/Socket';
-import 'effect/RequestResolver';
-import 'effect/Request';
-import 'effect/Scope';
-import 'effect/RateLimiter';
+
+/**
+ * @fileoverview Synchronous Keccak-256 hash function without Effect service layer.
+ *
+ * @description
+ * Provides a direct synchronous Keccak-256 hash function that bypasses the Effect
+ * service layer. Use this when you need a simple hash without Effect dependency
+ * injection overhead.
+ *
+ * @module Keccak256/hashSync
+ * @since 0.2.25
+ */
+
+/**
+ * Computes the Keccak-256 hash of the provided data synchronously.
+ *
+ * @description
+ * This is a direct synchronous version of the Keccak-256 hash that does not
+ * require the Effect service layer. Use this when you need a simple hash
+ * operation without Effect dependency injection.
+ *
+ * For Effect-based applications that need testability and dependency injection,
+ * use {@link hash} with {@link KeccakService} instead.
+ *
+ * @param {Uint8Array} data - The input bytes to hash. Can be any length.
+ * @returns {Keccak256Hash} A 32-byte Keccak256Hash (branded Uint8Array)
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { hashSync } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const data = new Uint8Array([1, 2, 3])
+ * const result = hashSync(data)
+ * console.log(result) // Uint8Array(32) [...]
+ * ```
+ *
+ * @example Hashing a string
+ * ```typescript
+ * import { hashSync } from 'voltaire-effect/crypto/Keccak256'
+ *
+ * const message = new TextEncoder().encode('hello world')
+ * const hash = hashSync(message)
+ * ```
+ *
+ * @see {@link hash} - Effect-based version with dependency injection
+ * @see {@link KeccakService} - Service interface for Effect-based usage
+ * @since 0.2.25
+ */
+declare const hashSync: (data: Uint8Array) => Keccak256Hash;
 
 /**
  * @fileoverview Keccak-256 cryptographic hashing module for Effect.
@@ -104,13 +166,15 @@ import 'effect/RateLimiter';
  * @since 0.0.1
  */
 
-declare const index$v_KeccakLive: typeof KeccakLive;
-declare const index$v_KeccakService: typeof KeccakService;
-declare const index$v_KeccakServiceShape: typeof KeccakServiceShape;
-declare const index$v_KeccakTest: typeof KeccakTest;
-declare const index$v_hash: typeof hash;
-declare namespace index$v {
-  export { index$v_KeccakLive as KeccakLive, index$v_KeccakService as KeccakService, index$v_KeccakServiceShape as KeccakServiceShape, index$v_KeccakTest as KeccakTest, index$v_hash as hash };
+declare const index$w_Keccak256Hash: typeof Keccak256Hash;
+declare const index$w_KeccakLive: typeof KeccakLive;
+declare const index$w_KeccakService: typeof KeccakService;
+declare const index$w_KeccakServiceShape: typeof KeccakServiceShape;
+declare const index$w_KeccakTest: typeof KeccakTest;
+declare const index$w_hash: typeof hash;
+declare const index$w_hashSync: typeof hashSync;
+declare namespace index$w {
+  export { index$w_Keccak256Hash as Keccak256Hash, index$w_KeccakLive as KeccakLive, index$w_KeccakService as KeccakService, index$w_KeccakServiceShape as KeccakServiceShape, index$w_KeccakTest as KeccakTest, index$w_hash as hash, index$w_hashSync as hashSync };
 }
 
 /**
@@ -159,23 +223,23 @@ declare namespace index$v {
  * @since 0.0.1
  */
 
-declare const index$u_InvalidPrivateKeyError: typeof InvalidPrivateKeyError;
-declare const index$u_InvalidPublicKeyError: typeof InvalidPublicKeyError;
-declare const index$u_InvalidRecoveryIdError: typeof InvalidRecoveryIdError;
-declare const index$u_InvalidSignatureError: typeof InvalidSignatureError;
-declare const index$u_Secp256k1Error: typeof Secp256k1Error;
-declare const index$u_Secp256k1Errors: typeof Secp256k1Errors;
-declare const index$u_Secp256k1Live: typeof Secp256k1Live;
-declare const index$u_Secp256k1Service: typeof Secp256k1Service;
-declare const index$u_Secp256k1ServiceShape: typeof Secp256k1ServiceShape;
-declare const index$u_Secp256k1Test: typeof Secp256k1Test;
-declare const index$u_SignOptions: typeof SignOptions;
-declare const index$u_mapToSecp256k1Error: typeof mapToSecp256k1Error;
-declare const index$u_recover: typeof recover;
-declare const index$u_sign: typeof sign;
-declare const index$u_verify: typeof verify;
-declare namespace index$u {
-  export { index$u_InvalidPrivateKeyError as InvalidPrivateKeyError, index$u_InvalidPublicKeyError as InvalidPublicKeyError, index$u_InvalidRecoveryIdError as InvalidRecoveryIdError, index$u_InvalidSignatureError as InvalidSignatureError, index$u_Secp256k1Error as Secp256k1Error, index$u_Secp256k1Errors as Secp256k1Errors, index$u_Secp256k1Live as Secp256k1Live, index$u_Secp256k1Service as Secp256k1Service, index$u_Secp256k1ServiceShape as Secp256k1ServiceShape, index$u_Secp256k1Test as Secp256k1Test, index$u_SignOptions as SignOptions, index$u_mapToSecp256k1Error as mapToSecp256k1Error, index$u_recover as recover, index$u_sign as sign, index$u_verify as verify };
+declare const index$v_InvalidPrivateKeyError: typeof InvalidPrivateKeyError;
+declare const index$v_InvalidPublicKeyError: typeof InvalidPublicKeyError;
+declare const index$v_InvalidRecoveryIdError: typeof InvalidRecoveryIdError;
+declare const index$v_InvalidSignatureError: typeof InvalidSignatureError;
+declare const index$v_Secp256k1Error: typeof Secp256k1Error;
+declare const index$v_Secp256k1Errors: typeof Secp256k1Errors;
+declare const index$v_Secp256k1Live: typeof Secp256k1Live;
+declare const index$v_Secp256k1Service: typeof Secp256k1Service;
+declare const index$v_Secp256k1ServiceShape: typeof Secp256k1ServiceShape;
+declare const index$v_Secp256k1Test: typeof Secp256k1Test;
+declare const index$v_SignOptions: typeof SignOptions;
+declare const index$v_mapToSecp256k1Error: typeof mapToSecp256k1Error;
+declare const index$v_recover: typeof recover;
+declare const index$v_sign: typeof sign;
+declare const index$v_verify: typeof verify;
+declare namespace index$v {
+  export { index$v_InvalidPrivateKeyError as InvalidPrivateKeyError, index$v_InvalidPublicKeyError as InvalidPublicKeyError, index$v_InvalidRecoveryIdError as InvalidRecoveryIdError, index$v_InvalidSignatureError as InvalidSignatureError, index$v_Secp256k1Error as Secp256k1Error, index$v_Secp256k1Errors as Secp256k1Errors, index$v_Secp256k1Live as Secp256k1Live, index$v_Secp256k1Service as Secp256k1Service, index$v_Secp256k1ServiceShape as Secp256k1ServiceShape, index$v_Secp256k1Test as Secp256k1Test, index$v_SignOptions as SignOptions, index$v_mapToSecp256k1Error as mapToSecp256k1Error, index$v_recover as recover, index$v_sign as sign, index$v_verify as verify };
 }
 
 /**
@@ -215,18 +279,18 @@ declare namespace index$u {
  * @see {@link https://eips.ethereum.org/EIPS/eip-712 | EIP-712 Specification}
  */
 
-declare const index$t_EIP712Live: typeof EIP712Live;
-declare const index$t_EIP712Service: typeof EIP712Service;
-declare const index$t_EIP712ServiceShape: typeof EIP712ServiceShape;
-declare const index$t_EIP712Test: typeof EIP712Test;
-declare const index$t_hashDomain: typeof hashDomain;
-declare const index$t_hashStruct: typeof hashStruct;
-declare const index$t_hashTypedData: typeof hashTypedData;
-declare const index$t_recoverAddress: typeof recoverAddress;
-declare const index$t_signTypedData: typeof signTypedData;
-declare const index$t_verifyTypedData: typeof verifyTypedData;
-declare namespace index$t {
-  export { index$t_EIP712Live as EIP712Live, index$t_EIP712Service as EIP712Service, index$t_EIP712ServiceShape as EIP712ServiceShape, index$t_EIP712Test as EIP712Test, index$t_hashDomain as hashDomain, index$t_hashStruct as hashStruct, index$t_hashTypedData as hashTypedData, index$t_recoverAddress as recoverAddress, index$t_signTypedData as signTypedData, index$t_verifyTypedData as verifyTypedData };
+declare const index$u_EIP712Live: typeof EIP712Live;
+declare const index$u_EIP712Service: typeof EIP712Service;
+declare const index$u_EIP712ServiceShape: typeof EIP712ServiceShape;
+declare const index$u_EIP712Test: typeof EIP712Test;
+declare const index$u_hashDomain: typeof hashDomain;
+declare const index$u_hashStruct: typeof hashStruct;
+declare const index$u_hashTypedData: typeof hashTypedData;
+declare const index$u_recoverAddress: typeof recoverAddress;
+declare const index$u_signTypedData: typeof signTypedData;
+declare const index$u_verifyTypedData: typeof verifyTypedData;
+declare namespace index$u {
+  export { index$u_EIP712Live as EIP712Live, index$u_EIP712Service as EIP712Service, index$u_EIP712ServiceShape as EIP712ServiceShape, index$u_EIP712Test as EIP712Test, index$u_hashDomain as hashDomain, index$u_hashStruct as hashStruct, index$u_hashTypedData as hashTypedData, index$u_recoverAddress as recoverAddress, index$u_signTypedData as signTypedData, index$u_verifyTypedData as verifyTypedData };
 }
 
 /**
@@ -374,18 +438,18 @@ declare const verifySiweMessage: (params: VerifySiweMessageParams) => Effect.Eff
  * @since 0.1.0
  */
 
-type index$s_CreateSiweMessageParams = CreateSiweMessageParams;
-type index$s_SiweFields = SiweFields;
-type index$s_SiweMessage = SiweMessage;
-declare const index$s_SiweMessageSchema: typeof SiweMessageSchema;
-type index$s_VerifyError = VerifyError;
-declare const index$s_VerifyError: typeof VerifyError;
-type index$s_VerifySiweMessageParams = VerifySiweMessageParams;
-declare const index$s_createSiweMessage: typeof createSiweMessage;
-declare const index$s_parseSiweMessage: typeof parseSiweMessage;
-declare const index$s_verifySiweMessage: typeof verifySiweMessage;
-declare namespace index$s {
-  export { type index$s_CreateSiweMessageParams as CreateSiweMessageParams, ParseError$1 as ParseError, type index$s_SiweFields as SiweFields, type index$s_SiweMessage as SiweMessage, index$s_SiweMessageSchema as SiweMessageSchema, index$s_VerifyError as VerifyError, type index$s_VerifySiweMessageParams as VerifySiweMessageParams, index$s_createSiweMessage as createSiweMessage, index$s_parseSiweMessage as parseSiweMessage, index$s_verifySiweMessage as verifySiweMessage };
+type index$t_CreateSiweMessageParams = CreateSiweMessageParams;
+type index$t_SiweFields = SiweFields;
+type index$t_SiweMessage = SiweMessage;
+declare const index$t_SiweMessageSchema: typeof SiweMessageSchema;
+type index$t_VerifyError = VerifyError;
+declare const index$t_VerifyError: typeof VerifyError;
+type index$t_VerifySiweMessageParams = VerifySiweMessageParams;
+declare const index$t_createSiweMessage: typeof createSiweMessage;
+declare const index$t_parseSiweMessage: typeof parseSiweMessage;
+declare const index$t_verifySiweMessage: typeof verifySiweMessage;
+declare namespace index$t {
+  export { type index$t_CreateSiweMessageParams as CreateSiweMessageParams, ParseError$1 as ParseError, type index$t_SiweFields as SiweFields, type index$t_SiweMessage as SiweMessage, index$t_SiweMessageSchema as SiweMessageSchema, index$t_VerifyError as VerifyError, type index$t_VerifySiweMessageParams as VerifySiweMessageParams, index$t_createSiweMessage as createSiweMessage, index$t_parseSiweMessage as parseSiweMessage, index$t_verifySiweMessage as verifySiweMessage };
 }
 
 /**
@@ -571,29 +635,29 @@ declare const toLightBlock: (block: unknown) => LightBlock;
  * ```
  */
 
-declare const index$r_BackfillOptions: typeof BackfillOptions;
-type index$r_BlockError = BlockError;
-declare const index$r_BlockError: typeof BlockError;
-declare const index$r_BlockInclude: typeof BlockInclude;
-type index$r_BlockNotFoundError = BlockNotFoundError;
-declare const index$r_BlockNotFoundError: typeof BlockNotFoundError;
-declare const index$r_BlockStream: typeof BlockStream;
-declare const index$r_BlockStreamConstructorOptions: typeof BlockStreamConstructorOptions;
-declare const index$r_BlockStreamEvent: typeof BlockStreamEvent;
-declare const index$r_BlockStreamMetadata: typeof BlockStreamMetadata;
-declare const index$r_BlockStreamOptions: typeof BlockStreamOptions;
-declare const index$r_BlocksEvent: typeof BlocksEvent;
-declare const index$r_LightBlock: typeof LightBlock;
-declare const index$r_ReorgEvent: typeof ReorgEvent;
-declare const index$r_RetryOptions: typeof RetryOptions;
-declare const index$r_StreamBlock: typeof StreamBlock;
-declare const index$r_WatchOptions: typeof WatchOptions;
-declare const index$r_fetchBlock: typeof fetchBlock;
-declare const index$r_fetchBlockByHash: typeof fetchBlockByHash;
-declare const index$r_fetchBlockReceipts: typeof fetchBlockReceipts;
-declare const index$r_toLightBlock: typeof toLightBlock;
-declare namespace index$r {
-  export { index$r_BackfillOptions as BackfillOptions, index$r_BlockError as BlockError, index$r_BlockInclude as BlockInclude, index$r_BlockNotFoundError as BlockNotFoundError, index$r_BlockStream as BlockStream, index$r_BlockStreamConstructorOptions as BlockStreamConstructorOptions, index$r_BlockStreamEvent as BlockStreamEvent, index$r_BlockStreamMetadata as BlockStreamMetadata, index$r_BlockStreamOptions as BlockStreamOptions, index$r_BlocksEvent as BlocksEvent, index$r_LightBlock as LightBlock, index$r_ReorgEvent as ReorgEvent, index$r_RetryOptions as RetryOptions, index$r_StreamBlock as StreamBlock, index$r_WatchOptions as WatchOptions, index$r_fetchBlock as fetchBlock, index$r_fetchBlockByHash as fetchBlockByHash, index$r_fetchBlockReceipts as fetchBlockReceipts, index$r_toLightBlock as toLightBlock };
+declare const index$s_BackfillOptions: typeof BackfillOptions;
+type index$s_BlockError = BlockError;
+declare const index$s_BlockError: typeof BlockError;
+declare const index$s_BlockInclude: typeof BlockInclude;
+type index$s_BlockNotFoundError = BlockNotFoundError;
+declare const index$s_BlockNotFoundError: typeof BlockNotFoundError;
+declare const index$s_BlockStream: typeof BlockStream;
+declare const index$s_BlockStreamConstructorOptions: typeof BlockStreamConstructorOptions;
+declare const index$s_BlockStreamEvent: typeof BlockStreamEvent;
+declare const index$s_BlockStreamMetadata: typeof BlockStreamMetadata;
+declare const index$s_BlockStreamOptions: typeof BlockStreamOptions;
+declare const index$s_BlocksEvent: typeof BlocksEvent;
+declare const index$s_LightBlock: typeof LightBlock;
+declare const index$s_ReorgEvent: typeof ReorgEvent;
+declare const index$s_RetryOptions: typeof RetryOptions;
+declare const index$s_StreamBlock: typeof StreamBlock;
+declare const index$s_WatchOptions: typeof WatchOptions;
+declare const index$s_fetchBlock: typeof fetchBlock;
+declare const index$s_fetchBlockByHash: typeof fetchBlockByHash;
+declare const index$s_fetchBlockReceipts: typeof fetchBlockReceipts;
+declare const index$s_toLightBlock: typeof toLightBlock;
+declare namespace index$s {
+  export { index$s_BackfillOptions as BackfillOptions, index$s_BlockError as BlockError, index$s_BlockInclude as BlockInclude, index$s_BlockNotFoundError as BlockNotFoundError, index$s_BlockStream as BlockStream, index$s_BlockStreamConstructorOptions as BlockStreamConstructorOptions, index$s_BlockStreamEvent as BlockStreamEvent, index$s_BlockStreamMetadata as BlockStreamMetadata, index$s_BlockStreamOptions as BlockStreamOptions, index$s_BlocksEvent as BlocksEvent, index$s_LightBlock as LightBlock, index$s_ReorgEvent as ReorgEvent, index$s_RetryOptions as RetryOptions, index$s_StreamBlock as StreamBlock, index$s_WatchOptions as WatchOptions, index$s_fetchBlock as fetchBlock, index$s_fetchBlockByHash as fetchBlockByHash, index$s_fetchBlockReceipts as fetchBlockReceipts, index$s_toLightBlock as toLightBlock };
 }
 
 /**
@@ -635,17 +699,17 @@ declare class EventStreamError extends EventStreamError_base<{
  * @see {@link TransportService} - Required dependency
  */
 
-type EventType = BrandedAbi.Event.EventType;
+type EventType$1 = BrandedAbi.Event.EventType;
 
 /**
  * Options for backfill with address and event included
  */
-interface BackfillStreamOptions<TEvent extends EventType> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, BackfillOptions$1 {
+interface BackfillStreamOptions<TEvent extends EventType$1> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, BackfillOptions$1 {
 }
 /**
  * Options for watch with address and event included
  */
-interface WatchStreamOptions<TEvent extends EventType> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, WatchOptions$1 {
+interface WatchStreamOptions<TEvent extends EventType$1> extends Omit<EventStreamConstructorOptions<TEvent>, "provider">, WatchOptions$1 {
 }
 /**
  * Shape of the EventStream service.
@@ -672,7 +736,7 @@ type EventStreamShape = {
      * });
      * ```
      */
-    readonly backfill: <TEvent extends EventType>(options: BackfillStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
+    readonly backfill: <TEvent extends EventType$1>(options: BackfillStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
     /**
      * Watch for new events by polling.
      *
@@ -690,7 +754,7 @@ type EventStreamShape = {
      * });
      * ```
      */
-    readonly watch: <TEvent extends EventType>(options: WatchStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
+    readonly watch: <TEvent extends EventType$1>(options: WatchStreamOptions<TEvent>) => Stream.Stream<EventStreamResult<TEvent>, EventStreamError>;
 };
 declare const EventStreamService_base: Context.TagClass<EventStreamService, "EventStreamService", EventStreamShape>;
 /**
@@ -822,22 +886,22 @@ declare const validateWordCount: (mnemonic: string) => boolean;
  * @see {@link https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki | BIP-39 Specification}
  */
 
-declare const index$q_Bip39Live: typeof Bip39Live;
-declare const index$q_Bip39Service: typeof Bip39Service;
-declare const index$q_Bip39ServiceShape: typeof Bip39ServiceShape;
-declare const index$q_Bip39Test: typeof Bip39Test;
-declare const index$q_MnemonicStrength: typeof MnemonicStrength;
-declare const index$q_WORD_COUNTS: typeof WORD_COUNTS;
-declare const index$q_generateMnemonic: typeof generateMnemonic;
-declare const index$q_getWordCount: typeof getWordCount;
-declare const index$q_mnemonicToSeed: typeof mnemonicToSeed;
-declare const index$q_mnemonicToSeedSync: typeof mnemonicToSeedSync;
-declare const index$q_mnemonicToWords: typeof mnemonicToWords;
-declare const index$q_validateMnemonic: typeof validateMnemonic;
-declare const index$q_validateWordCount: typeof validateWordCount;
-declare const index$q_wordsToMnemonic: typeof wordsToMnemonic;
-declare namespace index$q {
-  export { index$q_Bip39Live as Bip39Live, index$q_Bip39Service as Bip39Service, index$q_Bip39ServiceShape as Bip39ServiceShape, index$q_Bip39Test as Bip39Test, index$q_MnemonicStrength as MnemonicStrength, index$q_WORD_COUNTS as WORD_COUNTS, index$q_generateMnemonic as generateMnemonic, index$q_getWordCount as getWordCount, index$q_mnemonicToSeed as mnemonicToSeed, index$q_mnemonicToSeedSync as mnemonicToSeedSync, index$q_mnemonicToWords as mnemonicToWords, index$q_validateMnemonic as validateMnemonic, index$q_validateWordCount as validateWordCount, index$q_wordsToMnemonic as wordsToMnemonic };
+declare const index$r_Bip39Live: typeof Bip39Live;
+declare const index$r_Bip39Service: typeof Bip39Service;
+declare const index$r_Bip39ServiceShape: typeof Bip39ServiceShape;
+declare const index$r_Bip39Test: typeof Bip39Test;
+declare const index$r_MnemonicStrength: typeof MnemonicStrength;
+declare const index$r_WORD_COUNTS: typeof WORD_COUNTS;
+declare const index$r_generateMnemonic: typeof generateMnemonic;
+declare const index$r_getWordCount: typeof getWordCount;
+declare const index$r_mnemonicToSeed: typeof mnemonicToSeed;
+declare const index$r_mnemonicToSeedSync: typeof mnemonicToSeedSync;
+declare const index$r_mnemonicToWords: typeof mnemonicToWords;
+declare const index$r_validateMnemonic: typeof validateMnemonic;
+declare const index$r_validateWordCount: typeof validateWordCount;
+declare const index$r_wordsToMnemonic: typeof wordsToMnemonic;
+declare namespace index$r {
+  export { index$r_Bip39Live as Bip39Live, index$r_Bip39Service as Bip39Service, index$r_Bip39ServiceShape as Bip39ServiceShape, index$r_Bip39Test as Bip39Test, index$r_MnemonicStrength as MnemonicStrength, index$r_WORD_COUNTS as WORD_COUNTS, index$r_generateMnemonic as generateMnemonic, index$r_getWordCount as getWordCount, index$r_mnemonicToSeed as mnemonicToSeed, index$r_mnemonicToSeedSync as mnemonicToSeedSync, index$r_mnemonicToWords as mnemonicToWords, index$r_validateMnemonic as validateMnemonic, index$r_validateWordCount as validateWordCount, index$r_wordsToMnemonic as wordsToMnemonic };
 }
 
 /**
@@ -869,11 +933,11 @@ declare namespace index$q {
  * @since 0.0.1
  */
 
-declare const index$p_Blake2Live: typeof Blake2Live;
-declare const index$p_Blake2Service: typeof Blake2Service;
-declare const index$p_Blake2Test: typeof Blake2Test;
-declare namespace index$p {
-  export { index$p_Blake2Live as Blake2Live, index$p_Blake2Service as Blake2Service, index$p_Blake2Test as Blake2Test, hash$1 as hash };
+declare const index$q_Blake2Live: typeof Blake2Live;
+declare const index$q_Blake2Service: typeof Blake2Service;
+declare const index$q_Blake2Test: typeof Blake2Test;
+declare namespace index$q {
+  export { index$q_Blake2Live as Blake2Live, index$q_Blake2Service as Blake2Service, index$q_Blake2Test as Blake2Test, hash$1 as hash };
 }
 
 /**
@@ -911,12 +975,12 @@ declare namespace index$p {
  * @since 0.0.1
  */
 
-declare const index$o_Bls12381Live: typeof Bls12381Live;
-declare const index$o_Bls12381Service: typeof Bls12381Service;
-declare const index$o_Bls12381ServiceShape: typeof Bls12381ServiceShape;
-declare const index$o_aggregate: typeof aggregate;
-declare namespace index$o {
-  export { index$o_Bls12381Live as Bls12381Live, index$o_Bls12381Service as Bls12381Service, index$o_Bls12381ServiceShape as Bls12381ServiceShape, index$o_aggregate as aggregate, sign$1 as sign, verify$1 as verify };
+declare const index$p_Bls12381Live: typeof Bls12381Live;
+declare const index$p_Bls12381Service: typeof Bls12381Service;
+declare const index$p_Bls12381ServiceShape: typeof Bls12381ServiceShape;
+declare const index$p_aggregate: typeof aggregate;
+declare namespace index$p {
+  export { index$p_Bls12381Live as Bls12381Live, index$p_Bls12381Service as Bls12381Service, index$p_Bls12381ServiceShape as Bls12381ServiceShape, index$p_aggregate as aggregate, sign$1 as sign, verify$1 as verify };
 }
 
 /**
@@ -973,20 +1037,20 @@ type G2PointType = Uint8Array & {
  * @since 0.0.1
  */
 
-declare const index$n_Bn254Error: typeof Bn254Error;
-declare const index$n_Bn254Live: typeof Bn254Live;
-declare const index$n_Bn254Service: typeof Bn254Service;
-declare const index$n_Bn254ServiceShape: typeof Bn254ServiceShape;
-declare const index$n_Bn254Test: typeof Bn254Test;
-declare const index$n_g1Add: typeof g1Add;
-declare const index$n_g1Generator: typeof g1Generator;
-declare const index$n_g1Mul: typeof g1Mul;
-declare const index$n_g2Add: typeof g2Add;
-declare const index$n_g2Generator: typeof g2Generator;
-declare const index$n_g2Mul: typeof g2Mul;
-declare const index$n_pairingCheck: typeof pairingCheck;
-declare namespace index$n {
-  export { type G1PointType as BN254G1PointType, type G2PointType as BN254G2PointType, index$n_Bn254Error as Bn254Error, index$n_Bn254Live as Bn254Live, index$n_Bn254Service as Bn254Service, index$n_Bn254ServiceShape as Bn254ServiceShape, index$n_Bn254Test as Bn254Test, index$n_g1Add as g1Add, index$n_g1Generator as g1Generator, index$n_g1Mul as g1Mul, index$n_g2Add as g2Add, index$n_g2Generator as g2Generator, index$n_g2Mul as g2Mul, index$n_pairingCheck as pairingCheck };
+declare const index$o_Bn254Error: typeof Bn254Error;
+declare const index$o_Bn254Live: typeof Bn254Live;
+declare const index$o_Bn254Service: typeof Bn254Service;
+declare const index$o_Bn254ServiceShape: typeof Bn254ServiceShape;
+declare const index$o_Bn254Test: typeof Bn254Test;
+declare const index$o_g1Add: typeof g1Add;
+declare const index$o_g1Generator: typeof g1Generator;
+declare const index$o_g1Mul: typeof g1Mul;
+declare const index$o_g2Add: typeof g2Add;
+declare const index$o_g2Generator: typeof g2Generator;
+declare const index$o_g2Mul: typeof g2Mul;
+declare const index$o_pairingCheck: typeof pairingCheck;
+declare namespace index$o {
+  export { type G1PointType as BN254G1PointType, type G2PointType as BN254G2PointType, index$o_Bn254Error as Bn254Error, index$o_Bn254Live as Bn254Live, index$o_Bn254Service as Bn254Service, index$o_Bn254ServiceShape as Bn254ServiceShape, index$o_Bn254Test as Bn254Test, index$o_g1Add as g1Add, index$o_g1Generator as g1Generator, index$o_g1Mul as g1Mul, index$o_g2Add as g2Add, index$o_g2Generator as g2Generator, index$o_g2Mul as g2Mul, index$o_pairingCheck as pairingCheck };
 }
 
 /**
@@ -1024,19 +1088,19 @@ declare namespace index$n {
  * @see {@link https://datatracker.ietf.org/doc/html/rfc8439 | RFC 8439}
  */
 
-declare const index$m_ChaCha20Poly1305Error: typeof ChaCha20Poly1305Error;
-declare const index$m_ChaCha20Poly1305Live: typeof ChaCha20Poly1305Live;
-declare const index$m_ChaCha20Poly1305Service: typeof ChaCha20Poly1305Service;
-declare const index$m_ChaCha20Poly1305ServiceShape: typeof ChaCha20Poly1305ServiceShape;
-declare const index$m_ChaCha20Poly1305Test: typeof ChaCha20Poly1305Test;
-declare const index$m_InvalidKeyError: typeof InvalidKeyError;
-declare const index$m_InvalidNonceError: typeof InvalidNonceError;
-declare const index$m_decrypt: typeof decrypt;
-declare const index$m_encrypt: typeof encrypt;
-declare const index$m_generateKey: typeof generateKey;
-declare const index$m_generateNonce: typeof generateNonce;
-declare namespace index$m {
-  export { index$m_ChaCha20Poly1305Error as ChaCha20Poly1305Error, index$m_ChaCha20Poly1305Live as ChaCha20Poly1305Live, index$m_ChaCha20Poly1305Service as ChaCha20Poly1305Service, index$m_ChaCha20Poly1305ServiceShape as ChaCha20Poly1305ServiceShape, index$m_ChaCha20Poly1305Test as ChaCha20Poly1305Test, index$m_InvalidKeyError as InvalidKeyError, index$m_InvalidNonceError as InvalidNonceError, index$m_decrypt as decrypt, index$m_encrypt as encrypt, index$m_generateKey as generateKey, index$m_generateNonce as generateNonce };
+declare const index$n_ChaCha20Poly1305Error: typeof ChaCha20Poly1305Error;
+declare const index$n_ChaCha20Poly1305Live: typeof ChaCha20Poly1305Live;
+declare const index$n_ChaCha20Poly1305Service: typeof ChaCha20Poly1305Service;
+declare const index$n_ChaCha20Poly1305ServiceShape: typeof ChaCha20Poly1305ServiceShape;
+declare const index$n_ChaCha20Poly1305Test: typeof ChaCha20Poly1305Test;
+declare const index$n_InvalidKeyError: typeof InvalidKeyError;
+declare const index$n_InvalidNonceError: typeof InvalidNonceError;
+declare const index$n_decrypt: typeof decrypt;
+declare const index$n_encrypt: typeof encrypt;
+declare const index$n_generateKey: typeof generateKey;
+declare const index$n_generateNonce: typeof generateNonce;
+declare namespace index$n {
+  export { index$n_ChaCha20Poly1305Error as ChaCha20Poly1305Error, index$n_ChaCha20Poly1305Live as ChaCha20Poly1305Live, index$n_ChaCha20Poly1305Service as ChaCha20Poly1305Service, index$n_ChaCha20Poly1305ServiceShape as ChaCha20Poly1305ServiceShape, index$n_ChaCha20Poly1305Test as ChaCha20Poly1305Test, index$n_InvalidKeyError as InvalidKeyError, index$n_InvalidNonceError as InvalidNonceError, index$n_decrypt as decrypt, index$n_encrypt as encrypt, index$n_generateKey as generateKey, index$n_generateNonce as generateNonce };
 }
 
 /**
@@ -1075,13 +1139,13 @@ declare namespace index$m {
  * @since 0.0.1
  */
 
-declare const index$l_Ed25519Live: typeof Ed25519Live;
-declare const index$l_Ed25519Service: typeof Ed25519Service;
-declare const index$l_Ed25519ServiceShape: typeof Ed25519ServiceShape;
-declare const index$l_Ed25519Test: typeof Ed25519Test;
-declare const index$l_getPublicKey: typeof getPublicKey;
-declare namespace index$l {
-  export { index$l_Ed25519Live as Ed25519Live, index$l_Ed25519Service as Ed25519Service, index$l_Ed25519ServiceShape as Ed25519ServiceShape, index$l_Ed25519Test as Ed25519Test, index$l_getPublicKey as getPublicKey, sign$2 as sign, verify$2 as verify };
+declare const index$m_Ed25519Live: typeof Ed25519Live;
+declare const index$m_Ed25519Service: typeof Ed25519Service;
+declare const index$m_Ed25519ServiceShape: typeof Ed25519ServiceShape;
+declare const index$m_Ed25519Test: typeof Ed25519Test;
+declare const index$m_getPublicKey: typeof getPublicKey;
+declare namespace index$m {
+  export { index$m_Ed25519Live as Ed25519Live, index$m_Ed25519Service as Ed25519Service, index$m_Ed25519ServiceShape as Ed25519ServiceShape, index$m_Ed25519Test as Ed25519Test, index$m_getPublicKey as getPublicKey, sign$2 as sign, verify$2 as verify };
 }
 
 /**
@@ -1090,11 +1154,11 @@ declare namespace index$l {
  * @since 0.2.14
  */
 
-declare const index$k_unwrapSignature: typeof unwrapSignature;
-declare const index$k_verifySignature: typeof verifySignature;
-declare const index$k_wrapSignature: typeof wrapSignature;
-declare namespace index$k {
-  export { index$k_unwrapSignature as unwrapSignature, index$k_verifySignature as verifySignature, index$k_wrapSignature as wrapSignature };
+declare const index$l_unwrapSignature: typeof unwrapSignature;
+declare const index$l_verifySignature: typeof verifySignature;
+declare const index$l_wrapSignature: typeof wrapSignature;
+declare namespace index$l {
+  export { index$l_unwrapSignature as unwrapSignature, index$l_verifySignature as verifySignature, index$l_wrapSignature as wrapSignature };
 }
 
 /**
@@ -1136,24 +1200,24 @@ declare namespace index$k {
  * @see {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki | BIP-44 Multi-Account}
  */
 
-declare const index$j_HDNode: typeof HDNode;
-declare const index$j_HDPath: typeof HDPath;
-declare const index$j_HDWalletError: typeof HDWalletError;
-declare const index$j_HDWalletService: typeof HDWalletService;
-declare const index$j_HDWalletServiceShape: typeof HDWalletServiceShape;
-declare const index$j_HDWalletTest: typeof HDWalletTest;
-declare const index$j_HardenedDerivationError: typeof HardenedDerivationError;
-declare const index$j_InvalidPathError: typeof InvalidPathError;
-declare const index$j_InvalidSeedError: typeof InvalidSeedError;
-declare const index$j_derive: typeof derive;
-declare const index$j_fromMnemonic: typeof fromMnemonic;
-declare const index$j_fromSeed: typeof fromSeed;
-declare const index$j_getPrivateKey: typeof getPrivateKey;
-declare const index$j_mapToHDWalletError: typeof mapToHDWalletError;
-declare const index$j_withPrivateKey: typeof withPrivateKey;
-declare const index$j_withSeed: typeof withSeed;
-declare namespace index$j {
-  export { index$j_HDNode as HDNode, index$j_HDPath as HDPath, index$j_HDWalletError as HDWalletError, index$j_HDWalletService as HDWalletService, index$j_HDWalletServiceShape as HDWalletServiceShape, index$j_HDWalletTest as HDWalletTest, index$j_HardenedDerivationError as HardenedDerivationError, InvalidKeyError$1 as InvalidKeyError, index$j_InvalidPathError as InvalidPathError, index$j_InvalidSeedError as InvalidSeedError, index$j_derive as derive, index$j_fromMnemonic as fromMnemonic, index$j_fromSeed as fromSeed, generateMnemonic$1 as generateMnemonic, index$j_getPrivateKey as getPrivateKey, getPublicKey$1 as getPublicKey, index$j_mapToHDWalletError as mapToHDWalletError, mnemonicToSeed$1 as mnemonicToSeed, index$j_withPrivateKey as withPrivateKey, index$j_withSeed as withSeed };
+declare const index$k_HDNode: typeof HDNode;
+declare const index$k_HDPath: typeof HDPath;
+declare const index$k_HDWalletError: typeof HDWalletError;
+declare const index$k_HDWalletService: typeof HDWalletService;
+declare const index$k_HDWalletServiceShape: typeof HDWalletServiceShape;
+declare const index$k_HDWalletTest: typeof HDWalletTest;
+declare const index$k_HardenedDerivationError: typeof HardenedDerivationError;
+declare const index$k_InvalidPathError: typeof InvalidPathError;
+declare const index$k_InvalidSeedError: typeof InvalidSeedError;
+declare const index$k_derive: typeof derive;
+declare const index$k_fromMnemonic: typeof fromMnemonic;
+declare const index$k_fromSeed: typeof fromSeed;
+declare const index$k_getPrivateKey: typeof getPrivateKey;
+declare const index$k_mapToHDWalletError: typeof mapToHDWalletError;
+declare const index$k_withPrivateKey: typeof withPrivateKey;
+declare const index$k_withSeed: typeof withSeed;
+declare namespace index$k {
+  export { index$k_HDNode as HDNode, index$k_HDPath as HDPath, index$k_HDWalletError as HDWalletError, index$k_HDWalletService as HDWalletService, index$k_HDWalletServiceShape as HDWalletServiceShape, index$k_HDWalletTest as HDWalletTest, index$k_HardenedDerivationError as HardenedDerivationError, InvalidKeyError$1 as InvalidKeyError, index$k_InvalidPathError as InvalidPathError, index$k_InvalidSeedError as InvalidSeedError, index$k_derive as derive, index$k_fromMnemonic as fromMnemonic, index$k_fromSeed as fromSeed, generateMnemonic$1 as generateMnemonic, index$k_getPrivateKey as getPrivateKey, getPublicKey$1 as getPublicKey, index$k_mapToHDWalletError as mapToHDWalletError, mnemonicToSeed$1 as mnemonicToSeed, index$k_withPrivateKey as withPrivateKey, index$k_withSeed as withSeed };
 }
 
 /**
@@ -1189,14 +1253,14 @@ declare namespace index$j {
  * @since 0.0.1
  */
 
-declare const index$i_HMACLive: typeof HMACLive;
-declare const index$i_HMACService: typeof HMACService;
-declare const index$i_HMACServiceShape: typeof HMACServiceShape;
-declare const index$i_HMACTest: typeof HMACTest;
-declare const index$i_hmacSha256: typeof hmacSha256;
-declare const index$i_hmacSha512: typeof hmacSha512;
-declare namespace index$i {
-  export { index$i_HMACLive as HMACLive, index$i_HMACService as HMACService, index$i_HMACServiceShape as HMACServiceShape, index$i_HMACTest as HMACTest, index$i_hmacSha256 as hmacSha256, index$i_hmacSha512 as hmacSha512 };
+declare const index$j_HMACLive: typeof HMACLive;
+declare const index$j_HMACService: typeof HMACService;
+declare const index$j_HMACServiceShape: typeof HMACServiceShape;
+declare const index$j_HMACTest: typeof HMACTest;
+declare const index$j_hmacSha256: typeof hmacSha256;
+declare const index$j_hmacSha512: typeof hmacSha512;
+declare namespace index$j {
+  export { index$j_HMACLive as HMACLive, index$j_HMACService as HMACService, index$j_HMACServiceShape as HMACServiceShape, index$j_HMACTest as HMACTest, index$j_hmacSha256 as hmacSha256, index$j_hmacSha512 as hmacSha512 };
 }
 
 /**
@@ -1231,14 +1295,14 @@ declare namespace index$i {
  * @see {@link https://eips.ethereum.org/EIPS/eip-2335 | EIP-2335}
  */
 
-declare const index$h_DecryptError: typeof DecryptError;
-declare const index$h_KeystoreLive: typeof KeystoreLive;
-declare const index$h_KeystoreService: typeof KeystoreService;
-declare const index$h_KeystoreServiceShape: typeof KeystoreServiceShape;
-declare const index$h_KeystoreTest: typeof KeystoreTest;
-declare const index$h_withDecryptedKey: typeof withDecryptedKey;
-declare namespace index$h {
-  export { index$h_DecryptError as DecryptError, index$h_KeystoreLive as KeystoreLive, index$h_KeystoreService as KeystoreService, index$h_KeystoreServiceShape as KeystoreServiceShape, index$h_KeystoreTest as KeystoreTest, decrypt$1 as decrypt, encrypt$1 as encrypt, index$h_withDecryptedKey as withDecryptedKey };
+declare const index$i_DecryptError: typeof DecryptError;
+declare const index$i_KeystoreLive: typeof KeystoreLive;
+declare const index$i_KeystoreService: typeof KeystoreService;
+declare const index$i_KeystoreServiceShape: typeof KeystoreServiceShape;
+declare const index$i_KeystoreTest: typeof KeystoreTest;
+declare const index$i_withDecryptedKey: typeof withDecryptedKey;
+declare namespace index$i {
+  export { index$i_DecryptError as DecryptError, index$i_KeystoreLive as KeystoreLive, index$i_KeystoreService as KeystoreService, index$i_KeystoreServiceShape as KeystoreServiceShape, index$i_KeystoreTest as KeystoreTest, decrypt$1 as decrypt, encrypt$1 as encrypt, index$i_withDecryptedKey as withDecryptedKey };
 }
 
 /**
@@ -1274,16 +1338,16 @@ declare namespace index$h {
  * @see {@link https://eips.ethereum.org/EIPS/eip-4844 | EIP-4844}
  */
 
-declare const index$g_KZGError: typeof KZGError;
-declare const index$g_KZGLive: typeof KZGLive;
-declare const index$g_KZGService: typeof KZGService;
-declare const index$g_KZGServiceShape: typeof KZGServiceShape;
-declare const index$g_KZGTest: typeof KZGTest;
-declare const index$g_blobToKzgCommitment: typeof blobToKzgCommitment;
-declare const index$g_computeBlobKzgProof: typeof computeBlobKzgProof;
-declare const index$g_verifyBlobKzgProof: typeof verifyBlobKzgProof;
-declare namespace index$g {
-  export { index$g_KZGError as KZGError, index$g_KZGLive as KZGLive, index$g_KZGService as KZGService, index$g_KZGServiceShape as KZGServiceShape, index$g_KZGTest as KZGTest, index$g_blobToKzgCommitment as blobToKzgCommitment, index$g_computeBlobKzgProof as computeBlobKzgProof, index$g_verifyBlobKzgProof as verifyBlobKzgProof };
+declare const index$h_KZGError: typeof KZGError;
+declare const index$h_KZGLive: typeof KZGLive;
+declare const index$h_KZGService: typeof KZGService;
+declare const index$h_KZGServiceShape: typeof KZGServiceShape;
+declare const index$h_KZGTest: typeof KZGTest;
+declare const index$h_blobToKzgCommitment: typeof blobToKzgCommitment;
+declare const index$h_computeBlobKzgProof: typeof computeBlobKzgProof;
+declare const index$h_verifyBlobKzgProof: typeof verifyBlobKzgProof;
+declare namespace index$h {
+  export { index$h_KZGError as KZGError, index$h_KZGLive as KZGLive, index$h_KZGService as KZGService, index$h_KZGServiceShape as KZGServiceShape, index$h_KZGTest as KZGTest, index$h_blobToKzgCommitment as blobToKzgCommitment, index$h_computeBlobKzgProof as computeBlobKzgProof, index$h_verifyBlobKzgProof as verifyBlobKzgProof };
 }
 
 /**
@@ -1319,15 +1383,15 @@ declare namespace index$g {
  * @see {@link https://eips.ethereum.org/EIPS/eip-2565 | EIP-2565}
  */
 
-declare const index$f_ModExpLive: typeof ModExpLive;
-declare const index$f_ModExpService: typeof ModExpService;
-declare const index$f_ModExpServiceShape: typeof ModExpServiceShape;
-declare const index$f_ModExpTest: typeof ModExpTest;
-declare const index$f_calculateGas: typeof calculateGas;
-declare const index$f_modexp: typeof modexp;
-declare const index$f_modexpBytes: typeof modexpBytes;
-declare namespace index$f {
-  export { index$f_ModExpLive as ModExpLive, index$f_ModExpService as ModExpService, index$f_ModExpServiceShape as ModExpServiceShape, index$f_ModExpTest as ModExpTest, index$f_calculateGas as calculateGas, index$f_modexp as modexp, index$f_modexpBytes as modexpBytes };
+declare const index$g_ModExpLive: typeof ModExpLive;
+declare const index$g_ModExpService: typeof ModExpService;
+declare const index$g_ModExpServiceShape: typeof ModExpServiceShape;
+declare const index$g_ModExpTest: typeof ModExpTest;
+declare const index$g_calculateGas: typeof calculateGas;
+declare const index$g_modexp: typeof modexp;
+declare const index$g_modexpBytes: typeof modexpBytes;
+declare namespace index$g {
+  export { index$g_ModExpLive as ModExpLive, index$g_ModExpService as ModExpService, index$g_ModExpServiceShape as ModExpServiceShape, index$g_ModExpTest as ModExpTest, index$g_calculateGas as calculateGas, index$g_modexp as modexp, index$g_modexpBytes as modexpBytes };
 }
 
 /**
@@ -1363,11 +1427,11 @@ declare namespace index$f {
  * @since 0.0.1
  */
 
-declare const index$e_P256Live: typeof P256Live;
-declare const index$e_P256Service: typeof P256Service;
-declare const index$e_P256ServiceShape: typeof P256ServiceShape;
-declare namespace index$e {
-  export { index$e_P256Live as P256Live, index$e_P256Service as P256Service, index$e_P256ServiceShape as P256ServiceShape, sign$3 as sign, verify$3 as verify };
+declare const index$f_P256Live: typeof P256Live;
+declare const index$f_P256Service: typeof P256Service;
+declare const index$f_P256ServiceShape: typeof P256ServiceShape;
+declare namespace index$f {
+  export { index$f_P256Live as P256Live, index$f_P256Service as P256Service, index$f_P256ServiceShape as P256ServiceShape, sign$3 as sign, verify$3 as verify };
 }
 
 /**
@@ -1399,11 +1463,11 @@ declare namespace index$e {
  * @since 0.0.1
  */
 
-declare const index$d_Ripemd160Live: typeof Ripemd160Live;
-declare const index$d_Ripemd160Service: typeof Ripemd160Service;
-declare const index$d_Ripemd160Test: typeof Ripemd160Test;
-declare namespace index$d {
-  export { index$d_Ripemd160Live as Ripemd160Live, index$d_Ripemd160Service as Ripemd160Service, index$d_Ripemd160Test as Ripemd160Test, hash$2 as hash };
+declare const index$e_Ripemd160Live: typeof Ripemd160Live;
+declare const index$e_Ripemd160Service: typeof Ripemd160Service;
+declare const index$e_Ripemd160Test: typeof Ripemd160Test;
+declare namespace index$e {
+  export { index$e_Ripemd160Live as Ripemd160Live, index$e_Ripemd160Service as Ripemd160Service, index$e_Ripemd160Test as Ripemd160Test, hash$2 as hash };
 }
 
 /**
@@ -1452,11 +1516,11 @@ declare namespace index$d {
  * @since 0.0.1
  */
 
-declare const index$c_SHA256Live: typeof SHA256Live;
-declare const index$c_SHA256Service: typeof SHA256Service;
-declare const index$c_SHA256Test: typeof SHA256Test;
-declare namespace index$c {
-  export { index$c_SHA256Live as SHA256Live, index$c_SHA256Service as SHA256Service, index$c_SHA256Test as SHA256Test, hash$3 as hash };
+declare const index$d_SHA256Live: typeof SHA256Live;
+declare const index$d_SHA256Service: typeof SHA256Service;
+declare const index$d_SHA256Test: typeof SHA256Test;
+declare namespace index$d {
+  export { index$d_SHA256Live as SHA256Live, index$d_SHA256Service as SHA256Service, index$d_SHA256Test as SHA256Test, hash$3 as hash };
 }
 
 /**
@@ -1494,14 +1558,14 @@ declare namespace index$c {
  * @see {@link https://datatracker.ietf.org/doc/html/rfc7748 | RFC 7748}
  */
 
-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 };
+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 };
 }
 
 type JsonRpcIdType = number | string | null;
@@ -2049,13 +2113,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$1<TResult = unknown>(raw: unknown): Effect.Effect<JsonRpcResponseType<TResult>, JsonRpcParseError>;
+declare function parse$2<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$1;
+    parse: typeof parse$2;
     isSuccess: typeof isSuccess;
     isError: typeof isError;
     unwrap: typeof unwrap;
@@ -2063,13 +2127,13 @@ declare const Response: {
 
 type BatchResponseType = readonly JsonRpcResponseType[];
 declare function from(raw: unknown[]): BatchResponseType;
-declare function parse(raw: unknown): Effect.Effect<BatchResponseType, JsonRpcParseError>;
+declare function parse$1(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;
+    parse: typeof parse$1;
     findById: typeof findById;
     errors: typeof errors;
     results: typeof results;
@@ -3248,40 +3312,40 @@ declare const AnvilMethodRequest: S.Union<[S.Struct<{
 /** Type for AnvilMethodRequest union */
 type AnvilMethodRequestType = S.Schema.Type<typeof AnvilMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -7095,309 +7159,309 @@ declare const EthMethodRequest: S.Union<[S.Struct<{
 /** Type for EthMethodRequest union */
 type EthMethodRequestType = S.Schema.Type<typeof EthMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -7817,65 +7881,65 @@ declare const HardhatMethodRequest: S.Union<[S.Struct<{
 /** Type for HardhatMethodRequest union */
 type HardhatMethodRequestType = S.Schema.Type<typeof HardhatMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -8021,28 +8085,28 @@ declare const NetMethodRequest: S.Union<[S.Struct<{
 /** Type for NetMethodRequest union */
 type NetMethodRequestType = S.Schema.Type<typeof NetMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -8383,29 +8447,29 @@ declare const TxpoolMethodRequest: S.Union<[S.Struct<{
 /** Type for TxpoolMethodRequest union */
 type TxpoolMethodRequestType = S.Schema.Type<typeof TxpoolMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -9262,99 +9326,99 @@ declare const WalletMethodRequest: S.Union<[S.Struct<{
 /** Type for WalletMethodRequest union */
 type WalletMethodRequestType = S.Schema.Type<typeof WalletMethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -9457,20 +9521,20 @@ declare const Web3MethodRequest: S.Union<[S.Struct<{
 /** Type for Web3MethodRequest union */
 type Web3MethodRequestType = S.Schema.Type<typeof Web3MethodRequest>;
 
-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 };
+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 };
 }
 
 /**
@@ -10476,13 +10540,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10501,13 +10565,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10538,13 +10602,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10573,8 +10637,8 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly time?: string | undefined;
         readonly gasLimit?: string | undefined;
         readonly coinbase?: string | undefined;
-        readonly random?: string | undefined;
         readonly baseFee?: string | undefined;
+        readonly random?: string | undefined;
         readonly blobBaseFee?: string | undefined;
     }];
     readonly jsonrpc: "2.0";
@@ -10599,13 +10663,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10629,13 +10693,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10654,13 +10718,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10679,13 +10743,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10893,13 +10957,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -10928,13 +10992,13 @@ declare const decodeRequest: (u: unknown, overrideOptions?: effect_SchemaAST.Par
         readonly to?: string | null | undefined;
         readonly value?: string | undefined;
         readonly gas?: string | undefined;
-        readonly gasPrice?: string | undefined;
-        readonly maxFeePerGas?: string | undefined;
-        readonly maxPriorityFeePerGas?: string | undefined;
         readonly accessList?: readonly {
             readonly address: string;
             readonly storageKeys: readonly string[];
         }[] | undefined;
+        readonly gasPrice?: string | undefined;
+        readonly maxFeePerGas?: string | undefined;
+        readonly maxPriorityFeePerGas?: string | undefined;
         readonly maxFeePerBlobGas?: string | undefined;
         readonly blobVersionedHashes?: readonly string[] | undefined;
         readonly authorizationList?: readonly {
@@ -11221,73 +11285,73 @@ declare const isErrorResponse: (response: GenericJsonRpcResponseType) => respons
  */
 declare const isSuccessResponse: (response: GenericJsonRpcResponseType) => response is S.Schema.Type<typeof GenericJsonRpcSuccessResponse>;
 
-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 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 StatusRequest: () => JsonRpcRequestType;
@@ -11383,101 +11447,2256 @@ declare namespace Web3$1 {
   export { Web3$1_ClientVersionRequest as ClientVersionRequest, Web3$1_Sha3Request as Sha3Request, Web3$1_Web3 as Web3 };
 }
 
-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;
-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_nextId: typeof nextId;
-declare const index$2_parseErrorCode: typeof parseErrorCode;
-declare const index$2_resetId: typeof resetId;
-declare const index$2_unwrap: typeof unwrap;
-declare const index$2_withParams: typeof withParams;
+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 namespace index$2 {
-  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_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_nextId as nextId, index$2_parseErrorCode as parseErrorCode, from$4 as requestFrom, index$2_resetId as resetId, from$1 as responseFrom, parse$1 as responseParse, index$2_unwrap as unwrap, index$2_withParams as withParams };
+  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 };
 }
 
 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 & {
@@ -11958,4 +14177,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$s as Auth, type BackfillStreamOptions, index$q as Bip39, index$p as Blake2, index$r as BlockUtils, index$o as Bls12381, index$n as Bn254, index$m as ChaCha20Poly1305, index$t as EIP712, ERC1155, ERC165, ERC20, index$k as ERC6492, ERC721, index$l as Ed25519, EventStream, EventStreamError, EventStreamService, type EventStreamShape, index$j as HDWallet, index$i as HMAC, index$2 as JsonRpc, index$g as KZG, index$v as Keccak256, index$h as Keystore, index$f as ModExp, index$e as P256, ProviderService, index$d as Ripemd160, index$c as SHA256, index$u as Secp256k1, StandardsError, index$1 as Stream, TransportService, index as Unit, type WatchStreamOptions, index$b as X25519, makeEventStream };
+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 };