voltaire-effect 0.2.23

package/dist/crypto/index.js

@@ -0,0 +1,1254 @@
+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 * as Effect46 from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Bls12381 from '@tevm/voltaire/Bls12381';
+import * as Ed25519 from '@tevm/voltaire/Ed25519';
+import { Keystore, DecryptionError, InvalidMacError, UnsupportedVersionError, UnsupportedKdfError, InvalidScryptNError, InvalidPbkdf2IterationsError, EncryptionError } from '@tevm/voltaire/Keystore';
+import * as P256 from '@tevm/voltaire/P256';
+import * as Secp256k1 from '@tevm/voltaire/Secp256k1';
+import { InvalidSignatureError as InvalidSignatureError$1, InvalidPublicKeyError as InvalidPublicKeyError$1, Secp256k1Error as Secp256k1Error$1, InvalidPrivateKeyError as InvalidPrivateKeyError$1 } from '@tevm/voltaire/Secp256k1';
+import { decodeParameters, encodeParameters } from '@tevm/voltaire/Abi';
+import { Address } from '@tevm/voltaire/Address';
+import * as Hex2 from '@tevm/voltaire/Hex';
+import * as X25519 from '@tevm/voltaire/X25519';
+
+// src/crypto/AesGcm/AesGcmService.ts
+var AesGcmService = class extends Context.Tag("AesGcmService")() {
+};
+var InvalidKeyError = class extends Data5.TaggedError("InvalidKeyError") {
+};
+var InvalidNonceError = class extends Data5.TaggedError("InvalidNonceError") {
+};
+var VALID_KEY_LENGTHS = [16, 32];
+var NONCE_LENGTH = 12;
+var validateKey = (key) => VALID_KEY_LENGTHS.includes(key.length) ? Effect46.void : Effect46.fail(
+  new InvalidKeyError({
+    message: `Key must be 16 or 32 bytes, got ${key.length}`,
+    keyLength: key.length,
+    expectedLengths: VALID_KEY_LENGTHS
+  })
+);
+var validateNonce = (nonce) => nonce.length === NONCE_LENGTH ? Effect46.void : Effect46.fail(
+  new InvalidNonceError({
+    message: `Nonce must be ${NONCE_LENGTH} bytes, got ${nonce.length}`,
+    nonceLength: nonce.length,
+    expectedLength: NONCE_LENGTH
+  })
+);
+var encrypt = (key, plaintext, nonce, aad) => Effect46.gen(function* () {
+  yield* validateKey(key);
+  yield* validateNonce(nonce);
+  return yield* Effect46.tryPromise({
+    try: async () => {
+      const cryptoKey = await AesGcm.importKey(key);
+      return AesGcm.encrypt(plaintext, cryptoKey, nonce, aad);
+    },
+    catch: (e) => e
+  });
+});
+var decrypt = (key, ciphertext, nonce, aad) => Effect46.gen(function* () {
+  yield* validateKey(key);
+  yield* validateNonce(nonce);
+  return yield* Effect46.tryPromise({
+    try: async () => {
+      const cryptoKey = await AesGcm.importKey(key);
+      return AesGcm.decrypt(ciphertext, cryptoKey, nonce, aad);
+    },
+    catch: (e) => e
+  });
+});
+var generateKey = (bits = 256) => Effect46.tryPromise({
+  try: async () => {
+    const cryptoKey = await AesGcm.generateKey(bits);
+    return AesGcm.exportKey(cryptoKey);
+  },
+  catch: (e) => e
+});
+var generateNonce = () => Effect46.try({
+  try: () => AesGcm.generateNonce(),
+  catch: (e) => e
+});
+var AesGcmLive = Layer.succeed(AesGcmService, {
+  encrypt: (key, plaintext, nonce, aad) => encrypt(key, plaintext, nonce, aad),
+  decrypt: (key, ciphertext, nonce, aad) => decrypt(key, ciphertext, nonce, aad),
+  generateKey: (bits) => generateKey(bits ?? 256),
+  generateNonce: () => generateNonce()
+});
+var AesGcmTest = Layer.succeed(AesGcmService, {
+  encrypt: () => Effect46.succeed(new Uint8Array(32)),
+  decrypt: () => Effect46.succeed(new Uint8Array(16)),
+  generateKey: () => Effect46.succeed(new Uint8Array(32)),
+  generateNonce: () => Effect46.succeed(new Uint8Array(12))
+});
+var Bip39Service = class extends Context.Tag("Bip39Service")() {
+};
+var Bip39Live = Layer.succeed(Bip39Service, {
+  generateMnemonic: (strength = 128) => Effect46.sync(() => Bip39.generateMnemonic(strength)),
+  validateMnemonic: (mnemonic) => Effect46.sync(() => Bip39.validateMnemonic(mnemonic)),
+  mnemonicToSeed: (mnemonic, passphrase) => Effect46.promise(() => Bip39.mnemonicToSeed(mnemonic, passphrase)),
+  mnemonicToSeedSync: (mnemonic, passphrase) => Effect46.sync(() => Bip39.mnemonicToSeedSync(mnemonic, passphrase)),
+  getWordCount: (entropyBits) => Effect46.sync(() => Bip39.getWordCount(entropyBits))
+});
+var TEST_MNEMONIC = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+var Bip39Test = Layer.succeed(Bip39Service, {
+  generateMnemonic: (_strength) => Effect46.succeed(TEST_MNEMONIC),
+  validateMnemonic: (_mnemonic) => Effect46.succeed(true),
+  mnemonicToSeed: (_mnemonic, _passphrase) => Effect46.succeed(new Uint8Array(64)),
+  mnemonicToSeedSync: (_mnemonic, _passphrase) => Effect46.succeed(new Uint8Array(64)),
+  getWordCount: (_entropyBits) => Effect46.succeed(12)
+});
+var generateMnemonic = (strength) => Effect46.gen(function* () {
+  const bip39 = yield* Bip39Service;
+  return yield* bip39.generateMnemonic(strength);
+});
+var validateMnemonic = (mnemonic) => Effect46.gen(function* () {
+  const bip39 = yield* Bip39Service;
+  return yield* bip39.validateMnemonic(mnemonic);
+});
+var mnemonicToSeed = (mnemonic, passphrase) => Effect46.gen(function* () {
+  const bip39 = yield* Bip39Service;
+  return yield* bip39.mnemonicToSeed(mnemonic, passphrase);
+});
+var mnemonicToSeedSync = (mnemonic, passphrase) => Effect46.gen(function* () {
+  const bip39 = yield* Bip39Service;
+  return yield* bip39.mnemonicToSeedSync(mnemonic, passphrase);
+});
+var getWordCount = (entropyBits) => Effect46.gen(function* () {
+  const bip39 = yield* Bip39Service;
+  return yield* bip39.getWordCount(entropyBits);
+});
+var Blake2Service = class extends Context.Tag("Blake2Service")() {
+};
+var Blake2Live = Layer.succeed(Blake2Service, {
+  hash: (data, outputLength = 64) => Effect46.sync(() => Blake2.hash(data, outputLength))
+});
+var Blake2Test = Layer.succeed(Blake2Service, {
+  hash: (_data, outputLength = 64) => Effect46.sync(() => new Uint8Array(outputLength))
+});
+var hash = (data, outputLength) => Effect46.gen(function* () {
+  const blake2 = yield* Blake2Service;
+  return yield* blake2.hash(data, outputLength);
+});
+var aggregate2 = (signatures) => Effect46.try({
+  try: () => Bls12381.aggregate(signatures),
+  catch: (e) => e
+});
+var Bls12381Service = class extends Context.Tag("Bls12381Service")() {
+};
+var sign2 = (message, privateKey) => Effect46.try({
+  try: () => Bls12381.sign(message, privateKey),
+  catch: (e) => e
+});
+var verify2 = (signature, message, publicKey) => Effect46.try({
+  try: () => Bls12381.verify(signature, message, publicKey),
+  catch: (e) => e
+});
+
+// src/crypto/Bls12381/Bls12381Live.ts
+var Bls12381Live = Layer.succeed(Bls12381Service, {
+  sign: sign2,
+  verify: verify2,
+  aggregate: aggregate2
+});
+var Bn254Error = class extends Data5.TaggedError("Bn254Error") {
+};
+var Bn254Service = class extends Context.Tag("Bn254Service")() {
+};
+var Bn254Live = Layer.succeed(Bn254Service, {
+  g1Add: (a, b) => Effect46.try({
+    try: () => BN254.G1.add(a, b),
+    catch: (e) => new Bn254Error({
+      operation: "g1Add",
+      message: `G1 point addition failed: ${e}`,
+      cause: e
+    })
+  }),
+  g1Mul: (point, scalar) => Effect46.try({
+    try: () => BN254.G1.mul(point, scalar),
+    catch: (e) => new Bn254Error({
+      operation: "g1Mul",
+      message: `G1 scalar multiplication failed: ${e}`,
+      cause: e
+    })
+  }),
+  g1Generator: () => Effect46.try({
+    try: () => BN254.G1.generator(),
+    catch: (e) => new Bn254Error({
+      operation: "g1Generator",
+      message: `Failed to get G1 generator: ${e}`,
+      cause: e
+    })
+  }),
+  g2Add: (a, b) => Effect46.try({
+    try: () => BN254.G2.add(a, b),
+    catch: (e) => new Bn254Error({
+      operation: "g2Add",
+      message: `G2 point addition failed: ${e}`,
+      cause: e
+    })
+  }),
+  g2Mul: (point, scalar) => Effect46.try({
+    try: () => BN254.G2.mul(point, scalar),
+    catch: (e) => new Bn254Error({
+      operation: "g2Mul",
+      message: `G2 scalar multiplication failed: ${e}`,
+      cause: e
+    })
+  }),
+  g2Generator: () => Effect46.try({
+    try: () => BN254.G2.generator(),
+    catch: (e) => new Bn254Error({
+      operation: "g2Generator",
+      message: `Failed to get G2 generator: ${e}`,
+      cause: e
+    })
+  }),
+  pairingCheck: (pairs) => Effect46.try({
+    try: () => BN254.Pairing.pairingCheck(pairs),
+    catch: (e) => new Bn254Error({
+      operation: "pairingCheck",
+      message: `Pairing check failed: ${e}`,
+      cause: e
+    })
+  })
+});
+var mockG1Point = {
+  x: 1n,
+  y: 2n,
+  z: 1n
+};
+var mockG2Point = {
+  x: { c0: 1n, c1: 0n },
+  y: { c0: 1n, c1: 0n },
+  z: { c0: 1n, c1: 0n }
+};
+var Bn254Test = Layer.succeed(Bn254Service, {
+  g1Add: (_a, _b) => Effect46.succeed(mockG1Point),
+  g1Mul: (_point, _scalar) => Effect46.succeed(mockG1Point),
+  g1Generator: () => Effect46.succeed(mockG1Point),
+  g2Add: (_a, _b) => Effect46.succeed(mockG2Point),
+  g2Mul: (_point, _scalar) => Effect46.succeed(mockG2Point),
+  g2Generator: () => Effect46.succeed(mockG2Point),
+  pairingCheck: (_pairs) => Effect46.succeed(true)
+});
+var g1Add = (a, b) => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g1Add(a, b);
+});
+var g1Mul = (point, scalar) => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g1Mul(point, scalar);
+});
+var g1Generator = () => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g1Generator();
+});
+var g2Add = (a, b) => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g2Add(a, b);
+});
+var g2Mul = (point, scalar) => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g2Mul(point, scalar);
+});
+var g2Generator = () => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.g2Generator();
+});
+var pairingCheck = (pairs) => Effect46.gen(function* () {
+  const bn254 = yield* Bn254Service;
+  return yield* bn254.pairingCheck(pairs);
+});
+var InvalidKeyError2 = class extends Data5.TaggedError("InvalidKeyError") {
+};
+var InvalidNonceError2 = class extends Data5.TaggedError("InvalidNonceError") {
+};
+
+// src/crypto/ChaCha20Poly1305/ChaCha20Poly1305Service.ts
+var KEY_LENGTH = 32;
+var NONCE_LENGTH2 = 12;
+var validateKey2 = (key) => key.length === KEY_LENGTH ? Effect46.void : Effect46.fail(
+  new InvalidKeyError2({
+    message: `Key must be ${KEY_LENGTH} bytes, got ${key.length}`,
+    keyLength: key.length,
+    expectedLength: KEY_LENGTH
+  })
+);
+var validateNonce2 = (nonce) => nonce.length === NONCE_LENGTH2 ? Effect46.void : Effect46.fail(
+  new InvalidNonceError2({
+    message: `Nonce must be ${NONCE_LENGTH2} bytes, got ${nonce.length}`,
+    nonceLength: nonce.length,
+    expectedLength: NONCE_LENGTH2
+  })
+);
+var ChaCha20Poly1305Service = class extends Context.Tag(
+  "ChaCha20Poly1305Service"
+)() {
+};
+var ChaCha20Poly1305Live = Layer.succeed(ChaCha20Poly1305Service, {
+  encrypt: (plaintext, key, nonce, additionalData) => Effect46.gen(function* () {
+    yield* validateKey2(key);
+    yield* validateNonce2(nonce);
+    return ChaCha20Poly1305.encrypt(plaintext, key, nonce, additionalData);
+  }),
+  decrypt: (ciphertext, key, nonce, additionalData) => Effect46.gen(function* () {
+    yield* validateKey2(key);
+    yield* validateNonce2(nonce);
+    return ChaCha20Poly1305.decrypt(ciphertext, key, nonce, additionalData);
+  }),
+  generateKey: () => Effect46.sync(() => ChaCha20Poly1305.generateKey()),
+  generateNonce: () => Effect46.sync(() => ChaCha20Poly1305.generateNonce())
+});
+var ChaCha20Poly1305Test = Layer.succeed(ChaCha20Poly1305Service, {
+  encrypt: (_plaintext, _key, _nonce, _additionalData) => Effect46.sync(() => new Uint8Array(32)),
+  decrypt: (_ciphertext, _key, _nonce, _additionalData) => Effect46.sync(() => new Uint8Array(16)),
+  generateKey: () => Effect46.sync(() => new Uint8Array(32)),
+  generateNonce: () => Effect46.sync(() => new Uint8Array(12))
+});
+var encrypt2 = (plaintext, key, nonce, additionalData) => Effect46.gen(function* () {
+  const service = yield* ChaCha20Poly1305Service;
+  return yield* service.encrypt(plaintext, key, nonce, additionalData);
+});
+var decrypt2 = (ciphertext, key, nonce, additionalData) => Effect46.gen(function* () {
+  const service = yield* ChaCha20Poly1305Service;
+  return yield* service.decrypt(ciphertext, key, nonce, additionalData);
+});
+var generateKey2 = () => Effect46.gen(function* () {
+  const service = yield* ChaCha20Poly1305Service;
+  return yield* service.generateKey();
+});
+var generateNonce2 = () => Effect46.gen(function* () {
+  const service = yield* ChaCha20Poly1305Service;
+  return yield* service.generateNonce();
+});
+var Ed25519Service = class extends Context.Tag("Ed25519Service")() {
+};
+var getPublicKey = (secretKey) => Effect46.try({
+  try: () => Ed25519.derivePublicKey(secretKey),
+  catch: (e) => e
+});
+var sign4 = (message, secretKey) => Effect46.try({
+  try: () => Ed25519.sign(message, secretKey),
+  catch: (e) => e
+});
+var verify4 = (signature, message, publicKey) => Effect46.try({
+  try: () => Ed25519.verify(signature, message, publicKey),
+  catch: (e) => e
+});
+
+// src/crypto/Ed25519/Ed25519Live.ts
+var Ed25519Live = Layer.succeed(Ed25519Service, {
+  sign: sign4,
+  verify: verify4,
+  getPublicKey
+});
+var EIP712Service = class extends Context.Tag("EIP712Service")() {
+};
+var EIP712Live = Layer.succeed(EIP712Service, {
+  hashTypedData: (typedData) => Effect46.sync(() => EIP712.hashTypedData(typedData)),
+  signTypedData: (typedData, privateKey) => Effect46.sync(() => EIP712.signTypedData(typedData, privateKey)),
+  verifyTypedData: (signature, typedData, address) => Effect46.sync(() => EIP712.verifyTypedData(signature, typedData, address)),
+  recoverAddress: (signature, typedData) => Effect46.sync(() => EIP712.recoverAddress(signature, typedData)),
+  hashDomain: (domain) => Effect46.sync(() => EIP712.Domain.hash(domain)),
+  hashStruct: (primaryType, data, types) => Effect46.sync(() => EIP712.hashStruct(primaryType, data, types))
+});
+var mockHash = new Uint8Array(32);
+var mockAddress = new Uint8Array(20);
+var mockSignature = {
+  r: new Uint8Array(32),
+  s: new Uint8Array(32),
+  v: 27
+};
+var EIP712Test = Layer.succeed(EIP712Service, {
+  hashTypedData: (_typedData) => Effect46.succeed(mockHash),
+  signTypedData: (_typedData, _privateKey) => Effect46.succeed(mockSignature),
+  verifyTypedData: (_signature, _typedData, _address) => Effect46.succeed(true),
+  recoverAddress: (_signature, _typedData) => Effect46.succeed(mockAddress),
+  hashDomain: (_domain) => Effect46.succeed(mockHash),
+  hashStruct: (_primaryType, _data, _types) => Effect46.succeed(mockHash)
+});
+var hashTypedData = (typedData) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.hashTypedData(typedData);
+});
+var signTypedData = (typedData, privateKey) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.signTypedData(typedData, privateKey);
+});
+var verifyTypedData = (signature, typedData, address) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.verifyTypedData(signature, typedData, address);
+});
+var recoverAddress = (signature, typedData) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.recoverAddress(signature, typedData);
+});
+var hashDomain = (domain) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.hashDomain(domain);
+});
+var hashStruct = (primaryType, data, types) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  return yield* eip712.hashStruct(primaryType, data, types);
+});
+var HMACService = class extends Context.Tag("HMACService")() {
+};
+var HMACLive = Layer.succeed(HMACService, {
+  sha256: (key, message) => Effect46.sync(() => HMAC.sha256(key, message)),
+  sha512: (key, message) => Effect46.sync(() => HMAC.sha512(key, message))
+});
+var HMACTest = Layer.succeed(HMACService, {
+  sha256: (_key, _message) => Effect46.succeed(new Uint8Array(32)),
+  sha512: (_key, _message) => Effect46.succeed(new Uint8Array(64))
+});
+var hmacSha256 = (key, message) => Effect46.gen(function* () {
+  const hmac = yield* HMACService;
+  return yield* hmac.sha256(key, message);
+});
+var hmacSha512 = (key, message) => Effect46.gen(function* () {
+  const hmac = yield* HMACService;
+  return yield* hmac.sha512(key, message);
+});
+var KeccakService = class extends Context.Tag("KeccakService")() {
+};
+var KeccakLive = Layer.succeed(KeccakService, {
+  hash: (data) => Effect46.sync(() => Keccak256.hash(data))
+});
+var KeccakTest = Layer.succeed(KeccakService, {
+  hash: (_data) => Effect46.sync(() => new Uint8Array(32))
+});
+
+// src/crypto/Keccak256/hash.ts
+var hash2 = (data) => Effect46.gen(function* () {
+  const keccak = yield* KeccakService;
+  return yield* keccak.hash(data);
+});
+var toDecryptError = (error) => {
+  if (error instanceof DecryptionError) return error;
+  if (error instanceof InvalidMacError) return error;
+  if (error instanceof UnsupportedVersionError) return error;
+  if (error instanceof UnsupportedKdfError) return error;
+  if (error instanceof InvalidScryptNError) return error;
+  if (error instanceof InvalidPbkdf2IterationsError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new DecryptionError(message, {
+    cause: error instanceof Error ? error : void 0
+  });
+};
+var decrypt3 = (keystore, password) => Effect46.try({
+  try: () => Keystore.decrypt(keystore, password),
+  catch: toDecryptError
+});
+var withDecryptedKey = (keystore, password, use) => Effect46.acquireRelease(
+  decrypt3(keystore, password),
+  (privateKey) => Effect46.sync(() => privateKey.fill(0))
+).pipe(Effect46.flatMap(use), Effect46.scoped);
+var toEncryptionError = (error) => {
+  if (error instanceof EncryptionError) return error;
+  if (error instanceof InvalidScryptNError) return error;
+  if (error instanceof InvalidPbkdf2IterationsError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new EncryptionError(message, {
+    cause: error instanceof Error ? error : void 0
+  });
+};
+var encrypt3 = (privateKey, password, options) => Effect46.tryPromise({
+  try: () => Keystore.encrypt(privateKey, password, options),
+  catch: toEncryptionError
+});
+var KeystoreService = class extends Context.Tag("KeystoreService")() {
+};
+
+// src/crypto/Keystore/KeystoreLive.ts
+var KeystoreLive = Layer.succeed(KeystoreService, {
+  encrypt: encrypt3,
+  decrypt: decrypt3
+});
+var mockPrivateKey = new Uint8Array(32).fill(
+  66
+);
+var mockKeystore = {
+  version: 3,
+  id: "test-uuid",
+  crypto: {
+    cipher: "aes-128-ctr",
+    ciphertext: "0".repeat(64),
+    cipherparams: { iv: "0".repeat(32) },
+    kdf: "scrypt",
+    kdfparams: {
+      dklen: 32,
+      n: 262144,
+      r: 8,
+      p: 1,
+      salt: "0".repeat(64)
+    },
+    mac: "0".repeat(64)
+  }
+};
+var testImpl = {
+  encrypt: (_privateKey, _password, _options) => Effect46.succeed(mockKeystore),
+  decrypt: (_keystore, _password) => Effect46.succeed(mockPrivateKey)
+};
+var KeystoreTest = Layer.succeed(KeystoreService, testImpl);
+var KZGError = class extends Data5.TaggedError("KZGError") {
+};
+var KZGService = class extends Context.Tag("KZGService")() {
+};
+var KZGLive = Layer.succeed(KZGService, {
+  blobToKzgCommitment: (blob) => Effect46.try({
+    try: () => KZG.blobToKzgCommitment(blob),
+    catch: (e) => new KZGError({
+      code: "INVALID_BLOB",
+      operation: "blobToKzgCommitment",
+      message: `Failed to compute KZG commitment: ${e}`,
+      cause: e
+    })
+  }),
+  computeBlobKzgProof: (blob, commitment) => Effect46.try({
+    try: () => KZG.computeBlobKzgProof(blob, commitment),
+    catch: (e) => new KZGError({
+      code: "OPERATION_FAILED",
+      operation: "computeBlobKzgProof",
+      message: `Failed to compute KZG proof: ${e}`,
+      cause: e
+    })
+  }),
+  verifyBlobKzgProof: (blob, commitment, proof) => Effect46.try({
+    try: () => KZG.verifyBlobKzgProof(blob, commitment, proof),
+    catch: (e) => new KZGError({
+      code: "OPERATION_FAILED",
+      operation: "verifyBlobKzgProof",
+      message: `Failed to verify KZG proof: ${e}`,
+      cause: e
+    })
+  }),
+  loadTrustedSetup: () => Effect46.try({
+    try: () => KZG.loadTrustedSetup(),
+    catch: (e) => new KZGError({
+      code: "SETUP_NOT_LOADED",
+      operation: "loadTrustedSetup",
+      message: `Failed to load trusted setup: ${e}`,
+      cause: e
+    })
+  }),
+  isInitialized: () => Effect46.try({
+    try: () => KZG.isInitialized(),
+    catch: (e) => new KZGError({
+      code: "OPERATION_FAILED",
+      operation: "isInitialized",
+      message: `Failed to check initialization status: ${e}`,
+      cause: e
+    })
+  })
+});
+var KZGTest = Layer.succeed(KZGService, {
+  blobToKzgCommitment: (_blob) => Effect46.sync(() => new Uint8Array(48)),
+  computeBlobKzgProof: (_blob, _commitment) => Effect46.sync(() => new Uint8Array(48)),
+  verifyBlobKzgProof: (_blob, _commitment, _proof) => Effect46.succeed(true),
+  loadTrustedSetup: () => Effect46.succeed(void 0),
+  isInitialized: () => Effect46.succeed(true)
+});
+
+// src/crypto/KZG/commit.ts
+var blobToKzgCommitment = (blob) => Effect46.gen(function* () {
+  const kzg = yield* KZGService;
+  return yield* kzg.blobToKzgCommitment(blob);
+});
+var computeBlobKzgProof = (blob, commitment) => Effect46.gen(function* () {
+  const kzg = yield* KZGService;
+  return yield* kzg.computeBlobKzgProof(blob, commitment);
+});
+var verifyBlobKzgProof = (blob, commitment, proof) => Effect46.gen(function* () {
+  const kzg = yield* KZGService;
+  return yield* kzg.verifyBlobKzgProof(blob, commitment, proof);
+});
+var P256Service = class extends Context.Tag("P256Service")() {
+};
+var sign6 = (messageHash, privateKey) => Effect46.try({
+  try: () => P256.sign(messageHash, privateKey),
+  catch: (e) => e
+});
+var verify6 = (signature, messageHash, publicKey) => Effect46.try({
+  try: () => P256.verify(signature, messageHash, publicKey),
+  catch: (e) => e
+});
+
+// src/crypto/P256/P256Live.ts
+var P256Live = Layer.succeed(P256Service, {
+  sign: sign6,
+  verify: verify6
+});
+var Ripemd160Service = class extends Context.Tag("Ripemd160Service")() {
+};
+var Ripemd160Live = Layer.succeed(Ripemd160Service, {
+  hash: (data) => Effect46.sync(() => Ripemd160.hash(data))
+});
+var Ripemd160Test = Layer.succeed(Ripemd160Service, {
+  hash: (_data) => Effect46.sync(() => new Uint8Array(20))
+});
+
+// src/crypto/Ripemd160/hash.ts
+var hash3 = (data) => Effect46.gen(function* () {
+  const ripemd160 = yield* Ripemd160Service;
+  return yield* ripemd160.hash(data);
+});
+var Secp256k1Error = class extends Data5.TaggedError("Secp256k1Error") {
+};
+var InvalidPrivateKeyError = class extends Data5.TaggedError(
+  "InvalidPrivateKeyError"
+) {
+};
+var InvalidPublicKeyError = class extends Data5.TaggedError(
+  "InvalidPublicKeyError"
+) {
+};
+var InvalidSignatureError = class extends Data5.TaggedError(
+  "InvalidSignatureError"
+) {
+};
+var InvalidRecoveryIdError = class extends Data5.TaggedError(
+  "InvalidRecoveryIdError"
+) {
+};
+var getMessage = (error) => error instanceof Error ? error.message : String(error);
+var getRecoveryId = (error) => {
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error.recoveryId ?? error.v;
+  return typeof candidate === "number" ? candidate : void 0;
+};
+function mapToSecp256k1Error(error, operation) {
+  const message = getMessage(error);
+  const normalized = message.toLowerCase();
+  const isPrivateKey = normalized.includes("private key") || normalized.includes("scalar");
+  const isPublicKey = normalized.includes("public key") || normalized.includes("point");
+  const isSignature = normalized.includes("signature");
+  const isRecovery = normalized.includes("recovery") || normalized.includes("recovery id");
+  const recoveryId = getRecoveryId(error);
+  switch (operation) {
+    case "sign": {
+      if (error instanceof InvalidPrivateKeyError) return error;
+      if (error instanceof Secp256k1Error) return error;
+      if (error instanceof InvalidPrivateKeyError$1) {
+        return new InvalidPrivateKeyError({
+          message: error.message,
+          cause: error
+        });
+      }
+      if (error instanceof Secp256k1Error$1) {
+        return new Secp256k1Error({ message: error.message, cause: error });
+      }
+      if (isPrivateKey) {
+        return new InvalidPrivateKeyError({
+          message: `Invalid private key: ${message}`,
+          cause: error
+        });
+      }
+      return new Secp256k1Error({
+        message: `sign failed: ${message}`,
+        cause: error
+      });
+    }
+    case "recover": {
+      if (error instanceof InvalidSignatureError) return error;
+      if (error instanceof InvalidRecoveryIdError) return error;
+      if (error instanceof Secp256k1Error) return error;
+      if (error instanceof InvalidSignatureError$1) {
+        return new InvalidSignatureError({
+          message: error.message,
+          cause: error
+        });
+      }
+      if (error instanceof Secp256k1Error$1) {
+        return new Secp256k1Error({ message: error.message, cause: error });
+      }
+      if (isRecovery) {
+        return new InvalidRecoveryIdError({
+          message: `Invalid recovery ID: ${message}`,
+          recoveryId: recoveryId ?? -1,
+          cause: error
+        });
+      }
+      if (isSignature) {
+        return new InvalidSignatureError({
+          message: `Invalid signature: ${message}`,
+          cause: error
+        });
+      }
+      return new Secp256k1Error({
+        message: `recover failed: ${message}`,
+        cause: error
+      });
+    }
+    case "verify": {
+      if (error instanceof InvalidSignatureError) return error;
+      if (error instanceof InvalidPublicKeyError) return error;
+      if (error instanceof Secp256k1Error) return error;
+      if (error instanceof InvalidSignatureError$1) {
+        return new InvalidSignatureError({
+          message: error.message,
+          cause: error
+        });
+      }
+      if (error instanceof InvalidPublicKeyError$1) {
+        return new InvalidPublicKeyError({
+          message: error.message,
+          cause: error
+        });
+      }
+      if (error instanceof Secp256k1Error$1) {
+        return new Secp256k1Error({ message: error.message, cause: error });
+      }
+      if (isPublicKey) {
+        return new InvalidPublicKeyError({
+          message: `Invalid public key: ${message}`,
+          cause: error
+        });
+      }
+      if (isSignature) {
+        return new InvalidSignatureError({
+          message: `Invalid signature: ${message}`,
+          cause: error
+        });
+      }
+      return new Secp256k1Error({
+        message: `verify failed: ${message}`,
+        cause: error
+      });
+    }
+  }
+}
+var Secp256k1Service = class extends Context.Tag("Secp256k1Service")() {
+};
+
+// src/crypto/Secp256k1/Secp256k1Live.ts
+var Secp256k1Live = Layer.succeed(Secp256k1Service, {
+  sign: (messageHash, privateKey, options) => Effect46.try({
+    try: () => Secp256k1.sign(messageHash, privateKey, options),
+    catch: (e) => mapToSecp256k1Error(e, "sign")
+  }),
+  recover: (signature, messageHash) => Effect46.try({
+    try: () => Secp256k1.recoverPublicKey(signature, messageHash),
+    catch: (e) => mapToSecp256k1Error(e, "recover")
+  }),
+  verify: (signature, messageHash, publicKey) => Effect46.try({
+    try: () => Secp256k1.verify(signature, messageHash, publicKey),
+    catch: (e) => mapToSecp256k1Error(e, "verify")
+  })
+});
+var SHA256Service = class extends Context.Tag("SHA256Service")() {
+};
+var SHA256Live = Layer.succeed(SHA256Service, {
+  hash: (data) => Effect46.sync(() => SHA256.hash(data))
+});
+var SHA256Test = Layer.succeed(SHA256Service, {
+  hash: (_data) => Effect46.sync(() => new Uint8Array(32))
+});
+
+// src/crypto/SHA256/hash.ts
+var hash4 = (data) => Effect46.gen(function* () {
+  const sha256 = yield* SHA256Service;
+  return yield* sha256.hash(data);
+});
+
+// src/crypto/CryptoLive.ts
+var CryptoLive = Layer.mergeAll(
+  KeccakLive,
+  Secp256k1Live,
+  SHA256Live,
+  Blake2Live,
+  Ripemd160Live,
+  Bls12381Live,
+  Ed25519Live,
+  P256Live,
+  KZGLive,
+  Bn254Live,
+  Bip39Live,
+  HMACLive,
+  EIP712Live,
+  ChaCha20Poly1305Live,
+  KeystoreLive
+);
+var Ed25519Test = Layer.succeed(Ed25519Service, {
+  sign: (_message, _secretKey) => Effect46.succeed(new Uint8Array(64)),
+  verify: (_signature, _message, _publicKey) => Effect46.succeed(true),
+  getPublicKey: (_secretKey) => Effect46.succeed(new Uint8Array(32))
+});
+var HDWalletService = class extends Context.Tag("HDWalletService")() {
+};
+var TEST_MNEMONIC2 = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+var HDWalletTest = Layer.succeed(HDWalletService, {
+  derive: (_node, _path) => Effect46.succeed({}),
+  generateMnemonic: (_strength) => Effect46.succeed(TEST_MNEMONIC2),
+  fromSeed: (_seed) => Effect46.succeed({}),
+  fromMnemonic: (_mnemonic, _passphrase) => Effect46.succeed({}),
+  mnemonicToSeed: (_mnemonic) => Effect46.succeed(new Uint8Array(64)),
+  getPrivateKey: (_node) => Effect46.succeed(new Uint8Array(32)),
+  getPublicKey: (_node) => Effect46.succeed(new Uint8Array(33))
+});
+var recover = (signature, messageHash) => Effect46.try({
+  try: () => Secp256k1.recoverPublicKey(signature, messageHash),
+  catch: (e) => mapToSecp256k1Error(e, "recover")
+});
+var mockSignature2 = new Uint8Array(65);
+var mockPublicKey = new Uint8Array(65);
+var testImpl2 = {
+  sign: (_messageHash, _privateKey, _options) => Effect46.succeed(mockSignature2),
+  recover: (_signature, _messageHash) => Effect46.succeed(mockPublicKey),
+  verify: (_signature, _messageHash, _publicKey) => Effect46.succeed(true)
+};
+var Secp256k1Test = Layer.succeed(Secp256k1Service, testImpl2);
+var sign9 = (messageHash, privateKey, options) => Effect46.try({
+  try: () => Secp256k1.sign(messageHash, privateKey, options),
+  catch: (e) => mapToSecp256k1Error(e, "sign")
+});
+var verify9 = (signature, messageHash, publicKey) => Effect46.try({
+  try: () => Secp256k1.verify(signature, messageHash, publicKey),
+  catch: (e) => mapToSecp256k1Error(e, "verify")
+});
+
+// src/crypto/CryptoTest.ts
+var CryptoTest = Layer.mergeAll(
+  KeccakTest,
+  Secp256k1Test,
+  SHA256Test,
+  Blake2Test,
+  Ripemd160Test,
+  Ed25519Test,
+  KZGTest,
+  HDWalletTest,
+  Bn254Test,
+  Bip39Test,
+  HMACTest,
+  EIP712Test,
+  ChaCha20Poly1305Test,
+  KeystoreTest
+);
+var ERC6492_SUFFIX = "0x6492649264926492649264926492649264926492649264926492649264926492";
+var ERC6492_PARAMS = [
+  { type: "address", name: "factory" },
+  { type: "bytes", name: "factoryData" },
+  { type: "bytes", name: "signature" }
+];
+var normalizeHex = (value) => typeof value === "string" ? value : Hex2.fromBytes(value);
+var unwrapSignature = (signature) => Effect46.sync(() => {
+  const lower = signature.toLowerCase();
+  const suffix = ERC6492_SUFFIX.slice(2);
+  if (!lower.endsWith(suffix)) {
+    return null;
+  }
+  const encoded = `0x${lower.slice(2, lower.length - suffix.length)}`;
+  try {
+    const decoded = decodeParameters(
+      ERC6492_PARAMS,
+      Hex2.toBytes(encoded)
+    );
+    const [factory, factoryData, innerSignature] = decoded;
+    return {
+      factoryAddress: Address(factory),
+      factoryData: normalizeHex(factoryData),
+      signature: normalizeHex(innerSignature)
+    };
+  } catch {
+    return null;
+  }
+});
+var VerifyError = class _VerifyError extends Data5.TaggedError("VerifyError") {
+  /**
+   * Creates a new VerifyError.
+   *
+   * @param message - Error description
+   * @param options - Optional cause
+   */
+  static of(message, options) {
+    return new _VerifyError({ message, cause: options?.cause });
+  }
+};
+var RecoverError = class _RecoverError extends Data5.TaggedError("RecoverError") {
+  /**
+   * Creates a new RecoverError.
+   *
+   * @param message - Error description
+   * @param options - Optional cause
+   */
+  static of(message, options) {
+    return new _RecoverError({ message, cause: options?.cause });
+  }
+};
+var AddressDerivationError = class _AddressDerivationError extends Data5.TaggedError(
+  "AddressDerivationError"
+) {
+  /**
+   * Creates a new AddressDerivationError.
+   *
+   * @param message - Error description
+   * @param options - Optional cause
+   */
+  static of(message, options) {
+    return new _AddressDerivationError({ message, cause: options?.cause });
+  }
+};
+
+// src/crypto/ERC6492/verifySignature.ts
+var UNIVERSAL_VALIDATOR_BYTECODE = "0x60806040523480156200001157600080fd5b50604051620007003803806200070083398101604081905262000034916200056f565b6000620000438484846200004f565b9050806000526001601ff35b600080846001600160a01b0316803b806020016040519081016040528181526000908060200190933c90507f6492649264926492649264926492649264926492649264926492649264926492620000a68462000451565b036200021f57600060608085806020019051810190620000c79190620005ce565b8651929550909350915060000362000192576000836001600160a01b031683604051620000f5919062000643565b6000604051808303816000865af19150503d806000811462000134576040519150601f19603f3d011682016040523d82523d6000602084013e62000139565b606091505b5050905080620001905760405162461bcd60e51b815260206004820152601e60248201527f5369676e617475726556616c696461746f723a206465706c6f796d656e74000060448201526064015b60405180910390fd5b505b604051630b135d3f60e11b808252906001600160a01b038a1690631626ba7e90620001c4908b90869060040162000661565b602060405180830381865afa158015620001e2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200020891906200069d565b6001600160e01b031916149450505050506200044a565b805115620002b157604051630b135d3f60e11b808252906001600160a01b03871690631626ba7e9062000259908890889060040162000661565b602060405180830381865afa15801562000277573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200029d91906200069d565b6001600160e01b031916149150506200044a565b8251604114620003195760405162461bcd60e51b815260206004820152603a6024820152600080516020620006e083398151915260448201527f3a20696e76616c6964207369676e6174757265206c656e677468000000000000606482015260840162000187565b620003236200046b565b506020830151604080850151855186939260009185919081106200034b576200034b620006c9565b016020015160f81c9050601b81148015906200036b57508060ff16601c14155b15620003cf5760405162461bcd60e51b815260206004820152603b6024820152600080516020620006e083398151915260448201527f3a20696e76616c6964207369676e617475726520762076616c75650000000000606482015260840162000187565b6040805160008152602081018083528a905260ff83169181019190915260608101849052608081018390526001600160a01b038a169060019060a0016020604051602081039080840390855afa1580156200042e573d6000803e3d6000fd5b505050602060405103516001600160a01b031614955050505050505b9392505050565b60006020825110156200046357600080fd5b508051015190565b60405180606001604052806003906020820280368337509192915050565b6001600160a01b03811681146200049f57600080fd5b50565b634e487b7160e01b600052604160045260246000fd5b60005b83811015620004d5578181015183820152602001620004bb565b50506000910152565b600082601f830112620004f057600080fd5b81516001600160401b03808211156200050d576200050d620004a2565b604051601f8301601f19908116603f01168101908282118183101715620005385762000538620004a2565b816040528381528660208588010111156200055257600080fd5b62000565846020830160208901620004b8565b9695505050505050565b6000806000606084860312156200058557600080fd5b8351620005928162000489565b6020850151604086015191945092506001600160401b03811115620005b657600080fd5b620005c486828701620004de565b9150509250925092565b600080600060608486031215620005e457600080fd5b8351620005f18162000489565b60208501519093506001600160401b03808211156200060f57600080fd5b6200061d87838801620004de565b935060408601519150808211156200063457600080fd5b50620005c486828701620004de565b6000825162000657818460208701620004b8565b9190910192915050565b828152604060208201526000825180604084015262000688816060850160208701620004b8565b601f01601f1916919091016060019392505050565b600060208284031215620006b057600080fd5b81516001600160e01b0319811681146200044a57600080fd5b634e487b7160e01b600052603260045260246000fdfe5369676e617475726556616c696461746f72237265636f7665725369676e6572";
+var VALIDATOR_PARAMS = [
+  { type: "address", name: "signer" },
+  { type: "bytes32", name: "hash" },
+  { type: "bytes", name: "signature" }
+];
+var normalizeAddress = (address) => typeof address === "string" ? address : Address.toHex(address);
+var decodeRevertReason = (data) => {
+  if (!data.startsWith("0x08c379a0")) {
+    return null;
+  }
+  try {
+    const decoded = decodeParameters(
+      [{ type: "string" }],
+      Hex2.toBytes(`0x${data.slice(10)}`)
+    );
+    return decoded[0];
+  } catch {
+    return null;
+  }
+};
+var normalizeCallResult = (value) => typeof value === "string" ? value : Hex2.fromBytes(value);
+var verifySignature = (params) => Effect46.gen(function* () {
+  const messageHex = params.message;
+  const messageBytes = yield* Effect46.try({
+    try: () => Hex2.toBytes(messageHex),
+    catch: (e) => new VerifyError({
+      message: `Invalid message hash: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  });
+  if (messageBytes.length !== 32) {
+    return yield* Effect46.fail(
+      new VerifyError({
+        message: `Invalid message hash length: expected 32 bytes, got ${messageBytes.length}`
+      })
+    );
+  }
+  const encodedParams = yield* Effect46.try({
+    try: () => encodeParameters(
+      VALIDATOR_PARAMS,
+      [
+        normalizeAddress(params.address),
+        messageHex,
+        params.signature
+      ]
+    ),
+    catch: (e) => new VerifyError({
+      message: `Failed to encode validation calldata: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  });
+  const data = `${UNIVERSAL_VALIDATOR_BYTECODE}${Hex2.fromBytes(encodedParams).slice(2)}`;
+  const callResult = yield* params.provider.call({ data }).pipe(
+    Effect46.mapError(
+      (e) => new VerifyError({
+        message: `Signature verification call failed: ${e instanceof Error ? e.message : String(e)}`,
+        cause: e
+      })
+    )
+  );
+  const callHex = normalizeCallResult(
+    callResult
+  ).toLowerCase();
+  const revertReason = decodeRevertReason(callHex);
+  if (revertReason) {
+    return yield* Effect46.fail(
+      new VerifyError({
+        message: `Signature verification reverted: ${revertReason}`
+      })
+    );
+  }
+  if (callHex === "0x01" || callHex === "0x1") {
+    return true;
+  }
+  if (callHex === "0x" || callHex === "0x00" || callHex === "0x0") {
+    return false;
+  }
+  return yield* Effect46.fail(
+    new VerifyError({
+      message: `Unexpected result from UniversalSigValidator: ${callHex}`
+    })
+  );
+});
+var ERC6492_SUFFIX2 = "0x6492649264926492649264926492649264926492649264926492649264926492";
+var ERC6492_PARAMS2 = [
+  { type: "address", name: "factory" },
+  { type: "bytes", name: "factoryData" },
+  { type: "bytes", name: "signature" }
+];
+var normalizeAddress2 = (address) => typeof address === "string" ? address : Address.toHex(address);
+var wrapSignature = (params) => Effect46.sync(() => {
+  const encoded = encodeParameters(
+    ERC6492_PARAMS2,
+    [
+      normalizeAddress2(params.factoryAddress),
+      params.factoryData,
+      params.signature
+    ]
+  );
+  const encodedHex = Hex2.fromBytes(encoded);
+  return `${encodedHex}${ERC6492_SUFFIX2.slice(2)}`;
+});
+var EIP191_PREFIX = "Ethereum Signed Message:\n";
+var hashMessage = (message) => Effect46.gen(function* () {
+  const keccak = yield* KeccakService;
+  let messageBytes;
+  if (typeof message === "string") {
+    if (message.startsWith("0x")) {
+      const hexStr = message.slice(2);
+      messageBytes = new Uint8Array(hexStr.length / 2);
+      for (let i = 0; i < messageBytes.length; i++) {
+        messageBytes[i] = Number.parseInt(hexStr.slice(i * 2, i * 2 + 2), 16);
+      }
+    } else {
+      messageBytes = new TextEncoder().encode(message);
+    }
+  } else {
+    messageBytes = message;
+  }
+  const lenStr = String(messageBytes.length);
+  const lenBytes = new TextEncoder().encode(lenStr);
+  const prefixBytes = new TextEncoder().encode(EIP191_PREFIX);
+  const totalLength = prefixBytes.length + lenBytes.length + messageBytes.length;
+  const data = new Uint8Array(totalLength);
+  data.set(prefixBytes, 0);
+  data.set(lenBytes, prefixBytes.length);
+  data.set(messageBytes, prefixBytes.length + lenBytes.length);
+  return yield* keccak.hash(data);
+});
+var InvalidPathError = class extends Data5.TaggedError("InvalidPathError") {
+};
+var InvalidSeedError = class extends Data5.TaggedError("InvalidSeedError") {
+};
+var HardenedDerivationError = class extends Data5.TaggedError(
+  "HardenedDerivationError"
+) {
+};
+var InvalidKeyError3 = class extends Data5.TaggedError("InvalidKeyError") {
+};
+
+// src/crypto/HDWallet/derive.ts
+var derive = (node, path) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.derive(node, path);
+});
+var generateMnemonic2 = (strength = 128) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.generateMnemonic(strength);
+});
+var fromSeed = (seed) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.fromSeed(seed);
+});
+var fromMnemonic = (mnemonic, passphrase) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.fromMnemonic(mnemonic, passphrase);
+});
+var mnemonicToSeed2 = (mnemonic) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.mnemonicToSeed(mnemonic);
+});
+var withSeed = (mnemonic, use) => Effect46.acquireRelease(
+  mnemonicToSeed2(mnemonic),
+  (seed) => Effect46.sync(() => seed.fill(0))
+).pipe(Effect46.flatMap(use), Effect46.scoped);
+var getPrivateKey = (node) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.getPrivateKey(node);
+});
+var withPrivateKey = (node, use) => Effect46.acquireRelease(
+  getPrivateKey(node),
+  (key) => Effect46.sync(() => {
+    if (key) {
+      key.fill(0);
+    }
+  })
+).pipe(
+  Effect46.flatMap(
+    (key) => key ? use(key) : Effect46.fail(
+      new InvalidKeyError3({
+        message: "HD node does not contain a private key."
+      })
+    )
+  ),
+  Effect46.scoped
+);
+var getPublicKey2 = (node) => Effect46.gen(function* () {
+  const hdwallet = yield* HDWalletService;
+  return yield* hdwallet.getPublicKey(node);
+});
+var ModExpService = class extends Context.Tag("ModExpService")() {
+};
+var ModExpLive = Layer.succeed(ModExpService, {
+  modexp: (base, exp, modulus) => Effect46.sync(() => ModExp.modexp(base, exp, modulus)),
+  modexpBytes: (baseBytes, expBytes, modBytes) => Effect46.sync(() => ModExp.modexpBytes(baseBytes, expBytes, modBytes)),
+  calculateGas: (baseLen, expLen, modLen, expHead) => Effect46.sync(() => ModExp.calculateGas(baseLen, expLen, modLen, expHead))
+});
+var ModExpTest = Layer.succeed(ModExpService, {
+  modexp: (_base, _exp, _modulus) => Effect46.sync(() => 0n),
+  modexpBytes: (_baseBytes, _expBytes, modBytes) => Effect46.sync(() => new Uint8Array(modBytes.length)),
+  calculateGas: (_baseLen, _expLen, _modLen, _expHead) => Effect46.sync(() => 200n)
+});
+var modexp = (base, exp, modulus) => Effect46.gen(function* () {
+  const service = yield* ModExpService;
+  return yield* service.modexp(base, exp, modulus);
+});
+var modexpBytes = (baseBytes, expBytes, modBytes) => Effect46.gen(function* () {
+  const service = yield* ModExpService;
+  return yield* service.modexpBytes(baseBytes, expBytes, modBytes);
+});
+var calculateGas = (baseLen, expLen, modLen, expHead) => Effect46.gen(function* () {
+  const service = yield* ModExpService;
+  return yield* service.calculateGas(baseLen, expLen, modLen, expHead);
+});
+
+// src/crypto/Signature/constantTimeEqual.ts
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+var normalizeSignature = (signature) => {
+  if (signature instanceof Uint8Array) {
+    if (signature.length !== 65) {
+      throw new Error(`Expected 65-byte signature, got ${signature.length}`);
+    }
+    const r2 = signature.slice(0, 32);
+    const s2 = signature.slice(32, 64);
+    const vByte = signature[64];
+    const v2 = vByte !== void 0 && vByte < 27 ? vByte + 27 : vByte ?? 27;
+    return { r: r2, s: s2, v: v2 };
+  }
+  const { r, s } = signature;
+  let v;
+  if (signature.v !== void 0) {
+    v = signature.v < 27 ? signature.v + 27 : signature.v;
+  } else if (signature.yParity !== void 0) {
+    v = signature.yParity + 27;
+  } else {
+    throw new Error("Signature must have either v or yParity");
+  }
+  return { r, s, v };
+};
+var recoverAddress2 = (params) => Effect46.gen(function* () {
+  const keccak = yield* KeccakService;
+  const secp256k1 = yield* Secp256k1Service;
+  const normalizedSig = yield* Effect46.try({
+    try: () => normalizeSignature(params.signature),
+    catch: (e) => RecoverError.of(`Invalid signature format: ${e}`, {
+      cause: e
+    })
+  });
+  const secp256k1Sig = {
+    r: Hash(normalizedSig.r),
+    s: Hash(normalizedSig.s),
+    v: normalizedSig.v
+  };
+  const publicKey = yield* secp256k1.recover(secp256k1Sig, params.hash).pipe(
+    Effect46.mapError(
+      (e) => new RecoverError({
+        message: `Public key recovery failed: ${e}`,
+        cause: e
+      })
+    )
+  );
+  const pubKeyBytes = publicKey;
+  const addressHash = yield* keccak.hash(pubKeyBytes).pipe(
+    Effect46.mapError(
+      (e) => new AddressDerivationError({
+        message: `Address hash failed: ${e}`,
+        cause: e
+      })
+    )
+  );
+  return addressHash.slice(12);
+});
+var recoverMessageAddress = (params) => Effect46.gen(function* () {
+  const hash5 = yield* hashMessage(params.message);
+  return yield* recoverAddress2({
+    hash: hash5,
+    signature: params.signature
+  });
+});
+var verifyHash = (params) => Effect46.gen(function* () {
+  const recoveredAddress = yield* recoverAddress2({
+    hash: params.hash,
+    signature: params.signature
+  }).pipe(
+    Effect46.mapError(
+      (e) => new VerifyError({
+        message: `Signature verification failed: ${e.message}`,
+        cause: e
+      })
+    )
+  );
+  return constantTimeEqual(recoveredAddress, params.address);
+});
+var verifyMessage = (params) => Effect46.gen(function* () {
+  const recoveredAddress = yield* recoverMessageAddress({
+    message: params.message,
+    signature: params.signature
+  }).pipe(
+    Effect46.mapError(
+      (e) => new VerifyError({
+        message: `Signature verification failed: ${e.message}`,
+        cause: e
+      })
+    )
+  );
+  return constantTimeEqual(recoveredAddress, params.address);
+});
+var verifyTypedData2 = (params) => Effect46.gen(function* () {
+  const eip712 = yield* EIP712Service;
+  const hash5 = yield* eip712.hashTypedData(params.typedData);
+  const recoveredAddress = yield* recoverAddress2({
+    hash: hash5,
+    signature: params.signature
+  }).pipe(
+    Effect46.mapError(
+      (e) => new VerifyError({
+        message: `Signature verification failed: ${e.message}`,
+        cause: e
+      })
+    )
+  );
+  return constantTimeEqual(recoveredAddress, params.address);
+});
+var computeSecret = (secretKey, publicKey) => Effect46.try({
+  try: () => X25519.scalarmult(secretKey, publicKey),
+  catch: (e) => e
+});
+var generateKeyPair = () => Effect46.sync(() => X25519.generateKeypair());
+var getPublicKey3 = (secretKey) => Effect46.try({
+  try: () => X25519.derivePublicKey(secretKey),
+  catch: (e) => e
+});
+var X25519Service = class extends Context.Tag("X25519Service")() {
+};
+
+// src/crypto/X25519/X25519Live.ts
+var X25519Live = Layer.succeed(X25519Service, {
+  generateKeyPair,
+  getPublicKey: getPublicKey3,
+  computeSecret
+});
+var X25519Test = Layer.succeed(X25519Service, {
+  generateKeyPair: () => Effect46.succeed({
+    secretKey: new Uint8Array(32),
+    publicKey: new Uint8Array(32)
+  }),
+  getPublicKey: (_secretKey) => Effect46.succeed(new Uint8Array(32)),
+  computeSecret: (_secretKey, _publicKey) => Effect46.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 };