@helios-lang/contract-utils 0.1.20 → 0.1.23

package/src/{lib/Libg_v0_16.js → compiler/CompilerLib_v0_16.js}

@@ -2,14 +2,15 @@ import { bytesToHex } from "@helios-lang/compiler"
 import { readHeader } from "@helios-lang/compiler-utils"
 
 /**
- * @typedef {import("../codegen/index.js").Module} ModuleDetails
- * @typedef {import("../codegen/index.js").Validator} ValidatorDetails
+ * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
+ * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
+ 
  * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
- * @typedef {import("./Lib.js").CompileOptions} CompileOptions
- * @typedef {import("./Lib.js").CompileOutput} CompileOutput
- * @typedef {import("./Lib.js").Lib} Lib
- * @typedef {import("./Lib.js").LibOptions} LibOptions
- * @typedef {import("./Lib.js").SourceDetails} SourceDetails
+ * @typedef {import("./CompilerLib.js").CompileOptions} CompileOptions
+ * @typedef {import("./CompilerLib.js").CompileOutput} CompileOutput
+ * @typedef {import("./CompilerLib.js").CompilerLib} CompilerLib
+ * @typedef {import("./CompilerLib.js").SourceDetails} SourceDetails
+ * @typedef {import("./CompilerLib.js").TypeCheckOutput} TypeCheckOutput
  */
 
 /**
@@ -20,7 +21,7 @@ import { readHeader } from "@helios-lang/compiler-utils"
 
 /**
  * @typedef {{
- * }} HashType
+ * }} ScriptHashType
  */
 
 /**
@@ -47,7 +48,22 @@ import { readHeader } from "@helios-lang/compiler-utils"
 
 /**
  * @typedef {{
- *   name: {value: string}
+ *   src: {
+ *     raw: string
+ *   }
+ * }} Site
+ */
+
+/**
+ * @typedef {{
+ *   value: string
+ *   site: Site
+ * }} WordToken
+ */
+
+/**
+ * @typedef {{
+ *   name: WordToken
  *   filterDependencies: (all: Module[]) => Module[]
  *   statements: Statement[]
  * }} Module
@@ -55,6 +71,7 @@ import { readHeader } from "@helios-lang/compiler-utils"
 /**
  * @typedef {{
  *   name: string
+ *   purpose: "testing" | "minting" | "spending" | "staking" | "endpoint" | "module" | "unknown"
  *   toIR: (ctx: any, extra: Map<string, IR>) => IR
  *   types: UserTypes
  *   mainImportedModules: Module[]
@@ -111,30 +128,14 @@ import { readHeader } from "@helios-lang/compiler-utils"
  */
 
 /**
- * @implements {Lib}
+ * @implements {CompilerLib}
  */
