@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

package/dist/IR/IRNodes/IRConstr.js

@@ -1,13 +1,13 @@
 import { forceBigUInt } from "../../utils/ints.js";
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { mapArrayLike } from "./utils/mapArrayLike.js";
 import { makeArrayLikeProxy } from "./utils/makeArrayLikeProxy.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
+import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
+import { Constr } from "@harmoniclabs/uplc";
 export class IRConstr {
     index;
     fields;
@@ -19,49 +19,46 @@ export class IRConstr {
         const self = this;
         this.meta = meta;
         this._parent = undefined;
-        Object.defineProperty(this, "index", {
-            value: forceBigUInt(index),
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        Object.defineProperty(this, "fields", {
-            value: makeArrayLikeProxy(fields, isIRTerm, 
-            // initModifyElem
-            newElem => {
-                // newElem = newElem.clone();
-                newElem.parent = self;
-                // self.markHashAsInvalid()
-                return newElem;
-            }, 
-            // modifyElem
-            // called before setting the new value
-            // the return value is the value that will be set
-            (newElem, oldElem) => {
-                if (!shallowEqualIRTermHash(oldElem, newElem))
-                    self.markHashAsInvalid();
-                newElem.parent = self;
-                return newElem;
-            }),
-            writable: false,
-            enumerable: true,
-            configurable: false
+        this.index = forceBigUInt(index);
+        this.fields = makeArrayLikeProxy(fields, isIRTerm, 
+        // initModifyElem
+        newElem => {
+            // newElem = newElem.clone();
+            newElem.parent = self;
+            // self.markHashAsInvalid()
+            return newElem;
+        }, 
+        // modifyElem
+        // called before setting the new value
+        // the return value is the value that will be set
+        (newElem, oldElem) => {
+            newElem.parent = self;
+            return newElem;
         });
         this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
     }
+    toUPLC(ctx) {
+        if (this.fields.length <= 0) {
+            return new Constr(this.index, []);
+        }
+        const fields = mapArrayLike(this.fields, f => f.toUPLC(ctx));
+        return new Constr(this.index, fields);
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRConstr.tag, positiveIntAsBytes(this.index), ...mapArrayLike(this.fields, f => f.hash)));
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRConstr.tag, positiveIntAsBytes(this.index), ...mapArrayLike(this.fields, f => irHashToBytes(f.hash))));
         return this._hash;
     }
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return isIRHash(this._hash); }
+    children() {
+        return Array.from(this.fields);
+    }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -75,7 +72,7 @@ export class IRConstr {
         this._parent = newParent;
     }
     clone() {
-        return new IRConstr(this.index, mapArrayLike(this.fields, f => f.clone()), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+        return new IRConstr(this.index, mapArrayLike(this.fields, f => f.clone()), { ...this.meta }, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

package/dist/IR/IRNodes/IRDelayed.d.ts

@@ -1,30 +1,33 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
 import { IIRParent } from "../interfaces/IIRParent.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { IRHash } from "../IRHash.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRDelayedMetadata extends BaseIRMetadata {
 }
-export declare class IRDelayed implements Cloneable<IRDelayed>, IHash, IIRParent, ToJson {
+export declare class IRDelayed implements IIRTerm, Cloneable<IRDelayed>, IIRParent, ToJson {
     readonly meta: IRDelayedMetadata;
-    constructor(delayed: IRTerm, _unsafeHash?: IRHash);
+    constructor(delayed: IRTerm, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
+    private _hash;
+    get hash(): IRHash;
+    isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
     static get kind(): IRNodeKind.Delayed;
     get kind(): IRNodeKind.Delayed;
     static get tag(): Uint8Array;
     private _delayed;
     get delayed(): IRTerm;
     set delayed(newDelayed: IRTerm | undefined);
-    private _hash;
-    get hash(): IRHash;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
     clone(): IRDelayed;
     toJSON(): any;
     toJson(): any;

package/dist/IR/IRNodes/IRDelayed.js

@@ -2,9 +2,9 @@ import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { isIRHash, hashIrData, irHashToBytes } from "../IRHash.js";
+import { Delay } from "@harmoniclabs/uplc";
 export class IRDelayed {
     meta = {};
     constructor(delayed, _unsafeHash) {
@@ -12,8 +12,26 @@ export class IRDelayed {
             throw new Error("IRDelayed argument was not an IRTerm");
         this._delayed = delayed;
         this._delayed.parent = this;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
         this._parent = undefined;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC(ctx) {
+        return new Delay(this.delayed.toUPLC(ctx));
+    }
+    _hash;
+    get hash() {
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRDelayed.tag, irHashToBytes(this.delayed.hash)));
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [this.delayed];
     }
     static get kind() { return IRNodeKind.Delayed; }
     get kind() { return IRDelayed.kind; }
@@ -24,20 +42,11 @@ export class IRDelayed {
         if (!isIRTerm(newDelayed)) {
             throw new BasePlutsError("invalid IRTerm to be delayed");
         }
-        if (!shallowEqualIRTermHash(this._delayed, newDelayed))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // _delayed.parent = undefined;
         this._delayed = newDelayed;
         this._delayed.parent = this;
     }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRDelayed.tag, this.delayed.hash));
-        }
-        return this._hash;
-    }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -50,13 +59,8 @@ export class IRDelayed {
             return;
         this._parent = newParent;
     }
-    isHashPresent() { return isIRHash(this._hash); }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this._parent?.markHashAsInvalid();
-    }
     clone() {
-        return new IRDelayed(this.delayed.clone(), this.isHashPresent() ? this.hash : undefined);
+        return new IRDelayed(this.delayed.clone(), this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

package/dist/IR/IRNodes/IRError.d.ts

@@ -1,24 +1,27 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IHash } from "../interfaces/IHash.js";
 import { IIRParent } from "../interfaces/IIRParent.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { IRHash } from "../IRHash.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
 export interface IRErrorMetadata extends BaseIRMetadata {
 }
-export declare class IRError implements Cloneable<IRError>, IHash, IIRParent, ToJson {
+export declare class IRError implements IIRTerm, Cloneable<IRError>, IIRParent, ToJson {
     readonly meta: IRErrorMetadata;
     msg?: string;
     addInfos?: any;
     constructor(msg?: string, addInfos?: any);
-    static get kind(): IRNodeKind.Error;
-    get kind(): IRNodeKind.Error;
-    static get tag(): Uint8Array;
+    toUPLC(): UPLCTerm;
     get hash(): IRHash;
     isHashPresent(): boolean;
     markHashAsInvalid(): void;
+    children(): IRTerm[];
+    static get kind(): IRNodeKind.Error;
+    get kind(): IRNodeKind.Error;
+    static get tag(): Uint8Array;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);

package/dist/IR/IRNodes/IRError.js

@@ -1,8 +1,9 @@
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { hashIrData } from "../IRHash.js";
+import { ErrorUPLC } from "@harmoniclabs/uplc";
 const irErrorBitTag = new Uint8Array([IRNodeKind.Error]);
-const errorHash = hashIrData(irErrorBitTag.slice());
+const irErrorHash = hashIrData(irErrorBitTag);
 export class IRError {
     meta;
     msg;
@@ -13,12 +14,18 @@ export class IRError {
         this.meta = {};
         this._parent = undefined;
     }
+    toUPLC() {
+        return new ErrorUPLC(this.msg, this.addInfos);
+    }
+    get hash() { return irErrorHash; }
+    isHashPresent() { return true; }
+    markHashAsInvalid() { throw new Error("IRError: hash is always present and valid"); }
+    children() {
+        return [];
+    }
     static get kind() { return IRNodeKind.Error; }
     get kind() { return IRError.kind; }
     static get tag() { return irErrorBitTag.slice(); }
-    get hash() { return errorHash; }
-    isHashPresent() { return true; }
-    markHashAsInvalid() { throw new Error("IRError.markHashAsInvalid was called but error doesn't have childs"); }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {

package/dist/IR/IRNodes/IRForced.d.ts

@@ -1,24 +1,27 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
 import { IIRParent } from "../interfaces/IIRParent.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
 import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRForcedMetadata extends BaseIRMetadata {
 }
-export declare class IRForced implements Cloneable<IRForced>, IHash, IIRParent, ToJson {
+export declare class IRForced implements IIRTerm, Cloneable<IRForced>, IIRParent, ToJson {
     readonly meta: IRForcedMetadata;
     constructor(forced: IRTerm, _unsafeHash?: IRHash);
-    private _forced;
-    get forced(): IRTerm;
-    set forced(newForced: IRTerm | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
     private _hash;
     get hash(): IRHash;
     isHashPresent(): boolean;
     markHashAsInvalid(): void;
+    children(): IRTerm[];
+    private _forced;
+    get forced(): IRTerm;
+    set forced(newForced: IRTerm | undefined);
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);

package/dist/IR/IRNodes/IRForced.js

@@ -2,19 +2,37 @@ import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
+import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { Force } from "@harmoniclabs/uplc";
 export class IRForced {
     meta;
     constructor(forced, _unsafeHash) {
         this.meta = {};
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
         if (!isIRTerm(forced))
             throw new Error("IRForced argument was not an IRTerm");
         this._forced = forced;
         this._forced.parent = this;
         this._parent = undefined;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC(ctx) {
+        return new Force(this.forced.toUPLC(ctx));
+    }
+    _hash;
+    get hash() {
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRForced.tag, irHashToBytes(this.forced.hash)));
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [this._forced];
     }
     _forced;
     get forced() { return this._forced; }
@@ -22,25 +40,11 @@ export class IRForced {
         if (!isIRTerm(newForced)) {
             throw new BasePlutsError("invalid IRTerm to be forced");
         }
-        if (!shallowEqualIRTermHash(this._forced, newForced))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // _forced.parent = undefined;
         this._forced = newForced;
         this._forced.parent = this;
     }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRForced.tag, this._forced.hash));
-        }
-        return this._hash;
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -57,7 +61,7 @@ export class IRForced {
     get kind() { return IRForced.kind; }
     static get tag() { return new Uint8Array([IRForced.kind]); }
     clone() {
-        return new IRForced(this.forced.clone(), this.isHashPresent() ? this.hash : undefined);
+        return new IRForced(this.forced.clone(), this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

package/dist/IR/IRNodes/IRFunc.d.ts

@@ -1,27 +1,31 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
 import { IIRParent } from "../interfaces/IIRParent.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { IRHash } from "../IRHash.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRFuncMetadata extends BaseIRMetadata {
 }
-export declare class IRFunc implements Cloneable<IRFunc>, IHash, IIRParent, ToJson {
-    readonly arity: number;
-    constructor(arity: number, body: IRTerm, func_name?: string | undefined, _unsafeHash?: IRHash);
+export declare class IRFunc implements IIRTerm, Cloneable<IRFunc>, IIRParent, ToJson {
+    readonly params: symbol[];
+    get arity(): number;
+    constructor(params: symbol[], body: IRTerm, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
+    private _hash;
+    get hash(): IRHash;
+    isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
     static get kind(): IRNodeKind.Func;
     get kind(): IRNodeKind.Func;
     static get tag(): Uint8Array;
     private _body;
     get body(): IRTerm;
     set body(newBody: IRTerm);
-    private _hash;
-    get hash(): IRHash;
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
     readonly meta: IRFuncMetadata;
     get name(): string | undefined;
     private _parent;

package/dist/IR/IRNodes/IRFunc.js

@@ -3,36 +3,46 @@ import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
 import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
+import { Lambda } from "@harmoniclabs/uplc";
 export class IRFunc {
-    arity;
-    constructor(arity, body, func_name, _unsafeHash) {
-        if (!Number.isSafeInteger(arity) && arity >= 1)
-            throw new BasePlutsError("invalid arity for 'IRFunc'");
+    params = [];
+    get arity() { return this.params.length; }
+    constructor(params, body, _unsafeHash) {
         if (!isIRTerm(body))
             throw new Error("IRFunc body argument was not an IRTerm");
-        Object.defineProperties(this, {
-            arity: {
-                value: arity,
-                writable: false,
-                enumerable: true,
-                configurable: false
-            },
-            meta: {
-                value: {
-                    name: typeof func_name === "string" ? func_name : (void 0)
-                },
-                writable: true,
-                enumerable: true,
-                configurable: false
-            }
-        });
+        this.params = params.slice();
+        this.meta = {};
         this._body = body;
         this._body.parent = this;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
         this._parent = undefined;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC(ctx) {
+        ctx = ctx.newChild(this.params);
+        const arity = this.params.length;
+        const irBody = this._body;
+        // IRRecursive not valid for uplc translation
+        let result = irBody.toUPLC(ctx);
+        for (let i = 0; i < arity; i++)
+            result = new Lambda(result);
+        return result;
+    }
+    _hash;
+    get hash() {
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRFunc.tag, positiveIntAsBytes(this.arity), irHashToBytes(this._body.hash)));
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [this._body];
     }
     static get kind() { return IRNodeKind.Func; }
     get kind() { return IRFunc.kind; }
@@ -43,25 +53,11 @@ export class IRFunc {
         if (!isIRTerm(newBody)) {
             throw new BasePlutsError("invalid IRTerm to be a function body");
         }
-        if (!shallowEqualIRTermHash(this._body, newBody))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // _body.parent = undefined;
         this._body = newBody;
         this._body.parent = this;
     }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRFunc.tag, positiveIntAsBytes(this.arity), this._body.hash));
-        }
-        return this._hash;
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
     meta;
     get name() { return this.meta.name; }
     ;
@@ -78,7 +74,8 @@ export class IRFunc {
         this._parent = newParent;
     }
     clone() {
-        return new IRFunc(this.arity, this._body.clone(), this.meta.name, this.isHashPresent() ? this.hash : undefined);
+        return new IRFunc(this.params, // .slice() in constructor
+        this._body.clone());
     }
     toJSON() { return this.toJson(); }
     toJson() {

package/dist/IR/IRNodes/IRHoisted.d.ts

@@ -1,11 +1,12 @@
 import { IRMetadata } from "../interfaces/IRMetadata.js";
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { ToJson } from "../../utils/ToJson.js";
-import { IRTerm } from "../IRTerm.js";
-import { IHash, IIRParent } from "../interfaces/index.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { IIRParent } from "../interfaces/index.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { IRHash } from "../IRHash.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
 export type HoistedSetEntry = {
     hoisted: IRHoisted;
     nReferences: number;
@@ -18,21 +19,26 @@ export interface IRHoistedMeta {
     **/
     forceHoist?: boolean;
     name?: string | undefined;
+    handled?: boolean;
 }
 export interface IRHoistedMetadata extends IRMetadata {
     meta: IRHoistedMeta;
 }
-export declare class IRHoisted implements Cloneable<IRHoisted>, IHash, IIRParent, ToJson, IRHoistedMetadata {
+export declare class IRHoisted implements IIRTerm, Cloneable<IRHoisted>, IIRParent, ToJson, IRHoistedMetadata {
     readonly meta: IRHoistedMeta;
-    constructor(hoisted: IRTerm, metadata?: Partial<IRHoistedMeta>, _unsafeHash?: IRHash);
-    static get kind(): IRNodeKind.Hoisted;
-    get kind(): IRNodeKind.Hoisted;
-    static get tag(): Uint8Array;
+    get name(): symbol;
+    constructor(hoisted: IRTerm, metadata?: Partial<IRHoistedMeta>, _unsafeHash?: IRHash | undefined);
+    toUPLC(): UPLCTerm;
     private _hash;
     get hash(): IRHash;
-    markHashAsInvalid(): void;
     isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
+    static get kind(): IRNodeKind.Hoisted;
+    get kind(): IRNodeKind.Hoisted;
+    static get tag(): Uint8Array;
     private _hoisted;
+    get value(): IRTerm;
     get hoisted(): IRTerm;
     set hoisted(newHoisted: IRTerm);
     private _deps;
@@ -53,3 +59,4 @@ export declare class IRHoisted implements Cloneable<IRHoisted>, IHash, IIRParent
 export declare function getSortedHoistedSet(hoistedTerms: HoistedSetEntry[]): HoistedSetEntry[];
 export declare function getHoistedTerms(irTerm: IRTerm): HoistedSetEntry[];
 export declare function cloneHoistedSetEntry({ hoisted, nReferences }: HoistedSetEntry): HoistedSetEntry;
+export declare function tryInferName(value: IRTerm): string | undefined;