voltaire-effect 0.2.23

package/src/primitives/MaxFeePerGas/BigInt.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Schema for MaxFeePerGas from bigint (wei).
+ * @module MaxFeePerGas/BigInt
+ * @since 0.1.0
+ */
+
+import { Uint } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+export type MaxFeePerGasType = bigint & { readonly __tag: "MaxFeePerGas" };
+
+const MaxFeePerGasTypeSchema = S.declare<MaxFeePerGasType>(
+	(u): u is MaxFeePerGasType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "MaxFeePerGas" },
+);
+
+/**
+ * Schema for MaxFeePerGas from bigint (wei).
+ *
+ * @example
+ * ```typescript
+ * import * as MaxFeePerGas from 'voltaire-effect/primitives/MaxFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const maxFee = S.decodeSync(MaxFeePerGas.BigInt)(50000000000n) // 50 gwei in wei
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const BigInt: S.Schema<MaxFeePerGasType, bigint> = S.transformOrFail(
+	S.BigIntFromSelf,
+	MaxFeePerGasTypeSchema,
+	{
+		strict: true,
+		decode: (value, _options, ast) => {
+			try {
+				return ParseResult.succeed(
+					Uint.from(value) as unknown as MaxFeePerGasType,
+				);
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, value, (e as Error).message),
+				);
+			}
+		},
+		encode: (maxFee) => ParseResult.succeed(maxFee as bigint),
+	},
+).annotations({ identifier: "MaxFeePerGas.BigInt" });

package/src/primitives/MaxFeePerGas/Gwei.ts

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Schema for MaxFeePerGas from gwei.
+ * @module MaxFeePerGas/Gwei
+ * @since 0.1.0
+ */
+
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+import type { MaxFeePerGasType } from "./BigInt.js";
+
+const GWEI = 1_000_000_000n;
+
+const MaxFeePerGasTypeSchema = S.declare<MaxFeePerGasType>(
+	(u): u is MaxFeePerGasType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "MaxFeePerGas" },
+);
+
+/**
+ * Schema for MaxFeePerGas from gwei.
+ * Decodes gwei to wei, encodes wei to gwei.
+ *
+ * @example
+ * ```typescript
+ * import * as MaxFeePerGas from 'voltaire-effect/primitives/MaxFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const maxFee = S.decodeSync(MaxFeePerGas.Gwei)(50) // 50 gwei -> wei
+ * const gwei = S.encodeSync(MaxFeePerGas.Gwei)(maxFee) // 50n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const Gwei: S.Schema<MaxFeePerGasType, number | bigint> =
+	S.transformOrFail(
+		S.Union(S.Number, S.BigIntFromSelf),
+		MaxFeePerGasTypeSchema,
+		{
+			strict: true,
+			decode: (value, _options, ast) => {
+				try {
+					const gwei =
+						typeof value === "number" ? globalThis.BigInt(value) : value;
+					if (gwei < 0n) {
+						return ParseResult.fail(
+							new ParseResult.Type(
+								ast,
+								value,
+								"MaxFeePerGas cannot be negative",
+							),
+						);
+					}
+					return ParseResult.succeed(
+						(gwei * GWEI) as unknown as MaxFeePerGasType,
+					);
+				} catch (e) {
+					return ParseResult.fail(
+						new ParseResult.Type(ast, value, (e as Error).message),
+					);
+				}
+			},
+			encode: (maxFee) => ParseResult.succeed(maxFee / GWEI),
+		},
+	).annotations({ identifier: "MaxFeePerGas.Gwei" });

package/src/primitives/MaxFeePerGas/index.ts

@@ -0,0 +1,47 @@
+/**
+ * @module MaxFeePerGas
+ * @description Effect Schemas for EIP-1559 maximum fee per gas.
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as MaxFeePerGas from 'voltaire-effect/primitives/MaxFeePerGas'
+ *
+ * function estimateMaxFee(baseFee: MaxFeePerGas.MaxFeePerGasType) {
+ *   // ...
+ * }
+ * ```
+ *
+ * MaxFeePerGas is the maximum total fee per gas a user is willing to pay.
+ * The actual fee paid is: min(baseFee + priorityFee, maxFeePerGas)
+ * Setting maxFeePerGas protects users from sudden base fee spikes.
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `MaxFeePerGas.BigInt` | bigint (wei) | MaxFeePerGasType |
+ * | `MaxFeePerGas.Gwei` | number/bigint (gwei) | MaxFeePerGasType |
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import * as MaxFeePerGas from 'voltaire-effect/primitives/MaxFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * // From wei
+ * const maxFee = S.decodeSync(MaxFeePerGas.BigInt)(50000000000n)
+ *
+ * // From gwei (more ergonomic)
+ * const maxFee2 = S.decodeSync(MaxFeePerGas.Gwei)(50)
+ *
+ * // Convert to gwei for display
+ * const gwei = MaxFeePerGas.toGwei(maxFee) // 50n
+ * ```
+ *
+ * @since 0.1.0
+ */
+
+export { BigInt, type MaxFeePerGasType } from "./BigInt.js";
+export { Gwei } from "./Gwei.js";
+export { toGwei } from "./toGwei.js";

