voltaire-effect 0.2.23 → 0.2.24

package/dist/KZGService-B7PJerOb.d.ts

@@ -0,0 +1,146 @@
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { KzgBlobType, KzgCommitmentType, KzgProofType } from '@tevm/voltaire';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+declare const KZGError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "KZGError";
+} & Readonly<A>;
+/**
+ * Error thrown when a KZG operation fails.
+ *
+ * @description
+ * Contains the operation that failed, error code, message, and optional cause.
+ *
+ * Common failure reasons:
+ * - Trusted setup not loaded (SETUP_NOT_LOADED)
+ * - Invalid blob size or format (INVALID_BLOB)
+ * - Invalid commitment format (INVALID_COMMITMENT)
+ * - Invalid proof format (INVALID_PROOF)
+ * - Verification failure
+ *
+ * @since 0.0.1
+ */
+declare class KZGError extends KZGError_base<{
+    /** Error code for programmatic handling */
+    readonly code: "SETUP_NOT_LOADED" | "INVALID_BLOB" | "INVALID_COMMITMENT" | "INVALID_PROOF" | "OPERATION_FAILED";
+    /** The KZG operation that failed */
+    readonly operation: "blobToKzgCommitment" | "computeBlobKzgProof" | "verifyBlobKzgProof" | "loadTrustedSetup" | "isInitialized";
+    /** Human-readable error message */
+    readonly message: string;
+    /** Underlying error that caused this failure */
+    readonly cause?: unknown;
+}> {
+}
+/**
+ * Shape interface for KZG commitment service operations.
+ *
+ * @description
+ * Defines the contract for KZG implementations. Operations require the trusted
+ * setup to be loaded first via loadTrustedSetup().
+ *
+ * @since 0.0.1
+ */
+interface KZGServiceShape {
+    /**
+     * Computes a KZG commitment for a blob.
+     * @param blob - The 128KB blob data
+     * @returns Effect containing the 48-byte commitment, or KZGError if operation fails
+     */
+    readonly blobToKzgCommitment: (blob: KzgBlobType) => Effect.Effect<KzgCommitmentType, KZGError>;
+    /**
+     * Computes a KZG proof for a blob and commitment.
+     * @param blob - The 128KB blob data
+     * @param commitment - The 48-byte commitment
+     * @returns Effect containing the 48-byte proof, or KZGError if operation fails
+     */
+    readonly computeBlobKzgProof: (blob: KzgBlobType, commitment: KzgCommitmentType) => Effect.Effect<KzgProofType, KZGError>;
+    /**
+     * Verifies a KZG proof against a blob and commitment.
+     * @param blob - The 128KB blob data
+     * @param commitment - The 48-byte commitment
+     * @param proof - The 48-byte proof
+     * @returns Effect containing true if proof is valid, or KZGError if operation fails
+     */
+    readonly verifyBlobKzgProof: (blob: KzgBlobType, commitment: KzgCommitmentType, proof: KzgProofType) => Effect.Effect<boolean, KZGError>;
+    /**
+     * Loads the trusted setup for KZG operations.
+     * @returns Effect that completes when setup is loaded, or KZGError if loading fails
+     */
+    readonly loadTrustedSetup: () => Effect.Effect<void, KZGError>;
+    /**
+     * Checks if the trusted setup has been initialized.
+     * @returns Effect containing true if initialized, or KZGError if check fails
+     */
+    readonly isInitialized: () => Effect.Effect<boolean, KZGError>;
+}
+declare const KZGService_base: Context.TagClass<KZGService, "KZGService", KZGServiceShape>;
+/**
+ * KZG polynomial commitment service for Effect-based applications.
+ * Implements EIP-4844 blob commitments for Ethereum proto-danksharding.
+ *
+ * @example
+ * ```typescript
+ * import { KZGService, KZGLive } from 'voltaire-effect/crypto'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const kzg = yield* KZGService
+ *   yield* kzg.loadTrustedSetup()
+ *   const commitment = yield* kzg.blobToKzgCommitment(blob)
+ *   const proof = yield* kzg.computeBlobKzgProof(blob, commitment)
+ *   return yield* kzg.verifyBlobKzgProof(blob, commitment, proof)
+ * }).pipe(Effect.provide(KZGLive))
+ * ```
+ * @since 0.0.1
+ */
+declare class KZGService extends KZGService_base {
+}
+/**
+ * Production layer for KZGService using native KZG implementation.
+ *
+ * @description
+ * Provides real KZG operations using the c-kzg-4844 library with Ethereum's
+ * trusted setup. The trusted setup must be loaded before other operations.
+ *
+ * @example
+ * ```typescript
+ * import { KZGService, KZGLive } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const kzg = yield* KZGService
+ *   yield* kzg.loadTrustedSetup()
+ *   const commitment = yield* kzg.blobToKzgCommitment(blob)
+ *   return commitment
+ * }).pipe(Effect.provide(KZGLive))
+ * ```
+ *
+ * @since 0.0.1
+ * @see {@link KZGTest} for unit testing
+ */
+declare const KZGLive: Layer.Layer<KZGService, never, never>;
+/**
+ * Test layer for KZGService returning deterministic mock values.
+ *
+ * @description
+ * Provides mock implementations for unit testing. Returns zero-filled
+ * arrays for commitments/proofs and always verifies as true.
+ * Use when testing application logic without cryptographic overhead.
+ *
+ * @example
+ * ```typescript
+ * import { KZGService, KZGTest, blobToKzgCommitment } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const testProgram = blobToKzgCommitment(blob).pipe(Effect.provide(KZGTest))
+ * // Returns Uint8Array(48) filled with zeros
+ * ```
+ *
+ * @since 0.0.1
+ */
+declare const KZGTest: Layer.Layer<KZGService, never, never>;
+
+export { KZGService as K, KZGError as a, KZGLive as b, type KZGServiceShape as c, KZGTest as d };

