@helios-lang/contract-utils 0.2.8 → 0.2.10

package/src/codegen/TypeSchema.js

@@ -1,158 +1,154 @@
 /**
- * TODO: references and ids for recursive types and more descriptive codegen
- * TODO: use `kind: "internal" | "list" | "map" | "struct" | "option" | "enum"` instead of `primitiveType` etc.
- * TODO: additional property for struct: `format: "list" | "map"`
- * TODO: rename primitiveType -> internalType
- * @typedef {{
- *     primitiveType: string
- * } | {
- *     listItemType: TypeSchema
- * } | {
- *     mapKeyType: TypeSchema
- *     mapValueType: TypeSchema
- * } | {
- *     optionSomeType: TypeSchema
- * } | {
- *     structFieldTypes: {
- *         name: string
- *         type: TypeSchema
- *     }[]
- * } | {
- *     enumVariantTypes: {
- *          name: string,
- *          fieldTypes: {
- *              name: string
- *              type: TypeSchema
- *          }[]
- *     }[]
- * }} TypeSchema
+ * @typedef {import("@helios-lang/type-utils").TypeSchema} TypeSchema
  */
 
 /**
+ * TODO: handle recursive data structures
  * @param {TypeSchema} schema
  * @returns {[string, string]} - the first entry is the canonical type, the second is the permissive type
  */
 export function genTypes(schema) {
-    if ("primitiveType" in schema) {
-        switch (schema.primitiveType) {
-            case "Address":
-                return ["Address", "Address | string"]
-            case "Any":
-                return ["never", "any"]
-            case "AssetClass":
-                return [
-                    "AssetClass",
-                    "AssetClass | string | [string | MintingPolicyHash | number[], string | number[]] | {mph: MintingPolicyHash | string | number[], tokenName: string | number[]}"
-                ]
-            case "Bool":
-                return ["boolean", "boolean"]
-            case "ByteArray":
-                return ["number[]", "number[]"]
-            case "SpendingCredential":
-                return [
-                    "SpendingCredential",
-                    "SpendingCredential | PubKeyHash | ValidatorHash"
-                ]
-            case "Data":
-                return ["UplcData", "UplcData"]
-            case "Duration":
-                return ["bigint", "IntLike"]
-            case "Int":
-                return ["bigint", "IntLike"]
-            case "MintingPolicyHash":
-                return [
-                    "MintingPolicyHash",
-                    "MintingPolicyHash | string | number[]"
-                ]
-            case "PubKey":
-                return ["PubKey", "PubKey | string | number[]"]
-            case "PubKeyHash":
-                return ["PubKeyHash", "PubKeyHash | string | number[]"]
-            case "Real":
-                return ["number", "number"]
-            case "StakingCredential":
-                return [
-                    "StakingCredential",
-                    "StakingCredential | StakingHash | PubKeyHash | StakingValidatorHash"
-                ]
-            case "StakingHash":
-                return [
-                    "StakingHash",
-                    "StakingHash | PubKeyHash | StakingValidatorHash"
-                ]
-            case "StakingValidatorHash":
-                return [
-                    "StakingValidatorHash",
-                    "StakingValidatorHash | string | number[]"
-                ]
-            case "String":
-                return ["string", "string"]
-            case "Time":
-                return ["number", "TimeLike"]
-            case "TimeRange":
-                return [
-                    "TimeRange",
-                    "TimeRange | [TimeLike, TimeLike] | {start?: TimeLike, excludeStart?: boolean, end?: TimeLike, excludeEnd?: boolean}"
-                ]
-            case "TxId":
-                return ["TxId", "TxId | string | number[]"]
-            case "TxOutputDatum":
-                return [
-                    "TxOutputDatum | null",
-                    "TxOutputDatum | null | undefined | DatumHash | UplcData"
-                ]
-            case "TxOutputId":
-                return ["TxOutputId", "TxOutputId | string"]
-            case "ValidatorHash":
-                return ["ValidatorHash", "ValidatorHash | string | number[]"]
-            case "Value":
-                return [
-                    "Value",
-                    "Value | [MintingPolicyHash | string | number[], [number[] | string, IntLike][]][] | {mph: MintingPolicyHash | string | number[], tokens: {name: number[] | string, qty: IntLike}[]}[]"
-                ]
-            default:
-                throw new Error(
-                    `unhandled primitive ${schema.primitiveType} in hl2ts`
-                )
+    const kind = schema.kind
+
+    switch (kind) {
+        case "internal":
+            const name = schema.name
+            switch (name) {
+                case "Address":
+                    return ["Address", "Address | string"]
+                case "AssetClass":
+                    return [
+                        "AssetClass",
+                        "AssetClass | string | [string | MintingPolicyHash | number[], string | number[]] | {mph: MintingPolicyHash | string | number[], tokenName: string | number[]}"
+                    ]
+                case "Bool":
+                    return ["boolean", "boolean"]
+                case "ByteArray":
+                    return ["number[]", "number[]"]
+                case "Data":
+                    return ["UplcData", "UplcData"]
+                case "Duration":
+                    return ["bigint", "IntLike"]
+                case "Int":
+                    return ["bigint", "IntLike"]
+                case "MintingPolicyHash":
+                    return [
+                        "MintingPolicyHash",
+                        "MintingPolicyHash | string | number[]"
+                    ]
+                case "PubKey":
+                    return ["PubKey", "PubKey | string | number[]"]
+                case "PubKeyHash":
+                    return ["PubKeyHash", "PubKeyHash | string | number[]"]
+                case "Real":
+                    return ["number", "number"]
+                case "SpendingCredential":
+                    return [
+                        "SpendingCredential",
+                        "SpendingCredential | PubKeyHash | ValidatorHash"
+                    ]
+                case "StakingCredential":
+                    return [
+                        "StakingCredential",
+                        "StakingCredential | StakingHash | PubKeyHash | StakingValidatorHash"
+                    ]
+                case "StakingHash":
+                    return [
+                        "StakingHash",
+                        "StakingHash | PubKeyHash | StakingValidatorHash"
+                    ]
+                case "StakingValidatorHash":
+                    return [
+                        "StakingValidatorHash",
+                        "StakingValidatorHash | string | number[]"
+                    ]
+                case "String":
+                    return ["string", "string"]
+
+                case "Time":
+                    return ["number", "TimeLike"]
+                case "TimeRange":
+                    return [
+                        "TimeRange",
+                        "TimeRange | [TimeLike, TimeLike] | {start?: TimeLike, excludeStart?: boolean, end?: TimeLike, excludeEnd?: boolean}"
+                    ]
+                case "TxId":
+                    return ["TxId", "TxId | string | number[]"]
+                case "TxOutputDatum":
+                    return [
+                        "TxOutputDatum | null",
+                        "TxOutputDatum | null | undefined | DatumHash | UplcData"
+                    ]
+                case "TxOutputId":
+                    return ["TxOutputId", "TxOutputId | string"]
+                case "ValidatorHash":
+                    return [
+                        "ValidatorHash",
+                        "ValidatorHash | string | number[]"
+                    ]
+                case "Value":
+                    return [
+                        "Value",
+                        "Value | [MintingPolicyHash | string | number[], [number[] | string, IntLike][]][] | {mph: MintingPolicyHash | string | number[], tokens: {name: number[] | string, qty: IntLike}[]}[]"
+                    ]
+                default:
+                    throw new Error(`unhandled primitive '${name}' in hl2ts`)
+            }
+        case "list": {
+            const [c, p] = genTypes(schema.itemType)
+            return [`(${c})[]`, `(${p})[]`]
         }
-    } else if ("listItemType" in schema) {
-        const [c, p] = genTypes(schema.listItemType)
-        return [`(${c})[]`, `(${p})[]`]
-    } else if ("optionSomeType" in schema) {
-        const [c, p] = genTypes(schema.optionSomeType)
-        return [`(${c}) | null`, `(${p}) | null | undefined`]
-    } else if ("mapKeyType" in schema) {
-        const [ck, pk] = genTypes(schema.mapKeyType)
-        const [cv, pv] = genTypes(schema.mapValueType)
+        case "map": {
+            const [ck, pk] = genTypes(schema.keyType)
+            const [cv, pv] = genTypes(schema.valueType)
 
-        return [`Map<${ck}, ${cv}>`, `Map<${pk}, ${pv}> | [${pk}, ${pv}][]`]
-    } else if ("structFieldTypes" in schema) {
-        const fieldTypes = schema.structFieldTypes.map(({ name, type }) => ({
-            name: name,
-            types: genTypes(type)
-        }))
+            return [`Map<${ck}, ${cv}>`, `Map<${pk}, ${pv}> | [${pk}, ${pv}][]`]
+        }
+        case "option": {
+            const [c, p] = genTypes(schema.someType)
+            return [`(${c}) | null`, `(${p}) | null | undefined`]
+        }
+        case "struct": {
+            const fieldTypes = schema.fieldTypes.map(({ name, type }) => ({
+                name: name,
+                types: genTypes(type)
+            }))
 
-        return [
-            `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${c}`).join(", ")}}`,
-            `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${p}`).join(", ")}}`
-        ]
-    } else if ("enumVariantTypes" in schema) {
-        const variantTypes = schema.enumVariantTypes.map(
-            ({ name, fieldTypes }) => ({
+            return [
+                `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${c}`).join(", ")}}`,
+                `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${p}`).join(", ")}}`
+            ]
+        }
+        case "enum": {
+            const variantTypes = schema.variantTypes.map((variant) => ({
+                name: variant.name,
+                types: genTypes(variant)
+            }))
+
+            return [
+                variantTypes
+                    .map(({ name, types: [c, p] }) => `{${name}: ${c}}`)
+                    .join(" | "),
+                variantTypes
+                    .map(({ name, types: [c, p] }) => `{${name}: ${p}}`)
+                    .join(" | ")
+            ]
+        }
+        case "variant": {
+            // similar to structure
+            const fieldTypes = schema.fieldTypes.map(({ name, type }) => ({
                 name: name,
-                types: genTypes({ structFieldTypes: fieldTypes })
-            })
-        )
+                types: genTypes(type)
+            }))
 
