@harmoniclabs/pebble 0.2.0 → 0.3.0

package/dist/IR/CompilationCtx.d.ts

@@ -0,0 +1,40 @@
+import type { IRHash } from "./IRHash.js";
+/**
+ * Per-compilation mutable state.
+ *
+ * Everything here is scoped to a single compile so that compilations are
+ * hermetic: one compile can never observe or mutate another's caches.
+ * Combined with content-addressed `IRHash` (which has no global state at
+ * all), this makes the whole pipeline free of cross-compilation leakage.
+ *
+ * The maps hold (or name) IR nodes that belong to *this* compile's tree —
+ * `hoistedCache` in particular references live nodes that later passes
+ * mutate in place, which is exactly why it must not outlive the compile.
+ *
+ * Node value types are kept as `unknown`/`any` here to avoid an
+ * `IR/IRNodes` import cycle; the consumers cast at the use site.
+ */
+export declare class CompilationCtx {
+    /** hoisted-term hash -> the letted node it was lowered to (live tree node). */
+    readonly hoistedCache: Map<IRHash, WeakRef<any>>;
+    /** hoisted-term hash -> the stable binder symbol used to name it. */
+    readonly hoistedHashToSymbol: Map<IRHash, WeakRef<Symbol>>;
+    /** letted-term hash -> the stable binder symbol used to name it. */
+    readonly lettedHashToSymbol: Map<IRHash, WeakRef<Symbol>>;
+    /** element-type name -> cached `mapToType` TIR helper (clones only). */
+    readonly mapToTypeCache: Map<string, any>;
+}
+/**
+ * The context for the compilation currently in flight. If none is active
+ * (e.g. an `IRTerm.name` access from a debug/`showIR` path outside a
+ * compile) a process-wide default is used — safe because, with
+ * content-addressed hashing, sharing these caches can no longer cause a
+ * miscompile; it only affects one-off naming.
+ */
+export declare function currentCompilationCtx(): CompilationCtx;
+/**
+ * Run `fn` with `ctx` as the active compilation context, restoring the
+ * previous one afterwards (so nested compiles are well-behaved). The
+ * `finally` guarantees the context is cleared even if `fn` throws.
+ */
+export declare function withCompilationCtx<T>(ctx: CompilationCtx, fn: () => T): T;

package/dist/IR/CompilationCtx.js

@@ -0,0 +1,54 @@
+/**
+ * Per-compilation mutable state.
+ *
+ * Everything here is scoped to a single compile so that compilations are
+ * hermetic: one compile can never observe or mutate another's caches.
+ * Combined with content-addressed `IRHash` (which has no global state at
+ * all), this makes the whole pipeline free of cross-compilation leakage.
+ *
+ * The maps hold (or name) IR nodes that belong to *this* compile's tree —
+ * `hoistedCache` in particular references live nodes that later passes
+ * mutate in place, which is exactly why it must not outlive the compile.
+ *
+ * Node value types are kept as `unknown`/`any` here to avoid an
+ * `IR/IRNodes` import cycle; the consumers cast at the use site.
+ */
+export class CompilationCtx {
+    /** hoisted-term hash -> the letted node it was lowered to (live tree node). */
+    hoistedCache = new Map();
+    /** hoisted-term hash -> the stable binder symbol used to name it. */
+    hoistedHashToSymbol = new Map();
+    /** letted-term hash -> the stable binder symbol used to name it. */
+    lettedHashToSymbol = new Map();
+    /** element-type name -> cached `mapToType` TIR helper (clones only). */
+    mapToTypeCache = new Map();
+}
+let _current = undefined;
+let _default = undefined;
+/**
+ * The context for the compilation currently in flight. If none is active
+ * (e.g. an `IRTerm.name` access from a debug/`showIR` path outside a
+ * compile) a process-wide default is used — safe because, with
+ * content-addressed hashing, sharing these caches can no longer cause a
+ * miscompile; it only affects one-off naming.
+ */
+export function currentCompilationCtx() {
+    if (_current !== undefined)
+        return _current;
+    return (_default ??= new CompilationCtx());
+}
+/**
+ * Run `fn` with `ctx` as the active compilation context, restoring the
+ * previous one afterwards (so nested compiles are well-behaved). The
+ * `finally` guarantees the context is cleared even if `fn` throws.
+ */
+export function withCompilationCtx(ctx, fn) {
+    const prev = _current;
+    _current = ctx;
+    try {
+        return fn();
+    }
+    finally {
+        _current = prev;
+    }
+}

