voltaire-effect 0.2.23 → 0.2.25

package/src/primitives/Base64/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module Base64
- * @description Effect-based schemas for standard and URL-safe base64 encoding.
+ * @description Effect-based schemas and functions for standard and URL-safe base64 encoding.
  *
  * ## Type Declarations
  *
@@ -12,17 +12,97 @@
  * }
  * ```
  *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `Base64.Schema` | string \| Uint8Array | BrandedBase64 |
+ * | `Base64.UrlSchema` | string \| Uint8Array | BrandedBase64Url |
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * Base64.from(value)        // Effect<BrandedBase64, Error>
+ * Base64.fromUrlSafe(value) // Effect<BrandedBase64Url, Error>
+ * ```
+ *
+ * ## Encoding (Pure)
+ *
+ * ```typescript
+ * Base64.encode(bytes)           // BrandedBase64
+ * Base64.encodeString(str)       // BrandedBase64
+ * Base64.encodeUrlSafe(bytes)    // BrandedBase64Url
+ * Base64.encodeStringUrlSafe(str) // BrandedBase64Url
+ * ```
+ *
+ * ## Decoding (Effect-wrapped)
+ *
+ * ```typescript
+ * Base64.decode(encoded)           // Effect<Uint8Array, Error>
+ * Base64.decodeToString(encoded)   // Effect<string, Error>
+ * Base64.decodeUrlSafe(encoded)    // Effect<Uint8Array, Error>
+ * Base64.decodeUrlSafeToString(encoded) // Effect<string, Error>
+ * ```
+ *
+ * ## Conversion (Pure)
+ *
+ * ```typescript
+ * Base64.toBytes(b64)        // Uint8Array
+ * Base64.toBytesUrlSafe(b64) // Uint8Array
+ * Base64.toString(b64)       // string
+ * Base64.toStringUrlSafe(b64) // string
+ * Base64.toBase64(bytes)     // BrandedBase64
+ * Base64.toBase64Url(bytes)  // BrandedBase64Url
+ * ```
+ *
+ * ## Validation (Pure)
+ *
+ * ```typescript
+ * Base64.isValid(str)        // boolean
+ * Base64.isValidUrlSafe(str) // boolean
+ * ```
+ *
+ * ## Size Calculation (Pure)
+ *
+ * ```typescript
+ * Base64.calcEncodedSize(byteCount) // number
+ * Base64.calcDecodedSize(encoded)   // number
+ * ```
+ *
  * @example
  * ```typescript
  * import * as Base64 from 'voltaire-effect/primitives/Base64'
  * import * as Schema from 'effect/Schema'
+ * import { Effect } from 'effect'
  *
  * const encoded = Schema.decodeSync(Base64.Schema)('SGVsbG8gV29ybGQ=')
+ * const decoded = await Effect.runPromise(Base64.decode('SGVsbG8='))
  * ```
  *
  * @since 0.0.1
  * @module
  */
 
+// Types
 export type { BrandedBase64, BrandedBase64Url } from "@tevm/voltaire/Base64";
+
+// Schemas
 export { Schema, UrlSchema } from "./Base64Schema.js";
+
+// Constructors (Effect-wrapped)
+export { from, fromUrlSafe } from "./from.js";
+
+// Encoding (Pure)
+export { encode, encodeString, encodeUrlSafe, encodeStringUrlSafe } from "./encode.js";
+
+// Decoding (Effect-wrapped)
+export { decode, decodeToString, decodeUrlSafe, decodeUrlSafeToString } from "./decode.js";
+
+// Conversion (Pure)
+export { toBytes, toBytesUrlSafe, toString, toStringUrlSafe, toBase64, toBase64Url } from "./convert.js";
+
+// Validation (Pure)
+export { isValid, isValidUrlSafe } from "./validation.js";
+
+// Size Calculation (Pure)
+export { calcEncodedSize, calcDecodedSize } from "./size.js";

package/src/primitives/Base64/size.ts

@@ -0,0 +1,16 @@
+/**
+ * @module size
+ * @description Pure Base64 size calculation functions
+ * @since 0.1.0
+ */
+import { Base64 } from "@tevm/voltaire/Base64";
+
+/**
+ * Calculate encoded size for given byte count
+ */
+export const calcEncodedSize = (byteCount: number): number => Base64.calcEncodedSize(byteCount);
+
+/**
+ * Calculate decoded size for given Base64 string length
+ */
+export const calcDecodedSize = (encodedLength: number): number => Base64.calcDecodedSize(encodedLength);

