voltaire-effect 0.2.23 → 0.2.25

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" },
+);

package/src/primitives/AccessList/addressCount.ts

@@ -0,0 +1,21 @@
+/**
+ * @module addressCount
+ * @description Count total addresses in access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Count total addresses in access list
+ *
+ * @param list - Access list to count
+ * @returns Number of addresses
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const count = AccessList.addressCount(list)
+ * ```
+ */
+export const addressCount = (list: BrandedAccessList): number =>
+  AccessList.addressCount(list);

package/src/primitives/AccessList/assertValid.ts

@@ -0,0 +1,37 @@
+/**
+ * @module assertValid
+ * @description Validate access list structure with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type {
+  InvalidFormatError,
+  InvalidLengthError,
+} from "@tevm/voltaire/errors";
+
+type AssertValidError = InvalidFormatError | InvalidLengthError;
+
+/**
+ * Validate access list structure
+ *
+ * @param list - Access list to validate
+ * @returns Effect yielding void or failing with AssertValidError
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   yield* AccessList.assertValid(list)
+ *   console.log('Valid access list')
+ * })
+ * ```
+ */
+export const assertValid = (
+  list: BrandedAccessList,
+): Effect.Effect<void, AssertValidError> =>
+  Effect.try({
+    try: () => AccessList.assertValid(list),
+    catch: (e) => e as AssertValidError,
+  });

package/src/primitives/AccessList/create.ts

@@ -0,0 +1,19 @@
+/**
+ * @module create
+ * @description Create empty access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Create empty access list
+ *
+ * @returns Empty access list
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const list = AccessList.create()
+ * ```
+ */
+export const create = (): BrandedAccessList => AccessList.create();

package/src/primitives/AccessList/deduplicate.ts

@@ -0,0 +1,23 @@
+/**
+ * @module deduplicate
+ * @description Deduplicate access list entries
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Deduplicate access list entries
+ *
+ * Merges duplicate addresses and removes duplicate storage keys.
+ *
+ * @param list - Access list to deduplicate
+ * @returns Deduplicated access list
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const deduped = AccessList.deduplicate(list)
+ * ```
+ */
+export const deduplicate = (list: BrandedAccessList): BrandedAccessList =>
+  AccessList.deduplicate(list);

package/src/primitives/AccessList/from.ts

@@ -0,0 +1,39 @@
+/**
+ * @module from
+ * @description Create AccessList from array or bytes with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import {
+  AccessList,
+  type BrandedAccessList,
+  type Item,
+} from "@tevm/voltaire/AccessList";
+import type {
+  InvalidFormatError,
+  InvalidLengthError,
+} from "@tevm/voltaire/errors";
+
+type AccessListError = InvalidFormatError | InvalidLengthError;
+
+/**
+ * Create AccessList from array or bytes
+ *
+ * @param value - AccessList items or RLP bytes
+ * @returns Effect yielding BrandedAccessList or failing with AccessListError
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = AccessList.from([{ address, storageKeys: [] }])
+ * const list = await Effect.runPromise(program)
+ * ```
+ */
+export const from = (
+  value: readonly Item[] | Uint8Array,
+): Effect.Effect<BrandedAccessList, AccessListError> =>
+  Effect.try({
+    try: () => AccessList.from(value),
+    catch: (e) => e as AccessListError,
+  });

package/src/primitives/AccessList/fromBytes.ts

@@ -0,0 +1,36 @@
+/**
+ * @module fromBytes
+ * @description Decode RLP bytes to access list with Effect error handling
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type {
+  DecodingError,
+  InvalidFormatError,
+  InvalidLengthError,
+} from "@tevm/voltaire/errors";
+
+type FromBytesError = DecodingError | InvalidFormatError | InvalidLengthError;
+
+/**
+ * Decode RLP bytes to access list
+ *
+ * @param bytes - RLP-encoded access list
+ * @returns Effect yielding BrandedAccessList or failing with FromBytesError
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ * import * as Effect from 'effect/Effect'
+ *
+ * const program = AccessList.fromBytes(bytes)
+ * const list = await Effect.runPromise(program)
+ * ```
+ */
+export const fromBytes = (
+  bytes: Uint8Array,
+): Effect.Effect<BrandedAccessList, FromBytesError> =>
+  Effect.try({
+    try: () => AccessList.fromBytes(bytes),
+    catch: (e) => e as FromBytesError,
+  });

