@helios-lang/effect 0.1.4 → 0.1.6

package/types/internal/Float.d.ts

@@ -0,0 +1,38 @@
+import { Encoding, Either } from "effect";
+/**
+ * Custom IEEE 754 Float16 implementation, not fast, but easy to audit
+ * @param {number[]} bytes
+ * @returns {number}
+ */
+export declare function decodeFloat16(bytes: number[]): Either.Either<number, Encoding.DecodeException>;
+/**
+ * Custom IEEE 754 Float16 implementation, not fast, but easy to audit
+ * @param f
+ * @returns
+ */
+export declare function encodeFloat16(f: number): number[];
+/**
+ * Leverages the builtin DataView class to decode a IEEE 754 float32 number
+ * @param {number[]} bytes
+ * @returns
+ */
+export declare function decodeFloat32(bytes: number[]): Either.Either<number, Encoding.DecodeException>;
+/**
+ * Leverages the builtin DataView class to encode a floating point number using IEEE 754 float32 encoding
+ * @param f
+ * @returns
+ */
+export declare function encodeFloat32(f: number): number[];
+/**
+ * Leverages the builtin DataView class to decode a IEEE 754 float64 number
+ * @param bytes
+ * @returns
+ */
+export declare function decodeFloat64(bytes: number[]): Either.Either<number, Encoding.DecodeException>;
+/**
+ * Leverages the builtin DataView class to encode a floating point number using IEEE 754 float64 encoding
+ * @param f
+ * @returns
+ */
+export declare function encodeFloat64(f: number): number[];
+//# sourceMappingURL=Float.d.ts.map

package/types/internal/Float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Float.d.ts","sourceRoot":"","sources":["../../src/internal/Float.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAuCzC;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAiCjD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkCjD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAajD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EAAE,GACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAYjD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMjD"}

package/types/internal/Utf8.d.ts

@@ -0,0 +1,24 @@
+import { Effect, Encoding } from "effect";
+/**
+ * Decodes a list of uint8 bytes into a string using UTF-8 encoding.
+ * @example
+ * bytesToUtf8([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]) == "hello world"
+ * @param bytes
+ * @returns
+ */
+export declare function decode(bytes: string | number[] | Uint8Array): Effect.Effect<string, Encoding.DecodeException>;
+/**
+ * Encodes a string into a list of uint8 bytes using UTF-8 encoding.
+ * @example
+ * utf8ToBytes("hello world") == [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
+ * @param str
+ * @returns
+ */
+export declare function encode(str: string): Uint8Array;
+/**
+ * Tests if a uint8 array is valid utf8 encoding.
+ * @param {number[]} bytes
+ * @returns {boolean}
+ */
+export declare function isValid(bytes: string | number[] | Uint8Array): boolean;
+//# sourceMappingURL=Utf8.d.ts.map

package/types/internal/Utf8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utf8.d.ts","sourceRoot":"","sources":["../../src/internal/Utf8.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAGzC;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,GACpC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAUjD;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,GAAG,OAAO,CAiBtE"}