package/src/primitives/Base64/validation.ts

@@ -0,0 +1,16 @@
+/**
+ * @module validation
+ * @description Pure Base64 validation functions
+ * @since 0.1.0
+ */
+import { Base64 } from "@tevm/voltaire/Base64";
+
+/**
+ * Check if string is valid standard Base64
+ */
+export const isValid = (value: string): boolean => Base64.isValid(value);
+
+/**
+ * Check if string is valid URL-safe Base64
+ */
+export const isValidUrlSafe = (value: string): boolean => Base64.isValidUrlSafe(value);

package/src/primitives/Blob/Blob.test.ts

@@ -0,0 +1,292 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Effect } from "effect";
+import {
+	SIZE,
+	FIELD_ELEMENTS_PER_BLOB,
+	BYTES_PER_FIELD_ELEMENT,
+	MAX_PER_TRANSACTION,
+	MAX_DATA_PER_BLOB,
+} from "./index.js";
+import { from } from "./from.js";
+import { fromData } from "./fromData.js";
+import { isValid } from "./isValid.js";
+import { isValidVersion } from "./isValidVersion.js";
+import { toData } from "./toData.js";
+import { calculateGas } from "./calculateGas.js";
+import { estimateBlobCount } from "./estimateBlobCount.js";
+import { splitData } from "./splitData.js";
+import { joinData } from "./joinData.js";
+import { toVersionedHash } from "./toVersionedHash.js";
+import { toCommitment } from "./toCommitment.js";
+import { toProof } from "./toProof.js";
+import { verify } from "./verify.js";
+import { verifyBatch } from "./verifyBatch.js";
+import { BlobSchema } from "./BlobSchema.js";
+import { KZGTest } from "../../crypto/KZG/KZGService.js";
+import * as S from "effect/Schema";
+
+describe("Blob", () => {
+	describe("constants", () => {
+		it("SIZE is 131072", () => {
+			expect(SIZE).toBe(131072);
+		});
+
+		it("FIELD_ELEMENTS_PER_BLOB is 4096", () => {
+			expect(FIELD_ELEMENTS_PER_BLOB).toBe(4096);
+		});
+
+		it("BYTES_PER_FIELD_ELEMENT is 32", () => {
+			expect(BYTES_PER_FIELD_ELEMENT).toBe(32);
+		});
+
+		it("MAX_PER_TRANSACTION is 6", () => {
+			expect(MAX_PER_TRANSACTION).toBe(6);
+		});
+
+		it("MAX_DATA_PER_BLOB is 126972", () => {
+			expect(MAX_DATA_PER_BLOB).toBe(126972);
+		});
+	});
+
+	describe("isValid", () => {
+		it("returns true for 128KB blob", () => {
+			const blob = new Uint8Array(SIZE);
+			expect(isValid(blob)).toBe(true);
+		});
+
+		it("returns false for wrong size", () => {
+			expect(isValid(new Uint8Array(100))).toBe(false);
+			expect(isValid(new Uint8Array(SIZE + 1))).toBe(false);
+		});
+	});
+
+	describe("from", () => {
+		it.effect("returns blob if already valid size", () =>
+			Effect.gen(function* () {
+				const input = new Uint8Array(SIZE);
+				const blob = yield* from(input);
+				expect(blob.length).toBe(SIZE);
+			}),
+		);
+
+		it.effect("encodes smaller data", () =>
+			Effect.gen(function* () {
+				const data = new TextEncoder().encode("Hello");
+				const blob = yield* from(data);
+				expect(blob.length).toBe(SIZE);
+			}),
+		);
+	});
+
+	describe("fromData", () => {
+		it.effect("encodes data with padding", () =>
+			Effect.gen(function* () {
+				const data = new TextEncoder().encode("Hello, blob!");
+				const blob = yield* fromData(data);
+				expect(blob.length).toBe(SIZE);
+			}),
+		);
+
+		it.effect("fails for data too large", () =>
+			Effect.gen(function* () {
+				const data = new Uint8Array(MAX_DATA_PER_BLOB + 1);
+				const result = yield* Effect.either(fromData(data));
+				expect(result._tag).toBe("Left");
+			}),
+		);
+	});
+
+	describe("toData", () => {
+		it.effect("round-trips data correctly", () =>
+			Effect.gen(function* () {
+				const original = new TextEncoder().encode("Hello, blob!");
+				const blob = yield* fromData(original);
+				const extracted = toData(blob);
+				expect(new TextDecoder().decode(extracted)).toBe("Hello, blob!");
+			}),
+		);
+	});
+
+	describe("isValidVersion", () => {
+		it("returns true for valid KZG version", () => {
+			const hash = new Uint8Array(32);
+			hash[0] = 0x01;
+			expect(isValidVersion(hash as any)).toBe(true);
+		});
+
+		it("returns false for wrong version", () => {
+			const hash = new Uint8Array(32);
+			hash[0] = 0x00;
+			expect(isValidVersion(hash as any)).toBe(false);
+		});
+
+		it("returns false for wrong length", () => {
+			const hash = new Uint8Array(31);
+			hash[0] = 0x01;
+			expect(isValidVersion(hash as any)).toBe(false);
+		});
+	});
+
+	describe("calculateGas", () => {
+		it.effect("calculates gas for valid count", () =>
+			Effect.gen(function* () {
+				const gas = yield* calculateGas(3);
+				expect(gas).toBe(3 * 131072);
+			}),
+		);
+
+		it.effect("returns 0 for 0 blobs", () =>
+			Effect.gen(function* () {
+				const gas = yield* calculateGas(0);
+				expect(gas).toBe(0);
+			}),
+		);
+
+		it.effect("fails for invalid count", () =>
+			Effect.gen(function* () {
+				const result = yield* Effect.either(calculateGas(7));
+				expect(result._tag).toBe("Left");
+			}),
+		);
+	});
+
+	describe("estimateBlobCount", () => {
+		it.effect("estimates correctly", () =>
+			Effect.gen(function* () {
+				const count = yield* estimateBlobCount(200000);
+				expect(count).toBe(2);
+			}),
+		);
+
+		it.effect("returns 0 for empty data", () =>
+			Effect.gen(function* () {
+				const count = yield* estimateBlobCount(0);
+				expect(count).toBe(0);
+			}),
+		);
+
+		it.effect("fails for negative size", () =>
+			Effect.gen(function* () {
+				const result = yield* Effect.either(estimateBlobCount(-1));
+				expect(result._tag).toBe("Left");
+			}),
+		);
+	});
+
+	describe("splitData/joinData", () => {
+		it.effect("round-trips large data", () =>
+			Effect.gen(function* () {
+				const original = new Uint8Array(200000);
+				for (let i = 0; i < original.length; i++) {
+					original[i] = i % 256;
+				}
+				const blobs = yield* splitData(original);
+				expect(blobs.length).toBe(2);
+				const rejoined = yield* joinData(blobs);
+				expect(rejoined).toEqual(original);
+			}),
+		);
+
+		it.effect("fails for data requiring too many blobs", () =>
+			Effect.gen(function* () {
+				const huge = new Uint8Array(MAX_DATA_PER_BLOB * 7);
+				const result = yield* Effect.either(splitData(huge));
+				expect(result._tag).toBe("Left");
+			}),
+		);
+	});
+
+	describe("toVersionedHash", () => {
+		it.effect("creates versioned hash from commitment", () =>
+			Effect.gen(function* () {
+				const commitment = new Uint8Array(48);
+				const hash = yield* toVersionedHash(commitment as any);
+				expect(hash.length).toBe(32);
+				expect(hash[0]).toBe(0x01);
+			}),
+		);
+
+		it.effect("fails for invalid commitment size", () =>
+			Effect.gen(function* () {
+				const commitment = new Uint8Array(32);
+				const result = yield* Effect.either(
+					toVersionedHash(commitment as any),
+				);
+				expect(result._tag).toBe("Left");
+			}),
+		);
+	});
+
+	describe("KZG operations with KZGTest", () => {
+		it.effect("toCommitment returns 48-byte commitment", () =>
+			Effect.gen(function* () {
+				const blob = yield* fromData(new Uint8Array(100));
+				const commitment = yield* toCommitment(blob);
+				expect(commitment.length).toBe(48);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+
+		it.effect("toProof returns 48-byte proof", () =>
+			Effect.gen(function* () {
+				const blob = yield* fromData(new Uint8Array(100));
+				const commitment = yield* toCommitment(blob);
+				const proof = yield* toProof(blob, commitment);
+				expect(proof.length).toBe(48);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+
+		it.effect("verify returns true with test layer", () =>
+			Effect.gen(function* () {
+				const blob = yield* fromData(new Uint8Array(100));
+				const commitment = yield* toCommitment(blob);
+				const proof = yield* toProof(blob, commitment);
+				const isValid = yield* verify(blob, commitment, proof);
+				expect(isValid).toBe(true);
+			}).pipe(Effect.provide(KZGTest)),
+		);
+	});
+
+	describe("verifyBatch", () => {
+		it.effect("fails with not implemented error", () =>
+			Effect.gen(function* () {
+				const blob = yield* fromData(new Uint8Array(100));
+				const commitment = new Uint8Array(48) as any;
+				const proof = new Uint8Array(48) as any;
+				const result = yield* Effect.either(
+					verifyBatch([blob], [commitment], [proof]),
+				);
+				expect(result._tag).toBe("Left");
+				if (result._tag === "Left") {
+					expect(result.left.name).toBe("BlobNotImplementedError");
+				}
+			}),
+		);
+
+		it.effect("validates array length mismatch", () =>
+			Effect.gen(function* () {
+				const blob = yield* fromData(new Uint8Array(100));
+				const commitment = new Uint8Array(48) as any;
+				const result = yield* Effect.either(
+					verifyBatch([blob], [commitment], []),
+				);
+				expect(result._tag).toBe("Left");
+				if (result._tag === "Left") {
+					expect(result.left.name).toBe("BlobArrayLengthMismatchError");
+				}
+			}),
+		);
+	});
+
+	describe("BlobSchema", () => {
+		it("decodes valid blob", () => {
+			const bytes = new Uint8Array(SIZE);
+			const blob = S.decodeSync(BlobSchema)(bytes);
+			expect(blob.length).toBe(SIZE);
+		});
+
+		it("fails for invalid size", () => {
+			const bytes = new Uint8Array(100);
+			expect(() => S.decodeSync(BlobSchema)(bytes)).toThrow();
+		});
+	});
+});

package/src/primitives/Blob/calculateGas.ts

@@ -0,0 +1,30 @@
+/**
+ * @module calculateGas
+ * @description Calculate blob gas for number of blobs
+ * @since 0.1.0
+ */
+import { BrandedBlob as BlobNamespace } from "@tevm/voltaire";
+import { Effect } from "effect";
+import type { InvalidBlobCountError } from "@tevm/voltaire/Blob";
+
+/**
+ * Calculate blob gas for number of blobs.
+ *
+ * @param blobCount - Number of blobs (0-6)
+ * @returns Effect yielding total blob gas or failing with InvalidBlobCountError
+ * @example
+ * ```typescript
+ * import * as Blob from 'voltaire-effect/primitives/Blob'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const gas = await Effect.runPromise(Blob.calculateGas(3)) // 393216
+ * ```
+ * @since 0.1.0
+ */
+export const calculateGas = (
+	blobCount: number,
+): Effect.Effect<number, InvalidBlobCountError> =>
+	Effect.try({
+		try: () => BlobNamespace.calculateGas(blobCount),
+		catch: (e) => e as InvalidBlobCountError,
+	});

package/src/primitives/Blob/estimateBlobCount.ts

@@ -0,0 +1,30 @@
+/**
+ * @module estimateBlobCount
+ * @description Estimate number of blobs needed for data
+ * @since 0.1.0
+ */
+import { BrandedBlob as BlobNamespace } from "@tevm/voltaire";
+import { Effect } from "effect";
+import type { InvalidBlobDataSizeError } from "@tevm/voltaire/Blob";
+
+/**
+ * Estimate number of blobs needed for data.
+ *
+ * @param dataSize - Size of data in bytes
+ * @returns Effect yielding blob count or failing with InvalidBlobDataSizeError
+ * @example
+ * ```typescript
+ * import * as Blob from 'voltaire-effect/primitives/Blob'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const count = await Effect.runPromise(Blob.estimateBlobCount(200000)) // 2
+ * ```
+ * @since 0.1.0
+ */
+export const estimateBlobCount = (
+	dataSize: number,
+): Effect.Effect<number, InvalidBlobDataSizeError> =>
+	Effect.try({
+		try: () => BlobNamespace.estimateBlobCount(dataSize),
+		catch: (e) => e as InvalidBlobDataSizeError,
+	});

package/src/primitives/Blob/from.ts

@@ -0,0 +1,38 @@
+/**
+ * @module from
+ * @description Create Blob from Uint8Array with Effect error handling
+ * @since 0.1.0
+ */
+import { BrandedBlob as BlobNamespace } from "@tevm/voltaire";
+import { Effect } from "effect";
+import type { InvalidBlobDataSizeError } from "@tevm/voltaire/Blob";
+
+type BrandedBlob = BlobNamespace.BrandedBlob;
+
+/**
+ * Create Blob from Uint8Array (either raw blob data or data to encode)
+ *
+ * If input is 131072 bytes, returns as-is. Otherwise encodes with padding.
+ *
+ * @param value - Uint8Array (either 131072 bytes blob or data to encode)
+ * @returns Effect yielding BrandedBlob or failing with InvalidBlobDataSizeError
+ * @example
+ * ```typescript
+ * import * as Blob from 'voltaire-effect/primitives/Blob'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Raw 128KB blob
+ * const blob1 = await Effect.runPromise(Blob.from(new Uint8Array(131072)))
+ *
+ * // Auto-encode smaller data
+ * const blob2 = await Effect.runPromise(Blob.from(new TextEncoder().encode("Hello")))
+ * ```
+ * @since 0.1.0
+ */
+export const from = (
+	value: Uint8Array,
+): Effect.Effect<BrandedBlob, InvalidBlobDataSizeError> =>
+	Effect.try({
+		try: () => BlobNamespace.from(value),
+		catch: (e) => e as InvalidBlobDataSizeError,
+	});

package/src/primitives/Blob/fromData.ts

@@ -0,0 +1,36 @@
+/**
+ * @module fromData
+ * @description Create Blob from arbitrary data with EIP-4844 field element encoding
+ * @since 0.1.0
+ */
+import { BrandedBlob as BlobNamespace } from "@tevm/voltaire";
+import { Effect } from "effect";
+import type { InvalidBlobDataSizeError } from "@tevm/voltaire/Blob";
+
+type BrandedBlob = BlobNamespace.BrandedBlob;
+
+/**
+ * Create Blob from arbitrary data (will be padded to 128KB)
+ *
+ * Uses EIP-4844 field element encoding where each 32-byte field element
+ * has byte[0] = 0x00 for BLS field constraint. First 4 bytes store length.
+ *
+ * @param data - Data to encode (max 126972 bytes)
+ * @returns Effect yielding BrandedBlob or failing with InvalidBlobDataSizeError
+ * @example
+ * ```typescript
+ * import * as Blob from 'voltaire-effect/primitives/Blob'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const data = new TextEncoder().encode("Hello, blob!")
+ * const blob = await Effect.runPromise(Blob.fromData(data))
+ * ```
+ * @since 0.1.0
+ */
+export const fromData = (
+	data: Uint8Array,
+): Effect.Effect<BrandedBlob, InvalidBlobDataSizeError> =>
+	Effect.try({
+		try: () => BlobNamespace.fromData(data),
+		catch: (e) => e as InvalidBlobDataSizeError,
+	});

package/src/primitives/Blob/index.ts

@@ -8,6 +8,51 @@
  * This module provides Effect-based schemas and functions for creating,
  * validating, and working with blob data.
  *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as Blob from 'voltaire-effect/primitives/Blob'
+ *
+ * function processBlob(blob: Blob.BrandedBlob) {
+ *   // ...
+ * }
+ * ```
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output | Description |
+ * |--------|-------|--------|-------------|
+ * | `Blob.Schema` | Uint8Array | BrandedBlob | Validates exactly 131072 bytes |
+ *
+ * ## Constructors (Effect-wrapped)
+ *
+ * ```typescript
+ * Blob.from(bytes)       // Effect<BrandedBlob, InvalidBlobDataSizeError>
+ * Blob.fromData(data)    // Effect<BrandedBlob, InvalidBlobDataSizeError>
+ * ```
+ *
+ * ## Pure Functions
+ *
+ * ```typescript
+ * Blob.isValid(data)        // boolean - check if exactly 128KB
+ * Blob.isValidVersion(hash) // boolean - check versioned hash version byte
+ * Blob.toData(blob)         // Uint8Array - extract original data
+ * ```
+ *
+ * ## Effectful Functions
+ *
+ * ```typescript
+ * Blob.calculateGas(count)       // Effect<number, InvalidBlobCountError>
+ * Blob.estimateBlobCount(size)   // Effect<number, InvalidBlobDataSizeError>
+ * Blob.splitData(data)           // Effect<BrandedBlob[], InvalidBlobDataSizeError>
+ * Blob.joinData(blobs)           // Effect<Uint8Array, BlobError>
+ * Blob.toCommitment(blob)        // Effect<Commitment, KZGError, KZGService>
+ * Blob.toProof(blob, commitment) // Effect<Proof, KZGError, KZGService>
+ * Blob.toVersionedHash(commitment) // Effect<VersionedHash, InvalidCommitmentSizeError>
+ * Blob.verify(blob, commitment, proof) // Effect<boolean, KZGError, KZGService>
+ * Blob.verifyBatch(blobs, commitments, proofs) // Effect<boolean, BlobError>
+ * ```
+ *
  * @example
  * ```typescript
  * import * as Blob from 'voltaire-effect/primitives/Blob'
@@ -30,25 +75,67 @@
  * @since 0.0.1
  */
 
-/**
- * Blob constants from EIP-4844
- * - SIZE: 131,072 bytes (128KB)
- * - FIELD_ELEMENTS_PER_BLOB: 4,096
- * - BYTES_PER_FIELD_ELEMENT: 32
- * - MAX_PER_TRANSACTION: 6
- */
+// Re-export types from voltaire
+export type {
+	BrandedBlob,
+	Commitment,
+	Proof,
+	VersionedHash,
+} from "@tevm/voltaire/Blob";
+
+// Re-export constants from voltaire
 export {
 	BYTES_PER_FIELD_ELEMENT,
 	FIELD_ELEMENTS_PER_BLOB,
 	MAX_PER_TRANSACTION,
 	SIZE,
+	COMMITMENT_VERSION_KZG,
+	GAS_PER_BLOB,
+	TARGET_GAS_PER_BLOCK,
+	MAX_DATA_PER_BLOB,
 } from "@tevm/voltaire/Blob";
-/** Schema for blob validation */
+
+// Re-export errors from voltaire
+export {
+	BlobArrayLengthMismatchError,
+	BlobNotImplementedError,
+	InvalidBlobCountError,
+	InvalidBlobDataSizeError,
+	InvalidBlobLengthPrefixError,
+	InvalidBlobSizeError,
+	InvalidCommitmentSizeError,
+	InvalidProofSizeError,
+} from "@tevm/voltaire/Blob";
+
+// Re-export factory functions from voltaire (for advanced use/DI)
+export {
+	Blob,
+	ToCommitment,
+	ToProof,
+	ToVersionedHash,
+	Verify,
+	VerifyBatch,
+} from "@tevm/voltaire/Blob";
+
+// Schema
 export { BlobSchema, BlobSchema as Schema } from "./BlobSchema.js";
-/** Create blob from exact 131,072 bytes */
-/** Create blob from arbitrary data with padding */
 
-/** Check if data is valid blob size */
+// Constructors (Effect-wrapped)
+export { from } from "./from.js";
+export { fromData } from "./fromData.js";
+
+// Pure functions
 export { isValid } from "./isValid.js";
-/** Extract original data from blob */
+export { isValidVersion } from "./isValidVersion.js";
 export { toData } from "./toData.js";
+
+// Effectful functions
+export { calculateGas } from "./calculateGas.js";
+export { estimateBlobCount } from "./estimateBlobCount.js";
+export { joinData } from "./joinData.js";
+export { splitData } from "./splitData.js";
+export { toCommitment } from "./toCommitment.js";
+export { toProof } from "./toProof.js";
+export { toVersionedHash } from "./toVersionedHash.js";
+export { verify } from "./verify.js";
+export { verifyBatch } from "./verifyBatch.js";