-        return [
-            variantTypes
-                .map(({ name, types: [c, p] }) => `{${name}: ${c}}`)
-                .join(" | "),
-            variantTypes
-                .map(({ name, types: [c, p] }) => `{${name}: ${p}}`)
-                .join(" | ")
-        ]
-    } else {
-        throw new Error(`unhandled TypeSchema ${JSON.stringify(schema)}`)
+            return [
+                `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${c}`).join(", ")}}`,
+                `{${fieldTypes.map(({ name, types: [c, p] }) => `${name}: ${p}`).join(", ")}}`
+            ]
+        }
+        case "reference":
+            throw new Error("recursive data structures not yet handled")
+        default:
+            throw new Error(`unhandled TypeSchema kind '${kind}'`)
     }
 }

package/src/compiler/CompilerLib.js

@@ -1,18 +1,26 @@
+import { readHeader } from "@helios-lang/compiler-utils"
+
 export {}
 
 /**
+ * @typedef {import("@helios-lang/uplc").UplcData} UplcData
  * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
  * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
  * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
  */
 
+/**
+ * @typedef {any} ScriptHashType
+ */
+
 /**
  * @typedef {{
- *   allValidatorHashTypes: {[name: string]: any}
+ *   allValidatorHashTypes: {[name: string]: ScriptHashType}
  *   hashDependencies: {[name: string]: string}
  *   dependsOnOwnHash?: boolean
  *   ownHash?: string
- *   parameters?: Record<string, any>
+ *   parameters?: Record<string, UplcData>
+ *   isTestnet: boolean
  *   optimize: boolean
  * }} CompileOptions
  */
@@ -20,7 +28,6 @@ export {}
 /**
  * @typedef {{
  *   cborHex: string
- *   prettyIR: string
  * }} CompileOutput
  */
 
@@ -42,7 +49,7 @@ export {}
 /**
  * @typedef {{
  *   version: string
- *   getScriptHashType: (purpose: string) => any
+ *   getScriptHashType: (purpose: string) => ScriptHashType
  *   typeCheck: (validators: string[], modules: string[]) => ({
  *     modules: {[name: string]: TypeCheckedModule},
  *     validators: {[name: string]: TypeCheckedValidator}
@@ -50,3 +57,21 @@ export {}
  *   compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput
  * }} CompilerLib
  */
+
+/**
+ * @typedef {Record<string, string[]>} DagDependencies
+ */
+
+/**
+ * @param {CompilerLib} lib
+ * @param {string[]} validators
+ * @returns {{[name: string]: ScriptHashType}}
+ */
+export function getValidatorTypes(lib, validators) {
+    return Object.fromEntries(
+        validators.map((src) => {
+            const [purpose, name] = readHeader(src)
+            return [name, lib.getScriptHashType(purpose)]
+        })
+    )
+}

package/src/compiler/CompilerLib_v0_16.js

@@ -1,29 +1,22 @@
-import { bytesToHex } from "@helios-lang/compiler"
+import { bytesToHex } from "@helios-lang/codec-utils"
 import { readHeader } from "@helios-lang/compiler-utils"
 import { expectSome } from "@helios-lang/type-utils"
+import { getValidatorTypes } from "./CompilerLib.js"
 
 /**
+ * @typedef {import("@helios-lang/uplc").UplcData} UplcData
  * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
  * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
- * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
+ * @typedef {import("../codegen/index.js").TypeSchema} TypeSchema
  * @typedef {import("./CompilerLib.js").CompileOptions} CompileOptions
  * @typedef {import("./CompilerLib.js").CompileOutput} CompileOutput
  * @typedef {import("./CompilerLib.js").CompilerLib} CompilerLib
+ * @typedef {import("./CompilerLib.js").DagDependencies} DagDependencies
+ * @typedef {import("./CompilerLib.js").ScriptHashType} ScriptHashType
  * @typedef {import("./CompilerLib.js").SourceDetails} SourceDetails
  * @typedef {import("./CompilerLib.js").TypeCheckOutput} TypeCheckOutput
  */
 
-/**
- * @typedef {{
- *   [name: string]: string[]
- * }} DagDependencies
- */
-
-/**
- * @typedef {{
- * }} ScriptHashType
- */
-
 /**
  * @typedef {{
  *   includes: (m: string) => boolean
@@ -101,34 +94,34 @@ import { expectSome } from "@helios-lang/type-utils"
  *   type:  string
  * } | {
  *   type:     "List"
- *   itemType: TypeSchema
+ *   itemType: TypeSchema16
  * } | {
  *   type:      "Map"
- *   keyType:   TypeSchema
- *   valueType: TypeSchema
+ *   keyType:   TypeSchema16
+ *   valueType: TypeSchema16
  * } | {
  *   type:     "Option"
- *   someType: TypeSchema
+ *   someType: TypeSchema16
  * } | {
  *   type:       "Struct"
- *   fieldTypes: NamedTypeSchema[]
+ *   fieldTypes: NamedTypeSchema16[]
  * } | {
  *   type:         "Enum"
- *   variantTypes: {name: string, fieldTypes: NamedTypeSchema[]}[]
- * }} TypeSchema
+ *   variantTypes: {name: string, fieldTypes: NamedTypeSchema16[]}[]
+ * }} TypeSchema16
  */
 
 /**
  * @typedef {{
  * 	 name: string
- * } & TypeSchema} NamedTypeSchema
+ * } & TypeSchema16} NamedTypeSchema16
  */
 
 /**
  * @typedef {{
  *   inputType: string
  *   outputType: string
- *   internalType: TypeSchema
+ *   internalType: TypeSchema16
  * }} TypeDetails
  */
 
@@ -183,7 +176,9 @@ export class CompilerLib_v0_16 {
             case "staking":
                 return this.lib.StakingValidatorHashType
             default:
-                throw new Error("unhandled validator type")
+                throw new Error(
+                    `Helios v${this.version} doesn't support validator purpose '${purpose}' (hint: supported purposes are 'spending', 'minting' and 'staking')`
+                )
         }
     }
 
