@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

package/dist/IR/IRNodes/IRNative/index.d.ts

@@ -1,29 +1,32 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { IHash } from "../../interfaces/IHash.js";
 import { IIRParent } from "../../interfaces/IIRParent.js";
 import { IRNativeTag } from "./IRNativeTag.js";
 import { IRParentTerm } from "../../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "../BaseIRMetadata.js";
 import { ToJson } from "../../../utils/ToJson.js";
-import { IRHash } from "../../IRHash.js";
 import { IRNodeKind } from "../../IRNodeKind.js";
 import { TirType } from "../../../compiler/tir/types/TirType.js";
-import { IRHoisted } from "../index.js";
-import { IRTerm } from "../../IRTerm.js";
+import { IIRTerm, IRTerm } from "../../IRTerm.js";
+import { IRHash } from "../../IRHash.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { IRHoisted } from "../IRHoisted.js";
 export interface IRNativeMetadata extends BaseIRMetadata {
 }
 /**
  * `IRNative` ⊇ (`Builtins` + `std::fn`)
 **/
-export declare class IRNative implements Cloneable<IRNative>, IHash, IIRParent, ToJson {
+export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent, ToJson {
     readonly tag: IRNativeTag;
     static get kind(): IRNodeKind.Native;
     get kind(): IRNodeKind.Native;
     static get tag(): Uint8Array;
     constructor(tag: IRNativeTag);
+    toUPLC(): UPLCTerm;
+    private _hash;
     get hash(): IRHash;
+    isHashPresent(): boolean;
     markHashAsInvalid(): void;
-    isHashPresent(): true;
+    children(): IRTerm[];
     private _meta;
     get meta(): IRNativeMetadata;
     private _parent;
@@ -136,9 +139,7 @@ export declare class IRNative implements Cloneable<IRNative>, IHash, IIRParent,
     static get _id(): IRNative;
     static get _not(): IRNative;
     static get _strictAnd(): IRNative;
-    static get _and(): IRNative;
     static get _strictOr(): IRNative;
-    static get _or(): IRNative;
     static get _gtBS(): IRNative;
     static get _gtEqBS(): IRNative;
     static get _gtInt(): IRNative;

package/dist/IR/IRNodes/IRNative/index.js

@@ -1,13 +1,9 @@
 import { concatUint8Arr } from "../../utils/concatUint8Arr.js";
-import { positiveBigIntAsBytes } from "../../utils/positiveIntAsBytes.js";
+import { zigzagBigintAsBytes } from "../../utils/positiveIntAsBytes.js";
 import { IRNativeTag, nativeTagToString } from "./IRNativeTag.js";
-import UPLCFlatUtils from "../../../utils/UPLCFlatUtils/index.js";
 import { isIRParentTerm } from "../../utils/isIRParentTerm.js";
-import { hashIrData } from "../../IRHash.js";
 import { isObject } from "@harmoniclabs/obj-utils";
 import { IRNodeKind } from "../../IRNodeKind.js";
-import { IRConst, IRFunc, IRHoisted, IRVar } from "../index.js";
-import { _ir_apps } from "../../tree_utils/_ir_apps.js";
 import { getUnaliased } from "../../../compiler/tir/types/utils/getUnaliased.js";
 import { TirDataStructType } from "../../../compiler/tir/types/TirStructType.js";
 import { TirAliasType } from "../../../compiler/tir/types/TirAliasType.js";
@@ -22,12 +18,19 @@ import { TirListT } from "../../../compiler/tir/types/TirNativeType/native/list.
 import { TirDataOptT } from "../../../compiler/tir/types/TirNativeType/native/Optional/data.js";
 import { TirStringT } from "../../../compiler/tir/types/TirNativeType/native/string.js";
 import { TirVoidT } from "../../../compiler/tir/types/TirNativeType/native/void.js";
+import { isIRHash, hashIrData } from "../../IRHash.js";
+import { Builtin } from "@harmoniclabs/uplc";
+import { _ir_apps } from "../IRApp.js";
+import { IRHoisted } from "../IRHoisted.js";
+import { IRFunc } from "../IRFunc.js";
+import { IRVar } from "../IRVar.js";
+import { IRConst } from "../IRConst.js";
 /**
  * we might not need all the hashes
  *
  * but one we get one for a specific tag is not worth it re calculate it
  */
-const nativeHashesCache = {};
+const nativeHashesPreimageCache = {};
 /**
  * `IRNative` ⊇ (`Builtins` + `std::fn`)
 **/
@@ -38,15 +41,28 @@ export class IRNative {
     static get tag() { return new Uint8Array([IRNative.kind]); }
     constructor(tag) {
         this.tag = tag;
+        this._hash = undefined;
     }
+    toUPLC() {
+        if (this.tag < 0)
+            throw new Error("IRNative tag cannot be negative during uplc translation");
+        return new Builtin(this.tag);
+    }
+    _hash;
     get hash() {
-        if (nativeHashesCache[this.tag] === undefined) {
-            nativeHashesCache[this.tag] = hashIrData(concatUint8Arr(IRNative.tag, positiveBigIntAsBytes(UPLCFlatUtils.zigzagBigint(BigInt(this.tag)))));
-        }
-        return nativeHashesCache[this.tag];
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRNative.tag, zigzagBigintAsBytes(BigInt(this.tag))));
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [];
     }
-    markHashAsInvalid() { throw new Error("IRNative should never be invalid; 'markHashAsInvalid' called"); }
-    isHashPresent() { return true; }
     _meta;
     get meta() {
         if (!isObject(this._meta))
@@ -178,9 +194,7 @@ export class IRNative {
     static get _id() { return new IRNative(IRNativeTag._id); }
     static get _not() { return new IRNative(IRNativeTag._not); }
     static get _strictAnd() { return new IRNative(IRNativeTag._strictAnd); }
-    static get _and() { return new IRNative(IRNativeTag._and); }
     static get _strictOr() { return new IRNative(IRNativeTag._strictOr); }
-    static get _or() { return new IRNative(IRNativeTag._or); }
     static get _gtBS() { return new IRNative(IRNativeTag._gtBS); }
     static get _gtEqBS() { return new IRNative(IRNativeTag._gtEqBS); }
     static get _gtInt() { return new IRNative(IRNativeTag._gtInt); }
@@ -227,14 +241,37 @@ export class IRNative {
         if (type instanceof TirLinearMapT)
             return IRNative.equalListOf(new TirPairDataT());
         if (type instanceof TirUnConstrDataResultT)
-            return new IRHoisted(new IRFunc(2, _ir_apps(IRNative.equalsData, _ir_apps(IRNative.constrData, new IRVar(0)), _ir_apps(IRNative.constrData, new IRVar(1)))));
-        // don't even hoist, who is even going to use this?
+            return getEqUnConstr();
         if (type instanceof TirVoidT)
-            return new IRFunc(2, IRConst.bool(true));
+            return getEqVoid();
         const tsEnsureExsaustiveCheck = type;
         throw new Error("invalid type for std equality");
     }
     static equalListOf(type) {
-        return new IRHoisted(_ir_apps(IRNative._mkEqualsList, IRNative.equals(type)), { forceHoist: false, name: `equalsListOf_${type.toString()}` });
+        const key = type.toTirTypeKey();
+        if (!(eqListNames[key] instanceof IRHoisted)) {
+            eqListNames[key] = new IRHoisted(_ir_apps(IRNative._mkEqualsList, IRNative.equals(type)), { forceHoist: false, name: `equalsListOf_${type.toString()}` });
+        }
+        return eqListNames[key].clone();
     }
 }
+/// NOTE, wrap in functions to break circular dependencies
+const eqListNames = {};
+const eqUnConstr_a = Symbol("a");
+const eqUnConstr_b = Symbol("b");
+let _eqUnConstr = undefined;
+function getEqUnConstr() {
+    if (_eqUnConstr instanceof IRHoisted)
+        return _eqUnConstr.clone();
+    _eqUnConstr = new IRHoisted(new IRFunc([eqUnConstr_a, eqUnConstr_b], _ir_apps(IRNative.equalsData, _ir_apps(IRNative.constrData, new IRVar(eqUnConstr_a)), _ir_apps(IRNative.constrData, new IRVar(eqUnConstr_b)))));
+    return _eqUnConstr.clone();
+}
+const eqVoid_a = Symbol("a");
+const eqVoid_b = Symbol("b");
+let _eqVoid = undefined;
+function getEqVoid() {
+    if (_eqVoid instanceof IRHoisted)
+        return _eqVoid.clone();
+    _eqVoid = new IRHoisted(new IRFunc([eqVoid_a, eqVoid_b], IRConst.bool(true)));
+    return _eqVoid.clone();
+}

package/dist/IR/IRNodes/IRNative/isForcedNative.d.ts

@@ -1,3 +1,5 @@
 import { IRNative } from "./index.js";
 import { IRTerm } from "../../IRTerm.js";
+import { IRNativeTag } from "./IRNativeTag.js";
+export declare function isForcedNativeTag(tag: IRNativeTag): boolean;
 export declare function isForcedNative(node: IRTerm): node is IRNative;

package/dist/IR/IRNodes/IRNative/isForcedNative.js

@@ -1,6 +1,6 @@
 import { IRNative } from "./index.js";
 import { IRNativeTag } from "./IRNativeTag.js";
-function isForcedNativeTag(tag) {
+export function isForcedNativeTag(tag) {
     return (tag === IRNativeTag.strictIfThenElse ||
         tag === IRNativeTag.chooseUnit ||
         tag === IRNativeTag.trace ||

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

@@ -1,25 +1,33 @@
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { Cloneable } from "../../utils/Cloneable.js";
+import { ToJson } from "../../utils/ToJson.js";
+import { IIRParent } from "../interfaces/index.js";
 import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
-import { IRTerm } from "../IRTerm.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
 export interface IRRecursiveMetadata extends BaseIRMetadata {
 }
-export declare class IRRecursive {
+export declare class IRRecursive implements IIRTerm, Cloneable<IRRecursive>, IIRParent, ToJson {
+    get arity(): number;
+    readonly name: symbol;
+    get params(): symbol[];
+    readonly meta: IRRecursiveMetadata;
+    constructor(name: 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.Recursive;
     get kind(): IRNodeKind.Recursive;
     static get tag(): Uint8Array;
-    readonly arity: number;
-    constructor(body: IRTerm, func_name?: string | undefined, _unsafeHash?: IRHash);
     private _body;
     get body(): IRTerm;
     set body(newBody: IRTerm);
-    private _hash;
-    get hash(): IRHash;
-    isHashPresent(): boolean;
-    markHashAsInvalid(): void;
-    readonly meta: IRRecursiveMetadata;
-    get name(): string | undefined;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRTerm | undefined);

package/dist/IR/IRNodes/IRRecursive.js

@@ -1,69 +1,61 @@
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
-import { isIRHash, hashIrData } from "../IRHash.js";
+import { isIRHash, hashIrData, irHashToBytes } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { isIRTerm } from "../utils/isIRTerm.js";
 export class IRRecursive {
-    static get kind() { return IRNodeKind.Recursive; }
-    get kind() { return IRRecursive.kind; }
-    static get tag() { return new Uint8Array([IRRecursive.kind]); }
-    arity;
-    constructor(body, func_name, _unsafeHash) {
+    get arity() { return 1; }
+    name;
+    get params() { return [this.name]; }
+    meta;
+    constructor(name, body, _unsafeHash) {
         if (!isIRTerm(body))
             throw new Error("IRRecursive body argument was not an IRTerm");
-        Object.defineProperties(this, {
-            arity: {
-                value: 1,
-                writable: false,
-                enumerable: true,
-                configurable: false
-            },
-            meta: {
-                value: {
-                    name: typeof func_name === "string" ? func_name : (void 0)
-                },
-                writable: true,
-                enumerable: true,
-                configurable: false
-            }
-        });
+        if (!(typeof name === "symbol"
+            && typeof name.description === "string"
+            && name.description.length > 0))
+            throw new BasePlutsError("invalid name for IRVar");
+        this.name = name;
+        this._parent = undefined;
+        this.meta = { name: name.description };
         this._body = body;
         this._body.parent = this;
         this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-        this._parent = undefined;
     }
+    toUPLC(ctx) {
+        throw new Error("Can't convert 'IRRecursive' to valid UPLC;" +
+            "IRRecursive are expected to be converted before calling '_irToUplc'");
+    }
+    _hash;
+    get hash() {
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRRecursive.tag, 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.Recursive; }
+    get kind() { return IRRecursive.kind; }
+    static get tag() { return new Uint8Array([IRRecursive.kind]); }
     _body;
     get body() { return this._body; }
     set body(newBody) {
         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(IRRecursive.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; }
-    ;
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -77,7 +69,7 @@ export class IRRecursive {
         this._parent = newParent;
     }
     clone() {
-        return new IRRecursive(this._body.clone(), this.meta.name, this.isHashPresent() ? this.hash : undefined);
+        return new IRRecursive(this.name, this._body.clone(), this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

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

@@ -1,45 +1,31 @@
 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 { IRRecursive } from "./IRRecursive.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRSelfCallMetadata extends BaseIRMetadata {
 }
-export declare class IRSelfCall implements Cloneable<IRSelfCall>, IHash, IIRParent, ToJson {
+export declare class IRSelfCall implements IIRTerm, Cloneable<IRSelfCall>, IIRParent, ToJson {
+    readonly name: symbol;
+    readonly meta: IRSelfCallMetadata;
+    constructor(name: symbol, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
     private _hash;
     get hash(): IRHash;
-    /**
-     * called inside the dbn setter
-     */
+    isHashPresent(): boolean;
     markHashAsInvalid(): void;
-    isHashPresent(): true;
-    private _dbn;
-    /**
-     * the IR DeBruijn index is not necessarly the same of the UPLC
-     * ( more ofthen than not it won't be the same )
-     *
-     * this is because in the IR things like `plet`
-     * are skipping some DeBruijin levels that are instead present
-     * in the final UPLC
-    **/
-    get dbn(): number;
-    set dbn(newDbn: number);
     static get kind(): IRNodeKind.SelfCall;
     get kind(): IRNodeKind.SelfCall;
     static get tag(): Uint8Array;
-    readonly meta: IRSelfCallMetadata;
-    private _definition;
-    get definition(): IRRecursive;
-    set definition(newDefinition: IRRecursive | undefined);
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);
-    private _findDefinition;
-    constructor(DeBruijn: number | bigint);
+    children(): IRTerm[];
     clone(): IRSelfCall;
     toJSON(): any;
     toJson(): any;

package/dist/IR/IRNodes/IRSelfCall.js

@@ -1,65 +1,41 @@
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
-import { IRRecursive } from "./IRRecursive.js";
-import { IRFunc } from "./IRFunc.js";
+import { hashVarSym } from "./utils/hashVarSym.js";
 export class IRSelfCall {
+    name;
+    meta;
+    constructor(name, _unsafeHash) {
+        if (!(typeof name === "symbol"
+            && typeof name.description === "string"
+            && name.description.length > 0))
+            throw new BasePlutsError("invalid name for IRSelfCall");
+        this.name = name;
+        this._parent = undefined;
+        this.meta = {};
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    toUPLC(ctx) {
+        throw new Error("Can't convert 'IRSelfCall' to valid UPLC;" +
+            "IRSelfCall are expected to be converted before calling '_irToUplc'");
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = getSelfCallHashAtDbn(this.dbn);
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRSelfCall.tag, hashVarSym(this.name)));
         return this._hash;
     }
-    /**
-     * called inside the dbn setter
-     */
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return true; }
-    _dbn;
-    /**
-     * the IR DeBruijn index is not necessarly the same of the UPLC
-     * ( more ofthen than not it won't be the same )
-     *
-     * this is because in the IR things like `plet`
-     * are skipping some DeBruijin levels that are instead present
-     * in the final UPLC
-    **/
-    get dbn() { return this._dbn; }
-    set dbn(newDbn) {
-        if (!(Number.isSafeInteger(newDbn) && newDbn >= 0)) {
-            throw new BasePlutsError("invalid index for an `IRSelfCall` instance; new DeBruijn was: " + newDbn);
-        }
-        if (newDbn === this._dbn)
-            return; // everything ok
-        this.markHashAsInvalid();
-        this._dbn = newDbn;
-    }
     static get kind() { return IRNodeKind.SelfCall; }
     get kind() { return IRSelfCall.kind; }
     static get tag() { return new Uint8Array([IRSelfCall.kind]); }
-    meta;
-    _definition;
-    get definition() {
-        if (!(this._definition instanceof IRRecursive)) {
-            this._definition = this._findDefinition();
-        }
-        return this._definition;
-    }
-    set definition(newDefinition) {
-        if (newDefinition === undefined) {
-            this._definition = undefined;
-            return;
-        }
-        else
-            throw new Error("IRSelfCall definition (IRRecursive parent) can't be changed unless set to undefined");
-    }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -73,55 +49,17 @@ export class IRSelfCall {
         // change parent
         this._parent = newParent;
         // if we change parent, _definition should be recalculated
-        this._definition = undefined;
-    }
-    _findDefinition() {
-        let node = this;
-        let dbn = this.dbn;
-        while (node.parent !== undefined) {
-            node = node.parent;
-            if (node instanceof IRRecursive ||
-                node instanceof IRFunc) {
-                if (dbn === 0) {
-                    if (node.parent instanceof IRRecursive)
-                        return node.parent;
-                    else
-                        throw new Error("IRSelfCall was pointing to a IRFunc node");
-                }
-                dbn -= node.arity;
-            }
-        }
-        throw new Error("IRSelfCall instance was not inside a IRRecursive instance");
-    }
-    constructor(DeBruijn) {
-        Object.defineProperty(this, "meta", {
-            value: {},
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        this._hash = undefined;
-        DeBruijn = typeof DeBruijn === "number" ? DeBruijn : Number(DeBruijn);
-        this._dbn = DeBruijn;
-        // call setter to check for validity
-        this.dbn = DeBruijn;
-        this._parent = undefined;
+        // this._definition = undefined;
     }
+    children() { return []; }
     clone() {
-        return new IRSelfCall(this.dbn);
+        return new IRSelfCall(this.name, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
         return {
             type: "IRSelfCall",
-            dbn: this.dbn
+            name: this.name
         };
     }
 }
-const dbnSelfCallCache = {};
-function getSelfCallHashAtDbn(dbn) {
-    if (!isIRHash(dbnSelfCallCache[dbn])) {
-        dbnSelfCallCache[dbn] = (hashIrData(concatUint8Arr(IRSelfCall.tag, positiveIntAsBytes(dbn))));
-    }
-    return dbnSelfCallCache[dbn];
-}

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

@@ -1,40 +1,32 @@
 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 { UPLCVar } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRVarMetadata extends BaseIRMetadata {
 }
-export declare class IRVar implements Cloneable<IRVar>, IHash, IIRParent, ToJson {
+export declare class IRVar implements IIRTerm, Cloneable<IRVar>, IIRParent, ToJson {
+    private readonly _creationStack;
+    readonly meta: IRVarMetadata;
+    readonly name: symbol;
+    constructor(name: symbol, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCVar;
     private _hash;
     get hash(): IRHash;
-    /**
-     * called inside the dbn setter
-     */
+    isHashPresent(): boolean;
     markHashAsInvalid(): void;
-    isHashPresent(): true;
-    private _dbn;
-    /**
-     * the IR DeBruijn index is not necessarly the same of the UPLC
-     * ( more ofthen than not it won't be the same )
-     *
-     * this is because in the IR things like `IRLetted` and `IRHoisted`
-     * are skipping some DeBruijin levels that are instead present
-     * in the final UPLC
-    **/
-    get dbn(): number;
-    set dbn(newDbn: number);
     static get kind(): IRNodeKind.Var;
     get kind(): IRNodeKind.Var;
     static get tag(): Uint8Array;
-    readonly meta: IRVarMetadata;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);
-    constructor(DeBruijn: number | bigint);
+    children(): IRTerm[];
     clone(): IRVar;
     toJSON(): any;
     toJson(): any;