@helios-lang/contract-utils 0.1.6 → 0.1.8

package/types/lib/Libg_v0_16.d.ts

@@ -0,0 +1,233 @@
+/**
+ * @typedef {{
+ *   [name: string]: string[]
+ * }} DagDependencies
+ */
+/**
+ * @typedef {{
+ * }} HashType
+ */
+/**
+ * @typedef {{
+ *   includes: (m: string) => boolean
+ * }} IR
+ */
+/**
+ * @typedef {{
+ *   name: string
+ * }} EnumStatement
+ */
+/**
+ * @typedef {{
+ *   name: string
+ * }} StructStatement
+ */
+/**
+ * @typedef {StructStatement | EnumStatement | any} Statement
+ */
+/**
+ * @typedef {{
+ *   name: {value: string}
+ *   filterDependencies: (all: Module[]) => Module[]
+ *   statements: Statement[]
+ * }} Module
+ */
+/**
+ * @typedef {{
+ *   name: string
+ *   toIR: (ctx: any, extra: Map<string, IR>) => IR
+ *   types: UserTypes
+ *   mainImportedModules: Module[]
+ *   mainModule: Module
+ *   mainArgTypes: DataType[]
+ * }} Program
+ */
+/**
+ * @typedef {{
+ *   typeDetails?: TypeDetails
+ * }} DataType
+ */
+/**
+ * @typedef {{
+ *   type:  string
+ * } | {
+ *   type:     "List"
+ *   itemType: TypeSchema
+ * } | {
+ *   type:      "Map"
+ *   keyType:   TypeSchema
+ *   valueType: TypeSchema
+ * } | {
+ *   type:     "Option"
+ *   someType: TypeSchema
+ * } | {
+ *   type:       "Struct"
+ *   fieldTypes: NamedTypeSchema[]
+ * } | {
+ *   type:         "Enum"
+ *   variantTypes: {name: string, fieldTypes: NamedTypeSchema[]}[]
+ * }} TypeSchema
+ */
+/**
+ * @typedef {{
+ * 	 name: string
+ * } & TypeSchema} NamedTypeSchema
+ */
+/**
+ * @typedef {{
+ *   inputType: string
+ *   outputType: string
+ *   internalType: TypeSchema
+ * }} TypeDetails
+ */
+/**
+ * @typedef {{
+ * }} UserTypes
+ */
+/**
+ * @implements {Lib}
+ */
+export class Lib_v0_16 implements Lib {
+    /**
+     * @param {any} lib
+     */
+    constructor(lib: any);
+    lib: any;
+    /**
+     * @type {string}
+     */
+    get version(): string;
+    /**
+     * @private
+     * @param {string} purpose
+     * @returns {HashType}
+     */
+    private getValidatorType;
+    /**
+     * @private
+     * @param {SourceDetails[]} validators
+     * @param {SourceDetails[]} modules
+     * @param {{[name: string]: HashType}} validatorTypes
+     * @returns {Program[]}
+     */
+    private createPrograms;
+    /**
+     * @private
+     * @param {Program} program
+     * @param {{[name: string]: HashType}} validatorTypes
+     * @returns {IR}
+     */
+    private toTestIR;
+    /**
+     * @private
+     * @param {Program[]} validators
+     * @param {{[name: string]: HashType}} validatorTypes
+     * @returns {DagDependencies}
+     */
+    private buildDagDependencies;
+    /**
+     * @param {{[name: string]: SourceDetails}} validators
+     * @param {{[name: string]: SourceDetails}} modules
+     * @returns {{modules: {[name: string]: ModuleDetails}, validators: {[name: string]: ValidatorDetails}}}
+     */
+    typeCheck(validators: {
+        [name: string]: import("./Lib.js").SourceDetails;
+    }, modules: {
+        [name: string]: import("./Lib.js").SourceDetails;
+    }): {
+        modules: {
+            [name: string]: import("./Lib.js").ModuleDetails;
+        };
+        validators: {
+            [name: string]: import("./Lib.js").ValidatorDetails;
+        };
+    };
+    /**
+     * @param {TypeSchema} it
+     * @returns {InternalTypeDetails}
+     */
+    convertInternalType(it: TypeSchema): InternalTypeDetails;
+    /**
+     * @param {DataType} dt
+     * @returns {InternalTypeDetails}
+     */
+    getInternalTypeDetails(dt: DataType): InternalTypeDetails;
+    /**
+     * @param {string} main
+     * @param {string[]} modules
+     * @param {CompileOptions} options
+     * @returns {CompileOutput}
+     */
+    compile(main: string, modules: string[], options: CompileOptions): CompileOutput;
+}
+export type ModuleDetails = import("../codegen/index.js").Module;
+export type ValidatorDetails = import("../codegen/index.js").Validator;
+export type InternalTypeDetails = import("../codegen/index.js").TypeSchema;
+export type CompileOptions = import("./Lib.js").CompileOptions;
+export type CompileOutput = import("./Lib.js").CompileOutput;
+export type Lib = import("./Lib.js").Lib;
+export type SourceDetails = import("./Lib.js").SourceDetails;
+export type DagDependencies = {
+    [name: string]: string[];
+};
+export type HashType = {};
+export type IR = {
+    includes: (m: string) => boolean;
+};
+export type EnumStatement = {
+    name: string;
+};
+export type StructStatement = {
+    name: string;
+};
+export type Statement = StructStatement | EnumStatement | any;
+export type Module = {
+    name: {
+        value: string;
+    };
+    filterDependencies: (all: Module[]) => Module[];
+    statements: Statement[];
+};
+export type Program = {
+    name: string;
+    toIR: (ctx: any, extra: Map<string, IR>) => IR;
+    types: UserTypes;
+    mainImportedModules: Module[];
+    mainModule: Module;
+    mainArgTypes: DataType[];
+};
+export type DataType = {
+    typeDetails?: TypeDetails;
+};
+export type TypeSchema = {
+    type: string;
+} | {
+    type: "List";
+    itemType: TypeSchema;
+} | {
+    type: "Map";
+    keyType: TypeSchema;
+    valueType: TypeSchema;
+} | {
+    type: "Option";
+    someType: TypeSchema;
+} | {
+    type: "Struct";
+    fieldTypes: NamedTypeSchema[];
+} | {
+    type: "Enum";
+    variantTypes: {
+        name: string;
+        fieldTypes: NamedTypeSchema[];
+    }[];
+};
+export type NamedTypeSchema = {
+    name: string;
+} & TypeSchema;
+export type TypeDetails = {
+    inputType: string;
+    outputType: string;
+    internalType: TypeSchema;
+};
+export type UserTypes = {};
+//# sourceMappingURL=Libg_v0_16.d.ts.map