package/src/Bech32.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { Either } from "effect"
-import * as Bech32 from "./Bech32.js"
-import * as Utf8 from "./internal/Utf8.js"
-
-describe("Bech32.encode", () => {
-  it("fails with empty human readable part", () => {
-    expect(() => Bech32.encode("", [])).toThrow()
-  })
-
-  it('returns "foo1vehk7cnpwgry9h96" for "foobar" with "foo" human-readable-part', () => {
-    expect(Bech32.encode("foo", Utf8.encode("foobar"))).toBe(
-      "foo1vehk7cnpwgry9h96"
-    )
-  })
-
-  it('returns "addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld" for #70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539 with "addr_test" human-readable-part', () => {
-    expect(
-      Bech32.encode(
-        "addr_test",
-        "70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539"
-      )
-    ).toBe("addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld")
-  })
-})
-
-describe("Bech32.decode", () => {
-  it("fails for empty string", () => {
-    expect(Bech32.decode("")._tag).toBe("Left")
-  })
-
-  it("fails for random string", () => {
-    expect(Bech32.decode("balbalbal")._tag).toBe("Left")
-  })
-
-  it('returns #70a9508f015cfbcffc3d88ac4c1c934b5b82d2bb281d464672f6c49539 for "addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld"', () => {
-    expect(
-      Bech32.decode(
-        "addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld"
-      )
-    ).toEqual(
-      Either.right({
-        prefix: "addr_test",
-        bytes: [
-          0x70, 0xa9, 0x50, 0x8f, 0x01, 0x5c, 0xfb, 0xcf, 0xfc, 0x3d, 0x88,
-          0xac, 0x4c, 0x1c, 0x93, 0x4b, 0x5b, 0x82, 0xd2, 0xbb, 0x28, 0x1d,
-          0x46, 0x46, 0x72, 0xf6, 0xc4, 0x95, 0x39
-        ]
-      })
-    )
-  })
-
-  it("for script1agrmwv7exgffcdu27cn5xmnuhsh0p0ukuqpkhdgm800xksw7e2w", () => {
-    expect(
-      Bech32.decode(
-        "script1agrmwv7exgffcdu27cn5xmnuhsh0p0ukuqpkhdgm800xksw7e2w"
-      )
-    ).toEqual(
-      Either.right({
-        prefix: "script",
-        bytes: [
-          0xea, 0x07, 0xb7, 0x33, 0xd9, 0x32, 0x12, 0x9c, 0x37, 0x8a, 0xf6,
-          0x27, 0x43, 0x6e, 0x7c, 0xbc, 0x2e, 0xf0, 0xbf, 0x96, 0xe0, 0x03,
-          0x6b, 0xb5, 0x1b, 0x3b, 0xde, 0x6b
-        ]
-      })
-    )
-  })
-})
-
-const testVector: [string, boolean][] = [
-  ["", false],
-  ["blablabla", false],
-  ["addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld", true],
-  ["foo1vehk7cnpwgry9h96", true],
-  ["foo1vehk7cnpwgry9h97", false],
-  ["a12uel5l", true],
-  ["mm1crxm3i", false],
-  ["A1G7SGD8", false],
-  ["abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw", true],
-  ["?1ezyfcl", true],
-  ["addr_test1wz54prcptnaullpa3zkyc8ynfddc954m9qw5v3nj7mzf2wggs2uld", true]
-]
-
-describe("Bech32.isValid", () => {
-  testVector.forEach(([encoded, expected]) => {
-    it(`returns ${expected} for "${encoded}"`, () => {
-      expect(Bech32.isValid(encoded)).toBe(expected)
-    })
-  })
-})
-
-describe("Bech32.decode()/Bech32.encode() roundtrip", () => {
-  const roundtrip = (encoded: string): string => {
-    const decodeResult = Bech32.decode(encoded)
-    if (decodeResult._tag == "Left") {
-      // eslint-disable-next-line @typescript-eslint/only-throw-error
-      throw decodeResult.left
-    }
-
-    const { prefix, bytes } = decodeResult.right
-
-    return Bech32.encode(prefix, bytes)
-  }
-
-  testVector.forEach(([encoded, expected]) => {
-    if (expected) {
-      it(`ok for "${encoded}"`, () => {
-        expect(roundtrip(encoded)).toBe(encoded)
-      })
-    } else {
-      it(`fails for "${encoded}"`, () => {
-        expect(() => roundtrip(encoded)).toThrow()
-      })
-    }
-  })
-})

package/src/Bech32.ts

