@helios-lang/contract-utils 0.3.5 → 0.3.6

package/src/artifacts/TypeArtifact.js

@@ -0,0 +1,104 @@
+import { collectBuiltinTypes, genTypes } from "../codegen/TypeSchema.js"
+import { ChildArtifactWriter } from "./ChildArtifactWriter.js"
+import { writeFunctionArtifact } from "./FunctionArtifact.js"
+
+/**
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { Artifact } from "./Artifact.js"
+ * @import { FunctionDetails, TypeDetails } from "./symbols.js"
+ */
+
+/**
+ *
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {TypeDetails} props
+ * @param {Record<string, FunctionDetails>} members
+ */
+export function writeTypeArtifact(parent, name, props, members) {
+    const artifact = new TypeArtifact(parent, name)
+
+    const schema = props.schema
+
+    artifact.writeSchema(schema)
+    artifact.writeType(schema)
+    artifact.writeConverters()
+
+    for (let memberName in members) {
+        writeFunctionArtifact(artifact, memberName, members[memberName])
+    }
+
+    // also write enum members
+    if (schema.kind == "enum") {
+        for (let variant of schema.variantTypes) {
+            writeTypeArtifact(artifact, variant.name, { schema: variant }, {})
+        }
+    }
+
+    artifact.save()
+
+    parent.writeAggregateExport(name)
+}
+
+class TypeArtifact extends ChildArtifactWriter {
+    /**
+     * @param {Artifact} parent
+     * @param {string} name
+     */
+    constructor(parent, name) {
+        super(parent, name)
+    }
+
+    /**
+     * @param {TypeSchema} schema
+     */
+    writeSchema(schema) {
+        this.addImport("TypeSchema", "@helios-lang/type-utils", true)
+
+        this.writeDeclLine(`export const $schema: TypeSchema`)
+        this.writeDefLine(
+            `/**
+ * @type {import("@helios-lang/type-utils").TypeSchema}
+ */
+export const $schema = ${JSON.stringify(schema, undefined, 4)}`
+        )
+    }
+
+    /**
+     * @param {TypeSchema} schema
+     */
+    writeType(schema) {
+        const types = genTypes(schema)
+
+        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)
+        })
+    }
+
+    writeConverters() {
+        this.addImport("convertToUplcData", "@helios-lang/contract-utils")
+        this.addImport("convertFromUplcData", "@helios-lang/contract-utils")
+        this.addImport("UplcData", "@helios-lang/uplc", true)
+
+        this.writeDeclLine(
+            `export function $toUplcData(x: $PermissiveType): UplcData`
+        )
+        this.writeDeclLine(
+            `export function $fromUplcData(data: UplcData): $StrictType`
+        )
+
+        this.writeDefLine(`export function $toUplcData(x) {
+    return convertToUplcData($schema, x)
+}`)
+        this.writeDefLine(`export function $fromUplcData(data) {
+    return convertFromUplcData($schema, data, {
+        isMainnet: ${this.isMainnet}
+    })
+}`)
+    }
+}

package/src/artifacts/ValidatorArtifact.js

@@ -0,0 +1,158 @@
+import { genTypes } from "../codegen/TypeSchema.js"
+import { ModuleArtifact } from "./ModuleArtifact.js"
+
+/**
+ * @import { MintingContext, ScriptHash, SpendingContext, StakingContext } from "@helios-lang/ledger"
+ * @import { Cast } from "../index.js"
+ * @import { Artifact } from "./Artifact.js"
+ * @import { ModuleSymbols } from "./symbols.js"
+ */
+
+/**
+ * @param {Artifact} parent
+ * @param {string} name
+ * @param {ScriptHash} hash
+ * @param {ModuleSymbols} symbols
+ */
+export function writeValidatorArtifact(parent, name, hash, symbols) {
+    const artifact = new ValdiatorArtifact(parent, name)
+
+    artifact.writeHash(hash)
+
+    artifact.writeSymbols(symbols)
+
+    artifact.save()
+
+    parent.writeAggregateExport(name)
+}
+
+/**
+ * @implements {Artifact}
+ */
+class ValdiatorArtifact extends ModuleArtifact {
+    /**
+     * @param {Artifact} parent
+     * @param {string} name
+     */
+    constructor(parent, name) {
+        super(parent, name)
+    }
+
+    /**
+     * @param {ScriptHash} hash
+     */
+    writeHash(hash) {
+        // TODO: SpendingContext, MintingContext, StakingContext
+        if (hash.kind == "MintingPolicyHash") {
+            this.addImport(
+                "MintingPolicyHash",
+                "@helios-lang/ledger",
+                true
+            ).addImport("makeMintingPolicyHash", "@helios-lang/ledger")
+
+            if (!hash.context) {
+                this.writeDeclLine(
+                    `export const $hash: MintingPolicyHash`
+                ).writeDefLine(
+                    `export const $hash = makeMintingPolicyHash("${hash.toHex()}")`
+                )
+            } else {
+                this.addImport("makeCast", "@helios-lang/contract-utils")
+                this.addImport("MintingContext", "@helios-lang/ledger", true)
+
+                const context =
+                    /** @type {MintingContext<unknown, unknown>} */ (
+                        hash.context
+                    )
+                const program = context.program
+                const redeemer = /** @type {Cast<unknown, unknown>} */ (
+                    context.redeemer
+                )
+                const types = genTypes(redeemer.schema)
+
+                this.writeProgram("$program", program).writeDeclLine(
+                    `export const $hash: MintingPolicyHash<MintingContext<${types[0]}, ${types[1]}>>`
+                )
+                    .writeDefLine(`export const $hash = makeMintingPolicyHash("${hash.toHex()}", {
+    program: $program,
+    redeemer: makeCast(${JSON.stringify(redeemer.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}})
+})`)
+            }
+        } else if (hash.kind == "StakingValidatorHash") {
+            this.addImport(
+                "StakingValidatorHash",
+                "@helios-lang/ledger",
+                true
+            ).addImport("makeStakingValidatorHash", "@helios-lang/ledger")
+
+            if (!hash.context) {
+                this.writeDeclLine(
+                    `export const $hash: StakingValidatorHash`
+                ).writeDefLine(
+                    `export const $hash = makeStakingValidatorHash("${hash.toHex()}")`
+                )
+            } else {
+                this.addImport("makeCast", "@helios-lang/contract-utils")
+                this.addImport("StakingContext", "@helios-lang/ledger", true)
+
+                const context =
+                    /** @type {StakingContext<unknown, unknown>} */ (
+                        hash.context
+                    )
+                const program = context.program
+                const redeemer = /** @type {Cast<unknown, unknown>} */ (
+                    context.redeemer
+                )
+                const types = genTypes(redeemer.schema)
+
+                this.writeProgram("$program", program).writeDeclLine(
+                    `export const $hash: StakingValidatorHash<StakingContext<${types[0]}, ${types[1]}>>`
+                )
+                    .writeDefLine(`export const $hash = makeStakingValidatorHash("${hash.toHex()}", {
+    program: $program,
+    redeemer: makeCast(${JSON.stringify(redeemer.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}})
+})`)
+            }
+        } else if (hash.kind == "ValidatorHash") {
+            this.addImport(
+                "ValidatorHash",
+                "@helios-lang/ledger",
+                true
+            ).addImport("makeValidatorHash", "@helios-lang/ledger")
+
+            if (!hash.context) {
+                this.writeDeclLine(
+                    `export const $hash: ValidatorHash`
+                ).writeDefLine(
+                    `export const $hash = makeValidatorHash("${hash.toHex()}")`
+                )
+            } else {
+                this.addImport("makeCast", "@helios-lang/contract-utils")
+                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).writeDeclLine(
+                    `export const $hash: ValidatorHash<SpendingContext<${dTypes[0]}, ${dTypes[1]}, ${rTypes[0]}, ${rTypes[1]}>>`
+                )
+                    .writeDefLine(`export const $hash = makeValidatorHash("${hash.toHex()}", {
+    program: $program,
+    datum: makeCast(${JSON.stringify(datum.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}}),
+    redeemer: makeCast(${JSON.stringify(redeemer.schema, undefined, 4).split("\n").join("\n    ")}, {isMainnet: ${this.isMainnet}})
+})`)
+            }
+        }
+    }
+}

