@helios-lang/contract-utils 0.1.19 → 0.1.23

package/examples/multi-validator/README.md

@@ -0,0 +1,5 @@
+# Codegen multi policy
+
+Run `npx hl2ts` to generate Javascript/Typescript equivalents of the `spending.hl` and `minting.hl` validators.
+
+Then have a look at `contract.js` to see how these validators can be used within Javascript/Typescript in a type-safe way (ideally using VSCode so you can hover over the types).

package/examples/{spending → multi-validator}/contract.js

@@ -5,7 +5,10 @@ import { match_string, match_string_policy } from "./index.js"
 const context = ContractContextBuilder.new()
     .with(match_string)
     .with(match_string_policy)
-    .build()
+    .build({
+        match_string_policy:
+            "f7c8a87011f1aec5967dd3cd68b7a2c26135d750867bfd957b4d8967" // expected hash for match_string_policy
+    })
 
 console.log(context.match_string_policy.toHex())
 
@@ -13,4 +16,6 @@ const address = Address.fromHash(context.match_string)
 
 const b = new TxBuilder()
     .mint(context.match_string_policy, [["", 10]], "hello")
-    .pay(address, 0n, { hash: { One: { message: "hello" } } })
+    .pay(address, 1_000_000n, { hash: { One: { message: "hello" } } })
+    // Types from Helios are propagated into Typescript, allowing typesafe conversion of Datums
+    .pay(address, 2_000_000n, { hash: { Two: { message: "hello" } } })

package/examples/{spending → multi-validator}/index.d.ts