package/src/primitives/MaxFeePerGas/toGwei.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Pure function to convert MaxFeePerGas to gwei.
+ * @module MaxFeePerGas/toGwei
+ * @since 0.1.0
+ */
+
+import type { MaxFeePerGasType } from "./BigInt.js";
+
+const GWEI = 1_000_000_000n;
+
+/**
+ * Converts a max fee from wei to gwei.
+ *
+ * @param value - Max fee in wei
+ * @returns Max fee in gwei
+ *
+ * @example
+ * ```typescript
+ * import * as MaxFeePerGas from 'voltaire-effect/primitives/MaxFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const maxFee = S.decodeSync(MaxFeePerGas.Gwei)(50)
+ * const gwei = MaxFeePerGas.toGwei(maxFee) // 50n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toGwei = (value: MaxFeePerGasType): bigint => value / GWEI;

package/src/primitives/MaxPriorityFeePerGas/BigInt.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Schema for MaxPriorityFeePerGas from bigint (wei).
+ * @module MaxPriorityFeePerGas/BigInt
+ * @since 0.1.0
+ */
+
+import { Uint } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+export type MaxPriorityFeePerGasType = bigint & {
+	readonly __tag: "MaxPriorityFeePerGas";
+};
+
+const MaxPriorityFeePerGasTypeSchema = S.declare<MaxPriorityFeePerGasType>(
+	(u): u is MaxPriorityFeePerGasType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "MaxPriorityFeePerGas" },
+);
+
+/**
+ * Schema for MaxPriorityFeePerGas from bigint (wei).
+ *
+ * @example
+ * ```typescript
+ * import * as MaxPriorityFeePerGas from 'voltaire-effect/primitives/MaxPriorityFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const tip = S.decodeSync(MaxPriorityFeePerGas.BigInt)(2000000000n) // 2 gwei in wei
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const BigInt: S.Schema<MaxPriorityFeePerGasType, bigint> =
+	S.transformOrFail(S.BigIntFromSelf, MaxPriorityFeePerGasTypeSchema, {
+		strict: true,
+		decode: (value, _options, ast) => {
+			try {
+				return ParseResult.succeed(
+					Uint.from(value) as unknown as MaxPriorityFeePerGasType,
+				);
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, value, (e as Error).message),
+				);
+			}
+		},
+		encode: (tip) => ParseResult.succeed(tip as bigint),
+	}).annotations({ identifier: "MaxPriorityFeePerGas.BigInt" });

package/src/primitives/MaxPriorityFeePerGas/Gwei.ts

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Schema for MaxPriorityFeePerGas from gwei.
+ * @module MaxPriorityFeePerGas/Gwei
+ * @since 0.1.0
+ */
+
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+import type { MaxPriorityFeePerGasType } from "./BigInt.js";
+
+const GWEI = 1_000_000_000n;
+
+const MaxPriorityFeePerGasTypeSchema = S.declare<MaxPriorityFeePerGasType>(
+	(u): u is MaxPriorityFeePerGasType => typeof u === "bigint" && u >= 0n,
+	{ identifier: "MaxPriorityFeePerGas" },
+);
+
+/**
+ * Schema for MaxPriorityFeePerGas from gwei.
+ * Decodes gwei to wei, encodes wei to gwei.
+ *
+ * @example
+ * ```typescript
+ * import * as MaxPriorityFeePerGas from 'voltaire-effect/primitives/MaxPriorityFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const tip = S.decodeSync(MaxPriorityFeePerGas.Gwei)(2) // 2 gwei -> wei
+ * const gwei = S.encodeSync(MaxPriorityFeePerGas.Gwei)(tip) // 2n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const Gwei: S.Schema<MaxPriorityFeePerGasType, number | bigint> =
+	S.transformOrFail(
+		S.Union(S.Number, S.BigIntFromSelf),
+		MaxPriorityFeePerGasTypeSchema,
+		{
+			strict: true,
+			decode: (value, _options, ast) => {
+				try {
+					const gwei =
+						typeof value === "number" ? globalThis.BigInt(value) : value;
+					if (gwei < 0n) {
+						return ParseResult.fail(
+							new ParseResult.Type(
+								ast,
+								value,
+								"MaxPriorityFeePerGas cannot be negative",
+							),
+						);
+					}
+					return ParseResult.succeed(
+						(gwei * GWEI) as unknown as MaxPriorityFeePerGasType,
+					);
+				} catch (e) {
+					return ParseResult.fail(
+						new ParseResult.Type(ast, value, (e as Error).message),
+					);
+				}
+			},
+			encode: (tip) => ParseResult.succeed(tip / GWEI),
+		},
+	).annotations({ identifier: "MaxPriorityFeePerGas.Gwei" });

package/src/primitives/MaxPriorityFeePerGas/index.ts

@@ -0,0 +1,51 @@
+/**
+ * @module MaxPriorityFeePerGas
+ * @description Effect Schemas for EIP-1559 priority fee (tip).
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as MaxPriorityFeePerGas from 'voltaire-effect/primitives/MaxPriorityFeePerGas'
+ *
+ * function setTip(tip: MaxPriorityFeePerGas.MaxPriorityFeePerGasType) {
+ *   // ...
+ * }
+ * ```
+ *
+ * The priority fee is paid to validators to incentivize transaction inclusion.
+ * Higher tips during congestion lead to faster inclusion.
+ *
+ * Typical values:
+ * - Low priority: 1-2 gwei
+ * - Medium priority: 2-3 gwei
+ * - High priority: 5+ gwei
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `MaxPriorityFeePerGas.BigInt` | bigint (wei) | MaxPriorityFeePerGasType |
+ * | `MaxPriorityFeePerGas.Gwei` | number/bigint (gwei) | MaxPriorityFeePerGasType |
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import * as MaxPriorityFeePerGas from 'voltaire-effect/primitives/MaxPriorityFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * // From wei
+ * const tip = S.decodeSync(MaxPriorityFeePerGas.BigInt)(2000000000n)
+ *
+ * // From gwei (more ergonomic)
+ * const tip2 = S.decodeSync(MaxPriorityFeePerGas.Gwei)(2)
+ *
+ * // Convert to gwei for display
+ * const gwei = MaxPriorityFeePerGas.toGwei(tip) // 2n
+ * ```
+ *
+ * @since 0.1.0
+ */
+
+export { BigInt, type MaxPriorityFeePerGasType } from "./BigInt.js";
+export { Gwei } from "./Gwei.js";
+export { toGwei } from "./toGwei.js";

