voltaire-effect 0.2.23

package/dist/AccountService-BetXokad.d.ts

@@ -0,0 +1,1717 @@
+import { Keccak256Hash } from '@tevm/voltaire';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { HexType } from '@tevm/voltaire/Hex';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { AddressType } from '@tevm/voltaire/Address';
+import { HashType } from '@tevm/voltaire/Hash';
+import { BlockInclude, WatchOptions, BlockStreamEvent, BackfillOptions, BlocksEvent } from '@tevm/voltaire/block';
+import * as Stream from 'effect/Stream';
+
+/**
+ * @fileoverview Keccak-256 service definition and layer implementations for Effect.
+ *
+ * @description
+ * Provides the KeccakService Effect Tag and both production (KeccakLive) and
+ * test (KeccakTest) layer implementations. The service pattern enables
+ * dependency injection for testability and flexibility.
+ *
+ * @module Keccak256/KeccakService
+ * @since 0.0.1
+ */
+
+/**
+ * Shape interface for the Keccak-256 hashing service.
+ *
+ * @description
+ * Defines the contract for Keccak-256 hash implementations.
+ * Used as the service shape for {@link KeccakService}.
+ *
+ * @since 0.0.1
+ */
+interface KeccakServiceShape {
+    /**
+     * Computes the Keccak-256 hash of input data.
+     *
+     * @param {Uint8Array} data - The input bytes to hash (any length)
+     * @returns {Effect.Effect<Keccak256Hash>} Effect containing the 32-byte hash
+     */
+    readonly hash: (data: Uint8Array) => Effect.Effect<Keccak256Hash>;
+}
+declare const KeccakService_base: Context.TagClass<KeccakService, "KeccakService", KeccakServiceShape>;
+/**
+ * Keccak-256 hashing service for Effect-based applications.
+ *
+ * @description
+ * An Effect Context.Tag that provides the standard Ethereum hashing algorithm
+ * used for addresses, signatures, state roots, and more. The service pattern
+ * enables swapping implementations for testing or alternative backends.
+ *
+ * The service exposes a single `hash` method that takes arbitrary bytes and
+ * produces a 32-byte Keccak-256 hash.
+ *
+ * @example Basic usage with Effect.gen
+ * ```typescript
+ * import { KeccakService, KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const keccak = yield* KeccakService
+ *   return yield* keccak.hash(new Uint8Array([1, 2, 3]))
+ * }).pipe(Effect.provide(KeccakLive))
+ *
+ * const hash = await Effect.runPromise(program)
+ * ```
+ *
+ * @example Chaining multiple hashes
+ * ```typescript
+ * import { KeccakService, KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const doubleHash = Effect.gen(function* () {
+ *   const keccak = yield* KeccakService
+ *   const first = yield* keccak.hash(new Uint8Array([1, 2, 3]))
+ *   return yield* keccak.hash(first)
+ * }).pipe(Effect.provide(KeccakLive))
+ * ```
+ *
+ * @example Composing with other services
+ * ```typescript
+ * import { KeccakService, KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * import { Secp256k1Service, Secp256k1Live } from 'voltaire-effect/crypto/Secp256k1'
+ * import * as Effect from 'effect/Effect'
+ * import * as Layer from 'effect/Layer'
+ *
+ * const program = Effect.gen(function* () {
+ *   const keccak = yield* KeccakService
+ *   const secp = yield* Secp256k1Service
+ *   const msgHash = yield* keccak.hash(message)
+ *   return yield* secp.sign(msgHash, privateKey)
+ * }).pipe(Effect.provide(Layer.merge(KeccakLive, Secp256k1Live)))
+ * ```
+ *
+ * @see {@link KeccakLive} - Production implementation
+ * @see {@link KeccakTest} - Test implementation
+ * @see {@link hash} - Standalone hash function
+ * @since 0.0.1
+ */
+declare class KeccakService extends KeccakService_base {
+}
+/**
+ * Production layer for KeccakService using native Keccak-256 implementation.
+ *
+ * @description
+ * Provides the real Keccak-256 hash implementation from the voltaire library.
+ * Use this layer in production applications for cryptographically secure hashing.
+ *
+ * The underlying implementation uses optimized native code (Zig/Rust) for
+ * high-performance hashing.
+ *
+ * @example Providing the live layer
+ * ```typescript
+ * import { KeccakService, KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const keccak = yield* KeccakService
+ *   return yield* keccak.hash(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))
+ * })
+ *
+ * const result = await Effect.runPromise(program.pipe(Effect.provide(KeccakLive)))
+ * ```
+ *
+ * @example Merging with other layers
+ * ```typescript
+ * import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'
+ * import { SHA256Live } from 'voltaire-effect/crypto/SHA256'
+ * import * as Layer from 'effect/Layer'
+ *
+ * const CryptoLive = Layer.merge(KeccakLive, SHA256Live)
+ * ```
+ *
+ * @see {@link KeccakService} - The service tag
+ * @see {@link KeccakTest} - Test implementation for unit tests
+ * @since 0.0.1
+ */
+declare const KeccakLive: Layer.Layer<KeccakService, never, never>;
+/**
+ * Test layer for KeccakService returning deterministic zero-filled hashes.
+ *
+ * @description
+ * Provides a mock Keccak-256 implementation that always returns a 32-byte
+ * array filled with zeros. Use for unit testing without cryptographic overhead
+ * when the actual hash value doesn't matter for the test.
+ *
+ * This layer is useful for:
+ * - Unit tests that need deterministic output
+ * - Performance tests that want to isolate non-crypto logic
+ * - Tests where the hash value is not validated
+ *
+ * @example Using in tests
+ * ```typescript
+ * import { KeccakService, KeccakTest } from 'voltaire-effect/crypto/Keccak256'
+ * import * as Effect from 'effect/Effect'
+ * import { describe, it, expect } from 'vitest'
+ *
+ * describe('MyService', () => {
+ *   it('should hash data', async () => {
+ *     const program = Effect.gen(function* () {
+ *       const keccak = yield* KeccakService
+ *       return yield* keccak.hash(new Uint8Array([1, 2, 3]))
+ *     })
+ *
+ *     const result = await Effect.runPromise(program.pipe(Effect.provide(KeccakTest)))
+ *     expect(result).toEqual(new Uint8Array(32)) // All zeros
+ *   })
+ * })
+ * ```
+ *
+ * @see {@link KeccakService} - The service tag
+ * @see {@link KeccakLive} - Production implementation
+ * @since 0.0.1
+ */
+declare const KeccakTest: Layer.Layer<KeccakService, never, never>;
+
+/**
+ * @fileoverview Transport error class for JSON-RPC communication failures.
+ *
+ * @module TransportError
+ * @since 0.0.1
+ *
+ * @description
+ * Defines the error type used by all transport implementations when JSON-RPC
+ * communication fails. The error includes the JSON-RPC error code, message,
+ * and optional additional data for debugging.
+ *
+ * Common JSON-RPC error codes:
+ * - -32700: Parse error
+ * - -32600: Invalid request
+ * - -32601: Method not found
+ * - -32602: Invalid params
+ * - -32603: Internal error
+ * - -32000 to -32099: Server errors (implementation-defined)
+ *
+ * @see {@link TransportService} - The service that uses this error type
+ */
+declare const TransportError_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: "TransportError";
+} & Readonly<A>;
+/**
+ * Error thrown when a transport operation fails.
+ *
+ * @description
+ * Contains JSON-RPC error code and optional data for debugging.
+ * This error is thrown by all transport implementations (HttpTransport,
+ * WebSocketTransport, BrowserTransport) when a JSON-RPC request fails.
+ *
+ * The error includes:
+ * - `code`: Standard JSON-RPC error code
+ * - `message`: Human-readable error description
+ * - `data`: Optional additional error data from the provider
+ *
+ * @since 0.0.1
+ *
+ * @example Creating a transport error
+ * ```typescript
+ * const error = new TransportError({
+ *   code: -32603,
+ *   message: 'Internal error',
+ *   data: { details: 'Connection refused' }
+ * })
+ *
+ * console.log(error.code)    // -32603
+ * console.log(error.message) // 'Internal error'
+ * console.log(error.data)    // { details: 'Connection refused' }
+ * ```
+ *
+ * @example Handling transport errors in Effect
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { TransportService, TransportError, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const transport = yield* TransportService
+ *   return yield* transport.request<string>('eth_blockNumber')
+ * }).pipe(
+ *   Effect.catchTag('TransportError', (error) => {
+ *     if (error.code === -32601) {
+ *       console.log('Method not supported by this node')
+ *     }
+ *     return Effect.fail(error)
+ *   }),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ *
+ * @see {@link TransportService} - The service that produces this error
+ */
+declare class TransportError extends TransportError_base<{
+    /**
+     * The original input that caused the error.
+     */
+    readonly input: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    /**
+     * JSON-RPC error code.
+     */
+    readonly code: number;
+    /**
+     * Human-readable error message.
+     */
+    readonly message: string;
+    /**
+     * Additional error data from the JSON-RPC response.
+     *
+     * @description
+     * May contain provider-specific error details such as revert reasons,
+     * stack traces, or other debugging information.
+     */
+    readonly data?: unknown;
+    /**
+     * Optional underlying cause.
+     */
+    readonly cause?: unknown;
+    /**
+     * Optional context for debugging.
+     */
+    readonly context?: Record<string, unknown>;
+}> {
+    /**
+     * Creates a new TransportError.
+     *
+     * @param input - JSON-RPC error response containing code, message, and optional data
+     * @param message - Optional override for the error message
+     * @param options - Optional error options
+     * @param options.cause - Underlying error that caused this failure
+     */
+    constructor(input: {
+        code: number;
+        message: string;
+        data?: unknown;
+    }, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+
+/**
+ * @fileoverview Blocks service definition for block-related JSON-RPC calls.
+ *
+ * @module BlocksService
+ * @since 0.3.0
+ *
+ * @description
+ * The BlocksService provides block and uncle lookup operations split out of
+ * ProviderService. This includes block numbers, block bodies, transaction counts,
+ * and uncle retrieval/counts.
+ *
+ * @see {@link ProviderService} - Combined convenience service
+ */
+
+/**
+ * Shape of the Blocks service.
+ *
+ * @since 0.3.0
+ */
+type BlocksShape = {
+    /** Gets the current block number */
+    readonly getBlockNumber: () => Effect.Effect<bigint, GetBlockNumberError>;
+    /** Gets a block by tag, hash, or number */
+    readonly getBlock: (args?: GetBlockArgs) => Effect.Effect<BlockType, GetBlockError>;
+    /** Gets the transaction count in a block */
+    readonly getBlockTransactionCount: (args: GetBlockTransactionCountArgs) => Effect.Effect<bigint, GetBlockTransactionCountError>;
+    /** Gets all receipts for a block (if supported by the node) */
+    readonly getBlockReceipts?: (args?: GetBlockReceiptsArgs) => Effect.Effect<ReceiptType[], GetBlockReceiptsError>;
+    /** Gets an uncle block by block identifier and index */
+    readonly getUncle: (args: GetUncleArgs, uncleIndex: `0x${string}`) => Effect.Effect<UncleBlockType, GetUncleError>;
+    /** Gets the number of uncles in a block (if supported by the node) */
+    readonly getUncleCount?: (args: GetUncleCountArgs) => Effect.Effect<bigint, GetUncleCountError>;
+};
+declare const BlocksService_base: Context.TagClass<BlocksService, "BlocksService", BlocksShape>;
+/**
+ * Blocks service for block-related JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class BlocksService extends BlocksService_base {
+}
+
+/**
+ * @fileoverview Events service definition for log/filter JSON-RPC calls.
+ *
+ * @module EventsService
+ * @since 0.3.0
+ */
+
+/**
+ * Shape of the Events service.
+ *
+ * @since 0.3.0
+ */
+type EventsShape = {
+    /** Gets logs matching the filter */
+    readonly getLogs: (filter: LogFilter) => Effect.Effect<LogType[], GetLogsError>;
+    /** Creates an event filter (eth_newFilter) */
+    readonly createEventFilter: (filter?: EventFilter) => Effect.Effect<FilterId, CreateEventFilterError>;
+    /** Creates a new block filter (eth_newBlockFilter) */
+    readonly createBlockFilter: () => Effect.Effect<FilterId, CreateBlockFilterError>;
+    /** Creates a pending transaction filter (eth_newPendingTransactionFilter) */
+    readonly createPendingTransactionFilter: () => Effect.Effect<FilterId, CreatePendingTransactionFilterError>;
+    /** Gets changes since last poll for a filter (eth_getFilterChanges) */
+    readonly getFilterChanges: (filterId: FilterId) => Effect.Effect<FilterChanges, GetFilterChangesError>;
+    /** Gets all logs for a filter (eth_getFilterLogs) */
+    readonly getFilterLogs: (filterId: FilterId) => Effect.Effect<LogType[], GetFilterLogsError>;
+    /** Uninstalls a filter (eth_uninstallFilter) */
+    readonly uninstallFilter: (filterId: FilterId) => Effect.Effect<boolean, UninstallFilterError>;
+};
+declare const EventsService_base: Context.TagClass<EventsService, "EventsService", EventsShape>;
+/**
+ * Events service for log and filter JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class EventsService extends EventsService_base {
+}
+
+/**
+ * @fileoverview Network service definition for network/meta JSON-RPC calls.
+ *
+ * @module NetworkService
+ * @since 0.3.0
+ */
+
+/**
+ * Syncing status as returned by eth_syncing.
+ *
+ * @since 0.3.0
+ */
+type SyncingStatus = false | {
+    startingBlock: string;
+    currentBlock: string;
+    highestBlock: string;
+    [key: string]: string;
+};
+/**
+ * Result tuple for eth_getWork.
+ *
+ * @since 0.3.0
+ */
+type WorkResult = [`0x${string}`, `0x${string}`, `0x${string}`];
+/**
+ * Shape of the Network service.
+ *
+ * @since 0.3.0
+ */
+type NetworkShape = {
+    /** Gets the chain ID */
+    readonly getChainId: () => Effect.Effect<number, GetChainIdError>;
+    /** Gets the current gas price */
+    readonly getGasPrice: () => Effect.Effect<bigint, GetGasPriceError>;
+    /** Gets the max priority fee per gas (EIP-1559) */
+    readonly getMaxPriorityFeePerGas: () => Effect.Effect<bigint, GetMaxPriorityFeePerGasError>;
+    /** Gets fee history for gas estimation */
+    readonly getFeeHistory: (blockCount: number, newestBlock: BlockTag, rewardPercentiles: number[]) => Effect.Effect<FeeHistoryType, GetFeeHistoryError>;
+    /** Gets the blob base fee (EIP-4844) */
+    readonly getBlobBaseFee: () => Effect.Effect<bigint, GetBlobBaseFeeError>;
+    /** Gets syncing status (if supported) */
+    readonly getSyncing?: () => Effect.Effect<SyncingStatus, GetSyncingError>;
+    /** Gets available accounts (if supported) */
+    readonly getAccounts?: () => Effect.Effect<`0x${string}`[], GetAccountsError>;
+    /** Gets coinbase address (if supported) */
+    readonly getCoinbase?: () => Effect.Effect<`0x${string}`, GetCoinbaseError>;
+    /** Gets network version (net_version) */
+    readonly netVersion?: () => Effect.Effect<string, NetVersionError>;
+    /** Gets protocol version (eth_protocolVersion) */
+    readonly getProtocolVersion?: () => Effect.Effect<string, GetProtocolVersionError>;
+    /** Returns whether the client is mining (eth_mining) */
+    readonly getMining?: () => Effect.Effect<boolean, GetMiningError>;
+    /** Gets the current hashrate (eth_hashrate) */
+    readonly getHashrate?: () => Effect.Effect<bigint, GetHashrateError>;
+    /** Gets work package for mining (eth_getWork) */
+    readonly getWork?: () => Effect.Effect<WorkResult, GetWorkError>;
+    /** Submits a mining solution (eth_submitWork) */
+    readonly submitWork?: (nonce: `0x${string}`, powHash: `0x${string}`, mixDigest: `0x${string}`) => Effect.Effect<boolean, SubmitWorkError>;
+    /** Submits mining hashrate (eth_submitHashrate) */
+    readonly submitHashrate?: (hashrate: `0x${string}`, id: `0x${string}`) => Effect.Effect<boolean, SubmitHashrateError>;
+};
+declare const NetworkService_base: Context.TagClass<NetworkService, "NetworkService", NetworkShape>;
+/**
+ * Network service for network/meta JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class NetworkService extends NetworkService_base {
+}
+
+/**
+ * @fileoverview Simulation service definition for call and simulation JSON-RPC methods.
+ *
+ * @module SimulationService
+ * @since 0.3.0
+ */
+
+/**
+ * Single block simulation input for eth_simulateV1.
+ *
+ * @since 0.3.0
+ */
+interface SimulateV1BlockCall {
+    /** Optional block overrides applied during the simulation */
+    readonly blockOverrides?: BlockOverrides;
+    /** Optional state overrides applied during the simulation */
+    readonly stateOverrides?: StateOverride;
+    /** Calls to execute within the block */
+    readonly calls: readonly CallRequest[];
+}
+/**
+ * Payload for eth_simulateV1.
+ *
+ * @since 0.3.0
+ */
+interface SimulateV1Payload {
+    /** Sequence of block simulations to execute */
+    readonly blockStateCalls: readonly SimulateV1BlockCall[];
+    /** Enable transfer tracing (if supported by node) */
+    readonly traceTransfers?: boolean;
+    /** Enable validation mode (if supported by node) */
+    readonly validation?: boolean;
+    /** Return full transaction objects (if supported) */
+    readonly returnFullTransactions?: boolean;
+}
+/**
+ * Call result from eth_simulateV1.
+ *
+ * @since 0.3.0
+ */
+interface SimulateV1CallResult {
+    /** Call execution status (0x1 success, 0x0 revert) */
+    readonly status: `0x${string}`;
+    /** Return data (hex) */
+    readonly returnData: `0x${string}`;
+    /** Gas used (hex) */
+    readonly gasUsed: `0x${string}`;
+    /** Logs emitted by the call */
+    readonly logs?: LogType[];
+    /** Optional error information */
+    readonly error?: {
+        code?: number;
+        message?: string;
+    };
+}
+/**
+ * Simulated block result from eth_simulateV1.
+ *
+ * @since 0.3.0
+ */
+interface SimulateV1BlockResult {
+    /** Base fee per gas (hex) */
+    readonly baseFeePerGas?: `0x${string}`;
+    /** Blob gas used (hex) */
+    readonly blobGasUsed?: `0x${string}`;
+    /** Calls executed in the block */
+    readonly calls: SimulateV1CallResult[];
+    /** Gas limit (hex) */
+    readonly gasLimit?: `0x${string}`;
+    /** Gas used (hex) */
+    readonly gasUsed?: `0x${string}`;
+    /** Simulated block hash */
+    readonly hash?: `0x${string}`;
+    /** Simulated block number (hex) */
+    readonly number?: `0x${string}`;
+    /** Simulated block timestamp (hex) */
+    readonly timestamp?: `0x${string}`;
+}
+/**
+ * Result type for eth_simulateV1.
+ *
+ * @since 0.3.0
+ */
+type SimulateV1Result = SimulateV1BlockResult[];
+/**
+ * Payload for eth_simulateV2 (draft / evolving).
+ *
+ * @since 0.3.0
+ */
+type SimulateV2Payload = Record<string, unknown>;
+/**
+ * Result type for eth_simulateV2 (draft / evolving).
+ *
+ * @since 0.3.0
+ */
+type SimulateV2Result = unknown;
+/**
+ * Shape of the Simulation service.
+ *
+ * @since 0.3.0
+ */
+type SimulationShape = {
+    /** Executes a call without sending a transaction */
+    readonly call: (tx: CallRequest, blockTag?: BlockTag, stateOverride?: StateOverride, blockOverrides?: BlockOverrides) => Effect.Effect<HexType | `0x${string}`, CallError>;
+    /** Estimates gas for a transaction */
+    readonly estimateGas: (tx: CallRequest, blockTag?: BlockTag, stateOverride?: StateOverride) => Effect.Effect<bigint, EstimateGasError>;
+    /** Creates an access list for a transaction */
+    readonly createAccessList: (tx: CallRequest) => Effect.Effect<AccessListType, CreateAccessListError>;
+    /** Simulates multiple blocks and calls (if supported) */
+    readonly simulateV1?: (payload: SimulateV1Payload, blockTag?: BlockTag) => Effect.Effect<SimulateV1Result, SimulateV1Error>;
+    /** Simulates with the V2 API (draft / evolving, if supported) */
+    readonly simulateV2?: <TResult = SimulateV2Result>(payload: SimulateV2Payload, blockTag?: BlockTag) => Effect.Effect<TResult, SimulateV2Error>;
+};
+declare const SimulationService_base: Context.TagClass<SimulationService, "SimulationService", SimulationShape>;
+/**
+ * Simulation service for call/simulation JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class SimulationService extends SimulationService_base {
+}
+
+/**
+ * @fileoverview Streaming service definition for streaming JSON-RPC calls.
+ *
+ * @module StreamingService
+ * @since 0.3.0
+ */
+
+/**
+ * Shape of the Streaming service.
+ *
+ * @since 0.3.0
+ */
+type StreamingShape = {
+    /** Watch for new blocks with reorg detection */
+    readonly watchBlocks: <TInclude extends BlockInclude = "header">(options?: WatchOptions<TInclude>) => Stream.Stream<BlockStreamEvent<TInclude>, WatchBlocksError>;
+    /** Backfill historical blocks */
+    readonly backfillBlocks: <TInclude extends BlockInclude = "header">(options: BackfillOptions<TInclude>) => Stream.Stream<BlocksEvent<TInclude>, BackfillBlocksError>;
+    /** Subscribes to JSON-RPC streams (eth_subscribe) */
+    readonly subscribe?: (subscription: string, params?: readonly unknown[]) => Effect.Effect<`0x${string}`, SubscribeError>;
+    /** Unsubscribes from JSON-RPC streams (eth_unsubscribe) */
+    readonly unsubscribe?: (subscriptionId: `0x${string}`) => Effect.Effect<boolean, UnsubscribeError>;
+};
+declare const StreamingService_base: Context.TagClass<StreamingService, "StreamingService", StreamingShape>;
+/**
+ * Streaming service for block streams and subscriptions.
+ *
+ * @since 0.3.0
+ */
+declare class StreamingService extends StreamingService_base {
+}
+
+/**
+ * @fileoverview Transaction service definition for transaction-related JSON-RPC calls.
+ *
+ * @module TransactionService
+ * @since 0.3.0
+ */
+
+/**
+ * Shape of the Transaction service.
+ *
+ * @since 0.3.0
+ */
+type TransactionShape = {
+    /** Gets a transaction by hash */
+    readonly getTransaction: (hash: HashInput) => Effect.Effect<TransactionType, GetTransactionError>;
+    /** Gets a transaction receipt */
+    readonly getTransactionReceipt: (hash: HashInput) => Effect.Effect<ReceiptType, GetTransactionReceiptError>;
+    /** Gets a transaction by block hash and index (if supported) */
+    readonly getTransactionByBlockHashAndIndex?: (blockHash: HashInput, index: TransactionIndexInput) => Effect.Effect<TransactionType, GetTransactionByBlockHashAndIndexError>;
+    /** Gets a transaction by block number/tag and index (if supported) */
+    readonly getTransactionByBlockNumberAndIndex?: (blockTag: BlockTag | bigint, index: TransactionIndexInput) => Effect.Effect<TransactionType, GetTransactionByBlockNumberAndIndexError>;
+    /** Sends a signed raw transaction */
+    readonly sendRawTransaction: (signedTx: HexType | `0x${string}`) => Effect.Effect<`0x${string}`, SendRawTransactionError>;
+    /** Sends a transaction via unlocked JSON-RPC account (if supported) */
+    readonly sendTransaction?: (tx: RpcTransactionRequest) => Effect.Effect<`0x${string}`, SendTransactionError>;
+    /** Waits for a transaction to be confirmed */
+    readonly waitForTransactionReceipt: (hash: HashInput, opts?: {
+        confirmations?: number;
+        timeout?: number;
+        pollingInterval?: number;
+    }) => Effect.Effect<ReceiptType, WaitForTransactionReceiptError>;
+    /** Gets the number of confirmations for a transaction */
+    readonly getTransactionConfirmations: (hash: HashInput) => Effect.Effect<bigint, GetTransactionConfirmationsError>;
+};
+declare const TransactionService_base: Context.TagClass<TransactionService, "TransactionService", TransactionShape>;
+/**
+ * Transaction service for transaction-related JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class TransactionService extends TransactionService_base {
+}
+
+/**
+ * Address input type that accepts both branded AddressType and plain hex strings.
+ * Provides flexibility for API consumers while maintaining type safety.
+ */
+type AddressInput = AddressType | `0x${string}`;
+/**
+ * Hash input type that accepts both branded HashType and plain hex strings.
+ */
+type HashInput = HashType | `0x${string}`;
+/**
+ * Transaction index input type for block transaction lookups.
+ */
+type TransactionIndexInput = number | bigint | `0x${string}`;
+/**
+ * Filter identifier returned by eth_newFilter methods.
+ *
+ * @since 0.0.1
+ */
+type FilterId = `0x${string}`;
+declare const ProviderResponseError_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: "ProviderResponseError";
+} & Readonly<A>;
+/**
+ * Error thrown when the provider returns an invalid or unexpected response.
+ *
+ * @since 0.0.1
+ */
+declare class ProviderResponseError extends ProviderResponseError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderNotFoundError_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: "ProviderNotFoundError";
+} & Readonly<A>;
+/**
+ * Error thrown when a requested resource is missing (block, tx, receipt, etc.).
+ *
+ * @since 0.0.1
+ */
+declare class ProviderNotFoundError extends ProviderNotFoundError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly resource?: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        resource?: string;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderValidationError_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: "ProviderValidationError";
+} & Readonly<A>;
+/**
+ * Error thrown when inputs fail validation before an RPC call is made.
+ *
+ * @since 0.0.1
+ */
+declare class ProviderValidationError extends ProviderValidationError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderTimeoutError_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: "ProviderTimeoutError";
+} & Readonly<A>;
+/**
+ * Error thrown when waiting for a result exceeds a timeout.
+ *
+ * @since 0.0.1
+ */
+declare class ProviderTimeoutError extends ProviderTimeoutError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly timeoutMs?: number;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        timeoutMs?: number;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderStreamError_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: "ProviderStreamError";
+} & Readonly<A>;
+/**
+ * Error thrown by provider streams (watch/backfill).
+ *
+ * @since 0.0.1
+ */
+declare class ProviderStreamError extends ProviderStreamError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderReceiptPendingError_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: "ProviderReceiptPendingError";
+} & Readonly<A>;
+/**
+ * Error used internally while waiting for a transaction receipt.
+ *
+ * @since 0.0.1
+ */
+declare class ProviderReceiptPendingError extends ProviderReceiptPendingError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+declare const ProviderConfirmationsPendingError_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: "ProviderConfirmationsPendingError";
+} & Readonly<A>;
+/**
+ * Error used internally while waiting for confirmation depth.
+ *
+ * @since 0.0.1
+ */
+declare class ProviderConfirmationsPendingError extends ProviderConfirmationsPendingError_base<{
+    readonly input: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly context?: Record<string, unknown>;
+}> {
+    constructor(input: unknown, message?: string, options?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+    });
+}
+/**
+ * Union of all provider-specific errors (excludes TransportError).
+ *
+ * @since 0.0.1
+ */
+type ProviderError = ProviderResponseError | ProviderNotFoundError | ProviderValidationError | ProviderTimeoutError | ProviderStreamError | ProviderReceiptPendingError | ProviderConfirmationsPendingError;
+/**
+ * Error unions for ProviderService methods.
+ *
+ * @since 0.0.1
+ */
+type GetBlockNumberError = TransportError | ProviderResponseError;
+type GetBlockError = TransportError | ProviderNotFoundError;
+type GetBlockTransactionCountError = TransportError | ProviderResponseError;
+type GetBalanceError = TransportError | ProviderResponseError;
+type GetTransactionCountError = TransportError | ProviderResponseError;
+type GetCodeError = TransportError;
+type GetStorageAtError = TransportError;
+type GetTransactionError = TransportError | ProviderNotFoundError;
+type GetTransactionReceiptError = TransportError | ProviderNotFoundError;
+type WaitForTransactionReceiptError = TransportError | ProviderValidationError | ProviderTimeoutError | ProviderResponseError | ProviderReceiptPendingError | ProviderConfirmationsPendingError;
+type CallError = TransportError;
+type EstimateGasError = TransportError | ProviderResponseError;
+type CreateAccessListError = TransportError;
+type GetLogsError = TransportError;
+type CreateEventFilterError = TransportError;
+type CreateBlockFilterError = TransportError;
+type CreatePendingTransactionFilterError = TransportError;
+type GetFilterChangesError = TransportError;
+type GetFilterLogsError = TransportError;
+type UninstallFilterError = TransportError;
+type GetChainIdError = TransportError | ProviderResponseError | ProviderValidationError;
+type GetGasPriceError = TransportError | ProviderResponseError;
+type GetMaxPriorityFeePerGasError = TransportError | ProviderResponseError;
+type GetFeeHistoryError = TransportError | ProviderValidationError;
+type WatchBlocksError = TransportError | ProviderStreamError;
+type BackfillBlocksError = TransportError | ProviderStreamError;
+type SendRawTransactionError = TransportError;
+type GetUncleError = TransportError | ProviderNotFoundError;
+type GetProofError = TransportError;
+type GetBlobBaseFeeError = TransportError | ProviderResponseError | ProviderNotFoundError;
+type GetTransactionConfirmationsError = TransportError | ProviderResponseError;
+type GetBlockReceiptsError = TransportError | ProviderNotFoundError;
+type GetUncleCountError = TransportError | ProviderResponseError;
+type GetTransactionByBlockHashAndIndexError = TransportError | ProviderNotFoundError;
+type GetTransactionByBlockNumberAndIndexError = TransportError | ProviderNotFoundError;
+type SendTransactionError = TransportError;
+type SignError = TransportError;
+type SignTransactionError = TransportError;
+type SimulateV1Error = TransportError;
+type SimulateV2Error = TransportError;
+type GetSyncingError = TransportError;
+type GetAccountsError = TransportError;
+type GetCoinbaseError = TransportError;
+type NetVersionError = TransportError;
+type SubscribeError = TransportError;
+type UnsubscribeError = TransportError;
+type GetProtocolVersionError = TransportError;
+type GetMiningError = TransportError;
+type GetHashrateError = TransportError | ProviderResponseError;
+type GetWorkError = TransportError;
+type SubmitWorkError = TransportError;
+type SubmitHashrateError = TransportError;
+/**
+ * Block identifier for Ethereum RPC calls.
+ *
+ * @description
+ * Used to specify which block to query for operations like getBalance, getCode, etc.
+ * Can be a named tag for special blocks or a hex-encoded block number.
+ *
+ * Named tags:
+ * - `"latest"` - Most recent mined block
+ * - `"earliest"` - Genesis block
+ * - `"pending"` - Pending block (transactions in mempool)
+ * - `"safe"` - Latest safe head block (2/3 attestations)
+ * - `"finalized"` - Latest finalized block (cannot be reverted)
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * ```typescript
+ * // Using named tags
+ * const balance1 = yield* provider.getBalance(address, 'latest')
+ * const balance2 = yield* provider.getBalance(address, 'finalized')
+ *
+ * // Using hex block number
+ * const balance3 = yield* provider.getBalance(address, '0x1234')
+ * ```
+ */
+type BlockTag = "latest" | "earliest" | "pending" | "safe" | "finalized" | `0x${string}`;
+/**
+ * State override for a single account.
+ *
+ * @description
+ * Allows modifying account state before executing eth_call or eth_estimateGas.
+ * Useful for simulating transactions with modified balances, code, or storage.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * ```typescript
+ * const override: AccountStateOverride = {
+ *   balance: 1000000000000000000n,  // Override balance to 1 ETH
+ *   nonce: 5n,                       // Override nonce
+ *   code: '0x6080604052...',         // Replace contract code
+ *   state: {                         // Replace entire storage
+ *     '0x0000...0000': '0x0000...0001'
+ *   },
+ *   stateDiff: {                     // Merge with existing storage
+ *     '0x0000...0001': '0x0000...0064'
+ *   }
+ * }
+ * ```
+ */
+interface AccountStateOverride {
+    /** Override balance in wei */
+    readonly balance?: bigint;
+    /** Override nonce */
+    readonly nonce?: bigint;
+    /** Override contract bytecode */
+    readonly code?: HexType | `0x${string}`;
+    /** Replace entire storage with this mapping (slot -> value) */
+    readonly state?: Record<`0x${string}`, `0x${string}`>;
+    /** Merge these slots with existing storage (slot -> value) */
+    readonly stateDiff?: Record<`0x${string}`, `0x${string}`>;
+}
+/**
+ * State override set mapping addresses to account overrides.
+ *
+ * @description
+ * Maps account addresses to their state overrides. Each address can have
+ * its balance, nonce, code, and storage modified for the duration of the call.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * ```typescript
+ * const stateOverride: StateOverride = {
+ *   '0x1234...': { balance: 1000000000000000000n },
+ *   '0x5678...': { code: '0x6080604052...' }
+ * }
+ * ```
+ */
+type StateOverride = Record<`0x${string}`, AccountStateOverride>;
+/**
+ * Block overrides for call simulation.
+ *
+ * @description
+ * Allows overriding block context during eth_call execution.
+ * Useful for simulating calls at different block conditions.
+ *
+ * @since 0.0.1
+ */
+interface BlockOverrides {
+    /** Override block number */
+    readonly number?: bigint;
+    /** Override block difficulty */
+    readonly difficulty?: bigint;
+    /** Override block time (unix timestamp) */
+    readonly time?: bigint;
+    /** Override gas limit */
+    readonly gasLimit?: bigint;
+    /** Override coinbase/miner address */
+    readonly coinbase?: AddressInput;
+    /** Override random/prevrandao */
+    readonly random?: HashInput;
+    /** Override base fee */
+    readonly baseFee?: bigint;
+}
+/**
+ * Request parameters for eth_call and eth_estimateGas.
+ *
+ * @description
+ * Defines the parameters for simulating a transaction call without
+ * actually sending it to the network. Used for reading contract state
+ * and estimating gas costs.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * ```typescript
+ * const callRequest: CallRequest = {
+ *   to: '0x1234...',           // Contract address
+ *   from: '0x5678...',         // Sender address (optional)
+ *   data: '0x...',             // Encoded function call
+ *   value: 0n,                 // ETH to send (optional)
+ *   gas: 100000n               // Gas limit (optional)
+ * }
+ * ```
+ */
+interface CallRequest {
+    /** Target contract address to call */
+    readonly to?: AddressInput;
+    /** Sender address (affects msg.sender in call) */
+    readonly from?: AddressInput;
+    /** ABI-encoded function call data */
+    readonly data?: HexType | `0x${string}`;
+    /** Value in wei to send with the call */
+    readonly value?: bigint;
+    /** Gas limit for the call (defaults to node estimate) */
+    readonly gas?: bigint;
+}
+/**
+ * JSON-RPC transaction request for eth_sendTransaction / eth_signTransaction.
+ *
+ * @since 0.3.0
+ */
+type RpcTransactionRequest = Omit<CallRequest, "from" | "to"> & {
+    /** Sender address (required for eth_sendTransaction / eth_signTransaction) */
+    readonly from: AddressInput;
+    /** Recipient address (null/undefined for contract deployment) */
+    readonly to?: AddressInput | null;
+    /** Gas price for legacy/EIP-2930 transactions */
+    readonly gasPrice?: bigint;
+    /** Max fee per gas for EIP-1559+ transactions */
+    readonly maxFeePerGas?: bigint;
+    /** Max priority fee per gas for EIP-1559+ transactions */
+    readonly maxPriorityFeePerGas?: bigint;
+    /** Transaction nonce */
+    readonly nonce?: bigint;
+    /** Optional access list (EIP-2930+) */
+    readonly accessList?: AccessListInput;
+    /** Optional chain id */
+    readonly chainId?: bigint;
+    /** Explicit transaction type (0-4) */
+    readonly type?: 0 | 1 | 2 | 3 | 4;
+    /** Max fee per blob gas (EIP-4844) */
+    readonly maxFeePerBlobGas?: bigint;
+    /** Blob versioned hashes (EIP-4844) */
+    readonly blobVersionedHashes?: readonly `0x${string}`[];
+};
+/**
+ * Arguments for getBlock - discriminated union to prevent invalid combinations.
+ *
+ * @description
+ * Either query by blockTag OR by blockHash, never both.
+ *
+ * @since 0.0.1
+ */
+type GetBlockArgs = {
+    /** Block tag (latest, earliest, pending, safe, finalized, or hex number) */
+    blockTag?: BlockTag;
+    /** Whether to include full transaction objects */
+    includeTransactions?: boolean;
+    blockHash?: never;
+    blockNumber?: never;
+} | {
+    /** Block hash to query */
+    blockHash: HashInput;
+    /** Whether to include full transaction objects */
+    includeTransactions?: boolean;
+    blockTag?: never;
+    blockNumber?: never;
+} | {
+    /** Block number as bigint */
+    blockNumber: bigint;
+    /** Whether to include full transaction objects */
+    includeTransactions?: boolean;
+    blockTag?: never;
+    blockHash?: never;
+};
+/**
+ * Arguments for getBlockReceipts - block identifier only.
+ *
+ * @since 0.3.0
+ */
+type GetBlockReceiptsArgs = {
+    /** Block tag (latest, earliest, pending, safe, finalized, or hex number) */
+    blockTag?: BlockTag;
+    blockHash?: never;
+    blockNumber?: never;
+} | {
+    /** Block hash to query */
+    blockHash: HashInput;
+    blockTag?: never;
+    blockNumber?: never;
+} | {
+    /** Block number as bigint */
+    blockNumber: bigint;
+    blockTag?: never;
+    blockHash?: never;
+};
+/**
+ * Arguments for getBlockTransactionCount - discriminated union.
+ *
+ * @description
+ * Either query by blockTag OR by blockHash, never both.
+ *
+ * @since 0.0.1
+ */
+type GetBlockTransactionCountArgs = {
+    /** Block tag (latest, earliest, pending, safe, finalized, or hex number) */
+    blockTag?: BlockTag;
+    blockHash?: never;
+} | {
+    /** Block hash to query */
+    blockHash: HashInput;
+    blockTag?: never;
+};
+/**
+ * Filter parameters for eth_getLogs - discriminated union.
+ *
+ * @description
+ * Defines the criteria for querying event logs from contracts.
+ * Either use blockHash OR fromBlock/toBlock range, never both.
+ *
+ * @since 0.0.1
+ *
+ * @example
+ * ```typescript
+ * // Get all Transfer events from a token contract by block range
+ * const filter: LogFilter = {
+ *   address: '0x1234...',
+ *   topics: ['0xddf252ad...'], // Transfer event signature
+ *   fromBlock: 'latest',
+ *   toBlock: 'latest'
+ * }
+ *
+ * // Get events by block hash
+ * const filter2: LogFilter = {
+ *   address: '0x1234...',
+ *   blockHash: '0xabc...'
+ * }
+ * ```
+ */
+type LogFilter = {
+    /** Specific block hash (mutually exclusive with fromBlock/toBlock) */
+    blockHash: HashInput;
+    fromBlock?: never;
+    toBlock?: never;
+    /** Contract address(es) to filter (single or array) */
+    address?: AddressInput | AddressInput[];
+    /** Topic filters by position (null for wildcard at that position) */
+    topics?: (HashInput | HashInput[] | null)[];
+} | {
+    blockHash?: never;
+    /** Start block for range query (inclusive) */
+    fromBlock?: BlockTag;
+    /** End block for range query (inclusive) */
+    toBlock?: BlockTag;
+    /** Contract address(es) to filter (single or array) */
+    address?: AddressInput | AddressInput[];
+    /** Topic filters by position (null for wildcard at that position) */
+    topics?: (HashInput | HashInput[] | null)[];
+};
+/**
+ * Filter parameters for eth_newFilter.
+ *
+ * @description
+ * Defines the criteria for creating an event log filter.
+ *
+ * @since 0.0.1
+ */
+type EventFilter = {
+    /** Contract address(es) to filter (single or array) */
+    readonly address?: AddressInput | AddressInput[];
+    /** Topic filters by position (null for wildcard at that position) */
+    readonly topics?: (HashInput | HashInput[] | null)[];
+    /** Start block for range query (inclusive) */
+    readonly fromBlock?: BlockTag;
+    /** End block for range query (inclusive) */
+    readonly toBlock?: BlockTag;
+};
+/**
+ * Ethereum block as returned by JSON-RPC.
+ *
+ * @description
+ * Contains all block header fields and optionally full transaction objects.
+ * All numeric fields are hex-encoded strings.
+ *
+ * @since 0.0.1
+ */
+interface BlockType {
+    /** Block number (hex-encoded) - null for pending blocks */
+    number: string | null;
+    /** Block hash - null for pending blocks */
+    hash: string | null;
+    /** Parent block hash */
+    parentHash: string;
+    /** Proof-of-work nonce */
+    nonce: string;
+    /** Hash of uncle blocks */
+    sha3Uncles: string;
+    /** Bloom filter for logs */
+    logsBloom: string;
+    /** Merkle root of transactions */
+    transactionsRoot: string;
+    /** Merkle root of state trie */
+    stateRoot: string;
+    /** Merkle root of receipts */
+    receiptsRoot: string;
+    /** Block miner/validator address */
+    miner: string;
+    /** Block difficulty (legacy PoW) */
+    difficulty: string;
+    /** Cumulative difficulty (legacy PoW) */
+    totalDifficulty: string;
+    /** Extra data included by miner */
+    extraData: string;
+    /** Block size in bytes (hex) */
+    size: string;
+    /** Maximum gas allowed in block (hex) */
+    gasLimit: string;
+    /** Total gas used by transactions (hex) */
+    gasUsed: string;
+    /** Block timestamp (hex, unix seconds) */
+    timestamp: string;
+    /** Transaction hashes or full transaction objects */
+    transactions: string[] | TransactionType[];
+    /** Uncle block hashes */
+    uncles: string[];
+    /** Base fee per gas (EIP-1559, hex) */
+    baseFeePerGas?: string;
+    /** Withdrawals (EIP-4895) */
+    withdrawals?: WithdrawalType[];
+    /** Withdrawals root (EIP-4895) */
+    withdrawalsRoot?: string;
+    /** Blob gas used (EIP-4844, hex) */
+    blobGasUsed?: string;
+    /** Excess blob gas (EIP-4844, hex) */
+    excessBlobGas?: string;
+    /** Parent beacon block root (EIP-4788, hex) */
+    parentBeaconBlockRoot?: string;
+}
+/**
+ * Withdrawal object (EIP-4895).
+ *
+ * @since 0.0.1
+ */
+interface WithdrawalType {
+    /** Withdrawal index (hex) */
+    index: string;
+    /** Validator index (hex) */
+    validatorIndex: string;
+    /** Recipient address */
+    address: string;
+    /** Amount in Gwei (hex) */
+    amount: string;
+}
+/**
+ * Ethereum transaction as returned by JSON-RPC.
+ *
+ * @description
+ * Contains all transaction fields. Type determines which fee fields are present.
+ * All numeric fields are hex-encoded strings.
+ *
+ * @since 0.0.1
+ */
+interface TransactionType {
+    /** Transaction hash */
+    hash: string;
+    /** Sender's transaction count at send time (hex) */
+    nonce: string;
+    /** Block hash (null if pending) */
+    blockHash: string | null;
+    /** Block number (hex, null if pending) */
+    blockNumber: string | null;
+    /** Index in block (hex, null if pending) */
+    transactionIndex: string | null;
+    /** Sender address */
+    from: string;
+    /** Recipient address (null for contract creation) */
+    to: string | null;
+    /** Value in wei (hex) */
+    value: string;
+    /** Gas limit (hex) */
+    gas: string;
+    /** Gas price in wei (hex, legacy) */
+    gasPrice?: string;
+    /** Max fee per gas (hex, EIP-1559) */
+    maxFeePerGas?: string;
+    /** Max priority fee per gas (hex, EIP-1559) */
+    maxPriorityFeePerGas?: string;
+    /** Input data (hex) */
+    input: string;
+    /** v component of signature (hex) */
+    v?: string;
+    /** r component of signature (hex) */
+    r?: string;
+    /** s component of signature (hex) */
+    s?: string;
+    /** Transaction type (hex: 0x0=legacy, 0x1=2930, 0x2=1559) */
+    type?: string;
+    /** Access list (EIP-2930) */
+    accessList?: Array<{
+        address: string;
+        storageKeys: string[];
+    }>;
+    /** Chain ID (hex) */
+    chainId?: string;
+    /** Max fee per blob gas (EIP-4844, hex) */
+    maxFeePerBlobGas?: string;
+    /** Blob versioned hashes (EIP-4844) */
+    blobVersionedHashes?: string[];
+    /** y parity for EIP-2930+ (hex) */
+    yParity?: string;
+}
+/**
+ * Transaction receipt as returned by JSON-RPC.
+ *
+ * @description
+ * Contains the result of transaction execution including status,
+ * gas used, and generated logs.
+ *
+ * @since 0.0.1
+ */
+interface ReceiptType {
+    /** Transaction hash */
+    transactionHash: string;
+    /** Index in block (hex) */
+    transactionIndex: string;
+    /** Block hash */
+    blockHash: string;
+    /** Block number (hex) */
+    blockNumber: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address (null for contract creation) */
+    to: string | null;
+    /** Cumulative gas used in block up to this tx (hex) */
+    cumulativeGasUsed: string;
+    /** Gas used by this transaction (hex) */
+    gasUsed: string;
+    /** Effective gas price paid (hex) */
+    effectiveGasPrice?: string;
+    /** Contract address created (null if not contract creation) */
+    contractAddress: string | null;
+    /** Event logs emitted */
+    logs: LogType[];
+    /** Bloom filter for logs */
+    logsBloom: string;
+    /** Transaction type (hex) */
+    type?: string;
+    /** Success status (hex: 0x1=success, 0x0=failure) */
+    status: string;
+}
+/**
+ * Event log as returned by JSON-RPC.
+ *
+ * @description
+ * Represents an event emitted by a smart contract.
+ * Topics contain indexed event parameters.
+ *
+ * @since 0.0.1
+ */
+interface LogType {
+    /** Contract that emitted the log */
+    address: string;
+    /** Indexed event parameters (first is event signature) */
+    topics: string[];
+    /** Non-indexed event data (hex) */
+    data: string;
+    /** Block number (hex) */
+    blockNumber: string;
+    /** Transaction hash */
+    transactionHash: string;
+    /** Transaction index in block (hex) */
+    transactionIndex: string;
+    /** Block hash */
+    blockHash: string;
+    /** Log index in block (hex) */
+    logIndex: string;
+    /** True if log was removed due to reorg */
+    removed: boolean;
+}
+/**
+ * Result type for eth_getFilterChanges.
+ *
+ * @description
+ * Returns logs for event filters or hashes for block/transaction filters.
+ *
+ * @since 0.0.1
+ */
+type FilterChanges = LogType[] | `0x${string}`[];
+/**
+ * Access list result from eth_createAccessList.
+ *
+ * @description
+ * Contains the generated access list and estimated gas.
+ * Access lists can reduce gas costs for EIP-2930+ transactions.
+ *
+ * @since 0.0.1
+ */
+interface AccessListType {
+    /** List of addresses and storage slots accessed */
+    accessList: Array<{
+        address: string;
+        storageKeys: string[];
+    }>;
+    /** Estimated gas with access list (hex) */
+    gasUsed: string;
+}
+/**
+ * Access list input for EIP-2930+ transactions.
+ *
+ * @since 0.3.0
+ */
+type AccessListInput = Array<{
+    address: AddressInput;
+    storageKeys: Array<`0x${string}`>;
+}>;
+/**
+ * Fee history result from eth_feeHistory.
+ *
+ * @description
+ * Historical base fee and priority fee data for gas estimation.
+ * Useful for EIP-1559 transaction fee calculation.
+ *
+ * @since 0.0.1
+ */
+interface FeeHistoryType {
+    /** Oldest block in the returned range (hex) */
+    oldestBlock: string;
+    /** Base fee per gas for each block (hex) */
+    baseFeePerGas: string[];
+    /** Ratio of gas used to gas limit per block */
+    gasUsedRatio: number[];
+    /** Priority fee percentiles per block (if requested) */
+    reward?: string[][];
+}
+/**
+ * Storage proof for a single slot.
+ *
+ * @since 0.0.1
+ */
+interface StorageProofType {
+    /** Storage slot key (hex) */
+    key: string;
+    /** Value at slot (hex) */
+    value: string;
+    /** Merkle proof nodes (array of hex) */
+    proof: string[];
+}
+/**
+ * Account proof result from eth_getProof.
+ *
+ * @description
+ * Contains the Merkle-Patricia proof for an account and optional storage slots.
+ * Useful for stateless verification and light client implementations.
+ *
+ * @since 0.0.1
+ */
+interface ProofType {
+    /** Account address */
+    address: string;
+    /** Merkle proof nodes for account (array of hex) */
+    accountProof: string[];
+    /** Account balance (hex) */
+    balance: string;
+    /** Account code hash */
+    codeHash: string;
+    /** Account nonce (hex) */
+    nonce: string;
+    /** Storage trie root hash */
+    storageHash: string;
+    /** Storage proofs for requested slots */
+    storageProof: StorageProofType[];
+}
+/**
+ * Uncle block type (partial block without transactions).
+ *
+ * @since 0.0.1
+ */
+interface UncleBlockType {
+    /** Block number (hex) - null for pending blocks */
+    number: string | null;
+    /** Block hash - null for pending blocks */
+    hash: string | null;
+    /** Parent block hash */
+    parentHash: string;
+    /** Proof-of-work nonce */
+    nonce: string;
+    /** Hash of uncle blocks */
+    sha3Uncles: string;
+    /** Bloom filter for logs */
+    logsBloom: string;
+    /** Merkle root of transactions */
+    transactionsRoot: string;
+    /** Merkle root of state trie */
+    stateRoot: string;
+    /** Merkle root of receipts */
+    receiptsRoot: string;
+    /** Block miner/validator address */
+    miner: string;
+    /** Block difficulty (legacy PoW) */
+    difficulty: string;
+    /** Cumulative difficulty (legacy PoW) */
+    totalDifficulty: string;
+    /** Extra data included by miner */
+    extraData: string;
+    /** Block size in bytes (hex) */
+    size: string;
+    /** Maximum gas allowed in block (hex) */
+    gasLimit: string;
+    /** Total gas used by transactions (hex) */
+    gasUsed: string;
+    /** Block timestamp (hex, unix seconds) */
+    timestamp: string;
+    /** Uncle block hashes */
+    uncles: string[];
+}
+/**
+ * Arguments for getUncle - either by block tag or block hash.
+ *
+ * @since 0.0.1
+ */
+type GetUncleArgs = {
+    /** Block tag (latest, earliest, pending, safe, finalized, or hex number) */
+    blockTag?: BlockTag;
+    blockHash?: never;
+} | {
+    /** Block hash to query */
+    blockHash: HashInput;
+    blockTag?: never;
+};
+/**
+ * Arguments for getUncleCount - either by block tag or block hash.
+ *
+ * @since 0.3.0
+ */
+type GetUncleCountArgs = {
+    /** Block tag (latest, earliest, pending, safe, finalized, or hex number) */
+    blockTag?: BlockTag;
+    blockHash?: never;
+} | {
+    /** Block hash to query */
+    blockHash: HashInput;
+    blockTag?: never;
+};
+/**
+ * Shape of the provider service.
+ *
+ * @description
+ * Composition of the focused provider services (blocks, accounts, transactions,
+ * simulation, events, network, streaming). Each method returns an Effect that may
+ * fail with a method-specific error union (see the Get*Error type aliases), plus
+ * TransportError for RPC failures.
+ *
+ * @since 0.0.1
+ */
+type ProviderShape = BlocksShape & AccountShape & TransactionShape & SimulationShape & EventsShape & NetworkShape & StreamingShape;
+declare const ProviderService_base: Context.TagClass<ProviderService, "ProviderService", ProviderShape>;
+/**
+ * Provider service for read-only blockchain operations.
+ *
+ * @description
+ * Provides methods for querying blocks, transactions, balances, and more.
+ * This is an Effect Context.Tag that must be provided with a concrete
+ * implementation (Provider layer) before running.
+ *
+ * The service provides all standard Ethereum JSON-RPC read methods:
+ * - Block queries (getBlock, getBlockNumber, getBlockTransactionCount)
+ * - Account queries (getBalance, getTransactionCount, getCode, getStorageAt)
+ * - Transaction queries (getTransaction, getTransactionReceipt, waitForTransactionReceipt)
+ * - Call simulation (call, estimateGas, createAccessList)
+ * - Event queries (getLogs)
+ * - Filter subscriptions (createEventFilter, createBlockFilter, createPendingTransactionFilter, getFilterChanges, getFilterLogs, uninstallFilter)
+ * - Network info (getChainId, getGasPrice, getMaxPriorityFeePerGas, getFeeHistory)
+ *
+ * Requires TransportService to be provided for actual RPC communication.
+ *
+ * @since 0.0.1
+ *
+ * @example Basic usage with HttpTransport
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { ProviderService, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const provider = yield* ProviderService
+ *   const blockNum = yield* provider.getBlockNumber()
+ *   const balance = yield* provider.getBalance('0x1234...')
+ *   return { blockNum, balance }
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ *
+ * await Effect.runPromise(program)
+ * ```
+ *
+ * @example Querying block and transaction data
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { ProviderService, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const provider = yield* ProviderService
+ *
+ *   // Get latest block with full transactions
+ *   const block = yield* provider.getBlock({
+ *     blockTag: 'latest',
+ *     includeTransactions: true
+ *   })
+ *
+ *   // Get specific transaction
+ *   const tx = yield* provider.getTransaction('0x...')
+ *
+ *   // Wait for transaction confirmation
+ *   const receipt = yield* provider.waitForTransactionReceipt('0x...', {
+ *     confirmations: 3,
+ *     timeout: 60000
+ *   })
+ *
+ *   return { block, tx, receipt }
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @example Contract interaction (read-only)
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { ProviderService, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const provider = yield* ProviderService
+ *
+ *   // Call a view function
+ *   const result = yield* provider.call({
+ *     to: '0x1234...',
+ *     data: '0x...' // encoded function call
+ *   })
+ *
+ *   // Estimate gas for a transaction
+ *   const gasEstimate = yield* provider.estimateGas({
+ *     to: '0x1234...',
+ *     data: '0x...',
+ *     value: 1000000000000000000n // 1 ETH
+ *   })
+ *
+ *   return { result, gasEstimate }
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @example Querying event logs
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { ProviderService, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const provider = yield* ProviderService
+ *
+ *   // Get Transfer events from a token contract
+ *   const logs = yield* provider.getLogs({
+ *     address: '0x1234...',
+ *     topics: ['0xddf252ad...'], // Transfer event signature
+ *     fromBlock: '0x100000',
+ *     toBlock: 'latest'
+ *   })
+ *
+ *   return logs
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://...'))
+ * )
+ * ```
+ *
+ * @see {@link Provider} - The live implementation layer
+ * @see {@link ProviderShape} - The service interface shape
+ * @see {@link ProviderError} - Union of provider-specific errors
+ * @see {@link TransportError} - Underlying transport failures
+ * @see {@link TransportService} - Required dependency for RPC communication
+ */
+declare class ProviderService extends ProviderService_base {
+}
+
+/**
+ * @fileoverview Account service definition for account-related JSON-RPC calls.
+ *
+ * @module AccountService
+ * @since 0.3.0
+ *
+ * @description
+ * The AccountService provides account state queries and optional RPC signing
+ * operations (eth_sign, eth_signTransaction) when supported by the node.
+ *
+ * @see {@link ProviderService} - Combined convenience service
+ */
+
+/**
+ * Shape of the Account service.
+ *
+ * @since 0.3.0
+ */
+type AccountShape = {
+    /** Gets the balance of an address */
+    readonly getBalance: (address: AddressInput, blockTag?: BlockTag) => Effect.Effect<bigint, GetBalanceError>;
+    /** Gets the transaction count (nonce) for an address */
+    readonly getTransactionCount: (address: AddressInput, blockTag?: BlockTag) => Effect.Effect<bigint, GetTransactionCountError>;
+    /** Gets the bytecode at an address */
+    readonly getCode: (address: AddressInput, blockTag?: BlockTag) => Effect.Effect<HexType | `0x${string}`, GetCodeError>;
+    /** Gets storage at a specific slot */
+    readonly getStorageAt: (address: AddressInput, slot: HashInput, blockTag?: BlockTag) => Effect.Effect<HexType | `0x${string}`, GetStorageAtError>;
+    /** Gets Merkle-Patricia proof for an account and storage slots */
+    readonly getProof: (address: AddressInput, storageKeys: (HashInput | `0x${string}`)[], blockTag?: BlockTag) => Effect.Effect<ProofType, GetProofError>;
+    /** Signs arbitrary data with an unlocked account (if supported) */
+    readonly sign?: (address: AddressInput, message: HexType | `0x${string}`) => Effect.Effect<`0x${string}`, SignError>;
+    /** Signs a transaction with an unlocked account (if supported) */
+    readonly signTransaction?: (tx: RpcTransactionRequest) => Effect.Effect<unknown, SignTransactionError>;
+};
+declare const AccountService_base: Context.TagClass<AccountService, "AccountService", AccountShape>;
+/**
+ * Account service for account-related JSON-RPC operations.
+ *
+ * @since 0.3.0
+ */
+declare class AccountService extends AccountService_base {
+}
+
+export { ProviderStreamError as $, type AccessListType as A, type BackfillBlocksError as B, type CallError as C, type GetLogsError as D, type EstimateGasError as E, type FeeHistoryType as F, type GetBalanceError as G, type GetMaxPriorityFeePerGasError as H, type GetProofError as I, type GetStorageAtError as J, type GetTransactionConfirmationsError as K, type GetTransactionCountError as L, type GetTransactionError as M, type GetTransactionReceiptError as N, type GetUncleError as O, ProviderService as P, type LogFilter as Q, type LogType as R, NetworkService as S, TransactionService as T, type NetworkShape as U, ProviderConfirmationsPendingError as V, type ProviderError as W, ProviderNotFoundError as X, ProviderReceiptPendingError as Y, ProviderResponseError as Z, type ProviderShape as _, AccountService as a, ProviderTimeoutError as a0, ProviderValidationError as a1, type ReceiptType as a2, type SendRawTransactionError as a3, type SimulateV1BlockResult as a4, type SimulateV1CallResult as a5, type SimulateV1Payload as a6, type SimulateV1Result as a7, type SimulateV2Payload as a8, type SimulateV2Result as a9, SimulationService as aa, type SimulationShape as ab, StreamingService as ac, type StreamingShape as ad, type SyncingStatus as ae, type TransactionShape as af, type TransactionType as ag, type UninstallFilterError as ah, type WaitForTransactionReceiptError as ai, type WatchBlocksError as aj, type WorkResult as ak, TransportError as al, KeccakService as am, KeccakLive as an, KeccakTest as ao, type HashInput as ap, type TransactionIndexInput as aq, type AddressInput as ar, type KeccakServiceShape as as, type AccountShape as b, BlocksService as c, type BlocksShape as d, type BlockTag as e, type BlockType as f, type CallRequest as g, type CreateAccessListError as h, type CreateBlockFilterError as i, type CreateEventFilterError as j, type CreatePendingTransactionFilterError as k, type EventFilter as l, EventsService as m, type EventsShape as n, type FilterChanges as o, type FilterId as p, type GetBlobBaseFeeError as q, type GetBlockError as r, type GetBlockNumberError as s, type GetBlockTransactionCountError as t, type GetChainIdError as u, type GetCodeError as v, type GetFeeHistoryError as w, type GetFilterChangesError as x, type GetFilterLogsError as y, type GetGasPriceError as z };