@helios-lang/contract-utils 0.3.10 → 0.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helios-lang/contract-utils",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Convenience and type-safety utilities for using Helios validators from within Typescript",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/artifacts/ArtifactWriter.js

@@ -1,8 +1,10 @@
 import { makeStringWriter } from "@helios-lang/codec-utils"
 import { expectDefined } from "@helios-lang/type-utils"
+import { collectBuiltinTypes } from "../codegen/TypeSchema.js"
 
 /**
  * @import { StringWriter } from "@helios-lang/codec-utils"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
  * @import { FileSystem } from "../index.js"
  */
 
@@ -61,6 +63,17 @@ export class ArtifactWriter {
         return this
     }
 
+    /**
+     * @param {TypeSchema} schema
+     */
+    collectAndImportTypes(schema) {
+        const internalTypes = collectBuiltinTypes(schema)
+
+        Array.from(internalTypes.entries()).forEach(([name, from]) => {
+            this.addImport(name, from, true)
+        })
+    }
+
     /**
      * @param {string} line
      * @returns {ArtifactWriter}

package/src/artifacts/ChildArtifactWriter.js

@@ -45,6 +45,14 @@ export class ChildArtifactWriter extends ArtifactWriter {
      * @returns {ChildArtifactWriter}
      */
     writeProgram(name, program, includeDef) {
+        this.writeDeclLine(`export const $programCborHex: string`)
+
+        if (includeDef) {
+            this.writeDefLine(
+                `export const $programCborHex = "${bytesToHex(program.toCbor())}"`
+            )
+        }
+
         if (program.plutusVersion == "PlutusScriptV1") {
             this.addImport("UplcProgramV1", "@helios-lang/uplc", true)
             this.writeDeclLine(`export const ${name}: UplcProgramV1`)
@@ -102,7 +110,7 @@ function stringifyProgram(decoderName, program) {
     const sourceMap = makeUplcSourceMap({ term: program.root })
 
     return `/* @__PURE__ */ ${decoderName}(
-    "${bytesToHex(program.toCbor())}",
+    $programCborHex,
     {${stringifyAlt("decodeUplcProgramV2FromCbor", program.alt)}
         sourceMap: ${JSON.stringify(sourceMap.toJsonSafe(), undefined, 4).split("\n").join("\n        ")}
     }

package/src/artifacts/FunctionArtifact.js

@@ -1,11 +1,17 @@
+import { bytesToHex } from "@helios-lang/codec-utils"
+import { expectDefined, isRight } from "@helios-lang/type-utils"
+import { convertFromUplcData } from "../cast/index.js"
 import {
-    genFuncType,
     genUserFuncArgsType,
     genUserFuncRetType
 } from "../codegen/LoadedScriptsWriter.js"
+import { genTypes } from "../codegen/TypeSchema.js"
 import { ChildArtifactWriter } from "./ChildArtifactWriter.js"
 
 /**
+ * @import { Address, AssetClass } from "@helios-lang/ledger"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { UplcData, UplcProgram } from "@helios-lang/uplc"
  * @import { UserFuncProps } from "../index.js"
  * @import { Artifact } from "./Artifact.js"
  * @import { FunctionDetails } from "./symbols.js"
@@ -24,7 +30,7 @@ export function writeFunctionArtifact(parent, name, details) {
 
     artifact.writeProgram("$program", program, true)
     artifact.writeProps(props)
-    artifact.writeEvals(props)
+    artifact.writeEvals(program, props)
 
     artifact.save()
 
@@ -49,13 +55,15 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
     }
 
     /**
+     * @param {UplcProgram} program
      * @param {UserFuncProps} props
      */
-    writeEvals(props) {
+    writeEvals(program, props) {
         const safeArgsType = genUserFuncArgsType(props)
         const unsafeArgsType = genUserFuncArgsType(props, true)
         const retType = genUserFuncRetType(props)
         const unsafeRetType = genUserFuncRetType(props, true)
+        const isConst = safeArgsType == "{}"
 
         this.addImport("UplcLogger", "@helios-lang/uplc", true)
         this.addImport("UplcData", "@helios-lang/uplc", true)
@@ -63,28 +71,190 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
 
         this.addImport("evalUserFunc", "@helios-lang/contract-utils")
             .writeDeclLine(
-                `export function $eval(args${safeArgsType == "{}" ? "?" : ""}: ${safeArgsType}, logOptions?: UplcLogger | undefined): ${retType}`
+                `export function $eval(args${isConst ? "?" : ""}: ${safeArgsType}, logOptions?: UplcLogger | undefined): ${retType}`
             )
             .writeDefLine(
-                `export function $eval(args${safeArgsType == "{}" ? " = {}" : ""}, logOptions = undefined) {
+                `export function $eval(args${isConst ? " = {}" : ""}, logOptions = undefined) {
     return evalUserFunc($program, $props, args, logOptions)
 }`
             )
             .addImport("evalUserFuncUnsafe", "@helios-lang/contract-utils")
             .writeDeclLine(
-                `export function $evalUnsafe(args${unsafeArgsType == "{}" ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): ${unsafeRetType}`
+                `export function $evalUnsafe(args${isConst ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): ${unsafeRetType}`
             )
             .writeDefLine(
-                `export function $evalUnsafe(args${unsafeArgsType == "{}" ? " = {}" : ""}, logOptions = undefined) {
+                `export function $evalUnsafe(args${isConst ? " = {}" : ""}, logOptions = undefined) {
     return evalUserFuncUnsafe($program, $props, args, logOptions)
 }`
             )
             .addImport("profileUserFunc", "@helios-lang/contract-utils")
             .writeDeclLine(
-                `export function $profile(args${unsafeArgsType == "{}" ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): CekResult`
+                `export function $profile(args${isConst ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): CekResult`
             )
-            .writeDefLine(`export function $profile(args${unsafeArgsType == "{}" ? " = {}" : ""}, logOptions = undefined) {
+            .writeDefLine(`export function $profile(args${isConst ? " = {}" : ""}, logOptions = undefined) {
     return profileUserFunc($program, $props, args, logOptions)
 }`)
+
+        if (isConst && props.returns) {
+            // attempt to evaluate, and add $constData and $constValue
+            try {
+                const result = program.eval([])
+
+                if (
+                    isRight(result.result) &&
+                    typeof result.result.right != "string" &&
+                    result.result.right.kind == "data"
+                ) {
+                    const data = result.result.right.value
+
+                    const uplcDataType = expectDefined(
+                        {
+                            int: "IntData",
+                            bytes: "ByteArrayData",
+                            constr: "ConstrData",
+                            map: "MapData",
+                            list: "ListData"
+                        }[data.kind]
+                    )
+
+                    this.addImport(uplcDataType, "@helios-lang/uplc", true)
+                        .writeDeclLine(`export const $constCborHex: string`)
+                        .writeDefLine(
+                            `export const $constCborHex = "${bytesToHex(data.toCbor())}"`
+                        )
+                        .writeDeclLine(
+                            `export const $constData: ${uplcDataType}`
+                        )
+                        .addImport("decodeUplcData", "@helios-lang/uplc", false)
+                        .writeDefLine(
+                            `export const $constData = /* @__PURE__ */ decodeUplcData($constCborHex)`
+                        )
+
+                    const valueTypeSchema = props.returns
+                    const valueTypes = genTypes(valueTypeSchema)
+                    this.collectAndImportTypes(valueTypeSchema)
+                    this.writeDeclLine(
+                        `export const $constValue: ${valueTypes[0]}`
+                    )
+
+                    const value = convertFromUplcData(valueTypeSchema, data, {
+                        isMainnet: this.isMainnet
+                    })
+                    const constValueStr = this.stringifyConstValue(
+                        valueTypeSchema,
+                        data,
+                        value
+                    )
+
+                    if (constValueStr !== undefined) {
+                        this.writeDefLine(
+                            `export const $constValue = ${constValueStr}`
+                        )
+                    } else {
+                        // fallback
+                        this.addImport(
+                            "convertFromUplcData",
+                            "@helios-lang/contract-utils"
+                        )
+                            .writeDefLine(`export const $constValue = /* @__PURE__ */ convertFromUplcData(${JSON.stringify(valueTypeSchema)}, $constData, {
+    isMainnet: ${this.isMainnet}
+})`)
+                    }
+                }
+            } catch (_e) {
+                // don't do anything, simply ignore
+            }
+        }
+    }
+
+    /**
+     * @param {TypeSchema} schema
+     * @param {UplcData} data
+     * @param {any} value
+     * @returns {string | undefined}
+     */
+    stringifyConstValue(schema, data, value) {
+        // TODO: it might be more efficient to represent the following directly as a primitive value
+        if (schema.kind == "internal" && schema.name == "Address") {
+            /**
+             * @type {Address}
+             */
+            const v = value
+            if (v.era == "Shelley") {
+                this.addImport(
+                    "makeShelleyAddress",
+                    "@helios-lang/ledger",
+                    false
+                )
+                return `/* @__PURE__ */ makeShelleyAddress("${v.toBech32()}")`
+            }
+        } else if (schema.kind == "internal" && schema.name == "AssetClass") {
+            /**
+             * @type {AssetClass}
+             */
+            const v = value
+            this.addImport("parseAssetClass", "@helios-lang/ledger", false)
+            return `/* @__PURE__ */ parseAssetClass("${v.toString()}")`
+        } else if (schema.kind == "internal" && schema.name == "Bool") {
+            /**
+             * @type {boolean}
+             */
+            const v = value
+            return v.toString()
+        } else if (schema.kind == "internal" && schema.name == "ByteArray") {
+            /**
+             * @type {number[]}
+             */
+            const v = value
+            return `[${v.map((b) => b.toString()).join(", ")}]`
+        } else if (
+            schema.kind == "internal" &&
+            ["Any", "Data"].includes(schema.name)
+        ) {
+            return "$constData"
+        } else if (
+            schema.kind == "internal" &&
+            ["Duration", "Int"].includes(schema.name)
+        ) {
+            /**
+             * @type {bigint}
+             */
+            const v = value
+            return `${v.toString()}n`
+        } else if (
+            schema.kind == "internal" &&
+            [
+                "MintingPolicyHash",
+                "PubKeyHash",
+                "StakingValidatorHash",
+                "TxId",
+                "ValidatorHash"
+            ].includes(schema.name)
+        ) {
+            /**
+             * @type {{bytes: number[]}}
+             */
+            const v = value
+            const makerFunc = `make${schema.name}`
+            this.addImport(makerFunc, "@helios-lang/ledger", false)
+            return `/* @__PURE__ */ ${makerFunc}("${bytesToHex(v.bytes)}")`
+        } else if (
+            schema.kind == "internal" &&
+            ["Real", "Time"].includes(schema.name)
+        ) {
+            /**
+             * @type {number}
+             */
+            const v = value
+            return v.toString()
+        } else if (schema.kind == "internal" && schema.name == "String") {
+            /**
+             * @type {string}
+             */
+            const v = value
+            return `"${v.toString()}"`
+        }
+
+        return undefined
     }
 }

package/src/artifacts/TypeArtifact.js

@@ -1,4 +1,4 @@
-import { collectBuiltinTypes, genTypes } from "../codegen/TypeSchema.js"
+import { genTypes } from "../codegen/TypeSchema.js"
 import { ChildArtifactWriter } from "./ChildArtifactWriter.js"
 import { writeFunctionArtifact } from "./FunctionArtifact.js"
 
@@ -73,11 +73,7 @@ export const $schema = ${JSON.stringify(schema, undefined, 4)}`
         this.writeDeclLine(`export type $StrictType = ${types[0]}`)
         this.writeDeclLine(`export type $PermissiveType = ${types[1]}`)
 
-        const internalTypes = collectBuiltinTypes(schema)
-
-        Array.from(internalTypes.entries()).forEach(([name, from]) => {
-            this.addImport(name, from, true)
-        })
+        this.collectAndImportTypes(schema)
     }
 
     writeConverters() {

package/src/artifacts/ValidatorArtifact.js

@@ -206,9 +206,11 @@ class ValdiatorArtifact extends ModuleArtifact {
         super.writeAggregateExport(name)
 
         if (name == "main") {
-            this.writeDefLine(
-                `import { $program } from "./${name}/index.js"`
-            ).writeDefLine(`export { $program }`)
+            this.writeDefLine(`import { $program } from "./${name}/index.js"`)
+                .writeDefLine(`export { $program }`)
+                .writeDefLine(
+                    `export { $programCborHex } from "./${name}/index.js"`
+                )
             this.hasMainFunction = true
         }
 

package/types/artifacts/ArtifactWriter.d.ts

@@ -1,5 +1,6 @@
 /**
  * @import { StringWriter } from "@helios-lang/codec-utils"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
  * @import { FileSystem } from "../index.js"
  */
 export class ArtifactWriter {
@@ -40,6 +41,10 @@ export class ArtifactWriter {
      * @returns {ArtifactWriter}
      */
     addImport(name: string, from: string, isType?: boolean): ArtifactWriter;
+    /**
+     * @param {TypeSchema} schema
+     */
+    collectAndImportTypes(schema: TypeSchema): void;
     /**
      * @param {string} line
      * @returns {ArtifactWriter}
@@ -61,4 +66,5 @@ export class ArtifactWriter {
     save(): void;
 }
 import type { FileSystem } from "../index.js";
+import type { TypeSchema } from "@helios-lang/type-utils";
 //# sourceMappingURL=ArtifactWriter.d.ts.map

package/types/artifacts/ArtifactWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ArtifactWriter.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;IA+BI;;;OAGG;IACH,gBAHW,UAAU,OACV,MAAM,EAShB;IAzCD;;;OAGG;IACH,aAFU,UAAU,CAElB;IAEF;;;OAGG;IACH,cAFU,MAAM,CAEb;IAEH;;;OAGG;IACH,aAAI;IAEJ;;;OAGG;IACH,YAAG;IAEH;;;OAGG;IACH,gBAAO;IAeP;;;;;OAKG;IACH,gBALW,MAAM,QACN,MAAM,WACN,OAAO,GACL,cAAc,CAK1B;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,cAAc,CAM1B;IAED;;OAEG;IACH,aA8DC;CACJ;gCAxJ8B,aAAa"}
+{"version":3,"file":"ArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ArtifactWriter.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;IA+BI;;;OAGG;IACH,gBAHW,UAAU,OACV,MAAM,EAShB;IAzCD;;;OAGG;IACH,aAFU,UAAU,CAElB;IAEF;;;OAGG;IACH,cAFU,MAAM,CAEb;IAEH;;;OAGG;IACH,aAAI;IAEJ;;;OAGG;IACH,YAAG;IAEH;;;OAGG;IACH,gBAAO;IAeP;;;;;OAKG;IACH,gBALW,MAAM,QACN,MAAM,WACN,OAAO,GACL,cAAc,CAK1B;IAED;;OAEG;IACH,8BAFW,UAAU,QAQpB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,cAAc,CAK1B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,cAAc,CAM1B;IAED;;OAEG;IACH,aA8DC;CACJ;gCAnK8B,aAAa;gCADb,yBAAyB"}

package/types/artifacts/ChildArtifactWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChildArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ChildArtifactWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,oBAHW,QAAQ,QACR,MAAM,EAOhB;IArBD;;;OAGG;IACH,iBAFU,QAAQ,CAEZ;IAEN;;;OAGG;IACH,eAFU,MAAM,CAEZ;IAaJ;;OAEG;IACH,iBAFU,OAAO,CAIhB;IAED;;;;;OAKG;IACH,mBALW,MAAM,WACN,WAAW,cACX,OAAO,GACL,mBAAmB,CA+C/B;CACJ;+BA1F8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}
+{"version":3,"file":"ChildArtifactWriter.d.ts","sourceRoot":"","sources":["../../src/artifacts/ChildArtifactWriter.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,oBAHW,QAAQ,QACR,MAAM,EAOhB;IArBD;;;OAGG;IACH,iBAFU,QAAQ,CAEZ;IAEN;;;OAGG;IACH,eAFU,MAAM,CAEZ;IAaJ;;OAEG;IACH,iBAFU,OAAO,CAIhB;IAED;;;;;OAKG;IACH,mBALW,MAAM,WACN,WAAW,cACX,OAAO,GACL,mBAAmB,CAuD/B;CACJ;+BAlG8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}

package/types/artifacts/FunctionArtifact.d.ts

@@ -1,4 +1,7 @@
 /**
+ * @import { Address, AssetClass } from "@helios-lang/ledger"
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { UplcData, UplcProgram } from "@helios-lang/uplc"
  * @import { UserFuncProps } from "../index.js"
  * @import { Artifact } from "./Artifact.js"
  * @import { FunctionDetails } from "./symbols.js"

package/types/artifacts/FunctionArtifact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/FunctionArtifact.js"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH;;;;GAIG;AACH,8CAJW,QAAQ,QACR,MAAM,WACN,eAAe,QAezB;8BAtB4B,eAAe;qCACR,cAAc"}
+{"version":3,"file":"FunctionArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/FunctionArtifact.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AAEH;;;;GAIG;AACH,8CAJW,QAAQ,QACR,MAAM,WACN,eAAe,QAezB;8BAtB4B,eAAe;qCACR,cAAc"}