package/dist/{X25519Test-DGsk1V9o.d.ts → X25519Test-C8Cicdd_.d.ts}

@@ -13,6 +13,7 @@ import * as Context from 'effect/Context';
 import * as effect_Cause from 'effect/Cause';
 import * as effect_Types from 'effect/Types';
 import { SignatureError as SignatureError$1, InvalidScalarError } from '@tevm/voltaire/Bls12381';
+import { K as KZGService, a as KZGError } from './KZGService-B7PJerOb.js';
 import { InvalidSecretKeyError, Ed25519Error, InvalidSignatureError as InvalidSignatureError$1, InvalidPublicKeyError as InvalidPublicKeyError$2 } from '@tevm/voltaire/Ed25519';
 import { HexType } from '@tevm/voltaire/Hex';
 import { HMACType } from '@tevm/voltaire/HMAC';
@@ -3004,144 +3005,6 @@ declare const P256Service_base: Context.TagClass<P256Service, "P256Service", P25
 declare class P256Service extends P256Service_base {
 }
 
-declare const KZGError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "KZGError";
-} & Readonly<A>;
-/**
- * Error thrown when a KZG operation fails.
- *
- * @description
- * Contains the operation that failed, error code, message, and optional cause.
- *
- * Common failure reasons:
- * - Trusted setup not loaded (SETUP_NOT_LOADED)
- * - Invalid blob size or format (INVALID_BLOB)
- * - Invalid commitment format (INVALID_COMMITMENT)
- * - Invalid proof format (INVALID_PROOF)
- * - Verification failure
- *
- * @since 0.0.1
- */
-declare class KZGError extends KZGError_base<{
-    /** Error code for programmatic handling */
-    readonly code: "SETUP_NOT_LOADED" | "INVALID_BLOB" | "INVALID_COMMITMENT" | "INVALID_PROOF" | "OPERATION_FAILED";
-    /** The KZG operation that failed */
-    readonly operation: "blobToKzgCommitment" | "computeBlobKzgProof" | "verifyBlobKzgProof" | "loadTrustedSetup" | "isInitialized";
-    /** Human-readable error message */
-    readonly message: string;
-    /** Underlying error that caused this failure */
-    readonly cause?: unknown;
-}> {
-}
-/**
- * Shape interface for KZG commitment service operations.
- *
- * @description
- * Defines the contract for KZG implementations. Operations require the trusted
- * setup to be loaded first via loadTrustedSetup().
- *
- * @since 0.0.1
- */
-interface KZGServiceShape {
-    /**
-     * Computes a KZG commitment for a blob.
-     * @param blob - The 128KB blob data
-     * @returns Effect containing the 48-byte commitment, or KZGError if operation fails
-     */
-    readonly blobToKzgCommitment: (blob: KzgBlobType) => Effect.Effect<KzgCommitmentType, KZGError>;
-    /**
-     * Computes a KZG proof for a blob and commitment.
-     * @param blob - The 128KB blob data
-     * @param commitment - The 48-byte commitment
-     * @returns Effect containing the 48-byte proof, or KZGError if operation fails
-     */
-    readonly computeBlobKzgProof: (blob: KzgBlobType, commitment: KzgCommitmentType) => Effect.Effect<KzgProofType, KZGError>;
-    /**
-     * Verifies a KZG proof against a blob and commitment.
-     * @param blob - The 128KB blob data
-     * @param commitment - The 48-byte commitment
-     * @param proof - The 48-byte proof
-     * @returns Effect containing true if proof is valid, or KZGError if operation fails
-     */
-    readonly verifyBlobKzgProof: (blob: KzgBlobType, commitment: KzgCommitmentType, proof: KzgProofType) => Effect.Effect<boolean, KZGError>;
-    /**
-     * Loads the trusted setup for KZG operations.
-     * @returns Effect that completes when setup is loaded, or KZGError if loading fails
-     */
-    readonly loadTrustedSetup: () => Effect.Effect<void, KZGError>;
-    /**
-     * Checks if the trusted setup has been initialized.
-     * @returns Effect containing true if initialized, or KZGError if check fails
-     */
-    readonly isInitialized: () => Effect.Effect<boolean, KZGError>;
-}
-declare const KZGService_base: Context.TagClass<KZGService, "KZGService", KZGServiceShape>;
-/**
- * KZG polynomial commitment service for Effect-based applications.
- * Implements EIP-4844 blob commitments for Ethereum proto-danksharding.
- *
- * @example
- * ```typescript
- * import { KZGService, KZGLive } from 'voltaire-effect/crypto'
- * import * as Effect from 'effect/Effect'
- *
- * const program = Effect.gen(function* () {
- *   const kzg = yield* KZGService
- *   yield* kzg.loadTrustedSetup()
- *   const commitment = yield* kzg.blobToKzgCommitment(blob)
- *   const proof = yield* kzg.computeBlobKzgProof(blob, commitment)
- *   return yield* kzg.verifyBlobKzgProof(blob, commitment, proof)
- * }).pipe(Effect.provide(KZGLive))
- * ```
- * @since 0.0.1
- */
-declare class KZGService extends KZGService_base {
-}
-/**
- * Production layer for KZGService using native KZG implementation.
- *
- * @description
- * Provides real KZG operations using the c-kzg-4844 library with Ethereum's
- * trusted setup. The trusted setup must be loaded before other operations.
- *
- * @example
- * ```typescript
- * import { KZGService, KZGLive } from 'voltaire-effect/crypto/KZG'
- * import * as Effect from 'effect/Effect'
- *
- * const program = Effect.gen(function* () {
- *   const kzg = yield* KZGService
- *   yield* kzg.loadTrustedSetup()
- *   const commitment = yield* kzg.blobToKzgCommitment(blob)
- *   return commitment
- * }).pipe(Effect.provide(KZGLive))
- * ```
- *
- * @since 0.0.1
- * @see {@link KZGTest} for unit testing
- */
-declare const KZGLive: Layer.Layer<KZGService, never, never>;
-/**
- * Test layer for KZGService returning deterministic mock values.
- *
- * @description
- * Provides mock implementations for unit testing. Returns zero-filled
- * arrays for commitments/proofs and always verifies as true.
- * Use when testing application logic without cryptographic overhead.
- *
- * @example
- * ```typescript
- * import { KZGService, KZGTest, blobToKzgCommitment } from 'voltaire-effect/crypto/KZG'
- * import * as Effect from 'effect/Effect'
- *
- * const testProgram = blobToKzgCommitment(blob).pipe(Effect.provide(KZGTest))
- * // Returns Uint8Array(48) filled with zeros
- * ```
- *
- * @since 0.0.1
- */
-declare const KZGTest: Layer.Layer<KZGService, never, never>;
-
 /**
  * @fileoverview KeystoreService Effect service definition for keystore encryption.
  * @module Keystore/KeystoreService
@@ -5349,4 +5212,4 @@ declare const X25519Live: Layer.Layer<X25519Service, never, never>;
  */
 declare const X25519Test: Layer.Layer<X25519Service, never, never>;
 
