voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Rlp/decodeObject.ts

@@ -0,0 +1,46 @@
+import {
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Decodes RLP-encoded bytes to an object with known keys.
+ *
+ * @param data - RLP-encoded data
+ * @returns Effect that succeeds with decoded object or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { decodeObject, encodeObject } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const encoded = Effect.runSync(encodeObject({
+ *   name: new Uint8Array([65, 66]),
+ *   age: new Uint8Array([25])
+ * }))
+ * const decoded = Effect.runSync(decodeObject(encoded))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const decodeObject = (
+	data: Uint8Array,
+): Effect.Effect<Record<string, unknown>, RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.decodeObject(data),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("RLP object decoding failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/decodeValue.ts

@@ -0,0 +1,51 @@
+import {
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Decodes RLP-encoded bytes and returns the value directly.
+ *
+ * This is a convenience wrapper around decode() that returns just the decoded value
+ * without the metadata wrapper.
+ *
+ * @param bytes - RLP-encoded data
+ * @returns Effect that succeeds with decoded value or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { decodeValue } from 'voltaire-effect/primitives/Rlp'
+ *
+ * // Decode bytes - returns Uint8Array directly
+ * const value = Effect.runSync(decodeValue(new Uint8Array([0x83, 1, 2, 3])))
+ * // => Uint8Array([1, 2, 3])
+ *
+ * // Decode list - returns nested arrays
+ * const items = Effect.runSync(decodeValue(new Uint8Array([0xc3, 0x01, 0x02, 0x03])))
+ * // => [Uint8Array([1]), Uint8Array([2]), Uint8Array([3])]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const decodeValue = (
+	bytes: Uint8Array,
+): Effect.Effect<Uint8Array | unknown[], RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.decodeValue(bytes),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("RLP value decoding failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/encodeBatch.ts

@@ -0,0 +1,50 @@
+import {
+	type BrandedRlp,
+	type RlpEncodingError,
+	RlpEncodingError as RlpEncodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+type Encodable = Uint8Array | BrandedRlp | Encodable[];
+
+const isRlpEncodingError = (e: unknown): e is RlpEncodingError =>
+	e instanceof RlpEncodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpEncodingError");
+
+/**
+ * Encodes multiple items efficiently.
+ *
+ * @param items - Array of items to encode
+ * @returns Effect that succeeds with array of RLP-encoded results or fails with RlpEncodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { encodeBatch } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const items = [
+ *   [new Uint8Array([1, 2]), new Uint8Array([3, 4])],
+ *   [new Uint8Array([5, 6]), new Uint8Array([7, 8])]
+ * ]
+ * const encoded = Effect.runSync(encodeBatch(items))
+ * // => [Uint8Array(...), Uint8Array(...)]
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const encodeBatch = (
+	items: Encodable[][],
+): Effect.Effect<Uint8Array[], RlpEncodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.encodeBatch(items),
+		catch: (e) =>
+			isRlpEncodingError(e)
+				? e
+				: new RlpEncodingErrorClass("RLP batch encoding failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/encodeObject.ts

@@ -0,0 +1,48 @@
+import {
+	type BrandedRlp,
+	type RlpEncodingError,
+	RlpEncodingError as RlpEncodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+type Encodable = Uint8Array | BrandedRlp | Encodable[];
+
+const isRlpEncodingError = (e: unknown): e is RlpEncodingError =>
+	e instanceof RlpEncodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpEncodingError");
+
+/**
+ * Encodes an object (key-value pairs) to RLP format.
+ *
+ * @param obj - Object to encode
+ * @returns Effect that succeeds with RLP-encoded bytes or fails with RlpEncodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { encodeObject } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const encoded = Effect.runSync(encodeObject({
+ *   name: new Uint8Array([65, 66, 67]),
+ *   age: new Uint8Array([25])
+ * }))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const encodeObject = (
+	obj: Record<string, Encodable>,
+): Effect.Effect<Uint8Array, RlpEncodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.encodeObject(obj),
+		catch: (e) =>
+			isRlpEncodingError(e)
+				? e
+				: new RlpEncodingErrorClass("RLP object encoding failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/encodeVariadic.ts

@@ -0,0 +1,49 @@
+import {
+	type BrandedRlp,
+	type RlpEncodingError,
+	RlpEncodingError as RlpEncodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+type Encodable = Uint8Array | BrandedRlp | Encodable[];
+
+const isRlpEncodingError = (e: unknown): e is RlpEncodingError =>
+	e instanceof RlpEncodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpEncodingError");
+
+/**
+ * Encodes a variadic list of items to RLP format.
+ *
+ * @param items - Items to encode
+ * @returns Effect that succeeds with RLP-encoded bytes or fails with RlpEncodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { encodeVariadic } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const encoded = Effect.runSync(encodeVariadic(
+ *   new Uint8Array([1, 2]),
+ *   new Uint8Array([3, 4]),
+ *   new Uint8Array([5, 6])
+ * ))
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const encodeVariadic = (
+	...items: Encodable[]
+): Effect.Effect<Uint8Array, RlpEncodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.encodeVariadic(...items),
+		catch: (e) =>
+			isRlpEncodingError(e)
+				? e
+				: new RlpEncodingErrorClass("RLP variadic encoding failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/equals.ts

@@ -0,0 +1,22 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Checks if two RLP Data structures are equal.
+ *
+ * @param data - First RLP data structure
+ * @param other - Second RLP data structure
+ * @returns True if structures are deeply equal
+ *
+ * @example
+ * ```typescript
+ * import { equals } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const a = { type: 'bytes', value: new Uint8Array([1, 2]) }
+ * const b = { type: 'bytes', value: new Uint8Array([1, 2]) }
+ * equals(a, b) // => true
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const equals = (data: BrandedRlp, other: BrandedRlp): boolean =>
+	VoltaireRlp.equals(data, other);

package/src/primitives/Rlp/from.ts

@@ -0,0 +1,44 @@
+import {
+	type BrandedRlp,
+	type RlpEncodingError,
+	RlpEncodingError as RlpEncodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpEncodingError = (e: unknown): e is RlpEncodingError =>
+	e instanceof RlpEncodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpEncodingError");
+
+/**
+ * Creates an RLP data structure from various inputs.
+ *
+ * @param value - Uint8Array (bytes), BrandedRlp, or array (list)
+ * @returns Effect that succeeds with RLP data structure or fails with RlpEncodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { from } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const rlp = Effect.runSync(from(new Uint8Array([1, 2, 3])))
+ * // => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const from = (
+	value: Uint8Array | BrandedRlp | BrandedRlp[],
+): Effect.Effect<BrandedRlp, RlpEncodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.from(value),
+		catch: (e) =>
+			isRlpEncodingError(e)
+				? e
+				: new RlpEncodingErrorClass("RLP from failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/fromJSON.ts

@@ -0,0 +1,45 @@
+import {
+	type BrandedRlp,
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Converts JSON representation back to RLP Data.
+ *
+ * @param json - JSON object from toJSON
+ * @returns Effect that succeeds with RLP data structure or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { fromJSON } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const json = { type: 'bytes', value: [1, 2, 3] }
+ * const data = Effect.runSync(fromJSON(json))
+ * // => { type: 'bytes', value: Uint8Array([1, 2, 3]) }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const fromJSON = (
+	json: unknown,
+): Effect.Effect<BrandedRlp, RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.fromJSON(json),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("RLP fromJSON failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/getEncodedLength.ts

@@ -0,0 +1,47 @@
+import {
+	type BrandedRlp,
+	type RlpEncodingError,
+	RlpEncodingError as RlpEncodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+type Encodable = Uint8Array | BrandedRlp | Encodable[];
+
+const isRlpEncodingError = (e: unknown): e is RlpEncodingError =>
+	e instanceof RlpEncodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpEncodingError");
+
+/**
+ * Gets the total byte length of RLP-encoded data without actually encoding.
+ *
+ * @param data - Data to measure
+ * @returns Effect that succeeds with length in bytes after RLP encoding or fails with RlpEncodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { getEncodedLength } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const bytes = new Uint8Array([1, 2, 3])
+ * const length = Effect.runSync(getEncodedLength(bytes))
+ * // => 4 (0x83 prefix + 3 bytes)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const getEncodedLength = (
+	data: Encodable,
+): Effect.Effect<number, RlpEncodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.getEncodedLength(data),
+		catch: (e) =>
+			isRlpEncodingError(e)
+				? e
+				: new RlpEncodingErrorClass("getEncodedLength failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/getLength.ts

@@ -0,0 +1,44 @@
+import {
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Gets the total length of an RLP item (prefix + payload).
+ *
+ * @param data - RLP-encoded data
+ * @returns Effect that succeeds with total length in bytes or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { getLength } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const encoded = new Uint8Array([0x83, 1, 2, 3])
+ * const length = Effect.runSync(getLength(encoded))
+ * // => 4 (1 byte prefix + 3 bytes payload)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const getLength = (
+	data: Uint8Array,
+): Effect.Effect<number, RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.getLength(data),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("getLength failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});

package/src/primitives/Rlp/index.ts

@@ -21,21 +21,44 @@
  * |--------|-------|--------|
  * | `Rlp.Schema` | Uint8Array | BrandedRlp |
  *
- * ## Effect Functions
+ * ## API Design
  *
- * Encoding (can fail on invalid input):
- * - `encode(data)` - Encode bytes or nested arrays
- * - `encodeBytes(bytes)` - Encode a single byte array
- * - `encodeList(items)` - Encode a list of items
- * - `encodeArray(items)` - Encode array to RLP bytes
+ * ### Pure Functions (Direct Return)
+ * - `equals(a, b)` - boolean
+ * - `isData(value)` - boolean (type guard)
+ * - `isBytesData(value)` - boolean (type guard)
+ * - `isListData(value)` - boolean (type guard)
+ * - `isCanonical(bytes)` - boolean
+ * - `toJSON(data)` - unknown
+ * - `toRaw(data)` - Uint8Array | unknown[]
  *
- * Decoding (can fail on malformed RLP):
- * - `decode(bytes)` - Decode RLP bytes to data structure
- * - `decodeArray(bytes)` - Decode RLP bytes to array
+ * ### Effect-Returning Functions (Fallible)
+ *
+ * Encoding:
+ * - `encode(data)` - Effect<Uint8Array, RlpEncodingError>
+ * - `encodeBytes(bytes)` - Effect<Uint8Array>
+ * - `encodeList(items)` - Effect<Uint8Array>
+ * - `encodeArray(items)` - Effect<Uint8Array>
+ * - `encodeObject(obj)` - Effect<Uint8Array, RlpEncodingError>
+ * - `encodeBatch(items)` - Effect<Uint8Array[], RlpEncodingError>
+ * - `encodeVariadic(...items)` - Effect<Uint8Array, RlpEncodingError>
+ *
+ * Decoding:
+ * - `decode(bytes)` - Effect<Decoded, RlpDecodingError>
+ * - `decodeArray(bytes)` - Effect<unknown[], RlpDecodingError>
+ * - `decodeObject(bytes)` - Effect<Record<string, unknown>, RlpDecodingError>
+ * - `decodeValue(bytes)` - Effect<Uint8Array | unknown[], RlpDecodingError>
+ * - `decodeBatch(items)` - Effect<unknown[][], RlpDecodingError>
  *
  * Utilities:
- * - `flatten(data)` - Flatten nested RLP to array of bytes
- * - `validate(bytes)` - Check if bytes are valid RLP
+ * - `from(value)` - Effect<BrandedRlp, RlpEncodingError>
+ * - `fromJSON(json)` - Effect<BrandedRlp, RlpDecodingError>
+ * - `flatten(data)` - Effect<Array<BrandedRlp & { type: "bytes" }>>
+ * - `validate(bytes)` - Effect<boolean>
+ * - `isList(bytes)` - Effect<boolean, RlpDecodingError>
+ * - `isString(bytes)` - Effect<boolean, RlpDecodingError>
+ * - `getLength(bytes)` - Effect<number, RlpDecodingError>
+ * - `getEncodedLength(data)` - Effect<number, RlpEncodingError>
  *
  * @example Schema usage
  * ```typescript
@@ -62,13 +85,43 @@
  * @since 0.1.0
  */
 
+// Type exports
 export type { BrandedRlp } from "@tevm/voltaire/Rlp";
-export { type Decoded, decode } from "./decode.js";
-export { decodeArray } from "./decodeArray.js";
+
+// Schema and errors
+export { RlpDecodingError, RlpEncodingError, Schema } from "./RlpSchema.js";
+
+// Pure functions (direct return)
+export { equals } from "./equals.js";
+export { isCanonical } from "./isCanonical.js";
+export { isBytesData } from "./isBytesData.js";
+export { isData } from "./isData.js";
+export { isListData } from "./isListData.js";
+export { toJSON } from "./toJSON.js";
+export { toRaw } from "./toRaw.js";
+
+// Effect-returning encoding functions
 export { encode } from "./encode.js";
 export { encodeArray } from "./encodeArray.js";
+export { encodeBatch } from "./encodeBatch.js";
 export { encodeBytes } from "./encodeBytes.js";
 export { encodeList } from "./encodeList.js";
+export { encodeObject } from "./encodeObject.js";
+export { encodeVariadic } from "./encodeVariadic.js";
+
+// Effect-returning decoding functions
+export { type Decoded, decode } from "./decode.js";
+export { decodeArray } from "./decodeArray.js";
+export { decodeBatch } from "./decodeBatch.js";
+export { decodeObject } from "./decodeObject.js";
+export { decodeValue } from "./decodeValue.js";
+
+// Effect-returning utility functions
 export { flatten } from "./flatten.js";
-export { RlpDecodingError, RlpEncodingError, Schema } from "./RlpSchema.js";
+export { from } from "./from.js";
+export { fromJSON } from "./fromJSON.js";
+export { getEncodedLength } from "./getEncodedLength.js";
+export { getLength } from "./getLength.js";
+export { isList } from "./isList.js";
+export { isString } from "./isString.js";
 export { validate } from "./validate.js";

package/src/primitives/Rlp/isBytesData.ts

@@ -0,0 +1,21 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Checks if value is RLP bytes data.
+ *
+ * @param value - Value to check
+ * @returns True if value is RLP bytes data structure
+ *
+ * @example
+ * ```typescript
+ * import { isBytesData } from 'voltaire-effect/primitives/Rlp'
+ *
+ * isBytesData({ type: 'bytes', value: new Uint8Array([1]) }) // => true
+ * isBytesData({ type: 'list', value: [] }) // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isBytesData = (
+	value: unknown,
+): value is BrandedRlp & { type: "bytes" } => VoltaireRlp.isBytesData(value);

package/src/primitives/Rlp/isCanonical.ts

@@ -0,0 +1,32 @@
+import { Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Validates if RLP encoding is canonical.
+ *
+ * Canonical encoding rules:
+ * - Integers must use minimum bytes (no leading zeros)
+ * - Strings/bytes must use shortest length prefix
+ * - Single byte < 0x80 must not be encoded as string
+ * - Length prefix must use minimum bytes
+ *
+ * @param bytes - RLP-encoded data
+ * @param depth - Current recursion depth (internal)
+ * @returns True if encoding is canonical
+ *
+ * @example
+ * ```typescript
+ * import { isCanonical } from 'voltaire-effect/primitives/Rlp'
+ *
+ * // Canonical encoding
+ * const canonical = new Uint8Array([0x83, 0x64, 0x6f, 0x67]) // "dog"
+ * isCanonical(canonical) // => true
+ *
+ * // Non-canonical: single byte should not be prefixed
+ * const nonCanonical = new Uint8Array([0x81, 0x7f]) // should be just 0x7f
+ * isCanonical(nonCanonical) // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isCanonical = (bytes: Uint8Array, depth?: number): boolean =>
+	VoltaireRlp.isCanonical(bytes, depth);

package/src/primitives/Rlp/isData.ts

@@ -0,0 +1,21 @@
+import { type BrandedRlp, Rlp as VoltaireRlp } from "@tevm/voltaire/Rlp";
+
+/**
+ * Checks if value is an RLP Data structure.
+ *
+ * @param value - Value to check
+ * @returns True if value is valid RLP data structure
+ *
+ * @example
+ * ```typescript
+ * import { isData } from 'voltaire-effect/primitives/Rlp'
+ *
+ * isData({ type: 'bytes', value: new Uint8Array([1]) }) // => true
+ * isData({ type: 'list', value: [] }) // => true
+ * isData('invalid') // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isData = (value: unknown): value is BrandedRlp =>
+	VoltaireRlp.isData(value);

package/src/primitives/Rlp/isList.ts

@@ -0,0 +1,46 @@
+import {
+	type RlpDecodingError,
+	RlpDecodingError as RlpDecodingErrorClass,
+	Rlp as VoltaireRlp,
+} from "@tevm/voltaire/Rlp";
+import * as Effect from "effect/Effect";
+
+const isRlpDecodingError = (e: unknown): e is RlpDecodingError =>
+	e instanceof RlpDecodingErrorClass ||
+	(e !== null &&
+		typeof e === "object" &&
+		"name" in e &&
+		e.name === "RlpDecodingError");
+
+/**
+ * Checks if RLP-encoded data represents a list.
+ *
+ * @param data - RLP-encoded data
+ * @returns Effect that succeeds with boolean or fails with RlpDecodingError
+ *
+ * @example
+ * ```typescript
+ * import * as Effect from 'effect/Effect'
+ * import { isList } from 'voltaire-effect/primitives/Rlp'
+ *
+ * const list = new Uint8Array([0xc3, 0x01, 0x02, 0x03])
+ * Effect.runSync(isList(list)) // => true
+ *
+ * const bytes = new Uint8Array([0x83, 0x01, 0x02, 0x03])
+ * Effect.runSync(isList(bytes)) // => false
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const isList = (
+	data: Uint8Array,
+): Effect.Effect<boolean, RlpDecodingError> =>
+	Effect.try({
+		try: () => VoltaireRlp.isList(data),
+		catch: (e) =>
+			isRlpDecodingError(e)
+				? e
+				: new RlpDecodingErrorClass("isList check failed", {
+						cause: e instanceof Error ? e : undefined,
+					}),
+	});