@harmoniclabs/pebble 0.1.9 → 0.2.0

package/dist/compiler/Compiler.js

@@ -1,7 +1,9 @@
-import { compileUPLC, Force, parseUPLC, UPLCProgram } from "@harmoniclabs/uplc";
-import { Machine } from "@harmoniclabs/plutus-machine";
+import { Application, compileUPLC, Force, parseUPLC, UPLCConst, UPLCProgram } from "@harmoniclabs/uplc";
+import { CEKError, Machine } from "@harmoniclabs/plutus-machine";
+import { DiagnosticCategory } from "../diagnostics/DiagnosticCategory.js";
 import { DiagnosticEmitter } from "../diagnostics/DiagnosticEmitter.js";
-import { defaultOptions } from "../IR/toUPLC/CompilerOptions.js";
+import { COMPILER_VERSION } from "../version.generated.js";
+import { semverSatisfies } from "../utils/semverSatisfies.js";
 import { AstCompiler } from "./AstCompiler/AstCompiler.js";
 import { createMemoryCompilerIoApi } from "./io/CompilerIoApi.js";
 import { compileTypedProgram } from "./TirCompiler/compileTirProgram.js";
@@ -12,14 +14,27 @@ import { __unsafe_clear_letted_hash_to_symbol } from "../IR/IRNodes/IRLetted.js"
 import { __unsafe_clear_hoisted_cache } from "../IR/toUPLC/subRoutines/replaceHoistedWithLetted.js";
 import { __unsafe_clear_mapToType_cache } from "./TirCompiler/expressify/expressifyVars.js";
 import { compileIRToUPLC } from "../IR/toUPLC/compileIRToUPLC.js";
