@helios-lang/effect 0.1.5 → 0.1.6

package/src/internal/Flat.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { makeWriter as makeBitWriter } from "./Bits.js"
-import * as Flat from "./Flat.js"
-
-describe("Flat.encodeInt()", () => {
-  it("writes 8 bits for 0", () => {
-    const bw = makeBitWriter()
-
-    Flat.encodeInt(bw, 0n)
-
-    expect(bw.length).toBe(8)
-  })
-
-  it("writes 8 bits for 127", () => {
-    const bw = makeBitWriter()
-
-    Flat.encodeInt(bw, 127n)
-
-    expect(bw.length).toBe(8)
-  })
-
-  it("writes 16 bits for 128", () => {
-    const bw = makeBitWriter()
-
-    Flat.encodeInt(bw, 128n)
-
-    expect(bw.length).toBe(16)
-  })
-})

package/src/internal/Flat.ts

@@ -1,387 +0,0 @@
-import * as Bits from "./Bits.js"
-
-/**
- * Instantiate a `Flat.Reader` with {@link makeReader}.
- */
-export interface Reader {
-  isAtEnd(): boolean
-  readBits(n: number): number
-  readBool(): boolean
-  readBuiltinId(): number
-  readBytes(): number[]
-  readInt(): bigint
-  readTag(): number
-  readList<T>(readItem: (r: Reader) => T): T[]
-}
-
-/**
- * @param bytes
- * @returns
- */
-export function makeReader(bytes: string | number[] | Uint8Array): Reader {
-  return new ReaderImpl(bytes)
-}
-
-class ReaderImpl implements Reader {
-  private readonly bitReader: Bits.Reader
-
-  /**
-   * @param bytes
-   */
-  constructor(bytes: string | number[] | Uint8Array) {
-    this.bitReader = Bits.makeReader(bytes)
-  }
-
-  isAtEnd(): boolean {
-    return this.bitReader.isAtEnd()
-  }
-
-  /**
-   * @param n
-   * @returns
-   */
-  readBits(n: number): number {
-    return this.bitReader.readBits(n)
-  }
-
-  readBool(): boolean {
-    return this.readBits(1) == 1
-  }
-
-  readBuiltinId(): number {
-    return this.readBits(7)
-  }
-
-  readBytes(): number[] {
-    return decodeBytes(this.bitReader)
-  }
-
-  /**
-   * @returns {bigint}
-   */
-  readInt(): bigint {
-    return decodeInt(this.bitReader)
-  }
-
-  /**
-   * Reads a Plutus-core list with a specified size per element
-   * Calls itself recursively until the end of the list is reached
-   * @template T
-   * @param readItem
-   * @returns
-   */
-  readList<T>(readItem: (r: Reader) => T): T[] {
-    // Cons and Nil constructors come from Lisp/Haskell
-    //  cons 'a' creates a linked list node,
-    //  nil      creates an empty linked list
-    const nilOrCons = this.readBits(1)
-
-    if (nilOrCons == 0) {
-      return []
-    } else {
-      return [readItem(this)].concat(this.readList(readItem))
-    }
-  }
-
-  readTag(): number {
-    return this.readBits(4)
-  }
-}
-
-/**
- * Instantiate a `FlatWriter` with {@link makeWriter}.
- */
-export interface Writer {
-  writeBool(b: boolean): Writer
-  writeBytes(bytes: number[]): Writer
-  writeInt(x: bigint | number): Writer
-  writeListCons(): Writer
-  writeListNil(): Writer
-  writeTermTag(tag: number): Writer
-  writeTypeBits(typeBits: string): Writer
-  writeBuiltinId(id: number): Writer
-  finalize(): number[]
-}
-
-/**
- * @returns
- */
-export function makeWriter(): Writer {
-  return new WriterImpl()
-}
-
-class WriterImpl implements Writer {
-  private readonly bitWriter: Bits.Writer
-
-  constructor() {
-    this.bitWriter = Bits.makeWriter()
-  }
-
-  /**
-   * @param b
-   * @returns
-   * Self for chaining
-   */
-  writeBool(b: boolean): Writer {
-    if (b) {
-      this.bitWriter.writeBits("1")
-    } else {
-      this.bitWriter.writeBits("0")
-    }
-
-    return this
-  }
-
-  /**
-   * @param bytes
-   * @returns
-   * Self for chaining
-   */
-  writeBytes(bytes: number[]): Writer {
-    encodeBytes(this.bitWriter, bytes)
-
-    return this
-  }
-
-  /**
-   * @param x
-   * @returns
-   * Self for chaining
-   * @throws
-   * If x is negative
-   */
-  writeInt(x: bigint): Writer {
-    if (x < 0) {
-      throw new Error("x in writeInt isn't positive")
-    }
-    encodeInt(this.bitWriter, x)
-
-    return this
-  }
-
-  /**
-   * @returns
-   * Self for chaining
-   */
-  writeListCons(): Writer {
-    this.bitWriter.writeBits("1")
-    return this
-  }
-
-  /**
-   * @returns
-   * Self for chaining
-   */
-  writeListNil(): Writer {
-    this.bitWriter.writeBits("0")
-    return this
-  }
-
-  /**
-   * @param tag
-   * @returns
-   * Self for chaining
-   */
-  writeTermTag(tag: number): Writer {
-    this.bitWriter.writeBits(Bits.pad(tag.toString(2), 4))
-    return this
-  }
-
-  /**
-   * @param typeBits
-   * @returns
-   * Self for chaining
-   */
-  writeTypeBits(typeBits: string): Writer {
-    this.bitWriter.writeBits("1" + typeBits + "0")
-    return this
-  }
-
-  /**
-   * @param id
-   */
-  writeBuiltinId(id: number): Writer {
-    this.bitWriter.writeBits(Bits.pad(id.toString(2), 7))
-
-    return this
-  }
-
-  /**
-   * @returns
-   */
-  finalize(): number[] {
-    return this.bitWriter.finalize()
-  }
-}
-
-/**
- * @param reader
- * @returns
- */
-export function decodeBytes(reader: Bits.Reader): number[] {
-  reader.moveToByteBoundary(true)
-
-  const bytes = []
-
-  let nChunk = reader.readByte()
-
-  while (nChunk > 0) {
-    for (let i = 0; i < nChunk; i++) {
-      bytes.push(reader.readByte())
-    }
-
-    nChunk = reader.readByte()
-  }
-
-  return bytes
-}
-
-/**
- * Write a list of bytes to the bitWriter using flat encoding.
- * Used by UplcString, UplcByteArray and UplcDataValue
- * Equivalent to E_B* function in Plutus-core docs
- * @param writer
- * @param bytes
- * @param pad
- * Optional, defaults to false
- */
-export function encodeBytes(
-  writer: Bits.Writer,
-  bytes: number[],
-  pad: boolean = true
-): void {
-  if (pad) {
-    writer.padToByteBoundary(true)
-  }
-
-  // the rest of this function is equivalent to E_C* function in Plutus-core docs
-  const n = bytes.length
-  let pos = 0
-
-  // write chunks of 255
-  while (pos < n) {
-    // each iteration is equivalent to E_C function in Plutus-core docs
-
-    const nChunk = Math.min(n - pos, 255)
-
-    // equivalent to E_8 function in Plutus-core docs
-    writer.writeBits(Bits.pad(nChunk.toString(2), 8))
-
-    for (let i = pos; i < pos + nChunk; i++) {
-      const b = bytes[i]
-
-      // equivalent to E_8 function in Plutus-core docs
-      writer.writeBits(Bits.pad(b.toString(2), 8))
-    }
-
-    pos += nChunk
-  }
-
-  if (pad) {
-    writer.writeBits("00000000")
-  }
-}
-
-/**
- * Includes type bits
- * @param n
- * @returns
- */
-export function bytesSize(n: number): number {
-  return 4 + n * 8 + Math.ceil(n / 256) * 8 + 8
-}
-
-/**
- * Returns an unsigned (zigzag encoded) bigint
- * @param reader
- * @returns
- */
-export function decodeInt(reader: Bits.Reader): bigint {
-  const bytes = []
-
-  let b = reader.readByte()
-  bytes.push(b)
-
-  while (!rawByteIsLast(b)) {
-    b = reader.readByte()
-    bytes.push(b)
-  }
-
-  // strip the leading bit
-  return decodeIntLE7(bytes.map((b) => parseRawByte(b))) // raw int is unsigned
-}
-
-/**
- * Combines a list of Plutus-core bytes into a bigint (leading bit of each byte is ignored).
- * Differs from bytesToBigInt in utils.js because only 7 bits are used from each byte.
- * @param bytes
- * @returns
- */
-function decodeIntLE7(bytes: number[]): bigint {
-  let value = BigInt(0)
-
-  const n = bytes.length
-
-  for (let i = 0; i < n; i++) {
-    const b = bytes[i]
-
-    // 7 (not 8), because leading bit isn't used here
-    value = value + BigInt(b) * pow2(BigInt(i) * 7n)
-  }
-
-  return value
-}
-
-/**
- * 2 to the power 'p' for bigint.
- * @param p
- * @returns
- */
-function pow2(p: bigint): bigint {
-  return p <= 0n ? 1n : 2n << (p - 1n)
-}
-
-/**
- * Parses a single byte in the Plutus-core byte-list representation of an int
- * @param b
- * @returns
- */
-function parseRawByte(b: number): number {
-  return b & 0b01111111
-}
-
-/**
- * Returns true if 'b' is the last byte in the Plutus-core byte-list representation of an int.
- * @param b
- * @returns
- */
-function rawByteIsLast(b: number): boolean {
-  return (b & 0b10000000) == 0
-}
-
-/**
- * @param bitWriter
- * @param x
- * positive number
- */
-export function encodeInt(bitWriter: Bits.Writer, x: bigint) {
-  const bitString = Bits.pad(x.toString(2), 7)
-
-  // split every 7th
-  const parts = []
-  for (let i = 0; i < bitString.length; i += 7) {
-    parts.push(bitString.slice(i, i + 7))
-  }
-
-  // reverse the parts
-  parts.reverse()
-
-  for (let i = 0; i < parts.length; i++) {
-    if (i == parts.length - 1) {
-      // last
-      bitWriter.writeBits("0" + parts[i])
-    } else {
-      bitWriter.writeBits("1" + parts[i])
-    }
-  }
-}

