@helios-lang/effect 0.1.0

package/src/Uplc/DataSchema.ts

@@ -0,0 +1,181 @@
+import { Effect, Encoding, ParseResult, Schema } from "effect"
+import { decode as decodeUtf8, encode as encodeUtf8 } from "../internal/Utf8.js"
+import { DataUnencoded as Data } from "./Data.js"
+
+const BigIntSchema = Schema.transformOrFail(Data, Schema.BigIntFromSelf, {
+  strict: true,
+  decode: (data) => {
+    if ("int" in data) {
+      return ParseResult.succeed(data.int)
+    } else {
+      return ParseResult.fail(
+        new ParseResult.Unexpected(data, "expected IntData")
+      )
+    }
+  },
+  encode: (value) => ParseResult.succeed({ int: value })
+})
+
+export { BigIntSchema as BigInt }
+
+export const Int = Schema.transformOrFail(Data, Schema.Int, {
+  strict: true,
+  decode: (data) => {
+    if ("int" in data) {
+      return ParseResult.succeed(Number(data.int))
+    } else {
+      return ParseResult.fail(
+        new ParseResult.Unexpected(data, "expected IntData")
+      )
+    }
+  },
+  encode: (value) => {
+    if (value % 1.0 != 0) {
+      return ParseResult.fail(
+        new ParseResult.Unexpected(value, "not an integer")
+      )
+    } else {
+      return ParseResult.succeed({ int: BigInt(Math.round(value)) })
+    }
+  }
+})
+
+export const ByteArray = Schema.transformOrFail(
+  Data,
+  Schema.Uint8ArrayFromHex,
+  {
+    strict: true,
+    decode: (data) => {
+      if ("bytes" in data) {
+        return ParseResult.succeed(data.bytes)
+      } else {
+        return ParseResult.fail(
+          new ParseResult.Unexpected(data, "expected ByteArrayData")
+        )
+      }
+    },
+    encode: (hex) => ParseResult.succeed({ bytes: hex })
+  }
+)
+
+const StringSchema = Schema.transformOrFail(Data, Schema.String, {
+  strict: true,
+  decode: (data) => {
+    if ("bytes" in data) {
+      return decodeUtf8(data.bytes).pipe(
+        Effect.mapError((e) => {
+          return new ParseResult.Unexpected(data.bytes, e.message)
+        })
+      )
+    } else {
+      return ParseResult.fail(
+        new ParseResult.Unexpected(data, "expected ByteArrayData")
+      )
+    }
+  },
+  encode: (s) =>
+    ParseResult.succeed({ bytes: Encoding.encodeHex(encodeUtf8(s)) })
+})
+
+export { StringSchema as String }
+
+const ArraySchema = <ItemType>(
+  itemSchema: Schema.Schema<ItemType, Schema.Schema.Encoded<typeof Data>>
+) =>
+  Schema.transformOrFail(Data, Schema.Array(itemSchema), {
+    strict: true,
+    decode: (data) => {
+      if ("list" in data) {
+        return ParseResult.succeed(data.list)
+      } else {
+        return ParseResult.fail(
+          new ParseResult.Unexpected(data, "expected ListData")
+        )
+      }
+    },
+    encode: (items) => ParseResult.succeed({ list: items })
+  })
+
+export { ArraySchema as Array }
+
+export const Struct = <
+  FieldTypes extends { [key: string]: any }
+>(fieldSchemas: {
+  [FieldName in keyof FieldTypes]: Schema.Schema<FieldTypes[FieldName], Data>
+}) =>
+  Schema.transformOrFail(Data, Schema.Struct(fieldSchemas), {
+    strict: true,
+    decode: (data) => {
+      if ("list" in data) {
+        return Effect.all(
+          Object.entries(fieldSchemas).map(([fieldName], i) => {
+            if (i >= data.list.length) {
+              return Effect.fail(
+                new ParseResult.Unexpected(
+                  data,
+                  `expected at least ${i + 1} entries in ListData`
+                )
+              )
+            }
+
+            const itemData = data.list[i]
+
+            return Effect.succeed([fieldName, itemData] as [string, Data])
+          })
+        ).pipe(Effect.map(Object.fromEntries))
+      } else {
+        return ParseResult.fail(
+          new ParseResult.Unexpected(data, "expected ListData")
+        )
+      }
+    },
+    encode: (fields) => ParseResult.succeed({ list: Object.values(fields) })
+  })
+
+export const EnumVariant = <FieldTypes extends { [key: string]: any }>(
+  tag: number | bigint,
+  fieldSchemas: {
+    [FieldName in keyof FieldTypes]: Schema.Schema<FieldTypes[FieldName], Data>
+  }
+) =>
+  Schema.transformOrFail(Data, Schema.Struct(fieldSchemas), {
+    strict: true,
+    decode: (data) => {
+      if ("fields" in data) {
+        if (data.constructor != Number(tag)) {
+          return ParseResult.fail(
+            new ParseResult.Unexpected(
+              data,
+              `expected ConstrData with constructor tag ${tag}`
+            )
+          )
+        }
+
+        return Effect.all(
+          Object.entries(fieldSchemas).map(([fieldName], i) => {
+            if (i >= data.fields.length) {
+              return Effect.fail(
+                new ParseResult.Unexpected(
+                  data,
+                  `expected at least ${i + 1} entries in ConstrData`
+                )
+              )
+            }
+
+            const itemData = data.fields[i]
+            
+            return Effect.succeed([fieldName, itemData] as [string, Data])
+          })
+        ).pipe(Effect.map(Object.fromEntries))
+      } else {
+        return ParseResult.fail(
+          new ParseResult.Unexpected(data, "expected ConstrData")
+        )
+      }
+    },
+    encode: (fields) =>
+      ParseResult.succeed({
+        constructor: Number(tag),
+        fields: Object.values(fields)
+      })
+  })