package/src/primitives/AccessList/gasCost.ts

@@ -0,0 +1,22 @@
+/**
+ * @module gasCost
+ * @description Calculate total gas cost for access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Calculate total gas cost for access list
+ *
+ * @param list - Access list to calculate cost for
+ * @returns Total gas cost in wei
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const cost = AccessList.gasCost(list)
+ * // cost = ADDRESS_COST + (numKeys * STORAGE_KEY_COST)
+ * ```
+ */
+export const gasCost = (list: BrandedAccessList): bigint =>
+  AccessList.gasCost(list);

package/src/primitives/AccessList/gasSavings.ts

@@ -0,0 +1,26 @@
+/**
+ * @module gasSavings
+ * @description Calculate gas savings from using access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Calculate gas savings from using access list
+ *
+ * Compares cold access costs vs access list costs.
+ *
+ * @param list - Access list to calculate savings for
+ * @returns Estimated gas savings (can be negative if not beneficial)
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const savings = AccessList.gasSavings(list)
+ * if (savings > 0n) {
+ *   console.log('Access list saves gas:', savings)
+ * }
+ * ```
+ */
+export const gasSavings = (list: BrandedAccessList): bigint =>
+  AccessList.gasSavings(list);

package/src/primitives/AccessList/hasSavings.ts

@@ -0,0 +1,23 @@
+/**
+ * @module hasSavings
+ * @description Check if access list provides net gas savings
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+
+/**
+ * Check if access list provides net gas savings
+ *
+ * @param list - Access list to check
+ * @returns true if access list saves gas overall
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * if (AccessList.hasSavings(list)) {
+ *   // Use the access list in transaction
+ * }
+ * ```
+ */
+export const hasSavings = (list: BrandedAccessList): boolean =>
+  AccessList.hasSavings(list);

package/src/primitives/AccessList/includesAddress.ts

@@ -0,0 +1,25 @@
+/**
+ * @module includesAddress
+ * @description Check if address is in access list
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type { AddressType } from "@tevm/voltaire/Address";
+
+/**
+ * Check if address is in access list
+ *
+ * @param list - Access list to search
+ * @param address - Address to find
+ * @returns true if address is in access list
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const hasAddress = AccessList.includesAddress(list, address)
+ * ```
+ */
+export const includesAddress = (
+  list: BrandedAccessList,
+  address: AddressType,
+): boolean => AccessList.includesAddress(list, address);

package/src/primitives/AccessList/includesStorageKey.ts

@@ -0,0 +1,28 @@
+/**
+ * @module includesStorageKey
+ * @description Check if storage key is in access list for given address
+ * @since 0.1.0
+ */
+import { AccessList, type BrandedAccessList } from "@tevm/voltaire/AccessList";
+import type { AddressType } from "@tevm/voltaire/Address";
+import type { HashType } from "@tevm/voltaire/Hash";
+
+/**
+ * Check if storage key is in access list for given address
+ *
+ * @param list - Access list to search
+ * @param address - Address to check
+ * @param storageKey - Storage key to find
+ * @returns true if storage key is accessible
+ * @example
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * const isAccessible = AccessList.includesStorageKey(list, address, key)
+ * ```
+ */
+export const includesStorageKey = (
+  list: BrandedAccessList,
+  address: AddressType,
+  storageKey: HashType,
+): boolean => AccessList.includesStorageKey(list, address, storageKey);

package/src/primitives/AccessList/index.ts