package/dist/IR/IRHash.d.ts

@@ -1,5 +1,26 @@
-export type IRHash = number;
-export declare function __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION(): void;
+/**
+ * Content-addressed IR hash.
+ *
+ * An `IRHash` is the lowercase-hex blake2b-128 digest of a node's
+ * structural *preimage* — its tag byte(s) concatenated with the digests
+ * of its children (a Merkle hash over the IR tree). Because it is a pure
+ * function of the node's content, the same term always hashes to the
+ * same value for the entire life of the process: there is no global
+ * counter and no interning table, and therefore **nothing to reset
+ * between compilations**.
+ *
+ * This is what makes compilation hermetic. The previous implementation
+ * interned preimages to a sequential integer and reset the counter at
+ * the end of every compile; long-lived nodes (the module-level
+ * `hoisted_*` singletons) cached integer hashes from the pre-reset
+ * numbering, so after the first reset freshly-minted nodes collided with
+ * those stale hashes and the hoist/let dedup merged unrelated terms.
+ * Content addressing removes the failure mode by construction.
+ *
+ * Memory: there is no central table that accumulates across compiles —
+ * each node memoizes its own digest and is collected normally.
+ */
+export type IRHash = string;
 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;

package/dist/IR/IRHash.js

@@ -1,73 +1,23 @@
-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
+import { blake2b_128 } from "@harmoniclabs/crypto";
+import { fromHex, toHex } from "@harmoniclabs/uint8array-utils";
+/** 16 bytes (blake2b-128) -> 32 lowercase hex chars. */
+const IR_HASH_HEX_LEN = 32;
 export function hashIrData(data) {
-    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;
+    return toHex(blake2b_128(data));
 }
 export function isIRHash(hash) {
-    return (typeof hash === "number"
-        && hash === hash // not NaN
-        && hash <= MAX_SAFE_INTEGER
-        && hash >= MIN_SAFE_INTEGER
-        && BigInt(hash) <= hash
-        && BigInt(hash) >= hash);
+    return (typeof hash === "string"
+        && hash.length === IR_HASH_HEX_LEN);
 }
 export function equalIrHash(a, b) {
-    // we can allow ourselves to use standard equality
-    // only because we always return the same object for the same hash
     return a === b;
-    /*
-    return (
-        // a instanceof Uint32Array &&
-        // b instanceof Uint32Array &&
-        // a.length === 4 &&
-        // b.length === 4 &&
-        a[0] === b[0] &&
-        a[1] === b[1] &&
-        a[2] === b[2] &&
-        a[3] === b[3]
-    );
-    //*/
 }
 export function irHashToHex(hash) {
-    return _positiveHash(hash)
-        .toString(16)
-        // we MUST pad to 16 chars
-        // otherwise, hash concatenation could be ambiguous
-        .padStart(16, "0");
+    return hash;
 }
 export function irHashFromHex(hex) {
-    return _fromPositiveHash(BigInt("0x" + hex));
+    return hex;
 }
 export function irHashToBytes(hash) {
-    return fromHex(irHashToHex(hash));
+    return fromHex(hash);
 }

package/dist/IR/IRNodes/IRConst.js

@@ -8,6 +8,7 @@ import { IRNodeKind } from "../IRNodeKind.js";
 import { getUnaliased } from "../../compiler/tir/types/utils/getUnaliased.js";
 import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType } from "../../compiler/tir/types/TirStructType.js";
+import { TirEnumType } from "../../compiler/tir/types/TirEnumType.js";
 import { getListTypeArg } from "../../compiler/tir/types/utils/getListTypeArg.js";
 import { TirTypeParam } from "../../compiler/tir/types/TirTypeParam.js";
 import { constT, isPair, UPLCConst } from "@harmoniclabs/uplc";
@@ -17,6 +18,8 @@ import { TirBytesT } from "../../compiler/tir/types/TirNativeType/native/bytes.j
 import { TirDataT } from "../../compiler/tir/types/TirNativeType/native/data.js";
 import { TirFuncT } from "../../compiler/tir/types/TirNativeType/native/function.js";
 import { TirIntT } from "../../compiler/tir/types/TirNativeType/native/int.js";