package/src/primitives/MaxPriorityFeePerGas/toGwei.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Pure function to convert MaxPriorityFeePerGas to gwei.
+ * @module MaxPriorityFeePerGas/toGwei
+ * @since 0.1.0
+ */
+
+import type { MaxPriorityFeePerGasType } from "./BigInt.js";
+
+const GWEI = 1_000_000_000n;
+
+/**
+ * Converts a priority fee from wei to gwei.
+ *
+ * @param value - Priority fee in wei
+ * @returns Priority fee in gwei
+ *
+ * @example
+ * ```typescript
+ * import * as MaxPriorityFeePerGas from 'voltaire-effect/primitives/MaxPriorityFeePerGas'
+ * import * as S from 'effect/Schema'
+ *
+ * const tip = S.decodeSync(MaxPriorityFeePerGas.Gwei)(2)
+ * const gwei = MaxPriorityFeePerGas.toGwei(tip) // 2n
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toGwei = (value: MaxPriorityFeePerGasType): bigint => value / GWEI;

package/src/primitives/MemoryDump/MemoryDumpSchema.ts

@@ -0,0 +1,70 @@
+import { MemoryDump } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+/**
+ * The MemoryDump type representing EVM memory state.
+ * @since 0.0.1
+ */
+type MemoryDumpType = ReturnType<typeof MemoryDump.from>;
+
+/**
+ * Internal schema declaration for MemoryDump type validation.
+ * @internal
+ */
+const MemoryDumpTypeSchema = S.declare<MemoryDumpType>(
+	(u): u is MemoryDumpType => {
+		if (typeof u !== "object" || u === null) return false;
+		const obj = u as Record<string, unknown>;
+		return obj.data instanceof Uint8Array && typeof obj.length === "number";
+	},
+	{ identifier: "MemoryDump" },
+);
+
+/**
+ * Effect Schema for validating and parsing EVM memory dumps.
+ * Memory dumps capture the state of EVM memory during execution or debugging.
+ *
+ * @param input - A Uint8Array or object with data and optional length
+ * @returns The validated MemoryDumpType
+ *
+ * @example
+ * ```typescript
+ * import * as S from 'effect/Schema'
+ * import { MemoryDumpSchema } from 'voltaire-effect/MemoryDump'
+ *
+ * // Parse from Uint8Array
+ * const dump = S.decodeSync(MemoryDumpSchema)(new Uint8Array([0, 1, 2, 3]))
+ *
+ * // Parse from object with explicit length
+ * const dumpWithLength = S.decodeSync(MemoryDumpSchema)({
+ *   data: new Uint8Array([0, 1, 2, 3]),
+ *   length: 4
+ * })
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const MemoryDumpSchema: S.Schema<
+	MemoryDumpType,
+	Uint8Array | { data: Uint8Array; length?: number }
+> = S.transformOrFail(
+	S.Union(
+		S.Uint8ArrayFromSelf,
+		S.Struct({ data: S.Uint8ArrayFromSelf, length: S.optional(S.Number) }),
+	),
+	MemoryDumpTypeSchema,
+	{
+		strict: true,
+		decode: (value, _options, ast) => {
+			try {
+				return ParseResult.succeed(MemoryDump.from(value));
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, value, (e as Error).message),
+				);
+			}
+		},
+		encode: (dump) => ParseResult.succeed(dump.data),
+	},
+).annotations({ identifier: "MemoryDumpSchema" });

package/src/primitives/MemoryDump/index.ts

@@ -0,0 +1,22 @@
+/**
+ * MemoryDump module for working with EVM memory state in Effect.
+ * Memory dumps capture the state of EVM memory during execution or debugging.
+ *
+ * @example
+ * ```typescript
+ * import * as MemoryDump from 'voltaire-effect/MemoryDump'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Create a memory dump
+ * const dump = Effect.runSync(MemoryDump.from(new Uint8Array([0, 1, 2, 3])))
+ *
+ * // Using the Schema for validation
+ * import * as S from 'effect/Schema'
+ * const parsed = S.decodeSync(MemoryDump.MemoryDumpSchema)(new Uint8Array(32))
+ * ```
+ *
+ * @since 0.0.1
+ * @module
+ */
+
+export { MemoryDumpSchema } from "./MemoryDumpSchema.js";

