@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/IR/IRHash.d.ts

@@ -0,0 +1,8 @@
+export type IRHash = Readonly<Uint32Array> & {
+    length: 4;
+};
+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;

package/dist/IR/IRHash.js

@@ -0,0 +1,78 @@
+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;
+    }
+}
+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;
+}
+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);
+}
+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 toHex(new Uint8Array(hash.buffer));
+}
+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)
+    ]);
+}

package/dist/IR/IRNodeKind.d.ts

@@ -0,0 +1,17 @@
+export declare enum IRNodeKind {
+    Var = 0,
+    Func = 1,
+    App = 2,
+    Const = 3,
+    Native = 4,
+    Letted = 5,
+    Hoisted = 6,
+    Error = 7,
+    Forced = 8,
+    Delayed = 9,
+    Constr = 10,
+    Case = 11,
+    Recursive = 12,
+    SelfCall = 13,
+    SopDeconstr = 14
+}

package/dist/IR/IRNodeKind.js

@@ -0,0 +1,19 @@
+export var IRNodeKind;
+(function (IRNodeKind) {
+    IRNodeKind[IRNodeKind["Var"] = 0] = "Var";
+    IRNodeKind[IRNodeKind["Func"] = 1] = "Func";
+    IRNodeKind[IRNodeKind["App"] = 2] = "App";
+    IRNodeKind[IRNodeKind["Const"] = 3] = "Const";
+    IRNodeKind[IRNodeKind["Native"] = 4] = "Native";
+    IRNodeKind[IRNodeKind["Letted"] = 5] = "Letted";
+    IRNodeKind[IRNodeKind["Hoisted"] = 6] = "Hoisted";
+    IRNodeKind[IRNodeKind["Error"] = 7] = "Error";
+    IRNodeKind[IRNodeKind["Forced"] = 8] = "Forced";
+    IRNodeKind[IRNodeKind["Delayed"] = 9] = "Delayed";
+    IRNodeKind[IRNodeKind["Constr"] = 10] = "Constr";
+    IRNodeKind[IRNodeKind["Case"] = 11] = "Case";
+    IRNodeKind[IRNodeKind["Recursive"] = 12] = "Recursive";
+    IRNodeKind[IRNodeKind["SelfCall"] = 13] = "SelfCall";
+    IRNodeKind[IRNodeKind["SopDeconstr"] = 14] = "SopDeconstr";
+})(IRNodeKind || (IRNodeKind = {}));
+Object.freeze(IRNodeKind);

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

@@ -0,0 +1,3 @@
+export interface BaseIRMetadata {
+    name?: string | undefined;
+}

package/dist/IR/IRNodes/BaseIRMetadata.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+import { IRTerm } from "../IRTerm.js";
+import { IHash } from "../interfaces/IHash.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";
+export interface IRAppMeta extends BaseIRMetadata {
+    __src__?: string | undefined;
+}
+export declare class IRApp implements Cloneable<IRApp>, IHash, IIRParent, ToJson {
+    constructor(_fn_: IRTerm, _arg_: IRTerm, meta?: IRAppMeta | undefined, _unsafeHash?: IRHash);
+    static get kind(): IRNodeKind;
+    get kind(): IRNodeKind;
+    static get tag(): Uint8Array;
+    private _fn;
+    get fn(): IRTerm;
+    set fn(newFn: IRTerm);
+    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);
+    private _meta;
+    get meta(): IRAppMeta;
+    clone(): IRApp;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRApp.js

@@ -0,0 +1,91 @@
+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";
+export class IRApp {
+    constructor(_fn_, _arg_, meta = undefined, _unsafeHash) {
+        if (!isIRTerm(_fn_))
+            throw new Error("invalid function node for `IRApp`");
+        if (!isIRTerm(_arg_))
+            throw new Error("invalid argument node for `IRApp`");
+        this._meta = meta;
+        this._fn = _fn_;
+        this._arg = _arg_;
+        this._fn.parent = this;
+        this._arg.parent = this;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    static get kind() { return IRNodeKind.App; }
+    get kind() { return IRApp.kind; }
+    static get tag() { return new Uint8Array([IRApp.kind]); }
+    _fn;
+    get fn() { return this._fn; }
+    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;
+        this._fn.parent = this;
+    }
+    _arg;
+    get arg() { return this._arg; }
+    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) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        // change parent
+        this._parent = newParent;
+    }
+    _meta;
+    get meta() {
+        if (!isObject(this._meta))
+            this._meta = {};
+        return this._meta;
+    }
+    clone() {
+        return new IRApp(this.fn.clone(), this.arg.clone(), isObject(this._meta) ? { ...this._meta } : undefined, this.isHashPresent() ? this.hash : undefined);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRApp",
+            fn: this.fn.toJson(),
+            arg: this.arg.toJson()
+        };
+    }
+}

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

@@ -0,0 +1,32 @@
+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 { 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";
+export interface IRCaseMeta extends BaseIRMetadata {
+}
+export declare class IRCase implements Cloneable<IRCase>, IHash, IIRParent, ToJson {
+    static get kind(): IRNodeKind.Case;
+    get kind(): IRNodeKind.Case;
+    static get tag(): Uint8Array;
+    constructor(constrTerm: IRTerm, continuations: ArrayLike<IRTerm>, meta?: IRCaseMeta, _unsafeHash?: IRHash);
+    private _hash;
+    get hash(): IRHash;
+    markHashAsInvalid(): void;
+    isHashPresent(): boolean;
+    private _constrTerm;
+    get constrTerm(): IRTerm;
+    set constrTerm(newConstrTerm: IRTerm);
+    readonly continuations: MutArrayLike<IRTerm>;
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    readonly meta: IRCaseMeta;
+    clone(): IRCase;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRCase.js

@@ -0,0 +1,91 @@
+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";
+export class IRCase {
+    static get kind() { return IRNodeKind.Case; }
+    get kind() { return IRCase.kind; }
+    static get tag() { return new Uint8Array([IRCase.kind]); }
+    constructor(constrTerm, continuations, meta = {}, _unsafeHash) {
+        const self = this;
+        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._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+    }
+    _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)));
+        }
+        return this._hash;
+    }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    _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) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        this._parent = newParent;
+    }
+    meta;
+    clone() {
+        return new IRCase(this.constrTerm, mapArrayLike(this.continuations, f => f.clone()), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            constrTerm: this.constrTerm.toString(),
+            continuations: mapArrayLike(this.continuations, f => f.toJson())
+        };
+    }
+}

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

@@ -0,0 +1,49 @@
+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 { 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";
+export interface IRConstPair {
+    fst: IRConstValue;
+    snd: IRConstValue;
+}
+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 {
+    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;
+    private _meta;
+    get meta(): IRConstMetadata | undefined;
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    clone(): IRConst;
+    toJSON(): any;
+    toJson(): any;
+    static get unit(): IRConst;
+    static bool(b: boolean): IRConst;
+    static bytes(b: Uint8Array): IRConst;
+    static int(n: number | bigint): IRConst;
+    static str(string: string): IRConst;
+    static data(d: Data): IRConst;
+    static listOf(t: TirType): (vals: IRConstValue[]) => IRConst;
+}
+export declare function isIRConstValue(value: any): value is IRConstValue;
+export declare function constValueToJson(value: IRConstValue): any;
+export declare function tirTypeToUplcType(t: TirType): ConstType;