package/types/lib/Libg_v0_16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Libg_v0_16.d.ts","sourceRoot":"","sources":["../../src/lib/Libg_v0_16.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;;;GAMG;AACH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AAEH;;GAEG;AACH;IACI;;OAEG;IACH,iBAFW,GAAG,EAIb;IADG,SAAc;IAGlB;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,yBAWC;IAED;;;;;;OAMG;IACH,uBAcC;IAED;;;;;OAKG;IACH,iBAWC;IAED;;;;;OAKG;IACH,6BAeC;IAED;;;;OAIG;IACH;;;;;;;;;;;MAuEC;IAED;;;OAGG;IACH,wBAHW,UAAU,GACR,mBAAmB,CAgC/B;IAED;;;OAGG;IACH,2BAHW,QAAQ,GACN,mBAAmB,CAc/B;IAED;;;;;OAKG;IACH,cALW,MAAM,WACN,MAAM,EAAE,WACR,cAAc,GACZ,aAAa,CA4FzB;CACJ;4BAzbY,OAAO,qBAAqB,EAAE,MAAM;+BACpC,OAAO,qBAAqB,EAAE,SAAS;kCACvC,OAAO,qBAAqB,EAAE,UAAU;6BACxC,OAAO,UAAU,EAAE,cAAc;4BACjC,OAAO,UAAU,EAAE,aAAa;kBAChC,OAAO,UAAU,EAAE,GAAG;4BACtB,OAAO,UAAU,EAAE,aAAa;;;;uBAchC,EACT;;kBAKe,MAAM,KAAK,OAAO;;4BAKxB;IACZ,MAAU,MAAM,CAAA;CACb;8BAIS;IACZ,MAAU,MAAM,CAAA;CACb;wBAIS,eAAe,GAAG,aAAa,GAAG,GAAG;;UAKvC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;8BACK,MAAM,EAAE,KAAK,MAAM,EAAE;gBACnC,SAAS,EAAE;;;UAKjB,MAAM;gBACA,GAAG,SAAS,IAAI,MAAM,EAAE,EAAE,CAAC,KAAK,EAAE;WACvC,SAAS;yBACK,MAAM,EAAE;gBACjB,MAAM;kBACJ,QAAQ,EAAE;;uBAKhB;IACZ,WAAe,CAAC,EAAE,WAAW,CAAA;CAC1B;yBAIS;IACZ,IAAQ,EAAG,MAAM,CAAA;CACd,GAAG;IACN,IAAQ,EAAM,MAAM,CAAA;IACpB,QAAY,EAAE,UAAU,CAAA;CACrB,GAAG;IACN,IAAQ,EAAO,KAAK,CAAA;IACpB,OAAW,EAAI,UAAU,CAAA;IACzB,SAAa,EAAE,UAAU,CAAA;CACtB,GAAG;IACN,IAAQ,EAAM,QAAQ,CAAA;IACtB,QAAY,EAAE,UAAU,CAAA;CACrB,GAAG;IACN,IAAQ,EAAQ,QAAQ,CAAA;IACxB,UAAc,EAAE,eAAe,EAAE,CAAA;CAC9B,GAAG;IACN,IAAQ,EAAU,MAAM,CAAA;IACxB,YAAgB,EAAE;QAAC,MAAM,MAAM,CAAC;QAAC,UAAU,EAAE,eAAe,EAAE,CAAA;KAAC,EAAE,CAAA;CAC9D;8BAIS;IACZ,MAAU,MAAM,CAAA;CACb,GAAG,UAAU;0BAIJ;IACZ,SAAa,EAAE,MAAM,CAAA;IACrB,UAAc,EAAE,MAAM,CAAA;IACtB,YAAgB,EAAE,UAAU,CAAA;CACzB;wBAIS,EACT"}

