@harmoniclabs/pebble 0.1.0-dev0

package/dist/compiler/tir/expressions/TirFromDataExpr.js

@@ -0,0 +1,196 @@
+import { IRApp } from "../../../IR/IRNodes/IRApp.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRConstr } from "../../../IR/IRNodes/IRConstr.js";
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { _ir_let } from "../../../IR/tree_utils/_ir_let.js";
+import { TirBoolT } from "../types/TirNativeType/native/bool.js";
+import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
+import { TirDataT } from "../types/TirNativeType/native/data.js";
+import { TirIntT } from "../types/TirNativeType/native/int.js";
+import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../types/TirNativeType/native/list.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { TirStringT } from "../types/TirNativeType/native/string.js";
+import { TirVoidT } from "../types/TirNativeType/native/void.js";
+import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { isTirType } from "../types/TirType.js";
+import { getListTypeArg } from "../types/utils/getListTypeArg.js";
+import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+export class TirFromDataExpr {
+    dataExpr;
+    type;
+    range;
+    constructor(dataExpr, type, range) {
+        this.dataExpr = dataExpr;
+        this.type = type;
+        this.range = range;
+    }
+    clone() {
+        return new TirFromDataExpr(this.dataExpr.clone(), this.type.clone(), this.range.clone());
+    }
+    get isConstant() { return this.dataExpr.isConstant; }
+    deps() {
+        return this.dataExpr.deps();
+    }
+    toIR(ctx) {
+        return _inlineFromData(this.type, this.dataExpr.toIR(ctx));
+    }
+    toString() {
+        return `fromData(${this.dataExpr.toString()}) as ${this.type.toString()}`;
+    }
+}
+export function _inlineFromData(target_t, dataExprIR) {
+    const to_t = getUnaliased(target_t);
+    if (
+    // target type is data-encoded
+    to_t instanceof TirDataStructType
+        || to_t instanceof TirDataOptT
+        || to_t instanceof TirDataT)
+        return dataExprIR;
+    if (to_t instanceof TirLinearMapT)
+        return _ir_apps(
+        // linear maps only have pairs as elements
+        // and we only support pairs of data (bc we only have `mkPairData`)
+        IRNative.unMapData, dataExprIR);
+    if (to_t instanceof TirListT) {
+        const elems_t = getUnaliased(getListTypeArg(to_t));
+        const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataOptT
+            || elems_t instanceof TirDataT)
+            return listOfDataExpr;
+        return _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), listOfDataExpr);
+    }
+    if (to_t instanceof TirSopOptT) {
+        const value_t = getOptTypeArg(to_t);
+        if (!isTirType(value_t))
+            throw new Error("TirFromDataExpr: unreachable");
+        return _ir_let(// introuduce a var
+        _ir_apps(IRNative.unConstrData, dataExprIR), _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+        ), IRConst.int(0)), 
+        // then (Just value)
+        new IRConstr(0, [
+            _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, new IRVar(0) // unConstrData result
+            )))
+        ]), 
+        // else (Nothing)
+        new IRHoisted(new IRConstr(1, []))));
+    }
+    if (to_t instanceof TirSoPStructType) {
+        return _inlineMultiSopConstrFromData(to_t, dataExprIR);
+    }
+    return _ir_apps(_fromDataUplcFunc(to_t), dataExprIR);
+}
+;
+export function _fromDataUplcFunc(_target_t) {
+    const target_t = getUnaliased(_target_t);
+    if (target_t instanceof TirDataT
+        || target_t instanceof TirDataOptT
+        || target_t instanceof TirDataStructType)
+        return IRNative._id;
+    if (target_t instanceof TirIntT)
+        return IRNative.unIData;
+    if (target_t instanceof TirBytesT)
+        return IRNative.unBData;
+    if (target_t instanceof TirVoidT)
+        return _mkUnit;
+    if (target_t instanceof TirBoolT)
+        return _boolFromData;
+    if (target_t instanceof TirStringT)
+        return _strFromData;
+    if (target_t instanceof TirLinearMapT)
+        // linear maps only have pairs as elements
+        // and we only support pairs of data (bc we only have `mkPairData`)
+        return IRNative.unMapData;
+    if (target_t instanceof TirListT) {
+        const elems_t = getUnaliased(getListTypeArg(target_t));
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataOptT
+            || elems_t instanceof TirDataT)
+            return IRNative.unListData;
+        return new IRHoisted(new IRFunc(1, // data ( representing list )
+        _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), _ir_apps(IRNative.unListData, new IRVar(0) // data
+        ))));
+    }
+    if (target_t instanceof TirSopOptT
+        || target_t instanceof TirSoPStructType) {
+        return new IRHoisted(new IRFunc(1, // data
+        _inlineFromData(target_t, new IRVar(0) // data
+        )));
+    }
+    throw new Error(`TirFromDataExpr: cannot convert from Data to type ${target_t.toString()}`);
+}
+const _mkUnit = new IRHoisted(new IRFunc(1, IRConst.unit, "~_mkUnit"));
+const _boolFromData = new IRHoisted(new IRFunc(1, _ir_apps(IRNative.equalsInteger, new IRApp(IRNative.fstPair, new IRApp(IRNative.unConstrData, new IRVar(0))), IRConst.int(0))));
+const _strFromData = new IRHoisted(new IRFunc(1, // data
+_ir_apps(IRNative.decodeUtf8, _ir_apps(IRNative.unBData, new IRVar(0) // data
+))));
+export function _inilneSingeSopConstrFromData(sop_t, dataExprIR) {
+    if (sop_t.constructors.length !== 1)
+        throw new Error("_inilneSingeSopConstrFromData: multiple constructors");
+    const constr = sop_t.constructors[0];
+    if (constr.fields.length === 0)
+        return new IRHoisted(new IRConstr(0, []));
+    if (constr.fields.length === 1) {
+        const value_t = getUnaliased(constr.fields[0].type);
+        if (!isTirType(value_t))
+            throw new Error("TirFromDataExpr: unreachable");
+        return new IRConstr(0, [
+            _inlineFromData(value_t, 
+            // get head of fields list
+            _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR))))
+        ]);
+    }
+    return _ir_let(_ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR)), // introuduce fields list
+    new IRConstr(0, constr.fields.map((field, i) => {
+        const field_t = getUnaliased(field.type);
+        if (!isTirType(field_t))
+            throw new Error("TirFromDataExpr: unreachable");
+        return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0 ? new IRVar(0) // fields list
+            : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(0) // fields list
+            )));
+    })));
+}
+export function _inlineMultiSopConstrFromData(sop_t, dataExprIR) {
+    if (sop_t.constructors.length <= 1)
+        return _inilneSingeSopConstrFromData(sop_t, dataExprIR);
+    const continuations = sop_t.constructors.map((constr, constrIdx) => {
+        if (constr.fields.length === 0)
+            return new IRHoisted(new IRConstr(constrIdx, []));
+        if (constr.fields.length === 1) {
+            const value_t = getUnaliased(constr.fields[0].type);
+            if (!isTirType(value_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return new IRConstr(constrIdx, [
+                _inlineFromData(value_t, _ir_apps(IRNative.headList, new IRVar(0) // fields list
+                ))
+            ]);
+        }
+        return new IRConstr(constrIdx, constr.fields.map((field, i) => {
+            const field_t = getUnaliased(field.type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0 ? new IRVar(0) // fields list
+                : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(0) // fields list
+                )));
+        }));
+    });
+    let finalIfThenElseChain = continuations[continuations.length - 1];
+    for (let i = continuations.length - 2; i >= 0; i--) {
+        finalIfThenElseChain = new IRForced(_ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(1), // isConstrIdx
+        IRConst.int(i)), new IRDelayed(continuations[i]), new IRDelayed(finalIfThenElseChain)));
+    }
+    return _ir_let(_ir_apps(IRNative.unConstrData, dataExprIR), // unConstrData result
+    _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+    )), // isConstrIdx
+    _ir_let(_ir_apps(IRNative.sndPair, new IRVar(1)), // fields list
+    finalIfThenElseChain)));
+}