package/src/internal/Float.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { Either } from "effect"
-import { toHex } from "./Bytes.js"
-import * as Float from "./Float.js"
-
-/**
- * Taken from https://en.wikipedia.org/wiki/Half-precision_floating-point_format
- * [encoded, original number]
- */
-const testVector: [number[], number][] = [
-  [[0, 0], 0],
-  [[0, 1], 0.000000059604645],
-  [[0x03, 0xff], 0.000060975552],
-  [[4, 0], 0.00006103515625],
-  [[0x35, 0x55], 0.33325195],
-  [[0x3b, 0xff], 0.99951172],
-  [[0x3c, 0x00], 1],
-  [[0x3c, 0x01], 1.00097656],
-  [[0x7b, 0xff], 65504],
-  [[0x7c, 0x00], Number.POSITIVE_INFINITY],
-  [[0x7c, 0x01], Number.NaN],
-  [[0x80, 0x00], -0],
-  [[0xc0, 0x00], -2],
-  [[0xfc, 0x00], Number.NEGATIVE_INFINITY]
-]
-
-describe("Float.decodeFloat16()", () => {
-  testVector.forEach(([bytes, f]) => {
-    it(`decodes #${toHex(bytes)} as ${f}`, () => {
-      expect(
-        Either.map(Float.decodeFloat16(bytes), (x) => x.toExponential(7))
-      ).toEqual(Either.right(f.toExponential(7)))
-    })
-  })
-
-  it("fails for more than 2 input bytes", () => {
-    expect(Float.decodeFloat16([0, 0, 0])._tag).toBe("Left")
-  })
-
-  it("fails for less than 2 input bytes", () => {
-    expect(Float.decodeFloat16([0])._tag).toBe("Left")
-  })
-})
-
-describe("Float.encodeFloat16()", () => {
-  testVector.forEach(([bytes, f]) => {
-    it(`encodes ${f} as #${toHex(bytes)}`, () => {
-      expect(Float.encodeFloat16(f)).toEqual(bytes)
-    })
-  })
-})