package/types/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { loadLibrary } from "./load.js";
+//# sourceMappingURL=index.d.ts.map

package/types/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.js"],"names":[],"mappings":""}

package/types/lib/load.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @typedef {import("./Lib.js").Lib} Lib
+ */
+/**
+ * @returns {Lib}
+ */
+export function loadLibrary(): Lib;
+export type Lib = import("./Lib.js").Lib;
+//# sourceMappingURL=load.d.ts.map

package/types/lib/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/lib/load.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;GAEG;AACH,+BAFa,GAAG,CAcf;kBAlBY,OAAO,UAAU,EAAE,GAAG"}

package/types/runtime/Cast.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {import("@helios-lang/uplc").UplcData} UplcData
+ * @typedef {import("../codegen/index.js").TypeSchema} TypeSchema
+ */
+/**
+ * @template [TStrict=UplcData]
+ * @template [TPermissive=UplcData]
+ */
+export class Cast<TStrict = import("@helios-lang/ledger").UplcData, TPermissive = import("@helios-lang/ledger").UplcData> {
+    /**
+     * @param {TypeSchema} schema
+     */
+    constructor(schema: TypeSchema);
+    /**
+     * @readonly
+     * @type {TypeSchema}
+     */
+    readonly schema: TypeSchema;
+    /**
+     * @param {UplcData} data
+     * @returns {TStrict}
+     */
+    fromUplcData(data: UplcData): TStrict;
+    /**
+     * @param {TPermissive} x
+     * @returns {UplcData}
+     */
+    toUplcData(x: TPermissive): UplcData;
+}
+export type UplcData = import("@helios-lang/uplc").UplcData;
+export type TypeSchema = import("../codegen/index.js").TypeSchema;
+//# sourceMappingURL=Cast.d.ts.map

package/types/runtime/Cast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/runtime/Cast.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;GAGG;AACH;IAOI;;OAEG;IACH,oBAFW,UAAU,EAIpB;IAXD;;;OAGG;IACH,iBAFU,UAAU,CAEd;IASN;;;OAGG;IACH,mBAHW,QAAQ,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,cAHW,WAAW,GACT,QAAQ,CAIpB;CACJ;uBArCY,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,qBAAqB,EAAE,UAAU"}

