voltaire-effect 0.2.23 → 0.2.25

package/dist/crypto/index.js

@@ -1,7 +1,7 @@
 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 Effect48 from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Bls12381 from '@tevm/voltaire/Bls12381';
 import * as Ed25519 from '@tevm/voltaire/Ed25519';
@@ -23,24 +23,24 @@ 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(
+var validateKey = (key) => VALID_KEY_LENGTHS.includes(key.length) ? Effect48.void : Effect48.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(
+var validateNonce = (nonce) => nonce.length === NONCE_LENGTH ? Effect48.void : Effect48.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* () {
+var encrypt = (key, plaintext, nonce, aad) => Effect48.gen(function* () {
   yield* validateKey(key);
   yield* validateNonce(nonce);
-  return yield* Effect46.tryPromise({
+  return yield* Effect48.tryPromise({
     try: async () => {
       const cryptoKey = await AesGcm.importKey(key);
       return AesGcm.encrypt(plaintext, cryptoKey, nonce, aad);
@@ -48,10 +48,10 @@ var encrypt = (key, plaintext, nonce, aad) => Effect46.gen(function* () {
     catch: (e) => e
   });
 });
-var decrypt = (key, ciphertext, nonce, aad) => Effect46.gen(function* () {
+var decrypt = (key, ciphertext, nonce, aad) => Effect48.gen(function* () {
   yield* validateKey(key);
   yield* validateNonce(nonce);
-  return yield* Effect46.tryPromise({
+  return yield* Effect48.tryPromise({
     try: async () => {
       const cryptoKey = await AesGcm.importKey(key);
       return AesGcm.decrypt(ciphertext, cryptoKey, nonce, aad);
@@ -59,14 +59,14 @@ var decrypt = (key, ciphertext, nonce, aad) => Effect46.gen(function* () {
     catch: (e) => e
   });
 });
-var generateKey = (bits = 256) => Effect46.tryPromise({
+var generateKey = (bits = 256) => Effect48.tryPromise({
   try: async () => {
     const cryptoKey = await AesGcm.generateKey(bits);
     return AesGcm.exportKey(cryptoKey);
   },
   catch: (e) => e
 });
-var generateNonce = () => Effect46.try({
+var generateNonce = () => Effect48.try({
   try: () => AesGcm.generateNonce(),
   catch: (e) => e
 });
@@ -77,71 +77,71 @@ var AesGcmLive = Layer.succeed(AesGcmService, {
   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))
+  encrypt: () => Effect48.succeed(new Uint8Array(32)),
+  decrypt: () => Effect48.succeed(new Uint8Array(16)),
+  generateKey: () => Effect48.succeed(new Uint8Array(32)),
+  generateNonce: () => Effect48.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))
+  generateMnemonic: (strength = 128) => Effect48.sync(() => Bip39.generateMnemonic(strength)),
+  validateMnemonic: (mnemonic) => Effect48.sync(() => Bip39.validateMnemonic(mnemonic)),
+  mnemonicToSeed: (mnemonic, passphrase) => Effect48.promise(() => Bip39.mnemonicToSeed(mnemonic, passphrase)),
+  mnemonicToSeedSync: (mnemonic, passphrase) => Effect48.sync(() => Bip39.mnemonicToSeedSync(mnemonic, passphrase)),
+  getWordCount: (entropyBits) => Effect48.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)
+  generateMnemonic: (_strength) => Effect48.succeed(TEST_MNEMONIC),
+  validateMnemonic: (_mnemonic) => Effect48.succeed(true),
+  mnemonicToSeed: (_mnemonic, _passphrase) => Effect48.succeed(new Uint8Array(64)),
+  mnemonicToSeedSync: (_mnemonic, _passphrase) => Effect48.succeed(new Uint8Array(64)),
+  getWordCount: (_entropyBits) => Effect48.succeed(12)
 });
-var generateMnemonic = (strength) => Effect46.gen(function* () {
+var generateMnemonic = (strength) => Effect48.gen(function* () {
   const bip39 = yield* Bip39Service;
   return yield* bip39.generateMnemonic(strength);
 });
-var validateMnemonic = (mnemonic) => Effect46.gen(function* () {
+var validateMnemonic = (mnemonic) => Effect48.gen(function* () {
   const bip39 = yield* Bip39Service;
   return yield* bip39.validateMnemonic(mnemonic);
 });
-var mnemonicToSeed = (mnemonic, passphrase) => Effect46.gen(function* () {
+var mnemonicToSeed = (mnemonic, passphrase) => Effect48.gen(function* () {
   const bip39 = yield* Bip39Service;
   return yield* bip39.mnemonicToSeed(mnemonic, passphrase);
 });
-var mnemonicToSeedSync = (mnemonic, passphrase) => Effect46.gen(function* () {
+var mnemonicToSeedSync = (mnemonic, passphrase) => Effect48.gen(function* () {
   const bip39 = yield* Bip39Service;
   return yield* bip39.mnemonicToSeedSync(mnemonic, passphrase);
 });
-var getWordCount = (entropyBits) => Effect46.gen(function* () {
+var getWordCount = (entropyBits) => Effect48.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))
+  hash: (data, outputLength = 64) => Effect48.sync(() => Blake2.hash(data, outputLength))
 });
 var Blake2Test = Layer.succeed(Blake2Service, {
-  hash: (_data, outputLength = 64) => Effect46.sync(() => new Uint8Array(outputLength))
+  hash: (_data, outputLength = 64) => Effect48.sync(() => new Uint8Array(outputLength))
 });
-var hash = (data, outputLength) => Effect46.gen(function* () {
+var hash = (data, outputLength) => Effect48.gen(function* () {
   const blake2 = yield* Blake2Service;
   return yield* blake2.hash(data, outputLength);
 });
-var aggregate2 = (signatures) => Effect46.try({
+var aggregate2 = (signatures) => Effect48.try({
   try: () => Bls12381.aggregate(signatures),
   catch: (e) => e
 });
 var Bls12381Service = class extends Context.Tag("Bls12381Service")() {
 };
-var sign2 = (message, privateKey) => Effect46.try({
+var sign2 = (message, privateKey) => Effect48.try({
   try: () => Bls12381.sign(message, privateKey),
   catch: (e) => e
 });
-var verify2 = (signature, message, publicKey) => Effect46.try({
+var verify2 = (signature, message, publicKey) => Effect48.try({
   try: () => Bls12381.verify(signature, message, publicKey),
   catch: (e) => e
 });
@@ -157,7 +157,7 @@ var Bn254Error = class extends Data5.TaggedError("Bn254Error") {
 var Bn254Service = class extends Context.Tag("Bn254Service")() {
 };
 var Bn254Live = Layer.succeed(Bn254Service, {
-  g1Add: (a, b) => Effect46.try({
+  g1Add: (a, b) => Effect48.try({
     try: () => BN254.G1.add(a, b),
     catch: (e) => new Bn254Error({
       operation: "g1Add",
@@ -165,7 +165,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  g1Mul: (point, scalar) => Effect46.try({
+  g1Mul: (point, scalar) => Effect48.try({
     try: () => BN254.G1.mul(point, scalar),
     catch: (e) => new Bn254Error({
       operation: "g1Mul",
@@ -173,7 +173,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  g1Generator: () => Effect46.try({
+  g1Generator: () => Effect48.try({
     try: () => BN254.G1.generator(),
     catch: (e) => new Bn254Error({
       operation: "g1Generator",
@@ -181,7 +181,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  g2Add: (a, b) => Effect46.try({
+  g2Add: (a, b) => Effect48.try({
     try: () => BN254.G2.add(a, b),
     catch: (e) => new Bn254Error({
       operation: "g2Add",
@@ -189,7 +189,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  g2Mul: (point, scalar) => Effect46.try({
+  g2Mul: (point, scalar) => Effect48.try({
     try: () => BN254.G2.mul(point, scalar),
     catch: (e) => new Bn254Error({
       operation: "g2Mul",
@@ -197,7 +197,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  g2Generator: () => Effect46.try({
+  g2Generator: () => Effect48.try({
     try: () => BN254.G2.generator(),
     catch: (e) => new Bn254Error({
       operation: "g2Generator",
@@ -205,7 +205,7 @@ var Bn254Live = Layer.succeed(Bn254Service, {
       cause: e
     })
   }),
-  pairingCheck: (pairs) => Effect46.try({
+  pairingCheck: (pairs) => Effect48.try({
     try: () => BN254.Pairing.pairingCheck(pairs),
     catch: (e) => new Bn254Error({
       operation: "pairingCheck",
@@ -225,39 +225,39 @@ var mockG2Point = {
   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* () {
+  g1Add: (_a, _b) => Effect48.succeed(mockG1Point),
+  g1Mul: (_point, _scalar) => Effect48.succeed(mockG1Point),
+  g1Generator: () => Effect48.succeed(mockG1Point),
+  g2Add: (_a, _b) => Effect48.succeed(mockG2Point),
+  g2Mul: (_point, _scalar) => Effect48.succeed(mockG2Point),
+  g2Generator: () => Effect48.succeed(mockG2Point),
+  pairingCheck: (_pairs) => Effect48.succeed(true)
+});
+var g1Add = (a, b) => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g1Add(a, b);
 });
-var g1Mul = (point, scalar) => Effect46.gen(function* () {
+var g1Mul = (point, scalar) => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g1Mul(point, scalar);
 });
-var g1Generator = () => Effect46.gen(function* () {
+var g1Generator = () => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g1Generator();
 });
-var g2Add = (a, b) => Effect46.gen(function* () {
+var g2Add = (a, b) => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g2Add(a, b);
 });
-var g2Mul = (point, scalar) => Effect46.gen(function* () {
+var g2Mul = (point, scalar) => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g2Mul(point, scalar);
 });
-var g2Generator = () => Effect46.gen(function* () {
+var g2Generator = () => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.g2Generator();
 });
-var pairingCheck = (pairs) => Effect46.gen(function* () {
+var pairingCheck = (pairs) => Effect48.gen(function* () {
   const bn254 = yield* Bn254Service;
   return yield* bn254.pairingCheck(pairs);
 });
@@ -269,14 +269,14 @@ 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(
+var validateKey2 = (key) => key.length === KEY_LENGTH ? Effect48.void : Effect48.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(
+var validateNonce2 = (nonce) => nonce.length === NONCE_LENGTH2 ? Effect48.void : Effect48.fail(
   new InvalidNonceError2({
     message: `Nonce must be ${NONCE_LENGTH2} bytes, got ${nonce.length}`,
     nonceLength: nonce.length,
@@ -288,52 +288,52 @@ var ChaCha20Poly1305Service = class extends Context.Tag(
 )() {
 };
 var ChaCha20Poly1305Live = Layer.succeed(ChaCha20Poly1305Service, {
-  encrypt: (plaintext, key, nonce, additionalData) => Effect46.gen(function* () {
+  encrypt: (plaintext, key, nonce, additionalData) => Effect48.gen(function* () {
     yield* validateKey2(key);
     yield* validateNonce2(nonce);
     return ChaCha20Poly1305.encrypt(plaintext, key, nonce, additionalData);
   }),
-  decrypt: (ciphertext, key, nonce, additionalData) => Effect46.gen(function* () {
+  decrypt: (ciphertext, key, nonce, additionalData) => Effect48.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())
+  generateKey: () => Effect48.sync(() => ChaCha20Poly1305.generateKey()),
+  generateNonce: () => Effect48.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))
+  encrypt: (_plaintext, _key, _nonce, _additionalData) => Effect48.sync(() => new Uint8Array(32)),
+  decrypt: (_ciphertext, _key, _nonce, _additionalData) => Effect48.sync(() => new Uint8Array(16)),
+  generateKey: () => Effect48.sync(() => new Uint8Array(32)),
+  generateNonce: () => Effect48.sync(() => new Uint8Array(12))
 });
-var encrypt2 = (plaintext, key, nonce, additionalData) => Effect46.gen(function* () {
+var encrypt2 = (plaintext, key, nonce, additionalData) => Effect48.gen(function* () {
   const service = yield* ChaCha20Poly1305Service;
   return yield* service.encrypt(plaintext, key, nonce, additionalData);
 });
-var decrypt2 = (ciphertext, key, nonce, additionalData) => Effect46.gen(function* () {
+var decrypt2 = (ciphertext, key, nonce, additionalData) => Effect48.gen(function* () {
   const service = yield* ChaCha20Poly1305Service;
   return yield* service.decrypt(ciphertext, key, nonce, additionalData);
 });
-var generateKey2 = () => Effect46.gen(function* () {
+var generateKey2 = () => Effect48.gen(function* () {
   const service = yield* ChaCha20Poly1305Service;
   return yield* service.generateKey();
 });
-var generateNonce2 = () => Effect46.gen(function* () {
+var generateNonce2 = () => Effect48.gen(function* () {
   const service = yield* ChaCha20Poly1305Service;
   return yield* service.generateNonce();
 });
 var Ed25519Service = class extends Context.Tag("Ed25519Service")() {
 };
-var getPublicKey = (secretKey) => Effect46.try({
+var getPublicKey = (secretKey) => Effect48.try({
   try: () => Ed25519.derivePublicKey(secretKey),
   catch: (e) => e
 });
-var sign4 = (message, secretKey) => Effect46.try({
+var sign4 = (message, secretKey) => Effect48.try({
   try: () => Ed25519.sign(message, secretKey),
   catch: (e) => e
 });
-var verify4 = (signature, message, publicKey) => Effect46.try({
+var verify4 = (signature, message, publicKey) => Effect48.try({
   try: () => Ed25519.verify(signature, message, publicKey),
   catch: (e) => e
 });
@@ -347,12 +347,12 @@ var Ed25519Live = Layer.succeed(Ed25519Service, {
 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))
+  hashTypedData: (typedData) => Effect48.sync(() => EIP712.hashTypedData(typedData)),
+  signTypedData: (typedData, privateKey) => Effect48.sync(() => EIP712.signTypedData(typedData, privateKey)),
+  verifyTypedData: (signature, typedData, address) => Effect48.sync(() => EIP712.verifyTypedData(signature, typedData, address)),
+  recoverAddress: (signature, typedData) => Effect48.sync(() => EIP712.recoverAddress(signature, typedData)),
+  hashDomain: (domain) => Effect48.sync(() => EIP712.Domain.hash(domain)),
+  hashStruct: (primaryType, data, types) => Effect48.sync(() => EIP712.hashStruct(primaryType, data, types))
 });
 var mockHash = new Uint8Array(32);
 var mockAddress = new Uint8Array(20);
@@ -362,66 +362,66 @@ var mockSignature = {
   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* () {
+  hashTypedData: (_typedData) => Effect48.succeed(mockHash),
+  signTypedData: (_typedData, _privateKey) => Effect48.succeed(mockSignature),
+  verifyTypedData: (_signature, _typedData, _address) => Effect48.succeed(true),
+  recoverAddress: (_signature, _typedData) => Effect48.succeed(mockAddress),
+  hashDomain: (_domain) => Effect48.succeed(mockHash),
+  hashStruct: (_primaryType, _data, _types) => Effect48.succeed(mockHash)
+});
+var hashTypedData = (typedData) => Effect48.gen(function* () {
   const eip712 = yield* EIP712Service;
   return yield* eip712.hashTypedData(typedData);
 });
-var signTypedData = (typedData, privateKey) => Effect46.gen(function* () {
+var signTypedData = (typedData, privateKey) => Effect48.gen(function* () {
   const eip712 = yield* EIP712Service;
   return yield* eip712.signTypedData(typedData, privateKey);
 });
-var verifyTypedData = (signature, typedData, address) => Effect46.gen(function* () {
+var verifyTypedData = (signature, typedData, address) => Effect48.gen(function* () {
   const eip712 = yield* EIP712Service;
   return yield* eip712.verifyTypedData(signature, typedData, address);
 });
-var recoverAddress = (signature, typedData) => Effect46.gen(function* () {
+var recoverAddress = (signature, typedData) => Effect48.gen(function* () {
   const eip712 = yield* EIP712Service;
   return yield* eip712.recoverAddress(signature, typedData);
 });
-var hashDomain = (domain) => Effect46.gen(function* () {
+var hashDomain = (domain) => Effect48.gen(function* () {
   const eip712 = yield* EIP712Service;
   return yield* eip712.hashDomain(domain);
 });
-var hashStruct = (primaryType, data, types) => Effect46.gen(function* () {
+var hashStruct = (primaryType, data, types) => Effect48.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))
+  sha256: (key, message) => Effect48.sync(() => HMAC.sha256(key, message)),
+  sha512: (key, message) => Effect48.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))
+  sha256: (_key, _message) => Effect48.succeed(new Uint8Array(32)),
+  sha512: (_key, _message) => Effect48.succeed(new Uint8Array(64))
 });
-var hmacSha256 = (key, message) => Effect46.gen(function* () {
+var hmacSha256 = (key, message) => Effect48.gen(function* () {
   const hmac = yield* HMACService;
   return yield* hmac.sha256(key, message);
 });
-var hmacSha512 = (key, message) => Effect46.gen(function* () {
+var hmacSha512 = (key, message) => Effect48.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))
+  hash: (data) => Effect48.sync(() => Keccak256.hash(data))
 });
 var KeccakTest = Layer.succeed(KeccakService, {
-  hash: (_data) => Effect46.sync(() => new Uint8Array(32))
+  hash: (_data) => Effect48.sync(() => new Uint8Array(32))
 });
 
 // src/crypto/Keccak256/hash.ts
-var hash2 = (data) => Effect46.gen(function* () {
+var hash2 = (data) => Effect48.gen(function* () {
   const keccak = yield* KeccakService;
   return yield* keccak.hash(data);
 });
@@ -437,14 +437,14 @@ var toDecryptError = (error) => {
     cause: error instanceof Error ? error : void 0
   });
 };
-var decrypt3 = (keystore, password) => Effect46.try({
+var decrypt3 = (keystore, password) => Effect48.try({
   try: () => Keystore.decrypt(keystore, password),
   catch: toDecryptError
 });
-var withDecryptedKey = (keystore, password, use) => Effect46.acquireRelease(
+var withDecryptedKey = (keystore, password, use) => Effect48.acquireRelease(
   decrypt3(keystore, password),
-  (privateKey) => Effect46.sync(() => privateKey.fill(0))
-).pipe(Effect46.flatMap(use), Effect46.scoped);
+  (privateKey) => Effect48.sync(() => privateKey.fill(0))
+).pipe(Effect48.flatMap(use), Effect48.scoped);
 var toEncryptionError = (error) => {
   if (error instanceof EncryptionError) return error;
   if (error instanceof InvalidScryptNError) return error;
@@ -454,7 +454,7 @@ var toEncryptionError = (error) => {
     cause: error instanceof Error ? error : void 0
   });
 };
-var encrypt3 = (privateKey, password, options) => Effect46.tryPromise({
+var encrypt3 = (privateKey, password, options) => Effect48.tryPromise({
   try: () => Keystore.encrypt(privateKey, password, options),
   catch: toEncryptionError
 });
@@ -488,8 +488,8 @@ var mockKeystore = {
   }
 };
 var testImpl = {
-  encrypt: (_privateKey, _password, _options) => Effect46.succeed(mockKeystore),
-  decrypt: (_keystore, _password) => Effect46.succeed(mockPrivateKey)
+  encrypt: (_privateKey, _password, _options) => Effect48.succeed(mockKeystore),
+  decrypt: (_keystore, _password) => Effect48.succeed(mockPrivateKey)
 };
 var KeystoreTest = Layer.succeed(KeystoreService, testImpl);
 var KZGError = class extends Data5.TaggedError("KZGError") {
@@ -497,7 +497,7 @@ var KZGError = class extends Data5.TaggedError("KZGError") {
 var KZGService = class extends Context.Tag("KZGService")() {
 };
 var KZGLive = Layer.succeed(KZGService, {
-  blobToKzgCommitment: (blob) => Effect46.try({
+  blobToKzgCommitment: (blob) => Effect48.try({
     try: () => KZG.blobToKzgCommitment(blob),
     catch: (e) => new KZGError({
       code: "INVALID_BLOB",
@@ -506,7 +506,7 @@ var KZGLive = Layer.succeed(KZGService, {
       cause: e
     })
   }),
-  computeBlobKzgProof: (blob, commitment) => Effect46.try({
+  computeBlobKzgProof: (blob, commitment) => Effect48.try({
     try: () => KZG.computeBlobKzgProof(blob, commitment),
     catch: (e) => new KZGError({
       code: "OPERATION_FAILED",
@@ -515,7 +515,7 @@ var KZGLive = Layer.succeed(KZGService, {
       cause: e
     })
   }),
-  verifyBlobKzgProof: (blob, commitment, proof) => Effect46.try({
+  verifyBlobKzgProof: (blob, commitment, proof) => Effect48.try({
     try: () => KZG.verifyBlobKzgProof(blob, commitment, proof),
     catch: (e) => new KZGError({
       code: "OPERATION_FAILED",
@@ -524,7 +524,7 @@ var KZGLive = Layer.succeed(KZGService, {
       cause: e
     })
   }),
-  loadTrustedSetup: () => Effect46.try({
+  loadTrustedSetup: () => Effect48.try({
     try: () => KZG.loadTrustedSetup(),
     catch: (e) => new KZGError({
       code: "SETUP_NOT_LOADED",
@@ -533,7 +533,7 @@ var KZGLive = Layer.succeed(KZGService, {
       cause: e
     })
   }),
-  isInitialized: () => Effect46.try({
+  isInitialized: () => Effect48.try({
     try: () => KZG.isInitialized(),
     catch: (e) => new KZGError({
       code: "OPERATION_FAILED",
@@ -544,33 +544,33 @@ var KZGLive = Layer.succeed(KZGService, {
   })
 });
 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)
+  blobToKzgCommitment: (_blob) => Effect48.sync(() => new Uint8Array(48)),
+  computeBlobKzgProof: (_blob, _commitment) => Effect48.sync(() => new Uint8Array(48)),
+  verifyBlobKzgProof: (_blob, _commitment, _proof) => Effect48.succeed(true),
+  loadTrustedSetup: () => Effect48.succeed(void 0),
+  isInitialized: () => Effect48.succeed(true)
 });
 
 // src/crypto/KZG/commit.ts
-var blobToKzgCommitment = (blob) => Effect46.gen(function* () {
+var blobToKzgCommitment = (blob) => Effect48.gen(function* () {
   const kzg = yield* KZGService;
   return yield* kzg.blobToKzgCommitment(blob);
 });
-var computeBlobKzgProof = (blob, commitment) => Effect46.gen(function* () {
+var computeBlobKzgProof = (blob, commitment) => Effect48.gen(function* () {
   const kzg = yield* KZGService;
   return yield* kzg.computeBlobKzgProof(blob, commitment);
 });
-var verifyBlobKzgProof = (blob, commitment, proof) => Effect46.gen(function* () {
+var verifyBlobKzgProof = (blob, commitment, proof) => Effect48.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({
+var sign6 = (messageHash, privateKey) => Effect48.try({
   try: () => P256.sign(messageHash, privateKey),
   catch: (e) => e
 });
-var verify6 = (signature, messageHash, publicKey) => Effect46.try({
+var verify6 = (signature, messageHash, publicKey) => Effect48.try({
   try: () => P256.verify(signature, messageHash, publicKey),
   catch: (e) => e
 });
@@ -583,14 +583,14 @@ var P256Live = Layer.succeed(P256Service, {
 var Ripemd160Service = class extends Context.Tag("Ripemd160Service")() {
 };
 var Ripemd160Live = Layer.succeed(Ripemd160Service, {
-  hash: (data) => Effect46.sync(() => Ripemd160.hash(data))
+  hash: (data) => Effect48.sync(() => Ripemd160.hash(data))
 });
 var Ripemd160Test = Layer.succeed(Ripemd160Service, {
-  hash: (_data) => Effect46.sync(() => new Uint8Array(20))
+  hash: (_data) => Effect48.sync(() => new Uint8Array(20))
 });
 
 // src/crypto/Ripemd160/hash.ts
-var hash3 = (data) => Effect46.gen(function* () {
+var hash3 = (data) => Effect48.gen(function* () {
   const ripemd160 = yield* Ripemd160Service;
   return yield* ripemd160.hash(data);
 });
@@ -724,15 +724,15 @@ var Secp256k1Service = class extends Context.Tag("Secp256k1Service")() {
 
 // src/crypto/Secp256k1/Secp256k1Live.ts
 var Secp256k1Live = Layer.succeed(Secp256k1Service, {
-  sign: (messageHash, privateKey, options) => Effect46.try({
+  sign: (messageHash, privateKey, options) => Effect48.try({
     try: () => Secp256k1.sign(messageHash, privateKey, options),
     catch: (e) => mapToSecp256k1Error(e, "sign")
   }),
-  recover: (signature, messageHash) => Effect46.try({
+  recover: (signature, messageHash) => Effect48.try({
     try: () => Secp256k1.recoverPublicKey(signature, messageHash),
     catch: (e) => mapToSecp256k1Error(e, "recover")
   }),
-  verify: (signature, messageHash, publicKey) => Effect46.try({
+  verify: (signature, messageHash, publicKey) => Effect48.try({
     try: () => Secp256k1.verify(signature, messageHash, publicKey),
     catch: (e) => mapToSecp256k1Error(e, "verify")
   })
@@ -740,14 +740,14 @@ var Secp256k1Live = Layer.succeed(Secp256k1Service, {
 var SHA256Service = class extends Context.Tag("SHA256Service")() {
 };
 var SHA256Live = Layer.succeed(SHA256Service, {
-  hash: (data) => Effect46.sync(() => SHA256.hash(data))
+  hash: (data) => Effect48.sync(() => SHA256.hash(data))
 });
 var SHA256Test = Layer.succeed(SHA256Service, {
-  hash: (_data) => Effect46.sync(() => new Uint8Array(32))
+  hash: (_data) => Effect48.sync(() => new Uint8Array(32))
 });
 
 // src/crypto/SHA256/hash.ts
-var hash4 = (data) => Effect46.gen(function* () {
+var hash4 = (data) => Effect48.gen(function* () {
   const sha256 = yield* SHA256Service;
   return yield* sha256.hash(data);
 });
@@ -771,39 +771,39 @@ var CryptoLive = Layer.mergeAll(
   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))
+  sign: (_message, _secretKey) => Effect48.succeed(new Uint8Array(64)),
+  verify: (_signature, _message, _publicKey) => Effect48.succeed(true),
+  getPublicKey: (_secretKey) => Effect48.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({
+  derive: (_node, _path) => Effect48.succeed({}),
+  generateMnemonic: (_strength) => Effect48.succeed(TEST_MNEMONIC2),
+  fromSeed: (_seed) => Effect48.succeed({}),
+  fromMnemonic: (_mnemonic, _passphrase) => Effect48.succeed({}),
+  mnemonicToSeed: (_mnemonic) => Effect48.succeed(new Uint8Array(64)),
+  getPrivateKey: (_node) => Effect48.succeed(new Uint8Array(32)),
+  getPublicKey: (_node) => Effect48.succeed(new Uint8Array(33))
+});
+var recover = (signature, messageHash) => Effect48.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)
+  sign: (_messageHash, _privateKey, _options) => Effect48.succeed(mockSignature2),
+  recover: (_signature, _messageHash) => Effect48.succeed(mockPublicKey),
+  verify: (_signature, _messageHash, _publicKey) => Effect48.succeed(true)
 };
 var Secp256k1Test = Layer.succeed(Secp256k1Service, testImpl2);
-var sign9 = (messageHash, privateKey, options) => Effect46.try({
+var sign9 = (messageHash, privateKey, options) => Effect48.try({
   try: () => Secp256k1.sign(messageHash, privateKey, options),
   catch: (e) => mapToSecp256k1Error(e, "sign")
 });
-var verify9 = (signature, messageHash, publicKey) => Effect46.try({
+var verify9 = (signature, messageHash, publicKey) => Effect48.try({
   try: () => Secp256k1.verify(signature, messageHash, publicKey),
   catch: (e) => mapToSecp256k1Error(e, "verify")
 });
@@ -832,7 +832,7 @@ var ERC6492_PARAMS = [
   { type: "bytes", name: "signature" }
 ];
 var normalizeHex = (value) => typeof value === "string" ? value : Hex2.fromBytes(value);
-var unwrapSignature = (signature) => Effect46.sync(() => {
+var unwrapSignature = (signature) => Effect48.sync(() => {
   const lower = signature.toLowerCase();
   const suffix = ERC6492_SUFFIX.slice(2);
   if (!lower.endsWith(suffix)) {
@@ -854,6 +854,32 @@ var unwrapSignature = (signature) => Effect46.sync(() => {
     return null;
   }
 });
+var ProviderService = class extends Context.Tag("ProviderService")() {
+};
+var bytesToHex = (bytes) => {
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+var toAddressHex = (input) => {
+  if (typeof input === "string") return input;
+  return bytesToHex(input);
+};
+var formatCallRequest = (tx) => {
+  const formatted = {};
+  if (tx.from) formatted.from = toAddressHex(tx.from);
+  if (tx.to) formatted.to = toAddressHex(tx.to);
+  if (tx.data) formatted.data = tx.data;
+  if (tx.value !== void 0) formatted.value = `0x${tx.value.toString(16)}`;
+  if (tx.gas !== void 0) formatted.gas = `0x${tx.gas.toString(16)}`;
+  return formatted;
+};
+var call = (request, blockTag = "latest") => Effect48.flatMap(
+  ProviderService,
+  (svc) => svc.request("eth_call", [formatCallRequest(request), blockTag])
+);
 var VerifyError = class _VerifyError extends Data5.TaggedError("VerifyError") {
   /**
    * Creates a new VerifyError.
@@ -913,9 +939,9 @@ var decodeRevertReason = (data) => {
   }
 };
 var normalizeCallResult = (value) => typeof value === "string" ? value : Hex2.fromBytes(value);
-var verifySignature = (params) => Effect46.gen(function* () {
+var verifySignature = (params) => Effect48.gen(function* () {
   const messageHex = params.message;
-  const messageBytes = yield* Effect46.try({
+  const messageBytes = yield* Effect48.try({
     try: () => Hex2.toBytes(messageHex),
     catch: (e) => new VerifyError({
       message: `Invalid message hash: ${e instanceof Error ? e.message : String(e)}`,
@@ -923,13 +949,13 @@ var verifySignature = (params) => Effect46.gen(function* () {
     })
   });
   if (messageBytes.length !== 32) {
-    return yield* Effect46.fail(
+    return yield* Effect48.fail(
       new VerifyError({
         message: `Invalid message hash length: expected 32 bytes, got ${messageBytes.length}`
       })
     );
   }
-  const encodedParams = yield* Effect46.try({
+  const encodedParams = yield* Effect48.try({
     try: () => encodeParameters(
       VALIDATOR_PARAMS,
       [
@@ -944,8 +970,8 @@ var verifySignature = (params) => Effect46.gen(function* () {
     })
   });
   const data = `${UNIVERSAL_VALIDATOR_BYTECODE}${Hex2.fromBytes(encodedParams).slice(2)}`;
-  const callResult = yield* params.provider.call({ data }).pipe(
-    Effect46.mapError(
+  const callResult = yield* call({ data }).pipe(
+    Effect48.mapError(
       (e) => new VerifyError({
         message: `Signature verification call failed: ${e instanceof Error ? e.message : String(e)}`,
         cause: e
@@ -957,7 +983,7 @@ var verifySignature = (params) => Effect46.gen(function* () {
   ).toLowerCase();
   const revertReason = decodeRevertReason(callHex);
   if (revertReason) {
-    return yield* Effect46.fail(
+    return yield* Effect48.fail(
       new VerifyError({
         message: `Signature verification reverted: ${revertReason}`
       })
@@ -969,7 +995,7 @@ var verifySignature = (params) => Effect46.gen(function* () {
   if (callHex === "0x" || callHex === "0x00" || callHex === "0x0") {
     return false;
   }
-  return yield* Effect46.fail(
+  return yield* Effect48.fail(
     new VerifyError({
       message: `Unexpected result from UniversalSigValidator: ${callHex}`
     })
@@ -982,7 +1008,7 @@ var ERC6492_PARAMS2 = [
   { type: "bytes", name: "signature" }
 ];
 var normalizeAddress2 = (address) => typeof address === "string" ? address : Address.toHex(address);
-var wrapSignature = (params) => Effect46.sync(() => {
+var wrapSignature = (params) => Effect48.sync(() => {
   const encoded = encodeParameters(
     ERC6492_PARAMS2,
     [
@@ -995,7 +1021,7 @@ var wrapSignature = (params) => Effect46.sync(() => {
   return `${encodedHex}${ERC6492_SUFFIX2.slice(2)}`;
 });
 var EIP191_PREFIX = "Ethereum Signed Message:\n";
-var hashMessage = (message) => Effect46.gen(function* () {
+var hashMessage = (message) => Effect48.gen(function* () {
   const keccak = yield* KeccakService;
   let messageBytes;
   if (typeof message === "string") {
@@ -1033,76 +1059,76 @@ var InvalidKeyError3 = class extends Data5.TaggedError("InvalidKeyError") {
 };
 
 // src/crypto/HDWallet/derive.ts
-var derive = (node, path) => Effect46.gen(function* () {
+var derive = (node, path) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.derive(node, path);
 });
-var generateMnemonic2 = (strength = 128) => Effect46.gen(function* () {
+var generateMnemonic2 = (strength = 128) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.generateMnemonic(strength);
 });
-var fromSeed = (seed) => Effect46.gen(function* () {
+var fromSeed = (seed) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.fromSeed(seed);
 });
-var fromMnemonic = (mnemonic, passphrase) => Effect46.gen(function* () {
+var fromMnemonic = (mnemonic, passphrase) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.fromMnemonic(mnemonic, passphrase);
 });
-var mnemonicToSeed2 = (mnemonic) => Effect46.gen(function* () {
+var mnemonicToSeed2 = (mnemonic) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.mnemonicToSeed(mnemonic);
 });
-var withSeed = (mnemonic, use) => Effect46.acquireRelease(
+var withSeed = (mnemonic, use) => Effect48.acquireRelease(
   mnemonicToSeed2(mnemonic),
-  (seed) => Effect46.sync(() => seed.fill(0))
-).pipe(Effect46.flatMap(use), Effect46.scoped);
-var getPrivateKey = (node) => Effect46.gen(function* () {
+  (seed) => Effect48.sync(() => seed.fill(0))
+).pipe(Effect48.flatMap(use), Effect48.scoped);
+var getPrivateKey = (node) => Effect48.gen(function* () {
   const hdwallet = yield* HDWalletService;
   return yield* hdwallet.getPrivateKey(node);
 });
-var withPrivateKey = (node, use) => Effect46.acquireRelease(
+var withPrivateKey = (node, use) => Effect48.acquireRelease(
   getPrivateKey(node),
-  (key) => Effect46.sync(() => {
+  (key) => Effect48.sync(() => {
     if (key) {
       key.fill(0);
     }
   })
 ).pipe(
-  Effect46.flatMap(
-    (key) => key ? use(key) : Effect46.fail(
+  Effect48.flatMap(
+    (key) => key ? use(key) : Effect48.fail(
       new InvalidKeyError3({
         message: "HD node does not contain a private key."
       })
     )
   ),
-  Effect46.scoped
+  Effect48.scoped
 );
-var getPublicKey2 = (node) => Effect46.gen(function* () {
+var getPublicKey2 = (node) => Effect48.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))
+  modexp: (base, exp, modulus) => Effect48.sync(() => ModExp.modexp(base, exp, modulus)),
+  modexpBytes: (baseBytes, expBytes, modBytes) => Effect48.sync(() => ModExp.modexpBytes(baseBytes, expBytes, modBytes)),
+  calculateGas: (baseLen, expLen, modLen, expHead) => Effect48.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)
+  modexp: (_base, _exp, _modulus) => Effect48.sync(() => 0n),
+  modexpBytes: (_baseBytes, _expBytes, modBytes) => Effect48.sync(() => new Uint8Array(modBytes.length)),
+  calculateGas: (_baseLen, _expLen, _modLen, _expHead) => Effect48.sync(() => 200n)
 });
-var modexp = (base, exp, modulus) => Effect46.gen(function* () {
+var modexp = (base, exp, modulus) => Effect48.gen(function* () {
   const service = yield* ModExpService;
   return yield* service.modexp(base, exp, modulus);
 });
-var modexpBytes = (baseBytes, expBytes, modBytes) => Effect46.gen(function* () {
+var modexpBytes = (baseBytes, expBytes, modBytes) => Effect48.gen(function* () {
   const service = yield* ModExpService;
   return yield* service.modexpBytes(baseBytes, expBytes, modBytes);
 });
-var calculateGas = (baseLen, expLen, modLen, expHead) => Effect46.gen(function* () {
+var calculateGas = (baseLen, expLen, modLen, expHead) => Effect48.gen(function* () {
   const service = yield* ModExpService;
   return yield* service.calculateGas(baseLen, expLen, modLen, expHead);
 });
@@ -1140,10 +1166,10 @@ var normalizeSignature = (signature) => {
   }
   return { r, s, v };
 };
-var recoverAddress2 = (params) => Effect46.gen(function* () {
+var recoverAddress2 = (params) => Effect48.gen(function* () {
   const keccak = yield* KeccakService;
   const secp256k1 = yield* Secp256k1Service;
-  const normalizedSig = yield* Effect46.try({
+  const normalizedSig = yield* Effect48.try({
     try: () => normalizeSignature(params.signature),
     catch: (e) => RecoverError.of(`Invalid signature format: ${e}`, {
       cause: e
@@ -1155,7 +1181,7 @@ var recoverAddress2 = (params) => Effect46.gen(function* () {
     v: normalizedSig.v
   };
   const publicKey = yield* secp256k1.recover(secp256k1Sig, params.hash).pipe(
-    Effect46.mapError(
+    Effect48.mapError(
       (e) => new RecoverError({
         message: `Public key recovery failed: ${e}`,
         cause: e
@@ -1164,7 +1190,7 @@ var recoverAddress2 = (params) => Effect46.gen(function* () {
   );
   const pubKeyBytes = publicKey;
   const addressHash = yield* keccak.hash(pubKeyBytes).pipe(
-    Effect46.mapError(
+    Effect48.mapError(
       (e) => new AddressDerivationError({
         message: `Address hash failed: ${e}`,
         cause: e
@@ -1173,19 +1199,19 @@ var recoverAddress2 = (params) => Effect46.gen(function* () {
   );
   return addressHash.slice(12);
 });
-var recoverMessageAddress = (params) => Effect46.gen(function* () {
+var recoverMessageAddress = (params) => Effect48.gen(function* () {
   const hash5 = yield* hashMessage(params.message);
   return yield* recoverAddress2({
     hash: hash5,
     signature: params.signature
   });
 });
-var verifyHash = (params) => Effect46.gen(function* () {
+var verifyHash = (params) => Effect48.gen(function* () {
   const recoveredAddress = yield* recoverAddress2({
     hash: params.hash,
     signature: params.signature
   }).pipe(
-    Effect46.mapError(
+    Effect48.mapError(
       (e) => new VerifyError({
         message: `Signature verification failed: ${e.message}`,
         cause: e
@@ -1194,12 +1220,12 @@ var verifyHash = (params) => Effect46.gen(function* () {
   );
   return constantTimeEqual(recoveredAddress, params.address);
 });
-var verifyMessage = (params) => Effect46.gen(function* () {
+var verifyMessage = (params) => Effect48.gen(function* () {
   const recoveredAddress = yield* recoverMessageAddress({
     message: params.message,
     signature: params.signature
   }).pipe(
-    Effect46.mapError(
+    Effect48.mapError(
       (e) => new VerifyError({
         message: `Signature verification failed: ${e.message}`,
         cause: e
@@ -1208,14 +1234,14 @@ var verifyMessage = (params) => Effect46.gen(function* () {
   );
   return constantTimeEqual(recoveredAddress, params.address);
 });
-var verifyTypedData2 = (params) => Effect46.gen(function* () {
+var verifyTypedData2 = (params) => Effect48.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(
+    Effect48.mapError(
       (e) => new VerifyError({
         message: `Signature verification failed: ${e.message}`,
         cause: e
@@ -1224,12 +1250,12 @@ var verifyTypedData2 = (params) => Effect46.gen(function* () {
   );
   return constantTimeEqual(recoveredAddress, params.address);
 });
-var computeSecret = (secretKey, publicKey) => Effect46.try({
+var computeSecret = (secretKey, publicKey) => Effect48.try({
   try: () => X25519.scalarmult(secretKey, publicKey),
   catch: (e) => e
 });
-var generateKeyPair = () => Effect46.sync(() => X25519.generateKeypair());
-var getPublicKey3 = (secretKey) => Effect46.try({
+var generateKeyPair = () => Effect48.sync(() => X25519.generateKeypair());
+var getPublicKey3 = (secretKey) => Effect48.try({
   try: () => X25519.derivePublicKey(secretKey),
   catch: (e) => e
 });
@@ -1243,12 +1269,12 @@ var X25519Live = Layer.succeed(X25519Service, {
   computeSecret
 });
 var X25519Test = Layer.succeed(X25519Service, {
-  generateKeyPair: () => Effect46.succeed({
+  generateKeyPair: () => Effect48.succeed({
     secretKey: new Uint8Array(32),
     publicKey: new Uint8Array(32)
   }),
-  getPublicKey: (_secretKey) => Effect46.succeed(new Uint8Array(32)),
-  computeSecret: (_secretKey, _publicKey) => Effect46.succeed(new Uint8Array(32))
+  getPublicKey: (_secretKey) => Effect48.succeed(new Uint8Array(32)),
+  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 };