@helios-lang/contract-utils 0.2.9 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@helios-lang/contract-utils",
-    "version": "0.2.9",
+    "version": "0.2.10",
     "description": "Convenience and type-safety utilities for using Helios validators from within Typescript",
     "main": "src/index.js",
     "types": "types/index.d.ts",
@@ -39,7 +39,7 @@
         "@helios-lang/codec-utils": "^0.1.30",
         "@helios-lang/compiler-utils": "^0.1.25",
         "@helios-lang/ledger": "^0.2.7",
-        "@helios-lang/type-utils": "^0.1.19",
+        "@helios-lang/type-utils": "^0.1.20",
         "@helios-lang/uplc": "^0.1.31"
     }
 }

package/src/cast/Cast.js

@@ -17,7 +17,7 @@ import {
     ValidatorHash,
     Value
 } from "@helios-lang/ledger"
-import { None } from "@helios-lang/type-utils"
+import { None, expectSome } from "@helios-lang/type-utils"
 import {
     ByteArrayData,
     ConstrData,
@@ -102,120 +102,154 @@ export class Cast {
 /**
  * @param {TypeSchema} schema
  * @param {any} x
+ * @param {Record<string, TypeSchema>} defs
  * @returns {UplcData}
  */
-function schemaToUplc(schema, x) {
-    if ("primitiveType" in schema) {
-        switch (schema.primitiveType) {
-            case "Address":
-                return Address.new(x).toUplcData()
-            case "Any":
-                return new IntData(0n)
-            case "AssetClass":
-                return AssetClass.new(x).toUplcData()
-            case "Bool":
-                return encodeBoolData(x)
-            case "ByteArray":
-                return new ByteArrayData(x)
-            case "Credential":
-            case "PaymentCredential":
-                return SpendingCredential.new(x).toUplcData()
-            case "Data":
-                return x
-            case "DatumHash":
-                return DatumHash.new(x).toUplcData()
-            case "DCert":
-                return x.toUplcData()
-            case "Duration":
-            case "Int":
-                return new IntData(x)
-            case "MintingPolicyHash":
-                return MintingPolicyHash.new(x).toUplcData()
-            case "PubKeyHash":
-                return PubKeyHash.new(x).toUplcData()
-            case "Real":
-                return encodeRealData(x)
-            case "ScriptHash":
-                return ScriptHash.new(x).toUplcData()
-            case "StakingCredential":
-                return StakingCredential.new(x).toUplcData()
-            case "StakingHash":
-                return StakingHash.new(x).toUplcData()
-            case "String":
-                return new ByteArrayData(encodeUtf8(x))
-            case "Time":
-                return new IntData(x)
-            case "TimeRange":
-                return TimeRange.new(x).toUplcData()
-            case "TxId":
-                return TxId.new(x).toUplcData()
-            case "TxOutputDatum":
-                return x
-                    ? TxOutputDatum.new(x)?.toUplcData() ??
-                          new ConstrData(0, [])
-                    : new ConstrData(0, [])
-            case "TxOutputId":
-                return TxOutputId.new(x).toUplcData()
-            case "ValidatorHash":
-                return ValidatorHash.new(x).toUplcData()
-            case "Value":
-                return Value.new(x).toUplcData()
-            default:
-                throw new Error(
-                    `not yet implemented for ${schema.primitiveType}`
-                )
+function schemaToUplc(schema, x, defs = {}) {
+    const kind = schema.kind
+
+    switch (kind) {
+        case "reference": {
+            const def = expectSome(defs[schema.id])
+            return schemaToUplc(def, x, defs)
         }
-    } else if ("listItemType" in schema) {
-        return new ListData(x.map((x) => schemaToUplc(schema.listItemType, x)))
-    } else if ("mapKeyType" in schema) {
-        const entries = x instanceof Map ? x.entries() : x
-        return new MapData(
-            entries.map(([k, v]) => [
-                schemaToUplc(schema.mapKeyType, k),
-                schemaToUplc(schema.mapValueType, v)
-            ])
-        )
-    } else if ("optionSomeType" in schema) {
-        return encodeOptionData(
-            x ? schemaToUplc(schema.optionSomeType, x) : None
-        )
-    } else if ("structFieldTypes" in schema) {
-        // TODO: Cip-68 support
-        if (schema.structFieldTypes.length == 1) {
-            return schemaToUplc(
-                schema.structFieldTypes[0].type,
-                x[schema.structFieldTypes[0].name]
-            )
-        } else {
+        case "internal": {
+            const name = schema.name
+
+            switch (name) {
+                case "Address":
+                    return Address.new(x).toUplcData()
+                case "Any":
+                    return new IntData(0n)
+                case "AssetClass":
+                    return AssetClass.new(x).toUplcData()
+                case "Bool":
+                    return encodeBoolData(x)
+                case "ByteArray":
+                    return new ByteArrayData(x)
+                case "Credential":
+                case "SpendingCredential":
+                    return SpendingCredential.new(x).toUplcData()
+                case "Data":
+                    return x
+                case "DatumHash":
+                    return DatumHash.new(x).toUplcData()
+                case "DCert":
+                    return x.toUplcData()
+                case "Duration":
+                case "Int":
+                    return new IntData(x)
+                case "MintingPolicyHash":
+                    return MintingPolicyHash.new(x).toUplcData()
+                case "PubKeyHash":
+                    return PubKeyHash.new(x).toUplcData()
+                case "Real":
+                    return encodeRealData(x)
+                case "ScriptHash":
+                    return ScriptHash.new(x).toUplcData()
+                case "StakingCredential":
+                    return StakingCredential.new(x).toUplcData()
+                case "StakingHash":
+                    return StakingHash.new(x).toUplcData()
+                case "String":
+                    return new ByteArrayData(encodeUtf8(x))
+                case "Time":
+                    return new IntData(x)
+                case "TimeRange":
+                    return TimeRange.new(x).toUplcData()
+                case "TxId":
+                    return TxId.new(x).toUplcData()
+                case "TxOutputDatum":
+                    return x
+                        ? TxOutputDatum.new(x)?.toUplcData() ??
+                              new ConstrData(0, [])
+                        : new ConstrData(0, [])
+                case "TxOutputId":
+                    return TxOutputId.new(x).toUplcData()
+                case "ValidatorHash":
+                    return ValidatorHash.new(x).toUplcData()
+                case "Value":
+                    return Value.new(x).toUplcData()
+                default:
+                    throw new Error(`not yet implemented for ${name}`)
+            }
+        }
+        case "list":
             return new ListData(
-                schema.structFieldTypes.map(({ name, type }) =>
-                    schemaToUplc(type, x[name])
-                )
+                x.map((x) => schemaToUplc(schema.itemType, x, defs))
+            )
+        case "map": {
+            const entries = x instanceof Map ? x.entries() : x
+            return new MapData(
+                entries.map(([k, v]) => [
+                    schemaToUplc(schema.keyType, k, defs),
+                    schemaToUplc(schema.valueType, v, defs)
+                ])
             )
         }
-    } else if ("enumVariantTypes") {
-        const variantName = Object.keys(x)[0]
-        const variantFields = Object.values(x)[0]
-        const tag = schema.enumVariantTypes.findIndex(
-            (v) => v.name == variantName
-        )
-
-        if (tag == -1) {
-            throw new Error(
-                `invalid variant ${variantName} (expected: ${schema.enumVariantTypes.map((v) => v.name).join(", ")})`
+        case "option":
+            return encodeOptionData(
+                x ? schemaToUplc(schema.someType, x, defs) : None
             )
+        case "struct": {
+            defs[schema.id] = schema
+            switch (schema.format) {
+                case "singleton":
+                    return schemaToUplc(
+                        schema.fieldTypes[0].type,
+                        x[schema.fieldTypes[0].name],
+                        defs
+                    )
+                case "list":
+                    return new ListData(
+                        schema.fieldTypes.map(({ name, type }) =>
+                            schemaToUplc(type, x[name])
+                        )
+                    )
+                case "map":
+                    return new MapData(
+                        schema.fieldTypes.map(({ name, type }) => [
+                            new ByteArrayData(encodeUtf8(name)),
+                            schemaToUplc(type, x[name], defs)
+                        ])
+                    )
+                default:
+                    throw new Error(
+                        `unhandled struct format '${schema.format}'`
+                    )
+            }
         }
+        case "enum": {
+            defs[schema.id] = schema
+            const variantName = Object.keys(x)[0]
+            const variantFields = Object.values(x)[0]
+            const tag = schema.variantTypes.findIndex(
+                (v) => v.name == variantName
+            )
+
+            if (tag == -1) {
+                throw new Error(
+                    `invalid variant ${variantName} (expected: ${schema.variantTypes.map((v) => v.name).join(", ")})`
+                )
+            }
 
-        return new ConstrData(
-            tag,
-            schema.enumVariantTypes[tag].fieldTypes.map((f) =>
-                schemaToUplc(f.type, variantFields[f.name])
+            return new ConstrData(
+                tag,
+                schema.variantTypes[tag].fieldTypes.map((f) =>
+                    schemaToUplc(f.type, variantFields[f.name], defs)
+                )
             )
-        )
-    } else {
-        throw new Error(
-            `not yet implemented for ${JSON.stringify(schema, undefined, 4)}`
-        )
+        }
+        case "variant":
+            defs[schema.id] = schema
+            return new ConstrData(
+                schema.tag,
+                schema.fieldTypes.map(({ name, type }) =>
+                    schemaToUplc(type, x[name])
+                )
+            )
+        default:
+            throw new Error(`unhandled schema kind '${kind}'`)
     }
 }
 
@@ -224,137 +258,198 @@ function schemaToUplc(schema, x) {
  * @param {TypeSchema} schema
  * @param {UplcData} data
  * @param {CastConfig} config
+ * @param {Record<string, TypeSchema>} defs
  * @returns {any}
  */
-function uplcToSchema(schema, data, config) {
-    if ("primitiveType" in schema) {
-        switch (schema.primitiveType) {
-            case "Address":
-                return Address.fromUplcData(config.isMainnet, data)
-            case "Any":
-                // TODO: should this throw an error?
-                return null
-            case "Bool":
-                return decodeBoolData(data, true)
-            case "ByteArray":
-                return ByteArrayData.expect(data).bytes
-            case "SpendingCredential":
-            case "Credential":
-                return SpendingCredential.fromUplcData(data)
-            case "Data":
-                return data
-            case "DCert":
-                throw new Error(
-                    "can't convert UplcData back into DCert (significant loss of information)"
-                )
-            case "Duration":
-            case "Int":
-                return IntData.expect(data).value
-            case "MintingPolicyHash":
-                return MintingPolicyHash.fromUplcData(data)
-            case "PubKeyHash":
-                return PubKeyHash.fromUplcData(data)
-            case "Real":
-                return decodeRealData(data)
-            case "ScriptHash":
-                return ScriptHash.fromUplcData(data)
-            case "StakingCredential":
-                return StakingCredential.fromUplcData(data)
-            case "StakingHash":
-                return StakingHash.fromUplcData(data)
-            case "StakingValidatorHash":
-                return StakingValidatorHash.fromUplcData(data)
-            case "String":
-                return decodeUtf8(ByteArrayData.expect(data).bytes)
-            case "Time":
-                return Number(IntData.expect(data).value) // a number has enough precision to represent ms since 1970 for another 142000 years
-            case "TimeRange":
-                return TimeRange.fromUplcData(data)
-            case "TxId":
-                return TxId.fromUplcData(data)
-            case "TxOutputId":
-                return TxOutputId.fromUplcData(data)
-            case "ValidatorHash":
-                return ValidatorHash.fromUplcData(data)
-            case "Value":
-                return Value.fromUplcData(data)
-            default:
-                throw new Error(
-                    `not yet implemented for ${schema.primitiveType}`
-                )
-        }
-    } else if ("listItemType" in schema) {
-        return ListData.expect(data).items.map((x) =>
-            uplcToSchema(schema.listItemType, x, config)
-        )
-    } else if ("mapKeyType" in schema) {
-        return new Map(
-            MapData.expect(data).items.map(([k, v]) => [
-                uplcToSchema(schema.mapKeyType, k, config),
-                uplcToSchema(schema.mapValueType, v, config)
-            ])
-        )
-    } else if ("optionSomeType" in schema) {
-        const optionData = decodeOptionData(data)
-        return optionData
-            ? uplcToSchema(schema.optionSomeType, optionData, config)
-            : None
-    } else if ("structFieldTypes" in schema) {
-        const nExpected = schema.structFieldTypes.length
-        // TODO: Cip-68 support
-        if (nExpected == 1) {
-            return {
-                [schema.structFieldTypes[0].name]: uplcToSchema(
-                    schema.structFieldTypes[0].type,
-                    data,
-                    config
-                )
-            }
-        } else {
-            const fields = ListData.expect(data).items
+function uplcToSchema(schema, data, config, defs = {}) {
+    const kind = schema.kind
 
-            if (fields.length != nExpected) {
-                throw new Error(
-                    `expected ${nExpected} fields in struct, got ${fields.length} fields`
-                )
-            }
+    switch (kind) {
+        case "internal": {
+            const name = schema.name
 
-            return Object.fromEntries(
-                fields.map((field, i) => [
-                    schema.structFieldTypes[i].name,
-                    uplcToSchema(schema.structFieldTypes[i].type, field, config)
+            switch (name) {
+                case "Address":
+                    return Address.fromUplcData(config.isMainnet, data)
+                case "Any":
+                    // TODO: should this throw an error?
+                    return null
+                case "Bool":
+                    return decodeBoolData(data, true)
+                case "ByteArray":
+                    return ByteArrayData.expect(data).bytes
+                case "SpendingCredential":
+                case "Credential":
+                    return SpendingCredential.fromUplcData(data)
+                case "Data":
+                    return data
+                case "DCert":
+                    throw new Error(
+                        "can't convert UplcData back into DCert (significant loss of information)"
+                    )
+                case "Duration":
+                case "Int":
+                    return IntData.expect(data).value
+                case "MintingPolicyHash":
+                    return MintingPolicyHash.fromUplcData(data)
+                case "PubKeyHash":
+                    return PubKeyHash.fromUplcData(data)
+                case "Real":
+                    return decodeRealData(data)
+                case "ScriptHash":
+                    return ScriptHash.fromUplcData(data)
+                case "StakingCredential":
+                    return StakingCredential.fromUplcData(data)
+                case "StakingHash":
+                    return StakingHash.fromUplcData(data)
+                case "StakingValidatorHash":
+                    return StakingValidatorHash.fromUplcData(data)
+                case "String":
+                    return decodeUtf8(ByteArrayData.expect(data).bytes)
+                case "Time":
+                    return Number(IntData.expect(data).value) // a number has enough precision to represent ms since 1970 for another 142000 years
+                case "TimeRange":
+                    return TimeRange.fromUplcData(data)
+                case "TxId":
+                    return TxId.fromUplcData(data)
+                case "TxOutputId":
+                    return TxOutputId.fromUplcData(data)
+                case "ValidatorHash":
+                    return ValidatorHash.fromUplcData(data)
+                case "Value":
+                    return Value.fromUplcData(data)
+                default:
+                    throw new Error(`not yet implemented for ${name}`)
+            }
+        }
+        case "list":
+            return ListData.expect(data).items.map((x) =>
+                uplcToSchema(schema.itemType, x, config, defs)
+            )
+        case "map":
+            return new Map(
+                MapData.expect(data).items.map(([k, v]) => [
+                    uplcToSchema(schema.keyType, k, config, defs),
+                    uplcToSchema(schema.valueType, v, config, defs)
                 ])
             )
+        case "option": {
+            const optionData = decodeOptionData(data)
+            return optionData
+                ? uplcToSchema(schema.someType, optionData, config, defs)
+                : None
         }
-    } else if ("enumVariantTypes" in schema) {
-        const { tag, fields } = ConstrData.expect(data)
+        case "struct": {
+            defs[schema.id] = schema
+            switch (schema.format) {
+                case "singleton":
+                    return {
+                        [schema.fieldTypes[0].name]: uplcToSchema(
+                            schema.fieldTypes[0].type,
+                            data,
+                            config,
+                            defs
+                        )
+                    }
+                case "list": {
+                    const fields = ListData.expect(data).items
+
+                    if (fields.length != schema.fieldTypes.length) {
+                        throw new Error(
+                            `expected ${schema.fieldTypes.length} fields in struct, got ${fields.length} fields`
+                        )
+                    }
 
-        const variantSchema = schema.enumVariantTypes[tag]
+                    return Object.fromEntries(
+                        fields.map((field, i) => [
+                            schema.fieldTypes[i].name,
+                            uplcToSchema(
+                                schema.fieldTypes[i].type,
+                                field,
+                                config,
+                                defs
+                            )
+                        ])
+                    )
+                }
+                case "map": {
+                    const entries = MapData.expect(data).items
 
-        if (!variantSchema) {
-            throw new Error(`tag ${tag} out of range`)
+                    if (entries.length != schema.fieldTypes.length) {
+                        throw new Error(
+                            `expected ${schema.fieldTypes.length} fields in struct, got ${entries.length} fields`
+                        )
+                    }
+
+                    return new Map(
+                        schema.fieldTypes.map(({ name, type }) => {
+                            const pair = expectSome(
+                                entries.find(
+                                    ([key, _]) =>
+                                        decodeUtf8(
+                                            ByteArrayData.expect(key).bytes
+                                        ) == name
+                                )
+                            )
+
+                            return [
+                                name,
+                                uplcToSchema(type, pair[1], config, defs)
+                            ]
+                        })
+                    )
+                }
+                default:
+                    throw new Error(
+                        `unhandled struct format '${schema.format}'`
+                    )
+            }
         }
+        case "enum": {
+            defs[schema.id] = schema
+            const { tag, fields } = ConstrData.expect(data)
 
-        const nExpected = variantSchema.fieldTypes.length
+            const variantSchema = schema.variantTypes[tag]
 
-        if (fields.length != nExpected) {
-            throw new Error(
-                `expected ${nExpected} fields for variant ${variantSchema.name} (tag ${tag}), got ${fields.length} fields`
-            )
+            if (!variantSchema) {
+                throw new Error(`tag ${tag} out of range`)
+            }
+
+            const nExpected = variantSchema.fieldTypes.length
+
+            if (fields.length != nExpected) {
+                throw new Error(
+                    `expected ${nExpected} fields for variant ${variantSchema.name} (tag ${tag}), got ${fields.length} fields`
+                )
+            }
+
+            return {
+                [variantSchema.name]: Object.fromEntries(
+                    fields.map((f, i) => [
+                        variantSchema.fieldTypes[i].name,
+                        uplcToSchema(
+                            variantSchema.fieldTypes[i].type,
+                            f,
+                            config,
+                            defs
+                        )
+                    ])
+                )
+            }
         }
+        case "variant": {
+            defs[schema.id] = schema
+            const { fields } = ConstrData.expect(data)
 
-        return {
-            [variantSchema.name]: Object.fromEntries(
-                fields.map((f, i) => [
-                    variantSchema.fieldTypes[i].name,
-                    uplcToSchema(variantSchema.fieldTypes[i].type, f, config)
+            return Object.fromEntries(
+                fields.map((field, i) => [
+                    schema.fieldTypes[i].name,
+                    uplcToSchema(schema.fieldTypes[i].type, field, config, defs)
                 ])
             )
         }
-    } else {
-        throw new Error(
-            `not yet implemented for ${JSON.stringify(schema, undefined, 4)}`
-        )
+        default:
+            throw new Error(`unhandled schema kind '${kind}'`)
     }
 }