voltaire-effect 0.3.0 → 1.0.1

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

@@ -4,7 +4,7 @@ import * as Effect from 'effect/Effect';
 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';
+import { c as InvalidSignatureError, b as InvalidRecoveryIdError, d as Secp256k1Error, S as Secp256k1Service, g as SignOptions, I as InvalidPrivateKeyError$1, a as InvalidPublicKeyError } from './Secp256k1Service-OxQ6hJFp.js';
 import * as Layer from 'effect/Layer';
 import { AddressType } from '@tevm/voltaire/Address';
 import { TypedData, Signature, Domain, Message, TypeDefinitions } from '@tevm/voltaire/EIP712';
@@ -18,7 +18,7 @@ import { InvalidSecretKeyError, Ed25519Error, InvalidSignatureError as InvalidSi
 import { HexType } from '@tevm/voltaire/Hex';
 import { HMACType } from '@tevm/voltaire/HMAC';
 import { Keystore, EncryptionError as EncryptionError$2, InvalidScryptNError, InvalidPbkdf2IterationsError, DecryptionError, InvalidMacError, UnsupportedVersionError, UnsupportedKdfError } from '@tevm/voltaire/Keystore';
-import { P256SignatureType, InvalidPrivateKeyError as InvalidPrivateKeyError$1, P256Error, InvalidPublicKeyError as InvalidPublicKeyError$1 } from '@tevm/voltaire/P256';
+import { P256SignatureType, InvalidPrivateKeyError as InvalidPrivateKeyError$2, P256Error, InvalidPublicKeyError as InvalidPublicKeyError$1 } from '@tevm/voltaire/P256';
 import { InvalidSecretKeyError as InvalidSecretKeyError$1, InvalidPublicKeyError as InvalidPublicKeyError$3, X25519Error } from '@tevm/voltaire/X25519';
 
 /**
@@ -378,7 +378,7 @@ declare const Secp256k1Test: Layer.Layer<Secp256k1Service, never, never>;
  * @see {@link Secp256k1Service} - Service interface for dependency injection
  * @since 0.0.1
  */
-declare const sign$3: (messageHash: HashType, privateKey: Uint8Array, options?: SignOptions) => Effect.Effect<Secp256k1SignatureType, InvalidPrivateKeyError | Secp256k1Error>;
+declare const sign$3: (messageHash: HashType, privateKey: Uint8Array, options?: SignOptions) => Effect.Effect<Secp256k1SignatureType, InvalidPrivateKeyError$1 | Secp256k1Error>;
 
 /**
  * @fileoverview Secp256k1 signature verification function for Effect-based applications.
@@ -2941,7 +2941,7 @@ interface P256ServiceShape {
      * @throws InvalidPrivateKeyError - When the private key is invalid
      * @throws P256Error - When signing fails
      */
-    readonly sign: (messageHash: HashType | Uint8Array, privateKey: Uint8Array) => Effect.Effect<P256SignatureType, InvalidPrivateKeyError$1 | P256Error>;
+    readonly sign: (messageHash: HashType | Uint8Array, privateKey: Uint8Array) => Effect.Effect<P256SignatureType, InvalidPrivateKeyError$2 | P256Error>;
     /**
      * Verifies a P-256 ECDSA signature against a message hash and public key.
      *
@@ -4794,7 +4794,7 @@ declare const P256Live: Layer.Layer<P256Service, never, never>;
  * @see {@link P256Service} - Full service interface
  * @since 0.0.1
  */
-declare const sign: (messageHash: HashType | Uint8Array, privateKey: Uint8Array) => Effect.Effect<P256SignatureType, InvalidPrivateKeyError$1 | P256Error>;
+declare const sign: (messageHash: HashType | Uint8Array, privateKey: Uint8Array) => Effect.Effect<P256SignatureType, InvalidPrivateKeyError$2 | P256Error>;
 
 /**
  * @fileoverview P-256 signature verification function for Effect-based applications.
@@ -4989,6 +4989,231 @@ declare const hash$1: (data: Uint8Array) => Effect.Effect<Ripemd160Hash, never,
  */
 declare const hash: (data: Uint8Array) => Effect.Effect<SHA256Hash, never, SHA256Service>;
 
+/**
+ * @fileoverview Error types for Signers module using Effect TaggedError.
+ * @module Signers/errors
+ * @since 0.0.1
+ */
+declare const CryptoError_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: "CryptoError";
+} & Readonly<A>;
+/**
+ * General cryptographic error during signing operations.
+ *
+ * @since 0.0.1
+ */
+declare class CryptoError extends CryptoError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const InvalidPrivateKeyError_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: "InvalidPrivateKeyError";
+} & Readonly<A>;
+/**
+ * Invalid private key format or value.
+ *
+ * @since 0.0.1
+ */
+declare class InvalidPrivateKeyError extends InvalidPrivateKeyError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+
+/**
+ * @fileoverview SignersService Effect service definition for cryptographic signing.
+ * @module
+ * @since 0.0.1
+ */
+
+/**
+ * Represents an Ethereum signer capable of signing messages, transactions, and typed data.
+ *
+ * @since 0.0.1
+ */
+interface Signer {
+    /** The Ethereum address derived from the signer's public key */
+    readonly address: string;
+    /** The 64-byte uncompressed public key (without 04 prefix) */
+    readonly publicKey: Uint8Array;
+    /** Signs a message using EIP-191 personal sign format */
+    readonly signMessage: (message: string | Uint8Array) => Effect.Effect<string, CryptoError>;
+    /** Signs a transaction and returns the signed transaction */
+    readonly signTransaction: (transaction: unknown) => Effect.Effect<unknown, CryptoError>;
+    /** Signs EIP-712 typed data */
+    readonly signTypedData: (typedData: unknown) => Effect.Effect<string, CryptoError>;
+}
+/**
+ * Shape of the SignersService interface.
+ *
+ * @since 0.0.1
+ */
+interface SignersServiceShape {
+    /** Creates a signer from a private key */
+    readonly fromPrivateKey: (privateKey: string | Uint8Array) => Effect.Effect<Signer, InvalidPrivateKeyError>;
+    /** Gets the Ethereum address from a signer */
+    readonly getAddress: (signer: Signer) => Effect.Effect<string, never>;
+    /** Recovers the sender address from a signed transaction */
+    readonly recoverTransactionAddress: (transaction: unknown) => Effect.Effect<string, CryptoError>;
+}
+declare const SignersService_base: Context.TagClass<SignersService, "SignersService", SignersServiceShape>;
+/**
+ * Effect service tag for cryptographic signing operations.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const signers = yield* SignersService
+ *   const signer = yield* signers.fromPrivateKey(privateKey)
+ *   const address = yield* signers.getAddress(signer)
+ *   return address
+ * })
+ * ```
+ *
+ * @since 0.0.1
+ */
+declare class SignersService extends SignersService_base {
+}
+
+/**
+ * @fileoverview Signer operations for Effect.
+ * @module Signers/operations
+ * @since 0.0.1
+ */
+
+/**
+ * Creates a signer from a private key.
+ *
+ * @description
+ * Constructs a Signer object that can sign messages, transactions, and typed data.
+ * The signer derives the Ethereum address and public key from the private key.
+ *
+ * @param privateKey - The 32-byte private key as hex string or Uint8Array
+ * @returns Effect containing a Signer object
+ *
+ * @example
+ * ```typescript
+ * import { fromPrivateKey, SignersLive } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signer = yield* fromPrivateKey('0x...')
+ *   const sig = yield* signer.signMessage('Hello')
+ *   return sig
+ * }).pipe(Effect.provide(SignersLive))
+ * ```
+ *
+ * @throws InvalidPrivateKeyError if the private key is invalid
+ * @see {@link getAddress} to get the signer's address
+ * @since 0.0.1
+ */
+declare const fromPrivateKey: (privateKey: string | Uint8Array) => Effect.Effect<Signer, InvalidPrivateKeyError>;
+/**
+ * Gets the Ethereum address from a signer.
+ *
+ * @description
+ * Returns the 20-byte Ethereum address derived from the signer's public key.
+ * The address is checksummed per EIP-55.
+ *
+ * @param signer - The signer object
+ * @returns Effect containing the Ethereum address as 0x-prefixed hex string
+ *
+ * @example
+ * ```typescript
+ * import { fromPrivateKey, getAddress, SignersLive } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signer = yield* fromPrivateKey('0x...')
+ *   return yield* getAddress(signer)
+ * }).pipe(Effect.provide(SignersLive))
+ * ```
+ *
+ * @throws Never fails
+ * @since 0.0.1
+ */
+declare const getAddress: (signer: Signer) => Effect.Effect<string, never>;
+/**
+ * Recovers the sender address from a signed transaction.
+ *
+ * @description
+ * Uses ecrecover to extract the Ethereum address that signed a transaction.
+ * This is how nodes verify transaction authenticity.
+ *
+ * @param transaction - The signed transaction object
+ * @returns Effect containing the recovered Ethereum address
+ *
+ * @example
+ * ```typescript
+ * import { recoverTransactionAddress, SignersLive } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = recoverTransactionAddress(signedTx).pipe(Effect.provide(SignersLive))
+ * ```
+ *
+ * @throws CryptoError if signature recovery fails
+ * @since 0.0.1
+ */
+declare const recoverTransactionAddress: (transaction: unknown) => Effect.Effect<string, CryptoError>;
+
+/**
+ * @fileoverview Production implementation of SignersService.
+ * @module Signers/SignersLive
+ * @since 0.0.1
+ */
+
+/**
+ * Production layer for SignersService using native implementation.
+ *
+ * @description
+ * Provides real signing operations using secp256k1 for signatures.
+ * Supports EIP-191 personal sign, transaction signing, and EIP-712 typed data.
+ *
+ * @example
+ * ```typescript
+ * import { SignersService, SignersLive } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const signers = yield* SignersService
+ *   const signer = yield* signers.fromPrivateKey(privateKey)
+ *   return yield* signers.getAddress(signer)
+ * }).pipe(Effect.provide(SignersLive))
+ * ```
+ *
+ * @since 0.0.1
+ * @see {@link SignersTest} for unit testing
+ */
+declare const SignersLive: Layer.Layer<SignersService, never, never>;
+
+/**
+ * @fileoverview Test implementation of SignersService.
+ * @module Signers/SignersTest
+ * @since 0.0.1
+ */
+
+/**
+ * Test layer for SignersService returning deterministic mock values.
+ *
+ * @description
+ * Provides mock implementations for unit testing. Returns a signer with
+ * the zero address and mock signatures.
+ * Use when testing application logic without cryptographic overhead.
+ *
+ * @example
+ * ```typescript
+ * import { SignersService, SignersTest, fromPrivateKey } from 'voltaire-effect/crypto/Signers'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const testProgram = fromPrivateKey('0x...').pipe(Effect.provide(SignersTest))
+ * // Returns mock signer with zero address
+ * ```
+ *
+ * @since 0.0.1
+ */
+declare const SignersTest: Layer.Layer<SignersService, never, never>;
+
 /**
  * @fileoverview X25519 ECDH shared secret computation for Effect.
  * @module X25519/computeSecret
@@ -5210,4 +5435,4 @@ declare const X25519Live: Layer.Layer<X25519Service, never, never>;
  */
 declare const X25519Test: Layer.Layer<X25519Service, never, never>;
 
