@helios-lang/effect 0.1.5 → 0.1.7

package/src/Ledger/Address.ts

@@ -1,248 +0,0 @@
-import { 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 Credential from "./Credential.js"
-import { IsMainnet } from "./IsMainnet.js"
-import * as PubKeyHash from "./PubKeyHash.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 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

@@ -1,90 +0,0 @@
-import { Encoding, Option, Schema } from "effect"
-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 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

@@ -1,164 +0,0 @@
-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 (const 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) => {
-      const assets: Record<string, bigint> = {}
-
-      for (const [policy, inner] of outer) {
-        for (const [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 (const [policy, inner] of otherAssets) {
-        if (policy._tag == "None") {
-          return yield* new Cbor.DecodeError(
-            stream,
-            "unexpected ADA assetclass in encoded non-ADA assets"
-          )
-        }
-
-        for (const [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

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

@@ -1,36 +0,0 @@
-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/IsMainnet.ts

@@ -1,6 +0,0 @@
-import { Context } from "effect"
-
-export class IsMainnet extends Context.Tag("IS_MAINNET")<
-  IsMainnet,
-  boolean
->() {}

package/src/Ledger/MintingPolicy.ts

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

package/src/Ledger/PubKeyHash.ts

@@ -1,36 +0,0 @@
-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(pkh: string): pkh is PubKeyHash {
-  return /^[0-9a-fA-F]+$/.test(pkh) && pkh.length == 56
-}
-
-export const PubKeyHash = Schema.String.pipe(
-  Schema.filter((pkh: string) => isValid(pkh) || "Invalid Cardano PubKeyHash"),
-  Schema.brand("PubKeyHash")
-)
-
-export type PubKeyHash = Schema.Schema.Type<typeof PubKeyHash>
-
-export function make(bytes: Bytes.BytesLike) {
-  return Schema.decode(PubKeyHash)(Bytes.toHex(bytes))
-}
-
-export const FromUplcData = Schema.transform(Data.ByteArray, PubKeyHash, {
-  strict: true,
-  decode: Encoding.encodeHex,
-  encode: (s) => Effect.runSync(Encoding.decodeHex(s))
-})
-
-export const decode = (bytes: Bytes.BytesLike): DecodeEffect<PubKeyHash> =>
-  decodeBytes(bytes).pipe(
-    Effect.map((bytes) => new Uint8Array(bytes)),
-    Effect.map(Encoding.encodeHex),
-    Effect.map(Schema.decodeSync(PubKeyHash))
-  )
-
-export function encode(pkh: PubKeyHash): number[] {
-  return encodeBytes(pkh)
-}

package/src/Ledger/TxId.ts

@@ -1,31 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Bytes from "../internal/Bytes.js"
-import * as Cbor from "../Cbor.js"
-
-export function isValid(txId: string): txId is TxId {
-  return txId.length == 64 && /^[0-9a-fA-F]+$/.test(txId)
-}
-
-export const TxId = Schema.String.pipe(
-  Schema.filter((id: string) => isValid(id) || "Invalid Cardano TxId"),
-  Schema.brand("TxId")
-)
-
-export type TxId = Schema.Schema.Type<typeof TxId>
-
-export function make(txId: Bytes.BytesLike) {
-  return Schema.decode(TxId)(Bytes.toHex(txId))
-}
-
-export const decode = (bytes: Bytes.BytesLike): Cbor.DecodeEffect<TxId> =>
-  Cbor.decodeBytes(bytes).pipe(
-    Effect.flatMap(make),
-    Effect.catchTag(
-      "ParseError",
-      (e) => new Cbor.DecodeError(Bytes.makeStream(bytes), e.message)
-    )
-  )
-
-export function encode(txId: TxId): number[] {
-  return Cbor.encodeBytes(txId)
-}