+import { TirArrayT } from "../../compiler/tir/types/TirNativeType/native/array.js";
+import { TirValueT } from "../../compiler/tir/types/TirNativeType/native/value.js";
 import { TirLinearMapT } from "../../compiler/tir/types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../compiler/tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../compiler/tir/types/TirNativeType/native/list.js";
@@ -142,6 +145,8 @@ function isValueAssignableToType(value, type) {
         return typeof value === "boolean";
     if (type instanceof TirIntT)
         return typeof value === "bigint";
+    if (type instanceof TirEnumType)
+        return typeof value === "bigint";
     if (type instanceof TirBytesT)
         return value instanceof Uint8Array;
     if (type instanceof TirStringT)
@@ -174,6 +179,11 @@ function isValueAssignableToType(value, type) {
         || type instanceof TirBlsG2T
         || type instanceof TirMlResultT)
         return false;
+    // Native `Value` and `Array<T>` are never IRConst literals — they
+    // only appear at runtime as results of builtins.
+    if (type instanceof TirValueT
+        || type instanceof TirArrayT)
+        return false;
     const tsEnsureExsaustiveCheck = type;
     return false;
 }
@@ -193,7 +203,7 @@ function serializeIRConstValue(value, type) {
         throw new Error("unreachable");
     if (type instanceof TirVoidT)
         return new Uint8Array(0);
-    if (type instanceof TirIntT) {
+    if (type instanceof TirIntT || type instanceof TirEnumType) {
         return positiveBigIntAsBytes(UPLCFlatUtils.zigzagBigint(BigInt(value)));
     }
     if (type instanceof TirStringT)
@@ -229,7 +239,9 @@ function serializeIRConstValue(value, type) {
         || type instanceof TirTypeParam
         || type instanceof TirBlsG1T
         || type instanceof TirBlsG2T
-        || type instanceof TirMlResultT)
+        || type instanceof TirMlResultT
+        || type instanceof TirValueT
+        || type instanceof TirArrayT)
         throw new Error("invalid uplc const type");
     const tsEnsureExsaustiveCheck = type;
     throw new Error("unreachable");
@@ -264,6 +276,8 @@ export function tirTypeToUplcType(t) {
         return constT.bool;
     if (t instanceof TirIntT)
         return constT.int;
+    if (t instanceof TirEnumType)
+        return constT.int;
     if (t instanceof TirBytesT)
         return constT.byteStr;
     if (t instanceof TirStringT)
@@ -272,6 +286,12 @@ export function tirTypeToUplcType(t) {
         const elemsT = tirTypeToUplcType(getListTypeArg(t));
         return constT.listOf(elemsT);
     }
+    if (t instanceof TirArrayT) {
+        const elemsT = tirTypeToUplcType(t.typeArg);
+        return constT.arrayOf(elemsT);
+    }
+    if (t instanceof TirValueT)
+        return constT.value;
     if (t instanceof TirDataT
         || t instanceof TirDataOptT
         || t instanceof TirDataStructType)

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

@@ -24,7 +24,6 @@ export interface IRHoistedMeta {
 export interface IRHoistedMetadata extends IRMetadata {
     meta: IRHoistedMeta;
 }
-export declare function __unsafe_clear_hoisted_hash_to_symbol(): void;
 export declare class IRHoisted implements IIRTerm, Cloneable<IRHoisted>, IIRParent, ToJson, IRHoistedMetadata {
     readonly meta: IRHoistedMeta;
     get name(): symbol;

package/dist/IR/IRNodes/IRHoisted.js

@@ -13,25 +13,23 @@ import { IRCase } from "./IRCase.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { IRRecursive } from "./IRRecursive.js";
 import { isIRHash, hashIrData, irHashToBytes, equalIrHash, irHashToHex } from "../IRHash.js";
+import { currentCompilationCtx } from "../CompilationCtx.js";
 import { IRNative } from "./IRNative/index.js";
 import { nativeTagToString } from "./IRNative/IRNativeTag.js";
 const defaultHoistedMeta = freezeAll({
     forceHoist: false
 });
-const _hoisted_hash_to_symbol = new Map();
-export function __unsafe_clear_hoisted_hash_to_symbol() {
-    _hoisted_hash_to_symbol.clear();
-}
 export class IRHoisted {
     meta;
     get name() {
         const hash = this.hash;
-        const cached = _hoisted_hash_to_symbol.get(hash)?.deref();
+        const hashToSymbol = currentCompilationCtx().hoistedHashToSymbol;
+        const cached = hashToSymbol.get(hash)?.deref();
         if (typeof cached === "symbol")
             return cached;
         const sym = Symbol(tryInferName(this.hoisted) ?? "hoisted_" + irHashToHex(hash));
         /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<Symbol>'
-        _hoisted_hash_to_symbol.set(hash, new WeakRef(sym));
+        hashToSymbol.set(hash, new WeakRef(sym));
         return sym;
     }
     constructor(hoisted, metadata = {}, _unsafeHash) {

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

@@ -34,7 +34,6 @@ export interface IRLettedMeta extends BaseIRMetadata {
 export interface IRLettedMetadata extends IRMetadata {
     meta: IRLettedMeta;
 }
-export declare function __unsafe_clear_letted_hash_to_symbol(): void;
 export declare class IRLetted implements IIRTerm, Cloneable<IRLetted>, IIRParent, ToJson, IRLettedMetadata {
     private _name;
     readonly meta: IRLettedMeta;

package/dist/IR/IRNodes/IRLetted.js

@@ -5,6 +5,7 @@ import { isIRTerm } from "../utils/isIRTerm.js";
 import { IRHoisted } from "./IRHoisted.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
 import { hashIrData, irHashToBytes, isIRHash } from "../IRHash.js";
+import { currentCompilationCtx } from "../CompilationCtx.js";
 import { IRNodeKind } from "../IRNodeKind.js";
 import { prettyIR } from "../utils/showIR.js";
 export function jsonLettedSetEntry(entry) {
@@ -25,23 +26,20 @@ const defaultLettedMeta = freezeAll({
     __src__: undefined,
     isClosed: false
 });
-const _letted_hash_to_symbol = new Map();
-export function __unsafe_clear_letted_hash_to_symbol() {
-    _letted_hash_to_symbol.clear();
-}
 export class IRLetted {
     _name;
     meta;
     get name() {
         const hash = this.hash;
-        const cached = _letted_hash_to_symbol.get(hash)?.deref();
+        const hashToSymbol = currentCompilationCtx().lettedHashToSymbol;
+        const cached = hashToSymbol.get(hash)?.deref();
         if (typeof cached === "symbol")
             return cached;
         if (typeof this._name !== "symbol")
             throw new Error("IRLetted had invalid name");
         const sym = this._name;
         /// @ts-ignore Argument of type 'WeakRef<object>' is not assignable to parameter of type 'WeakRef<Symbol>'
-        _letted_hash_to_symbol.set(hash, new WeakRef(sym));
+        hashToSymbol.set(hash, new WeakRef(sym));
         return sym;
     }
     constructor(name, toLet, metadata = {}, _unsafeHash) {

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

@@ -93,7 +93,20 @@ export declare enum IRNativeTag {
     countSetBits = 84,
     findFirstSetBit = 85,
     ripemd_160 = 86,
-    _dropList = -4,
+    expModInteger = 87,
+    dropList = 88,
+    lengthOfArray = 89,
+    listToArray = 90,
+    indexArray = 91,
+    bls12_381_G1_multiScalarMul = 92,
+    bls12_381_G2_multiScalarMul = 93,
+    insertCoin = 94,
+    lookupCoin = 95,
+    unionValue = 96,
+    valueContains = 97,
+    valueData = 98,
+    unValueData = 99,
+    scaleValue = 100,
     _foldr = -6,
     _foldl = -7,
     _length = -9,
@@ -135,6 +148,13 @@ export declare enum IRNativeTag {
     _findSopOptional = -45,
     _increment = -46,
     _decrement = -47,
-    _lookupLinearMap = -48
+    _lookupLinearMap = -48,
+    /** partial application of `scaleValue` with -1 — negates a native Value. */
+    _negateValue = -49,
+    /**
+     * `\a b -> valueContains(a, b) && valueContains(b, a)` — equality on
+     * canonical Values. Short-circuits on the first inequality.
+     */
+    _valueEq = -50
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

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

@@ -108,12 +108,27 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["countSetBits"] = 84] = "countSetBits";
     IRNativeTag[IRNativeTag["findFirstSetBit"] = 85] = "findFirstSetBit";
     IRNativeTag[IRNativeTag["ripemd_160"] = 86] = "ripemd_160";
+    // Chang2
+    IRNativeTag[IRNativeTag["expModInteger"] = 87] = "expModInteger";
+    IRNativeTag[IRNativeTag["dropList"] = 88] = "dropList";
+    IRNativeTag[IRNativeTag["lengthOfArray"] = 89] = "lengthOfArray";
+    IRNativeTag[IRNativeTag["listToArray"] = 90] = "listToArray";
+    IRNativeTag[IRNativeTag["indexArray"] = 91] = "indexArray";
+    IRNativeTag[IRNativeTag["bls12_381_G1_multiScalarMul"] = 92] = "bls12_381_G1_multiScalarMul";
+    IRNativeTag[IRNativeTag["bls12_381_G2_multiScalarMul"] = 93] = "bls12_381_G2_multiScalarMul";
+    IRNativeTag[IRNativeTag["insertCoin"] = 94] = "insertCoin";
+    IRNativeTag[IRNativeTag["lookupCoin"] = 95] = "lookupCoin";
+    IRNativeTag[IRNativeTag["unionValue"] = 96] = "unionValue";
+    IRNativeTag[IRNativeTag["valueContains"] = 97] = "valueContains";
+    IRNativeTag[IRNativeTag["valueData"] = 98] = "valueData";
+    IRNativeTag[IRNativeTag["unValueData"] = 99] = "unValueData";
+    IRNativeTag[IRNativeTag["scaleValue"] = 100] = "scaleValue";
     ////////////////////////////////////////////////////////////////////////////////
     // -------------------------------------------------------------------------- //
     // -------------------------- here starts the fun  -------------------------- //
     // -------------------------------------------------------------------------- //
     ////////////////////////////////////////////////////////////////////////////////
-    IRNativeTag[IRNativeTag["_dropList"] = -4] = "_dropList";
+    // _dropList          = -4,
     IRNativeTag[IRNativeTag["_foldr"] = -6] = "_foldr";
     IRNativeTag[IRNativeTag["_foldl"] = -7] = "_foldl";
     //     _mkFindDataOptional               = -8,
@@ -159,13 +174,20 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_increment"] = -46] = "_increment";
     IRNativeTag[IRNativeTag["_decrement"] = -47] = "_decrement";
     IRNativeTag[IRNativeTag["_lookupLinearMap"] = -48] = "_lookupLinearMap";
+    /** partial application of `scaleValue` with -1 — negates a native Value. */
+    IRNativeTag[IRNativeTag["_negateValue"] = -49] = "_negateValue";
+    /**
+     * `\a b -> valueContains(a, b) && valueContains(b, a)` — equality on
+     * canonical Values. Short-circuits on the first inequality.
+     */
+    IRNativeTag[IRNativeTag["_valueEq"] = -50] = "_valueEq";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
     if (nativeTag >= 0)
         return builtinTagToString(nativeTag);
     switch (nativeTag) {
-        case IRNativeTag._dropList: return "dropList";
+        // case IRNativeTag._dropList      : return "dropList";
         case IRNativeTag._foldr: return "foldr";
         case IRNativeTag._foldl: return "foldl";
         // case IRNativeTag._mkFindDataOptional          : return "mkFind";
@@ -205,6 +227,8 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._increment: return "increment";
         case IRNativeTag._decrement: return "decrement";
         case IRNativeTag._lookupLinearMap: return "lookupLinearMap";
+        case IRNativeTag._negateValue: return "negateValue";
+        case IRNativeTag._valueEq: return "valueEq";
         default: return "";
     }
 }

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

@@ -128,7 +128,20 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get countSetBits(): IRNative;
     static get findFirstSetBit(): IRNative;
     static get ripemd_160(): IRNative;
-    static get _dropList(): IRNative;
+    static get expModInteger(): IRNative;
+    static get dropList(): IRNative;
+    static get lengthOfArray(): IRNative;
+    static get listToArray(): IRNative;
+    static get indexArray(): IRNative;
+    static get bls12_381_G1_multiScalarMul(): IRNative;
+    static get bls12_381_G2_multiScalarMul(): IRNative;
+    static get insertCoin(): IRNative;
+    static get lookupCoin(): IRNative;
+    static get unionValue(): IRNative;
+    static get valueContains(): IRNative;
+    static get valueData(): IRNative;
+    static get unValueData(): IRNative;
+    static get scaleValue(): IRNative;
     static get _foldr(): IRNative;
     static get _foldl(): IRNative;
     static get _length(): IRNative;
@@ -164,6 +177,8 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _increment(): IRNative;
     static get _decrement(): IRNative;
     static get _isZero(): IRNative;
+    static get _negateValue(): IRNative;
+    static get _valueEq(): IRNative;
     static equals(type: TirType): IRTerm;
     static equalListOf(type: TirType): IRHoisted;
 }

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

@@ -6,6 +6,7 @@ import { isObject } from "@harmoniclabs/obj-utils";
 import { IRNodeKind } from "../../IRNodeKind.js";
 import { getUnaliased } from "../../../compiler/tir/types/utils/getUnaliased.js";
 import { TirDataStructType } from "../../../compiler/tir/types/TirStructType.js";
+import { TirEnumType } from "../../../compiler/tir/types/TirEnumType.js";
 import { TirAliasType } from "../../../compiler/tir/types/TirAliasType.js";
 import { getListTypeArg } from "../../../compiler/tir/types/utils/getListTypeArg.js";
 import { TirBlsG1T, TirBlsG2T, TirMlResultT, TirPairDataT, TirUnConstrDataResultT } from "../../../compiler/tir/types/TirNativeType/index.js";
@@ -13,6 +14,8 @@ import { TirBoolT } from "../../../compiler/tir/types/TirNativeType/native/bool.
 import { TirBytesT } from "../../../compiler/tir/types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../../../compiler/tir/types/TirNativeType/native/data.js";
 import { TirIntT } from "../../../compiler/tir/types/TirNativeType/native/int.js";
+import { TirArrayT } from "../../../compiler/tir/types/TirNativeType/native/array.js";
+import { TirValueT } from "../../../compiler/tir/types/TirNativeType/native/value.js";
 import { TirLinearMapT } from "../../../compiler/tir/types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../../../compiler/tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../../compiler/tir/types/TirNativeType/native/list.js";
@@ -182,7 +185,21 @@ export class IRNative {
     static get countSetBits() { return new IRNative(IRNativeTag.countSetBits); }
     static get findFirstSetBit() { return new IRNative(IRNativeTag.findFirstSetBit); }
     static get ripemd_160() { return new IRNative(IRNativeTag.ripemd_160); }
-    static get _dropList() { return new IRNative(IRNativeTag._dropList); }
+    // Chang2
+    static get expModInteger() { return new IRNative(IRNativeTag.expModInteger); }
+    static get dropList() { return new IRNative(IRNativeTag.dropList); }
+    static get lengthOfArray() { return new IRNative(IRNativeTag.lengthOfArray); }
+    static get listToArray() { return new IRNative(IRNativeTag.listToArray); }
+    static get indexArray() { return new IRNative(IRNativeTag.indexArray); }
+    static get bls12_381_G1_multiScalarMul() { return new IRNative(IRNativeTag.bls12_381_G1_multiScalarMul); }
+    static get bls12_381_G2_multiScalarMul() { return new IRNative(IRNativeTag.bls12_381_G2_multiScalarMul); }
+    static get insertCoin() { return new IRNative(IRNativeTag.insertCoin); }
+    static get lookupCoin() { return new IRNative(IRNativeTag.lookupCoin); }
+    static get unionValue() { return new IRNative(IRNativeTag.unionValue); }
+    static get valueContains() { return new IRNative(IRNativeTag.valueContains); }
+    static get valueData() { return new IRNative(IRNativeTag.valueData); }
+    static get unValueData() { return new IRNative(IRNativeTag.unValueData); }
+    static get scaleValue() { return new IRNative(IRNativeTag.scaleValue); }
     static get _foldr() { return new IRNative(IRNativeTag._foldr); }
     static get _foldl() { return new IRNative(IRNativeTag._foldl); }
     // static get _mkFindDataOptional() { return new IRNative( IRNativeTag._mkFindDataOptional ); }
@@ -221,12 +238,16 @@ export class IRNative {
     static get _increment() { return new IRNative(IRNativeTag._increment); }
     static get _decrement() { return new IRNative(IRNativeTag._decrement); }
     static get _isZero() { return new IRNative(IRNativeTag._isZero); }
+    static get _negateValue() { return new IRNative(IRNativeTag._negateValue); }
+    static get _valueEq() { return new IRNative(IRNativeTag._valueEq); }
     static equals(type) {
         type = getUnaliased(type);
         if (type instanceof TirAliasType)
             throw new Error("unreachable");
         if (type instanceof TirIntT)
             return IRNative.equalsInteger;
+        if (type instanceof TirEnumType)
+            return IRNative.equalsInteger;
         if (type instanceof TirBytesT)
             return IRNative.equalsByteString;
         if (type instanceof TirStringT)
@@ -249,9 +270,13 @@ export class IRNative {
             return getEqUnConstr();
         if (type instanceof TirVoidT)
             return getEqVoid();
+        // Native Value: equality via bidirectional valueContains
+        if (type instanceof TirValueT)
+            return IRNative._valueEq;
         if (type instanceof TirBlsG1T
             || type instanceof TirBlsG2T
-            || type instanceof TirMlResultT)
+            || type instanceof TirMlResultT
+            || type instanceof TirArrayT)
             throw new Error("invalid type for std equality");
         const tsEnsureExsaustiveCheck = type;
         throw new Error("invalid type for std equality");

package/dist/IR/IRNodes/utils/hashVarSym.d.ts

@@ -1,2 +1 @@
-export declare function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION(): void;
 export declare function hashVarSym(s: symbol): Uint8Array;

package/dist/IR/IRNodes/utils/hashVarSym.js

@@ -1,36 +1,30 @@
-// HASH GENERATOR
 import { fromHex } from "@harmoniclabs/uint8array-utils";
-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);
-const _sym_to_hash = new Map();
-const _hash_to_sym = new Map();
-let _next_hash = MIN_SAFE_INTEGER;
-const unusedHashes = [];
-function _collectUnusedHashes() {
-    for (const [h, s] of _hash_to_sym) {
-        if (!_sym_to_hash.has(s)) {
-            _hash_to_sym.delete(h);
-            unusedHashes.push(h);
-        }
-    }
-}
-export function __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION() {
-    _hash_to_sym.clear();
-    unusedHashes.length = 0;
-    _next_hash = MIN_SAFE_INTEGER;
-}
+/**
+ * Stable per-symbol bytes used as the preimage contribution of an
+ * `IRVar` / self-reference when hashing.
+ *
+ * Each distinct symbol is assigned a unique 8-byte id the first time it
+ * is hashed; subsequent calls for the same symbol return the same bytes.
+ * This makes hashing a pure function of the (symbol-identity) content,
+ * so a term's hash is stable for the life of the process — exactly what
+ * content-addressed `IRHash` requires.
+ *
+ * No global state needs resetting:
+ *  - the map is a `WeakMap`, so a symbol's entry is collected once the
+ *    symbol itself is unreachable (no unbounded growth);
+ *  - the counter is monotonic and never rewinds, so a symbol can never
+ *    be reassigned a colliding id (the bug that the old reset-based
+ *    scheme introduced).
+ */
+// `any` key: non-registered symbols are valid WeakMap keys at runtime
+// (ES2023 / Node 20+), but older `lib` typings don't model symbol keys.
+const _sym_to_bytes = new WeakMap();
+let _next_id = 0n;
 export function hashVarSym(s) {
-    const limitReached = _next_hash >= MAX_SAFE_INTEGER;
-    if (_next_hash % 0xffff === 0
-        || limitReached)
-        _collectUnusedHashes();
-    if (limitReached
-        && unusedHashes.length <= 0)
-        throw new Error("ran out of IR hashes");
-    const result_hash = unusedHashes.shift() ?? _next_hash++;
-    _sym_to_hash.set(s, result_hash);
-    _hash_to_sym.set(result_hash, s);
-    return fromHex((BigInt(result_hash) + BigInt(MAX_SAFE_INTEGER))
-        .toString(16)
-        .padStart(16, "0"));
+    let bytes = _sym_to_bytes.get(s);
+    if (bytes !== undefined)
+        return bytes;
+    bytes = fromHex((_next_id++).toString(16).padStart(16, "0"));
+    _sym_to_bytes.set(s, bytes);
+    return bytes;
 }