@helios-lang/effect 0.1.0

package/src/Uplc/Cek.ts

@@ -0,0 +1,92 @@
+//import { Either } from "effect"
+
+/**
+ * The context that terms and frames need to operate.
+ */
+export interface Context {
+  readonly cost: CostTracker
+  //getBuiltin(id: number): Builtin | undefined
+  print(message: string, site?: Site): void
+  popLastMessage(): string | undefined
+}
+
+export interface Cost {
+  readonly cpu: bigint
+  readonly mem: bigint
+}
+
+export type CostBreakdown = {
+  [name: string]: Cost & { count: number }
+}
+
+export interface CostModel {
+  readonly applyTerm: Cost
+  readonly builtinTerm: Cost
+  readonly caseTerm: Cost
+  readonly constTerm: Cost
+  readonly constrTerm: Cost
+  readonly delayTerm: Cost
+  readonly forceTerm: Cost
+  readonly lambdaTerm: Cost
+  readonly startupCost: Cost
+  readonly varTerm: Cost
+  readonly builtins: Record<string, (argSizes: number[]) => Cost>
+}
+
+export interface CostTracker {
+  readonly cost: Cost
+  readonly costModel: CostModel
+  readonly breakdown: CostBreakdown
+  incrApplyCost(): void
+  incrBuiltinCost(): void
+  incrCaseCost(): void
+  incrConstCost(): void
+  incrConstrCost(): void
+  incrDelayCost(): void
+  incrForceCost(): void
+  incrLambdaCost(): void
+  incrStartupCost(): void
+  incrVarCost(): void
+  incrArgSizesCost(name: string, argSizes: bigint[]): void
+}
+
+/**
+ * Instantiate a `Machine` with {@link makeCekMachine}.
+ */
+//export interface Machine extends Context {
+//  readonly builtins: Builtin[]
+//  readonly logger: Logger | undefined
+//  readonly state: State
+//  readonly trace: { message: string; site?: Site }[]
+//  eval(): Result
+//}
+
+/**
+ * TODO: rename to CEKResult
+ * @typedef {{
+ *   result: Either<
+ *     {
+ *       error: string
+ *       callSites: CallSiteInfo[]
+ *     },
+ *     string | UplcValue
+ *   >
+ *   cost: Cost
+ *   logs: {message: string, site?: Site}[]
+ *   breakdown: CostBreakdown
+ * }} CekResult
+ * Return value is optional and can be omitted if the UplcValue doesn't suffice to contain it (eg. lambda functions).
+ */
+//export interface Result {
+//  result: Either.Either<
+//    string | Value,
+//    { error: string; callSites: CallSiteInfo[] }
+//  >
+//}
+
+export interface Site {
+  readonly file: string
+  readonly line: number
+  readonly column: number
+  readonly description: string | undefined
+}

package/src/Uplc/Data.ts