package/dist/compiler/tir/expressions/TirFuncExpr.d.ts

@@ -0,0 +1,37 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirType } from "../types/TirType.js";
+import { TirBlockStmt } from "../statements/TirBlockStmt.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+import { TirFuncT } from "../types/TirNativeType/native/function.js";
+import { IRTerm } from "../../../IR/IRTerm.js";
+export declare class TirFuncExpr implements ITirExpr {
+    readonly name: string;
+    readonly params: TirSimpleVarDecl[];
+    returnType: TirType;
+    readonly body: TirBlockStmt;
+    readonly range: SourceRange;
+    private readonly _isLoop;
+    get type(): TirFuncT;
+    sig(): TirFuncT;
+    constructor(name: string, params: TirSimpleVarDecl[], returnType: TirType, body: TirBlockStmt, range: SourceRange, _isLoop?: boolean);
+    clone(): TirFuncExpr;
+    /**
+     * `true` if the function is guaranteed to never error
+     */
+    readonly isSafe: boolean;
+    /**
+     * `true` if, for all cases where the function can error,
+     * there is an alternative implementation that is safe (wrapping the result as `Optional`)
+     */
+    readonly isRecoverable: boolean;
+    isAnonymous(): boolean;
+    private _deps;
+    private _defineDeps;
+    deps(): string[];
+    private _isRecursive;
+    isRecursive(): boolean;
+    readonly isConstant: boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirFuncExpr.js

@@ -0,0 +1,92 @@
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
+import { IRRecursive } from "../../../IR/IRNodes/IRRecursive.js";
+import { TirReturnStmt } from "../statements/TirReturnStmt.js";
+import { TirFuncT } from "../types/TirNativeType/native/function.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+export class TirFuncExpr {
+    name;
+    params;
+    returnType;
+    body;
+    range;
+    _isLoop;
+    get type() {
+        return this.sig();
+    }
+    sig() {
+        return new TirFuncT(this.params.map(p => p.type), this.returnType);
+    }
+    constructor(name, 
+    // deconstructions are inlined in the body
+    params, 
+    // initialized to symbol while inferring
+    returnType, 
+    // in case of lambdas (that only specifies a return expression)
+    // this is just a return statement wrapped in a block
+    // (with decosntructed arguments if any) 
+    body, range, _isLoop = false) {
+        this.name = name;
+        this.params = params;
+        this.returnType = returnType;
+        this.body = body;
+        this.range = range;
+        this._isLoop = _isLoop;
+    }
+    clone() {
+        return new TirFuncExpr(this.name, this.params.slice(), this.returnType.clone(), this.body, this.range.clone(), this._isLoop);
+    }
+    /**
+     * `true` if the function is guaranteed to never error
+     */
+    isSafe = false;
+    /**
+     * `true` if, for all cases where the function can error,
+     * there is an alternative implementation that is safe (wrapping the result as `Optional`)
+     */
+    isRecoverable = false;
+    isAnonymous() {
+        return this.name === "";
+    }
+    _deps = undefined;
+    _defineDeps() {
+        if (Array.isArray(this._deps))
+            return;
+        const { introducedVars, deps } = this.params.reduce((acc, param) => {
+            mergeSortedStrArrInplace(acc.deps, filterSortedStrArrInplace(param.deps(), acc.introducedVars));
+            mergeSortedStrArrInplace(acc.introducedVars, param.introducedVars());
+            return acc;
+        }, { introducedVars: [], deps: [] });
+        mergeSortedStrArrInplace(deps, this.body.deps());
+        filterSortedStrArrInplace(deps, introducedVars);
+        this._deps = deps;
+    }
+    deps() {
+        this._defineDeps();
+        return this._deps.slice();
+    }
+    _isRecursive = false;
+    isRecursive() {
+        if (this._isLoop || this._isRecursive)
+            return true;
+        this._defineDeps();
+        this._isRecursive = this._deps.includes(this.name);
+        return this._isRecursive;
+    }
+    isConstant = false;
+    toIR(ctx) {
+        const returnStmt = this.body.stmts[0];
+        if (!(returnStmt instanceof TirReturnStmt))
+            throw new Error("function must be expressified before being converted to IR");
+        const expr = returnStmt.value;
+        const isRecursive = this.isRecursive();
+        ctx = ctx.newChild();
+        if (isRecursive)
+            ctx.defineRecursiveVar(this.name);
+        this.params.forEach(param => ctx.defineVar(param.name));
+        let irFunc = new IRFunc(this.params.length, expr.toIR(ctx), this.name);
+        if (isRecursive)
+            irFunc = new IRRecursive(irFunc, this.name);
+        return irFunc;
+    }
+}