package/types/runtime/ContractContext.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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<T extends {
+    [name: string]: Validator;
+}> {
+    /**
+     * @param {T} validators
+     */
+    constructor(validators: T);
+    /**
+     * @readonly
+     * @type {T}
+     */
+    readonly validators: T;
+}
+export type Validator = {
+    $name: string;
+    $purpose: string;
+    $program: {
+        optimized: UplcProgramV2;
+        unoptimized: UplcProgramV2;
+    };
+    $hash: ScriptHash;
+    $Redeemer: Cast<any, any>;
+    $Datum?: Cast<any, any>;
+};
+import { UplcProgramV2 } from "@helios-lang/uplc";
+import { ScriptHash } from "@helios-lang/ledger";
+import { Cast } from "./Cast.js";
+//# sourceMappingURL=ContractContext.d.ts.map

package/types/runtime/ContractContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractContext.d.ts","sourceRoot":"","sources":["../../src/runtime/ContractContext.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH;;GAEG;AACH;;;IAOI;;OAEG;IACH,wBAFW,CAAC,EAIX;IAXD;;;OAGG;IACH,qBAFU,CAAC,CAED;CAQb;wBA7BY;IACZ,KAAS,EAAE,MAAM,CAAA;IACjB,QAAY,EAAE,MAAM,CAAA;IACpB,QAAY,EAAE;QACd,SAAe,EAAE,aAAa,CAAA;QAC9B,WAAiB,EAAE,aAAa,CAAA;KAC3B,CAAA;IACL,KAAS,EAAE,UAAU,CAAA;IACrB,SAAa,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,CAAA;IAC7B,MAAU,CAAC,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,CAAA;CACxB;8BAd0B,mBAAmB;2BADtB,qBAAqB;qBAE3B,WAAW"}