package/src/primitives/MerkleTree/MerkleTreeSchema.ts

@@ -0,0 +1,52 @@
+import type { MerkleTree } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+type MerkleTreeType = MerkleTree.MerkleTreeType;
+type MerkleProofType = MerkleTree.MerkleProofType;
+
+const MerkleTreeTypeSchema = S.declare<MerkleTreeType>(
+	(u): u is MerkleTreeType => {
+		if (typeof u !== "object" || u === null) return false;
+		const obj = u as MerkleTreeType;
+		return (
+			"root" in obj &&
+			"leafCount" in obj &&
+			"depth" in obj &&
+			"leaves" in obj &&
+			obj.root instanceof Uint8Array
+		);
+	},
+	{ identifier: "MerkleTree" },
+);
+
+const MerkleProofTypeSchema = S.declare<MerkleProofType>(
+	(u): u is MerkleProofType => {
+		if (typeof u !== "object" || u === null) return false;
+		const obj = u as MerkleProofType;
+		return (
+			"leaf" in obj &&
+			"siblings" in obj &&
+			"leafIndex" in obj &&
+			"treeDepth" in obj &&
+			obj.leaf instanceof Uint8Array
+		);
+	},
+	{ identifier: "MerkleProof" },
+);
+
+export const Schema: S.Schema<MerkleTreeType, MerkleTreeType> =
+	S.transformOrFail(MerkleTreeTypeSchema, MerkleTreeTypeSchema, {
+		strict: true,
+		decode: (t, _options, _ast) => ParseResult.succeed(t),
+		encode: (t) => ParseResult.succeed(t),
+	}).annotations({ identifier: "MerkleTreeSchema" });
+
+export const ProofSchema: S.Schema<MerkleProofType, MerkleProofType> =
+	S.transformOrFail(MerkleProofTypeSchema, MerkleProofTypeSchema, {
+		strict: true,
+		decode: (t, _options, _ast) => ParseResult.succeed(t),
+		encode: (t) => ParseResult.succeed(t),
+	}).annotations({ identifier: "MerkleProofSchema" });
+
+export type { MerkleTreeType, MerkleProofType };