package/src/Uplc/Primitive.ts

@@ -0,0 +1,56 @@
+import { Brand, Schema } from "effect"
+
+export type Bool = boolean & Brand.Brand<"Bool">
+
+export const makeBool = Brand.nominal<Bool>()
+
+export type ByteArray = number[] & Brand.Brand<"ByteArray">
+
+export const makeByteArray = Brand.nominal<ByteArray>()
+
+export const Int = Schema.BigInt.pipe(Schema.brand("Int"))
+
+export type Int = bigint & Brand.Brand<"Int">
+
+export const makeInt = Brand.nominal<Int>()
+
+export type List = {
+  readonly _tag: "List"
+  readonly itemType: string // needed for empty lists
+  readonly items: Primitive[]
+}
+
+export function makeList(itemType: string, items: Primitive[]): List {
+  return {
+    _tag: "List",
+    itemType,
+    items
+  }
+}
+
+export type Pair = {
+  readonly _tag: "Pair"
+  readonly first: Primitive
+  readonly second: Primitive
+}
+
+export function makePair(first: Primitive, second: Primitive): Pair {
+  return {
+    _tag: "Pair",
+    first,
+    second
+  }
+}
+
+export type String = string & Brand.Brand<"String">
+
+export const makeString = Brand.nominal<String>()
+
+export type Unit = Brand.Brand<"Unit">
+
+const makeUnitInternal = Brand.nominal<Unit>()
+
+export const makeUnit = () => makeUnitInternal({})
+
+// TODO: add Bls12_381 primitives
+export type Primitive = Bool | ByteArray | Int | List | Pair | String | Unit

package/src/Uplc/index.ts

@@ -0,0 +1,3 @@
+export * as Data from "./Data.js"
+export * as DataSchema from "./DataSchema.js"
+export * as Primitive from "./Primitive.js"

package/src/index.ts

@@ -0,0 +1,4 @@
+export * as Address from "./Address.js"
+export * as Bech32 from "./Bech32.js"
+export * as Cbor from "./Cbor.js"
+export * as Uplc from "./Uplc"

package/src/internal/Base32.test.ts