package/types/runtime/ContractContextBuilder.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @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<T extends {
+    [name: string]: Validator;
+}> {
+    /**
+     * @returns {ContractContextBuilder<{}>}
+     */
+    static "new"(): ContractContextBuilder<{}>;
+    /**
+     * @private
+     * @param {T} validators
+     */
+    private constructor();
+    /**
+     * @private
+     * @readonly
+     * @type {T}
+     */
+    private readonly validators;
+    /**
+     * @template {Validator} V
+     * @param {V} validator
+     * @returns {ContractContextBuilder<T & {
+     *   [K in V["$name"]]: V
+     * }>}
+     */
+    with<V extends Validator>(validator: V): ContractContextBuilder<T & { [K in V["$name"]]: V; }>;
+    /**
+     *
+     * @param {Option<{[name: string]: string}>} expectedHashes
+     * @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?: Option<{
+        [name: string]: string;
+    }>): { [K_1 in keyof T]: T[K_1]["$purpose"] extends "spending" ? ValidatorHash<SpendingContext<import("./StrictType.js").StrictType<T[K_1]["$Datum"]>, import("./PermissiveType.js").PermissiveType<T[K_1]["$Datum"]>, import("./StrictType.js").StrictType<T[K_1]["$Redeemer"]>, import("./PermissiveType.js").PermissiveType<T[K_1]["$Redeemer"]>>> : T[K_1]["$purpose"] extends "minting" ? MintingPolicyHash<MintingContext<import("./StrictType.js").StrictType<T[K_1]["$Redeemer"]>, import("./PermissiveType.js").PermissiveType<T[K_1]["$Redeemer"]>>> : T[K_1]["$purpose"] extends "certifying" | "rewarding" ? StakingValidatorHash<StakingContext<import("./StrictType.js").StrictType<T[K_1]["$Redeemer"]>, import("./PermissiveType.js").PermissiveType<T[K_1]["$Redeemer"]>>> : never; };
+}
+export type CompiledValidator = import("./ContractContext.js").Validator;
+export type MintingContext<TRedeemerStrict, TRedeemerPermissive> = import("@helios-lang/ledger").MintingContext<TRedeemerStrict, TRedeemerPermissive>;
+export type SpendingContext<TDatumStrict, TDatumPermissive, TRedeemerStrict, TRedeemerPermissive> = import("@helios-lang/ledger").SpendingContext<TDatumStrict, TDatumPermissive, TRedeemerStrict, TRedeemerPermissive>;
+export type StakingContext<TRedeemerStrict, TRedeemerPermissive> = import("@helios-lang/ledger").StakingContext<TRedeemerStrict, TRedeemerPermissive>;
+export type PermissiveType<C extends Cast<import("@helios-lang/ledger").UplcData, import("@helios-lang/ledger").UplcData>> = import("./PermissiveType.js").PermissiveType<C>;
+export type StrictType<C extends Cast<import("@helios-lang/ledger").UplcData, import("@helios-lang/ledger").UplcData>> = import("./StrictType.js").StrictType<C>;
+export type Module = {
+    $name: string;
+    $sourceCode: string;
+    $dependencies: Module[];
+};
+export type Validator = {
+    $name: string;
+    $purpose: string;
+    $sourceCode: string;
+    $dependencies: Module[];
+    $hashDependencies: Validator[];
+    $dependsOnOwnHash: boolean;
+    $Redeemer: Cast<any, any>;
+    $Datum?: Cast<any, any>;
+};
+import { ValidatorHash } from "@helios-lang/ledger";
+import { MintingPolicyHash } from "@helios-lang/ledger";
+import { StakingValidatorHash } from "@helios-lang/ledger";
+import { Cast } from "./Cast.js";
+//# sourceMappingURL=ContractContextBuilder.d.ts.map

package/types/runtime/ContractContextBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractContextBuilder.d.ts","sourceRoot":"","sources":["../../src/runtime/ContractContextBuilder.js"],"names":[],"mappings":"AAaA;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH;;;IAgBI;;OAEG;IACH,gBAFa,uBAAuB,EAAE,CAAC,CAItC;IAbD;;;OAGG;IACH,sBAEC;IAbD;;;;OAIG;IACH,4BAAU;IAiBV;;;;;;OAMG;IACH,+FAKC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH;;2wBA4LC;CACJ;gCAtTY,OAAO,sBAAsB,EAAE,SAAS;mEAMxC,OAAO,qBAAqB,EAAE,cAAc,CAAC,eAAe,EAAE,mBAAmB,CAAC;oGAQlF,OAAO,qBAAqB,EAAE,eAAe,CAAC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,CAAC;mEAMnH,OAAO,qBAAqB,EAAE,cAAc,CAAC,eAAe,EAAE,mBAAmB,CAAC;6HAKlF,OAAO,qBAAqB,EAAE,cAAc,CAAC,CAAC,CAAC;yHAK/C,OAAO,iBAAiB,EAAE,UAAU,CAAC,CAAC,CAAC;qBAIvC;IACZ,KAAS,EAAE,MAAM,CAAA;IACjB,WAAe,EAAE,MAAM,CAAA;IACvB,aAAiB,EAAE,MAAM,EAAE,CAAA;CACxB;wBAIS;IACZ,KAAS,EAAE,MAAM,CAAA;IACjB,QAAY,EAAE,MAAM,CAAA;IACpB,WAAe,EAAE,MAAM,CAAA;IACvB,aAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,iBAAqB,EAAE,SAAS,EAAE,CAAA;IAClC,iBAAqB,EAAE,OAAO,CAAA;IAC9B,SAAa,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,CAAA;IAC7B,MAAU,CAAC,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,CAAA;CACxB;8BA3DG,qBAAqB;kCAArB,qBAAqB;qCAArB,qBAAqB;qBAIP,WAAW"}

package/types/runtime/PermissiveType.d.ts

@@ -0,0 +1,3 @@
+export type PermissiveType<C extends Cast<import("@helios-lang/uplc/types/data/UplcData.js").UplcData, import("@helios-lang/uplc/types/data/UplcData.js").UplcData>> = C extends Cast<any, infer TPermissive> ? TPermissive : never;
+import { Cast } from "./Cast.js";
+//# sourceMappingURL=PermissiveType.d.ts.map

package/types/runtime/PermissiveType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissiveType.d.ts","sourceRoot":"","sources":["../../src/runtime/PermissiveType.js"],"names":[],"mappings":";qBAAqB,WAAW"}

package/types/runtime/StrictType.d.ts

@@ -0,0 +1,3 @@
+export type StrictType<C extends Cast<import("@helios-lang/uplc/types/data/UplcData.js").UplcData, import("@helios-lang/uplc/types/data/UplcData.js").UplcData>> = C extends Cast<infer TStrict, any> ? TStrict : never;
+import { Cast } from "./Cast.js";
+//# sourceMappingURL=StrictType.d.ts.map

package/types/runtime/StrictType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrictType.d.ts","sourceRoot":"","sources":["../../src/runtime/StrictType.js"],"names":[],"mappings":";qBAAqB,WAAW"}

package/types/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export { Cast } from "./Cast.js";
+export { ContractContext } from "./ContractContext.js";
+export { ContractContextBuilder } from "./ContractContextBuilder.js";
+//# sourceMappingURL=index.d.ts.map

package/types/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.js"],"names":[],"mappings":""}

package/examples/spending/app.js

@@ -1,13 +0,0 @@
-import { Program } from "@hyperionbt/helios"
-import { utils, match_string } from "./unspecialized.js"
-
-const modules = [utils, ...]
-
-export class App {
-    /**
-     * @param {typeof utils} specializedUtils 
-     */
-    constructor(specializedUtils) {
-        this.program = Program.new(match_string, modules.replace("utils", specializedUtils))
-    }
-}