package/dist/compiler/tir/expressions/TirHoistedExpr.d.ts

@@ -0,0 +1,18 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirHoistedExpr implements ITirExpr {
+    readonly varName: string;
+    expr: TirExpr;
+    get type(): TirType;
+    get range(): SourceRange;
+    constructor(varName: string, expr: TirExpr);
+    clone(): TirHoistedExpr;
+    deps(): string[];
+    unsafeClone(): TirHoistedExpr;
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirHoistedExpr.js

@@ -0,0 +1,28 @@
+import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
+export class TirHoistedExpr {
+    varName;
+    expr;
+    get type() {
+        return this.expr.type;
+    }
+    get range() {
+        return this.expr.range;
+    }
+    constructor(varName, expr) {
+        this.varName = varName;
+        this.expr = expr;
+    }
+    clone() {
+        return new TirHoistedExpr(this.varName, this.expr.clone());
+    }
+    deps() {
+        return this.expr.deps();
+    }
+    unsafeClone() {
+        return new TirHoistedExpr(this.varName, this.expr);
+    }
+    get isConstant() { return this.expr.isConstant; }
+    toIR(ctx) {
+        return new IRHoisted(this.expr.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/TirInlineClosedIR.d.ts

@@ -0,0 +1,16 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirFuncT } from "../types/TirNativeType/index.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirInlineClosedIR implements ITirExpr {
+    readonly type: TirFuncT;
+    readonly getIr: (ctx: ToIRTermCtx) => IRTerm;
+    readonly range: SourceRange;
+    sig(): TirFuncT;
+    constructor(type: TirFuncT, getIr: (ctx: ToIRTermCtx) => IRTerm, range: SourceRange);
+    get isConstant(): boolean;
+    clone(): ITirExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirInlineClosedIR.js

@@ -0,0 +1,25 @@
+import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
+export class TirInlineClosedIR {
+    type;
+    getIr;
+    range;
+    sig() {
+        return this.type;
+    }
+    constructor(type, getIr, range) {
+        this.type = type;
+        this.getIr = getIr;
+        this.range = range;
+    }
+    get isConstant() { return true; }
+    clone() {
+        return new TirInlineClosedIR(this.type.clone(), this.getIr, this.range.clone());
+    }
+    deps() {
+        return []; // closed IR has no dependencies
+    }
+    toIR(ctx) {
+        // since closed, we can hoist to avoid duplications
+        return new IRHoisted(this.getIr(ctx));
+    }
+}

package/dist/compiler/tir/expressions/TirLettedExpr.d.ts

@@ -0,0 +1,18 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirLettedExpr implements ITirExpr {
+    readonly varName: string;
+    expr: TirExpr;
+    readonly range: SourceRange;
+    get type(): TirType;
+    constructor(varName: string, expr: TirExpr, range: SourceRange);
+    deps(): string[];
+    clone(): TirLettedExpr;
+    unsafeClone(): TirLettedExpr;
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirLettedExpr.js

@@ -0,0 +1,28 @@
+import { IRLetted } from "../../../IR/IRNodes/IRLetted.js";
+export class TirLettedExpr {
+    varName;
+    expr;
+    range;
+    get type() {
+        return this.expr.type;
+    }
+    constructor(varName, expr, range) {
+        this.varName = varName;
+        this.expr = expr;
+        this.range = range;
+    }
+    deps() {
+        return this.expr.deps();
+    }
+    clone() {
+        return new TirLettedExpr(this.varName, this.expr.clone(), this.range.clone());
+    }
+    unsafeClone() {
+        return new TirLettedExpr(this.varName, this.expr, // this.expr.clone(),
+        this.range);
+    }
+    get isConstant() { return this.expr.isConstant; }
+    toIR(ctx) {
+        return new IRLetted(ctx.dbn, this.expr.toIR(ctx));
+    }
+}

package/dist/compiler/tir/expressions/TirNativeFunc.d.ts

@@ -0,0 +1,104 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+import { TirFuncT } from "../types/TirNativeType/native/function.js";
+export declare class TirNativeFunc implements ITirExpr {
+    readonly tag: IRNativeTag;
+    readonly type: TirFuncT;
+    constructor(tag: IRNativeTag, type: TirFuncT);
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    clone(): TirNativeFunc;
+    get range(): SourceRange;
+    deps(): string[];
+    get isConstant(): boolean;
+    static get addInteger(): TirNativeFunc;
+    static get subtractInteger(): TirNativeFunc;
+    static get multiplyInteger(): TirNativeFunc;
+    static get divideInteger(): TirNativeFunc;
+    static get quotientInteger(): TirNativeFunc;
+    static get remainderInteger(): TirNativeFunc;
+    static get modInteger(): TirNativeFunc;
+    static get equalsInteger(): TirNativeFunc;
+    static get lessThanInteger(): TirNativeFunc;
+    static get lessThanEqualInteger(): TirNativeFunc;
+    static get appendByteString(): TirNativeFunc;
+    static get consByteString(): TirNativeFunc;
+    static get sliceByteString(): TirNativeFunc;
+    static get lengthOfByteString(): TirNativeFunc;
+    static get indexByteString(): TirNativeFunc;
+    static get equalsByteString(): TirNativeFunc;
+    static get lessThanByteString(): TirNativeFunc;
+    static get lessThanEqualsByteString(): TirNativeFunc;
+    static get sha2_256(): TirNativeFunc;
+    static get sha3_256(): TirNativeFunc;
+    static get blake2b_256(): TirNativeFunc;
+    static get verifyEd25519Signature(): TirNativeFunc;
+    static strictIfThenElse(returnT: TirType): TirNativeFunc;
+    static chooseUnit(returnT: TirType): TirNativeFunc;
+    static strictChooseList(elemT: TirType, returnT: TirType): TirNativeFunc;
+    static mkCons(elemT: TirType): TirNativeFunc;
+    static headList(elemT: TirType): TirNativeFunc;
+    static tailList(elemT: TirType): TirNativeFunc;
+    static nullList(elemT: TirType): TirNativeFunc;
+    static chooseData(returnT: TirType): TirNativeFunc;
+    static get constrData(): TirNativeFunc;
+    static get mapData(): TirNativeFunc;
+    static get listData(): TirNativeFunc;
+    static get iData(): TirNativeFunc;
+    static get bData(): TirNativeFunc;
+    static get unConstrData(): TirNativeFunc;
+    static get unConstrDataResultFields(): TirNativeFunc;
+    static get unConstrDataResultIndex(): TirNativeFunc;
+    static get unMapData(): TirNativeFunc;
+    static get unListData(): TirNativeFunc;
+    static get unIData(): TirNativeFunc;
+    static get unBData(): TirNativeFunc;
+    static get equalsData(): TirNativeFunc;
+    static get mkNilData(): TirNativeFunc;
+    static get serialiseData(): TirNativeFunc;
+    static get verifyEcdsaSecp256k1Signature(): TirNativeFunc;
+    static get verifySchnorrSecp256k1Signature(): TirNativeFunc;
+    static get keccak_256(): TirNativeFunc;
+    static get blake2b_224(): TirNativeFunc;
+    static get integerToByteString(): TirNativeFunc;
+    static get byteStringToInteger(): TirNativeFunc;
+    static get andByteString(): TirNativeFunc;
+    static get orByteString(): TirNativeFunc;
+    static get xorByteString(): TirNativeFunc;
+    static get complementByteString(): TirNativeFunc;
+    static get readBit(): TirNativeFunc;
+    static get writeBits(): TirNativeFunc;
+    static get replicateByte(): TirNativeFunc;
+    static get shiftByteString(): TirNativeFunc;
+    static get rotateByteString(): TirNativeFunc;
+    static get countSetBits(): TirNativeFunc;
+    static get findFirstSetBit(): TirNativeFunc;
+    static get ripemd_160(): TirNativeFunc;
+    static _dropList(elemT: TirType): TirNativeFunc;
+    static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
+    static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
+    static _mkFindDataOptional(elems_t: TirType): TirNativeFunc;
+    static _length(elemT: TirType): TirNativeFunc;
+    static _some(elemT: TirType): TirNativeFunc;
+    static _every(elemT: TirType): TirNativeFunc;
+    static _mkFilter(elemT: TirType): TirNativeFunc;
+    static _id(t: TirType): TirNativeFunc;
+    static get _not(): TirNativeFunc;
+    static get _strictAnd(): TirNativeFunc;
+    static get _and(): TirNativeFunc;
+    static get _strictOr(): TirNativeFunc;
+    static get _or(): TirNativeFunc;
+    static get _gtBS(): TirNativeFunc;
+    static get _gtEqBS(): TirNativeFunc;
+    static get _gtInt(): TirNativeFunc;
+    static get _gtEqInt(): TirNativeFunc;
+    static get _pairDataToData(): TirNativeFunc;
+    static get _pairDataFromData(): TirNativeFunc;
+    static _mkEqualsList(elemT: TirType): TirNativeFunc;
+    static get _equalPairData(): TirNativeFunc;
+    static get _equalBoolean(): TirNativeFunc;
+    static get _negateInt(): TirNativeFunc;
+}