@helios-lang/effect 0.1.1 → 0.1.3

package/package.json

@@ -1,21 +1,17 @@
 {
   "name": "@helios-lang/effect",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",
+    "./Ledger": "./dist/Ledger/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 +28,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,252 @@
+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
+): Address {
+  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 Cbor.DecodeError(
+            Bytes.makeStream(bytes),
+            `invalid Shelley Address header ${head}`
+          )
+        )
+    }
+  })
+
+export const decode = (bytes: Bytes.BytesLike): Cbor.DecodeEffect<Address> =>
+  decodeInternal(bytes).pipe(
+    Effect.map(({ isMainnet, spendingCredential, stakingCredential }) =>
+      make(isMainnet, spendingCredential, stakingCredential)
+    ),
+    Effect.catchTag(
+      "ParseError",
+      (e) => new Cbor.DecodeError(Bytes.makeStream(bytes), e.message)
+    ),
+    Effect.catchTag(
+      "DecodeException",
+      (e) =>
+        new Cbor.DecodeError(
+          Bytes.makeStream(bytes),
+          `bech32 decoding failed (${e.message})`
+        )
+    )
+  )
+
+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/AssetClass.ts

@@ -0,0 +1,96 @@
+import { Encoding, Option, Schema } from "effect"
+//import * as Bech32 from "../Bech32.js"
+import * as Bytes from "../internal/Bytes.js"
+import { Data } from "../Uplc"
+import * as MintingPolicy from "./MintingPolicy.js"
+import * as ValidatorHash from "./ValidatorHash.js"
+
+export function isValid(assetClass: string): assetClass is AssetClass {
+  const n = assetClass.length
+  return (
+    /^[0-9a-fA-F]+$/.test(assetClass) &&
+    n < 120 &&
+    (n == 0 || (n >= 56 && n % 2 == 0))
+  )
+}
+
+export const AssetClass = Schema.transform(
+  Schema.String,
+  Schema.String.pipe(
+    Schema.filter((ac: string) => isValid(ac) || "Invalid Cardano AssetClass"),
+    Schema.brand("AssetClass")
+  ),
+  {
+    strict: false,
+    decode: (s) => s.split(".").join(""),
+    encode: (s) => s
+  }
+)
+
+export type AssetClass = Schema.Schema.Type<typeof AssetClass>
+
+export const ADA = "" as AssetClass
+
+export function make(
+  policy: MintingPolicy.MintingPolicy,
+  tokenName: Bytes.BytesLike
+) {
+  if (policy._tag == "None") {
+    return ADA
+  } else {
+    return policy.value + Encoding.encodeHex(Bytes.toUint8Array(tokenName))
+  }
+}
+
+export const FromUplcData = Schema.transform(
+  Data.EnumVariant(0, {
+    policy: MintingPolicy.FromUplcData,
+    tokenName: Data.ByteArray
+  }),
+  AssetClass,
+  {
+    strict: true,
+    decode: ({ policy, tokenName }) => {
+      if (policy._tag == "None") {
+        return ADA
+      } else {
+        return policy.value + Encoding.encodeHex(tokenName)
+      }
+    },
+    encode: (assetClass) => {
+      return {
+        policy: policy(assetClass),
+        tokenName: Bytes.toUint8Array(tokenName(assetClass))
+      }
+    }
+  }
+)
+
+export function fingerprint(assetClass: string): string {
+  throw new Error("not yet implemented (need blake2b hashing function)")
+  //return Bech32.encode("asset", )
+}
+
+export function pretty(assetClass: string): string {
+  if (assetClass.length == 0) {
+    return "."
+  } else {
+    return assetClass.slice(0, 56) + "." + assetClass.slice(56)
+  }
+}
+
+export function policy(assetClass: string): MintingPolicy.MintingPolicy {
+  if (assetClass.length == 0) {
+    return Option.none()
+  } else {
+    return Option.some(assetClass.slice(0, 56) as ValidatorHash.ValidatorHash)
+  }
+}
+
+export function tokenName(assetClass: string): string {
+  if (assetClass.length == 0) {
+    return ""
+  } else {
+    return assetClass.slice(56)
+  }
+}

package/src/Ledger/Assets.ts