package/examples/spending/output.d.ts

@@ -1,18 +0,0 @@
-
-export const utils: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: []
-}
-export const match_string: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: [typeof utils]
-    $hashDependencies: []
-    $dependsOnOwnHash: boolean
-    $Redeemer: Cast<string, string>
-    $Datum: Cast<{message: string}, {message: string}>
-}
-

package/examples/spending/output2.d.ts

@@ -1,24 +0,0 @@
-
-
-export const utils: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: []
-}
-export const match_string: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: [typeof utils]
-    $hashDependencies: []
-    $dependsOnOwnHash: boolean
-    $Redeemer: Cast<string, string>
-    $Datum: Cast<
-      {One: {message: string}} | 
-      {Two: {code: bigint}}, 
-      {One: {message: string}} | 
-      {Two: {code: bigint | number | string}}
-    >
-}
-

package/examples/spending/output2.js

@@ -1,34 +0,0 @@
-export const utils = {
-    $name: "utils",
-    $purpose: "module",
-    $sourceCode: "module utils\n\nfunc compare(a: String, b: String) -> Bool {\n    a == b\n}",
-    $dependencies: [],
-}
-export const match_string = {
-    $name: "match_string",
-    $purpose: "spending",
-    $sourceCode: "spending match_string\n\nimport { compare } from utils\n\nenum Datum {\n One {\n  message: String\n }\n\n Two {\n  message: String\n }\n}\n\nfunc main(datum: Datum, redeemer: String, _) -> Bool {\n compare(datum.switch{d: One => d.message, d: Two => d.message}, redeemer)\n}",
-    $dependencies: [utils],
-    $hashDependencies: [],
-    $dependsOnOwnHash: false,
-    $Redeemer: new Cast({"primitiveType":"String"}),
-    $Datum: new Cast({"enumVariantTypes":[{"name":"One","fieldTypes":[{"name":"message","type":{"primitiveType":"String"}}]},{"name":"Two","fieldTypes":[{"name":"message","type":{"primitiveType":"String"}}]}]})
-}
-
-export const utils: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: []
-}
-export const match_string: {
-    $name: string
-    $purpose: string
-    $sourceCode: string
-    $dependencies: [typeof utils]
-    $hashDependencies: []
-    $dependsOnOwnHash: boolean
-    $Redeemer: Cast<string, string>
-    $Datum: Cast<{One: {message: string}} | {Two: {message: string}}, {One: {message: string}} | {Two: {message: string}}>
-}
-

package/examples/spending/specialized.js

@@ -1,6 +0,0 @@
-export const utils = {
-    $name: "utils",
-    $purpose: "module",
-    $sourceCode: "module utils\n\nfunc compare(a: String, b: String) -> Bool {\n    a == b\n}",
-    $dependencies: [],
-}

package/examples/spending/unspecialized.js

@@ -1,18 +0,0 @@
-import { Cast } from "@helios-lang/contract-utils"
-
-export const utils = {
-    $name: "utils",
-    $purpose: "module",
-    $sourceCode: "module utils\n\nfunc compare(a: String, b: String) -> Bool {\n    a == b\n}",
-    $dependencies: [],
-}
-export const match_string = {
-    $name: "match_string",
-    $purpose: "spending",
-    $sourceCode: "spending match_string\n\nimport { compare } from utils\n\nstruct Datum {\n message: String\n}\n\nfunc main(datum: Datum, redeemer: String, _) -> Bool {\n compare(datum.message, redeemer)\n}",
-    $dependencies: [utils],
-    $hashDependencies: [],
-    $dependsOnOwnHash: false,
-    $Redeemer: new Cast({"primitiveType":"String"}),
-    $Datum: new Cast({"structFieldTypes":[{"name":"message","type":{"primitiveType":"String"}}]})
-}