voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Abi/encodePacked.ts

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview ABI encodePacked - compact encoding without padding.
+ * Provides Effect-based wrapper for packed encoding.
+ *
+ * @module Abi/encodePacked
+ * @since 0.0.1
+ */
+
+import {
+	AbiEncodingError as AbiEncodingErrorClass,
+	type AbiEncodingError,
+	type AbiParameterMismatchError,
+	encodePacked as _encodePacked,
+} from "@tevm/voltaire/Abi";
+import type { HexType } from "@tevm/voltaire/Hex";
+import * as Effect from "effect/Effect";
+
+type EncodePackedErrorType = AbiParameterMismatchError | AbiEncodingError;
+
+const isAbiError = (e: unknown): e is EncodePackedErrorType =>
+	e !== null &&
+	typeof e === "object" &&
+	"name" in e &&
+	(e.name === "AbiParameterMismatchError" || e.name === "AbiEncodingError");
+
+/**
+ * Encodes values in packed format (no padding).
+ *
+ * @description
+ * Performs ABI encoding without padding, used for creating hashes
+ * where standard ABI encoding would waste space.
+ *
+ * @param {readonly string[]} types - Array of Solidity type strings.
+ * @param {readonly unknown[]} values - Array of values to encode.
+ * @returns {Effect.Effect<HexType, AbiParameterMismatchError | AbiEncodingError>}
+ *   Effect yielding encoded hex string.
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { encodePacked } from 'voltaire-effect/primitives/Abi'
+ *
+ * const encoded = await Effect.runPromise(
+ *   encodePacked(['address', 'uint256'], [address, amount])
+ * )
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const encodePacked = (
+	types: readonly string[],
+	values: readonly unknown[],
+): Effect.Effect<HexType, AbiParameterMismatchError | AbiEncodingError> =>
+	Effect.try({
+		try: () => _encodePacked(types, values),
+		catch: (e) =>
+			isAbiError(e)
+				? e
+				: new AbiEncodingErrorClass("Failed to encode packed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Abi/encodeWrappedError.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Address, Bytes, Selector } from "@tevm/voltaire";
+import * as Effect from "effect/Effect";
+import { encodeWrappedError } from "./encodeWrappedError.js";
+
+describe("encodeWrappedError", () => {
+	describe("success cases", () => {
+		it.effect("encodes wrapped error", () =>
+			Effect.gen(function* () {
+				const encoded = yield* encodeWrappedError({
+					target: Address.from("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"),
+					selector: Selector.fromHex("0xa9059cbb"),
+					reason: Bytes.from(new Uint8Array([1, 2, 3])),
+					details: Bytes.from(new Uint8Array([4, 5, 6])),
+				});
+				expect(encoded).toBeInstanceOf(Uint8Array);
+				expect(encoded.length).toBeGreaterThan(4);
+			}),
+		);
+	});
+});

package/src/primitives/Abi/encodeWrappedError.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Encodes ERC-7751 wrapped error data.
+ * Provides Effect-based wrapper for wrapped error encoding.
+ *
+ * @module Abi/encodeWrappedError
+ * @since 0.0.1
+ */
+
+import {
+	AbiEncodingError as AbiEncodingErrorClass,
+	type AbiEncodingError,
+	type WrappedErrorType,
+	encodeWrappedError as _encodeWrappedError,
+} from "@tevm/voltaire/Abi";
+import * as Effect from "effect/Effect";
+
+/**
+ * Wrapped error input structure (ERC-7751).
+ */
+export type WrappedErrorInput = WrappedErrorType;
+
+/**
+ * Encodes ERC-7751 wrapped error data.
+ *
+ * @description
+ * Creates encoded error data following the ERC-7751 specification:
+ * `error WrappedError(address target, bytes4 selector, bytes reason, bytes details)`
+ *
+ * @param {WrappedErrorInput} wrappedError - Wrapped error data.
+ * @returns {Effect.Effect<Uint8Array, AbiEncodingError>}
+ *   Effect yielding encoded error data (selector + ABI-encoded params).
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { encodeWrappedError } from 'voltaire-effect/primitives/Abi'
+ * import * as Address from '@tevm/voltaire/Address'
+ * import * as Selector from '@tevm/voltaire/Selector'
+ *
+ * const encoded = await Effect.runPromise(
+ *   encodeWrappedError({
+ *     target: Address.from('0x1234...'),
+ *     selector: Selector.fromHex('0xabcd1234'),
+ *     reason: new Uint8Array([...]),
+ *     details: new Uint8Array([...])
+ *   })
+ * )
+ * ```
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-7751
+ * @since 0.0.1
+ */
+export const encodeWrappedError = (
+	wrappedError: WrappedErrorInput,
+): Effect.Effect<Uint8Array, AbiEncodingError> =>
+	Effect.try({
+		try: () => _encodeWrappedError(wrappedError),
+		catch: (e) =>
+			e instanceof AbiEncodingErrorClass
+				? e
+				: new AbiEncodingErrorClass("Failed to encode wrapped error", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Abi/findSelectorCollisions.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import { fromArray } from "./AbiSchema.js";
+import {
+	findSelectorCollisions,
+	hasSelectorCollisions,
+} from "./findSelectorCollisions.js";
+
+const normalAbi = S.decodeUnknownSync(fromArray)([
+	{
+		type: "function",
+		name: "transfer",
+		stateMutability: "nonpayable",
+		inputs: [
+			{ name: "to", type: "address" },
+			{ name: "amount", type: "uint256" },
+		],
+		outputs: [{ type: "bool" }],
+	},
+	{
+		type: "function",
+		name: "balanceOf",
+		stateMutability: "view",
+		inputs: [{ name: "account", type: "address" }],
+		outputs: [{ type: "uint256" }],
+	},
+]);
+
+describe("findSelectorCollisions", () => {
+	describe("success cases", () => {
+		it.effect("returns empty array for normal ABI", () =>
+			Effect.gen(function* () {
+				const collisions = yield* findSelectorCollisions(normalAbi);
+				expect(collisions).toEqual([]);
+			}),
+		);
+	});
+});
+
+describe("hasSelectorCollisions", () => {
+	describe("success cases", () => {
+		it.effect("returns false for normal ABI", () =>
+			Effect.gen(function* () {
+				const hasCollisions = yield* hasSelectorCollisions(normalAbi);
+				expect(hasCollisions).toBe(false);
+			}),
+		);
+	});
+});

package/src/primitives/Abi/findSelectorCollisions.ts

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Finds function selector collisions in an ABI.
+ * Provides Effect-based wrapper for collision detection.
+ *
+ * @module Abi/findSelectorCollisions
+ * @since 0.0.1
+ */
+
+import {
+	type ItemType,
+	findSelectorCollisions as _findSelectorCollisions,
+	hasSelectorCollisions as _hasSelectorCollisions,
+} from "@tevm/voltaire/Abi";
+import type { HexType } from "@tevm/voltaire/Hex";
+import * as Effect from "effect/Effect";
+
+type AbiInput = readonly ItemType[];
+
+/**
+ * Selector collision information.
+ */
+export interface SelectorCollision {
+	selector: HexType;
+	functions: readonly ItemType[];
+}
+
+/**
+ * Finds function selector collisions in an ABI.
+ *
+ * @description
+ * Detects when multiple functions in an ABI share the same 4-byte selector.
+ * This can happen due to the birthday paradox with 4-byte hashes.
+ *
+ * @param {AbiInput} abi - The contract ABI to check.
+ * @returns {Effect.Effect<readonly SelectorCollision[], never>}
+ *   Effect yielding array of collisions (empty if none).
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { findSelectorCollisions } from 'voltaire-effect/primitives/Abi'
+ *
+ * const collisions = await Effect.runPromise(
+ *   findSelectorCollisions(abi)
+ * )
+ * if (collisions.length > 0) {
+ *   console.warn('Selector collisions detected:', collisions)
+ * }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const findSelectorCollisions = (
+	abi: AbiInput,
+): Effect.Effect<readonly SelectorCollision[], never> =>
+	Effect.sync(() => _findSelectorCollisions([...abi]) as SelectorCollision[]);
+
+/**
+ * Checks if an ABI has any function selector collisions.
+ *
+ * @description
+ * Quick check for the presence of selector collisions.
+ *
+ * @param {AbiInput} abi - The contract ABI to check.
+ * @returns {Effect.Effect<boolean, never>}
+ *   Effect yielding true if collisions exist.
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { hasSelectorCollisions } from 'voltaire-effect/primitives/Abi'
+ *
+ * const hasCollisions = await Effect.runPromise(
+ *   hasSelectorCollisions(abi)
+ * )
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const hasSelectorCollisions = (
+	abi: AbiInput,
+): Effect.Effect<boolean, never> =>
+	Effect.sync(() => _hasSelectorCollisions([...abi]));

package/src/primitives/Abi/index.ts

@@ -21,33 +21,59 @@ export {
 	ReceiveSchema,
 	StateMutabilitySchema,
 } from "./AbiSchema.js";
-export { decodeError } from "./decodeError.js";
-export { decodeEventLog } from "./decodeEventLog.js";
-export { decodeFunction } from "./decodeFunction.js";
-export { decodeFunctionData } from "./decodeFunctionData.js";
-export { decodeFunctionResult } from "./decodeFunctionResult.js";
+
+// Core encoding
+export { encode } from "./encode.js";
+export { encodePacked } from "./encodePacked.js";
+export { encodeWrappedError, type WrappedErrorInput } from "./encodeWrappedError.js";
+
+// Core decoding
+export { decode } from "./decode.js";
+export { decodeData } from "./decodeData.js";
+export { decodeLog, type LogInput } from "./decodeLog.js";
+export { decodeWrappedError, type WrappedErrorResult } from "./decodeWrappedError.js";
+
 // Error encoding/decoding
+export { decodeError } from "./decodeError.js";
 export { encodeError } from "./encodeError.js";
+
 // Event encoding/decoding
+export { decodeEventLog } from "./decodeEventLog.js";
 export { encodeEventLog } from "./encodeEventLog.js";
+
 // Function encoding/decoding
+export { decodeFunction } from "./decodeFunction.js";
+export { decodeFunctionData } from "./decodeFunctionData.js";
+export { decodeFunctionResult } from "./decodeFunctionResult.js";
 export { encodeFunction } from "./encodeFunction.js";
 export { encodeFunctionData } from "./encodeFunctionData.js";
 export { encodeFunctionResult } from "./encodeFunctionResult.js";
+
+// Lookup functions
 export { findError } from "./findError.js";
 export { findEvent } from "./findEvent.js";
-// Lookup functions
 export { findFunction } from "./findFunction.js";
+
+// Selector collision detection
+export {
+	findSelectorCollisions,
+	hasSelectorCollisions,
+	type SelectorCollision,
+} from "./findSelectorCollisions.js";
+
 // Formatting
 export { format } from "./format.js";
 export { formatWithArgs } from "./formatWithArgs.js";
+
+// Getters
 export { getErrorSignature } from "./getErrorSignature.js";
 export { getEvent } from "./getEvent.js";
 export { getEventSignature } from "./getEventSignature.js";
 export { getFunction } from "./getFunction.js";
 export { getFunctionSignature } from "./getFunctionSignature.js";
-// Selectors and signatures
 export { getSelector } from "./getSelector.js";
+
 // Parsing
 export { AbiParseError, parse } from "./parse.js";
 export { AbiItemParseError, parseItem } from "./parseItem.js";
+export { parseLogs, type ParsedLog, type ParseLogsInput } from "./parseLogs.js";

package/src/primitives/Abi/parseLogs.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import { fromArray } from "./AbiSchema.js";
+import { parseLogs } from "./parseLogs.js";
+
+const erc20Abi = S.decodeUnknownSync(fromArray)([
+	{
+		type: "event",
+		name: "Transfer",
+		inputs: [
+			{ name: "from", type: "address", indexed: true },
+			{ name: "to", type: "address", indexed: true },
+			{ name: "value", type: "uint256", indexed: false },
+		],
+	},
+]);
+
+describe("parseLogs", () => {
+	describe("success cases", () => {
+		it.effect("returns empty array for no matching logs", () =>
+			Effect.gen(function* () {
+				const parsed = yield* parseLogs(erc20Abi, [
+					{ data: new Uint8Array(32), topics: [new Uint8Array(32)] },
+				]);
+				expect(parsed).toEqual([]);
+			}),
+		);
+
+		it.effect("returns empty array for empty logs", () =>
+			Effect.gen(function* () {
+				const parsed = yield* parseLogs(erc20Abi, []);
+				expect(parsed).toEqual([]);
+			}),
+		);
+	});
+});

package/src/primitives/Abi/parseLogs.ts

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Parses multiple event logs using ABI.
+ * Provides Effect-based wrapper for batch log parsing.
+ *
+ * @module Abi/parseLogs
+ * @since 0.0.1
+ */
+
+import { type Abi, type ItemType } from "@tevm/voltaire/Abi";
+import type { HexType } from "@tevm/voltaire/Hex";
+import * as Effect from "effect/Effect";
+
+type AbiInput = readonly ItemType[];
+
+const toAbi = (input: AbiInput): Abi => input as unknown as Abi;
+
+/**
+ * Log input structure for parseLogs.
+ */
+export interface ParseLogsInput {
+	data: Uint8Array | string;
+	topics: readonly (Uint8Array | string)[];
+}
+
+/**
+ * Parsed log result.
+ */
+export interface ParsedLog {
+	eventName: string;
+	args: Record<string, unknown>;
+}
+
+/**
+ * Parses multiple event logs using ABI.
+ *
+ * @description
+ * Parses an array of log entries, returning successfully decoded logs.
+ * Logs that don't match any event in the ABI are silently filtered out.
+ *
+ * @param {AbiInput} abi - The contract ABI.
+ * @param {readonly ParseLogsInput[]} logs - Array of log objects.
+ * @returns {Effect.Effect<readonly ParsedLog[], never>}
+ *   Effect yielding array of parsed logs (never fails).
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { parseLogs } from 'voltaire-effect/primitives/Abi'
+ *
+ * const parsed = await Effect.runPromise(
+ *   parseLogs(abi, logs)
+ * )
+ * // [{ eventName: 'Transfer', args: { from, to, value } }]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const parseLogs = (
+	abi: AbiInput,
+	logs: readonly ParseLogsInput[],
+): Effect.Effect<readonly ParsedLog[], never> =>
+	Effect.sync(() => toAbi(abi).parseLogs(logs));

package/src/primitives/AccessList/AccessList.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as S from "effect/Schema";
+import * as AccessList from "./index.js";
+
+const makeAddress = (byte: number): Uint8Array & { readonly __brand?: symbol } =>
+  new Uint8Array(20).fill(byte) as Uint8Array & { readonly __brand?: symbol };
+
+const makeHash = (byte: number): Uint8Array & { readonly __brand?: symbol } =>
+  new Uint8Array(32).fill(byte) as Uint8Array & { readonly __brand?: symbol };
+
+describe("AccessList", () => {
+  describe("create", () => {
+    it("creates empty access list", () => {
+      const list = AccessList.create();
+      expect(AccessList.isEmpty(list)).toBe(true);
+      expect(AccessList.addressCount(list)).toBe(0);
+    });
+  });
+
+  describe("from", () => {
+    it("creates from items", async () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      const list = await Effect.runPromise(
+        AccessList.from([{ address: addr, storageKeys: [key] }])
+      );
+      expect(AccessList.addressCount(list)).toBe(1);
+      expect(AccessList.storageKeyCount(list)).toBe(1);
+    });
+  });
+
+  describe("type guards", () => {
+    it("is() validates access list", () => {
+      const list = AccessList.create();
+      expect(AccessList.is(list)).toBe(true);
+      expect(AccessList.is([])).toBe(true);
+      expect(AccessList.is("not a list")).toBe(false);
+      expect(AccessList.is([{ invalid: true }])).toBe(false);
+    });
+
+    it("isItem() validates items", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      expect(AccessList.isItem({ address: addr, storageKeys: [key] })).toBe(true);
+      expect(AccessList.isItem({ address: addr, storageKeys: [] })).toBe(true);
+      expect(AccessList.isItem({ address: "0x123", storageKeys: [] })).toBe(false);
+      expect(AccessList.isItem(null)).toBe(false);
+    });
+  });
+
+  describe("queries", () => {
+    it("isEmpty", () => {
+      expect(AccessList.isEmpty(AccessList.create())).toBe(true);
+    });
+
+    it("addressCount", () => {
+      const addr1 = makeAddress(0x01);
+      const addr2 = makeAddress(0x02);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr1);
+      list = AccessList.withAddress(list, addr2);
+      expect(AccessList.addressCount(list)).toBe(2);
+    });
+
+    it("storageKeyCount", () => {
+      const addr = makeAddress(0x42);
+      const key1 = makeHash(0x01);
+      const key2 = makeHash(0x02);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key1);
+      list = AccessList.withStorageKey(list, addr, key2);
+      expect(AccessList.storageKeyCount(list)).toBe(2);
+    });
+
+    it("includesAddress", () => {
+      const addr = makeAddress(0x42);
+      const other = makeAddress(0x43);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr);
+      expect(AccessList.includesAddress(list, addr)).toBe(true);
+      expect(AccessList.includesAddress(list, other)).toBe(false);
+    });
+
+    it("includesStorageKey", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      const other = makeHash(0x02);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key);
+      expect(AccessList.includesStorageKey(list, addr, key)).toBe(true);
+      expect(AccessList.includesStorageKey(list, addr, other)).toBe(false);
+    });
+
+    it("keysFor", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key);
+      const keys = AccessList.keysFor(list, addr);
+      expect(keys).toBeDefined();
+      expect(keys?.length).toBe(1);
+      expect(AccessList.keysFor(list, makeAddress(0x99))).toBeUndefined();
+    });
+  });
+
+  describe("gas calculations", () => {
+    it("gasCost", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key);
+      const cost = AccessList.gasCost(list);
+      expect(cost).toBe(AccessList.ADDRESS_COST + AccessList.STORAGE_KEY_COST);
+    });
+
+    it("gasSavings", () => {
+      const addr = makeAddress(0x42);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr);
+      const savings = AccessList.gasSavings(list);
+      expect(savings).toBe(AccessList.COLD_ACCOUNT_ACCESS_COST - AccessList.ADDRESS_COST);
+    });
+
+    it("hasSavings", () => {
+      const addr = makeAddress(0x42);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr);
+      expect(AccessList.hasSavings(list)).toBe(true);
+    });
+  });
+
+  describe("transformations", () => {
+    it("withAddress adds new address", () => {
+      const addr = makeAddress(0x42);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr);
+      expect(AccessList.includesAddress(list, addr)).toBe(true);
+    });
+
+    it("withAddress is idempotent", () => {
+      const addr = makeAddress(0x42);
+      let list = AccessList.create();
+      list = AccessList.withAddress(list, addr);
+      const list2 = AccessList.withAddress(list, addr);
+      expect(AccessList.addressCount(list2)).toBe(1);
+    });
+
+    it("withStorageKey adds key", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key);
+      expect(AccessList.includesStorageKey(list, addr, key)).toBe(true);
+    });
+
+    it("deduplicate merges duplicate addresses", () => {
+      const addr = makeAddress(0x42);
+      const key1 = makeHash(0x01);
+      const key2 = makeHash(0x02);
+      const list = [
+        { address: addr, storageKeys: [key1] },
+        { address: addr, storageKeys: [key2, key1] },
+      ] as AccessList.BrandedAccessList;
+      const deduped = AccessList.deduplicate(list);
+      expect(AccessList.addressCount(deduped)).toBe(1);
+      expect(AccessList.storageKeyCount(deduped)).toBe(2);
+    });
+
+    it("merge combines lists", () => {
+      const addr1 = makeAddress(0x01);
+      const addr2 = makeAddress(0x02);
+      const list1 = AccessList.withAddress(AccessList.create(), addr1);
+      const list2 = AccessList.withAddress(AccessList.create(), addr2);
+      const merged = AccessList.merge(list1, list2);
+      expect(AccessList.addressCount(merged)).toBe(2);
+    });
+
+    it("toBytes encodes to RLP", () => {
+      const list = AccessList.create();
+      const bytes = AccessList.toBytes(list);
+      expect(bytes).toBeInstanceOf(Uint8Array);
+    });
+  });
+
+  describe("assertValid", () => {
+    it("succeeds for valid list", async () => {
+      const list = AccessList.create();
+      await Effect.runPromise(AccessList.assertValid(list));
+    });
+  });
+
+  describe("Rpc schema", () => {
+    it("decodes from JSON-RPC format", () => {
+      const input = [
+        {
+          address: "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3",
+          storageKeys: [
+            "0x0000000000000000000000000000000000000000000000000000000000000001",
+          ],
+        },
+      ];
+      const list = S.decodeSync(AccessList.Rpc)(input);
+      expect(AccessList.addressCount(list)).toBe(1);
+      expect(AccessList.storageKeyCount(list)).toBe(1);
+    });
+
+    it("encodes to JSON-RPC format", () => {
+      const addr = makeAddress(0x42);
+      const key = makeHash(0x01);
+      let list = AccessList.create();
+      list = AccessList.withStorageKey(list, addr, key);
+      const json = S.encodeSync(AccessList.Rpc)(list);
+      expect(json).toHaveLength(1);
+      expect(json[0].address).toMatch(/^0x[0-9a-f]{40}$/);
+      expect(json[0].storageKeys).toHaveLength(1);
+    });
+  });
+
+  describe("constants", () => {
+    it("exports gas constants", () => {
+      expect(AccessList.ADDRESS_COST).toBe(2400n);
+      expect(AccessList.STORAGE_KEY_COST).toBe(1900n);
+      expect(AccessList.COLD_ACCOUNT_ACCESS_COST).toBe(2600n);
+      expect(AccessList.COLD_STORAGE_ACCESS_COST).toBe(2100n);
+      expect(AccessList.WARM_STORAGE_ACCESS_COST).toBe(100n);
+    });
+  });
+});

package/src/primitives/AccessList/AccessListTypeSchema.ts

@@ -0,0 +1,16 @@
+/**
+ * @module AccessListTypeSchema
+ * @description Effect Schema declaration for BrandedAccessList type
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import * as S from "effect/Schema";
+
+/**
+ * Schema declaration for the BrandedAccessList type
+ * @since 0.1.0
+ */
+export const AccessListTypeSchema = S.declare<BrandedAccessList>(
+  (u): u is BrandedAccessList => AccessList.is(u),
+  { identifier: "AccessList" },
+);