@helios-lang/contract-utils 0.3.11 → 0.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helios-lang/contract-utils",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "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"
  */
 
@@ -53,14 +55,25 @@ export class ArtifactWriter {
     /**
      * @param {string} name
      * @param {string} from
-     * @param {boolean} [isType]
+     * @param {boolean} isType
      * @returns {ArtifactWriter}
      */
-    addImport(name, from, isType = false) {
+    addImport(name, from, isType) {
         this.imports.push([name, from, isType])
         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`)
@@ -52,7 +60,8 @@ export class ChildArtifactWriter extends ArtifactWriter {
             if (includeDef) {
                 this.addImport(
                     "decodeUplcProgramV1FromCbor",
-                    "@helios-lang/uplc"
+                    "@helios-lang/uplc",
+                    false
                 )
                 this.writeDefLine(
                     `export const ${name} = ${stringifyProgram("decodeUplcProgramV1FromCbor", program)}`
@@ -65,7 +74,8 @@ export class ChildArtifactWriter extends ArtifactWriter {
             if (includeDef) {
                 this.addImport(
                     "decodeUplcProgramV2FromCbor",
-                    "@helios-lang/uplc"
+                    "@helios-lang/uplc",
+                    false
                 )
                 this.writeDefLine(
                     `export const ${name} = ${stringifyProgram("decodeUplcProgramV2FromCbor", program)}`
@@ -78,7 +88,8 @@ export class ChildArtifactWriter extends ArtifactWriter {
             if (includeDef) {
                 this.addImport(
                     "decodeUplcProgramV3FromCbor",
-                    "@helios-lang/uplc"
+                    "@helios-lang/uplc",
+                    false
                 )
                 this.writeDefLine(
                     `export const ${name} = ${stringifyProgram("decodeUplcProgramV3FromCbor", program)}`
@@ -102,7 +113,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,13 +1,17 @@
 import { bytesToHex } from "@helios-lang/codec-utils"
 import { expectDefined, isRight } from "@helios-lang/type-utils"
+import { convertFromUplcData } from "../cast/index.js"
 import {
     genUserFuncArgsType,
     genUserFuncRetType
 } from "../codegen/LoadedScriptsWriter.js"
+import { genTypes } from "../codegen/TypeSchema.js"
 import { ChildArtifactWriter } from "./ChildArtifactWriter.js"
 
 /**
- * @import { UplcProgram } from "@helios-lang/uplc"
+ * @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"
@@ -65,7 +69,7 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
         this.addImport("UplcData", "@helios-lang/uplc", true)
         this.addImport("CekResult", "@helios-lang/uplc", true)
 
-        this.addImport("evalUserFunc", "@helios-lang/contract-utils")
+        this.addImport("evalUserFunc", "@helios-lang/contract-utils", false)
             .writeDeclLine(
                 `export function $eval(args${isConst ? "?" : ""}: ${safeArgsType}, logOptions?: UplcLogger | undefined): ${retType}`
             )
@@ -74,7 +78,11 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
     return evalUserFunc($program, $props, args, logOptions)
 }`
             )
-            .addImport("evalUserFuncUnsafe", "@helios-lang/contract-utils")
+            .addImport(
+                "evalUserFuncUnsafe",
+                "@helios-lang/contract-utils",
+                false
+            )
             .writeDeclLine(
                 `export function $evalUnsafe(args${isConst ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): ${unsafeRetType}`
             )
@@ -83,7 +91,7 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
     return evalUserFuncUnsafe($program, $props, args, logOptions)
 }`
             )
-            .addImport("profileUserFunc", "@helios-lang/contract-utils")
+            .addImport("profileUserFunc", "@helios-lang/contract-utils", false)
             .writeDeclLine(
                 `export function $profile(args${isConst ? "?" : ""}: ${unsafeArgsType}, logOptions?: UplcLogger | undefined): CekResult`
             )
@@ -91,8 +99,8 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
     return profileUserFunc($program, $props, args, logOptions)
 }`)
 
