voltaire-effect 0.2.23 → 0.2.25

package/src/services/Provider/functions/getUncleCount.ts

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Free function to get the uncle count in a block.
+ *
+ * @module Provider/functions/getUncleCount
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import {
+	type BlockTag,
+	type GetUncleCountArgs,
+	ProviderResponseError,
+} from "../types.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Gets the number of uncles in a block.
+ *
+ * @param args - Block identifier (blockTag or blockHash)
+ * @returns Effect yielding the uncle count as bigint
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { getUncleCount, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   // Get uncle count for latest block
+ *   const count = yield* getUncleCount({})
+ *
+ *   // Get by block hash
+ *   const countByHash = yield* getUncleCount({
+ *     blockHash: '0x...'
+ *   })
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const getUncleCount = (
+	args: GetUncleCountArgs = {},
+): Effect.Effect<bigint, TransportError | ProviderResponseError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) => {
+		if ("blockHash" in args && args.blockHash !== undefined) {
+			const hash =
+				typeof args.blockHash === "string"
+					? args.blockHash
+					: `0x${Buffer.from(args.blockHash).toString("hex")}`;
+			return svc
+				.request<string>("eth_getUncleCountByBlockHash", [hash])
+				.pipe(
+					Effect.flatMap((hex) =>
+						Effect.try({
+							try: () => BigInt(hex),
+							catch: (error) =>
+								new ProviderResponseError(
+									hex,
+									"Invalid hex from eth_getUncleCountByBlockHash",
+									{ cause: error },
+								),
+						}),
+					),
+				);
+		}
+
+		const blockTag: BlockTag = args.blockTag ?? "latest";
+		return svc
+			.request<string>("eth_getUncleCountByBlockNumber", [blockTag])
+			.pipe(
+				Effect.flatMap((hex) =>
+					Effect.try({
+						try: () => BigInt(hex),
+						catch: (error) =>
+							new ProviderResponseError(
+								hex,
+								"Invalid hex from eth_getUncleCountByBlockNumber",
+								{ cause: error },
+							),
+					}),
+				),
+			);
+	});

package/src/services/Provider/functions/index.ts

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Free functions for Provider operations.
+ *
+ * @module Provider/functions
+ * @since 0.4.0
+ */
+
+// Block operations
+export { getBlockNumber } from "./getBlockNumber.js";
+export { getBlock } from "./getBlock.js";
+export { getBlockTransactionCount } from "./getBlockTransactionCount.js";
+export { getBlockReceipts } from "./getBlockReceipts.js";
+export { getUncle } from "./getUncle.js";
+export { getUncleCount } from "./getUncleCount.js";
+
+// Account operations
+export { getBalance } from "./getBalance.js";
+export { getTransactionCount } from "./getTransactionCount.js";
+export { getCode } from "./getCode.js";
+export { getStorageAt } from "./getStorageAt.js";
+export { getProof } from "./getProof.js";
+
+// Transaction operations
+export { getTransaction } from "./getTransaction.js";
+export { getTransactionReceipt } from "./getTransactionReceipt.js";
+export { getTransactionByBlockHashAndIndex } from "./getTransactionByBlockHashAndIndex.js";
+export { getTransactionByBlockNumberAndIndex } from "./getTransactionByBlockNumberAndIndex.js";
+export { sendRawTransaction } from "./sendRawTransaction.js";
+export { getTransactionConfirmations } from "./getTransactionConfirmations.js";
+export { waitForTransactionReceipt, type WaitForTransactionReceiptOptions } from "./waitForTransactionReceipt.js";
+
+// Call and simulation operations
+export { call } from "./call.js";
+export { estimateGas } from "./estimateGas.js";
+export { createAccessList, type CreateAccessListResult } from "./createAccessList.js";
+export { simulateV1 } from "./simulateV1.js";
+export { simulateV2 } from "./simulateV2.js";
+
+// Event/Log operations
+export { getLogs } from "./getLogs.js";
+export { createEventFilter } from "./createEventFilter.js";
+export { createBlockFilter } from "./createBlockFilter.js";
+export { createPendingTransactionFilter } from "./createPendingTransactionFilter.js";
+export { getFilterChanges } from "./getFilterChanges.js";
+export { getFilterLogs } from "./getFilterLogs.js";
+export { uninstallFilter } from "./uninstallFilter.js";
+
+// Network operations
+export { getChainId } from "./getChainId.js";
+export { getGasPrice } from "./getGasPrice.js";
+export { getMaxPriorityFeePerGas } from "./getMaxPriorityFeePerGas.js";
+export { getFeeHistory } from "./getFeeHistory.js";
+export { getBlobBaseFee } from "./getBlobBaseFee.js";
+export { getSyncing } from "./getSyncing.js";
+export { getAccounts } from "./getAccounts.js";
+export { getCoinbase } from "./getCoinbase.js";
+export { netVersion } from "./netVersion.js";
+export { getProtocolVersion } from "./getProtocolVersion.js";
+export { getMining } from "./getMining.js";
+export { getHashrate } from "./getHashrate.js";
+
+// Streaming operations
+export { watchBlocks } from "./watchBlocks.js";
+export { backfillBlocks } from "./backfillBlocks.js";
+
+// Subscription operations
+export { subscribe } from "./subscribe.js";
+export { unsubscribe } from "./unsubscribe.js";
+
+// Node-dependent operations (unlocked accounts)
+export { sendTransaction } from "./sendTransaction.js";
+export { sign } from "./sign.js";
+export { signTransaction } from "./signTransaction.js";

