@helios-lang/contract-utils 0.1.40 → 0.2.0

package/src/codegen/LoadedScriptsWriter.js

@@ -127,25 +127,76 @@ export class LoadedScriptsWriter {
         return this
     }
 
+    /**
+     * @param {string} path
+     * @param {string} typeName
+     * @param {string[]} typeParams
+     * @returns {LoadedScriptsWriter}
+     */
+    writeImportType(path, typeName, typeParams = []) {
+        this.definition.writeLine("/**")
+
+        for (let tp of typeParams) {
+            this.definition.writeLine(` * @template ${tp}`)
+        }
+
+        this.definition
+            .writeLine(
+                ` * @typedef {import("${path}").${typeName}${typeParams.length > 0 ? `<${typeParams.join(", ")}>` : ""}} ${typeName}`
+            )
+            .writeLine(" */")
+        ;[this.declaration, this.combined].forEach((w) => {
+            w.writeLine(`import type { ${typeName} } from "${path}";`)
+        })
+
+        return this
+    }
+
+    /**
+     * @param {string} path
+     * @param {string[]} objectNames
+     * @returns {LoadedScriptsWriter}
+     */
+    writeImport(path, ...objectNames) {
+        ;[this.definition, this.declaration, this.combined].forEach((w) => {
+            w.writeLine(`import { ${objectNames.join(", ")} } from "${path}";`)
+        })
+
+        return this
+    }
+
     /**
      * @private
      */
     writeHeaders() {
-        this.definition.writeLine(
-            'import { Cast } from "@helios-lang/contract-utils";'
+        this.writeImport("@helios-lang/contract-utils", "Cast")
+        this.writeImport(
+            "@helios-lang/ledger",
+            "Address",
+            "AssetClass",
+            "DatumHash",
+            "MintingPolicyHash",
+            "PubKey",
+            "PubKeyHash",
+            "SpendingCredential",
+            "StakingCredential",
+            "StakingHash",
+            "StakingValidatorHash",
+            "TimeRange",
+            "TxId",
+            "TxOutputDatum",
+            "ValidatorHash",
+            "Value"
         )
-        ;[this.declaration, this.combined].forEach((w) => {
-            w.writeLine(
-                'import type { IntLike } from "@helios-lang/codec-utils";'
-            )
-            w.writeLine('import { Cast } from "@helios-lang/contract-utils";')
-            w.writeLine(
-                'import type { TimeLike, UplcData } from "@helios-lang/ledger";'
-            )
-            w.writeLine(
-                'import { Address, AssetClass, DatumHash, MintingPolicyHash, PubKey, PubKeyHash, SpendingCredential, StakingCredential, StakingHash, StakingValidatorHash, TimeRange, TxId, TxOutputDatum, ValidatorHash, Value } from "@helios-lang/ledger";'
-            )
-        })
+        this.writeImportType("@helios-lang/codec-utils", "IntLike")
+        this.writeImportType("@helios-lang/contract-utils", "CastConfig")
+        this.writeImportType(
+            "@helios-lang/contract-utils",
+            "ConfigurableCast",
+            ["TStrict", "TPermissive"]
+        )
+        this.writeImportType("@helios-lang/ledger", "TimeLike")
+        this.writeImportType("@helios-lang/ledger", "UplcData")
     }
 
     /**
@@ -153,20 +204,28 @@ export class LoadedScriptsWriter {
      * @param {Record<string, TypeSchema>} types
      */
     writeTypes(types) {
+        ;[this.definition, this.declaration, this.combined].forEach((w) =>
+            w.write("    $types: {\n")
+        )
+
         for (let key in types) {
             const t = types[key]
             const tsTypes = genTypes(t)
 
             this.definition.write(
-                `    ${key}: new Cast(${JSON.stringify(t)}),\n`
+                `        ${key}: (config) => /** @type {Cast<${tsTypes[0]}, ${tsTypes[1]}>} */ (new Cast(${JSON.stringify(t)}, config)),\n`
             )
             this.declaration.write(
-                `    ${key}: Cast<${tsTypes[0]}, ${tsTypes[1]}>,\n`
+                `        ${key}: ConfigurableCast<${tsTypes[0]}, ${tsTypes[1]}>,\n`
             )
             this.combined.write(
-                `    ${key}: new Cast<${tsTypes[0]}, ${tsTypes[1]}>(${JSON.stringify(t)}),\n`
+                `        ${key}: (config: CastConfig) => new Cast<${tsTypes[0]}, ${tsTypes[1]}>(${JSON.stringify(t)}, config),\n`
             )
         }
+
+        ;[this.definition, this.declaration, this.combined].forEach((w) =>
+            w.write("    },\n")
+        )
     }
 
     /**
@@ -175,10 +234,10 @@ export class LoadedScriptsWriter {
      */
     writeModule(m) {
         this.definition.write(`export const ${m.name} = {
-    $name: "${m.name}",
-    $purpose: "${m.purpose}",
+    $name: /** @type {const} */ ("${m.name}"),
+    $purpose: /** @type {const} */ ("${m.purpose}"),
     $sourceCode: ${JSON.stringify(m.sourceCode)},
-    $dependencies: [${m.moduleDepedencies.join(", ")}],\n`)
+    $dependencies: /** @type {const} */ ([${m.moduleDepedencies.join(", ")}]),\n`)
 
         this.declaration.write(
             `export const ${m.name}: {
@@ -193,7 +252,7 @@ export class LoadedScriptsWriter {
     $name: "${m.name}" as const,
     $purpose: "${m.purpose}" as const,
     $sourceCode: ${JSON.stringify(m.sourceCode)} as string,
-    $dependencies: [${m.moduleDepedencies.join(", ")}],\n`
+    $dependencies: [${m.moduleDepedencies.join(", ")}] as const,\n`
         )
 
         this.writeTypes(m.types)
@@ -213,14 +272,14 @@ export class LoadedScriptsWriter {
 
         this.definition.write(
             `export const ${v.name} = {
-    $name: "${v.name}",
-    $purpose: "${v.purpose}",
+    $name: /** @type {const} */ ("${v.name}"),
+    $purpose: /** @type {const} */ ("${v.purpose}"),
     $sourceCode: ${JSON.stringify(v.sourceCode)},
-    $dependencies: [${v.moduleDepedencies.join(", ")}],
+    $dependencies: /** @type {const} */ ([${v.moduleDepedencies.join(", ")}]),
     $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
     $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)},
-    $Redeemer: new Cast(${JSON.stringify(v.Redeemer)}),
-${datumTypes ? `    $Datum: new Cast(${JSON.stringify(v.Datum)}),\n` : ""}`
+    $Redeemer: (config) => /** @type {Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>} */ (new Cast(${JSON.stringify(v.Redeemer)}, config)),
+${datumTypes ? `    $Datum: (config) => /** @type {Cast<${datumTypes[0]}, ${datumTypes[1]}>} */ (new Cast(${JSON.stringify(v.Datum)}, config)),\n` : ""}`
         )
 
         this.declaration.write(
@@ -234,8 +293,8 @@ ${datumTypes ? `    $Datum: new Cast(${JSON.stringify(v.Datum)}),\n` : ""}`
         .map((d) => `typeof ${d}`)
         .join(", ")}]
     $dependsOnOwnHash: boolean
-    $Redeemer: Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>
-${datumTypes ? `    $Datum: Cast<${datumTypes[0]}, ${datumTypes[1]}>,\n` : ""}`
+    $Redeemer: ConfigurableCast<${redeemerTypes[0]}, ${redeemerTypes[1]}>
+${datumTypes ? `    $Datum: ConfigurableCast<${datumTypes[0]}, ${datumTypes[1]}>,\n` : ""}`
         )
 
         this.combined.write(
@@ -243,11 +302,11 @@ ${datumTypes ? `    $Datum: Cast<${datumTypes[0]}, ${datumTypes[1]}>,\n` : ""}`
     $name: "${v.name}" as const,
     $purpose: "${v.purpose}" as const,
     $sourceCode: ${JSON.stringify(v.sourceCode)} as string,
-    $dependencies: [${v.moduleDepedencies.join(", ")}],
+    $dependencies: [${v.moduleDepedencies.join(", ")}] as const,
     $hashDependencies: [${v.hashDependencies.filter((d) => d != v.name).join(", ")}],
     $dependsOnOwnHash: ${v.hashDependencies.some((d) => d == v.name)} as boolean,
-    $Redeemer: new Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>(${JSON.stringify(v.Redeemer)}),
-${datumTypes ? `    $Datum: new Cast<${datumTypes[0]}, ${datumTypes[1]}>(${JSON.stringify(v.Datum)}),\n` : ""}`
+    $Redeemer: (config: CastConfig) => new Cast<${redeemerTypes[0]}, ${redeemerTypes[1]}>(${JSON.stringify(v.Redeemer)}, config),
+${datumTypes ? `    $Datum: (config: CastConfig) => new Cast<${datumTypes[0]}, ${datumTypes[1]}>(${JSON.stringify(v.Datum)}, config),\n` : ""}`
         )
 
         this.writeTypes(v.types)

package/src/codegen/LoadedValidator.js

@@ -1,5 +1,11 @@
 import { Cast } from "../cast/Cast.js"
 
+/**
+ * @template TStrict
+ * @template TPermissive
+ * @typedef {import("../cast/Cast.js").CastLike<TStrict, TPermissive>} CastLike
+ */
+
 /**
  * @typedef {import("./LoadedModule.js").LoadedModule} LoadedModule
  */
@@ -8,16 +14,34 @@ import { Cast } from "../cast/Cast.js"
  * @typedef {{
  *   $name: string
  *   $sourceCode: string
- *   $dependencies: LoadedModule[]
- *   $hashDependencies: LoadedValidator[]
+ *   $dependencies: ReadonlyArray<LoadedModule>
+ *   $hashDependencies: ReadonlyArray<LoadedValidator>
  *   $dependsOnOwnHash: boolean
- *   $Redeemer: Cast
+ *   $types: {[name: string]: CastLike<any, any>}
+ *   $Redeemer: CastLike<any, any>
  * } & (
  *   {
  *     $purpose: "spending"
- *     $Datum: Cast
+ *     $Datum: CastLike<any, any>
  *   } | {
  *     $purpose: "minting" | "certifying" | "rewarding" | "staking"
  *   }
  * )} LoadedValidator
  */
+
+/**
+ * @template {{$name: string}} N
+ * @typedef {{
+ *   [name in N["$name"]]: Extract<N, {"$name": name}>
+ * }} NamedDependencyToObject
+ */
+
+/**
+ * @template {ReadonlyArray<{$name: string}>} N
+ * @typedef {NamedDependencyToObject<N extends ReadonlyArray<infer M> ? M : never>} NamedDependenciesToObject
+ */
+
+/**
+ * @template {LoadedValidator} V
+ * @typedef {NamedDependenciesToObject<V["$dependencies"]>} ExtractDependencies
+ */

package/src/context/ContractContext.js

@@ -6,6 +6,7 @@ import {
 import { Cast } from "../cast/index.js"
 
 /**
+ * @typedef {import("../codegen/index.js").LoadedModule} LoadedModule
  * @typedef {import("../codegen/index.js").LoadedValidator} LoadedValidator
  */
 
@@ -30,12 +31,18 @@ import { Cast } from "../cast/index.js"
  */
 
 /**
- * @template {Cast} C
+ * @template TStrict
+ * @template TPermissive
+ * @typedef {import("../cast/index.js").CastLike<TStrict, TPermissive>} CastLike
+ */
+
+/**
+ * @template {CastLike<any, any>} C
  * @typedef {import("../cast/index.js").PermissiveType<C>} PermissiveType
  */
 
 /**
- * @template {Cast} C
+ * @template {CastLike<any, any>} C
  * @typedef {import("../cast/index.js").StrictType<C>} StrictType
  */
 
@@ -44,35 +51,59 @@ import { Cast } from "../cast/index.js"
  *   ValidatorHash<SpendingContext<any, any, any, any>> |
  *   MintingPolicyHash<MintingContext<any, any>> |
  *   StakingValidatorHash<StakingContext<any, any>>
- * )} AnyContractValidatorHash
+ * )} AnyContractValidatorContext
  */
 
 /**
  * @template {LoadedValidator} V
- * @typedef {V extends {"$purpose": "spending", "$Datum": Cast} ? ValidatorHash<
- *       SpendingContext<
- *         StrictType<V["$Datum"]>,
- *         PermissiveType<V["$Datum"]>,
- *         StrictType<V["$Redeemer"]>,
- *         PermissiveType<V["$Redeemer"]>
+ * @typedef {V extends {"$purpose": "spending", "$Datum": CastLike<any, any>, "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: ValidatorHash<
+ *         SpendingContext<
+ *           V["$Datum"],
+ *           PermissiveType<V["$Datum"]>,
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
  *       >
- *     > :
- *     V extends {"$purpose": "minting"} ? MintingPolicyHash<
- *       MintingContext<
- *         StrictType<V["$Redeemer"]>,
- *         PermissiveType<V["$Redeemer"]>
+ *     } & ContractTypesContext<V["$types"]> :
+ *     V extends {"$purpose": "minting", "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: MintingPolicyHash<
+ *         MintingContext<
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
  *       >
- *     > :
- *     V extends {"$purpose": ("certifying" | "rewarding" | "staking")} ? StakingValidatorHash<
- *       StakingContext<
- *         StrictType<V["$Redeemer"]>,
- *         PermissiveType<V["$Redeemer"]>
+ *     } & ContractTypesContext<V["$types"]> :
+ *     V extends {"$purpose": ("certifying" | "rewarding" | "staking"), "$Redeemer": CastLike<any, any>} ? {
+ *       $hash: StakingValidatorHash<
+ *         StakingContext<
+ *           StrictType<V["$Redeemer"]>,
+ *           PermissiveType<V["$Redeemer"]>
+ *         >
  *       >
- *     > : never
- * } ContractValidatorHash
+ *     } & ContractTypesContext<V["$types"]> :
+ *     never
+ * } ContractValidatorContexts
+ */
+
+/**
+ * @template {LoadedModule} V
+ * @typedef {ContractTypesContext<V["$types"]>} ContractModuleContexts
+ */
+
+/**
+ * @template {{[typeName:string]: CastLike<any, any>}} T
+ * @typedef {{
+ *   [K in keyof T]: Cast<StrictType<T[K]>, PermissiveType<T[K]>>
+ * }} ContractTypesContext
  */
 
 /**
- * @template {{[name: string]: LoadedValidator}} T
- * @typedef {{[K in keyof T]: ContractValidatorHash<T[K]>}} ContractContext
+ * @template {{[name: string]: LoadedValidator}} Vs
+ * @template {{[name: string]: LoadedModule}} Ms
+ * @typedef {{
+ *   [K in keyof Vs]: ContractValidatorContexts<Vs[K]>
+ * } & {
+ *   [K in keyof Ms]: ContractModuleContexts<Ms[K]>
+ * }} ContractContext
  */

package/src/context/ContractContextBuilder.js

@@ -1,69 +1,157 @@
 import { None } from "@helios-lang/type-utils"
 import { loadCompilerLib } from "../compiler/index.js"
 import { DagCompiler } from "./DagCompiler.js"
+import { configureCast } from "../cast/Cast.js"
 
 /**
+ * @typedef {import("../cast/index.js").CastConfig} CastConfig
  * @typedef {import("../codegen/LoadedModule.js").LoadedModule} LoadedModule
  * @typedef {import("../codegen/LoadedValidator.js").LoadedValidator} LoadedValidator
  * @typedef {import("../compiler/index.js").CompilerLib} CompilerLib
  */
 
 /**
- * @template {{[name: string]: LoadedValidator}} T
- * @typedef {import("./ContractContext.js").ContractContext<T>} ContractContext
+ * @template {LoadedValidator} V
+ * @typedef {import("../codegen/LoadedValidator.js").ExtractDependencies<V>} ExtractDependencies
  */
 
 /**
- * @template {{[name: string]: LoadedValidator}} T
+ * @template {{[name: string]: LoadedValidator}} Vs
+ * @template {{[name: string]: LoadedModule}} Ms
+ * @typedef {import("./ContractContext.js").ContractContext<Vs, Ms>} ContractContext
+ */
+
+/**
+ * @typedef {{
+ *   isMainnet: boolean
+ *   expectedHashes?: {[name: string]: string}
+ * }} ContractContextBuildProps
+ */
+
+/**
+ * @template {{[name: string]: LoadedValidator}} Vs
+ * @template {{[name: string]: LoadedModule}} Ms
  */
 export class ContractContextBuilder {
     /**
      * @private
      * @readonly
-     * @type {T}
+     * @type {Vs}
      */
     validators
 
+    /**
+     * @readonly
+     * @type {Ms}
+     */
+    modules
+
     /**
      * @private
-     * @param {T} validators
+     * @param {Vs} validators
+     * @param {Ms} modules
      */
-    constructor(validators) {
+    constructor(validators, modules) {
         this.validators = validators
+        this.modules = modules
     }
 
     /**
-     * @returns {ContractContextBuilder<{}>}
+     * @returns {ContractContextBuilder<{}, {}>}
      */
     static new() {
-        return new ContractContextBuilder({})
+        return new ContractContextBuilder({}, {})
     }
 
     /**
      * @template {LoadedValidator} V
      * @param {V} validator
-     * @returns {ContractContextBuilder<T & {
-     *   [K in V["$name"]]: V
-     * }>}
+     * @returns {ContractContextBuilder<
+     *   Vs & {[K in V["$name"]]: V},
+     *   Ms & ExtractDependencies<V>
+     * >}
      */
     with(validator) {
-        return new ContractContextBuilder({
-            ...this.validators,
-            [validator.$name]: validator
-        })
+        return new ContractContextBuilder(
+            /** @type {any} */ ({
+                ...this.validators,
+                [validator.$name]: validator
+            }),
+            /** @type {any} */ ({
+                ...this.modules,
+                ...Object.fromEntries(
+                    validator.$dependencies.map((d) => [d.$name, d])
+                )
+            })
+        )
+    }
+
+    /**
+     * @template {LoadedModule} M
+     * @param {M} m
+     * @returns {ContractContextBuilder<
+     *   Vs,
+     *   Ms & {[K in M["$name"]]: M}
+     * >}
+     */
+    withModule(m) {
+        return new ContractContextBuilder(
+            this.validators,
+            /** @type {any} */ ({
+                ...this.modules,
+                [m.$name]: m
+            })
+        )
     }
 
     /**
-     * @param {Option<{[name: string]: string}>} expectedHashes
-     * @returns {ContractContext<T>}
+     * @param {ContractContextBuildProps} props
+     * @returns {ContractContext<Vs, Ms>}
      */
-    build(expectedHashes = None) {
+    build(props) {
+        const castConfig = { isMainnet: props.isMainnet }
         const lib = loadCompilerLib()
 
-        const dagCompiler = new DagCompiler(lib)
+        const dagCompiler = new DagCompiler(lib, castConfig)
 
-        return /** @type {any} */ (
-            dagCompiler.build(Object.values(this.validators), expectedHashes)
+        /**
+         * @type {any}
+         */
+        const hashes = dagCompiler.build(
+            Object.values(this.validators),
+            props.expectedHashes
         )
+
+        /**
+         * @type {any}
+         */
+        const res = {}
+
+        for (let name in this.modules) {
+            res[name] = Object.fromEntries(
+                Object.entries(this.modules[name].$types).map(
+                    ([typeName, castLike]) => [
+                        typeName,
+                        configureCast(castLike, castConfig)
+                    ]
+                )
+            )
+        }
+
+        for (let name in this.validators) {
+            res[name] = {
+                ...Object.fromEntries(
+                    Object.entries(this.validators[name].$types).map(
+                        ([typeName, castLike]) => [
+                            typeName,
+                            configureCast(castLike, castConfig)
+                        ]
+                    )
+                ),
+                $hash: hashes[name]
+            }
+        }
+
+        return res
     }
 }

package/src/context/DagCompiler.js

@@ -6,11 +6,13 @@ import {
 } from "@helios-lang/ledger"
 import { None } from "@helios-lang/type-utils"
 import { UplcProgramV2 } from "@helios-lang/uplc"
+import { configureCast } from "../cast/index.js"
 
 /**
+ * @typedef {import("../cast/index.js").CastConfig} CastConfig
  * @typedef {import("../codegen/LoadedValidator.js").LoadedValidator} LoadedValidator
  * @typedef {import("../compiler/index.js").CompilerLib} CompilerLib
- * @typedef {import("./ContractContext.js").AnyContractValidatorHash} AnyContractValidatorHash
+ * @typedef {import("./ContractContext.js").AnyContractValidatorContext} AnyContractValidatorContext
  */
 
 /**
@@ -27,24 +29,33 @@ export class DagCompiler {
     /**
      * @private
      * @readonly
-     * @type {{[name: string]: AnyContractValidatorHash}}
+     * @type {CastConfig}
+     */
+    config
+
+    /**
+     * @private
+     * @readonly
+     * @type {{[name: string]: AnyContractValidatorContext}}
      */
     cache
 
     /**
      * @param {CompilerLib} lib
+     * @param {CastConfig} castConfig
      */
-    constructor(lib) {
+    constructor(lib, castConfig) {
         this.lib = lib
+        this.castConfig = castConfig
         this.cache = {}
     }
 
     /**
      * @param {LoadedValidator[]} validators
      * @param {Option<{[name: string]: string}>} expectedHashes
-     * @returns {{[name: string]: AnyContractValidatorHash}}
+     * @returns {{[name: string]: AnyContractValidatorContext}}
      */
-    build(validators, expectedHashes = None) {
+    build(validators, castConfig, expectedHashes = None) {
         const hashTypes = this.getHashTypes(validators)
 
         /**
@@ -132,14 +143,14 @@ export class DagCompiler {
      */
     addToCache(validator, program, hash) {
         const name = validator.$name
-        const redeemer = validator.$Redeemer
+        const redeemer = configureCast(validator.$Redeemer, this.castConfig)
 
         switch (validator.$purpose) {
             case "spending":
                 this.cache[name] = new ValidatorHash(hash, {
                     program,
                     redeemer,
-                    datum: validator.$Datum
+                    datum: configureCast(validator.$Datum, this.castConfig)
                 })
                 break
             case "minting":

package/src/index.js

@@ -1,15 +1,5 @@
-export { Cast } from "./cast/index.js"
+export * from "./cast/index.js"
 export { ContractContextBuilder } from "./context/index.js"
 export { typeCheckFiles, typeCheckScripts } from "./compiler/ops.js"
 export { LoadedScriptsWriter } from "./codegen/LoadedScriptsWriter.js"
 export { loadCompilerLib } from "./compiler/ops.js"
-
-/**
- * @template {import("./cast/index.js").Cast} C
- * @typedef {import("./cast/index.js").StrictType<C>} StrictType
- */
-
-/**
- * @template {import("./cast/index.js").Cast} C
- * @typedef {import("./cast/index.js").PermissiveType<C>} PermissiveType
- */