@@ -0,0 +1,219 @@
+import { Effect, Either } from "effect"
+import { describe, it, expect } from "bun:test"
+import * as Base32 from "./Base32.js"
+import * as Utf8 from "./Utf8.js"
+
+/**
+ * Some test vectors taken from https://chromium.googlesource.com/chromium/src/+/lkgr/components/base32/base32_unittest.cc
+ */
+
+describe(`Base32.make()`, () => {
+  it("fails for non-32 char alphabet", () => {
+    expect(() => Base32.make({ alphabet: "abcdefg" })).toThrow()
+  })
+
+  it("fails for non-unique 32 char alphabet", () => {
+    expect(() =>
+      Base32.make({ alphabet: "aacdefghijklmnopqrstuvwxyz234567" })
+    ).toThrow()
+  })
+
+  it("fails for non-single char padding (0 chars)", () => {
+    expect(() =>
+      Base32.make({
+        alphabet: Base32.DEFAULT_ALPHABET,
+        padChar: ""
+      })
+    ).toThrow()
+  })
+
+  it("fails for non-single char padding (more than 1 chars)", () => {
+    expect(() =>
+      Base32.make({
+        alphabet: Base32.DEFAULT_ALPHABET,
+        padChar: "=="
+      })
+    ).toThrow()
+  })
+
+  it("fails if padding char is part of alphabet", () => {
+    expect(() =>
+      Base32.make({
+        alphabet: "abcdefghijklmnopqrstuvwxyz23456=",
+        padChar: "="
+      })
+    ).toThrow()
+  })
+})
+
+describe("Base32.DEFAULT.isValid()", () => {
+  it("returns true for an empty string", () => {
+    expect(Base32.DEFAULT.isValid("")).toBe(true)
+  })
+
+  it('returns true for "my"', () => {
+    expect(Base32.DEFAULT.isValid("my")).toBe(true)
+  })
+
+  it('returns false for "f0" (invalid char)', () => {
+    expect(Base32.DEFAULT.isValid("f0")).toBe(false)
+  })
+
+  it('returns false for "fo=" (bad alignment with padding)', () => {
+    expect(Base32.DEFAULT.isValid("fo=")).toBe(false)
+  })
+
+  it('returns false for "fo=o====" (interrupted padding)', () => {
+    expect(Base32.DEFAULT.isValid("fo=o====")).toBe(false)
+  })
+
+  it('returns false for "foo=====" (invalid padding length)', () => {
+    expect(Base32.DEFAULT.isValid("foo=====")).toBe(false)
+  })
+
+  it('returns false for "fooo====" (bad terminating char)', () => {
+    expect(Base32.DEFAULT.isValid("fooo====")).toBe(false)
+  })
+
+  it('returns true for "fooa===="', () => {
+    expect(Base32.DEFAULT.isValid("fooa====")).toBe(true)
+  })
+})
+
+describe("Base32.encode() without padding", () => {
+  const codec = Base32.make({})
+
+  it("returns an empty string for []", () => {
+    expect(codec.encode([])).toBe("")
+  })
+
+  it('returns "my" for the utf-8 bytes of "f"', () => {
+    expect(codec.encode(Utf8.encode("f"))).toBe("my")
+  })
+
+  it('returns "mzxq" for the utf-8 bytes of "fo"', () => {
+    expect(codec.encode(Utf8.encode("fo"))).toBe("mzxq")
+  })
+
+  it('returns "mzxw6" for the utf-8 bytes of "foo"', () => {
+    expect(codec.encode(Utf8.encode("foo"))).toBe("mzxw6")
+  })
+
+  it('returns "mzxw6yq" for the utf-8 bytes of "foob"', () => {
+    expect(codec.encode(Utf8.encode("foob"))).toBe("mzxw6yq")
+  })
+
+  it('returns "mzxw6ytb" for the utf-8 bytes of "fooba"', () => {
+    expect(codec.encode(Utf8.encode("fooba"))).toBe("mzxw6ytb")
+  })
+
+  it('returns "mzxw6ytboi" for the utf-8 bytes of "foobar"', () => {
+    expect(codec.encode(Utf8.encode("foobar"))).toBe("mzxw6ytboi")
+  })
+})
+
+describe("Base32.decode()", () => {
+  const paddingLessCodec = Base32.make({ alphabet: Base32.DEFAULT_ALPHABET })
+  const paddingCodec = Base32.make({
+    ...Base32.DEFAULT_PROPS,
+    strict: true
+  })
+
+  it("returns [] for an empty string", () => {
+    expect(Base32.DEFAULT.decode("")).toEqual(Either.right(new Uint8Array([])))
+  })
+
+  it('returns the utf-8 bytes of "f" for "my"', () => {
+    expect(paddingLessCodec.decode("my")).toEqual(
+      Either.right(Utf8.encode("f"))
+    )
+  })
+
+  it('returns the utf-8 bytes of "fo" for "mzxq"', () => {
+    expect(Base32.DEFAULT.decode("mzxq")).toEqual(
+      Either.right(Utf8.encode("fo"))
+    )
+  })
+
+  it('fails for "mzxq" if strict', () => {
+    expect(paddingCodec.decode("mzxq")._tag).toBe("Left")
+  })
+
+  it('returns the utf-8 btyes of "foo" for "mzxw6"', () => {
+    expect(Base32.DEFAULT.decode("mzxw6")).toEqual(
+      Either.right(Utf8.encode("foo"))
+    )
+  })
+
+  it('returns the utf-8 bytes of "foob" for "mzxw6yq"', () => {
+    expect(Base32.DEFAULT.decode("mzxw6yq")).toEqual(
+      Either.right(Utf8.encode("foob"))
+    )
+  })
+
+  it('returns the utf-8 bytes of "fooba" for "mzxw6ytb"', () => {
+    expect(Base32.DEFAULT.decode("mzxw6ytb")).toEqual(
+      Either.right(Utf8.encode("fooba"))
+    )
+  })
+
+  it('returns the utf-8 bytes of "foobar" for "mzxw6ytboi"', () => {
+    expect(Base32.DEFAULT.decode("mzxw6ytboi")).toEqual(
+      Either.right(Utf8.encode("foobar"))
+    )
+  })
+
+  it('fails for "0" (invalid char)', () => {
+    expect(Base32.DEFAULT.decode("0")._tag).toBe("Left")
+  })
+
+  it('fails for "1" (invalid char)', () => {
+    expect(Base32.DEFAULT.decode("1")._tag).toBe("Left")
+  })
+
+  it('fails for "8" (invalid char)', () => {
+    expect(Base32.DEFAULT.decode("8")._tag).toBe("Left")
+  })
+
+  it('fails for "9" (invalid char)', () => {
+    expect(Base32.DEFAULT.decode("9")._tag).toBe("Left")
+  })
+
+  it('fails for "$" (invalid char)', () => {
+    expect(Base32.DEFAULT.decode("$")._tag).toBe("Left")
+  })
+
+  it('returns the same for "mzxw6ytboi" as for "MZXW6YTBOI" (case insensitive)', () => {
+    const s = "mzxw6ytboi"
+
+    expect(Base32.DEFAULT.decode(s)).toEqual(
+      Base32.DEFAULT.decode(s.toUpperCase())
+    )
+  })
+})
+
+describe("Base32.decode()/Base32.encode() roundtrip", () => {
+  function roundtrip(encoded: string): string {
+    return Base32.DEFAULT.encode(Effect.runSync(Base32.DEFAULT.decode(encoded)))
+  }
+
+  it("fails for foo=====", () => {
+    expect(() => roundtrip("foo=====")).toThrow()
+  })
+
+  it("fails for foo====", () => {
+    expect(() => roundtrip("foo====")).toThrow()
+  })
+
+  it("fails for foo=b", () => {
+    expect(() => roundtrip("foo=b")).toThrow()
+  })
+
+  it("ok for fooa====", () => {
+    expect(roundtrip("fooa====")).toBe("fooa====")
+  })
+
+  it("fails for for fooo====", () => {
+    expect(() => roundtrip("fooo====")).toThrow()
+  })
+})