package/src/services/Provider/functions/netVersion.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Free function to get the network version.
+ *
+ * @module Provider/functions/netVersion
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Gets the network ID (net_version).
+ *
+ * @returns Effect yielding the network version as string
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { netVersion, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const version = yield* netVersion()
+ *   console.log('Network version:', version)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const netVersion = (): Effect.Effect<
+	string,
+	TransportError,
+	ProviderService
+> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<string>("net_version"),
+	);

package/src/services/Provider/functions/sendRawTransaction.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Free function to send a raw signed transaction.
+ *
+ * @module Provider/functions/sendRawTransaction
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import type { TransportError } from "../../Transport/TransportError.js";
+import { ProviderService } from "../ProviderService.js";
+
+/**
+ * Sends a raw signed transaction.
+ *
+ * @param signedTx - The signed transaction as a hex string
+ * @returns Effect yielding the transaction hash
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { sendRawTransaction, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signedTx = '0x...' // Your signed transaction
+ *   const txHash = yield* sendRawTransaction(signedTx)
+ *   console.log(`Transaction submitted: ${txHash}`)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const sendRawTransaction = (
+	signedTx: `0x${string}`,
+): Effect.Effect<`0x${string}`, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<`0x${string}`>("eth_sendRawTransaction", [signedTx]),
+	);

package/src/services/Provider/functions/sendTransaction.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Free function to send a transaction from an unlocked account.
+ *
+ * @module Provider/functions/sendTransaction
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import { formatTransactionRequest, type RpcTransactionRequest } from "../utils.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Sends a transaction from an unlocked account using eth_sendTransaction.
+ *
+ * This is a node-dependent operation that requires the from address to be
+ * unlocked on the node (e.g., for local development or test nodes).
+ * For sending signed transactions, use sendRawTransaction instead.
+ *
+ * @param tx - Transaction request with from, to, value, data, etc.
+ * @returns Effect yielding the transaction hash
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { sendTransaction, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const txHash = yield* sendTransaction({
+ *     from: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *     to: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+ *     value: 1000000000000000000n, // 1 ETH
+ *   })
+ *   console.log('Transaction hash:', txHash)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('http://localhost:8545'))
+ * )
+ * ```
+ */
+export const sendTransaction = (
+	tx: RpcTransactionRequest,
+): Effect.Effect<`0x${string}`, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<`0x${string}`>("eth_sendTransaction", [formatTransactionRequest(tx)]),
+	);