-export { g2Generator as $, AddressDerivationError as A, Bip39Service as B, ChaCha20Poly1305Service as C, validateMnemonic as D, EIP712Service as E, Blake2Live as F, Blake2Test as G, HMACService as H, hash$2 as I, aggregate as J, KeystoreService as K, Bls12381Live as L, type Bls12381ServiceShape as M, sign$2 as N, verify$2 as O, P256Service as P, Bn254Error as Q, Ripemd160Service as R, SHA256Service as S, Bn254Live as T, type Bn254ServiceShape as U, VerifyError as V, Bn254Test as W, g1Add as X, g1Generator as Y, g1Mul as Z, g2Add as _, Blake2Service as a, KZGTest as a$, g2Mul as a0, pairingCheck as a1, ChaCha20Poly1305Live as a2, type ChaCha20Poly1305ServiceShape as a3, ChaCha20Poly1305Test as a4, decrypt$1 as a5, encrypt$1 as a6, generateKey as a7, generateNonce as a8, Ed25519Live as a9, type HDWalletError as aA, type HDWalletServiceShape as aB, HDWalletTest as aC, InvalidKeyError as aD, InvalidPathError as aE, InvalidSeedError as aF, mnemonicToSeed as aG, withPrivateKey as aH, withSeed as aI, HMACLive as aJ, type HMACServiceShape as aK, HMACTest as aL, hmacSha256 as aM, hmacSha512 as aN, hash$3 as aO, type DecryptError as aP, decrypt as aQ, encrypt as aR, KeystoreLive as aS, type KeystoreServiceShape as aT, KeystoreTest as aU, withDecryptedKey as aV, blobToKzgCommitment as aW, computeBlobKzgProof as aX, KZGError as aY, KZGLive as aZ, type KZGServiceShape as a_, type Ed25519ServiceShape as aa, Ed25519Test as ab, getPublicKey$2 as ac, sign$1 as ad, verify$1 as ae, EIP712Live as af, type EIP712ServiceShape as ag, EIP712Test as ah, hashDomain as ai, hashStruct as aj, hashTypedData as ak, recoverAddress$1 as al, signTypedData as am, verifyTypedData as an, unwrapSignature as ao, verifySignature as ap, wrapSignature as aq, derive as ar, fromMnemonic as as, fromSeed as at, generateMnemonic as au, getPrivateKey as av, getPublicKey$1 as aw, HardenedDerivationError as ax, type HDNode as ay, type HDPath as az, Bls12381Service as b, verifyBlobKzgProof as b0, calculateGas as b1, ModExpLive as b2, ModExpService as b3, type ModExpServiceShape as b4, ModExpTest as b5, modexp as b6, modexpBytes as b7, P256Live as b8, type P256ServiceShape as b9, InvalidNonceError as bA, mapToHDWalletError as bB, sign as ba, verify as bb, hash$1 as bc, Ripemd160Live as bd, Ripemd160Test as be, hash as bf, SHA256Live as bg, SHA256Test as bh, recoverAddress as bi, type SignatureError as bj, computeSecret as bk, generateKeyPair as bl, getPublicKey as bm, X25519Live as bn, X25519Service as bo, type X25519ServiceShape as bp, X25519Test as bq, recover as br, Secp256k1Live as bs, Secp256k1Test as bt, sign$3 as bu, verify$3 as bv, type MnemonicStrength as bw, WORD_COUNTS as bx, type ChaCha20Poly1305Error as by, InvalidKeyError$1 as bz, Bn254Service as c, Ed25519Service as d, KZGService as e, HDWalletService as f, CryptoLive as g, CryptoTest as h, index as i, type SignatureInput as j, RecoverError as k, AesGcmLive as l, AesGcmService as m, type AesGcmServiceShape as n, AesGcmTest as o, decrypt$2 as p, encrypt$2 as q, generateKey$1 as r, generateNonce$1 as s, Bip39Live as t, type Bip39ServiceShape as u, Bip39Test as v, generateMnemonic$1 as w, getWordCount as x, mnemonicToSeed$1 as y, mnemonicToSeedSync as z };
+export { g2Mul as $, AddressDerivationError as A, Bip39Service as B, ChaCha20Poly1305Service as C, Blake2Live as D, EIP712Service as E, Blake2Test as F, hash$2 as G, HMACService as H, aggregate as I, Bls12381Live as J, KeystoreService as K, type Bls12381ServiceShape as L, sign$2 as M, verify$2 as N, Bn254Error as O, P256Service as P, Bn254Live as Q, Ripemd160Service as R, SHA256Service as S, type Bn254ServiceShape as T, Bn254Test as U, VerifyError as V, g1Add as W, g1Generator as X, g1Mul as Y, g2Add as Z, g2Generator as _, Blake2Service as a, type ModExpServiceShape as a$, pairingCheck as a0, ChaCha20Poly1305Live as a1, type ChaCha20Poly1305ServiceShape as a2, ChaCha20Poly1305Test as a3, decrypt$1 as a4, encrypt$1 as a5, generateKey as a6, generateNonce as a7, Ed25519Live as a8, type Ed25519ServiceShape as a9, type HDWalletServiceShape as aA, HDWalletTest as aB, InvalidKeyError as aC, InvalidPathError as aD, InvalidSeedError as aE, mnemonicToSeed as aF, withPrivateKey as aG, withSeed as aH, HMACLive as aI, type HMACServiceShape as aJ, HMACTest as aK, hmacSha256 as aL, hmacSha512 as aM, hash$3 as aN, type DecryptError as aO, decrypt as aP, encrypt as aQ, KeystoreLive as aR, type KeystoreServiceShape as aS, KeystoreTest as aT, withDecryptedKey as aU, blobToKzgCommitment as aV, computeBlobKzgProof as aW, verifyBlobKzgProof as aX, calculateGas as aY, ModExpLive as aZ, ModExpService as a_, Ed25519Test as aa, getPublicKey$2 as ab, sign$1 as ac, verify$1 as ad, EIP712Live as ae, type EIP712ServiceShape as af, EIP712Test as ag, hashDomain as ah, hashStruct as ai, hashTypedData as aj, recoverAddress$1 as ak, signTypedData as al, verifyTypedData as am, unwrapSignature as an, verifySignature as ao, wrapSignature as ap, derive as aq, fromMnemonic as ar, fromSeed as as, generateMnemonic as at, getPrivateKey as au, getPublicKey$1 as av, HardenedDerivationError as aw, type HDNode as ax, type HDPath as ay, type HDWalletError as az, Bls12381Service as b, ModExpTest as b0, modexp as b1, modexpBytes as b2, P256Live as b3, type P256ServiceShape as b4, sign as b5, verify as b6, hash$1 as b7, Ripemd160Live as b8, Ripemd160Test as b9, hash as ba, SHA256Live as bb, SHA256Test as bc, recoverAddress as bd, type SignatureError as be, computeSecret as bf, generateKeyPair as bg, getPublicKey as bh, X25519Live as bi, X25519Service as bj, type X25519ServiceShape as bk, X25519Test as bl, recover as bm, Secp256k1Live as bn, Secp256k1Test as bo, sign$3 as bp, verify$3 as bq, type MnemonicStrength as br, WORD_COUNTS as bs, type ChaCha20Poly1305Error as bt, InvalidKeyError$1 as bu, InvalidNonceError as bv, mapToHDWalletError as bw, Bn254Service as c, Ed25519Service as d, HDWalletService as e, CryptoLive as f, CryptoTest as g, type SignatureInput as h, index as i, RecoverError as j, AesGcmLive as k, AesGcmService as l, type AesGcmServiceShape as m, AesGcmTest as n, decrypt$2 as o, encrypt$2 as p, generateKey$1 as q, generateNonce$1 as r, Bip39Live as s, type Bip39ServiceShape as t, Bip39Test as u, generateMnemonic$1 as v, getWordCount as w, mnemonicToSeed$1 as x, mnemonicToSeedSync as y, validateMnemonic as z };

package/dist/crypto/index.d.ts

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