package/src/primitives/MerkleTree/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @module MerkleTree
+ * @description Merkle tree and proof structures for cryptographic verification.
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as MerkleTree from 'voltaire-effect/primitives/MerkleTree'
+ *
+ * function verifyMerkleProof(proof: MerkleTree.MerkleProofType, tree: MerkleTree.MerkleTreeType) {
+ *   // ...
+ * }
+ * ```
+ *
+ * ## Schemas
+ *
+ * | Schema | Input | Output |
+ * |--------|-------|--------|
+ * | `Schema` | MerkleTree input | MerkleTreeType |
+ * | `ProofSchema` | MerkleProof input | MerkleProofType |
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import * as MerkleTree from 'voltaire-effect/primitives/MerkleTree'
+ * import * as S from 'effect/Schema'
+ *
+ * const tree = S.decodeSync(MerkleTree.Schema)(input)
+ * const proof = S.decodeSync(MerkleTree.ProofSchema)(proofInput)
+ * ```
+ *
+ * @since 0.1.0
+ */
+export {
+	type MerkleProofType,
+	type MerkleTreeType,
+	ProofSchema,
+	Schema,
+} from "./MerkleTreeSchema.js";

package/src/primitives/Metadata/MetadataSchema.ts

@@ -0,0 +1,57 @@
+import { Metadata } from "@tevm/voltaire";
+import * as ParseResult from "effect/ParseResult";
+import * as S from "effect/Schema";
+
+/**
+ * The Metadata type representing contract metadata (CBOR-encoded at end of bytecode).
+ * @since 0.0.1
+ */
+type MetadataType = ReturnType<typeof Metadata.from>;
+
+/**
+ * Internal schema declaration for Metadata type validation.
+ * @internal
+ */
+const MetadataTypeSchema = S.declare<MetadataType>(
+	(u): u is MetadataType => {
+		if (typeof u !== "object" || u === null) return false;
+		const obj = u as Record<string, unknown>;
+		return obj.raw instanceof Uint8Array;
+	},
+	{ identifier: "Metadata" },
+);
+
+/**
+ * Effect Schema for validating and parsing contract metadata.
+ * Contract metadata is CBOR-encoded data appended to the end of contract bytecode,
+ * containing information like compiler version, source hash, etc.
+ *
+ * @param input - A Uint8Array containing the raw metadata bytes
+ * @returns The validated MetadataType
+ *
+ * @example
+ * ```typescript
+ * import * as S from 'effect/Schema'
+ * import { MetadataSchema } from 'voltaire-effect/Metadata'
+ *
+ * // Parse metadata from bytecode
+ * const metadataBytes = new Uint8Array([0xa2, 0x64, 0x69, 0x70, 0x66, 0x73])
+ * const metadata = S.decodeSync(MetadataSchema)(metadataBytes)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const MetadataSchema: S.Schema<MetadataType, Uint8Array> =
+	S.transformOrFail(S.Uint8ArrayFromSelf, MetadataTypeSchema, {
+		strict: true,
+		decode: (raw, _options, ast) => {
+			try {
+				return ParseResult.succeed(Metadata.from(raw));
+			} catch (e) {
+				return ParseResult.fail(
+					new ParseResult.Type(ast, raw, (e as Error).message),
+				);
+			}
+		},
+		encode: (metadata) => ParseResult.succeed(metadata.raw),
+	}).annotations({ identifier: "MetadataSchema" });

package/src/primitives/Metadata/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Metadata module for working with contract metadata in Effect.
+ * Contract metadata is CBOR-encoded data appended to the end of contract bytecode,
+ * containing information like compiler version, source hash, and IPFS/Swarm links.
+ *
+ * @example
+ * ```typescript
+ * import * as Metadata from 'voltaire-effect/Metadata'
+ * import * as Effect from 'effect/Effect'
+ *
+ * // Parse metadata from bytecode
+ * const metadataBytes = new Uint8Array([0xa2, 0x64, 0x69, 0x70, 0x66, 0x73])
+ * const metadata = Effect.runSync(Metadata.from(metadataBytes))
+ *
+ * // Using the Schema for validation
+ * import * as S from 'effect/Schema'
+ * const parsed = S.decodeSync(Metadata.MetadataSchema)(metadataBytes)
+ * ```
+ *
+ * @since 0.0.1
+ * @module
+ */
+
+export { MetadataSchema } from "./MetadataSchema.js";