@@ -1,198 +0,0 @@
-import { Either, Encoding } from "effect"
-import * as Base32 from "./internal/Base32.js"
-
-/**
- * Bech32 base32 alphabet
- */
-const ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l" as const
-
-const PAYLOAD_CODEC = /* @__PURE__ */ Base32.make({
-  alphabet: ALPHABET
-})
-
-/**
- * Decomposes a Bech32 checksummed string (eg. a Cardano address), and returns the human readable part and the original bytes
- * Throws an error if checksum is invalid.
- * @param encoded
- * @returns
- * `prefix` part is the human-readable part, `bytes` part is a list containing the underlying bytes.
- */
-export function decode(
-  encoded: string
-): Either.Either<
-  { prefix: string; bytes: number[] },
-  Encoding.DecodeException
-> {
-  const [prefix, payload] = split(encoded)
-
-  if (!verifySplit(prefix, payload)) {
-    return Either.left(
-      Encoding.DecodeException(encoded, "invalid bech32 encoding")
-    )
-  }
-
-  const bytes = PAYLOAD_CODEC.decode(payload.slice(0, payload.length - 6))
-
-  if (bytes._tag == "Left") {
-    return Either.left(bytes.left)
-  }
-
-  return Either.right({ prefix, bytes: Array.from(bytes.right) })
-}
-
-/**
- * Creates a Bech32 checksummed string (eg. used to represent Cardano addresses).
- * @param prefix
- * human-readable part (eg. "addr")
- * @param payload
- * Hex encoded or a list of uint8 bytes
- * @returns
- * @throws
- * If prefix is empty
- */
-export function encode(
-  prefix: string,
-  payload: string | number[] | Uint8Array
-): string {
-  if (prefix.length == 0) {
-    throw new Error("human-readable-part must have non-zero length")
-  }
-
-  payload = PAYLOAD_CODEC.encodeRaw(payload)
-
-  const chkSum = calcChecksum(prefix, payload)
-
-  return (
-    prefix +
-    "1" +
-    payload
-      .concat(chkSum)
-      .map((i) => ALPHABET[i])
-      .join("")
-  )
-}
-
-/**
- * Verifies a Bech32 checksum. Prefix must be checked externally
- * @param {string} encoded
- * @returns {boolean}
- */
-export function isValid(encoded: string): boolean {
-  const [prefix, payload] = split(encoded)
-
-  return verifySplit(prefix, payload)
-}
-
-/**
- * Expand human readable prefix of the bech32 encoding so it can be used in the checkSum.
- * @param prefix
- * @returns
- */
-function expandPrefix(prefix: string): number[] {
-  const bytes = []
-  for (const c of prefix) {
-    bytes.push(c.charCodeAt(0) >> 5)
-  }
-
-  bytes.push(0)
-
-  for (const c of prefix) {
-    bytes.push(c.charCodeAt(0) & 31)
-  }
-
-  return bytes
-}
-
-/**
- * Split bech32 encoded string into human-readable-part and payload part.
- * @param encoded
- * @returns
- * First item is human-readable-part, second part is payload part
- */
-function split(encoded: string): [string, string] {
-  const i = encoded.indexOf("1")
-
-  if (i == -1 || i == 0) {
-    return ["", encoded]
-  } else {
-    return [encoded.slice(0, i), encoded.slice(i + 1)]
-  }
-}
-
-/**
- * Used as part of the bech32 checksum.
- * @param bytes
- * @returns
- */
-function polymod(bytes: number[]): number {
-  const GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
-
-  let chk = 1
-  for (const b of bytes) {
-    const c = chk >> 25
-    chk = ((chk & 0x1fffffff) << 5) ^ b
-
-    for (let i = 0; i < 5; i++) {
-      if (((c >> i) & 1) != 0) {
-        chk ^= GEN[i]
-      }
-    }
-  }
-
-  return chk
-}
-
-/**
- * Generate the bech32 checksum.
- * @param prefix
- * @param payload
- * numbers between 0 and 32
- * @returns
- * 6 numbers between 0 and 32
- */
-function calcChecksum(prefix: string, payload: number[]): number[] {
-  const bytes = expandPrefix(prefix).concat(payload)
-
-  const chk = polymod(bytes.concat([0, 0, 0, 0, 0, 0])) ^ 1
-
-  const chkSum: number[] = []
-  for (let i = 0; i < 6; i++) {
-    chkSum.push((chk >> (5 * (5 - i))) & 31)
-  }
-
-  return chkSum
-}
-
-/**
- * @param prefix
- * @param payload
- * @returns
- */
-function verifySplit(prefix: string, payload: string): boolean {
-  if (prefix.length == 0) {
-    return false
-  }
-
-  const data: number[] = []
-
-  for (const c of payload) {
-    const j = ALPHABET.indexOf(c)
-    if (j == -1) {
-      return false
-    }
-
-    data.push(j)
-  }
-
-  const chkSumA = data.slice(data.length - 6)
-
-  const chkSumB = calcChecksum(prefix, data.slice(0, data.length - 6))
-
-  for (let j = 0; j < 6; j++) {
-    if (chkSumA[j] != chkSumB[j]) {
-      return false
-    }
-  }
-
-  return true
-}