@helios-lang/effect 0.1.0 → 0.1.2

package/package.json

@@ -1,21 +1,16 @@
 {
   "name": "@helios-lang/effect",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
-  "scripts": {
-    "build": "tsc -p ./tsconfig.build.json",
-    "lint": "eslint",
-    "prettify": "prettier . --write",
-    "test": "pnpm run test:types && pnpm run lint && pnpm run test:suite",
-    "test:suite": "bun test .",
-    "test:types": "tsc -p ./tsconfig.json"
+  "exports": {
+    ".": "./dist/index.js",
+    "./Uplc": "./dist/Uplc/index.js"
   },
   "keywords": [],
   "author": "Christian Schmitz",
   "license": "BSD-3-Clause",
-  "packageManager": "pnpm@10.20.0",
   "prettier": {
     "trailingComma": "none",
     "tabWidth": 2,
@@ -32,5 +27,13 @@
   },
   "dependencies": {
     "effect": "^3.19.12"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json",
+    "lint": "eslint",
+    "prettify": "prettier . --write",
+    "test": "pnpm run test:types && pnpm run lint && pnpm run test:suite",
+    "test:suite": "bun test .",
+    "test:types": "tsc -p ./tsconfig.json"
   }
-}
+}

package/src/Ledger/Address.ts

