@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,196 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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;
-}