@helios-lang/contract-utils 0.3.4 → 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
+ */