voltaire-effect 1.0.0 → 1.0.1

package/dist/crypto/index.d.ts

@@ -0,0 +1,288 @@
+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';
+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';
+import { S as Secp256k1Service } from '../Secp256k1Service-OxQ6hJFp.js';
+export { I as InvalidPrivateKeyError, a as InvalidPublicKeyError, b as InvalidRecoveryIdError, c as InvalidSignatureError, d as Secp256k1Error, e as Secp256k1Errors, f as Secp256k1ServiceShape, g as SignOptions, m as mapToSecp256k1Error } from '../Secp256k1Service-OxQ6hJFp.js';
+import { AddressType } from '@tevm/voltaire/Address';
+import { HashType } from '@tevm/voltaire/Hash';
+import { TypedData } from '@tevm/voltaire/EIP712';
+import '@tevm/voltaire/Secp256k1';
+import 'effect/Layer';
+import '@tevm/voltaire/Signature';
+import 'effect/Context';
+import 'effect/Cause';
+import 'effect/Types';
+import '@tevm/voltaire/Bls12381';
+import '@tevm/voltaire/Ed25519';
+import '@tevm/voltaire/Hex';
+import '@tevm/voltaire/HMAC';
+import '@tevm/voltaire/Keystore';
+import '@tevm/voltaire/P256';
+import '@tevm/voltaire/X25519';
+
+/**
+ * @fileoverview Constant-time comparison utility for cryptographic operations.
+ * @module Signature/constantTimeEqual
+ * @since 0.0.1
+ */
+/**
+ * Performs constant-time comparison of two Uint8Arrays.
+ *
+ * @description
+ * This function is resistant to timing attacks - it always takes the same
+ * amount of time regardless of where the arrays differ. Use this for
+ * security-sensitive comparisons like:
+ * - Comparing cryptographic hashes
+ * - Comparing MACs/signatures
+ * - Comparing addresses for verification
+ *
+ * The implementation:
+ * 1. Returns false immediately if lengths differ (length is public information)
+ * 2. XORs all bytes and accumulates - no early exit on mismatch
+ * 3. Returns true only if all bytes match (XOR result is 0)
+ *
+ * @param a - First Uint8Array
+ * @param b - Second Uint8Array
+ * @returns true if arrays are equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { constantTimeEqual } from 'voltaire-effect/crypto/Signature'
+ *
+ * // Use for cryptographic comparisons
+ * const isValid = constantTimeEqual(computedHash, expectedHash)
+ * const addressMatch = constantTimeEqual(recoveredAddr, expectedAddr)
+ * ```
+ *
+ * @since 0.0.1
+ */
+declare function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
+
+/**
+ * @fileoverview EIP-191 personal message hashing.
+ * @module Signature/hashMessage
+ * @since 0.0.1
+ */
+
+/**
+ * Hashes a message according to EIP-191 personal_sign format.
+ *
+ * @description
+ * Creates the hash: keccak256("\x19Ethereum Signed Message:\n" + len + message)
+ *
+ * This is the standard format used by `personal_sign` in Ethereum wallets.
+ * The prefix prevents signed messages from being valid transactions.
+ *
+ * @param message - The message to hash (string or bytes; strings starting with 0x are treated as hex)
+ * @returns Effect containing the 32-byte hash
+ *
+ * @example
+ * ```typescript
+ * import { hashMessage } from 'voltaire-effect/crypto/Signature'
+ * import { KeccakLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = hashMessage('Hello, Ethereum!').pipe(Effect.provide(KeccakLive))
+ * const hash = await Effect.runPromise(program)
+ * ```
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-191
+ * @since 0.0.1
+ */
+declare const hashMessage: (message: string | Uint8Array) => Effect.Effect<Keccak256Hash, never, KeccakService>;
+
+/**
+ * @fileoverview Recover Ethereum address from EIP-191 signed message.
+ * @module Signature/recoverMessageAddress
+ * @since 0.0.1
+ */
+
+/**
+ * Recovers the signer address from an EIP-191 personal_sign signature.
+ *
+ * @description
+ * Hashes the message using EIP-191 format, then recovers the signer address.
+ * This is the inverse of `personal_sign` - given a message and signature,
+ * we can determine who signed it.
+ *
+ * The function:
+ * 1. Hashes the message with EIP-191 prefix
+ * 2. Recovers the public key using ecrecover
+ * 3. Derives the address from the public key
+ *
+ * @param params - Object containing message and signature
+ * @param params.message - The original message (string or bytes)
+ * @param params.signature - The signature (65 bytes or {r, s, v/yParity})
+ * @returns Effect containing the recovered 20-byte address
+ *
+ * @example
+ * ```typescript
+ * import { recoverMessageAddress } from 'voltaire-effect/crypto/Signature'
+ * import { CryptoLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = recoverMessageAddress({
+ *   message: 'Hello, Ethereum!',
+ *   signature: sig
+ * }).pipe(Effect.provide(CryptoLive))
+ *
+ * const address = await Effect.runPromise(program)
+ * ```
+ *
+ * @throws {RecoverError} When public key recovery fails
+ * @throws {AddressDerivationError} When address derivation fails
+ * @since 0.0.1
+ */
+declare const recoverMessageAddress: (params: {
+    message: string | Uint8Array;
+    signature: SignatureInput;
+}) => Effect.Effect<AddressType, RecoverError | AddressDerivationError, KeccakService | Secp256k1Service>;
+
+/**
+ * @fileoverview Verify signature against a raw hash.
+ * @module Signature/verifyHash
+ * @since 0.0.1
+ */
+
+/**
+ * Verifies a signature against a raw message hash.
+ *
+ * @description
+ * Recovers the signer address from the hash and signature, then
+ * compares it to the expected address using constant-time comparison.
+ *
+ * Use this when you already have the message hash (e.g., from EIP-712
+ * or custom hashing). For EIP-191 personal_sign, use `verifyMessage` instead.
+ *
+ * @param params - Object containing hash, signature, and expected address
+ * @param params.hash - The 32-byte message hash that was signed
+ * @param params.signature - The signature (65 bytes or {r, s, v/yParity})
+ * @param params.address - The expected signer address (20 bytes)
+ * @returns Effect containing true if signature is valid
+ *
+ * @example
+ * ```typescript
+ * import { verifyHash } from 'voltaire-effect/crypto/Signature'
+ * import { CryptoLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = verifyHash({
+ *   hash: messageHash,
+ *   signature: sig,
+ *   address: expectedAddress
+ * }).pipe(Effect.provide(CryptoLive))
+ *
+ * const isValid = await Effect.runPromise(program)
+ * ```
+ *
+ * @throws {VerifyError} When signature verification fails
+ * @since 0.0.1
+ */
+declare const verifyHash: (params: {
+    hash: HashType;
+    signature: SignatureInput;
+    address: AddressType;
+}) => Effect.Effect<boolean, VerifyError, KeccakService | Secp256k1Service>;
+
+/**
+ * @fileoverview Verify EIP-191 personal_sign signature.
+ * @module Signature/verifyMessage
+ * @since 0.0.1
+ */
+
+/**
+ * Verifies an EIP-191 personal_sign signature.
+ *
+ * @description
+ * Recovers the signer address from the message and signature, then
+ * compares it to the expected address using constant-time comparison.
+ *
+ * Returns true if the signature was created by the expected address.
+ *
+ * @param params - Object containing message, signature, and expected address
+ * @param params.message - The original message (string or bytes)
+ * @param params.signature - The signature (65 bytes or {r, s, v/yParity})
+ * @param params.address - The expected signer address (20 bytes)
+ * @returns Effect containing true if signature is valid
+ *
+ * @example
+ * ```typescript
+ * import { verifyMessage } from 'voltaire-effect/crypto/Signature'
+ * import { CryptoLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = verifyMessage({
+ *   message: 'Hello, Ethereum!',
+ *   signature: sig,
+ *   address: expectedAddress
+ * }).pipe(Effect.provide(CryptoLive))
+ *
+ * const isValid = await Effect.runPromise(program)
+ * ```
+ *
+ * @throws {VerifyError} When signature verification fails
+ * @since 0.0.1
+ */
+declare const verifyMessage: (params: {
+    message: string | Uint8Array;
+    signature: SignatureInput;
+    address: AddressType;
+}) => Effect.Effect<boolean, VerifyError, KeccakService | Secp256k1Service>;
+
+/**
+ * @fileoverview Verify EIP-712 typed data signature.
+ * @module Signature/verifyTypedData
+ * @since 0.0.1
+ */
+
+/**
+ * Verifies an EIP-712 typed data signature.
+ *
+ * @description
+ * Hashes the typed data using EIP-712 format, recovers the signer address,
+ * and compares it to the expected address using constant-time comparison.
+ *
+ * Returns true if the signature was created by the expected address.
+ *
+ * @param params - Object containing typedData, signature, and expected address
+ * @param params.typedData - The EIP-712 typed data that was signed
+ * @param params.signature - The signature (65 bytes or {r, s, v/yParity})
+ * @param params.address - The expected signer address (20 bytes)
+ * @returns Effect containing true if signature is valid
+ *
+ * @example
+ * ```typescript
+ * import { verifyTypedData } from 'voltaire-effect/crypto/Signature'
+ * import { CryptoLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const typedData = {
+ *   domain: { name: 'MyDApp', version: '1', chainId: 1 },
+ *   types: { Person: [{ name: 'name', type: 'string' }] },
+ *   primaryType: 'Person',
+ *   message: { name: 'Alice' }
+ * }
+ *
+ * const program = verifyTypedData({
+ *   typedData,
+ *   signature: sig,
+ *   address: expectedAddress
+ * }).pipe(Effect.provide(CryptoLive))
+ *
+ * const isValid = await Effect.runPromise(program)
+ * ```
+ *
+ * @throws {VerifyError} When signature verification fails
+ * @since 0.0.1
+ */
+declare const verifyTypedData: (params: {
+    typedData: TypedData;
+    signature: SignatureInput;
+    address: AddressType;
+}) => Effect.Effect<boolean, VerifyError, KeccakService | Secp256k1Service | EIP712Service>;
+
+export { AddressDerivationError, EIP712Service, KeccakService, RecoverError, Secp256k1Service, SignatureInput, VerifyError, constantTimeEqual, hashMessage, hashMessage as hashPersonalMessage, recoverMessageAddress, verifyHash, verifyMessage, verifyTypedData as verifyTypedDataSignature };