@helios-lang/contract-utils 0.1.20 → 0.1.24

package/src/codegen/Writer.js

@@ -1,37 +0,0 @@
-export class Writer {
-    /**
-     * @private
-     * @readonly
-     * @type {string[]}
-     */
-    parts
-
-    constructor() {
-        this.parts = []
-    }
-
-    /**
-     * @param {string} part
-     * @returns {Writer}
-     */
-    write(part) {
-        this.parts.push(part)
-        return this
-    }
-
-    /**
-     * @param {string} line
-     * @returns {Writer}
-     */
-    writeLine(line) {
-        this.parts.push(`${line}\n`)
-        return this
-    }
-
-    /**
-     * @returns {string}
-     */
-    finalize() {
-        return this.parts.join("")
-    }
-}

package/src/lib/Lib.js

@@ -1,56 +0,0 @@
-/**
- * @typedef {{
- *   allValidatorTypes: {[name: string]: any},
- *   otherValidators: {[name: string]: {purpose: string, hash: string}},
- *   dependsOnOwnHash?: boolean,
- *   ownHash?: string,
- *   optimize: boolean
- * }} CompileOptions
- */
-
-/**
- * @typedef {{
- *   cborHex: string
- *   prettyIR: string
- * }} CompileOutput
- */
-
-/**
- * @typedef {{
- *   isMainnet?: boolean
- *   checkCasts?: boolean
- *   moduleOrder?: string[]
- * }} LibOptions
- */
-
-/**
- * @typedef {{
- *   version: string
- *   getValidatorType: (purpose: string) => any
- *   typeCheck: (validators: {[name: string]: SourceDetails}, modules: {[name: string]: SourceDetails}) => ({
- * modules: {[name: string]: ModuleDetails}, validators: {[name: string]: ValidatorDetails}})
- *   compile: (main: string, modules: string[], options: CompileOptions) => CompileOutput
- * }} Lib
- */
-
-/**
- * @typedef {import("../codegen/index.js").TypeSchema} InternalTypeDetails
- * @typedef {import("../codegen/index.js").Module} ModuleDetails
- * @typedef {import("../codegen/index.js").Validator} ValidatorDetails
- */
-
-/**
- * @typedef {{
- *   name: string
- *   purpose: string
- *   sourceCode: string
- * }} SourceDetails
- */
-
-/**
- * @param {{VERSION: string}} lib
- * @returns {number[]}
- */
-export function getVersion(lib) {
-    return lib.VERSION.split(".").map((v) => Number(v))
-}

package/src/lib/index.js

@@ -1,6 +0,0 @@
-export { loadLibrary } from "./load.js"
-
-/**
- * @typedef {import("./Lib.js").Lib} Lib
- * @typedef {import("./Lib.js").LibOptions} LibOptions
- */

package/src/lib/load.js

@@ -1,26 +0,0 @@
-import * as lib from "@helios-lang/compiler"
-import { getVersion } from "./Lib.js"
-import { Lib_v0_16 } from "./Libg_v0_16.js"
-
-/**
- * @typedef {import("./Lib.js").Lib} Lib
- * @typedef {import("./Lib.js").LibOptions} LibOptions
- */
-
-/**
- * @param {LibOptions} options
- * @returns {Lib}
- */
-export function loadLibrary(options = {}) {
-    const [major, minor] = getVersion(lib)
-
-    switch (major) {
-        case 0:
-            switch (minor) {
-                case 16:
-                    return new Lib_v0_16(lib, options)
-            }
-        default:
-            throw new Error(`compiler version ${lib.VERSION} not supported`)
-    }
-}

package/src/runtime/ContractContext.js

@@ -1,35 +0,0 @@
-import { ScriptHash } from "@helios-lang/ledger"
-import { UplcProgramV2 } from "@helios-lang/uplc"
-import { Cast } from "./Cast.js"
-
-/**
- * @typedef {{
- *   $name: string
- *   $purpose: string
- *   $program: {
- *     optimized: UplcProgramV2
- *     unoptimized: UplcProgramV2
- *   }
- *   $hash: ScriptHash
- *   $Redeemer: Cast<any, any>
- *   $Datum?: Cast<any, any>
- * }} Validator
- */
-
-/**
- * @template {{[name: string]: Validator}} T
- */
-export class ContractContext {
-    /**
-     * @readonly
-     * @type {T}
-     */
-    validators
-
-    /**
-     * @param {T} validators
-     */
-    constructor(validators) {
-        this.validators = validators
-    }
-}

package/src/runtime/ContractContextBuilder.js

