@helios-lang/effect 0.1.2 → 0.1.4

package/src/Ledger/TxOutputId.ts

@@ -0,0 +1,63 @@
+import { Effect, Schema } from "effect"
+import * as Bytes from "../internal/Bytes.js"
+import * as Cbor from "../Cbor.js"
+import * as TxId from "./TxId.js"
+
+export function isValid(txOutputId: string): txOutputId is TxOutputId {
+  if (txOutputId.length < 65) {
+    return false
+  }
+
+  const txId = txOutputId.slice(0, 64)
+
+  const utxoIdx = parseInt(txOutputId.slice(64))
+
+  if (utxoIdx.toString() != txOutputId.slice(64)) {
+    return false
+  }
+
+  return /^[0-9a-fA-F]+$/.test(txId)
+}
+
+export const TxOutputId = Schema.transform(
+  Schema.String,
+  Schema.String.pipe(
+    Schema.filter((id: string) => isValid(id) || "Invalid Cardano TxOutputId"),
+    Schema.brand("TxOutputId")
+  ),
+  {
+    strict: false,
+    decode: (s) => s.split("#").join(""),
+    encode: (s) => s
+  }
+)
+
+export type TxOutputId = Schema.Schema.Type<typeof TxOutputId>
+
+export function make(txId: TxId.TxId, utxoIdx: number | bigint): TxOutputId {
+  return (txId + utxoIdx.toString()) as TxOutputId
+}
+
+export const decode = (bytes: Bytes.BytesLike): Cbor.DecodeEffect<TxOutputId> =>
+  Cbor.decodeTuple([TxId.decode, Cbor.decodeInt])(bytes).pipe(
+    Effect.map(([txId, utxoIdx]) => make(txId, utxoIdx))
+  )
+
+export function encode(txOutputId: TxOutputId): number[] {
+  return Cbor.encodeTuple([
+    TxId.encode(txId(txOutputId)),
+    Cbor.encodeInt(utxoIdx(txOutputId))
+  ])
+}
+
+export function pretty(txOutputId: TxOutputId): string {
+  return txId(txOutputId) + "#" + utxoIdx(txOutputId).toString()
+}
+
+export function txId(txOutputId: TxOutputId): TxId.TxId {
+  return txOutputId.slice(0, 64) as TxId.TxId
+}
+
+export function utxoIdx(txOutputId: TxOutputId): number {
+  return parseInt(txOutputId.slice(64))
+}

package/src/Ledger/ValidatorHash.ts

@@ -1,7 +1,7 @@
 import { Effect, Encoding, Schema } from "effect"
 import * as Bytes from "../internal/Bytes.js"
 import { decodeBytes, DecodeEffect, encodeBytes } from "../Cbor.js"
-import { Data } from "../Uplc/index.js"
+import { Data } from "../Uplc"
 
 export function isValid(vh: string): boolean {
   return /^[0-9a-fA-F]+$/.test(vh) && vh.length == 56

package/src/Ledger/index.ts

@@ -1,4 +1,14 @@
 export * as Address from "./Address.js"
+export * as AssetClass from "./AssetClass.js"
+export * as Assets from "./Assets.js"
 export * as Credential from "./Credential.js"
+export * as DatumHash from "./DatumHash.js"
+export { IsMainnet } from "./IsMainnet.js"
+export * as MintingPolicy from "./MintingPolicy.js"
 export * as PubKeyHash from "./PubKeyHash.js"
+export * as TxId from "./TxId.js"
+export * as TxInput from "./TxInput.js"
+export * as TxOutput from "./TxOutput.js"
+export * as TxOutputDatum from "./TxOutputDatum.js"
+export * as TxOutputId from "./TxOutputId.js"
 export * as ValidatorHash from "./ValidatorHash.js"

package/src/Uplc/Data.ts

@@ -427,6 +427,31 @@ const Array$ = <ItemType>(
 
 export { Array$ as Array }
 
+export const PairArray = <KeyType, ValueType>(
+  keySchema: Schema.Schema<KeyType, Schema.Schema.Encoded<typeof Data>>,
+  valueSchema: Schema.Schema<ValueType, Schema.Schema.Encoded<typeof Data>>
+) =>
+  Schema.transformOrFail(
+    Data,
+    Schema.Array(Schema.Tuple(keySchema, valueSchema)),
+    {
+      strict: true,
+      decode: (data) => {
+        if ("map" in data) {
+          return ParseResult.succeed(
+            data.map.map(({ k, v }) => [k, v] as const)
+          )
+        } else {
+          return ParseResult.fail(
+            new ParseResult.Unexpected(data, "expected MapData")
+          )
+        }
+      },
+      encode: (pairs) =>
+        ParseResult.succeed({ map: pairs.map(([k, v]) => ({ k, v })) })
+    }
+  )
+
 export const Struct = <
   FieldTypes extends { [fieldName: string]: Schema.Schema<any, Data> }
 >(
@@ -617,7 +642,9 @@ export const Enum = <
       encode: (value) => {
         const variantName = value._tag
 
-        const tag = Object.keys(variants).indexOf(variantName as unknown as string)
+        const tag = Object.keys(variants).indexOf(
+          variantName as unknown as string
+        )
 
         return ParseResult.succeed({
           constructor: tag,