package/src/services/Provider/functions/sign.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Free function to sign a message using an unlocked account.
+ *
+ * @module Provider/functions/sign
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import { toAddressHex } from "../utils.js";
+import type { AddressInput } from "../types.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Signs a message using an unlocked account via eth_sign.
+ *
+ * This is a node-dependent operation that requires the address to be
+ * unlocked on the node. The message is prefixed with the Ethereum
+ * signed message prefix before signing.
+ *
+ * @param address - Address of the account to sign with
+ * @param message - Hex-encoded message to sign
+ * @returns Effect yielding the signature
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { sign, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signature = yield* sign(
+ *     '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *     '0x48656c6c6f20576f726c64' // "Hello World"
+ *   )
+ *   console.log('Signature:', signature)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('http://localhost:8545'))
+ * )
+ * ```
+ */
+export const sign = (
+	address: AddressInput,
+	message: `0x${string}`,
+): Effect.Effect<`0x${string}`, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<`0x${string}`>("eth_sign", [toAddressHex(address), message]),
+	);

package/src/services/Provider/functions/signTransaction.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Free function to sign a transaction using an unlocked account.
+ *
+ * @module Provider/functions/signTransaction
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import { formatTransactionRequest, type RpcTransactionRequest } from "../utils.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Signs a transaction using an unlocked account via eth_signTransaction.
+ *
+ * This is a node-dependent operation that requires the from address to be
+ * unlocked on the node. Returns the signed transaction data that can be
+ * broadcast later using sendRawTransaction.
+ *
+ * @param tx - Transaction request to sign
+ * @returns Effect yielding the signed transaction data
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { signTransaction, sendRawTransaction, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signedTx = yield* signTransaction({
+ *     from: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *     to: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+ *     value: 1000000000000000000n,
+ *     nonce: 0n,
+ *     gas: 21000n,
+ *     maxFeePerGas: 20000000000n,
+ *     maxPriorityFeePerGas: 1000000000n,
+ *   })
+ *   console.log('Signed transaction:', signedTx)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('http://localhost:8545'))
+ * )
+ * ```
+ */
+export const signTransaction = (
+	tx: RpcTransactionRequest,
+): Effect.Effect<unknown, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<unknown>("eth_signTransaction", [formatTransactionRequest(tx)]),
+	);