@@ -0,0 +1,259 @@
+import { Effect, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import * as Cbor from "../Cbor.js"
+
+const SuspendedData = Schema.suspend(
+  (): Schema.Schema<Data, DataEncoded> => Data
+)
+
+export const ByteArray = Schema.Struct({
+  bytes: Schema.String
+})
+
+export type ByteArray = Schema.Schema.Type<typeof ByteArray>
+
+export type ByteArrayEncoded = Schema.Schema.Encoded<typeof ByteArray>
+
+export function makeByteArray(
+  bytes: string | number[] | Uint8Array
+): ByteArray {
+  return { bytes: Bytes.toHex(bytes) }
+}
+
+/**
+ * No need to serialize
+ *
+ * Cannot used Branded types due Schema issues.
+ */
+export const Int = Schema.Struct({
+  int: Schema.BigIntFromNumber
+})
+
+export type Int = Schema.Schema.Type<typeof Int>
+
+export type IntEncoded = Schema.Schema.Encoded<typeof Int>
+
+export function makeInt(value: number | bigint): Int {
+  return { int: BigInt(value) }
+}
+
+export const List = Schema.Struct({
+  list: Schema.Array(SuspendedData)
+})
+
+/**
+ * Must be defined explicitly to avoid circular reference problems
+ */
+export type List = {
+  readonly list: ReadonlyArray<Data>
+}
+
+export type ListEncoded = {
+  readonly list: ReadonlyArray<DataEncoded>
+}
+
+export function makeList(items: Data[]): List {
+  return {
+    list: items
+  }
+}
+
+export const Map = Schema.Struct({
+  map: Schema.Array(
+    Schema.Struct({
+      k: SuspendedData,
+      v: SuspendedData
+    })
+  )
+})
+
+/**
+ * Must be defined explicitly to avoid circular reference problems
+ */
+export type Map = {
+  readonly map: ReadonlyArray<{
+    readonly k: Data
+    readonly v: Data
+  }>
+}
+
+export type MapEncoded = {
+  readonly map: ReadonlyArray<{
+    readonly k: DataEncoded
+    readonly v: DataEncoded
+  }>
+}
+
+export function makeMap(entries: [Data, Data][]): Map {
+  return {
+    map: entries.map(([k, v]) => ({ k, v }))
+  }
+}
+
+export const Constr = Schema.Struct({
+  constructor: Schema.Number,
+  fields: Schema.Array(SuspendedData)
+})
+
+/**
+ * Must be defined explicitly to avoid circular reference problems
+ */
+export type Constr = {
+  readonly constructor: number
+  readonly fields: ReadonlyArray<Data>
+}
+
+export type ConstrEncoded = {
+  readonly constructor: number
+  readonly fields: ReadonlyArray<DataEncoded>
+}
+
+export function makeConstr(tag: bigint | number, fields: Data[]): Constr {
+  return {
+    constructor: Number(tag),
+    fields
+  }
+}
+
+export const Data = Schema.Union(ByteArray, Constr, Int, List, Map, Constr)
+
+export const DataUnencoded = Schema.typeSchema(Data)
+
+export type DataUnencoded = Data
+
+/**
+ * Must be defined explicitly to avoid circular reference problems
+ */
+export type Data = ByteArray | Constr | Int | List | Map
+
+export type DataEncoded =
+  | ByteArrayEncoded
+  | ConstrEncoded
+  | IntEncoded
+  | ListEncoded
+  | MapEncoded
+
+/**
+ * Simple recursive CBOR decoder
+ * @param bytes
+ * @returns
+ */
+export const decode = (bytes: Bytes.BytesLike): Cbor.DecodeEffect<Data> =>
+  Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes)
+
+    if (yield* Cbor.isList(stream)) {
+      const items = yield* Cbor.decodeList(decode)(stream)
+
+      return makeList(items)
+    } else if (yield* Cbor.isBytes(stream)) {
+      return makeByteArray(yield* Cbor.decodeBytes(stream))
+    } else if (yield* Cbor.isMap(stream)) {
+      const entries = yield* Cbor.decodeMap(decode, decode)(stream)
+
+      return makeMap(entries)
+    } else if (yield* Cbor.isConstr(stream)) {
+      const [tag, fields] = yield* Cbor.decodeConstr(decode)(stream)
+      return makeConstr(tag, fields)
+    } else {
+      return makeInt(yield* Cbor.decodeInt(stream))
+    }
+  })
+
+/**
+ * Simple recursive CBOR encoder
+ * @param data
+ * @returns
+ */
+export function encode(data: Data): number[] {
+  if ("bytes" in data) {
+    return Cbor.encodeBytes(data.bytes.slice(), true)
+  } else if ("fields" in data) {
+    return Cbor.encodeConstr(data.constructor, data.fields.map(encode))
+  } else if ("int" in data) {
+    return Cbor.encodeInt(data.int)
+  } else if ("list" in data) {
+    return Cbor.encodeList(data.list.map(encode))
+  } else if ("map" in data) {
+    return Cbor.encodeMap(data.map.map(({ k, v }) => [encode(k), encode(v)]))
+  } else {
+    throw new Error("Unrecognized Uplc.Data type")
+  }
+}
+
+export const NODE_MEM_SIZE = 4
+
+/**
+ * Simple recursive algorithm
+ * @param data
+ * @returns
+ */
+export function memSize(data: Data): number {
+  if ("bytes" in data) {
+    return NODE_MEM_SIZE + calcBytesMemSize(data.bytes)
+  } else if ("fields" in data) {
+    return data.fields.reduce(
+      (prev, field) => prev + memSize(field),
+      NODE_MEM_SIZE
+    )
+  } else if ("int" in data) {
+    return NODE_MEM_SIZE + calcIntMemSize(data.int)
+  } else if ("list" in data) {
+    return data.list.reduce((prev, item) => prev + memSize(item), NODE_MEM_SIZE)
+  } else if ("map" in data) {
+    return data.map.reduce(
+      (prev, { k, v }) => prev + memSize(k) + memSize(v),
+      NODE_MEM_SIZE
+    )
+  } else {
+    throw new Error("Unrecognized Uplc.Data type")
+  }
+}
+
+/**
+ * Calculates the mem size of a byte array without the DATA_NODE overhead.
+ * @param bytes
+ * @returns
+ */
+export function calcBytesMemSize(
+  bytes: string | readonly number[] | Uint8Array
+): number {
+  const n = Bytes.toArray(bytes).length
+
+  if (n === 0) {
+    return 1 // this is so annoying: haskell reference implementation says it should be 0, but current (20220925) testnet and mainnet settings say it's 1
+  } else {
+    return Math.floor((n - 1) / 8) + 1
+  }
+}
+
+/**
+ * Calculate the mem size of a integer (without the DATA_NODE overhead)
+ * @param value
+ * @returns
+ */
+export function calcIntMemSize(value: bigint) {
+  if (value == 0n) {
+    return 1
+  } else {
+    const abs = value > 0n ? value : -value
+
+    return Math.floor(log2i(abs) / 64) + 1
+  }
+}
+
+/**
+ * Math.log2 truncates, but we need a rounding down version
+ * @param x positive number
+ * @returns
+ */
+export function log2i(x: bigint): number {
+  let p = 0
+
+  while (x > 1n) {
+    x >>= 1n
+    p++
+  }
+
+  return p
+}

package/src/Uplc/DataSchema.test.ts

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