@@ -1,340 +0,0 @@
-import { bytesToHex } from "@helios-lang/codec-utils"
-import {
-    ScriptHash,
-    StakingValidatorHash,
-    ValidatorHash,
-    MintingPolicyHash
-} from "@helios-lang/ledger"
-import { None, expectSome } from "@helios-lang/type-utils"
-import { UplcProgramV2 } from "@helios-lang/uplc"
-import { loadLibrary } from "../lib/index.js"
-import { Cast } from "./Cast.js"
-import { ContractContext } from "./ContractContext.js"
-
-/**
- * @typedef {import("../lib/index.js").Lib} Lib
- * @typedef {import("../lib/index.js").LibOptions} LibOptions
- * @typedef {import("./ContractContext.js").Validator} CompiledValidator
- */
-
-/**
- * @template TRedeemerStrict
- * @template TRedeemerPermissive
- * @typedef {import("@helios-lang/ledger").MintingContext<TRedeemerStrict, TRedeemerPermissive>} MintingContext
- */
-
-/**
- * @template TDatumStrict
- * @template TDatumPermissive
- * @template TRedeemerStrict
- * @template TRedeemerPermissive
- * @typedef {import("@helios-lang/ledger").SpendingContext<TDatumStrict, TDatumPermissive, TRedeemerStrict, TRedeemerPermissive>} SpendingContext
- */
-
-/**
- * @template TRedeemerStrict
- * @template TRedeemerPermissive
- * @typedef {import("@helios-lang/ledger").StakingContext<TRedeemerStrict, TRedeemerPermissive>} StakingContext
- */
-
-/**
- * @template {Cast} C
- * @typedef {import("./PermissiveType.js").PermissiveType<C>} PermissiveType
- */
-
-/**
- * @template {Cast} C
- * @typedef {import("./StrictType.js").StrictType<C>} StrictType
- */
-
-/**
- * @typedef {{
- *   $name: string
- *   $sourceCode: string
- *   $dependencies: Module[]
- * }} Module
- */
-
-/**
- * @typedef {{
- *   $name: string
- *   $purpose: string
- *   $sourceCode: string
- *   $dependencies: Module[]
- *   $hashDependencies: Validator[]
- *   $dependsOnOwnHash: boolean
- *   $Redeemer: Cast<any, any>
- *   $Datum?: Cast<any, any>
- * }} Validator
- */
-
-/**
- * @template {{[name: string]: Validator}} T
- */
-export class ContractContextBuilder {
-    /**
-     * @private
-     * @readonly
-     * @type {T}
-     */
-    validators
-
-    /**
-     * @private
-     * @readonly
-     * @type {Option<Module[]>}
-     */
-    forcedModules
-
-    /**
-     * @private
-     * @param {T} validators
-     * @param {Option<Module[]>} forcedModules
-     */
-    constructor(validators, forcedModules = None) {
-        this.validators = validators
-        this.forcedModules = forcedModules
-    }
-
-    /**
-     * @returns {ContractContextBuilder<{}>}
-     */
-    static new() {
-        return new ContractContextBuilder({})
-    }
-
-    /**
-     * @param {Module[]} modules
-     * @returns {ContractContextBuilder<T>}
-     */
-    setModules(modules) {
-        return new ContractContextBuilder(this.validators, modules)
-    }
-
-    /**
-     * @template {Validator} V
-     * @param {V} validator
-     * @returns {ContractContextBuilder<T & {
-     *   [K in V["$name"]]: V
-     * }>}
-     */
-    with(validator) {
-        return new ContractContextBuilder(
-            {
-                ...this.validators,
-                [validator.$name]: validator
-            },
-            this.forcedModules
-        )
-    }
-
-    /**
-     * @private
-     * @param {Validator} validator
-     * @returns {Map<string, string>}
-     */
-    getModules(validator) {
-        if (this.forcedModules) {
-            return new Map(
-                this.forcedModules.map((m) => [m.$name, m.$sourceCode])
-            )
-        }
-
-        /**
-         * @type {Map<string, string>}
-         */
-        const result = new Map()
-        let stack = validator.$dependencies.slice()
-        let m = stack.pop()
-
-        while (m) {
-            if (!result.has(m.$name)) {
-                result.set(m.$name, m.$sourceCode)
-
-                stack = stack.concat(m.$dependencies)
-            }
-
-            m = stack.pop()
-        }
-
-        return result
-    }
-
-    /**
-     * @private
-     * @param {Lib} lib
-     * @returns {{[name: string]: any}}
-     */
-    getValidatorTypes(lib) {
-        return Object.fromEntries(
-            Object.entries(this.validators).map(([name, v]) => {
-                return [name, lib.getValidatorType(v.$purpose)]
-            })
-        )
-    }
-
-    /**
-     * @param {Option<{[name: string]: string}>} expectedHashes
-     * @param {LibOptions} options
-     * @returns {{
-     *   [K in keyof T]:
-     *     T[K]["$purpose"] extends "spending" ? ValidatorHash<
-     *       SpendingContext<
-     *         StrictType<T[K]["$Datum"]>,
-     *         PermissiveType<T[K]["$Datum"]>,
-     *         StrictType<T[K]["$Redeemer"]>,
-     *         PermissiveType<T[K]["$Redeemer"]>
-     *       >
-     *     > :
-     *     T[K]["$purpose"] extends "minting" ? MintingPolicyHash<
-     *       MintingContext<
-     *         StrictType<T[K]["$Redeemer"]>,
-     *         PermissiveType<T[K]["$Redeemer"]>
-     *       >
-     *     > :
-     *     T[K]["$purpose"] extends ("certifying" | "rewarding") ? StakingValidatorHash<
-     *       StakingContext<
-     *         StrictType<T[K]["$Redeemer"]>,
-     *         PermissiveType<T[K]["$Redeemer"]>
-     *       >
-     *     > : never
-     * }}
-     */
-    build(expectedHashes = None, options = {}) {
-        const lib = loadLibrary(options)
-
-        const allValidatorTypes = this.getValidatorTypes(lib)
-
-        /**
-         * @type {{[name: string]: (
-         *   ValidatorHash<SpendingContext<any, any, any, any>> |
-         *   MintingPolicyHash<MintingContext<any, any>> |
-         *   StakingValidatorHash<StakingContext<any, any>>
-         * )}}
-         */
-        const validators = {}
-
-        /**
-         * @returns {{[name: string]: {purpose: string, hash: string}}}
-         */
-        function getOtherValidators() {
-            /**
-             * @type {{[name: string]: {purpose: string, hash: string}}}
-             */
-            const otherValidators = {}
-
-            for (let k in validators) {
-                const v = validators[k]
-
-                if (v instanceof ValidatorHash) {
-                    otherValidators[k] = {
-                        purpose: "spending",
-                        hash: v.toHex()
-                    }
-                } else if (v instanceof MintingPolicyHash) {
-                    otherValidators[k] = {
-                        purpose: "minting",
-                        hash: v.toHex()
-                    }
-                } else if (v instanceof StakingValidatorHash) {
-                    otherValidators[k] = {
-                        purpose: "staking",
-                        hash: v.toHex()
-                    }
-                } else {
-                    throw new Error("unexpected ScriptHash")
-                }
-            }
-
-            return otherValidators
-        }
-
-        /**
-         * @param {Validator} validator
-         */
-        const buildValidator = (validator) => {
-            const name = validator.$name
-
-            if (name in validators) {
-                return
-            }
-
-            for (let v of validator.$hashDependencies) {
-                buildValidator(v)
-            }
-
-            const modules = this.getModules(validator)
-
-            const { cborHex: optimizedCborHex, prettyIR } = lib.compile(
-                validator.$sourceCode,
-                Array.from(modules.values()),
-                {
-                    optimize: true,
-                    otherValidators: getOtherValidators(),
-                    allValidatorTypes: allValidatorTypes,
-                    dependsOnOwnHash: validator.$dependsOnOwnHash
-                }
-            )
-
-            const optimizedProgram = UplcProgramV2.fromCbor(optimizedCborHex)
-
-            const ownHash = bytesToHex(optimizedProgram.hash())
-
-            if (expectedHashes && name in expectedHashes) {
-                if (expectedHashes[name] != ownHash) {
-                    console.log(prettyIR)
-
-                    throw new Error(
-                        `expected hash ${expectedHashes[name]} for validator ${name}, got ${ownHash}`
-                    )
-                }
-            }
-
-            const purpose = validator.$purpose
-
-            const { cborHex: unoptimizedCborHex } = lib.compile(
-                validator.$sourceCode,
-                Array.from(modules.values()),
-                {
-                    optimize: false,
-                    otherValidators: getOtherValidators(),
-                    allValidatorTypes: allValidatorTypes,
-                    ownHash: validator.$dependsOnOwnHash ? ownHash : undefined
-                }
-            )
-
-            const unoptimizedProgram =
-                UplcProgramV2.fromCbor(unoptimizedCborHex)
-
-            if (purpose == "spending") {
-                validators[name] = new ValidatorHash(ownHash, {
-                    program: optimizedProgram.withAlt(unoptimizedProgram),
-                    datum: expectSome(validator.$Datum),
-                    redeemer: validator.$Redeemer
-                })
-            } else if (purpose == "minting") {
-                validators[name] = new MintingPolicyHash(ownHash, {
-                    program: optimizedProgram.withAlt(unoptimizedProgram),
-                    redeemer: validator.$Redeemer
-                })
-            } else if (
-                purpose == "staking" ||
-                purpose == "certifying" ||
-                purpose == "rewarding"
-            ) {
-                validators[name] = new StakingValidatorHash(ownHash, {
-                    program: optimizedProgram.withAlt(unoptimizedProgram),
-                    redeemer: validator.$Redeemer
-                })
-            } else {
-                throw new Error("unhandled purpose")
-            }
-        }
-
-        for (let k in this.validators) {
-            buildValidator(this.validators[k])
-        }
-
-        return /** @type {any} */ (validators)
-    }
-}

package/src/runtime/index.js

@@ -1,3 +0,0 @@
-export { Cast } from "./Cast.js"
-export { ContractContext } from "./ContractContext.js"
-export { ContractContextBuilder } from "./ContractContextBuilder.js"