package/src/internal/Float.ts

@@ -1,190 +0,0 @@
-import { Encoding, Either } from "effect"
-import { toHex } from "./Bytes.js"
-
-const SPECIAL_EXPONENT = 31
-const LARGEST_SIGNIFICAND = 1024
-const POW2 = [
-  0.00006103515625, // 2^-14
-  0.0001220703125, // 2^-13
-  0.000244140625, // 2^-12
-  0.00048828125, // 2^-11
-  0.0009765625, // 2^-10
-  0.001953125, // 2^-9
-  0.00390625, // 2^-8
-  0.0078125, // 2^-7
-  0.015625, // 2^-6
-  0.03125, // 2^-5
-  0.0625, // 2^-4
-  0.125, // 2^-3
-  0.25, // 2^-2
-  0.5, // 2^-1
-  1, // 2^0
-  2, // 2^1
-  4, // 2^2
-  8, // 2^3
-  16, // 2^4
-  32, // 2^5
-  64, // 2^6
-  128, // 2^7
-  256, // 2^8
-  512, // 2^9
-  1024, // 2^10
-  2048, // 2^11
-  4096, // 2^12
-  8192, // 2^13
-  16384, // 2^14
-  32768, // 2^15
-  65536 // 2^16
-]
-
-/**
- * Custom IEEE 754 Float16 implementation, not fast, but easy to audit
- * @param {number[]} bytes
- * @returns {number}
- */
-export function decodeFloat16(
-  bytes: number[]
-): Either.Either<number, Encoding.DecodeException> {
-  if (bytes.length != 2) {
-    return Either.left(
-      Encoding.DecodeException(
-        toHex(bytes),
-        `expected 2 bytes for IEEE 754 encoded Float16 number, got ${bytes.length}`
-      )
-    )
-  }
-
-  const sign = bytes[0] >> 7 ? -1 : 1
-  const exponent = (bytes[0] & 0b01111100) >> 2
-  const significand = (bytes[0] & 0b00000011) * 256 + bytes[1]
-
-  if (exponent === 0) {
-    if (significand == 0) {
-      return Either.right(sign < 0 ? -0 : 0)
-    } else {
-      return Either.right((sign * POW2[0] * significand) / LARGEST_SIGNIFICAND)
-    }
-  } else if (exponent === SPECIAL_EXPONENT) {
-    if (significand == 0) {
-      return Either.right(
-        sign < 0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY
-      )
-    } else {
-      return Either.right(Number.NaN)
-    }
-  } else {
-    return Either.right(
-      sign * POW2[exponent - 1] * (1.0 + significand / LARGEST_SIGNIFICAND)
-    )
-  }
-}
-
-/**
- * Custom IEEE 754 Float16 implementation, not fast, but easy to audit
- * @param f
- * @returns
- */
-export function encodeFloat16(f: number): number[] {
-  if (Object.is(f, 0)) {
-    return [0, 0]
-  } else if (Object.is(f, -0)) {
-    return [0x80, 0]
-  } else if (f === Number.NEGATIVE_INFINITY) {
-    return [0xfc, 0]
-  } else if (f === Number.POSITIVE_INFINITY) {
-    return [0x7c, 0]
-  } else if (Number.isNaN(f)) {
-    return [0x7c, 1]
-  } else {
-    const sign = Math.sign(f)
-    const signBit = sign > 0 ? 0 : 0b10000000
-    f = Math.abs(f)
-
-    if (f < POW2[0]) {
-      const significand = Math.floor((f / POW2[0]) * LARGEST_SIGNIFICAND)
-
-      return [signBit | (significand >> 8), significand & 0xff]
-    } else {
-      const unbiasedExponent = Math.floor(Math.log2(f))
-      const exponent = (unbiasedExponent + 15) & 0b00011111
-
-      const significand = Math.round(
-        (f / POW2[exponent - 1] - 1) * LARGEST_SIGNIFICAND
-      )
-
-      return [
-        signBit | (exponent << 2) | (significand >> 8),
-        significand & 0xff
-      ]
-    }
-  }
-}
-
-/**
- * Leverages the builtin DataView class to decode a IEEE 754 float32 number
- * @param {number[]} bytes
- * @returns
- */
-export function decodeFloat32(
-  bytes: number[]
-): Either.Either<number, Encoding.DecodeException> {
-  if (bytes.length != 4) {
-    return Either.left(
-      Encoding.DecodeException(
-        toHex(bytes),
-        `expected 4 bytes for IEEE 754 encoded Float32, got ${bytes.length} bytes`
-      )
-    )
-  }
-
-  const view = new DataView(Uint8Array.from(bytes).buffer)
-
-  return Either.right(view.getFloat32(0))
-}
-
-/**
- * Leverages the builtin DataView class to encode a floating point number using IEEE 754 float32 encoding
- * @param f
- * @returns
- */
-export function encodeFloat32(f: number): number[] {
-  const view = new DataView(new ArrayBuffer(4))
-
-  view.setFloat32(0, f)
-
-  return Array.from(new Uint8Array(view.buffer))
-}
-
-/**
- * Leverages the builtin DataView class to decode a IEEE 754 float64 number
- * @param bytes
- * @returns
- */
-export function decodeFloat64(
-  bytes: number[]
-): Either.Either<number, Encoding.DecodeException> {
-  if (bytes.length != 8) {
-    return Either.left(
-      Encoding.DecodeException(
-        `expected 8 bytes for IEEE 754 encoded Float64, got ${bytes.length} bytes`
-      )
-    )
-  }
-
-  const view = new DataView(Uint8Array.from(bytes).buffer)
-
-  return Either.right(view.getFloat64(0))
-}
-
-/**
- * Leverages the builtin DataView class to encode a floating point number using IEEE 754 float64 encoding
- * @param f
- * @returns
- */
-export function encodeFloat64(f: number): number[] {
-  const view = new DataView(new ArrayBuffer(8))
-
-  view.setFloat64(0, f)
-
-  return Array.from(new Uint8Array(view.buffer))
-}

