voltaire-effect 0.2.23

package/src/crypto/HMAC/operations.ts

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Standalone HMAC operations for Effect-based applications.
+ * @module HMAC/operations
+ * @since 0.0.1
+ */
+
+import type { HMACType } from "@tevm/voltaire/HMAC";
+import * as Effect from "effect/Effect";
+import { HMACService } from "./HMACService.js";
+
+/**
+ * Computes HMAC-SHA256 for message authentication.
+ *
+ * @description
+ * Produces a 32-byte keyed authentication code using SHA-256. HMAC-SHA256
+ * is widely used in authentication protocols including:
+ *
+ * - AWS Signature Version 4
+ * - JWT HS256 signatures
+ * - OAuth 1.0 signatures
+ * - Webhook verification
+ *
+ * @param key - The secret key (any length, recommended 32+ bytes)
+ * @param message - The message to authenticate
+ * @returns Effect containing the 32-byte HMAC, requiring HMACService
+ *
+ * @example
+ * ```typescript
+ * import { hmacSha256, HMACLive } from 'voltaire-effect/crypto/HMAC'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Compute HMAC-SHA256
+ * const key = new TextEncoder().encode('secret-key')
+ * const message = new TextEncoder().encode('Hello, HMAC!')
+ *
+ * const mac = await Effect.runPromise(
+ *   hmacSha256(key, message).pipe(Effect.provide(HMACLive))
+ * )
+ * console.log(mac.length) // 32
+ *
+ * // Verify a webhook signature
+ * const verifyWebhook = Effect.gen(function* () {
+ *   const expected = yield* hmacSha256(webhookSecret, payload)
+ *   return constantTimeEqual(expected, providedSignature)
+ * }).pipe(Effect.provide(HMACLive))
+ * ```
+ *
+ * @throws Never - This operation is infallible
+ * @see {@link hmacSha512} - For stronger security (64-byte output)
+ * @see {@link HMACService} - Full service interface
+ * @since 0.0.1
+ */
+export const hmacSha256 = (
+	key: Uint8Array,
+	message: Uint8Array,
+): Effect.Effect<HMACType, never, HMACService> =>
+	Effect.gen(function* () {
+		const hmac = yield* HMACService;
+		return yield* hmac.sha256(key, message);
+	});
+
+/**
+ * Computes HMAC-SHA512 for message authentication.
+ *
+ * @description
+ * Produces a 64-byte keyed authentication code using SHA-512. HMAC-SHA512
+ * provides stronger security than HMAC-SHA256 and is used in:
+ *
+ * - BIP-32 HD wallet key derivation
+ * - JWT HS512 signatures
+ * - High-security authentication systems
+ *
+ * @param key - The secret key (any length, recommended 64+ bytes)
+ * @param message - The message to authenticate
+ * @returns Effect containing the 64-byte HMAC, requiring HMACService
+ *
+ * @example
+ * ```typescript
+ * import { hmacSha512, HMACLive } from 'voltaire-effect/crypto/HMAC'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Compute HMAC-SHA512
+ * const key = new TextEncoder().encode('master-secret')
+ * const message = new TextEncoder().encode('Bitcoin seed')
+ *
+ * const mac = await Effect.runPromise(
+ *   hmacSha512(key, message).pipe(Effect.provide(HMACLive))
+ * )
+ * console.log(mac.length) // 64
+ *
+ * // BIP-32 style key derivation
+ * const deriveKey = Effect.gen(function* () {
+ *   const I = yield* hmacSha512(chainCode, data)
+ *   const IL = I.slice(0, 32)  // Private key
+ *   const IR = I.slice(32)     // Chain code
+ *   return { privateKey: IL, chainCode: IR }
+ * }).pipe(Effect.provide(HMACLive))
+ * ```
+ *
+ * @throws Never - This operation is infallible
+ * @see {@link hmacSha256} - For 32-byte output
+ * @see {@link HMACService} - Full service interface
+ * @since 0.0.1
+ */
+export const hmacSha512 = (
+	key: Uint8Array,
+	message: Uint8Array,
+): Effect.Effect<HMACType, never, HMACService> =>
+	Effect.gen(function* () {
+		const hmac = yield* HMACService;
+		return yield* hmac.sha512(key, message);
+	});