@@ -0,0 +1,238 @@
+import { Context, Effect, Option, ParseResult, Schema } from "effect"
+import * as Bech32 from "../Bech32.js"
+import * as Cbor from "../Cbor.js"
+import * as Bytes from "../internal/Bytes.js"
+import { Data } from "../Uplc/index.js"
+import * as PubKeyHash from "./PubKeyHash.js"
+import * as Credential from "./Credential.js"
+import * as ValidatorHash from "./ValidatorHash.js"
+
+export function isValid(addr: string): boolean {
+  if (addr.startsWith("addr1") || addr.startsWith("addr_test1")) {
+    return Bech32.isValid(addr) // TODO: full validation
+  }
+  // TODO: validate Byron format
+
+  return false
+}
+
+export class IsMainnet extends Context.Tag("IS_MAINNET")<
+  IsMainnet,
+  boolean
+>() {}
+
+export const Address = Schema.String.pipe(
+  Schema.filter((addr: string) => {
+    return isValid(addr) || "Invalid Cardano Address"
+  }),
+  Schema.brand("Address")
+)
+
+export type Address = Schema.Schema.Type<typeof Address>
+
+export const FromUplcData = Schema.transformOrFail(
+  Data.EnumVariant(0, {
+    spendingCredential: Credential.FromUplcData,
+    stakingCredential: Data.Option(Credential.FromUplcData)
+  }),
+  Address,
+  {
+    strict: true,
+    decode: (data) =>
+      Effect.gen(function* () {
+        const isMainnet = yield* IsMainnet
+
+        return make(
+          isMainnet,
+          data.spendingCredential,
+          data.stakingCredential._tag == "Some"
+            ? data.stakingCredential.value
+            : undefined
+        )
+      }),
+    encode: (address) => {
+      const { spendingCredential, stakingCredential } = Effect.runSync(
+        decodeInternal(address)
+      )
+
+      return ParseResult.succeed({
+        spendingCredential,
+        stakingCredential: stakingCredential
+          ? Option.some(stakingCredential)
+          : Option.none()
+      })
+    }
+  }
+)
+
+export function make(
+  isMainnet: boolean,
+  spendingCredential: Credential.Credential,
+  stakingCredential?: Credential.Credential
+) {
+  const prefix = isMainnet ? "addr" : "addr_test"
+  const bytes: number[] = toShelleyBytes(
+    isMainnet,
+    spendingCredential,
+    stakingCredential
+  )
+
+  const s: string = Bech32.encode(prefix, bytes)
+
+  return s as Address
+}
+
+// returns the byte representation of an Address
+function toShelleyBytes(
+  isMainnet: boolean,
+  spendingCredential: Credential.Credential,
+  stakingCredential?: Credential.Credential
+): number[] {
+  const spendingCredBytes = Bytes.toArray(spendingCredential.hash)
+
+  if (stakingCredential) {
+    const stakingCredBytes = Bytes.toArray(stakingCredential.hash)
+
+    if (spendingCredential._tag == "PubKey") {
+      if (stakingCredential._tag == "PubKey") {
+        return [isMainnet ? 0x01 : 0x00]
+          .concat(spendingCredBytes)
+          .concat(stakingCredBytes)
+      } else {
+        return [isMainnet ? 0x21 : 0x20]
+          .concat(spendingCredBytes)
+          .concat(stakingCredBytes)
+      }
+    } else {
+      if (stakingCredential._tag == "PubKey") {
+        return [isMainnet ? 0x11 : 0x10]
+          .concat(spendingCredBytes)
+          .concat(stakingCredBytes)
+      } else {
+        return [isMainnet ? 0x31 : 0x30]
+          .concat(spendingCredBytes)
+          .concat(stakingCredBytes)
+      }
+    }
+  } else if (spendingCredential._tag == "PubKey") {
+    return [isMainnet ? 0x61 : 0x60].concat(spendingCredBytes)
+  } else {
+    return [isMainnet ? 0x71 : 0x70].concat(spendingCredBytes)
+  }
+}
+
+const decodeInternal = (bytes: Bytes.BytesLike) =>
+  Effect.gen(function* () {
+    if (typeof bytes == "string" && bytes.startsWith("addr")) {
+      bytes = (yield* Bech32.decode(bytes)).bytes
+    }
+
+    const innerBytes = (yield* Cbor.isBytes(bytes))
+      ? (yield* Cbor.decodeBytes(bytes))
+      : Bytes.toArray(bytes)
+
+    const head = innerBytes[0]
+
+    const isMainnet = (head & 0b00001111) != 0
+
+    const type = head & 0b11110000
+
+    const firstPart = () => {
+      return innerBytes.slice(1, 29)
+    }
+
+    const secondPart = () => {
+      return innerBytes.slice(29, 57)
+    }
+
+    switch (type) {
+      case 0x00:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makePubKey(
+            yield* PubKeyHash.make(firstPart())
+          ),
+          stakingCredential: Credential.makePubKey(
+            yield* PubKeyHash.make(secondPart())
+          )
+        }
+      case 0x10:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makeValidator(
+            yield* ValidatorHash.make(firstPart())
+          ),
+          stakingCredential: Credential.makePubKey(
+            yield* PubKeyHash.make(secondPart())
+          )
+        }
+      case 0x20:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makePubKey(
+            yield* PubKeyHash.make(firstPart())
+          ),
+          stakingCredential: Credential.makeValidator(
+            yield* ValidatorHash.make(secondPart())
+          )
+        }
+      case 0x30:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makeValidator(
+            yield* ValidatorHash.make(firstPart())
+          ),
+          stakingCredential: Credential.makeValidator(
+            yield* ValidatorHash.make(secondPart())
+          )
+        }
+      case 0x60:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makePubKey(
+            yield* PubKeyHash.make(firstPart())
+          )
+        }
+      case 0x70:
+        return {
+          isMainnet,
+          spendingCredential: Credential.makeValidator(
+            yield* ValidatorHash.make(firstPart())
+          )
+        }
+      default:
+        return yield* Effect.fail(
+          new Error(`invalid Shelley Address header ${head}`)
+        )
+    }
+  })
+
+export const decode = (bytes: Bytes.BytesLike) =>
+  Effect.gen(function* () {
+    const { isMainnet, spendingCredential, stakingCredential } =
+      yield* decodeInternal(bytes)
+
+    return make(isMainnet, spendingCredential, stakingCredential)
+  })
+
+export function encode(address: Address): number[] {
+  return Cbor.encodeBytes(bytes(address))
+}
+
+export function bytes(address: Address): number[] {
+  return Effect.runSync(Bech32.decode(address)).bytes
+}
+
+export function isMainnet(address: Address): boolean {
+  return !address.startsWith("addr_test")
+}
+
+export function spendingCredential(address: Address): Credential.Credential {
+  return Effect.runSync(decodeInternal(address)).spendingCredential
+}
+
+export function stakingCredential(
+  address: Address
+): Credential.Credential | undefined {
+  return Effect.runSync(decodeInternal(address)).stakingCredential
+}