-export class Lib_v0_16 {
-    /**
-     * @private
-     * @readonly
-     * @type {LibOptions}
-     */
-    options
-
+export class CompilerLib_v0_16 {
     /**
      * @param {any} lib
-     * @param {LibOptions} options
      */
-    constructor(lib, options) {
+    constructor(lib) {
         this.lib = lib
-
-        this.lib.config.set({
-            IS_TESTNET: !(options?.isMainnet ?? false),
-            CHECK_CASTS: options?.checkCasts ?? false,
-            IGNORE_UNEVALUATED_CONSTANTS: true
-        })
-
-        this.options = options
     }
 
     /**
@@ -146,9 +147,9 @@ export class Lib_v0_16 {
 
     /**
      * @param {string} purpose
-     * @returns {HashType}
+     * @returns {ScriptHashType}
      */
-    getValidatorType(purpose) {
+    getScriptHashType(purpose) {
         switch (purpose) {
             case "spending":
                 return this.lib.ValidatorHashType
@@ -161,33 +162,227 @@ export class Lib_v0_16 {
         }
     }
 
+    /**
+     * @param {string[]} validators
+     * @param {string[]} modules
+     * @returns {TypeCheckOutput}
+     */
+    typeCheck(validators, modules) {
+        const validatorTypes = Object.fromEntries(
+            validators.map((v) => {
+                const [purpose, name] = readHeader(v)
+                return [name, this.getScriptHashType(purpose)]
+            })
+        )
+
+        // create validator programs
+        let validatorPrograms = this.createPrograms(
+            validators,
+            modules,
+            validatorTypes
+        )
+
+        // build dag
+        const dag = this.buildDagDependencies(validatorPrograms, validatorTypes)
+
+        /**
+         * @type {{[name: string]: TypeCheckedValidator}}
+         */
+        const typeCheckedValidators = {}
+
+        /**
+         * @type {{[name: string]: TypeCheckedModule}}
+         */
+        const typeCheckedModules = {}
+
+        // collect the validators and the modules from the typechecked programs
+        for (let v of validatorPrograms) {
+            const name = v.name
+            const purpose = v.purpose
+            const sourceCode = v.mainModule.name.site.src.raw
+            const hashDependencies = dag[name]
+
+            const allModules = v.mainImportedModules
+            const moduleDepedencies = v.mainModule
+                .filterDependencies(allModules)
+                .map((m) => m.name.value)
+
+            typeCheckedValidators[name] = {
+                name: name,
+                purpose: purpose,
+                sourceCode: sourceCode,
+                hashDependencies: hashDependencies,
+                moduleDepedencies: moduleDepedencies,
+                types: {},
+                Redeemer: this.getInternalTypeDetails(
+                    v.mainArgTypes[purpose == "spending" ? 1 : 0]
+                ),
+                Datum:
+                    purpose == "spending"
+                        ? this.getInternalTypeDetails(v.mainArgTypes[0])
+                        : undefined
+            }
+
+            // add any module dependencies that haven't been added before
+            for (let m of v.mainImportedModules) {
+                const name = m.name.value
+                const sourceCode = m.name.site.src.raw
+
+                if (name in typeCheckedModules) {
+                    continue
+                }
+
+                typeCheckedModules[name] = {
+                    name: name,
+                    purpose: "module",
+                    sourceCode: sourceCode,
+                    moduleDepedencies: m
+                        .filterDependencies(allModules)
+                        .map((m) => m.name.value),
+                    types: {} // not yet exported
+                }
+            }
+        }
+
+        return {
+            modules: typeCheckedModules,
+            validators: typeCheckedValidators
+        }
+    }
+
+    /**
+     * Generate additional IR definitions
+     *   * dependency on own precalculated hash (eg. unoptimized program should use hash of optimized program)
+     *   * dependency on own hash through methods defined on the ScriptContext
+     *   * dependency on hashes of other validators
+     * @private
+     * @param {string} name - name of the validator being compiled
+     * @param {string} purpose - purpose the validator being compiled
+     * @param {number} nPosParams
+     * @param {CompileOptions} options
+     * @returns {Map<string, IR>}
+     */
+    generateExtraIRDefinitions(name, purpose, nPosParams, options) {
+        /**
+         * @type {Map<string, IR>}
+         */
+        const extra = new Map()
+
+        const IR = this.lib.IR
+
+        // inject own hash (either precalculated, or via ScriptContext)
+        if (options.ownHash) {
+            extra.set(
+                `__helios__scripts__${name}`,
+                new IR(`#${options.ownHash}`)
+            )
+        } else if (options.dependsOnOwnHash) {
+            const key = `__helios__scripts__${name}`
+            let ir = new IR(`__PARAM_${nPosParams - 1}`)
+
+            switch (purpose) {
+                case "spending":
+                    ir = new IR([
+                        new IR(
+                            `__helios__scriptcontext__get_current_validator_hash(`
+                        ),
+                        ir,
+                        new IR(`)()`)
+                    ])
+                    break
+                case "minting":
+                    ir = new IR([
+                        new IR(
+                            `__helios__scriptcontext__get_current_minting_policy_hash(`
+                        ),
+                        ir,
+                        new IR(`)()`)
+                    ])
+                    break
+                default:
+                    throw new Error("unhandled purpose")
+            }
+
+            extra.set(key, ir)
+        }
+
+        // inject hashes of other validators
+        Object.entries(options.hashDependencies ?? {}).forEach(
+            ([depName, dep]) => {
+                extra.set(`__helios__scripts__${depName}`, new IR(`#${dep}`))
+            }
+        )
+
+        return extra
+    }
+
+    /**
+     * @param {string} main
+     * @param {string[]} modules
+     * @param {CompileOptions} options
+     * @returns {CompileOutput}
+     */
+    compile(main, modules, options) {
+        const [purpose, name] = readHeader(main)
+
+        // use `Program.newInternal()` instead of `Program.new()` so we can inject custom IR before finally compiling to a UplcProgram
+        const program = this.lib.Program.newInternal(
+            main,
+            modules,
+            options.allValidatorHashTypes,
+            {
+                allowPosParams: false,
+                invertEntryPoint: true
+            }
+        )
+
+        const extra = this.generateExtraIRDefinitions(
+            name,
+            purpose,
+            program.nPosParams,
+            options
+        )
+        const optimize = options.optimize
+        const ir = program.toIR(new this.lib.ToIRContext(optimize), extra)
+
+        const irProgram =
+            program.nPosParams > 0
+                ? this.lib.IRParametricProgram.new(
+                      ir,
+                      purpose,
+                      program.nPosParams,
+                      optimize
+                  )
+                : this.lib.IRProgram.new(ir, purpose, optimize)
+
+        const cborHex = bytesToHex(irProgram.toUplc().toCbor())
+
+        return {
+            prettyIR: irProgram.program.annotate(),
+            cborHex
+        }
+    }
+
     /**
      * @private
-     * @param {SourceDetails[]} validators
-     * @param {SourceDetails[]} modules
-     * @param {{[name: string]: HashType}} validatorTypes
+     * @param {string[]} validators
+     * @param {string[]} modules
+     * @param {{[name: string]: ScriptHashType}} validatorTypes
      * @returns {Program[]}
      */
     createPrograms(validators, modules, validatorTypes) {
-        const moduleSrcs = modules.map((m) => m.sourceCode)
-
         return validators.map((v) =>
-            this.lib.Program.newInternal(
-                v.sourceCode,
-                moduleSrcs,
-                validatorTypes,
-                {
-                    allowPosParams: false,
-                    invertEntryPoint: true
-                }
-            )
+            this.lib.Program.newInternal(v, modules, validatorTypes, {
+                allowPosParams: false,
+                invertEntryPoint: true
+            })
         )
     }
 
     /**
      * @private
      * @param {Program} program
-     * @param {{[name: string]: HashType}} validatorTypes
+     * @param {{[name: string]: ScriptHashType}} validatorTypes
      * @returns {IR}
      */
     toTestIR(program, validatorTypes) {
@@ -206,7 +401,7 @@ export class Lib_v0_16 {
     /**
      * @private
      * @param {Program[]} validators
-     * @param {{[name: string]: HashType}} validatorTypes
+     * @param {{[name: string]: ScriptHashType}} validatorTypes
      * @returns {DagDependencies}
      */
     buildDagDependencies(validators, validatorTypes) {
@@ -227,84 +422,7 @@ export class Lib_v0_16 {
     }
 
     /**
-     * @param {{[name: string]: SourceDetails}} validators
-     * @param {{[name: string]: SourceDetails}} modules
-     * @returns {{modules: {[name: string]: ModuleDetails}, validators: {[name: string]: ValidatorDetails}}}
-     */
-    typeCheck(validators, modules) {
-        const validatorTypes = Object.fromEntries(
-            Object.values(validators).map((v) => [
-                v.name,
-                this.getValidatorType(v.purpose)
-            ])
-        )
-
-        // create validator programs
-        let validatorPrograms = this.createPrograms(
-            Object.values(validators),
-            Object.values(modules),
-            validatorTypes
-        )
-
-        // build dag
-        const dag = this.buildDagDependencies(validatorPrograms, validatorTypes)
-
-        // sort the validators according to the dag, a valid order should exist
-        // validatorPrograms = this.sortValidators(validatorPrograms, dag)
-
-        /**
-         * @type {{[name: string]: ValidatorDetails}}
-         */
-        const validatorDetails = {}
-
-        /**
-         * @type {{[name: string]: ModuleDetails}}
-         */
-        const moduleDetails = {}
-
-        for (let v of validatorPrograms) {
-            const hashDependencies = dag[v.name]
-            const allModules = v.mainImportedModules
-            const moduleDepedencies = v.mainModule
-                .filterDependencies(allModules)
-                .map((m) => m.name.value)
-            const purpose = validators[v.name].purpose
-
-            validatorDetails[v.name] = {
-                name: v.name,
-                purpose: validators[v.name].purpose,
-                sourceCode: validators[v.name].sourceCode,
-                hashDependencies: hashDependencies,
-                moduleDepedencies: moduleDepedencies,
-                types: {},
-                Redeemer: this.getInternalTypeDetails(
-                    v.mainArgTypes[purpose == "spending" ? 1 : 0]
-                ),
-                Datum:
-                    purpose == "spending"
-                        ? this.getInternalTypeDetails(v.mainArgTypes[0])
-                        : undefined
-            }
-
-            for (let m of v.mainImportedModules) {
-                if (!(m.name.value in moduleDetails)) {
-                    moduleDetails[m.name.value] = {
-                        name: m.name.value,
-                        purpose: "module",
-                        sourceCode: modules[m.name.value].sourceCode,
-                        moduleDepedencies: m
-                            .filterDependencies(allModules)
-                            .map((m) => m.name.value),
-                        types: {} // not yet exported
-                    }
-                }
-            }
-        }
-
-        return { modules: moduleDetails, validators: validatorDetails }
-    }
-
-    /**
+     * @private
      * @param {TypeSchema} it
      * @returns {InternalTypeDetails}
      */
@@ -341,6 +459,7 @@ export class Lib_v0_16 {
     }
 
     /**
+     * @private
      * @param {DataType} dt
      * @returns {InternalTypeDetails}
      */
@@ -357,135 +476,4 @@ export class Lib_v0_16 {
             }
         }
     }
-
-    /**
-     * @param {string[]} modules
-     * @returns {string[]}
-     */
-    sortModules(modules) {
-        if (!this.options?.moduleOrder) {
-            return modules
-        }
-
-        const n = modules.length
-        const tmp = modules.slice()
-
-        tmp.sort((a, b) => {
-            const nameA = readHeader(a)[1]
-            const nameB = readHeader(b)[1]
-
-            let iA = this.options.moduleOrder?.indexOf(nameA)
-            let iB = this.options.moduleOrder?.indexOf(nameB)
-
-            if (iA === undefined || iA == -1) {
-                iA = n
-            }
-
-            if (iB === undefined || iB == -1) {
-                iB = n
-            }
-
-            return iA - iB
-        })
-
-        return tmp
-    }
-
-    /**
-     * @param {string} main
-     * @param {string[]} modules
-     * @param {CompileOptions} options
-     * @returns {CompileOutput}
-     */
-    compile(main, modules, options) {
-        const [purpose, name] = readHeader(main)
-        const otherValidators = options.otherValidators ?? {}
-        const otherValidatorTypes = options.allValidatorTypes
-
-        modules = this.sortModules(modules)
-
-        const program = this.lib.Program.newInternal(
-            main,
-            modules,
-            otherValidatorTypes,
-            {
-                allowPosParams: false,
-                invertEntryPoint: true
-            }
-        )
-
-        /**
-         * @type {Map<any, any>}
-         */
-        const extra = new Map()
-        const IR = this.lib.IR
-
-        if (options.ownHash) {
-            const key = `__helios__scripts__${name}`
-
-            extra.set(key, new IR(`#${options.ownHash}`))
-        } else if (options.dependsOnOwnHash) {
-            const key = `__helios__scripts__${name}`
-            let ir = new IR(`__PARAM_${program.nPosParams - 1}`)
-
-            switch (purpose) {
-                case "spending":
-                    ir = new IR([
-                        new IR(
-                            `__helios__scriptcontext__get_current_validator_hash(`
-                        ),
-                        ir,
-                        new IR(`)()`)
-                    ])
-                    break
-                case "minting":
-                    ir = new IR([
-                        new IR(
-                            `__helios__scriptcontext__get_current_minting_policy_hash(`
-                        ),
-                        ir,
-                        new IR(`)()`)
-                    ])
-                    break
-                default:
-                    throw new Error("unhandled purpose")
-            }
-
-            extra.set(key, ir)
-        }
-
-        for (let other in otherValidators) {
-            const key = `__helios__scripts__${other}`
-
-            extra.set(key, new IR(`#${otherValidators[other].hash}`))
-        }
-
-        const optimize = options.optimize
-        const ir = program.toIR(new this.lib.ToIRContext(optimize), extra)
-
-        if (program.nPosParams > 0) {
-            const irProgram = this.lib.IRParametricProgram.new(
-                ir,
-                purpose,
-                program.nPosParams,
-                optimize
-            )
-
-            const cborHex = bytesToHex(irProgram.toUplc().toCbor())
-
-            return {
-                prettyIR: irProgram.program.annotate(),
-                cborHex
-            }
-        } else {
-            const irProgram = this.lib.IRProgram.new(ir, purpose, optimize)
-
-            const cborHex = bytesToHex(irProgram.toUplc().toCbor())
-
-            return {
-                prettyIR: irProgram.program.annotate(),
-                cborHex
-            }
-        }
-    }
 }

package/src/compiler/index.js

@@ -0,0 +1,6 @@
+export { loadCompilerLib, typeCheckFiles, typeCheckScripts } from "./ops.js"
+
+/**
+ * @typedef {import("./CompilerLib.js").CompilerLib} CompilerLib
+ * @typedef {import("./CompilerLib.js").TypeCheckOutput} TypeCheckOutput
+ */