@harmoniclabs/pebble 0.1.0-dev6 → 0.1.0-dev8

package/dist/IR/IRNodes/IRConst.js

@@ -2,7 +2,6 @@ import { Pair } from "@harmoniclabs/pair";
 import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
 import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
-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";
@@ -27,6 +26,7 @@ import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
 import { ByteString } from "@harmoniclabs/bytestring";
+import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 export function isIRConstPair(value) {
     return (value instanceof Pair &&
         isIRConstValue(value.fst) &&

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

@@ -96,11 +96,10 @@ export declare enum IRNativeTag {
     _dropList = -4,
     _foldr = -6,
     _foldl = -7,
-    _mkFindDataOptional = -8,
     _length = -9,
     _some = -10,
     _every = -11,
-    _mkFilter = -12,
+    _filter = -12,
     _id = -15,
     _not = -16,
     _strictAnd = -17,
@@ -131,6 +130,10 @@ export declare enum IRNativeTag {
     _exponentiateInteger = -40,
     _amountOfValue = -41,
     _isZero = -42,
-    _sortedValueLovelaces = -43
+    _sortedValueLovelaces = -43,
+    _getCredentialsHash = -44,
+    _findSopOptional = -45,
+    _increment = -46,
+    _decrement = -47
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

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

@@ -116,11 +116,11 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_dropList"] = -4] = "_dropList";
     IRNativeTag[IRNativeTag["_foldr"] = -6] = "_foldr";
     IRNativeTag[IRNativeTag["_foldl"] = -7] = "_foldl";
-    IRNativeTag[IRNativeTag["_mkFindDataOptional"] = -8] = "_mkFindDataOptional";
+    //     _mkFindDataOptional               = -8,
     IRNativeTag[IRNativeTag["_length"] = -9] = "_length";
     IRNativeTag[IRNativeTag["_some"] = -10] = "_some";
     IRNativeTag[IRNativeTag["_every"] = -11] = "_every";
-    IRNativeTag[IRNativeTag["_mkFilter"] = -12] = "_mkFilter";
+    IRNativeTag[IRNativeTag["_filter"] = -12] = "_filter";
     // _fstPair            = -13,
     // _sndPair            = -14,
     IRNativeTag[IRNativeTag["_id"] = -15] = "_id";
@@ -154,6 +154,10 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_amountOfValue"] = -41] = "_amountOfValue";
     IRNativeTag[IRNativeTag["_isZero"] = -42] = "_isZero";
     IRNativeTag[IRNativeTag["_sortedValueLovelaces"] = -43] = "_sortedValueLovelaces";
+    IRNativeTag[IRNativeTag["_getCredentialsHash"] = -44] = "_getCredentialsHash";
+    IRNativeTag[IRNativeTag["_findSopOptional"] = -45] = "_findSopOptional";
+    IRNativeTag[IRNativeTag["_increment"] = -46] = "_increment";
+    IRNativeTag[IRNativeTag["_decrement"] = -47] = "_decrement";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
@@ -163,11 +167,12 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._dropList: return "dropList";
         case IRNativeTag._foldr: return "foldr";
         case IRNativeTag._foldl: return "foldl";
-        case IRNativeTag._mkFindDataOptional: return "mkFind";
+        // case IRNativeTag._mkFindDataOptional          : return "mkFind";
+        case IRNativeTag._findSopOptional: return "findSopOptional";
         case IRNativeTag._length: return "length";
         case IRNativeTag._some: return "some";
         case IRNativeTag._every: return "every";
-        case IRNativeTag._mkFilter: return "mkFilter";
+        case IRNativeTag._filter: return "mkFilter";
         // case IRNativeTag._fstPair       : return "fstPair";
         // case IRNativeTag._sndPair       : return "sndPair";
         case IRNativeTag._id: return "id";
@@ -195,6 +200,9 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._amountOfValue: return "amountOfValue";
         case IRNativeTag._isZero: return "isZero";
         case IRNativeTag._sortedValueLovelaces: return "sortedValueLovelaces";
+        case IRNativeTag._getCredentialsHash: return "getCredentialHash";
+        case IRNativeTag._increment: return "increment";
+        case IRNativeTag._decrement: return "decrement";
         default: return "";
     }
 }

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

@@ -131,11 +131,10 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _dropList(): IRNative;
     static get _foldr(): IRNative;
     static get _foldl(): IRNative;
-    static get _mkFindDataOptional(): IRNative;
     static get _length(): IRNative;
     static get _some(): IRNative;
     static get _every(): IRNative;
-    static get _mkFilter(): IRNative;
+    static get _filter(): IRNative;
     static get _id(): IRNative;
     static get _not(): IRNative;
     static get _strictAnd(): IRNative;
@@ -161,6 +160,10 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _exponentiateInteger(): IRNative;
     static get _amountOfValue(): IRNative;
     static get _sortedValueLovelaces(): IRNative;
+    static get _getCredentialsHash(): IRNative;
+    static get _increment(): IRNative;
+    static get _decrement(): IRNative;
+    static get _isZero(): IRNative;
     static equals(type: TirType): IRTerm;
     static equalListOf(type: TirType): IRHoisted;
 }

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

@@ -184,11 +184,11 @@ export class IRNative {
     static get _dropList() { return new IRNative(IRNativeTag._dropList); }
     static get _foldr() { return new IRNative(IRNativeTag._foldr); }
     static get _foldl() { return new IRNative(IRNativeTag._foldl); }
-    static get _mkFindDataOptional() { return new IRNative(IRNativeTag._mkFindDataOptional); }
+    // static get _mkFindDataOptional() { return new IRNative( IRNativeTag._mkFindDataOptional ); }
     static get _length() { return new IRNative(IRNativeTag._length); }
     static get _some() { return new IRNative(IRNativeTag._some); }
     static get _every() { return new IRNative(IRNativeTag._every); }
-    static get _mkFilter() { return new IRNative(IRNativeTag._mkFilter); }
+    static get _filter() { return new IRNative(IRNativeTag._filter); }
     // static get _fstPair() { return new IRNative( IRNativeTag._fstPair ); }
     // static get _sndPair() { return new IRNative( IRNativeTag._sndPair ); }
     static get _id() { return new IRNative(IRNativeTag._id); }
@@ -216,6 +216,10 @@ export class IRNative {
     static get _exponentiateInteger() { return new IRNative(IRNativeTag._exponentiateInteger); }
     static get _amountOfValue() { return new IRNative(IRNativeTag._amountOfValue); }
     static get _sortedValueLovelaces() { return new IRNative(IRNativeTag._sortedValueLovelaces); }
+    static get _getCredentialsHash() { return new IRNative(IRNativeTag._getCredentialsHash); }
+    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 equals(type) {
         type = getUnaliased(type);
         if (type instanceof TirAliasType)

package/dist/IR/toUPLC/CompilerOptions.d.ts

@@ -24,7 +24,7 @@ export interface CompilerOptions {
     /**
      * path to the entry file
      */
-    readonly entry: string;
+    entry: string;
     /**
      * path of the root of the project
      */
@@ -33,6 +33,10 @@ export interface CompilerOptions {
      * path to the output directory
      */
     readonly outDir: string;
+    /**
+     * if `true` silences all compiler output
+     */
+    readonly silent: boolean;
     /**
      * uplc version (encoded in the script)
      */
@@ -76,5 +80,6 @@ export declare const extremeOptions: CompilerOptions;
 export declare const productionOptions: CompilerOptions;
 export declare const debugOptions: CompilerOptions;
 export declare const defaultOptions: CompilerOptions;
+export declare const testOptions: CompilerOptions;
 export declare const defulatCompilerOptions: CompilerOptions;
 export declare function completeCompilerOptions(options: Partial<CompilerOptions>, complete?: CompilerOptions): CompilerOptions;

package/dist/IR/toUPLC/CompilerOptions.js

@@ -36,6 +36,7 @@ export const extremeOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -46,6 +47,7 @@ export const productionOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: true,
     delayHoists: true,
@@ -56,13 +58,21 @@ export const debugOptions = Object.freeze({
     entry: "./src/index.pebble",
     root: ".",
     outDir: "./out",
+    silent: false,
     targetUplcVersion: defaultUplcVersion,
     removeTraces: false,
     delayHoists: false,
     uplcOptimizations: debugUplcOptimizations,
     addMarker: false
 });
-export const defaultOptions = productionOptions;
+export const defaultOptions = Object.freeze({
+    ...productionOptions,
+});
+export const testOptions = Object.freeze({
+    // ...debugOptions,
+    ...productionOptions,
+    silent: true
+});
 export const defulatCompilerOptions = defaultOptions;
 export function completeCompilerOptions(options, complete = defaultOptions) {
     let targetUplcVersion = options.targetUplcVersion instanceof UPLCVersion ? complete.targetUplcVersion : defaultUplcVersion;

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -31,7 +31,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     const options = completeCompilerOptions(paritalOptions);
-    const debugAsserts = options.debugAsserts ?? false;
+    // const debugAsserts = (options as any).debugAsserts ?? false;
     // unwrap top level letted and hoisted;
     while (term instanceof IRLetted || term instanceof IRHoisted) {
         // replace with value
@@ -39,33 +39,24 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         // forget the parent; this is the new root
         term.parent = undefined;
     }
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
+    ///////////////////////////////////////////////////////////////////////////////
+    // ------------------------------------------------------------------------- //
+    // ----------------------------- optimizations ----------------------------- //
+    // ------------------------------------------------------------------------- //
+    ///////////////////////////////////////////////////////////////////////////////
     // term = preEvaluateDefinedTermsAndReturnRoot( term );
     term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // removing unused variables BEFORE going into the rest of the compilation
     // helps letted terms to find a better spot (and possibly be inlined instead of hoisted)
     term = removeUnusedVarsAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     _makeAllNegativeNativesHoisted(term);
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ----------------------------- optimizations ----------------------------- //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    // --------------------- optimize recursive functions  --------------------- //
-    // avoid passing whole structs
-    // take letted terms outside
-    // ----------------------- optimize normal functions ----------------------- //
-    // avoid passing whole structs
-    // reorganize function arguments to take advantage of partial applicaiton
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ------------------------------ final steps ------------------------------ //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
     term = replaceNativesAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // re-call rewrite to optimize introduced hoisted
+    term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
+    // debugAsserts && _debug_assertions( term );
     // unwrap top level letted and hoisted;
     // some natives may be converted to hoisted;
     // this is really just an edge case
@@ -79,31 +70,39 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         term instanceof IRConst // while we are at it
     )
         return term.toUPLC();
+    ///////////////////////////////////////////////////////////////////////////////
+    // ------------------------------------------------------------------------- //
+    // ------------------------------- hoisting -------------------------------- //
+    // ------------------------------------------------------------------------- //
+    ///////////////////////////////////////////////////////////////////////////////
+    // hoist `(force (builtin ifThenElse))` or `(force (force (builtin fstPair)))` etc
     replaceForcedNativesWithHoisted(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     if (options.delayHoists)
         replaceHoistedWithLetted(term);
     else
         replaceClosedLettedWithHoisted(term);
-    debugAsserts && _debug_assertions(term);
-    if (debugAsserts
-        && options.delayHoists
-        && includesNode(term, node => node instanceof IRHoisted)) {
-        throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
-    }
+    // debugAsserts && _debug_assertions( term );
+    // if(
+    //     // debugAsserts
+    //     && options.delayHoists
+    //     && includesNode( term, node => node instanceof IRHoisted )
+    // ) {
+    //     throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
+    // }
     // handle letted before hoisted because the tree is smaller
     // and we also have less letted dependecies to handle
     term = handleLettedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     term = handleHoistedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // replaced hoisted terms might include new letted terms
     while (includesNode(term, node => node instanceof IRLetted
         || node instanceof IRHoisted)) {
         term = handleLettedAndReturnRoot(term);
         term = handleHoistedAndReturnRoot(term);
     }
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------- translate to UPLC --------------------------- //
@@ -117,13 +116,13 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // if( options.delayHoists ) replaceHoistedWithLetted( term );
     // handle new hoisted terms
     term = handleHoistedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // strictly necessary to check the options
     // otherwise forced natives where already hoisted
     // will be re-hosited; causeing uselsess evaluations
     if (!options.delayHoists)
         term = hoistForcedNatives(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // at this point we expect the IR to be translable 1:1 to UPLC
     // The loop is needed because after inlining some params, 
     // new params in outer (or sibling) functions can become 
@@ -161,11 +160,11 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     //     irJson.text,
     //     JSON.stringify( onlyHoistedAndLetted( irJson ) )
     // );
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // const srcmap = {};
     const uplc = term.toUPLC(ToUplcCtx.root());
     if (!isClosedTerm(uplc)) {
-        console.log(prettyUPLC(uplc));
+        console.error(prettyUPLC(uplc));
         throw new Error("compileIRToUPLC: final UPLC term is not closed:\n" +
             "This is a compiler internal error; please open an issue on github so we can fix this.");
     }

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -26,18 +26,10 @@ export class ToUplcCtx {
         const ctx = this.ctxMap.get(sym);
         const idx = ctx?._variables.indexOf(sym) ?? -1;
         if (idx <= -1) {
-            console.log(sym, ctx?.allVars());
+            console.error(sym, ctx?.allVars());
             throw new Error("Variable not found in its defining context");
         }
-        const declDbn = ctx._parentDbn + idx + 1;
-        if (declDbn === 5
-            && sym.description === "tailList") {
-            console.log({
-                ctxDbn: ctx.dbn,
-                idx
-            });
-        }
-        return declDbn;
+        return ctx._parentDbn + idx + 1;
     }
     getVarAccessDbn(sym) {
         const declDbn = this.getVarDeclDbn(sym);

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.js

@@ -65,8 +65,6 @@ export function getUnboundedIRVars(term) {
         }
         stack.push(...t.children());
     }
-    console.log("accessedVars", [...new Set(accessedVars.keys())]);
-    console.log("boundedVars", [...boundedVars]);
     for (const v of boundedVars)
         accessedVars.delete(v);
     return [...accessedVars.values()].flat();

package/dist/IR/toUPLC/subRoutines/handleLetted/index.js

@@ -4,7 +4,7 @@ import { getSortedLettedSet, getLettedTerms, IRLetted } from "../../../IRNodes/I
 import { IRVar } from "../../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
 import { findAllNoHoisted } from "../../_internal/findAll.js";
-import { getMaxScope } from "./groupByScope.js";
+import { getMaxScope, getUnboundedVars } from "./groupByScope.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
 import { lowestCommonAncestor } from "../../_internal/lowestCommonAncestor.js";
 import { isIRTerm } from "../../../utils/isIRTerm.js";
@@ -47,9 +47,22 @@ export function handleLettedAndReturnRoot(term) {
         //
         // hence why `pop` (and not `shift`)
         const { letted, nReferences } = sortedLettedSet.pop();
+        // const shouldLog = (
+        //     letted.value instanceof IRApp
+        //     && letted.value.fn instanceof IRNative
+        //     && letted.value.fn.tag === IRNativeTag.addInteger
+        //     && letted.value.arg instanceof IRConst
+        //     && letted.value.arg.value === -1n
+        // )
         // shouldLog && // console.log("nReferences", nReferences);
         // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
-        if (nReferences === 1) {
+        // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
+        // if( shouldLog ) {
+        //     console.log( prettyIRInline( letted ) );
+        // }
+        const wasSingleReferenceButRecursive = nReferences <= 1;
+        if (wasSingleReferenceButRecursive // nReferences <= 1
+            && !someParentIsRecursive(letted)) {
             // console.log("inlining letted (single reference) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
@@ -81,7 +94,9 @@ export function handleLettedAndReturnRoot(term) {
             continue;
         }
         // just in case
-        if (sameLettedRefs.length === 1 && !minScope) {
+        if (sameLettedRefs.length === 1
+            && !minScope
+            && !wasSingleReferenceButRecursive) {
             // console.log("inlining letted (single reference pedantic) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
@@ -108,6 +123,47 @@ export function handleLettedAndReturnRoot(term) {
             }
             ;
         }
+        if (wasSingleReferenceButRecursive) {
+            // OPTIMIZATION:
+            // TODO:
+            // see the general case below
+            const unbounded = getUnboundedVars(letted.value);
+            if (unbounded.size === 0) {
+                // if closed
+                // handle as hoisted
+                for (const ref of sameLettedRefs) {
+                    _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
+                }
+                term = new IRApp(new IRFunc([letted.name], term), letted.value);
+                continue;
+            }
+            // else find highest common ancestor where all unbounded vars are defined
+            // OPTIMIZATION:
+            // TODO:
+            // only hoist outside the highest, but fully defined, IRRecursive
+            // and NOT the highest overall
+            // otherwise we risk paying for introducing stuff we don't use
+            let tmp = lca;
+            // let lowestOutsideRecursive: IRTerm = lca;
+            while (tmp = tmp.parent) {
+                if (tmp instanceof IRDelayed) {
+                    lca = tmp;
+                    // lowestOutsideRecursive = tmp;
+                    continue;
+                }
+                if (tmp instanceof IRFunc || tmp instanceof IRRecursive) {
+                    if (tmp.params.some(p => unbounded.has(p))) {
+                        // some parameter is defined here
+                        // so we stop
+                        break;
+                    }
+                    else
+                        lca = tmp;
+                    // else lowestOutsideRecursive = tmp;
+                }
+            }
+            // lca = lowestOutsideRecursive;
+        }
         if (!isIRTerm(lca)) {
             throw new Error("letting nodes with hash " + irHashToHex(lettedHash) + " from different trees");
         }
@@ -176,3 +232,13 @@ function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, current
     }
     return currentRoot;
 }
+function someParentIsRecursive(term) {
+    let parent;
+    ;
+    while (parent = term.parent) {
+        if (parent instanceof IRRecursive)
+            return true;
+        term = parent;
+    }
+    return false;
+}

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -22,12 +22,13 @@ export declare const hoisted_sub4: IRHoisted;
 export declare const hoisted_length: IRHoisted;
 export declare const hoisted_dropList: IRHoisted;
 export declare const hoisted_sizeofPositiveInt: IRHoisted;
+export declare const hoisted_findSopOptional: IRHoisted;
 export declare const hoisted_mkFindDataOptional: IRHoisted;
 export declare const hoisted_strictAnd: IRHoisted;
 export declare const hoisted_strictOr: IRHoisted;
 export declare const hoisted_some: IRHoisted;
 export declare const hoisted_every: IRHoisted;
-export declare const hoisted_mkFilter: IRHoisted;
+export declare const hoisted_filter: IRHoisted;
 export declare const hoisted_gtBS: IRHoisted;
 export declare const hoisted_gtEqBS: IRHoisted;
 export declare const hoisted_gtInt: IRHoisted;
@@ -42,5 +43,6 @@ export declare const hoisted_exponentiateInteger: IRHoisted;
 export declare function nativeToIR(native: IRNative): IRTerm;
 export declare const hoisted_mkEqualsList: IRHoisted;
 export declare const hoisted_mkMapList: IRHoisted;
+export declare const hoisted_getCredentialsHash: IRHoisted;
 export declare const hoisted_sortedValueLovelaces: IRHoisted;
 export declare const hoisted_amountOfValue: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -12,10 +12,11 @@ import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { IRError } from "../../../IRNodes/IRError.js";
 import { _ir_apps } from "../../../IRNodes/IRApp.js";
-import { _ir_let } from "../../../tree_utils/_ir_let.js";
+import { _ir_let, _ir_let_sym } from "../../../tree_utils/_ir_let.js";
 import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
 import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
+import { IRConstr } from "../../../IRNodes/index.js";
 function _ir_strictAnd(left, right) {
     return _ir_apps(IRNative.strictIfThenElse, left, right, IRConst.bool(false));
 }
@@ -106,6 +107,22 @@ const foldl_head = Symbol("head");
 const foldl_tail = Symbol("tail");
 const hoiseted_foldl = new IRHoisted(new IRFunc([foldl_reduce], new IRRecursive(foldl_self, new IRFunc([foldl_acc], _ir_apps(hoisted_matchList.clone(), new IRDelayed(new IRVar(foldl_acc)), new IRFunc([foldl_head, foldl_tail], _ir_apps(new IRSelfCall(foldl_self), _ir_apps(new IRVar(foldl_reduce), new IRVar(foldl_acc), new IRVar(foldl_head)), new IRVar(foldl_tail))))))));
 hoiseted_foldl.hash;
+// hoisted _findSopOptional
+// (predicate: (a -> Bool)) -> (list: [a]) -> Optional<a>
+const findSop_predicate = Symbol("predicate");
+const findSop_self = Symbol("findOpt_self");
+const findSop_list = Symbol("list");
+const findSop_head = Symbol("head");
+export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predicate], new IRRecursive(findSop_self, new IRFunc([findSop_list], _ir_lazyChooseList(new IRVar(findSop_list), 
+// case nil
+new IRConstr(1, []), // None
+// case cons
+new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
+// then => Some(head)
+new IRConstr(1, [new IRVar(findSop_head)]), // Some{ head }
+// else => self(tail)
+_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))))))));
+hoisted_findSopOptional.hash;
 // hoisted _mkFindDataOptional
 const mkFind_elemToData = Symbol("elemToData");
 const mkFind_pred = Symbol("predicate");
@@ -139,13 +156,21 @@ const every_head = Symbol("head");
 const every_tail = Symbol("tail");
 export const hoisted_every = new IRHoisted(new IRFunc([every_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([every_dummy], new IRDelayed(IRConst.bool(true))), new IRFunc([every_self, every_head, every_tail], new IRForced(_ir_apps(hoisted_strictAnd.clone(), new IRDelayed(new IRApp(new IRVar(every_pred), new IRVar(every_head))), new IRDelayed(new IRApp(new IRVar(every_self), new IRVar(every_tail)))))))));
 hoisted_every.hash;
-// hoisted _mkFilter
-const filt_pnil = Symbol("pnilOfType");
+// hoisted _filter
 const filt_pred = Symbol("predicate");
+const filt_self = Symbol("filter_self");
+const filt_list = Symbol("list");
 const filt_elem = Symbol("elem");
-const filt_acc = Symbol("accum");
-export const hoisted_mkFilter = new IRHoisted(new IRFunc([filt_pnil, filt_pred], _ir_apps(hoisted_foldr.clone(), new IRFunc([filt_elem, filt_acc], new IRForced(_ir_apps(IRNative.strictIfThenElse, new IRApp(new IRVar(filt_pred), new IRVar(filt_elem)), new IRDelayed(_ir_apps(IRNative.mkCons, new IRVar(filt_elem), new IRVar(filt_acc))), new IRDelayed(new IRVar(filt_acc))))), new IRVar(filt_pnil))));
-hoisted_mkFilter.hash;
+export const hoisted_filter = new IRHoisted(new IRFunc([filt_pred], new IRRecursive(filt_self, new IRFunc([filt_list], _ir_lazyChooseList(new IRVar(filt_list), 
+// case nil
+new IRVar(filt_list), // nil
+// case cons
+_ir_let_sym(filt_elem, _ir_apps(IRNative.headList, new IRVar(filt_list)), _ir_lazyIfThenElse(_ir_apps(new IRVar(filt_pred), new IRVar(filt_elem)), 
+// then => cons(elem, self(tail))
+_ir_apps(IRNative.mkCons, new IRVar(filt_elem), _ir_apps(new IRSelfCall(filt_self), _ir_apps(IRNative.tailList, new IRVar(filt_list)))), 
+// else => self(tail)
+_ir_apps(new IRSelfCall(filt_self), _ir_apps(IRNative.tailList, new IRVar(filt_list))))))))));
+hoisted_filter.hash;
 // comparison & conversion hoisted (previously inline)
 const gtbs_a = Symbol("a"), gtbs_b = Symbol("b");
 export const hoisted_gtBS = new IRHoisted(new IRFunc([gtbs_a, gtbs_b], _ir_apps(IRNative.lessThanByteString, new IRVar(gtbs_b), new IRVar(gtbs_a))));
@@ -194,11 +219,12 @@ export function nativeToIR(native) {
     switch (native.tag) {
         case IRNativeTag._foldr: return hoisted_foldr.clone();
         case IRNativeTag._foldl: return hoiseted_foldl.clone();
-        case IRNativeTag._mkFindDataOptional: return hoisted_mkFindDataOptional.clone();
+        // case IRNativeTag._mkFindDataOptional: return hoisted_mkFindDataOptional.clone();
+        case IRNativeTag._findSopOptional: return hoisted_findSopOptional.clone();
         case IRNativeTag._length: return hoisted_length.clone();
         case IRNativeTag._some: return hoisted_some.clone();
         case IRNativeTag._every: return hoisted_every.clone();
-        case IRNativeTag._mkFilter: return hoisted_mkFilter.clone();
+        case IRNativeTag._filter: return hoisted_filter.clone();
         case IRNativeTag._id: return hoisted_id.clone();
         case IRNativeTag._not: return hoisted_not.clone();
         case IRNativeTag._strictAnd: return hoisted_strictAnd.clone();
@@ -217,9 +243,12 @@ export function nativeToIR(native) {
         case IRNativeTag._exponentiateInteger: return hoisted_exponentiateInteger.clone();
         case IRNativeTag._amountOfValue: return hoisted_amountOfValue.clone();
         case IRNativeTag._isZero: return hoisted_isZero.clone();
-        case IRNativeTag._sortedValueLovelaces: return hoisted_sortedValueLovelaces.clone?.() ?? (() => { throw new Error("_sortedValueLovelaces hoisted const missing"); })();
+        case IRNativeTag._sortedValueLovelaces: return hoisted_sortedValueLovelaces.clone();
+        case IRNativeTag._getCredentialsHash: return hoisted_getCredentialsHash.clone();
         case IRNativeTag._dropList: return hoisted_dropList.clone();
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
+        case IRNativeTag._increment: return hoisted_addOne.clone();
+        case IRNativeTag._decrement: return hoisted_subOne.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +
@@ -241,7 +270,7 @@ IRConst.bool(false),
 // both lists are cons
 _ir_strictAnd(_ir_apps(new IRVar(eqList_eqFunc), new IRApp(IRNative.headList, new IRVar(eqList_listA)), new IRApp(IRNative.headList, new IRVar(eqList_listB))), _ir_apps(new IRSelfCall(eqList_self), new IRApp(IRNative.tailList, new IRVar(eqList_listA)), new IRApp(IRNative.tailList, new IRVar(eqList_listB))))))))));
 hoisted_mkEqualsList.hash;
-// (nil of type) => ( a => b ) => [a] => [b]
+// (nil of type) [b] => ( a => b ) => [a] => [b]
 const mkMap_nil = Symbol("nilOfType");
 const mkMap_mapFunc = Symbol("mapFunc");
 const mkMap_map = Symbol("map_self");
@@ -256,6 +285,9 @@ _ir_apps(new IRVar(mkMap_mapFunc), new IRApp(IRNative.headList, new IRVar(mkMap_
 // recurse tail
 _ir_apps(new IRSelfCall(mkMap_map), new IRApp(IRNative.tailList, new IRVar(mkMap_list)))))))));
 hoisted_mkMapList.hash;
+const credHash_credentials = Symbol("credentials");
+export const hoisted_getCredentialsHash = new IRHoisted(new IRFunc([credHash_credentials], _ir_apps(IRNative.unBData, _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, new IRVar(credHash_credentials)))))));
+hoisted_getCredentialsHash.hash;
 // If _sortedValueLovelaces was previously inline, hoist it:
 const sorted_value = Symbol("value");
 export const hoisted_sortedValueLovelaces = new IRHoisted(new IRFunc([sorted_value], _ir_apps(IRNative.unIData, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.headList, _ir_apps(IRNative.unMapData, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.headList, new IRVar(sorted_value)))))))));