@@ -207,16 +202,15 @@ export class CompilerLib_v0_16 {
             }
         )
 
-        if (options.parameters && Object.keys(options.parameters).length > 0) {
-            program.parameters = options.parameters
-        }
+        this.setParameters(program, options.parameters)
 
-        const extra = this.generateExtraIRDefinitions(
+        const extra = this.genExtraIRDefs(
             name,
             purpose,
             program.nPosParams,
             options
         )
+
         const optimize = options.optimize
         const ir = program.toIR(new this.lib.ToIRContext(optimize), extra)
 
@@ -233,7 +227,6 @@ export class CompilerLib_v0_16 {
         const cborHex = bytesToHex(irProgram.toUplc().toCbor())
 
         return {
-            prettyIR: irProgram.program.annotate(),
             cborHex
         }
     }
@@ -244,12 +237,7 @@ export class CompilerLib_v0_16 {
      * @returns {TypeCheckOutput}
      */
     typeCheck(validators, modules) {
-        const validatorTypes = Object.fromEntries(
-            validators.map((v) => {
-                const [purpose, name] = readHeader(v)
-                return [name, this.getScriptHashType(purpose)]
-            })
-        )
+        const validatorTypes = getValidatorTypes(this, validators)
 
         // create validator programs
         let validatorPrograms = this.createPrograms(
@@ -353,7 +341,7 @@ export class CompilerLib_v0_16 {
      * @param {CompileOptions} options
      * @returns {Map<string, IR>}
      */
-    generateExtraIRDefinitions(name, purpose, nPosParams, options) {
+    genExtraIRDefs(name, purpose, nPosParams, options) {
         /**
          * @type {Map<string, IR>}
          */
@@ -467,30 +455,47 @@ export class CompilerLib_v0_16 {
 
     /**
      * @private
-     * @param {TypeSchema} it
-     * @returns {InternalTypeDetails}
+     * @param {TypeSchema16} it
+     * @returns {TypeSchema}
      */
     convertInternalType(it) {
         if ("itemType" in it) {
-            return { listItemType: this.convertInternalType(it.itemType) }
+            return {
+                kind: "list",
+                itemType: this.convertInternalType(it.itemType)
+            }
         } else if ("someType" in it) {
-            return { optionSomeType: this.convertInternalType(it.someType) }
+            return {
+                kind: "option",
+                someType: this.convertInternalType(it.someType)
+            }
         } else if ("fieldTypes" in it) {
             return {
-                structFieldTypes: it.fieldTypes.map((ft) => ({
+                kind: "struct",
+                id: "",
+                name: "",
+                format: it.fieldTypes.length == 1 ? "singleton" : "list",
+                fieldTypes: it.fieldTypes.map((ft) => ({
                     name: ft.name,
                     type: this.convertInternalType(ft)
                 }))
             }
         } else if ("keyType" in it) {
             return {
-                mapKeyType: this.convertInternalType(it.keyType),
-                mapValueType: this.convertInternalType(it.valueType)
+                kind: "map",
+                keyType: this.convertInternalType(it.keyType),
+                valueType: this.convertInternalType(it.valueType)
             }
         } else if ("variantTypes" in it) {
             return {
-                enumVariantTypes: it.variantTypes.map((vt) => ({
+                kind: "enum",
+                id: "",
+                name: "",
+                variantTypes: it.variantTypes.map((vt, i) => ({
+                    kind: "variant",
                     name: vt.name,
+                    tag: i,
+                    id: "",
                     fieldTypes: vt.fieldTypes.map((ft) => ({
                         name: ft.name,
                         type: this.convertInternalType(ft)
@@ -498,7 +503,7 @@ export class CompilerLib_v0_16 {
                 }))
             }
         } else {
-            return { primitiveType: it.type }
+            return { kind: "internal", name: it.type }
         }
     }
 
@@ -507,7 +512,7 @@ export class CompilerLib_v0_16 {
      * TODO: make sure it works for all structs and enums
      * @private
      * @param {DataType} dt
-     * @returns {InternalTypeDetails}
+     * @returns {TypeSchema}
      */
     getInternalTypeDetails(dt) {
         try {
@@ -516,17 +521,17 @@ export class CompilerLib_v0_16 {
             return this.convertInternalType(it)
         } catch (e) {
             if (e.message.includes("Data")) {
-                return { primitiveType: "Data" }
+                return { kind: "internal", name: "Data" }
             } else if (e.message.includes("DCert")) {
-                return { primitiveType: "DCert" }
+                return { kind: "internal", name: "DCert" }
             } else if (e.message.includes("Credential")) {
-                return { primitiveType: "SpendingCredential" }
+                return { kind: "internal", name: "SpendingCredential" }
             } else if (e.message.includes("OutputDatum")) {
-                return { primitiveType: "TxOutputDatum" }
+                return { kind: "internal", name: "TxOutputDatum" }
             } else if (e.message.includes("PubKey")) {
-                return { primitiveType: "PubKey" }
+                return { kind: "internal", name: "PubKey" }
             } else if (e.message.includes("ScriptHash")) {
-                return { primitiveType: "ScriptHash" }
+                return { kind: "internal", name: "ScriptHash" }
             } else {
                 throw e
             }
@@ -586,4 +591,23 @@ export class CompilerLib_v0_16 {
 
         return result
     }
+
+    /**
+     * @private
+     * @param {any} program
+     * @param {Option<Record<string, UplcData>>} parameters
+     */
+    setParameters(program, parameters) {
+        if (!parameters) {
+            return
+        }
+
+        const paramTypes = program.paramTypes
+
+        Object.entries(parameters).forEach(([key, value]) => {
+            if (key in paramTypes) {
+                program.changeParamSafe(key, value)
+            }
+        })
+    }
 }