+import { TirFuncExpr } from "./tir/expressions/TirFuncExpr.js";
+import { addBudget, zeroBudget, } from "./test/TestResult.js";
+import { PRNG } from "./test/fuzz/PRNG.js";
 export { SourceTypeMap } from "./SourceTypeMap.js";
 export class Compiler extends DiagnosticEmitter {
     io;
     cfg;
-    constructor(io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), cfg = defaultOptions, diagnostics) {
+    constructor(io = createMemoryCompilerIoApi({ useConsoleAsOutput: true }), cfg, diagnostics) {
         super(diagnostics);
         this.io = io;
         this.cfg = cfg;
+        const range = cfg?.compilerVersion;
+        if (typeof range !== "string" || range.length === 0) {
+            throw new Error(`Pebble compiler config is missing "compilerVersion". ` +
+                `Starting from @harmoniclabs/pebble@0.2.0 this field is required ` +
+                `and must be an npm-style semver range (e.g. "^0.2.0").`);
+        }
+        if (!semverSatisfies(COMPILER_VERSION, range)) {
+            throw new Error(`Pebble compiler version ${COMPILER_VERSION} does not satisfy ` +
+                `the configured "compilerVersion" range "${range}".`);
+        }
         if (cfg.silent === true) {
             this.io.stdout = { write() { } };
         }
@@ -102,6 +117,167 @@ export class Compiler extends DiagnosticEmitter {
         // compiles to `Delay(body)`; force it so the body executes.
         return Machine.eval(new Force(uplcProgram.body));
     }
+    async test(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            silent: true,
+            addMarker: false,
+        };
+        const nameFilter = config?.nameFilter;
+        const matches = (!nameFilter ? () => true :
+            typeof nameFilter === "string" ? (n) => n.includes(nameFilter) :
+                (n) => nameFilter.test(n));
+        const propertyIterations = Math.max(1, config?.propertyIterations ?? 100);
+        const seed = config?.seed ?? 0;
+        // 1) discovery pass: parse + check, populate program.tests.
+        //    diagnostics from this pass are surfaced once; subsequent per-test
+        //    passes use their own diagnostic arrays so we don't double-report.
+        const discovery = new AstCompiler(cfg, this.io, this.diagnostics);
+        const discoveryResult = await discovery.check();
+        const descriptors = discoveryResult.program.tests
+            .filter(t => matches(t.name))
+            .map(t => {
+            const fn = discoveryResult.program.functions.get(t.tirFuncName);
+            const paramNames = (fn instanceof TirFuncExpr) ? fn.params.map(p => p.sourceName ?? p.name) : [];
+            return {
+                name: t.name,
+                tirFuncName: t.tirFuncName,
+                sourceFile: t.sourceFile,
+                range: t.range,
+                paramNames,
+                fuzzerInfos: t.fuzzerInfos,
+            };
+        });
+        const results = new Array(descriptors.length);
+        for (let i = 0; i < descriptors.length; i++) {
+            results[i] = await this._runOneTest(cfg, descriptors[i], propertyIterations, seed);
+        }
+        return results;
+    }
+    async _runOneTest(cfg, desc, propertyIterations, seed) {
+        const isProperty = desc.fuzzerInfos.length > 0;
+        // fresh AstCompiler so the expressify pass starts from a clean program
+        const localDiagnostics = [];
+        const astCompiler = new AstCompiler(cfg, this.io, localDiagnostics);
+        await astCompiler.compileFile(cfg.entry, true);
+        if (localDiagnostics.some(d => d.category === DiagnosticCategory.Error)) {
+            return _failedTestResult(desc, "compile error: " + localDiagnostics.find(d => d.category === DiagnosticCategory.Error).toString(), isProperty ? "property" : "unit");
+        }
+        const fn = astCompiler.program.functions.get(desc.tirFuncName);
+        if (!(fn instanceof TirFuncExpr)) {
+            return _failedTestResult(desc, `test function "${desc.name}" not found after re-parse`, isProperty ? "property" : "unit");
+        }
+        astCompiler.program.contractTirFuncName = desc.tirFuncName;
+        let serialized;
+        try {
+            serialized = this._compileBackend(cfg, astCompiler.program, true);
+        }
+        catch (err) {
+            return _failedTestResult(desc, "backend error: " + (err instanceof Error ? err.message : String(err)), isProperty ? "property" : "unit");
+        }
+        const uplcProgram = parseUPLC(serialized);
+        if (!isProperty) {
+            const evalResult = Machine.eval(new Force(uplcProgram.body));
+            const isErr = evalResult.result instanceof CEKError;
+            const budget = {
+                cpu: BigInt(evalResult.budgetSpent.cpu),
+                mem: BigInt(evalResult.budgetSpent.mem),
+            };
+            const iter = {
+                passed: !isErr,
+                budgetSpent: budget,
+                logs: evalResult.logs.slice(),
+                error: isErr ? { msg: evalResult.result.msg } : undefined,
+            };
+            return {
+                name: desc.name,
+                sourceFile: desc.sourceFile,
+                range: desc.range,
+                kind: "unit",
+                passed: !isErr,
+                iterations: [iter],
+                totalBudget: addBudget(zeroBudget(), budget),
+            };
+        }
+        // ── Property test ──────────────────────────────────────────────
+        // Check that every parameter has an executable fuzzer in v1 (Phase 1).
+        const unsupported = desc.fuzzerInfos.find(fi => fi.kind === "unsupported" || fi.kind === "via_not_implemented");
+        if (unsupported) {
+            const reason = unsupported.kind === "via_not_implemented"
+                ? "user-defined fuzzers via the 'via' keyword are not yet executable (Phase 2)"
+                : unsupported.reason;
+            return {
+                name: desc.name,
+                sourceFile: desc.sourceFile,
+                range: desc.range,
+                kind: "property",
+                passed: false,
+                iterations: [],
+                totalBudget: zeroBudget(),
+                skippedReason: reason,
+                seed,
+            };
+        }
+        // Run N iterations with TS-side sampling.
+        const prng = new PRNG(seed);
+        const iterations = [];
+        let totalBudget = zeroBudget();
+        let passedAll = true;
+        for (let i = 0; i < propertyIterations; i++) {
+            const inputs = [];
+            const args = [];
+            for (let p = 0; p < desc.fuzzerInfos.length; p++) {
+                const fi = desc.fuzzerInfos[p];
+                if (fi.kind !== "primitive")
+                    throw new Error("unreachable: non-primitive after unsupported check");
+                const paramName = desc.paramNames[p] ?? `param${p}`;
+                if (fi.primitive === "int") {
+                    const v = prng.nextIntBiased();
+                    inputs.push({ name: paramName, value: v });
+                    args.push(UPLCConst.int(v));
+                }
+                else // bool
+                 {
+                    const v = prng.nextBool();
+                    inputs.push({ name: paramName, value: v });
+                    args.push(UPLCConst.bool(v));
+                }
+            }
+            let app = uplcProgram.body;
+            for (const arg of args)
+                app = new Application(app, arg);
+            const evalResult = Machine.eval(app);
+            const isErr = evalResult.result instanceof CEKError;
+            const budget = {
+                cpu: BigInt(evalResult.budgetSpent.cpu),
+                mem: BigInt(evalResult.budgetSpent.mem),
+            };
+            const iter = {
+                passed: !isErr,
+                budgetSpent: budget,
+                logs: evalResult.logs.slice(),
+                error: isErr ? { msg: evalResult.result.msg } : undefined,
+                inputs,
+            };
+            iterations.push(iter);
+            totalBudget = addBudget(totalBudget, budget);
+            if (isErr) {
+                passedAll = false;
+                break; // early exit on first failure (Phase 1; shrinking is Phase 2)
+            }
+        }
+        return {
+            name: desc.name,
+            sourceFile: desc.sourceFile,
+            range: desc.range,
+            kind: "property",
+            passed: passedAll,
+            iterations,
+            totalBudget,
+            seed,
+        };
+    }
     async runRepl(config) {
         const cfg = {
             ...this.cfg,
@@ -126,15 +302,17 @@ export class Compiler extends DiagnosticEmitter {
         // compiles to `Delay(body)`; force it so the body executes.
         return Machine.eval(new Force(uplcProgram.body));
     }
-    _compileBackend(cfg, program) {
+    _compileBackend(cfg, program, skipFileOutput = false) {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir, cfg);
         const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
-        const outDir = cfg.outDir;
-        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
-        this.io.writeFile(outPath, serialized, cfg.root);
-        this.io.stdout.write(`compiled program written to ${outPath}\n`);
+        if (!skipFileOutput) {
+            const outDir = cfg.outDir;
+            const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
+            this.io.writeFile(outPath, serialized, cfg.root);
+            this.io.stdout.write(`compiled program written to ${outPath}\n`);
+        }
         __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
         __VERY_UNSAFE_FORGET_VAR_SYM_HASHES_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
         __unsafe_clear_hoisted_hash_to_symbol();
@@ -144,3 +322,20 @@ export class Compiler extends DiagnosticEmitter {
         return serialized;
     }
 }
+function _failedTestResult(desc, msg, kind = "unit") {
+    const budget = zeroBudget();
+    return {
+        name: desc.name,
+        sourceFile: desc.sourceFile,
+        range: desc.range,
+        kind,
+        passed: false,
+        iterations: [{
+                passed: false,
+                budgetSpent: budget,
+                logs: [],
+                error: { msg },
+            }],
+        totalBudget: budget,
+    };
+}

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -30,6 +30,7 @@ import { TirTernaryExpr } from "../../tir/expressions/TirTernaryExpr.js";
 import { TirToDataExpr } from "../../tir/expressions/TirToDataExpr.js";
 import { TirTraceIfFalseExpr } from "../../tir/expressions/TirTraceIfFalseExpr.js";
 import { TirTraceExpr } from "../../tir/expressions/TirTraceExpr.js";
+import { TirShowExpr } from "../../tir/expressions/TirShowExpr.js";
 import { TirTypeConversionExpr } from "../../tir/expressions/TirTypeConversionExpr.js";
 import { TirVariableAccessExpr } from "../../tir/expressions/TirVariableAccessExpr.js";
 import { TirUnaryExclamation } from "../../tir/expressions/unary/TirUnaryExclamation.js";
@@ -242,6 +243,11 @@ export function expressifyVars(ctx, expr) {
     }
     if (expr instanceof TirInlineClosedIR)
         return expr;
+    if (expr instanceof TirShowExpr) {
+        // recurse into inner so any nested variables / casts get expressified;
+        // the show-bytes lowering happens at IR-emit time inside TirShowExpr.toIR.
+        return new TirShowExpr(expressifyVars(ctx, expr.inner), expr.range);
+    }
     const tsEnsureExhautstiveCheck = expr;
     console.error(expr);
     throw new Error("unreachable::expressifyVars");
@@ -276,7 +282,9 @@ function expressifyPropAccess(ctx, propAccessExpr) {
         || expr instanceof TirAssertAndContinueExpr
         || expr instanceof TirTraceIfFalseExpr
         || expr instanceof TirTraceExpr
-        || expr instanceof TirInlineClosedIR)
+        || expr instanceof TirInlineClosedIR
+        || expr instanceof TirShowExpr // result is bytes, properties already handled via .show() returning bytes_t
+    )
         throw new Error("Invalid property access expression");
     if (expr instanceof TirLitThisExpr) {
         let varName = ctx.properties.get("this")?.get(prop);
@@ -445,12 +453,15 @@ function expressifyMethodCall(ctx, methodCall) {
         }
         const structMethods = objectType.methodNamesPtr;
         const tirMethodName = structMethods.get(methodName);
-        if (!tirMethodName)
-            throw new Error(`Method '${methodName}' does not exist on type '${objectType.toString()}'`);
-        const funcExpr = ctx.program.functions.get(tirMethodName);
-        if (!funcExpr)
-            throw new Error(`Definition of method '${methodName}' on type '${objectType.toString()}' is missing.`);
-        return new TirCallExpr(funcExpr, [objectExpr, ...methodCall.args], methodCall.type, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
+        if (tirMethodName) {
+            const funcExpr = ctx.program.functions.get(tirMethodName);
+            if (!funcExpr)
+                throw new Error(`Definition of method '${methodName}' on type '${objectType.toString()}' is missing.`);
+            return new TirCallExpr(funcExpr, [objectExpr, ...methodCall.args], methodCall.type, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
+        }
+        // No user impl — fall through to the generic `.show()` fallback at the
+        // end of expressifyMethodCall (which auto-derives via _showIR for
+        // data-encoded structs).
     }
     if (objectType instanceof TirListT) {
         const result = expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, objectType, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd()));
@@ -491,6 +502,14 @@ function expressifyMethodCall(ctx, methodCall) {
             return new TirCallExpr(TirNativeFunc.consByteString, [methodCall.args[0], objectExpr], bytes_t, exprRange);
         }
     }
+    // Generic `.show()` fallback: any value whose type has a built-in
+    // `_showIR` impl can be shown by emitting a TirShowExpr. User types
+    // override this by declaring `type X implements Show { show(self): bytes
+    // { ... } }` — that path is taken earlier (alias/struct method-table
+    // dispatch) and never reaches here.
+    if (methodName === "show" && methodCall.args.length === 0) {
+        return new TirShowExpr(objectExpr, SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd())); // TirShowExpr is in TirExpr union, cast for return-type compat
+    }
     throw new Error(`not implemented::expressifyMethodCall for type '${objectType.toString()}' (method name: '${methodName}')`);
     // const tsEnsureExhautstiveCheck: never = objectType;
     throw new Error(`Cannot call method '${methodName}' on non-struct type '${objectType.toString()}'`);

package/dist/compiler/test/TestResult.d.ts

@@ -0,0 +1,38 @@
+import { SourceRange } from "../../ast/Source/SourceRange.js";
+export type TestKind = "unit" | "property";
+export interface TestBudget {
+    cpu: bigint;
+    mem: bigint;
+}
+export interface TestInput {
+    name: string;
+    value: unknown;
+}
+export interface TestIterationResult {
+    passed: boolean;
+    budgetSpent: TestBudget;
+    logs: string[];
+    error?: {
+        msg?: string;
+    };
+    /** the fuzzed input tuple for this iteration; undefined for unit tests */
+    inputs?: TestInput[];
+}
+export interface TestResult {
+    name: string;
+    sourceFile: string;
+    range: SourceRange;
+    kind: TestKind;
+    /** aggregate pass/fail across all iterations */
+    passed: boolean;
+    /** length 1 for unit tests, N for property tests */
+    iterations: TestIterationResult[];
+    /** sum of `budgetSpent` across iterations */
+    totalBudget: TestBudget;
+    /** non-empty when the test could not be executed at all (e.g. unsupported feature) */
+    skippedReason?: string;
+    /** seed used by the property runner (only set for property tests) */
+    seed?: number;
+}
+export declare function zeroBudget(): TestBudget;
+export declare function addBudget(a: TestBudget, b: TestBudget): TestBudget;

package/dist/compiler/test/TestResult.js

@@ -0,0 +1,6 @@
+export function zeroBudget() {
+    return { cpu: 0n, mem: 0n };
+}
+export function addBudget(a, b) {
+    return { cpu: a.cpu + b.cpu, mem: a.mem + b.mem };
+}

package/dist/compiler/test/fuzz/PRNG.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tiny seedable PRNG (mulberry32).
+ *
+ * Single-purpose, deterministic, no dependencies. Used by the Phase 1
+ * property-test runner to sample primitive values for parameters whose
+ * type has a built-in TS-side fuzzer (`int`, `bool`).
+ *
+ * Phase 2 will replace this with a Pebble-side fuzzer pipeline that runs
+ * on the CEK machine; that will let user-defined fuzzers (`via <expr>`)
+ * compose deterministically with the built-in ones.
+ */
+export declare class PRNG {
+    private state;
+    constructor(seed: number);
+    /** Returns an unsigned 32-bit integer. */
+    next32(): number;
+    /** Returns a boolean (uniform). */
+    nextBool(): boolean;
+    /**
+     * Returns a random bigint, biased toward edge values.
+     *
+     * 1 in 16 returns one of: 0, 1, -1, INT64_MAX, INT64_MIN, INT32_MAX, INT32_MIN.
+     * Otherwise samples uniformly across signed 64-bit range.
+     */
+    nextIntBiased(): bigint;
+}

package/dist/compiler/test/fuzz/PRNG.js

@@ -0,0 +1,59 @@
+/**
+ * Tiny seedable PRNG (mulberry32).
+ *
+ * Single-purpose, deterministic, no dependencies. Used by the Phase 1
+ * property-test runner to sample primitive values for parameters whose
+ * type has a built-in TS-side fuzzer (`int`, `bool`).
+ *
+ * Phase 2 will replace this with a Pebble-side fuzzer pipeline that runs
+ * on the CEK machine; that will let user-defined fuzzers (`via <expr>`)
+ * compose deterministically with the built-in ones.
+ */
+export class PRNG {
+    state;
+    constructor(seed) {
+        // ensure non-zero, fits in u32
+        this.state = (seed | 0) || 1;
+    }
+    /** Returns an unsigned 32-bit integer. */
+    next32() {
+        // mulberry32
+        let t = (this.state = (this.state + 0x6D2B79F5) | 0);
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return (t ^ (t >>> 14)) >>> 0;
+    }
+    /** Returns a boolean (uniform). */
+    nextBool() {
+        return (this.next32() & 1) === 1;
+    }
+    /**
+     * Returns a random bigint, biased toward edge values.
+     *
+     * 1 in 16 returns one of: 0, 1, -1, INT64_MAX, INT64_MIN, INT32_MAX, INT32_MIN.
+     * Otherwise samples uniformly across signed 64-bit range.
+     */
+    nextIntBiased() {
+        const edgeRoll = this.next32() & 0xF; // 0..15
+        if (edgeRoll === 0) {
+            const edges = [
+                0n,
+                1n,
+                -1n,
+                (1n << 63n) - 1n,
+                -(1n << 63n),
+                (1n << 31n) - 1n,
+                -(1n << 31n),
+            ];
+            return edges[this.next32() % edges.length];
+        }
+        // assemble a 64-bit signed value from two u32 samples
+        const hi = BigInt(this.next32());
+        const lo = BigInt(this.next32());
+        let v = (hi << 32n) | lo;
+        // interpret as signed (sign bit is bit 63)
+        if (v & (1n << 63n))
+            v -= (1n << 64n);
+        return v;
+    }
+}

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

@@ -21,5 +21,6 @@ import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
 import { TirIsExpr } from "./TirIsExpr.js";
-export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirIsExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirInlineClosedIR);
+import { TirShowExpr } from "./TirShowExpr.js";
+export type TirExpr = (TirUnaryPrefixExpr | TirLitteralExpr | TirParentesizedExpr | TirFuncExpr | TirCallExpr | TirCaseExpr | TirTypeConversionExpr | TirIsExpr | TirElemAccessExpr | TirTernaryExpr | TirPropAccessExpr | TirBinaryExpr | TirVariableAccessExpr | TirLettedExpr | TirNativeFunc | TirFailExpr | TirHoistedExpr | TirFromDataExpr | TirToDataExpr | TirAssertAndContinueExpr | TirTraceIfFalseExpr | TirTraceExpr | TirShowExpr | TirInlineClosedIR);
 export declare function isTirExpr(thing: any): thing is TirExpr;

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