package/src/crypto/Hash/index.ts

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Hash utility exports for Effect.
+ *
+ * @description
+ * Re-exports message and typed data hashing utilities from the Signature module
+ * and EIP712 module for convenient access.
+ *
+ * - `hashMessage` - EIP-191 personal_sign message hashing
+ * - `hashTypedData` - EIP-712 typed structured data hashing
+ *
+ * @example Hash a personal_sign message
+ * ```typescript
+ * import { hashMessage, KeccakLive } from 'voltaire-effect/crypto/Hash'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = hashMessage('Hello, Ethereum!').pipe(Effect.provide(KeccakLive))
+ * const hash = await Effect.runPromise(program)
+ * ```
+ *
+ * @example Hash EIP-712 typed data
+ * ```typescript
+ * import { hashTypedData, EIP712Live } from 'voltaire-effect/crypto/Hash'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const typedData = {
+ *   domain: { name: 'MyDApp', version: '1', chainId: 1 },
+ *   types: { Person: [{ name: 'name', type: 'string' }] },
+ *   primaryType: 'Person',
+ *   message: { name: 'Alice' }
+ * }
+ *
+ * const program = hashTypedData(typedData).pipe(Effect.provide(EIP712Live))
+ * const hash = await Effect.runPromise(program)
+ * ```
+ *
+ * @module Hash
+ * @since 0.0.1
+ */
+
+// Re-export hashTypedData from EIP712 module
+export {
+	EIP712Live,
+	EIP712Service,
+	EIP712Test,
+	hashTypedData,
+} from "../EIP712/index.js";
+
+// Re-export service dependencies for convenience
+export { KeccakLive, KeccakService, KeccakTest } from "../Keccak256/index.js";
+// Re-export hashMessage from Signature module
+export { hashMessage } from "../Signature/hashMessage.js";

