voltaire-effect 0.2.24 → 0.2.25

package/dist/ProviderService-BZ5pqDrD.d.ts

@@ -0,0 +1,319 @@
+import { Keccak256Hash } from '@tevm/voltaire';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+
+/**
+ * @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 Minimal Provider service for blockchain JSON-RPC operations.
+ *
+ * @module ProviderService
+ * @since 0.0.1
+ */
+
+/**
+ * Minimal provider shape - only the request method.
+ * All operations are exposed as free functions that use this internally.
+ */
+type ProviderShape = {
+    readonly request: <T>(method: string, params?: unknown[]) => Effect.Effect<T, TransportError>;
+};
+declare const ProviderService_base: Context.TagClass<ProviderService, "ProviderService", ProviderShape>;
+/**
+ * Provider service for blockchain JSON-RPC operations.
+ * Use free functions (getBalance, getBlock, call, etc.) for operations.
+ */
+declare class ProviderService extends ProviderService_base {
+}
+
+export { KeccakService as K, ProviderService as P, TransportError as T, type ProviderShape as a, KeccakLive as b, KeccakTest as c, type KeccakServiceShape as d };

package/dist/{X25519Test-C8Cicdd_.d.ts → X25519Test-D5Q-5fL9.d.ts}

@@ -1,7 +1,7 @@
 import * as _tevm_voltaire from '@tevm/voltaire';
 import { Keccak256Hash, Blake2Hash, SHA256Hash, Ripemd160Hash, KzgBlobType, KzgCommitmentType, KzgProofType } from '@tevm/voltaire';
 import * as Effect from 'effect/Effect';
-import { am as KeccakService, _ as ProviderShape } from './AccountService-BetXokad.js';
+import { K as KeccakService, P as ProviderService } from './ProviderService-BZ5pqDrD.js';
 import { HashType } from '@tevm/voltaire/Hash';
 import { Secp256k1SignatureType, Secp256k1PublicKeyType } from '@tevm/voltaire/Secp256k1';
 import { c as InvalidSignatureError, b as InvalidRecoveryIdError, d as Secp256k1Error, S as Secp256k1Service, g as SignOptions, I as InvalidPrivateKeyError, a as InvalidPublicKeyError } from './Secp256k1Service-OxQ6hJFp.js';
@@ -3879,7 +3879,6 @@ declare const unwrapSignature: (signature: HexType | `0x${string}`) => Effect.Ef
  * @param params.address - Expected signer address
  * @param params.message - 32-byte message hash
  * @param params.signature - Signature bytes (may be ERC-6492 wrapped)
- * @param params.provider - Provider service used for eth_call
  * @returns Effect containing true if signature is valid
  *
  * @since 0.2.14