-        if (isConst) {
-            // attempt to evaluate, and add $data
+        if (isConst && props.returns) {
+            // attempt to evaluate, and add $constData and $constValue
             try {
                 const result = program.eval([])
 
@@ -114,19 +122,144 @@ export const $props = ${JSON.stringify(props, undefined, 4)}`)
                     )
 
                     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("${bytesToHex(data.toCbor())}")`
+                            `export const $constData = /* @__PURE__ */ decodeUplcData($constCborHex)`
                         )
 
-                    // TODO: $constValue
+                    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",
+                            false
+                        )
+                            .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/RootArtifact.js

@@ -33,6 +33,7 @@ export function writeContractContextArtifacts(context, options) {
                 root,
                 moduleName,
                 moduleDetails.$hash,
+                moduleDetails.$purpose,
                 moduleDetails
             )
 

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,16 +73,20 @@ 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() {
-        this.addImport("convertToUplcData", "@helios-lang/contract-utils")
-        this.addImport("convertFromUplcData", "@helios-lang/contract-utils")
+        this.addImport(
+            "convertToUplcData",
+            "@helios-lang/contract-utils",
+            false
+        )
+        this.addImport(
+            "convertFromUplcData",
+            "@helios-lang/contract-utils",
+            false
+        )
         this.addImport("UplcData", "@helios-lang/uplc", true)
 
         this.writeDeclLine(

package/src/artifacts/ValidatorArtifact.js

@@ -12,14 +12,15 @@ import { ModuleArtifact } from "./ModuleArtifact.js"
  * @param {Artifact} parent
  * @param {string} name
  * @param {ScriptHash} hash
+ * @param {string} purpose
  * @param {ModuleSymbols} symbols
  */
-export function writeValidatorArtifact(parent, name, hash, symbols) {
+export function writeValidatorArtifact(parent, name, hash, purpose, symbols) {
     const artifact = new ValdiatorArtifact(parent, name)
 
     artifact.writeSymbols(symbols)
 
-    artifact.writeHash(hash)
+    artifact.writeHash(hash, purpose)
 
     artifact.save()
 
@@ -47,17 +48,149 @@ class ValdiatorArtifact extends ModuleArtifact {
 
     /**
      * @param {ScriptHash} hash
+     * @param {string} purpose
      */
-    writeHash(hash) {
+    writeHash(hash, purpose) {
         this.writeDeclLine(`export const $hashHex: string`)
         this.writeDefLine(`export const $hashHex = "${hash.toHex()}"`)
 
-        if (hash.kind == "MintingPolicyHash") {
+        if (purpose == "mixed") {
+            this.addImport("ValidatorHash", "@helios-lang/ledger", true)
+                .addImport("makeValidatorHash", "@helios-lang/ledger", false)
+                .addImport("MintingPolicyHash", "@helios-lang/ledger", true)
+                .addImport(
+                    "makeMintingPolicyHash",
+                    "@helios-lang/ledger",
+                    false
+                )
+                .addImport("StakingValidatorHash", "@helios-lang/ledger", true)
+                .addImport(
+                    "makeStakingValidatorHash",
+                    "@helios-lang/ledger",
+                    false
+                )
+
+            if (!hash.context) {
+                this.writeDeclLine(`export const $validatorHash: ValidatorHash`)
+                    .writeDefLine(
+                        `export const $validatorHash = /* @__PURE__ */ makeValidatorHash($hashHex)`
+                    )
+                    .writeDeclLine(
+                        `export const $mintingPolicyHash: MintingPolicyHash`
+                    )
+                    .writeDefLine(
+                        `export const $mintingPolicyHash = /* @__PURE__ */ makeMintingPolicyHash($hashHex)`
+                    )
+                    .writeDeclLine(
+                        `export const $stakingValidatorHash: StakingValidatorHash`
+                    )
+                    .writeDefLine(
+                        `export const $stakingValidatorHash = /* @__PURE__ */ makeStakingValidatorHash($hashHex)`
+                    )
+                    .addImport("ShelleyAddress", "@helios-lang/ledger", true)
+                    .writeDeclLine(
+                        `export const $validatorAddress: ShelleyAddress`
+                    )
+                    .addImport(
+                        "makeShelleyAddress",
+                        "@helios-lang/ledger",
+                        false
+                    )
+                    .writeDefLine(
+                        `export const $validatorAddress = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $validatorHash)`
+                    )
+            } else {
+                this.writeDeclLine(
+                    `export const $validatorHashWithoutContext: ValidatorHash`
+                )
+                    .writeDefLine(
+                        `export const $validatorHashWithoutContext = /* @__PURE__ */ makeValidatorHash($hashHex)`
+                    )
+                    .writeDeclLine(
+                        `export const $mintingPolicyHashWithoutContext: MintingPolicyHash`
+                    )
+                    .writeDefLine(
+                        `export const $mintingPolicyHashWithoutContext = /* @__PURE__ */ makeMintingPolicyHash($hashHex)`
+                    )
+                    .writeDeclLine(
+                        `export const $stakingValidatorHashWithoutContext: StakingValidatorHash`
+                    )
+                    .writeDefLine(
+                        `export const $stakingValidatorHashWithoutContext = /* @__PURE__ */ makeStakingValidatorHash($hashHex)`
+                    )
+                    .addImport("ShelleyAddress", "@helios-lang/ledger", true)
+                    .writeDeclLine(
+                        `export const $addressWithoutContext: ShelleyAddress`
+                    )
+                    .addImport(
+                        "makeShelleyAddress",
+                        "@helios-lang/ledger",
+                        false
+                    )
+                    .writeDefLine(
+                        `export const $addressWithoutContext = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $validatorHashWithoutContext)`
+                    )
+
+                this.addImport("makeCast", "@helios-lang/contract-utils", false)
+                this.addImport("SpendingContext", "@helios-lang/ledger", true)
+
+                const context =
+                    /** @type {SpendingContext<unknown, unknown, unknown, unknown>} */ (
+                        hash.context
+                    )
+                const program = context.program
+                const datum = /** @type {Cast<unknown, unknown>} */ (
+                    context.datum
+                )
+                const redeemer = /** @type {Cast<unknown, unknown>} */ (
+                    context.redeemer
+                )
+                const dTypes = genTypes(datum.schema)
+                const rTypes = genTypes(redeemer.schema)
+
+                this.writeProgram("$program", program, !this.hasMainFunction)
+
+                this.writeDeclLine(
+                    `export type $ContextType = SpendingContext<${dTypes[0]}, ${dTypes[1]}, ${rTypes[0]}, ${rTypes[1]}>`
+                )
+                    .writeDeclLine(
+                        `export const $validatorHash: ValidatorHash<$ContextType>`
+                    )
+                    .writeDefLine(
+                        `const $context = {
+    program: $program,
+    datum: /* @__PURE__ */ makeCast(${JSON.stringify(datum.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}}),
+    redeemer: /* @__PURE__ */ makeCast(${JSON.stringify(redeemer.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}})
+})`
+                    )
+                    .writeDefLine(
+                        `export const $validatorHash = /* @__PURE__ */ makeValidatorHash($hashHex, $context)`
+                    )
+                    .writeDeclLine(
+                        `export const $mintingPolicyHash: MintingPolicyHash<$ContextType>`
+                    )
+                    .writeDefLine(
+                        `export const $mintingPolicyHash = /* @__PURE__ */ makeMintingPolicyHash($hashHex, $context)`
+                    )
+                    .writeDeclLine(
+                        `export const $stakingValidatorHash: StakingValidatorHash<$ContextType>`
+                    )
+                    .writeDefLine(
+                        `export const $stakingValidatorHash = /* @__PURE__ */ makeStakingValidatorHash($hashHex, $context)`
+                    )
+                    .writeDeclLine(
+                        `export const $address: ShelleyAddress<ValidatorHash<$ContextType>>`
+                    )
+                    .writeDefLine(
+                        `export const $address = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $validatorHash)`
+                    )
+            }
+        } else if (hash.kind == "MintingPolicyHash") {
             this.addImport(
                 "MintingPolicyHash",
                 "@helios-lang/ledger",
                 true
-            ).addImport("makeMintingPolicyHash", "@helios-lang/ledger")
+            ).addImport("makeMintingPolicyHash", "@helios-lang/ledger", false)
 
             if (!hash.context) {
                 this.writeDeclLine(
@@ -72,7 +205,7 @@ class ValdiatorArtifact extends ModuleArtifact {
                     `export const $hashWithoutContext = /* @__PURE__ */ makeMintingPolicyHash($hashHex)`
                 )
 
-                this.addImport("makeCast", "@helios-lang/contract-utils")
+                this.addImport("makeCast", "@helios-lang/contract-utils", false)
                 this.addImport("MintingContext", "@helios-lang/ledger", true)
 
                 const context =
@@ -102,7 +235,11 @@ class ValdiatorArtifact extends ModuleArtifact {
                 "StakingValidatorHash",
                 "@helios-lang/ledger",
                 true
-            ).addImport("makeStakingValidatorHash", "@helios-lang/ledger")
+            ).addImport(
+                "makeStakingValidatorHash",
+                "@helios-lang/ledger",
+                false
+            )
 
             if (!hash.context) {
                 this.writeDeclLine(
@@ -117,7 +254,7 @@ class ValdiatorArtifact extends ModuleArtifact {
                     `export const $hashWithoutContext = /* @__PURE__*/ makeStakingValidatorHash($hashHex)`
                 )
 
-                this.addImport("makeCast", "@helios-lang/contract-utils")
+                this.addImport("makeCast", "@helios-lang/contract-utils", false)
                 this.addImport("StakingContext", "@helios-lang/ledger", true)
 
                 const context =
@@ -147,22 +284,44 @@ class ValdiatorArtifact extends ModuleArtifact {
                 "ValidatorHash",
                 "@helios-lang/ledger",
                 true
-            ).addImport("makeValidatorHash", "@helios-lang/ledger")
+            ).addImport("makeValidatorHash", "@helios-lang/ledger", false)
 
             if (!hash.context) {
-                this.writeDeclLine(
-                    `export const $hash: ValidatorHash`
-                ).writeDefLine(
-                    `export const $hash = /* @__PURE__ */ makeValidatorHash($hashHex)`
-                )
+                this.writeDeclLine(`export const $hash: ValidatorHash`)
+                    .writeDefLine(
+                        `export const $hash = /* @__PURE__ */ makeValidatorHash($hashHex)`
+                    )
+                    .addImport("ShelleyAddress", "@helios-lang/ledger", true)
+                    .writeDeclLine(`export const $address: ShelleyAddress`)
+                    .addImport(
+                        "makeShelleyAddress",
+                        "@helios-lang/ledger",
+                        false
+                    )
+                    .writeDefLine(
+                        `export const $address = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $hash)`
+                    )
             } else {
                 this.writeDeclLine(
                     `export const $hashWithoutContext: ValidatorHash`
-                ).writeDefLine(
-                    `export const $hashWithoutContext = /* @__PURE__ */ makeValidatorHash($hashHex)`
                 )
+                    .writeDefLine(
+                        `export const $hashWithoutContext = /* @__PURE__ */ makeValidatorHash($hashHex)`
+                    )
+                    .addImport("ShelleyAddress", "@helios-lang/ledger", true)
+                    .writeDeclLine(
+                        `export const $addressWithoutContext: ShelleyAddress`
+                    )
+                    .addImport(
+                        "makeShelleyAddress",
+                        "@helios-lang/ledger",
+                        false
+                    )
+                    .writeDefLine(
+                        `export const $addressWithoutContext = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $hashWithoutContext)`
+                    )
 
-                this.addImport("makeCast", "@helios-lang/contract-utils")
+                this.addImport("makeCast", "@helios-lang/contract-utils", false)
                 this.addImport("SpendingContext", "@helios-lang/ledger", true)
 
                 const context =
@@ -188,11 +347,20 @@ class ValdiatorArtifact extends ModuleArtifact {
                         `export const $hash: ValidatorHash<$ContextType>`
                     )
                     .writeDefLine(
-                        `export const $hash = /* @__PURE__ */ makeValidatorHash($hashHex, {
+                        `const $context = {
     program: $program,
     datum: /* @__PURE__ */ makeCast(${JSON.stringify(datum.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}}),
     redeemer: /* @__PURE__ */ makeCast(${JSON.stringify(redeemer.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}})
-})`
+}`
+                    )
+                    .writeDefLine(
+                        `export const $hash = /* @__PURE__ */ makeValidatorHash($hashHex, $context)`
+                    )
+                    .writeDeclLine(
+                        `export const $address: ShelleyAddress<ValidatorHash<$ContextType>>`
+                    )
+                    .writeDefLine(
+                        `export const $address = /* @__PURE__ */ makeShelleyAddress(${this.isMainnet}, $hash)`
                     )
             }
         }
@@ -206,9 +374,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 {
@@ -36,10 +37,14 @@ export class ArtifactWriter {
     /**
      * @param {string} name
      * @param {string} from
-     * @param {boolean} [isType]
+     * @param {boolean} isType
      * @returns {ArtifactWriter}
      */
-    addImport(name: string, from: string, isType?: boolean): 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,UACN,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,CA0D/B;CACJ;+BArG8B,qBAAqB;8BAIvB,eAAe;iCADZ,mBAAmB"}

package/types/artifacts/FunctionArtifact.d.ts

@@ -1,5 +1,7 @@
 /**
- * @import { UplcProgram } from "@helios-lang/uplc"
+ * @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":"AAQA;;;;;GAKG;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"}

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

@@ -1 +1 @@
-{"version":3,"file":"RootArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/RootArtifact.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,uDAHW,GAAG,WACH,oCAAoC,QAmC9C;0DAzCyJ,aAAa"}
+{"version":3,"file":"RootArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/RootArtifact.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH,uDAHW,GAAG,WACH,oCAAoC,QAoC9C;0DA1CyJ,aAAa"}

package/types/artifacts/ValidatorArtifact.d.ts

@@ -8,9 +8,10 @@
  * @param {Artifact} parent
  * @param {string} name
  * @param {ScriptHash} hash
+ * @param {string} purpose
  * @param {ModuleSymbols} symbols
  */
-export function writeValidatorArtifact(parent: Artifact, name: string, hash: ScriptHash, symbols: ModuleSymbols): void;
+export function writeValidatorArtifact(parent: Artifact, name: string, hash: ScriptHash, purpose: string, symbols: ModuleSymbols): void;
 import type { Artifact } from "./Artifact.js";
 import type { ScriptHash } from "@helios-lang/ledger";
 import type { ModuleSymbols } from "./symbols.js";

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

@@ -1 +1 @@
-{"version":3,"file":"ValidatorArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/ValidatorArtifact.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;;;GAKG;AACH,+CALW,QAAQ,QACR,MAAM,QACN,UAAU,WACV,aAAa,QAYvB;8BApB4B,eAAe;gCAFoC,qBAAqB;mCAGnE,cAAc"}
+{"version":3,"file":"ValidatorArtifact.d.ts","sourceRoot":"","sources":["../../src/artifacts/ValidatorArtifact.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,+CANW,QAAQ,QACR,MAAM,QACN,UAAU,WACV,MAAM,WACN,aAAa,QAYvB;8BArB4B,eAAe;gCAFoC,qBAAqB;mCAGnE,cAAc"}