-export { g2Mul as $, AddressDerivationError as A, Bip39Service as B, ChaCha20Poly1305Service as C, Blake2Live as D, EIP712Service as E, Blake2Test as F, hash$2 as G, HMACService as H, aggregate as I, Bls12381Live as J, KeystoreService as K, type Bls12381ServiceShape as L, sign$2 as M, verify$2 as N, Bn254Error as O, P256Service as P, Bn254Live as Q, Ripemd160Service as R, SHA256Service as S, type Bn254ServiceShape as T, Bn254Test as U, VerifyError as V, g1Add as W, g1Generator as X, g1Mul as Y, g2Add as Z, g2Generator as _, Blake2Service as a, type ModExpServiceShape as a$, pairingCheck as a0, ChaCha20Poly1305Live as a1, type ChaCha20Poly1305ServiceShape as a2, ChaCha20Poly1305Test as a3, decrypt$1 as a4, encrypt$1 as a5, generateKey as a6, generateNonce as a7, Ed25519Live as a8, type Ed25519ServiceShape as a9, type HDWalletServiceShape as aA, HDWalletTest as aB, InvalidKeyError as aC, InvalidPathError as aD, InvalidSeedError as aE, mnemonicToSeed as aF, withPrivateKey as aG, withSeed as aH, HMACLive as aI, type HMACServiceShape as aJ, HMACTest as aK, hmacSha256 as aL, hmacSha512 as aM, hash$3 as aN, type DecryptError as aO, decrypt as aP, encrypt as aQ, KeystoreLive as aR, type KeystoreServiceShape as aS, KeystoreTest as aT, withDecryptedKey as aU, blobToKzgCommitment as aV, computeBlobKzgProof as aW, verifyBlobKzgProof as aX, calculateGas as aY, ModExpLive as aZ, ModExpService as a_, Ed25519Test as aa, getPublicKey$2 as ab, sign$1 as ac, verify$1 as ad, EIP712Live as ae, type EIP712ServiceShape as af, EIP712Test as ag, hashDomain as ah, hashStruct as ai, hashTypedData as aj, recoverAddress$1 as ak, signTypedData as al, verifyTypedData as am, unwrapSignature as an, verifySignature as ao, wrapSignature as ap, derive as aq, fromMnemonic as ar, fromSeed as as, generateMnemonic as at, getPrivateKey as au, getPublicKey$1 as av, HardenedDerivationError as aw, type HDNode as ax, type HDPath as ay, type HDWalletError as az, Bls12381Service as b, ModExpTest as b0, modexp as b1, modexpBytes as b2, P256Live as b3, type P256ServiceShape as b4, sign as b5, verify as b6, hash$1 as b7, Ripemd160Live as b8, Ripemd160Test as b9, hash as ba, SHA256Live as bb, SHA256Test as bc, recoverAddress as bd, type SignatureError as be, computeSecret as bf, generateKeyPair as bg, getPublicKey as bh, X25519Live as bi, X25519Service as bj, type X25519ServiceShape as bk, X25519Test as bl, recover as bm, Secp256k1Live as bn, Secp256k1Test as bo, sign$3 as bp, verify$3 as bq, type MnemonicStrength as br, WORD_COUNTS as bs, type ChaCha20Poly1305Error as bt, InvalidKeyError$1 as bu, InvalidNonceError as bv, mapToHDWalletError as bw, Bn254Service as c, Ed25519Service as d, HDWalletService as e, CryptoLive as f, CryptoTest as g, type SignatureInput as h, index as i, RecoverError as j, AesGcmLive as k, AesGcmService as l, type AesGcmServiceShape as m, AesGcmTest as n, decrypt$2 as o, encrypt$2 as p, generateKey$1 as q, generateNonce$1 as r, Bip39Live as s, type Bip39ServiceShape as t, Bip39Test as u, generateMnemonic$1 as v, getWordCount as w, mnemonicToSeed$1 as x, mnemonicToSeedSync as y, validateMnemonic as z };
+export { g2Mul as $, AddressDerivationError as A, Bip39Service as B, ChaCha20Poly1305Service as C, Blake2Live as D, EIP712Service as E, Blake2Test as F, hash$2 as G, HMACService as H, aggregate as I, Bls12381Live as J, KeystoreService as K, type Bls12381ServiceShape as L, sign$2 as M, verify$2 as N, Bn254Error as O, P256Service as P, Bn254Live as Q, Ripemd160Service as R, SHA256Service as S, type Bn254ServiceShape as T, Bn254Test as U, VerifyError as V, g1Add as W, g1Generator as X, g1Mul as Y, g2Add as Z, g2Generator as _, Blake2Service as a, type ModExpServiceShape as a$, pairingCheck as a0, ChaCha20Poly1305Live as a1, type ChaCha20Poly1305ServiceShape as a2, ChaCha20Poly1305Test as a3, decrypt$1 as a4, encrypt$1 as a5, generateKey as a6, generateNonce as a7, Ed25519Live as a8, type Ed25519ServiceShape as a9, type HDWalletServiceShape as aA, HDWalletTest as aB, InvalidKeyError as aC, InvalidPathError as aD, InvalidSeedError as aE, mnemonicToSeed as aF, withPrivateKey as aG, withSeed as aH, HMACLive as aI, type HMACServiceShape as aJ, HMACTest as aK, hmacSha256 as aL, hmacSha512 as aM, hash$3 as aN, type DecryptError as aO, decrypt as aP, encrypt as aQ, KeystoreLive as aR, type KeystoreServiceShape as aS, KeystoreTest as aT, withDecryptedKey as aU, blobToKzgCommitment as aV, computeBlobKzgProof as aW, verifyBlobKzgProof as aX, calculateGas as aY, ModExpLive as aZ, ModExpService as a_, Ed25519Test as aa, getPublicKey$2 as ab, sign$1 as ac, verify$1 as ad, EIP712Live as ae, type EIP712ServiceShape as af, EIP712Test as ag, hashDomain as ah, hashStruct as ai, hashTypedData as aj, recoverAddress$1 as ak, signTypedData as al, verifyTypedData as am, unwrapSignature as an, verifySignature as ao, wrapSignature as ap, derive as aq, fromMnemonic as ar, fromSeed as as, generateMnemonic as at, getPrivateKey as au, getPublicKey$1 as av, HardenedDerivationError as aw, type HDNode as ax, type HDPath as ay, type HDWalletError as az, Bls12381Service as b, ModExpTest as b0, modexp as b1, modexpBytes as b2, P256Live as b3, type P256ServiceShape as b4, sign as b5, verify as b6, hash$1 as b7, Ripemd160Live as b8, Ripemd160Test as b9, WORD_COUNTS as bA, type ChaCha20Poly1305Error as bB, InvalidKeyError$1 as bC, InvalidNonceError as bD, mapToHDWalletError as bE, CryptoError as bF, InvalidPrivateKeyError as bG, hash as ba, SHA256Live as bb, SHA256Test as bc, recoverAddress as bd, type SignatureError as be, fromPrivateKey as bf, getAddress as bg, recoverTransactionAddress as bh, type Signer as bi, SignersLive as bj, SignersService as bk, type SignersServiceShape as bl, SignersTest as bm, computeSecret as bn, generateKeyPair as bo, getPublicKey as bp, X25519Live as bq, X25519Service as br, type X25519ServiceShape as bs, X25519Test as bt, recover as bu, Secp256k1Live as bv, Secp256k1Test as bw, sign$3 as bx, verify$3 as by, type MnemonicStrength as bz, Bn254Service as c, Ed25519Service as d, HDWalletService as e, CryptoLive as f, CryptoTest as g, type SignatureInput as h, index as i, RecoverError as j, AesGcmLive as k, AesGcmService as l, type AesGcmServiceShape as m, AesGcmTest as n, decrypt$2 as o, encrypt$2 as p, generateKey$1 as q, generateNonce$1 as r, Bip39Live as s, type Bip39ServiceShape as t, Bip39Test as u, generateMnemonic$1 as v, getWordCount as w, mnemonicToSeed$1 as x, mnemonicToSeedSync as y, validateMnemonic as z };