@@ -3888,8 +3887,7 @@ declare const verifySignature: (params: {
     address: AddressType | `0x${string}`;
     message: HexType | `0x${string}`;
     signature: HexType | `0x${string}`;
-    provider: ProviderShape;
-}) => Effect.Effect<boolean, VerifyError>;
+}) => Effect.Effect<boolean, VerifyError, ProviderService>;
 
 /**
  * @fileoverview Wrap signatures for ERC-6492 counterfactual validation.

package/dist/crypto/index.d.ts

@@ -1,7 +1,7 @@
-import { h as SignatureInput, j as RecoverError, A as AddressDerivationError, V as VerifyError, E as EIP712Service } from '../X25519Test-C8Cicdd_.js';
-export { k as AesGcmLive, l as AesGcmService, m as AesGcmServiceShape, n as AesGcmTest, s as Bip39Live, B as Bip39Service, t as Bip39ServiceShape, u as Bip39Test, D as Blake2Live, a as Blake2Service, F as Blake2Test, J as Bls12381Live, b as Bls12381Service, L as Bls12381ServiceShape, O as Bn254Error, Q as Bn254Live, c as Bn254Service, T as Bn254ServiceShape, U as Bn254Test, a1 as ChaCha20Poly1305Live, C as ChaCha20Poly1305Service, a2 as ChaCha20Poly1305ServiceShape, a3 as ChaCha20Poly1305Test, f as CryptoLive, g as CryptoTest, ae as EIP712Live, af as EIP712ServiceShape, ag as EIP712Test, a8 as Ed25519Live, d as Ed25519Service, a9 as Ed25519ServiceShape, aa as Ed25519Test, ax as HDNode, ay as HDPath, az as HDWalletError, e as HDWalletService, aA as HDWalletServiceShape, aB as HDWalletTest, aI as HMACLive, H as HMACService, aJ as HMACServiceShape, aK as HMACTest, aw as HardenedDerivationError, aC as InvalidKeyError, aD as InvalidPathError, aE as InvalidSeedError, aO as KeystoreDecryptError, aR as KeystoreLive, K as KeystoreService, aS as KeystoreServiceShape, aT as KeystoreTest, aZ as ModExpLive, a_ as ModExpService, a$ as ModExpServiceShape, b0 as ModExpTest, b3 as P256Live, P as P256Service, b4 as P256ServiceShape, b8 as Ripemd160Live, R as Ripemd160Service, b9 as Ripemd160Test, bb as SHA256Live, S as SHA256Service, bc as SHA256Test, bn as Secp256k1Live, bo as Secp256k1Test, be as SignatureError, bi as X25519Live, bj as X25519Service, bk as X25519ServiceShape, bl as X25519Test, o as aesGcmDecrypt, p as aesGcmEncrypt, q as aesGcmGenerateKey, r as aesGcmGenerateNonce, v as bip39GenerateMnemonic, x as bip39MnemonicToSeed, G as blake2Hash, aV as blobToKzgCommitment, I as bls12381Aggregate, M as bls12381Sign, N as bls12381Verify, a4 as chaCha20Poly1305Decrypt, a5 as chaCha20Poly1305Encrypt, a6 as chaCha20Poly1305GenerateKey, a7 as chaCha20Poly1305GenerateNonce, aW as computeBlobKzgProof, ab as ed25519GetPublicKey, ac as ed25519Sign, ad as ed25519Verify, ak as eip712RecoverAddress, an as erc6492UnwrapSignature, ao as erc6492VerifySignature, ap as erc6492WrapSignature, ar as fromMnemonic, as as fromSeed, W as g1Add, X as g1Generator, Y as g1Mul, Z as g2Add, _ as g2Generator, $ as g2Mul, at as generateMnemonic, w as getWordCount, ah as hashDomain, ai as hashStruct, aj as hashTypedData, aq as hdwalletDerive, au as hdwalletGetPrivateKey, av as hdwalletGetPublicKey, aG as hdwalletWithPrivateKey, aH as hdwalletWithSeed, aL as hmacSha256, aM as hmacSha512, aN as keccakHash, aP as keystoreDecrypt, aQ as keystoreEncrypt, aU as keystoreWithDecryptedKey, aF as mnemonicToSeed, y as mnemonicToSeedSync, b1 as modexp, b2 as modexpBytes, aY as modexpCalculateGas, b5 as p256Sign, b6 as p256Verify, a0 as pairingCheck, bm as recover, bd as recoverAddress, b7 as ripemd160Hash, ba as sha256Hash, bp as sign, al as signTypedData, aj as signatureHashTypedData, z as validateMnemonic, bq as verify, aX as verifyBlobKzgProof, am as verifyTypedData, bf as x25519ComputeSecret, bg as x25519GenerateKeyPair, bh as x25519GetPublicKey } from '../X25519Test-C8Cicdd_.js';
-import { am as KeccakService } from '../AccountService-BetXokad.js';
-export { an as KeccakLive, ao as KeccakTest } from '../AccountService-BetXokad.js';
+import { h as SignatureInput, j as RecoverError, A as AddressDerivationError, V as VerifyError, E as EIP712Service } from '../X25519Test-D5Q-5fL9.js';
+export { k as AesGcmLive, l as AesGcmService, m as AesGcmServiceShape, n as AesGcmTest, s as Bip39Live, B as Bip39Service, t as Bip39ServiceShape, u as Bip39Test, D as Blake2Live, a as Blake2Service, F as Blake2Test, J as Bls12381Live, b as Bls12381Service, L as Bls12381ServiceShape, O as Bn254Error, Q as Bn254Live, c as Bn254Service, T as Bn254ServiceShape, U as Bn254Test, a1 as ChaCha20Poly1305Live, C as ChaCha20Poly1305Service, a2 as ChaCha20Poly1305ServiceShape, a3 as ChaCha20Poly1305Test, f as CryptoLive, g as CryptoTest, ae as EIP712Live, af as EIP712ServiceShape, ag as EIP712Test, a8 as Ed25519Live, d as Ed25519Service, a9 as Ed25519ServiceShape, aa as Ed25519Test, ax as HDNode, ay as HDPath, az as HDWalletError, e as HDWalletService, aA as HDWalletServiceShape, aB as HDWalletTest, aI as HMACLive, H as HMACService, aJ as HMACServiceShape, aK as HMACTest, aw as HardenedDerivationError, aC as InvalidKeyError, aD as InvalidPathError, aE as InvalidSeedError, aO as KeystoreDecryptError, aR as KeystoreLive, K as KeystoreService, aS as KeystoreServiceShape, aT as KeystoreTest, aZ as ModExpLive, a_ as ModExpService, a$ as ModExpServiceShape, b0 as ModExpTest, b3 as P256Live, P as P256Service, b4 as P256ServiceShape, b8 as Ripemd160Live, R as Ripemd160Service, b9 as Ripemd160Test, bb as SHA256Live, S as SHA256Service, bc as SHA256Test, bn as Secp256k1Live, bo as Secp256k1Test, be as SignatureError, bi as X25519Live, bj as X25519Service, bk as X25519ServiceShape, bl as X25519Test, o as aesGcmDecrypt, p as aesGcmEncrypt, q as aesGcmGenerateKey, r as aesGcmGenerateNonce, v as bip39GenerateMnemonic, x as bip39MnemonicToSeed, G as blake2Hash, aV as blobToKzgCommitment, I as bls12381Aggregate, M as bls12381Sign, N as bls12381Verify, a4 as chaCha20Poly1305Decrypt, a5 as chaCha20Poly1305Encrypt, a6 as chaCha20Poly1305GenerateKey, a7 as chaCha20Poly1305GenerateNonce, aW as computeBlobKzgProof, ab as ed25519GetPublicKey, ac as ed25519Sign, ad as ed25519Verify, ak as eip712RecoverAddress, an as erc6492UnwrapSignature, ao as erc6492VerifySignature, ap as erc6492WrapSignature, ar as fromMnemonic, as as fromSeed, W as g1Add, X as g1Generator, Y as g1Mul, Z as g2Add, _ as g2Generator, $ as g2Mul, at as generateMnemonic, w as getWordCount, ah as hashDomain, ai as hashStruct, aj as hashTypedData, aq as hdwalletDerive, au as hdwalletGetPrivateKey, av as hdwalletGetPublicKey, aG as hdwalletWithPrivateKey, aH as hdwalletWithSeed, aL as hmacSha256, aM as hmacSha512, aN as keccakHash, aP as keystoreDecrypt, aQ as keystoreEncrypt, aU as keystoreWithDecryptedKey, aF as mnemonicToSeed, y as mnemonicToSeedSync, b1 as modexp, b2 as modexpBytes, aY as modexpCalculateGas, b5 as p256Sign, b6 as p256Verify, a0 as pairingCheck, bm as recover, bd as recoverAddress, b7 as ripemd160Hash, ba as sha256Hash, bp as sign, al as signTypedData, aj as signatureHashTypedData, z as validateMnemonic, bq as verify, aX as verifyBlobKzgProof, am as verifyTypedData, bf as x25519ComputeSecret, bg as x25519GenerateKeyPair, bh as x25519GetPublicKey } from '../X25519Test-D5Q-5fL9.js';
+import { K as KeccakService } from '../ProviderService-BZ5pqDrD.js';
+export { b as KeccakLive, c as KeccakTest } from '../ProviderService-BZ5pqDrD.js';
 import { Keccak256Hash } from '@tevm/voltaire';
 import * as Effect from 'effect/Effect';
 export { a as KZGError, b as KZGLive, K as KZGService, c as KZGServiceShape, d as KZGTest } from '../KZGService-B7PJerOb.js';
@@ -23,8 +23,6 @@ import '@tevm/voltaire/HMAC';
 import '@tevm/voltaire/Keystore';
 import '@tevm/voltaire/P256';
 import '@tevm/voltaire/X25519';
-import '@tevm/voltaire/block';
-import 'effect/Stream';
 
 /**
  * @fileoverview Constant-time comparison utility for cryptographic operations.