package/src/internal/Utf8.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { Effect } from "effect"
-import * as Utf8 from "./Utf8.js"
-
-describe("Utf8.isValid", () => {
-  it("returns true for []", () => {
-    expect(Utf8.isValid([])).toBe(true)
-  })
-
-  it("returns true for [104, 101, 108, ...]", () => {
-    expect(
-      Utf8.isValid([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
-    ).toBe(true)
-  })
-
-  it("returns false for [256] (invalid byte)", () => {
-    expect(Utf8.isValid([256])).toBe(false)
-  })
-
-  it("returns false for [255, 255, 255, 255] (invalid utf-8 sequence)", () => {
-    expect(Utf8.isValid([255, 255, 255, 255])).toBe(false)
-  })
-
-  it("returns true for [0xf0, 0xb1, 0x8d, 0x90]", () => {
-    expect(Utf8.isValid([0xf0, 0xb1, 0x8d, 0x90])).toBe(true)
-  })
-})
-
-describe("Utf8.encode", () => {
-  it("returns [] for an empty string", () => {
-    expect(Array.from(Utf8.encode(""))).toEqual([])
-  })
-
-  it('returns [104, 101, 108, ...] for "hello world"', () => {
-    expect(Array.from(Utf8.encode("hello world"))).toEqual([
-      104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100
-    ])
-  })
-
-  it('returns [0xf0, 0xb1, 0x8d, 0x90] for "\ud884\udf50"', () => {
-    expect(Array.from(Utf8.encode("\ud884\udf50"))).toEqual([
-      0xf0, 0xb1, 0x8d, 0x90
-    ])
-  })
-})
-
-describe("Utf8.decode", () => {
-  it("returns an empty string for []", () => {
-    expect(Effect.runSync(Utf8.decode([]))).toBe("")
-  })
-
-  it('returns "hello world" for [104, 101, 108, ...]', () => {
-    expect(
-      Effect.runSync(
-        Utf8.decode([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
-      )
-    ).toBe("hello world")
-  })
-
-  it('returns "\ud884\udf50" for [0xf0, 0xb1, 0x8d, 0x90]', () => {
-    expect(Effect.runSync(Utf8.decode([0xf0, 0xb1, 0x8d, 0x90]))).toBe(
-      "\ud884\udf50"
-    )
-  })
-
-  it("fails for [255, 255, 255, 255] (invalid utf-8 sequence)", () => {
-    expect(() => Effect.runSync(Utf8.decode([255, 255, 255, 255]))).toThrow()
-  })
-})