@@ -22,6 +22,7 @@ import { TirTraceExpr } from "./TirTraceExpr.js";
 import { TirNativeFunc } from "./TirNativeFunc.js";
 import { TirInlineClosedIR } from "./TirInlineClosedIR.js";
 import { TirIsExpr } from "./TirIsExpr.js";
+import { TirShowExpr } from "./TirShowExpr.js";
 export function isTirExpr(thing) {
     return isObject(thing) && (isTirUnaryPrefixExpr(thing)
         || isTirLitteralExpr(thing)
@@ -45,5 +46,6 @@ export function isTirExpr(thing) {
         || thing instanceof TirAssertAndContinueExpr
         || thing instanceof TirTraceIfFalseExpr
         || thing instanceof TirTraceExpr
+        || thing instanceof TirShowExpr
         || thing instanceof TirInlineClosedIR);
 }

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

@@ -65,6 +65,23 @@ export declare class TirNativeFunc implements ITirExpr {
     static get serialiseData(): TirNativeFunc;
     static get verifyEcdsaSecp256k1Signature(): TirNativeFunc;
     static get verifySchnorrSecp256k1Signature(): TirNativeFunc;
+    static get bls12_381_G1_add(): TirNativeFunc;
+    static get bls12_381_G1_neg(): TirNativeFunc;
+    static get bls12_381_G1_scalarMul(): TirNativeFunc;
+    static get bls12_381_G1_equal(): TirNativeFunc;
+    static get bls12_381_G1_hashToGroup(): TirNativeFunc;
+    static get bls12_381_G1_compress(): TirNativeFunc;
+    static get bls12_381_G1_uncompress(): TirNativeFunc;
+    static get bls12_381_G2_add(): TirNativeFunc;
+    static get bls12_381_G2_neg(): TirNativeFunc;
+    static get bls12_381_G2_scalarMul(): TirNativeFunc;
+    static get bls12_381_G2_equal(): TirNativeFunc;
+    static get bls12_381_G2_hashToGroup(): TirNativeFunc;
+    static get bls12_381_G2_compress(): TirNativeFunc;
+    static get bls12_381_G2_uncompress(): TirNativeFunc;
+    static get bls12_381_millerLoop(): TirNativeFunc;
+    static get bls12_381_mulMlResult(): TirNativeFunc;
+    static get bls12_381_finalVerify(): TirNativeFunc;
     static get keccak_256(): TirNativeFunc;
     static get blake2b_224(): TirNativeFunc;
     static get integerToByteString(): TirNativeFunc;