package/dist/crypto/index.d.ts

@@ -1,5 +1,5 @@
-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 { h as SignatureInput, j as RecoverError, A as AddressDerivationError, V as VerifyError, E as EIP712Service } from '../X25519Test-avt1DUgp.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, bv as Secp256k1Live, bw as Secp256k1Test, be as SignatureError, bi as Signer, bj as SignersLive, bk as SignersService, bl as SignersServiceShape, bm as SignersTest, bq as X25519Live, br as X25519Service, bs as X25519ServiceShape, bt 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, bf as fromPrivateKey, 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, bu as recover, bd as recoverAddress, bh as recoverTransactionAddress, b7 as ripemd160Hash, ba as sha256Hash, bx as sign, al as signTypedData, aj as signatureHashTypedData, bg as signersGetAddress, z as validateMnemonic, by as verify, aX as verifyBlobKzgProof, am as verifyTypedData, bn as x25519ComputeSecret, bo as x25519GenerateKeyPair, bp as x25519GetPublicKey } from '../X25519Test-avt1DUgp.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';

package/dist/crypto/index.js

@@ -1,6 +1,6 @@
 import * as Context from 'effect/Context';
 import * as Data5 from 'effect/Data';
-import { Bip39, Blake2, BN254, ChaCha20Poly1305, EIP712, HMAC, Keccak256, KZG, Ripemd160, SHA256, ModExp, AesGcm, Hash } from '@tevm/voltaire';
+import { Bip39, Blake2, BN254, ChaCha20Poly1305, EIP712, HMAC, Keccak256, KZG, Ripemd160, SHA256, ModExp, AesGcm, Signers, Hash } from '@tevm/voltaire';
 import * as Effect48 from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Bls12381 from '@tevm/voltaire/Bls12381';
