@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/IR/IRHash.d.ts

@@ -1,8 +1,8 @@
-export type IRHash = Readonly<Uint32Array> & {
-    length: 4;
-};
+export type IRHash = number;
+export declare function __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION(): void;
 export declare function hashIrData(data: Uint8Array): IRHash;
 export declare function isIRHash(hash: any): hash is IRHash;
 export declare function equalIrHash(a: IRHash, b: IRHash): boolean;
 export declare function irHashToHex(hash: IRHash): string;
 export declare function irHashFromHex(hex: string): IRHash;
+export declare function irHashToBytes(hash: IRHash): Uint8Array;

package/dist/IR/IRHash.js

@@ -1,49 +1,45 @@
-import { blake2b_128 } from "@harmoniclabs/crypto";
-import { toHex } from "@harmoniclabs/uint8array-utils";
-const _hash_cache = new Map();
-// double up to 256; then scale linearly
-const _MAX_DOUBLING_CACHE_SIZE = 256;
-const _MIN_CACHE_SIZE = 32;
-let _cleanSize = _MIN_CACHE_SIZE;
-function _cleanCache() {
-    // scale down
-    if (_hash_cache.size < _cleanSize) {
-        if (_cleanSize <= _MIN_CACHE_SIZE)
-            return; // don't clean unitl minimum size
-        const halfSize = _cleanSize >= (_MAX_DOUBLING_CACHE_SIZE * 2) ? _cleanSize - _MAX_DOUBLING_CACHE_SIZE : _cleanSize >>> 1;
-        if (_hash_cache.size < halfSize)
-            _cleanSize = halfSize;
-    }
-    // cleaning
-    for (const [key, ref] of _hash_cache.entries()) {
-        if (ref.deref() === undefined)
-            _hash_cache.delete(key);
-    }
-    // scale up
-    if (_hash_cache.size >= _cleanSize) {
-        _cleanSize = _cleanSize >= _MAX_DOUBLING_CACHE_SIZE ?
-            _cleanSize + _MAX_DOUBLING_CACHE_SIZE :
-            _cleanSize * 2;
-    }
+import { fromHex, toBase64 } from "@harmoniclabs/uint8array-utils";
+// HASH GENERATOR
+const MAX_SAFE_INTEGER = Number(globalThis.Number?.MAX_SAFE_INTEGER ?? ((2 ** 53) - 1));
+const MIN_SAFE_INTEGER = Number(globalThis.Number?.MIN_SAFE_INTEGER ?? -MAX_SAFE_INTEGER);
+let _preimage_to_hash = {};
+let _next_hash = MIN_SAFE_INTEGER;
+function _getNextHash() {
+    if (_next_hash >= MAX_SAFE_INTEGER)
+        throw new Error("ran out of IR hashes");
+    return _next_hash++;
 }
+export function __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION() {
+    _preimage_to_hash = {};
+    _next_hash = MIN_SAFE_INTEGER;
+}
+// HASH UTILS
+function _positiveHash(hash) {
+    return BigInt(hash) + BigInt(MAX_SAFE_INTEGER) + BigInt(1);
+}
+function _fromPositiveHash(posHash) {
+    const res = Number(posHash - BigInt(MAX_SAFE_INTEGER) - BigInt(1));
+    if (!isIRHash(res))
+        throw new Error("internal error: invalid hash generated");
+    return res;
+}
+// END HASH GENERATOR
 export function hashIrData(data) {
-    const hash8 = blake2b_128(data);
-    const key = toHex(hash8);
-    const cached = _hash_cache.get(key)?.deref();
-    if (isIRHash(cached))
-        return cached;
-    const result = new Uint32Array(hash8.buffer);
-    _hash_cache.set(key, new WeakRef(result));
-    _cleanCache();
-    return result;
+    const preimage = toBase64(data);
+    const exsisting = _preimage_to_hash[preimage];
+    if (typeof exsisting === "number")
+        return exsisting;
+    const nextHash = _getNextHash();
+    _preimage_to_hash[preimage] = nextHash;
+    return nextHash;
 }
 export function isIRHash(hash) {
-    return (
-    // most of the time we are checking an undefined value
-    // we just shortcut here
-    hash !== undefined &&
-        hash instanceof Uint32Array &&
-        hash.length === 4);
+    return (typeof hash === "number"
+        && hash === hash // not NaN
+        && hash <= MAX_SAFE_INTEGER
+        && hash >= MIN_SAFE_INTEGER
+        && BigInt(hash) <= hash
+        && BigInt(hash) >= hash);
 }
 export function equalIrHash(a, b) {
     // we can allow ourselves to use standard equality
@@ -63,16 +59,15 @@ export function equalIrHash(a, b) {
     //*/
 }
 export function irHashToHex(hash) {
-    return toHex(new Uint8Array(hash.buffer));
+    return _positiveHash(hash)
+        .toString(16)
+        // we MUST pad to 16 chars
+        // otherwise, hash concatenation could be ambiguous
+        .padStart(16, "0");
 }
 export function irHashFromHex(hex) {
-    if (hex.length !== 32 && !/^[0-9a-fA-F]$/.test(hex)) {
-        throw new Error("invalid hex string for IRHash");
-    }
-    return new Uint32Array([
-        parseInt(hex.slice(0, 8), 16),
-        parseInt(hex.slice(8, 16), 16),
-        parseInt(hex.slice(16, 24), 16),
-        parseInt(hex.slice(24, 32), 16)
-    ]);
+    return _fromPositiveHash(BigInt("0x" + hex));
+}
+export function irHashToBytes(hash) {
+    return fromHex(irHashToHex(hash));
 }

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

@@ -1,17 +1,24 @@
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
 import { IIRParent } from "../interfaces/IIRParent.js";
 import { ToJson } from "../../utils/ToJson.js";
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 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 IRAppMeta extends BaseIRMetadata {
     __src__?: string | undefined;
 }
-export declare class IRApp implements Cloneable<IRApp>, IHash, IIRParent, ToJson {
+export declare class IRApp implements IIRTerm, Cloneable<IRApp>, IIRParent, ToJson {
     constructor(_fn_: IRTerm, _arg_: IRTerm, meta?: IRAppMeta | undefined, _unsafeHash?: IRHash);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
+    private _hash;
+    get hash(): IRHash;
+    isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
     static get kind(): IRNodeKind;
     get kind(): IRNodeKind;
     static get tag(): Uint8Array;
@@ -21,10 +28,6 @@ export declare class IRApp implements Cloneable<IRApp>, IHash, IIRParent, ToJson
     private _arg;
     get arg(): IRTerm;
     set arg(newArg: IRTerm);
-    private _hash;
-    get hash(): IRHash;
-    markHashAsInvalid(): void;
-    isHashPresent(): boolean;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);
@@ -34,3 +37,4 @@ export declare class IRApp implements Cloneable<IRApp>, IHash, IIRParent, ToJson
     toJSON(): any;
     toJson(): any;
 }
+export declare function _ir_apps(...terms: [IRTerm, IRTerm, ...IRTerm[]]): IRApp;

package/dist/IR/IRNodes/IRApp.js

@@ -1,10 +1,10 @@
 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 { isObject } from "@harmoniclabs/obj-utils";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
+import { Application } from "@harmoniclabs/uplc";
 export class IRApp {
     constructor(_fn_, _arg_, meta = undefined, _unsafeHash) {
         if (!isIRTerm(_fn_))
@@ -18,6 +18,29 @@ export class IRApp {
         this._arg.parent = this;
         this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
     }
+    toUPLC(ctx) {
+        const arg = this._arg.toUPLC(ctx);
+        const fn = this._fn.toUPLC(ctx);
+        return new Application(fn, arg);
+    }
+    _hash;
+    get hash() {
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRApp.tag, irHashToBytes(this._fn.hash), irHashToBytes(this._arg.hash)));
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [
+            this._fn,
+            this._arg
+        ];
+    }
     static get kind() { return IRNodeKind.App; }
     get kind() { return IRApp.kind; }
     static get tag() { return new Uint8Array([IRApp.kind]); }
@@ -26,8 +49,6 @@ export class IRApp {
     set fn(newFn) {
         if (!isIRTerm(newFn))
             return;
-        if (!shallowEqualIRTermHash(this._fn, newFn))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // fn.parent = undefined;
         this._fn = newFn;
@@ -38,26 +59,11 @@ export class IRApp {
     set arg(newArg) {
         if (!isIRTerm(newArg))
             return;
-        if (!shallowEqualIRTermHash(this._arg, newArg))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // arg.parent = undefined;
         this._arg = newArg;
         this._arg.parent = this;
     }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRApp.tag, this._fn.hash, this._arg.hash));
-        }
-        return this._hash;
-    }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
-    isHashPresent() { return isIRHash(this._hash); }
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -78,7 +84,7 @@ export class IRApp {
         return this._meta;
     }
     clone() {
-        return new IRApp(this.fn.clone(), this.arg.clone(), isObject(this._meta) ? { ...this._meta } : undefined, this.isHashPresent() ? this.hash : undefined);
+        return new IRApp(this.fn.clone(), this.arg.clone(), isObject(this._meta) ? { ...this._meta } : undefined, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {
@@ -89,3 +95,11 @@ export class IRApp {
         };
     }
 }
+export function _ir_apps(...terms) {
+    // if( terms.length === 1 ) return terms[0] as IRApp;
+    let term = new IRApp(terms[0], terms[1]);
+    for (let i = 2; i < terms.length; i++) {
+        term = new IRApp(term, terms[i]);
+    }
+    return term;
+}

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

@@ -1,27 +1,31 @@
 import { Cloneable } from "../../utils/Cloneable.js";
 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 { BaseIRMetadata } from "./BaseIRMetadata.js";
 import { MutArrayLike } from "../utils/MutArrayLike.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 IRCaseMeta extends BaseIRMetadata {
 }
-export declare class IRCase implements Cloneable<IRCase>, IHash, IIRParent, ToJson {
+export declare class IRCase implements IIRTerm, Cloneable<IRCase>, IIRParent, ToJson {
+    readonly continuations: MutArrayLike<IRTerm>;
     static get kind(): IRNodeKind.Case;
     get kind(): IRNodeKind.Case;
     static get tag(): Uint8Array;
-    constructor(constrTerm: IRTerm, continuations: ArrayLike<IRTerm>, meta?: IRCaseMeta, _unsafeHash?: IRHash);
+    constructor(constrTerm: IRTerm, continuations: ArrayLike<IRTerm>, meta?: IRCaseMeta, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
     private _hash;
     get hash(): IRHash;
-    markHashAsInvalid(): void;
     isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
     private _constrTerm;
     get constrTerm(): IRTerm;
     set constrTerm(newConstrTerm: IRTerm);
-    readonly continuations: MutArrayLike<IRTerm>;
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);

package/dist/IR/IRNodes/IRCase.js

@@ -2,11 +2,12 @@ import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.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 { Case } from "@harmoniclabs/uplc";
 export class IRCase {
+    continuations;
     static get kind() { return IRNodeKind.Case; }
     get kind() { return IRCase.kind; }
     static get tag() { return new Uint8Array([IRCase.kind]); }
@@ -15,56 +16,56 @@ export class IRCase {
         this.meta = meta;
         this._constrTerm = constrTerm;
         this._constrTerm.parent = self;
-        Object.defineProperty(this, "continuations", {
-            value: makeArrayLikeProxy(continuations, isIRTerm, 
-            // initModifyElem
-            // function called once for each element in the array
-            // only at element definition
-            newElem => {
-                newElem.parent = self;
-                return newElem;
-            }, 
-            // modifyElem
-            (newElem, oldElem) => {
-                // keep the parent reference in the old child, useful for compilation
-                // oldElem.parent = undefined;
-                newElem.parent = self;
-                if (!shallowEqualIRTermHash(oldElem, newElem))
-                    self.markHashAsInvalid();
-                return newElem;
-            }),
-            writable: false,
-            enumerable: true,
-            configurable: false
+        this.continuations = makeArrayLikeProxy(continuations, isIRTerm, 
+        // initModifyElem
+        // function called once for each element in the array
+        // only at element definition
+        newElem => {
+            newElem.parent = self;
+            return newElem;
+        }, 
+        // modifyElem
+        (newElem, oldElem) => {
+            // keep the parent reference in the old child, useful for compilation
+            // oldElem.parent = undefined;
+            newElem.parent = self;
+            return newElem;
         });
         this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
     }
+    toUPLC(ctx) {
+        const constrTermUplc = this.constrTerm.toUPLC(ctx);
+        const continuationsUplc = mapArrayLike(this.continuations, c => c.toUPLC(ctx));
+        return new Case(constrTermUplc, continuationsUplc);
+    }
     _hash;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRCase.tag, this._constrTerm.hash, ...mapArrayLike(this.continuations, f => f.hash)));
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRCase.tag, irHashToBytes(this.constrTerm.hash), ...Array.from(this.continuations, c => irHashToBytes(c.hash))));
         return this._hash;
     }
+    isHashPresent() { return isIRHash(this._hash); }
     markHashAsInvalid() {
         this._hash = undefined;
         this.parent?.markHashAsInvalid();
     }
-    isHashPresent() { return isIRHash(this._hash); }
+    children() {
+        return [
+            this.constrTerm,
+            ...Array.from(this.continuations)
+        ];
+    }
     _constrTerm;
     get constrTerm() { return this._constrTerm; }
     set constrTerm(newConstrTerm) {
         if (!isIRTerm(newConstrTerm))
             return;
-        if (!shallowEqualIRTermHash(this._constrTerm, newConstrTerm))
-            this.markHashAsInvalid();
         // keep the parent reference in the old child, useful for compilation
         // constrTerm.parent = undefined;
         this._constrTerm = newConstrTerm;
         this._constrTerm.parent = this;
     }
-    continuations;
     _parent;
     get parent() { return this._parent; }
     set parent(newParent) {
@@ -79,7 +80,7 @@ export class IRCase {
     }
     meta;
     clone() {
-        return new IRCase(this.constrTerm, mapArrayLike(this.continuations, f => f.clone()), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+        return new IRCase(this.constrTerm, mapArrayLike(this.continuations, f => f.clone()), { ...this.meta }, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

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

@@ -1,13 +1,14 @@
 import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
 import { Data } from "@harmoniclabs/plutus-data";
 import { ToJson } from "../../utils/ToJson.js";
-import { IHash, IIRParent } from "../interfaces/index.js";
+import { IIRParent } from "../interfaces/index.js";
 import { IRParentTerm } from "../utils/isIRParentTerm.js";
 import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { TirType } from "../../compiler/tir/types/TirType.js";
 import { ConstType, UPLCConst } from "@harmoniclabs/uplc";
+import { IIRTerm, IRTerm } from "../IRTerm.js";
+import { IRHash } from "../IRHash.js";
 export interface IRConstPair {
     fst: IRConstValue;
     snd: IRConstValue;
@@ -16,18 +17,19 @@ export declare function isIRConstPair(value: any): value is IRConstPair;
 export type IRConstValue = bigint | Uint8Array | string | boolean | IRConstValue[] | IRConstPair | Data | undefined;
 export interface IRConstMetadata extends BaseIRMetadata {
 }
-export declare class IRConst implements Cloneable<IRConst>, IHash, IIRParent, ToJson {
+export declare class IRConst implements IIRTerm, Cloneable<IRConst>, IIRParent, ToJson {
     readonly type: TirType;
     readonly value: IRConstValue;
     static get kind(): IRNodeKind.Const;
     get kind(): IRNodeKind.Const;
     static get tag(): Uint8Array;
     constructor(type: TirType, value: IRConstValue, _unsafeHash?: IRHash);
-    toUPLC(): UPLCConst;
     private _hash;
     get hash(): IRHash;
-    markHashAsInvalid(): void;
     isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
+    toUPLC(): UPLCConst;
     private _meta;
     get meta(): IRConstMetadata | undefined;
     private _parent;

package/dist/IR/IRNodes/IRConst.js

@@ -6,7 +6,6 @@ import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { positiveBigIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { getUnaliased } from "../../compiler/tir/types/utils/getUnaliased.js";
 import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
@@ -26,6 +25,8 @@ import { TirDataOptT } from "../../compiler/tir/types/TirNativeType/native/Optio
 import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string.js";
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
+import { hashIrData, isIRHash } from "../IRHash.js";
+import { ByteString } from "@harmoniclabs/bytestring";
 export function isIRConstPair(value) {
     return (value instanceof Pair &&
         isIRConstValue(value.fst) &&
@@ -45,20 +46,29 @@ export class IRConst {
         this._parent = undefined;
         this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
     }
-    toUPLC() {
-        return new UPLCConst(tirTypeToUplcType(getUnaliased(this.type)), this.value);
-    }
-    _hash;
+    _hash = undefined;
     get hash() {
-        if (!isIRHash(this._hash)) {
-            this._hash = hashIrData(concatUint8Arr(IRConst.tag, new Uint8Array(this.type.toUplcConstType()), serializeIRConstValue(this.value, this.type)));
-        }
+        if (isIRHash(this._hash))
+            return this._hash;
+        this._hash = hashIrData(concatUint8Arr(IRConst.tag, new Uint8Array(this.type.toUplcConstType()), serializeIRConstValue(this.value, this.type)));
         return this._hash;
     }
-    markHashAsInvalid() { {
-        throw new Error("IRConst `markHashAsInvalid` was called; but a constant doesn't have childs");
-    } }
-    isHashPresent() { return isIRHash(this._hash); }
+    isHashPresent() { return true; }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    children() {
+        return [];
+    }
+    toUPLC() {
+        const type = getUnaliased(this.type);
+        if (type instanceof TirBytesT && this.value instanceof Uint8Array) {
+            // make a copy to prevent external mutation
+            return new UPLCConst(tirTypeToUplcType(type), new ByteString(this.value));
+        }
+        return new UPLCConst(tirTypeToUplcType(type), this.value);
+    }
     _meta = undefined;
     get meta() {
         if (!this._meta)
@@ -78,7 +88,7 @@ export class IRConst {
         this._parent = newParent;
     }
     clone() {
-        return new IRConst(this.type, this.value, this.isHashPresent() ? this.hash : undefined);
+        return new IRConst(this.type, this.value, this._hash);
     }
     toJSON() { return this.toJson(); }
     toJson() {

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

@@ -1,26 +1,30 @@
 import { Cloneable } from "../../utils/Cloneable.js";
 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 { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { MutArrayLike } from "../utils/MutArrayLike.js";
-import { IRHash } from "../IRHash.js";
 import { IRNodeKind } from "../IRNodeKind.js";
+import { IRHash } from "../IRHash.js";
+import { MutArrayLike } from "../utils/MutArrayLike.js";
+import { UPLCTerm } from "@harmoniclabs/uplc";
+import { ToUplcCtx } from "../toUPLC/ctx/ToUplcCtx.js";
 export interface IRConstrMeta extends BaseIRMetadata {
 }
-export declare class IRConstr implements Cloneable<IRConstr>, IHash, IIRParent, ToJson {
+export declare class IRConstr implements IIRTerm, Cloneable<IRConstr>, IIRParent, ToJson {
     readonly index: bigint;
     readonly fields: MutArrayLike<IRTerm>;
     readonly meta: IRConstrMeta;
     static get kind(): IRNodeKind.Constr;
     get kind(): IRNodeKind.Constr;
     static get tag(): Uint8Array;
-    constructor(index: number | bigint, fields: ArrayLike<IRTerm>, meta?: IRConstrMeta, _unsafeHash?: IRHash);
+    constructor(index: number | bigint, fields: ArrayLike<IRTerm>, meta?: IRConstrMeta, _unsafeHash?: IRHash | undefined);
+    toUPLC(ctx: ToUplcCtx): UPLCTerm;
     private _hash;
     get hash(): IRHash;
-    markHashAsInvalid(): void;
     isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    children(): IRTerm[];
     private _parent;
     get parent(): IRParentTerm | undefined;
     set parent(newParent: IRParentTerm | undefined);