package/src/artifacts/index.js

@@ -0,0 +1 @@
+export { writeContractContextArtifacts } from "./RootArtifact.js"

package/src/artifacts/symbols.js

@@ -0,0 +1,16 @@
+/**
+ * @import { TypeSchema } from "@helios-lang/type-utils"
+ * @import { Cast, UserFunc } from "../index.js"
+ */
+
+/**
+ * @typedef {UserFunc<any, any>} FunctionDetails
+ */
+
+/**
+ * @typedef {{schema: TypeSchema}} TypeDetails
+ */
+
+/**
+ * @typedef {Record<string, FunctionDetails | TypeDetails>} ModuleSymbols
+ */

package/src/cast/Cast.js

@@ -125,12 +125,11 @@ class CastImpl {
      * @returns {TStrict}
      */
     fromUplcData(data, dataPath = "") {
-        return convertUplcDataToSchemaDataWithDataPath(this.schema, data, {
+        return convertFromUplcData(this.schema, data, {
             isMainnet: this.config.isMainnet,
             unwrapSingleFieldEnumVariants:
                 !!this.config.unwrapSingleFieldEnumVariants,
-            dataPath,
-            defs: {}
+            dataPath
         })
     }
 
@@ -146,17 +145,54 @@ class CastImpl {
      * @returns {UplcData}
      */
     toUplcData(x, dataPath = "") {
-        const t = convertSchemaDataToUplcDataWithDataPath(this.schema, x, {
-            defs: {},
+        return convertToUplcData(this.schema, x, {
+            dataPath,
             unwrapSingleFieldEnumVariants:
-                !!this.config.unwrapSingleFieldEnumVariants,
-            dataPath
+                !!this.config.unwrapSingleFieldEnumVariants
         })
-        t.rawData = x
-        return t
     }
 }
 
+/**
+ * @template T
+ * @param {TypeSchema} schema
+ * @param {UplcData} data
+ * @param {{
+ *   isMainnet: boolean,
+ *   dataPath?: string,
+ *   unwrapSingleFieldEnumVariants?: boolean
+ * }} options
+ * @returns {T}
+ */
+export function convertFromUplcData(schema, data, options) {
+    return convertUplcDataToSchemaDataWithDataPath(schema, data, {
+        isMainnet: options.isMainnet,
+        unwrapSingleFieldEnumVariants: !!options.unwrapSingleFieldEnumVariants,
+        dataPath: options.dataPath ?? "",
+        defs: {}
+    })
+}
+
+/**
+ * @template T
+ * @param {TypeSchema} schema
+ * @param {T} x
+ * @param {{
+ *   dataPath?: string,
+ *   unwrapSingleFieldEnumVariants?: boolean
+ * }} [options]
+ * @returns {UplcData}
+ */
+export function convertToUplcData(schema, x, options = {}) {
+    const t = convertSchemaDataToUplcDataWithDataPath(schema, x, {
+        defs: {},
+        unwrapSingleFieldEnumVariants: !!options.unwrapSingleFieldEnumVariants,
+        dataPath: options.dataPath ?? ""
+    })
+    t.rawData = x
+    return t
+}
+
 /**
  * @param {TypeSchema} schema
  * @param {any} x - data