@@ -0,0 +1,164 @@
+import { Effect, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import * as Cbor from "../Cbor.js"
+import { Data } from "../Uplc"
+import * as AssetClass from "./AssetClass.js"
+import * as MintingPolicy from "./MintingPolicy.js"
+
+export const Assets = Schema.Record({
+  key: Schema.String, // can sadly not use AssetClass.AssetClass here
+  value: Schema.BigIntFromSelf
+}).pipe(
+  Schema.filter((assets) => {
+    for (let key in assets) {
+      if (!AssetClass.isValid(key)) {
+        return `Invalid AssetClass ${key}`
+      }
+    }
+
+    return true
+  })
+)
+
+export type Assets = Schema.Schema.Type<typeof Assets>
+
+export const FromUplcData = Schema.transform(
+  Data.PairArray(
+    MintingPolicy.FromUplcData,
+    Data.PairArray(Data.Hex, Data.BigInt)
+  ),
+  Assets,
+  {
+    strict: true,
+    decode: (outer) => {
+      let assets: Record<string, bigint> = {}
+
+      for (let [policy, inner] of outer) {
+        for (let [tokenName, quantity] of inner) {
+          assets[AssetClass.make(policy, tokenName)] = quantity
+        }
+      }
+
+      return assets as Assets
+    },
+    encode: (assets) => {
+      const outer = nestedRecords(assets)
+
+      return Object.entries(outer).map(
+        ([policy, inner]) =>
+          [
+            Effect.runSync(MintingPolicy.make(policy)),
+            Object.entries(inner)
+          ] as const
+      )
+    }
+  }
+)
+
+function nestedRecords(assets: Assets): Record<string, Record<string, bigint>> {
+  const outer: Record<string, Record<string, bigint>> = {}
+
+  Object.entries(assets).forEach(([assetClass, quantity]) => {
+    if (assetClass.length == 0) {
+      outer[assetClass] = { "": quantity }
+    } else {
+      const policy = assetClass.slice(0, 56)
+      const tokenName = assetClass.slice(56)
+
+      if (policy in outer) {
+        outer[policy] = {
+          ...outer[policy],
+          [tokenName]: quantity
+        }
+      } else {
+        outer[policy] = {
+          [tokenName]: quantity
+        }
+      }
+    }
+  })
+
+  return outer
+}
+
+export const decode = (bytes: Bytes.BytesLike): Cbor.DecodeEffect<Assets> =>
+  Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes)
+
+    if (yield* Cbor.isTuple(bytes)) {
+      const [lovelace, otherAssets] = yield* Cbor.decodeTuple([
+        Cbor.decodeInt,
+        Cbor.decodeMap(
+          MintingPolicy.decode,
+          Cbor.decodeMap(Cbor.decodeBytes, Cbor.decodeInt)
+        )
+      ])(stream)
+
+      const assets: Record<string, bigint> = {}
+
+      if (lovelace != 0n) {
+        assets[AssetClass.ADA] = lovelace
+      }
+
+      for (let [policy, inner] of otherAssets) {
+        if (policy._tag == "None") {
+          return yield* new Cbor.DecodeError(
+            stream,
+            "unexpected ADA assetclass in encoded non-ADA assets"
+          )
+        }
+
+        for (let [tokenName, quantity] of inner) {
+          const assetClass = AssetClass.make(policy, tokenName)
+
+          assets[assetClass] = quantity
+        }
+      }
+
+      return assets as Assets
+    } else {
+      return { [AssetClass.ADA]: yield* Cbor.decodeInt(stream) }
+    }
+  })
+
+export function encode(assets: Assets): number[] {
+  const acs = nonAdaAssetClasses(assets)
+
+  if (acs.length == 0) {
+    return Cbor.encodeInt(lovelace(assets))
+  } else {
+    const obj = nestedRecords(assets)
+    if (AssetClass.ADA in obj) {
+      delete obj[AssetClass.ADA]
+    }
+
+    return Cbor.encodeTuple([
+      Cbor.encodeInt(lovelace(assets)),
+      Cbor.encodeMap(
+        Object.entries(obj).map(([mph, tokens]) => {
+          return [
+            Cbor.encodeBytes(mph),
+            Cbor.encodeMap(
+              Object.entries(tokens).map(([tokenName, qty]) => [
+                Cbor.encodeBytes(tokenName),
+                Cbor.encodeInt(qty)
+              ])
+            )
+          ]
+        })
+      )
+    ])
+  }
+}
+
+export function allAssetClasses(assets: Assets): AssetClass.AssetClass[] {
+  return Object.keys(assets) as AssetClass.AssetClass[]
+}
+
+export function nonAdaAssetClasses(assets: Assets): AssetClass.AssetClass[] {
+  return allAssetClasses(assets).filter((ac) => ac != AssetClass.ADA)
+}
+
+export function lovelace(assets: Assets): bigint {
+  return assets[AssetClass.ADA] ?? 0n
+}

package/src/Ledger/Credential.ts

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

package/src/Ledger/MintingPolicy.ts

@@ -0,0 +1,57 @@
+import { Effect, Encoding, Option, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import * as Cbor from "../Cbor.js"
+import { Data } from "../Uplc"
+import * as ValidatorHash from "./ValidatorHash.js"
+
+// None is used for ADA
+export const MintingPolicy = Schema.Option(ValidatorHash.ValidatorHash)
+
+export type MintingPolicy = Schema.Schema.Type<typeof MintingPolicy>
+
+export const FromUplcData = Schema.transform(Data.ByteArray, MintingPolicy, {
+  strict: true,
+  decode: (bs) => {
+    if (bs.length == 0) {
+      return Option.none()
+    } else {
+      return Option.some(Encoding.encodeHex(bs))
+    }
+  },
+  encode: (opt) => {
+    if (opt._tag == "None") {
+      return new Uint8Array()
+    } else {
+      return Effect.runSync(Encoding.decodeHex(opt.value))
+    }
+  }
+})
+
+export function make(policy: Bytes.BytesLike) {
+  const p = Bytes.toHex(policy)
+
+  if (p.length == 0) {
+    return Effect.succeed(Option.none())
+  } else {
+    return ValidatorHash.make(p).pipe(Effect.map(Option.some))
+  }
+}
+
+export const decode = (
+  bytes: Bytes.BytesLike
+): Cbor.DecodeEffect<MintingPolicy> =>
+  Cbor.decodeBytes(bytes).pipe(
+    Effect.flatMap(make),
+    Effect.catchTag(
+      "ParseError",
+      (e) => new Cbor.DecodeError(Bytes.makeStream(bytes), e.message)
+    )
+  )
+
+export function encode(policy: MintingPolicy): number[] {
+  if (policy._tag == "None") {
+    return Cbor.encodeBytes([])
+  } else {
+    return Cbor.encodeBytes(policy.value)
+  }
+}