@@ -22,7 +22,7 @@ export const match_string: {
     $purpose: "spending"
     $sourceCode: string
     $dependencies: [typeof utils]
-    $hashDependencies: []
+    $hashDependencies: [typeof match_string_policy]
     $dependsOnOwnHash: boolean
     $Redeemer: Cast<string, string>
     $Datum: Cast<{One: {message: string}} | {Two: {code: bigint}}, {One: {message: string}} | {Two: {code: bigint | number | string}}>

package/examples/{spending → multi-validator}/index.js

@@ -18,10 +18,10 @@ export const match_string_policy = {
 export const match_string = {
     $name: "match_string",
     $purpose: "spending",
-    $sourceCode: "spending match_string\n\nimport { compare } from utils\n\nenum Datum {\n One {\n  message: String\n }\n\n Two {\n  code: Int\n }\n}\n\nfunc main(datum: Datum, redeemer: String, _) -> Bool {\n compare(datum.switch{d: One => d.message, d: Two => d.code.show()}, redeemer)\n}",
+    $sourceCode: "spending match_string\n\nimport { compare } from utils\n\nenum Datum {\n One {\n  message: String\n }\n\n Two {\n  code: Int\n }\n}\n\nfunc main(datum: Datum, redeemer: String, ctx: ScriptContext) -> Bool {\n compare(datum.switch{d: One => d.message, d: Two => d.code.show()}, redeemer) &&\n   ctx.tx.minted.get(AssetClass::new(Scripts::match_string_policy, #)) > 0\n}",
     $dependencies: [utils],
-    $hashDependencies: [],
-    $dependsOnOwnHash: false,
+    $hashDependencies: [match_string_policy],
+    $dependsOnOwnHash: true,
     $Redeemer: new Cast({"primitiveType":"String"}),
     $Datum: new Cast({"enumVariantTypes":[{"name":"One","fieldTypes":[{"name":"message","type":{"primitiveType":"String"}}]},{"name":"Two","fieldTypes":[{"name":"code","type":{"primitiveType":"Int"}}]}]})
 }

package/examples/{spending → multi-validator}/spending.hl

@@ -12,6 +12,7 @@ enum Datum {
 	}
 }
 
-func main(datum: Datum, redeemer: String, _) -> Bool {
-	compare(datum.switch{d: One => d.message, d: Two => d.code.show()}, redeemer)
+func main(datum: Datum, redeemer: String, ctx: ScriptContext) -> Bool {
+	compare(datum.switch{d: One => d.message, d: Two => d.code.show()}, redeemer) && 
+	  ctx.tx.minted.get(AssetClass::new(Scripts::match_string_policy, #)) > 0
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@helios-lang/contract-utils",
-    "version": "0.1.19",
+    "version": "0.1.23",
     "description": "Convenience and type-safety utilities for using Helios validators from within Typescript",
     "main": "src/index.js",
     "types": "types/index.d.ts",
@@ -11,12 +11,12 @@
     "scripts": {
         "build": "npm run build:types",
         "build:types": "npx tsc -p jsconfig.json --noEmit false --emitDeclarationOnly",
-        "clean": "find src/ -name *.d.ts* | xargs rm",
+        "prepack": "npm run test:pretty && npm run test:suite && npm run build",
         "prettify": "npx prettier . --write",
         "test": "npm run test:pretty && npm run test:types && npm run test:suite",
         "test:pretty": "npx prettier . --check",
         "test:suite": "node --test  --experimental-test-coverage",
-        "test:types": "npx tsc -p jsconfig.json --noEmit"
+        "test:types": "npm run build:types"
     },
     "author": "Christian Schmitz",
     "license": "BSD-3-Clause",
@@ -35,9 +35,9 @@
         "@helios-lang/compiler": "*"
     },
     "dependencies": {
-        "@helios-lang/codec-utils": "^0.1.26",
-        "@helios-lang/compiler-utils": "^0.1.20",
-        "@helios-lang/ledger": "^0.1.20",
+        "@helios-lang/codec-utils": "^0.1.27",
+        "@helios-lang/compiler-utils": "^0.1.21",
+        "@helios-lang/ledger": "^0.1.21",
         "@helios-lang/type-utils": "^0.1.8",
         "@helios-lang/uplc": "^0.1.22"
     }

package/src/{runtime → cast}/Cast.js

@@ -6,7 +6,6 @@ import {
     AssetClass,
     Credential,
     DatumHash,
-    DCert,
     MintingPolicyHash,
     PubKeyHash,
     ScriptHash,
@@ -26,7 +25,9 @@ import {
     IntData,
     ListData,
     MapData,
+    decodeBoolData,
     decodeOptionData,
+    encodeBoolData,
     encodeOptionData
 } from "@helios-lang/uplc"
 
@@ -36,8 +37,8 @@ import {
  */
 
 /**
- * @template [TStrict=UplcData]
- * @template [TPermissive=UplcData]
+ * @template [TStrict=any]
+ * @template [TPermissive=any]
  */
 export class Cast {
     /**
@@ -85,7 +86,7 @@ function schemaToUplc(schema, x) {
             case "AssetClass":
                 return AssetClass.fromAlike(x).toUplcData()
             case "Bool":
-                return new ConstrData(x ? 1 : 0, [])
+                return encodeBoolData(x)
             case "ByteArray":
                 return new ByteArrayData(x)
             case "Credential":
@@ -186,6 +187,7 @@ function schemaToUplc(schema, x) {
 }
 
 /**
+ * This should fail when deviating
  * @param {TypeSchema} schema
  * @param {UplcData} data
  * @returns {any}
@@ -199,7 +201,7 @@ function uplcToSchema(schema, data) {
                 // TODO: should this throw an error?
                 return null
             case "Bool":
-                return ConstrData.expect(data).tag == 1
+                return decodeBoolData(data, true)
             case "ByteArray":
                 return ByteArrayData.expect(data).bytes
             case "Credential":
@@ -261,8 +263,9 @@ function uplcToSchema(schema, data) {
             ? uplcToSchema(schema.optionSomeType, optionData)
             : None
     } else if ("structFieldTypes" in schema) {
+        const nExpected = schema.structFieldTypes.length
         // TODO: Cip-68 support
-        if (schema.structFieldTypes.length == 1) {
+        if (nExpected == 1) {
             return {
                 [schema.structFieldTypes[0].name]: uplcToSchema(
                     schema.structFieldTypes[0].type,
@@ -270,10 +273,18 @@ function uplcToSchema(schema, data) {
                 )
             }
         } else {
+            const fields = ListData.expect(data).items
+
+            if (fields.length != nExpected) {
+                throw new Error(
+                    `expected ${nExpected} fields in struct, got ${fields.length} fields`
+                )
+            }
+
             return Object.fromEntries(
-                ListData.expect(data).items.map((item, i) => [
+                fields.map((field, i) => [
                     schema.structFieldTypes[i].name,
-                    uplcToSchema(schema.structFieldTypes[i].type, item)
+                    uplcToSchema(schema.structFieldTypes[i].type, field)
                 ])
             )
         }
@@ -282,6 +293,18 @@ function uplcToSchema(schema, data) {
 
         const variantSchema = schema.enumVariantTypes[tag]
 
+        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) => [

package/src/cast/index.js

@@ -0,0 +1,12 @@
+import { Cast } from "./Cast.js"
+export { Cast }
+
+/**
+ * @template {Cast} C
+ * @typedef {import("./PermissiveType.js").PermissiveType<C>} PermissiveType
+ */
+
+/**
+ * @template {Cast} C
+ * @typedef {import("./StrictType.js").StrictType<C>} StrictType
+ */

package/src/codegen/LoadedModule.js

@@ -0,0 +1,9 @@
+export {}
+
+/**
+ * @typedef {{
+ *   $name: string
+ *   $sourceCode: string
+ *   $dependencies: LoadedModule[]
+ * }} LoadedModule
+ */

package/src/codegen/{TypescriptWriter.js → LoadedScriptsWriter.js}

@@ -1,121 +1,35 @@
+import { StringWriter } from "@helios-lang/codec-utils"
 import { genTypes } from "./TypeSchema.js"
-import { Writer } from "./Writer.js"
 
 /**
- * @typedef {import("./Module.js").Module} Module
- * @typedef {import("./Validator.js").Validator} Validator
+ * @typedef {import("./TypeCheckedModule.js").TypeCheckedModule} TypeCheckedModule
+ * @typedef {import("./TypeCheckedValidator.js").TypeCheckedValidator} TypeCheckedValidator
  */
 
-export class TypescriptWriter {
-    constructor() {
-        this.wjs = new Writer()
-        this.wdts = new Writer()
-    }
-
-    /**
-     * @param {string} js
-     * @param {string} dts
-     * @returns {TypescriptWriter}
-     */
-    write(js, dts = "") {
-        this.wjs.write(js)
-        this.wdts.write(dts)
-        return this
-    }
-
-    /**
-     * @param {string} js
-     * @param {string} dts
-     * @returns {TypescriptWriter}
-     */
-    writeLine(js, dts = "") {
-        if (js != "") {
-            this.wjs.writeLine(js)
-        }
-
-        if (dts != "") {
-            this.wdts.writeLine(dts)
-        }
-
-        return this
-    }
-
+export class LoadedScriptsWriter {
     /**
-     * @param {Module} m
+     * @private
      */
-    writeModule(m) {
-        this.write(
-            `export const ${m.name} = {
-    $name: "${m.name}",
-    $purpose: "${m.purpose}",
-    $sourceCode: ${JSON.stringify(m.sourceCode)},
-    $dependencies: [${m.moduleDepedencies.join(", ")}],
-}
-`,
-            `export const ${m.name}: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: [${m.moduleDepedencies.map((d) => `typeof ${d}`).join(", ")}]
-}
-`
-        )
+    constructor() {
+        this.definition = new StringWriter()
+        this.declaration = new StringWriter()
     }
 
     /**
-     * @param {Validator} v
+     * Constructs a LoadedScriptsWriter instance and initializes it be writing the header
+     * @returns {LoadedScriptsWriter}
      */
-    writeValidator(v) {
-        const redeemerTypes = genTypes(v.Redeemer)
-        const datumTypes = v.Datum ? genTypes(v.Datum) : undefined
-
-        this.write(
-            `export const ${v.name} = {
-    $name: "${v.name}",
-    $purpose: "${v.purpose}",
-    $sourceCode: ${JSON.stringify(v.sourceCode)},
-    $dependencies: [${v.moduleDepedencies.join(", ")}],
-    $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
-    $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)},
-    $Redeemer: new Cast(${JSON.stringify(v.Redeemer)}),
-    ${datumTypes ? `$Datum: new Cast(${JSON.stringify(v.Datum)})` : ""}
-}
-`,
-            `export const ${v.name}: {
-    $name: "${v.name}"
-    $purpose: "${v.purpose}"
-    $sourceCode: string
-    $dependencies: [${v.moduleDepedencies.map((d) => `typeof ${d}`).join(", ")}]
-    $hashDependencies: [${v.hashDependencies
-        .filter((d) => d != v.name)
-        .map((d) => `typeof ${d}`)
-        .join(", ")}]
-    $dependsOnOwnHash: boolean
-    $Redeemer: Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>
-    ${datumTypes ? `$Datum: Cast<${datumTypes[0]}, ${datumTypes[1]}>` : ""}
-}
-`
-        )
-    }
+    static new() {
+        const w = new LoadedScriptsWriter()
 
-    writeHeaders() {
-        this.wjs.writeLine(
-            'import { Cast } from "@helios-lang/contract-utils";'
-        )
+        w.writeHeaders()
 
-        this.wdts.writeLine(
-            'import type {UplcData} from "@helios-lang/ledger";'
-        )
-        this.wdts.writeLine(
-            'import { Address, AssetClass, Credential, DatumHash, MintingPolicyHash, PubKeyHash, StakingCredential, StakingHash, StakingValidatorHash, TimeRange, TxId, TxOutputDatum, ValidatorHash, Value} from "@helios-lang/ledger";'
-        )
-        this.wdts.writeLine(
-            'import { Cast } from "@helios-lang/contract-utils";'
-        )
+        return w
     }
 
     /**
-     * @param {{[name: string]: Module}} ms
+     * @param {{[name: string]: TypeCheckedModule}} ms
+     * @returns {LoadedScriptsWriter}
      */
     writeModules(ms) {
         /**
@@ -127,7 +41,7 @@ export class TypescriptWriter {
 
         while (todo.length > 0) {
             /**
-             * @type {Module[]}
+             * @type {TypeCheckedModule[]}
              */
             let todoNext = []
 
@@ -145,11 +59,13 @@ export class TypescriptWriter {
 
             todo = todoNext
         }
+
+        return this
     }
 
     /**
-     *
-     * @param {{[name: string]: Validator}} validators
+     * @param {{[name: string]: TypeCheckedValidator}} validators
+     * @returns {LoadedScriptsWriter}
      */
     writeValidators(validators) {
         /**
@@ -161,7 +77,7 @@ export class TypescriptWriter {
 
         while (todo.length > 0) {
             /**
-             * @type {Validator[]}
+             * @type {TypeCheckedValidator[]}
              */
             let todoNext = []
 
@@ -181,12 +97,106 @@ export class TypescriptWriter {
 
             todo = todoNext
         }
+
+        return this
     }
 
     /**
      * @returns {[string, string]}
      */
     finalize() {
-        return [this.wjs.finalize(), this.wdts.finalize()]
+        return [this.definition.finalize(), this.declaration.finalize()]
+    }
+
+    /**
+     * @private
+     * @param {string} def
+     * @param {string} decl
+     * @returns {LoadedScriptsWriter}
+     */
+    write(def, decl = "") {
+        this.definition.write(def)
+        this.declaration.write(decl)
+
+        return this
+    }
+
+    /**
+     * @private
+     */
+    writeHeaders() {
+        this.definition.writeLine(
+            'import { Cast } from "@helios-lang/contract-utils";'
+        )
+
+        this.declaration.writeLine(
+            'import type {UplcData} from "@helios-lang/ledger";'
+        )
+        this.declaration.writeLine(
+            'import { Address, AssetClass, Credential, DatumHash, MintingPolicyHash, PubKeyHash, StakingCredential, StakingHash, StakingValidatorHash, TimeRange, TxId, TxOutputDatum, ValidatorHash, Value} from "@helios-lang/ledger";'
+        )
+        this.declaration.writeLine(
+            'import { Cast } from "@helios-lang/contract-utils";'
+        )
+    }
+
+    /**
+     * @private
+     * @param {TypeCheckedModule} m
+     */
+    writeModule(m) {
+        this.write(
+            `export const ${m.name} = {
+    $name: "${m.name}",
+    $purpose: "${m.purpose}",
+    $sourceCode: ${JSON.stringify(m.sourceCode)},
+    $dependencies: [${m.moduleDepedencies.join(", ")}],
+}
+`,
+            `export const ${m.name}: {
+    $name: string
+    $purpose: string
+    $sourceCode: string
+    $dependencies: [${m.moduleDepedencies.map((d) => `typeof ${d}`).join(", ")}]
+}
+`
+        )
+    }
+
+    /**
+     * @private
+     * @param {TypeCheckedValidator} v
+     */
+    writeValidator(v) {
+        const redeemerTypes = genTypes(v.Redeemer)
+        const datumTypes = v.Datum ? genTypes(v.Datum) : undefined
+
+        this.write(
+            `export const ${v.name} = {
+    $name: "${v.name}",
+    $purpose: "${v.purpose}",
+    $sourceCode: ${JSON.stringify(v.sourceCode)},
+    $dependencies: [${v.moduleDepedencies.join(", ")}],
+    $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
+    $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)},
+    $Redeemer: new Cast(${JSON.stringify(v.Redeemer)}),
+    ${datumTypes ? `$Datum: new Cast(${JSON.stringify(v.Datum)})` : ""}
+}
+`,
+            `export const ${v.name}: {
+    $name: "${v.name}"
+    $purpose: "${v.purpose}"
+    $sourceCode: string
+    $dependencies: [${v.moduleDepedencies.map((d) => `typeof ${d}`).join(", ")}]
+    $hashDependencies: [${v.hashDependencies
+        .filter((d) => d != v.name)
+        .map((d) => `typeof ${d}`)
+        .join(", ")}]
+    $dependsOnOwnHash: boolean
+    $Redeemer: Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>
+    ${datumTypes ? `$Datum: Cast<${datumTypes[0]}, ${datumTypes[1]}>` : ""}
+}
+`
+        )
     }
 }

package/src/codegen/LoadedValidator.js

@@ -0,0 +1,23 @@
+import { Cast } from "../cast/Cast.js"
+
+/**
+ * @typedef {import("./LoadedModule.js").LoadedModule} LoadedModule
+ */
+
+/**
+ * @typedef {{
+ *   $name: string
+ *   $sourceCode: string
+ *   $dependencies: LoadedModule[]
+ *   $hashDependencies: LoadedValidator[]
+ *   $dependsOnOwnHash: boolean
+ *   $Redeemer: Cast
+ * } & (
+ *   {
+ *     $purpose: "spending"
+ *     $Datum: Cast
+ *   } | {
+ *     $purpose: "minting" | "certifying" | "rewarding" | "staking"
+ *   }
+ * )} LoadedValidator
+ */

package/src/codegen/{Module.js → TypeCheckedModule.js}

@@ -1,3 +1,5 @@
+export {}
+
 /**
  * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
  */
@@ -9,7 +11,5 @@
  *   sourceCode: string
  *   moduleDepedencies: string[]
  *   types: {[name: string]: TypeSchema}
- * }} Module
+ * }} TypeCheckedModule
  */
-
-export const _ = {}

package/src/codegen/{Validator.js → TypeCheckedValidator.js}

@@ -1,17 +1,14 @@
-/**
- * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
- */
+export {}
 
 /**
- * @typedef {import("./Module.js").Module} Module
+ * @typedef {import("./TypeCheckedModule.js").TypeCheckedModule} TypeCheckedModule
+ * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
  */
 
 /**
- * @typedef {Module & {
+ * @typedef {TypeCheckedModule & {
  *   hashDependencies: string[]
  *   Redeemer: TypeSchema
  *   Datum?: TypeSchema
- * }} Validator
+ * }} TypeCheckedValidator
  */
-
-export const _ = {}

package/src/codegen/TypeSchema.js

@@ -1,4 +1,8 @@
 /**
+ * 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
  * } | {

package/src/codegen/index.js

@@ -1,8 +1,9 @@
-export { TypescriptWriter } from "./TypescriptWriter.js"
-export { Writer } from "./Writer.js"
+export { LoadedScriptsWriter } from "./LoadedScriptsWriter.js"
 
 /**
- * @typedef {import("./Module.js").Module} Module
+ * @typedef {import("./LoadedModule.js").LoadedModule} LoadedModule
+ * @typedef {import("./LoadedValidator.js").LoadedValidator} LoadedValidator
+ * @typedef {import("./TypeCheckedModule.js").TypeCheckedModule} TypeCheckedModule
+ * @typedef {import("./TypeCheckedValidator.js").TypeCheckedValidator} TypeCheckedValidator
  * @typedef {import("./TypeSchema.js").TypeSchema} TypeSchema
- * @typedef {import("./Validator.js").Validator} Validator
  */

package/src/compiler/CompilerLib.js

@@ -0,0 +1,51 @@
+export {}
+
+/**
+ * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
+ * @typedef {import("../codegen/index.js").TypeCheckedModule} TypeCheckedModule
+ * @typedef {import("../codegen/index.js").TypeCheckedValidator} TypeCheckedValidator
+ */
+
+/**
+ * @typedef {{
+ *   allValidatorHashTypes: {[name: string]: any},
+ *   hashDependencies: {[name: string]: string},
+ *   dependsOnOwnHash?: boolean,
+ *   ownHash?: string,
+ *   optimize: boolean
+ * }} CompileOptions
+ */
+
+/**
+ * @typedef {{
+ *   cborHex: string
+ *   prettyIR: string
+ * }} CompileOutput
+ */
+
+/**
+ * @typedef {{
+ *   modules: {[name: string]: TypeCheckedModule}
+ *   validators: {[name: string]: TypeCheckedValidator}
+ * }} TypeCheckOutput
+ */
+
+/**
+ * @typedef {{
+ *   name: string
+ *   purpose: string
+ *   sourceCode: string
+ * }} SourceDetails
+ */
+
+/**
+ * @typedef {{
+ *   version: string
+ *   getScriptHashType: (purpose: string) => any
+ *   typeCheck: (validators: string[], modules: string[]) => ({
+ *     modules: {[name: string]: TypeCheckedModule},
+ *     validators: {[name: string]: TypeCheckedValidator}
+ *   })
+ *   compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput
+ * }} CompilerLib
+ */