package/src/Ledger/Credential.ts

@@ -0,0 +1,29 @@
+import { Schema } from "effect"
+import { PubKeyHash } from "./PubKeyHash.js"
+import { ValidatorHash } from "./ValidatorHash.js"
+import { Data } from "../Uplc/index.js"
+
+export const Credential = Schema.Union(
+  Schema.TaggedStruct("PubKey", { hash: PubKeyHash }),
+  Schema.TaggedStruct("Validator", { hash: ValidatorHash })
+)
+
+export type Credential = Schema.Schema.Type<typeof Credential>
+
+export function makePubKey(pkh: PubKeyHash): Credential {
+  return { _tag: "PubKey", hash: pkh }
+}
+
+export function makeValidator(vh: ValidatorHash): Credential {
+  return { _tag: "Validator", hash: vh }
+}
+
+export const FromUplcData = Schema.transform(
+  Data.Enum({ PubKey: { hash: Data.Hex }, Validator: { hash: Data.Hex } }),
+  Credential,
+  {
+    strict: true,
+    decode: (cred) => cred,
+    encode: (cred) => cred
+  }
+)

package/src/Ledger/PubKeyHash.ts

@@ -0,0 +1,36 @@
+import { Effect, Encoding, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import { decodeBytes, DecodeEffect, encodeBytes } from "../Cbor.js"
+import { Data } from "../Uplc/index.js"
+
+export function isValid(pkh: string): boolean {
+  return /^[0-9a-fA-F]+$/.test(pkh) && pkh.length == 56
+}
+
+export const PubKeyHash = Schema.String.pipe(
+  Schema.filter((pkh: string) => isValid(pkh) || "Invalid Cardano PubKeyHash"),
+  Schema.brand("PubKeyHash")
+)
+
+export type PubKeyHash = Schema.Schema.Type<typeof PubKeyHash>
+
+export function make(bytes: Bytes.BytesLike) {
+  return Schema.decode(PubKeyHash)(Bytes.toHex(bytes))
+}
+
+export const FromUplcData = Schema.transform(Data.ByteArray, PubKeyHash, {
+  strict: true,
+  decode: Encoding.encodeHex,
+  encode: (s) => Effect.runSync(Encoding.decodeHex(s))
+})
+
+export const decode = (bytes: Bytes.BytesLike): DecodeEffect<PubKeyHash> =>
+  decodeBytes(bytes).pipe(
+    Effect.map((bytes) => new Uint8Array(bytes)),
+    Effect.map(Encoding.encodeHex),
+    Effect.map(Schema.decodeSync(PubKeyHash))
+  )
+
+export function encode(pkh: PubKeyHash): number[] {
+  return encodeBytes(pkh)
+}

package/src/Ledger/ValidatorHash.ts

@@ -0,0 +1,36 @@
+import { Effect, Encoding, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import { decodeBytes, DecodeEffect, encodeBytes } from "../Cbor.js"
+import { Data } from "../Uplc/index.js"
+
+export function isValid(vh: string): boolean {
+  return /^[0-9a-fA-F]+$/.test(vh) && vh.length == 56
+}
+
+export const ValidatorHash = Schema.String.pipe(
+  Schema.filter((vh: string) => isValid(vh) || "Invalid Cardano ValidatorHash"),
+  Schema.brand("ValidatorHash")
+)
+
+export type ValidatorHash = Schema.Schema.Type<typeof ValidatorHash>
+
+export function make(bytes: Bytes.BytesLike) {
+  return Schema.decode(ValidatorHash)(Bytes.toHex(bytes))
+}
+
+export const FromUplcData = Schema.transform(Data.ByteArray, ValidatorHash, {
+  strict: true,
+  decode: Encoding.encodeHex,
+  encode: Bytes.toUint8Array
+})
+
+export const decode = (bytes: Bytes.BytesLike): DecodeEffect<ValidatorHash> =>
+  decodeBytes(bytes).pipe(
+    Effect.map((bytes) => new Uint8Array(bytes)),
+    Effect.map(Encoding.encodeHex),
+    Effect.map(Schema.decodeSync(ValidatorHash))
+  )
+
+export function encode(vh: ValidatorHash): number[] {
+  return encodeBytes(vh)
+}

package/src/Ledger/index.ts

@@ -0,0 +1,4 @@
+export * as Address from "./Address.js"
+export * as Credential from "./Credential.js"
+export * as PubKeyHash from "./PubKeyHash.js"
+export * as ValidatorHash from "./ValidatorHash.js"

package/src/Uplc/Data.test.ts

@@ -0,0 +1,321 @@
+import { describe, expect, it } from "bun:test"
+import { Schema } from "effect"
+import * as Data from "./Data.js"
+
+describe("Uplc.DataSchema.BigInt", () => {
+  it("succeeds for {int: 0n}", () => {
+    expect(Schema.decodeSync(Data.BigInt)({ int: 0n })).toBe(0n)
+  })
+
+  it("fails for {int: '0'}", () => {
+    expect(() => Schema.decodeUnknownSync(Data.BigInt)({ int: "0" })).toThrow()
+  })
+})
+
+describe("Uplc.DataSchema.Int", () => {
+  it("succeeds for {int: 0n}", () => {
+    expect(Schema.decodeSync(Data.Int)({ int: 0n })).toBe(0)
+  })
+
+  it("fails for {int: '0'}", () => {
+    expect(() => Schema.decodeUnknownSync(Data.Int)({ int: "0" })).toThrow()
+  })
+})
+
+describe("Uplc.DataSchema.String", () => {
+  it("succeeds for {bytes: ''}", () => {
+    expect(Schema.decodeSync(Data.String)(Data.makeByteArrayData(""))).toBe("")
+  })
+
+  it("fails for {bytes: 'ff'}", () => {
+    expect(() =>
+      Schema.decodeSync(Data.String)(Data.makeByteArrayData("ff"))
+    ).toThrow()
+  })
+
+  it("succeeds for {bytes: '48656C6C6F20576F726C64'}", () => {
+    expect(
+      Schema.decodeSync(Data.String)(
+        Data.makeByteArrayData("48656C6C6F20576F726C64")
+      )
+    ).toBe("Hello World")
+  })
+})
+
+describe("Uplc.DataSchema.Array", () => {
+  it("succeeds for empty ListData", () => {
+    expect(Schema.decodeSync(Data.Array(Data.String))({ list: [] })).toEqual([])
+  })
+
+  it("succeeds for ListData containg single 'Hello World' string", () => {
+    expect(
+      Schema.decodeSync(Data.Array(Data.String))({
+        list: [Data.makeByteArrayData("48656C6C6F20576F726C64")]
+      })
+    ).toEqual(["Hello World"])
+  })
+
+  it("fails if ListData items are heterogenous", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Array(Data.String))({
+        list: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0)
+        ]
+      })
+    ).toThrow()
+  })
+})
+
+describe("Uplc.DataSchema.Struct", () => {
+  it("succeeds for empty ListData for empty Struct", () => {
+    expect(Schema.decodeSync(Data.Struct({}))({ list: [] })).toEqual({})
+  })
+
+  it("fails for empty ListData if one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Struct({ foo: Data.String }))({
+        list: []
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for ListData with single entry if one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.Struct({ foo: Data.String }))({
+        list: [Data.makeByteArrayData("48656C6C6F20576F726C64")]
+      })
+    ).toEqual({ foo: "Hello World" })
+  })
+
+  it("fails for ListData with wrong entry in first place with one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Struct({ foo: Data.String }))({
+        list: [{ int: 0n }]
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for ListData with spurious entries at end with one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.Struct({ foo: Data.String }))({
+        list: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0)
+        ]
+      })
+    ).toEqual({ foo: "Hello World" })
+  })
+
+  it("succeeds for ListData with two entries with two fields", () => {
+    expect(
+      Schema.decodeSync(Data.Struct({ foo: Data.String, bar: Data.Int }))({
+        list: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toEqual({ foo: "Hello World", bar: 0 })
+  })
+
+  it("fails for ListData with two entries in wrong order with two fields", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Struct({ bar: Data.Int, foo: Data.String }))({
+        list: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toThrow()
+  })
+})
+
+describe("Uplc.DataSchema.EnumVariant", () => {
+  it("succeeds for empty ConstrData for empty EnumVariant", () => {
+    expect(
+      Schema.decodeSync(Data.EnumVariant(0, {}))({
+        constructor: 0,
+        fields: []
+      })
+    ).toEqual({})
+  })
+
+  it("fields for ConstrData with wrong tag", () => {
+    expect(() =>
+      Schema.decodeSync(Data.EnumVariant(0, {}))({
+        constructor: 1,
+        fields: []
+      })
+    ).toThrow()
+  })
+
+  it("fails for empty ConstrData if one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.EnumVariant(0, { foo: Data.String }))({
+        constructor: 0,
+        fields: []
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for ConstrData with single entry if one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.EnumVariant(0, { foo: Data.String }))({
+        constructor: 0,
+        fields: [Data.makeByteArrayData("48656C6C6F20576F726C64")]
+      })
+    ).toEqual({ foo: "Hello World" })
+  })
+
+  it("fails for ConstrData with wrong entry in first place with one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.EnumVariant(0, { foo: Data.String }))({
+        constructor: 0,
+        fields: [{ int: 0n }]
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for EnumVariant with spurious entries at end with one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.EnumVariant(0, { foo: Data.String }))({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toEqual({ foo: "Hello World" })
+  })
+
+  it("succeeds for EnumVariant with two entries with two fields", () => {
+    expect(
+      Schema.decodeSync(
+        Data.EnumVariant(0, {
+          foo: Data.String,
+          bar: Data.Int
+        })
+      )({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toEqual({ foo: "Hello World", bar: 0 })
+  })
+
+  it("fails for EnumVariant with two entries in wrong order with two fields", () => {
+    expect(() =>
+      Schema.decodeSync(
+        Data.EnumVariant(0, {
+          bar: Data.Int,
+          foo: Data.String
+        })
+      )({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toThrow()
+  })
+})
+
+describe("Uplc.DataSchema.Enum", () => {
+  it("succeeds for empty ConstrData for empty EnumVariant", () => {
+    expect(
+      Schema.decodeSync(Data.Enum({ foo: {} }))({
+        constructor: 0,
+        fields: []
+      })
+    ).toEqual({ _tag: "foo" })
+  })
+
+  it("fields for ConstrData with wrong tag", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Enum({ foo: {} }))({
+        constructor: 1,
+        fields: []
+      })
+    ).toThrow()
+  })
+
+  it("fails for empty ConstrData if one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Enum({ foo: { bar: Data.String } }))({
+        constructor: 0,
+        fields: []
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for ConstrData with single entry if one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.Enum({ foo: { bar: Data.String } }))({
+        constructor: 0,
+        fields: [Data.makeByteArrayData("48656C6C6F20576F726C64")]
+      })
+    ).toEqual({ _tag: "foo", bar: "Hello World" })
+  })
+
+  it("fails for ConstrData with wrong entry in first place with one field is defined", () => {
+    expect(() =>
+      Schema.decodeSync(Data.Enum({ foo: { bar: Data.String } }))({
+        constructor: 0,
+        fields: [{ int: 0n }]
+      })
+    ).toThrow()
+  })
+
+  it("succeeds for Enum with spurious entries at end with one field is defined", () => {
+    expect(
+      Schema.decodeSync(Data.Enum({ foo: { bar: Data.String } }))({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toEqual({ _tag: "foo", bar: "Hello World" })
+  })
+
+  it("succeeds for Enum with two entries with two fields", () => {
+    expect(
+      Schema.decodeSync(
+        Data.Enum({
+          foo: {
+            a: Data.String,
+            b: Data.Int
+          }
+        })
+      )({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toEqual({ _tag: "foo", a: "Hello World", b: 0 })
+  })
+
+  it("fails for Enum with two entries in wrong order with two fields", () => {
+    expect(() =>
+      Schema.decodeSync(
+        Data.Enum({
+          foo: {
+            a: Data.Int,
+            b: Data.String
+          }
+        })
+      )({
+        constructor: 0,
+        fields: [
+          Data.makeByteArrayData("48656C6C6F20576F726C64"),
+          Data.makeIntData(0n)
+        ]
+      })
+    ).toThrow()
+  })
+})