package/src/services/Provider/functions/simulateV1.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Free function to simulate multiple blocks and calls with eth_simulateV1.
+ *
+ * @module Provider/functions/simulateV1
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type {
+	BlockTag,
+	SimulateV1Payload,
+	SimulateV1Result,
+	SimulateV1Error,
+} from "../types.js";
+import { formatCallRequest, toAddressHex } from "../utils.js";
+
+/**
+ * Formats a SimulateV1Payload for JSON-RPC submission.
+ */
+const formatSimulateV1Payload = (payload: SimulateV1Payload): unknown => {
+	return {
+		blockStateCalls: payload.blockStateCalls.map((block) => ({
+			...(block.blockOverrides && {
+				blockOverrides: {
+					...(block.blockOverrides.number !== undefined && {
+						number: `0x${block.blockOverrides.number.toString(16)}`,
+					}),
+					...(block.blockOverrides.difficulty !== undefined && {
+						difficulty: `0x${block.blockOverrides.difficulty.toString(16)}`,
+					}),
+					...(block.blockOverrides.time !== undefined && {
+						time: `0x${block.blockOverrides.time.toString(16)}`,
+					}),
+					...(block.blockOverrides.gasLimit !== undefined && {
+						gasLimit: `0x${block.blockOverrides.gasLimit.toString(16)}`,
+					}),
+					...(block.blockOverrides.coinbase !== undefined && {
+						coinbase: toAddressHex(block.blockOverrides.coinbase),
+					}),
+					...(block.blockOverrides.baseFee !== undefined && {
+						baseFee: `0x${block.blockOverrides.baseFee.toString(16)}`,
+					}),
+				},
+			}),
+			...(block.stateOverrides && { stateOverrides: block.stateOverrides }),
+			calls: block.calls.map(formatCallRequest),
+		})),
+		...(payload.traceTransfers !== undefined && { traceTransfers: payload.traceTransfers }),
+		...(payload.validation !== undefined && { validation: payload.validation }),
+		...(payload.returnFullTransactions !== undefined && {
+			returnFullTransactions: payload.returnFullTransactions,
+		}),
+	};
+};
+
+/**
+ * Simulates multiple blocks and calls using eth_simulateV1.
+ *
+ * Note: This method is optional and not supported by all nodes.
+ *
+ * @param payload - The simulation payload
+ * @param blockTag - Block to simulate from (default: "latest")
+ * @returns Effect yielding the simulation results
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { simulateV1, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const results = yield* simulateV1({
+ *     blockStateCalls: [{
+ *       calls: [{
+ *         to: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+ *         data: '0x...'
+ *       }]
+ *     }]
+ *   })
+ *   console.log(results)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const simulateV1 = (
+	payload: SimulateV1Payload,
+	blockTag: BlockTag = "latest",
+): Effect.Effect<SimulateV1Result, SimulateV1Error, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<SimulateV1Result>("eth_simulateV1", [formatSimulateV1Payload(payload), blockTag]),
+	);

package/src/services/Provider/functions/simulateV2.ts

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Free function to simulate with eth_simulateV2.
+ *
+ * @module Provider/functions/simulateV2
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type {
+	BlockTag,
+	SimulateV2Payload,
+	SimulateV2Result,
+	SimulateV2Error,
+} from "../types.js";
+
+/**
+ * Simulates using eth_simulateV2 (draft/evolving API).
+ *
+ * Note: This method is optional and not supported by all nodes.
+ * The API is still evolving and may change.
+ *
+ * @param payload - The simulation payload (schema may evolve)
+ * @param blockTag - Block to simulate from (default: "latest")
+ * @returns Effect yielding the simulation results
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { simulateV2, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const results = yield* simulateV2({
+ *     // payload format may evolve
+ *   })
+ *   console.log(results)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const simulateV2 = <TResult = SimulateV2Result>(
+	payload: SimulateV2Payload,
+	blockTag: BlockTag = "latest",
+): Effect.Effect<TResult, SimulateV2Error, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<TResult>("eth_simulateV2", [payload, blockTag]),
+	);

package/src/services/Provider/functions/subscribe.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Free function to subscribe to Ethereum events via eth_subscribe.
+ *
+ * @module Provider/functions/subscribe
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Subscribes to Ethereum events using eth_subscribe.
+ *
+ * Requires a WebSocket transport that supports subscriptions.
+ *
+ * @param subscription - Subscription type (e.g., 'newHeads', 'logs', 'newPendingTransactions')
+ * @param params - Optional subscription parameters
+ * @returns Effect yielding the subscription ID
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { subscribe, Provider, WebSocketTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   // Subscribe to new block headers
+ *   const subId = yield* subscribe('newHeads')
+ *
+ *   // Subscribe to logs with filter
+ *   const logsSubId = yield* subscribe('logs', [{
+ *     address: '0x...',
+ *     topics: ['0x...']
+ *   }])
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(WebSocketTransport('wss://mainnet.infura.io/ws/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const subscribe = (
+	subscription: string,
+	params?: readonly unknown[],
+): Effect.Effect<`0x${string}`, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<`0x${string}`>("eth_subscribe", [subscription, ...(params ?? [])]),
+	);

package/src/services/Provider/functions/uninstallFilter.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Free function to uninstall a filter.
+ *
+ * @module Provider/functions/uninstallFilter
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type { FilterId } from "../types.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Uninstalls a filter and frees resources.
+ *
+ * @param filterId - Filter ID to uninstall
+ * @returns Effect yielding true if filter was found and removed
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { createBlockFilter, uninstallFilter, Provider, HttpTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const filterId = yield* createBlockFilter()
+ *   const uninstalled = yield* uninstallFilter(filterId)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(HttpTransport('https://mainnet.infura.io/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const uninstallFilter = (
+	filterId: FilterId,
+): Effect.Effect<boolean, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<boolean>("eth_uninstallFilter", [filterId]),
+	);

package/src/services/Provider/functions/unsubscribe.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Free function to unsubscribe from Ethereum events via eth_unsubscribe.
+ *
+ * @module Provider/functions/unsubscribe
+ * @since 0.4.0
+ */
+
+import * as Effect from "effect/Effect";
+import { ProviderService } from "../ProviderService.js";
+import type { TransportError } from "../../Transport/TransportError.js";
+
+/**
+ * Unsubscribes from an Ethereum subscription using eth_unsubscribe.
+ *
+ * @param subscriptionId - The subscription ID returned by subscribe()
+ * @returns Effect yielding true if successfully unsubscribed, false otherwise
+ *
+ * @since 0.4.0
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect'
+ * import { subscribe, unsubscribe, Provider, WebSocketTransport } from 'voltaire-effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const subId = yield* subscribe('newHeads')
+ *   // ... do work ...
+ *   const unsubscribed = yield* unsubscribe(subId)
+ *   console.log('Unsubscribed:', unsubscribed)
+ * }).pipe(
+ *   Effect.provide(Provider),
+ *   Effect.provide(WebSocketTransport('wss://mainnet.infura.io/ws/v3/YOUR_KEY'))
+ * )
+ * ```
+ */
+export const unsubscribe = (
+	subscriptionId: `0x${string}`,
+): Effect.Effect<boolean, TransportError, ProviderService> =>
+	Effect.flatMap(ProviderService, (svc) =>
+		svc.request<boolean>("eth_unsubscribe", [subscriptionId]),
+	);