package/src/crypto/KZG/KZG.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "@effect/vitest";
+import type {
+	KzgBlobType,
+	KzgCommitmentType,
+	KzgProofType,
+} from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import {
+	blobToKzgCommitment,
+	computeBlobKzgProof,
+	KZGService,
+	KZGTest,
+	verifyBlobKzgProof,
+} from "./index.js";
+
+describe("KZGService", () => {
+	describe("KZGTest", () => {
+		it.effect("blobToKzgCommitment returns 48-byte commitment", () =>
+			Effect.gen(function* () {
+				const kzg = yield* KZGService;
+				const result = yield* kzg.blobToKzgCommitment(
+					new Uint8Array(131072) as KzgBlobType,
+				);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(48);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+
+		it.effect("computeBlobKzgProof returns 48-byte proof", () =>
+			Effect.gen(function* () {
+				const kzg = yield* KZGService;
+				const blob = new Uint8Array(131072) as KzgBlobType;
+				const commitment = new Uint8Array(48) as KzgCommitmentType;
+				const result = yield* kzg.computeBlobKzgProof(blob, commitment);
+				expect(result).toBeInstanceOf(Uint8Array);
+				expect(result.length).toBe(48);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+
+		it.effect("verifyBlobKzgProof returns boolean", () =>
+			Effect.gen(function* () {
+				const kzg = yield* KZGService;
+				const blob = new Uint8Array(131072) as KzgBlobType;
+				const commitment = new Uint8Array(48) as KzgCommitmentType;
+				const proof = new Uint8Array(48) as KzgProofType;
+				const result = yield* kzg.verifyBlobKzgProof(blob, commitment, proof);
+				expect(result).toBe(true);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+
+		it.effect("isInitialized returns true", () =>
+			Effect.gen(function* () {
+				const kzg = yield* KZGService;
+				const result = yield* kzg.isInitialized();
+				expect(result).toBe(true);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+	});
+});
+
+describe("blobToKzgCommitment", () => {
+	it.effect("commits blob with KZGService dependency", () =>
+		Effect.gen(function* () {
+			const blob = new Uint8Array(131072) as KzgBlobType;
+			const result = yield* blobToKzgCommitment(blob);
+			expect(result).toBeInstanceOf(Uint8Array);
+			expect(result.length).toBe(48);
+		}).pipe(Effect.provide(KZGTest)),
+	);
+});
+
+describe("computeBlobKzgProof", () => {
+	it.effect("computes proof with KZGService dependency", () =>
+		Effect.gen(function* () {
+			const blob = new Uint8Array(131072) as KzgBlobType;
+			const commitment = new Uint8Array(48) as KzgCommitmentType;
+			const result = yield* computeBlobKzgProof(blob, commitment);
+			expect(result).toBeInstanceOf(Uint8Array);
+			expect(result.length).toBe(48);
+		}).pipe(Effect.provide(KZGTest)),
+	);
+});
+
+describe("verifyBlobKzgProof", () => {
+	it.effect("verifies proof with KZGService dependency", () =>
+		Effect.gen(function* () {
+			const blob = new Uint8Array(131072) as KzgBlobType;
+			const commitment = new Uint8Array(48) as KzgCommitmentType;
+			const proof = new Uint8Array(48) as KzgProofType;
+			const result = yield* verifyBlobKzgProof(blob, commitment, proof);
+			expect(result).toBe(true);
+		}).pipe(Effect.provide(KZGTest)),
+	);
+});

package/src/crypto/KZG/KZGService.ts

@@ -0,0 +1,241 @@
+/**
+ * @fileoverview KZGService Effect service definition for KZG polynomial commitments.
+ * @module KZG/KZGService
+ * @since 0.0.1
+ */
+import type {
+	KzgBlobType,
+	KzgCommitmentType,
+	KzgProofType,
+} from "@tevm/voltaire";
+import { KZG } from "@tevm/voltaire";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+/**
+ * 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
+ */
+export class KZGError extends Data.TaggedError("KZGError")<{
+	/** 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
+ */
+export 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>;
+}
+
+/**
+ * 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
+ */
+export class KZGService extends Context.Tag("KZGService")<
+	KZGService,
+	KZGServiceShape
+>() {}
+
+/**
+ * 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
+ */
+export const KZGLive = Layer.succeed(KZGService, {
+	blobToKzgCommitment: (blob) =>
+		Effect.try({
+			try: () => KZG.blobToKzgCommitment(blob) as KzgCommitmentType,
+			catch: (e) =>
+				new KZGError({
+					code: "INVALID_BLOB",
+					operation: "blobToKzgCommitment",
+					message: `Failed to compute KZG commitment: ${e}`,
+					cause: e,
+				}),
+		}),
+	computeBlobKzgProof: (blob, commitment) =>
+		Effect.try({
+			try: () => KZG.computeBlobKzgProof(blob, commitment) as KzgProofType,
+			catch: (e) =>
+				new KZGError({
+					code: "OPERATION_FAILED",
+					operation: "computeBlobKzgProof",
+					message: `Failed to compute KZG proof: ${e}`,
+					cause: e,
+				}),
+		}),
+	verifyBlobKzgProof: (blob, commitment, proof) =>
+		Effect.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: () =>
+		Effect.try({
+			try: () => KZG.loadTrustedSetup(),
+			catch: (e) =>
+				new KZGError({
+					code: "SETUP_NOT_LOADED",
+					operation: "loadTrustedSetup",
+					message: `Failed to load trusted setup: ${e}`,
+					cause: e,
+				}),
+		}),
+	isInitialized: () =>
+		Effect.try({
+			try: () => KZG.isInitialized(),
+			catch: (e) =>
+				new KZGError({
+					code: "OPERATION_FAILED",
+					operation: "isInitialized",
+					message: `Failed to check initialization status: ${e}`,
+					cause: e,
+				}),
+		}),
+});
+
+/**
+ * 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
+ */
+export const KZGTest = Layer.succeed(KZGService, {
+	blobToKzgCommitment: (_blob) =>
+		Effect.sync(() => new Uint8Array(48) as KzgCommitmentType),
+	computeBlobKzgProof: (_blob, _commitment) =>
+		Effect.sync(() => new Uint8Array(48) as KzgProofType),
+	verifyBlobKzgProof: (_blob, _commitment, _proof) => Effect.succeed(true),
+	loadTrustedSetup: () => Effect.succeed(undefined),
+	isInitialized: () => Effect.succeed(true),
+});

package/src/crypto/KZG/commit.ts

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview KZG commitment operations for Effect.
+ * @module KZG/commit
+ * @since 0.0.1
+ */
+import type { KzgBlobType, KzgCommitmentType } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import { type KZGError, KZGService } from "./KZGService.js";
+
+/**
+ * Computes a KZG commitment for a blob.
+ *
+ * @description
+ * Creates a 48-byte G1 point commitment from blob data. The commitment
+ * uniquely identifies the blob and can be verified with a proof.
+ * Used in EIP-4844 for blob transaction data availability.
+ *
+ * @param blob - The 128KB blob data (4096 field elements × 32 bytes)
+ * @returns Effect containing the 48-byte commitment or KZGError, requiring KZGService
+ *
+ * @example
+ * ```typescript
+ * import { blobToKzgCommitment, KZGLive } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = blobToKzgCommitment(blob).pipe(Effect.provide(KZGLive))
+ * // Returns: KzgCommitmentType (48 bytes)
+ * ```
+ *
+ * @see {@link computeBlobKzgProof} to generate proof
+ * @see {@link https://eips.ethereum.org/EIPS/eip-4844 | EIP-4844}
+ * @since 0.0.1
+ */
+export const blobToKzgCommitment = (
+	blob: KzgBlobType,
+): Effect.Effect<KzgCommitmentType, KZGError, KZGService> =>
+	Effect.gen(function* () {
+		const kzg = yield* KZGService;
+		return yield* kzg.blobToKzgCommitment(blob);
+	});
+
+/**
+ * Computes a KZG proof for a blob and commitment.
+ *
+ * @description
+ * Generates a 48-byte proof that the commitment correctly represents the blob.
+ * The proof can be verified by any party to confirm data availability without
+ * downloading the full blob.
+ *
+ * @param blob - The 128KB blob data (4096 field elements × 32 bytes)
+ * @param commitment - The 48-byte commitment from blobToKzgCommitment
+ * @returns Effect containing the 48-byte proof or KZGError, requiring KZGService
+ *
+ * @example
+ * ```typescript
+ * import { computeBlobKzgProof, blobToKzgCommitment, KZGLive } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const commitment = yield* blobToKzgCommitment(blob)
+ *   return yield* computeBlobKzgProof(blob, commitment)
+ * }).pipe(Effect.provide(KZGLive))
+ * ```
+ *
+ * @see {@link blobToKzgCommitment} to generate commitment
+ * @see {@link verifyBlobKzgProof} to verify the proof
+ * @since 0.0.1
+ */
+export const computeBlobKzgProof = (
+	blob: KzgBlobType,
+	commitment: KzgCommitmentType,
+): Effect.Effect<import("@tevm/voltaire").KzgProofType, KZGError, KZGService> =>
+	Effect.gen(function* () {
+		const kzg = yield* KZGService;
+		return yield* kzg.computeBlobKzgProof(blob, commitment);
+	});

package/src/crypto/KZG/index.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview KZG polynomial commitment module for Effect.
+ * Implements EIP-4844 blob commitments for Ethereum proto-danksharding.
+ *
+ * @module KZG
+ * @since 0.0.1
+ *
+ * @description
+ * KZG (Kate-Zaverucha-Goldberg) polynomial commitments enable efficient verification
+ * of blob data in Ethereum's EIP-4844 (proto-danksharding). This module wraps the
+ * trusted setup and commitment/proof operations in Effect for safe, composable usage.
+ *
+ * Key concepts:
+ * - Blob: 128KB of data (4096 field elements)
+ * - Commitment: 48-byte G1 point representing the blob
+ * - Proof: 48-byte proof that commitment matches blob
+ *
+ * @example
+ * ```typescript
+ * import { KZGService, KZGLive, blobToKzgCommitment, computeBlobKzgProof, verifyBlobKzgProof } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const commitment = yield* blobToKzgCommitment(blob)
+ *   const proof = yield* computeBlobKzgProof(blob, commitment)
+ *   const isValid = yield* verifyBlobKzgProof(blob, commitment, proof)
+ *   return isValid
+ * }).pipe(Effect.provide(KZGLive))
+ * ```
+ *
+ * @see {@link https://eips.ethereum.org/EIPS/eip-4844 | EIP-4844}
+ */
+
+export { blobToKzgCommitment, computeBlobKzgProof } from "./commit.js";
+export {
+	KZGError,
+	KZGLive,
+	KZGService,
+	type KZGServiceShape,
+	KZGTest,
+} from "./KZGService.js";
+export { verifyBlobKzgProof } from "./verify.js";

package/src/crypto/KZG/verify.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview KZG proof verification for Effect.
+ * @module KZG/verify
+ * @since 0.0.1
+ */
+import type {
+	KzgBlobType,
+	KzgCommitmentType,
+	KzgProofType,
+} from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import { type KZGError, KZGService } from "./KZGService.js";
+
+/**
+ * Verifies a KZG proof against a blob and commitment.
+ *
+ * @description
+ * Cryptographically verifies that the proof demonstrates the commitment
+ * correctly represents the blob. Used by validators and light clients
+ * to confirm blob data availability in EIP-4844 transactions.
+ *
+ * @param blob - The 128KB blob data (4096 field elements × 32 bytes)
+ * @param commitment - The 48-byte commitment
+ * @param proof - The 48-byte proof from computeBlobKzgProof
+ * @returns Effect containing true if proof is valid or KZGError, requiring KZGService
+ *
+ * @example
+ * ```typescript
+ * import { verifyBlobKzgProof, blobToKzgCommitment, computeBlobKzgProof, KZGLive } from 'voltaire-effect/crypto/KZG'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const commitment = yield* blobToKzgCommitment(blob)
+ *   const proof = yield* computeBlobKzgProof(blob, commitment)
+ *   return yield* verifyBlobKzgProof(blob, commitment, proof)
+ * }).pipe(Effect.provide(KZGLive))
+ * // Returns: true
+ * ```
+ *
+ * @see {@link blobToKzgCommitment} to generate commitment
+ * @see {@link computeBlobKzgProof} to generate proof
+ * @since 0.0.1
+ */
+export const verifyBlobKzgProof = (
+	blob: KzgBlobType,
+	commitment: KzgCommitmentType,
+	proof: KzgProofType,
+): Effect.Effect<boolean, KZGError, KZGService> =>
+	Effect.gen(function* () {
+		const kzg = yield* KZGService;
+		return yield* kzg.verifyBlobKzgProof(blob, commitment, proof);
+	});