@@ -1,32 +1,112 @@
 /**
  * @module AccessList
- * @description Effect Schemas for EIP-2930 access lists.
+ * @description Effect Schemas and functions for EIP-2930 access lists.
+ *
+ * ## Type Declarations
+ *
+ * ```typescript
+ * import * as AccessList from 'voltaire-effect/primitives/AccessList'
+ *
+ * function buildTx(accessList: AccessList.BrandedAccessList) {
+ *   // ...
+ * }
+ * ```
  *
  * ## Schemas
  *
- * | Schema | Input | Output |
- * |--------|-------|--------|
- * | `AccessList.Rpc` | JSON-RPC format | BrandedAccessList |
+ * | Schema | Input | Output | Description |
+ * |--------|-------|--------|-------------|
+ * | `AccessList.Rpc` | JSON-RPC format | BrandedAccessList | Decodes from RPC format |
  *
- * ## Usage
+ * ## Constructors
  *
  * ```typescript
- * import * as AccessList from 'voltaire-effect/primitives/AccessList'
- * import * as S from 'effect/Schema'
- *
- * // Decode from JSON-RPC format
- * const accessList = S.decodeSync(AccessList.Rpc)([
- *   {
- *     address: '0x742d35Cc6634C0532925a3b844Bc9e7595f251e3',
- *     storageKeys: ['0x0...1']
- *   }
- * ])
- *
- * // Encode back to JSON-RPC format
- * const json = S.encodeSync(AccessList.Rpc)(accessList)
+ * AccessList.create()             // BrandedAccessList (pure)
+ * AccessList.from(value)          // Effect<BrandedAccessList, Error>
+ * AccessList.fromBytes(bytes)     // Effect<BrandedAccessList, Error>
+ * ```
+ *
+ * ## Pure Functions
+ *
+ * ```typescript
+ * AccessList.is(value)            // type guard
+ * AccessList.isItem(value)        // type guard
+ * AccessList.isEmpty(list)        // boolean
+ * AccessList.addressCount(list)   // number
+ * AccessList.storageKeyCount(list) // number
+ * AccessList.includesAddress(list, addr) // boolean
+ * AccessList.includesStorageKey(list, addr, key) // boolean
+ * AccessList.keysFor(list, addr)  // readonly HashType[] | undefined
+ * AccessList.gasCost(list)        // bigint
+ * AccessList.gasSavings(list)     // bigint
+ * AccessList.hasSavings(list)     // boolean
+ * AccessList.deduplicate(list)    // BrandedAccessList
+ * AccessList.merge(...lists)      // BrandedAccessList
+ * AccessList.toBytes(list)        // Uint8Array
+ * AccessList.withAddress(list, addr) // BrandedAccessList
+ * AccessList.withStorageKey(list, addr, key) // BrandedAccessList
+ * ```
+ *
+ * ## Effectful Functions
+ *
+ * ```typescript
+ * AccessList.assertValid(list)    // Effect<void, AssertValidError>
  * ```
  *
  * @since 0.1.0
  */
 
-export { type AccessListInput, type AccessListItemInput, Rpc } from "./Rpc.js";
+// Re-export types from voltaire
+export type { BrandedAccessList, Item } from "@tevm/voltaire/AccessList";
+export { AccessListTypeSchema } from "./AccessListTypeSchema.js";
+
+// Re-export errors from voltaire
+export {
+  InvalidFormatError,
+  InvalidLengthError,
+  DecodingError,
+} from "@tevm/voltaire/errors";
+
+// Schemas
+export { Rpc, type AccessListInput, type AccessListItemInput } from "./Rpc.js";
+
+// Constructors
+export { create } from "./create.js";
+export { from } from "./from.js";
+export { fromBytes } from "./fromBytes.js";
+
+// Pure functions - type guards
+export { is } from "./is.js";
+export { isItem } from "./isItem.js";
+
+// Pure functions - queries
+export { isEmpty } from "./isEmpty.js";
+export { addressCount } from "./addressCount.js";
+export { storageKeyCount } from "./storageKeyCount.js";
+export { includesAddress } from "./includesAddress.js";
+export { includesStorageKey } from "./includesStorageKey.js";
+export { keysFor } from "./keysFor.js";
+
+// Pure functions - gas calculations
+export { gasCost } from "./gasCost.js";
+export { gasSavings } from "./gasSavings.js";
+export { hasSavings } from "./hasSavings.js";
+
+// Pure functions - transformations
+export { deduplicate } from "./deduplicate.js";
+export { merge } from "./merge.js";
+export { toBytes } from "./toBytes.js";
+export { withAddress } from "./withAddress.js";
+export { withStorageKey } from "./withStorageKey.js";
+
+// Effectful functions
+export { assertValid } from "./assertValid.js";
+
+// Re-export constants from voltaire
+export {
+  ADDRESS_COST,
+  STORAGE_KEY_COST,
+  COLD_ACCOUNT_ACCESS_COST,
+  COLD_STORAGE_ACCESS_COST,
+  WARM_STORAGE_ACCESS_COST,
+} from "@tevm/voltaire/AccessList";