@helios-lang/effect 0.1.0

package/src/Bech32.test.ts

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,198 @@
+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
+}