@@ -1250,6 +1250,76 @@ var verifyTypedData2 = (params) => Effect48.gen(function* () {
   );
   return constantTimeEqual(recoveredAddress, params.address);
 });
+var CryptoError = class extends Data5.TaggedError("CryptoError") {
+};
+var InvalidPrivateKeyError2 = class extends Data5.TaggedError(
+  "InvalidPrivateKeyError"
+) {
+};
+var fromPrivateKey = (privateKey) => Effect48.try({
+  try: () => {
+    const impl = Signers.PrivateKeySignerImpl.fromPrivateKey({ privateKey });
+    return {
+      address: impl.address,
+      publicKey: impl.publicKey,
+      signMessage: (message) => Effect48.tryPromise({
+        try: () => impl.signMessage(message),
+        catch: (e) => new CryptoError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e
+        })
+      }),
+      signTransaction: (transaction) => Effect48.tryPromise({
+        try: () => impl.signTransaction(transaction),
+        catch: (e) => new CryptoError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e
+        })
+      }),
+      signTypedData: (typedData) => Effect48.tryPromise({
+        try: () => impl.signTypedData(typedData),
+        catch: (e) => new CryptoError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e
+        })
+      })
+    };
+  },
+  catch: (e) => new InvalidPrivateKeyError2({
+    message: e instanceof Error ? e.message : String(e),
+    cause: e
+  })
+});
+var getAddress = (signer) => Effect48.succeed(signer.address);
+var recoverTransactionAddress = (transaction) => Effect48.tryPromise({
+  try: () => Signers.recoverTransactionAddress(transaction),
+  catch: (e) => new CryptoError({
+    message: e instanceof Error ? e.message : String(e),
+    cause: e
+  })
+});
+var SignersService = class extends Context.Tag("SignersService")() {
+};
+
+// src/crypto/Signers/SignersLive.ts
+var SignersLive = Layer.succeed(SignersService, {
+  fromPrivateKey,
+  getAddress,
+  recoverTransactionAddress
+});
+var mockSigner = {
+  address: "0x0000000000000000000000000000000000000000",
+  publicKey: new Uint8Array(64),
+  signMessage: (_message) => Effect48.succeed(`0x${"00".repeat(65)}`),
+  signTransaction: (transaction) => Effect48.succeed(transaction),
+  signTypedData: (_typedData) => Effect48.succeed(`0x${"00".repeat(65)}`)
+};
+var testImpl3 = {
+  fromPrivateKey: (_privateKey) => Effect48.succeed(mockSigner),
+  getAddress: (signer) => Effect48.succeed(signer.address),
+  recoverTransactionAddress: (_transaction) => Effect48.succeed("0x0000000000000000000000000000000000000000")
+};
+var SignersTest = Layer.succeed(SignersService, testImpl3);
 var computeSecret = (secretKey, publicKey) => Effect48.try({
   try: () => X25519.scalarmult(secretKey, publicKey),
   catch: (e) => e
@@ -1277,4 +1347,4 @@ var X25519Test = Layer.succeed(X25519Service, {
   computeSecret: (_secretKey, _publicKey) => Effect48.succeed(new Uint8Array(32))
 });
 
-export { AddressDerivationError, AesGcmLive, AesGcmService, AesGcmTest, Bip39Live, Bip39Service, Bip39Test, Blake2Live, Blake2Service, Blake2Test, Bls12381Live, Bls12381Service, Bn254Error, Bn254Live, Bn254Service, Bn254Test, ChaCha20Poly1305Live, ChaCha20Poly1305Service, ChaCha20Poly1305Test, CryptoLive, CryptoTest, EIP712Live, EIP712Service, EIP712Test, Ed25519Live, Ed25519Service, Ed25519Test, HDWalletService, HDWalletTest, HMACLive, HMACService, HMACTest, HardenedDerivationError, InvalidKeyError3 as InvalidKeyError, InvalidPathError, InvalidPrivateKeyError, InvalidPublicKeyError, InvalidRecoveryIdError, InvalidSeedError, InvalidSignatureError, KZGError, KZGLive, KZGService, KZGTest, KeccakLive, KeccakService, KeccakTest, KeystoreLive, KeystoreService, KeystoreTest, ModExpLive, ModExpService, ModExpTest, P256Live, P256Service, RecoverError, Ripemd160Live, Ripemd160Service, Ripemd160Test, SHA256Live, SHA256Service, SHA256Test, Secp256k1Error, Secp256k1Live, Secp256k1Service, Secp256k1Test, VerifyError, X25519Live, X25519Service, X25519Test, decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, generateKey as aesGcmGenerateKey, generateNonce as aesGcmGenerateNonce, generateMnemonic as bip39GenerateMnemonic, mnemonicToSeed as bip39MnemonicToSeed, hash as blake2Hash, blobToKzgCommitment, aggregate2 as bls12381Aggregate, sign2 as bls12381Sign, verify2 as bls12381Verify, decrypt2 as chaCha20Poly1305Decrypt, encrypt2 as chaCha20Poly1305Encrypt, generateKey2 as chaCha20Poly1305GenerateKey, generateNonce2 as chaCha20Poly1305GenerateNonce, computeBlobKzgProof, constantTimeEqual, getPublicKey as ed25519GetPublicKey, sign4 as ed25519Sign, verify4 as ed25519Verify, recoverAddress as eip712RecoverAddress, unwrapSignature as erc6492UnwrapSignature, verifySignature as erc6492VerifySignature, wrapSignature as erc6492WrapSignature, fromMnemonic, fromSeed, g1Add, g1Generator, g1Mul, g2Add, g2Generator, g2Mul, generateMnemonic2 as generateMnemonic, getWordCount, hashDomain, hashMessage, hashMessage as hashPersonalMessage, hashStruct, hashTypedData, derive as hdwalletDerive, getPrivateKey as hdwalletGetPrivateKey, getPublicKey2 as hdwalletGetPublicKey, withPrivateKey as hdwalletWithPrivateKey, withSeed as hdwalletWithSeed, hmacSha256, hmacSha512, hash2 as keccakHash, decrypt3 as keystoreDecrypt, encrypt3 as keystoreEncrypt, withDecryptedKey as keystoreWithDecryptedKey, mapToSecp256k1Error, mnemonicToSeed2 as mnemonicToSeed, mnemonicToSeedSync, modexp, modexpBytes, calculateGas as modexpCalculateGas, sign6 as p256Sign, verify6 as p256Verify, pairingCheck, recover, recoverAddress2 as recoverAddress, recoverMessageAddress, hash3 as ripemd160Hash, hash4 as sha256Hash, sign9 as sign, signTypedData, hashTypedData as signatureHashTypedData, validateMnemonic, verify9 as verify, verifyBlobKzgProof, verifyHash, verifyMessage, verifyTypedData, verifyTypedData2 as verifyTypedDataSignature, computeSecret as x25519ComputeSecret, generateKeyPair as x25519GenerateKeyPair, getPublicKey3 as x25519GetPublicKey };
+export { AddressDerivationError, AesGcmLive, AesGcmService, AesGcmTest, Bip39Live, Bip39Service, Bip39Test, Blake2Live, Blake2Service, Blake2Test, Bls12381Live, Bls12381Service, Bn254Error, Bn254Live, Bn254Service, Bn254Test, ChaCha20Poly1305Live, ChaCha20Poly1305Service, ChaCha20Poly1305Test, CryptoLive, CryptoTest, EIP712Live, EIP712Service, EIP712Test, Ed25519Live, Ed25519Service, Ed25519Test, HDWalletService, HDWalletTest, HMACLive, HMACService, HMACTest, HardenedDerivationError, InvalidKeyError3 as InvalidKeyError, InvalidPathError, InvalidPrivateKeyError, InvalidPublicKeyError, InvalidRecoveryIdError, InvalidSeedError, InvalidSignatureError, KZGError, KZGLive, KZGService, KZGTest, KeccakLive, KeccakService, KeccakTest, KeystoreLive, KeystoreService, KeystoreTest, ModExpLive, ModExpService, ModExpTest, P256Live, P256Service, RecoverError, Ripemd160Live, Ripemd160Service, Ripemd160Test, SHA256Live, SHA256Service, SHA256Test, Secp256k1Error, Secp256k1Live, Secp256k1Service, Secp256k1Test, SignersLive, SignersService, SignersTest, VerifyError, X25519Live, X25519Service, X25519Test, decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, generateKey as aesGcmGenerateKey, generateNonce as aesGcmGenerateNonce, generateMnemonic as bip39GenerateMnemonic, mnemonicToSeed as bip39MnemonicToSeed, hash as blake2Hash, blobToKzgCommitment, aggregate2 as bls12381Aggregate, sign2 as bls12381Sign, verify2 as bls12381Verify, decrypt2 as chaCha20Poly1305Decrypt, encrypt2 as chaCha20Poly1305Encrypt, generateKey2 as chaCha20Poly1305GenerateKey, generateNonce2 as chaCha20Poly1305GenerateNonce, computeBlobKzgProof, constantTimeEqual, getPublicKey as ed25519GetPublicKey, sign4 as ed25519Sign, verify4 as ed25519Verify, recoverAddress as eip712RecoverAddress, unwrapSignature as erc6492UnwrapSignature, verifySignature as erc6492VerifySignature, wrapSignature as erc6492WrapSignature, fromMnemonic, fromPrivateKey, fromSeed, g1Add, g1Generator, g1Mul, g2Add, g2Generator, g2Mul, generateMnemonic2 as generateMnemonic, getWordCount, hashDomain, hashMessage, hashMessage as hashPersonalMessage, hashStruct, hashTypedData, derive as hdwalletDerive, getPrivateKey as hdwalletGetPrivateKey, getPublicKey2 as hdwalletGetPublicKey, withPrivateKey as hdwalletWithPrivateKey, withSeed as hdwalletWithSeed, hmacSha256, hmacSha512, hash2 as keccakHash, decrypt3 as keystoreDecrypt, encrypt3 as keystoreEncrypt, withDecryptedKey as keystoreWithDecryptedKey, mapToSecp256k1Error, mnemonicToSeed2 as mnemonicToSeed, mnemonicToSeedSync, modexp, modexpBytes, calculateGas as modexpCalculateGas, sign6 as p256Sign, verify6 as p256Verify, pairingCheck, recover, recoverAddress2 as recoverAddress, recoverMessageAddress, recoverTransactionAddress, hash3 as ripemd160Hash, hash4 as sha256Hash, sign9 as sign, signTypedData, hashTypedData as signatureHashTypedData, getAddress as signersGetAddress, validateMnemonic, verify9 as verify, verifyBlobKzgProof, verifyHash, verifyMessage, verifyTypedData, verifyTypedData2 as verifyTypedDataSignature, computeSecret as x25519ComputeSecret, generateKeyPair as x25519GenerateKeyPair, getPublicKey3 as x25519GetPublicKey };