@nori-zk/proof-conversion/build/src/groth/proof.d.ts

Verifying zkVM proofs inside o1js circuits, to generate Mina compatible proof

import { G1Affine, G2Affine } from '../ec/index.js';
import { Fp2 } from '../towers/index.js';
import { G2Line } from '../lines/index.js';
import { GrothVk } from './vk.js';
declare const Proof_base: (new (value: {
    negA: G1Affine;
    B: G2Affine;
    C: G1Affine;
    PI: G1Affine;
    b_lines: G2Line[];
    pis: import("o1js").CanonicalForeignField[];
}) => {
    negA: G1Affine;
    B: G2Affine;
    C: G1Affine;
    PI: G1Affine;
    b_lines: G2Line[];
    pis: import("o1js").CanonicalForeignField[];
}) & {
    _isStruct: true;
} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
    negA: G1Affine;
    B: G2Affine;
    C: G1Affine;
    PI: G1Affine;
    b_lines: G2Line[];
    pis: import("o1js").CanonicalForeignField[];
}, {
    negA: {
        x: bigint;
        y: bigint;
    };
    B: {
        x: {
            c0: bigint;
            c1: bigint;
        };
        y: {
            c0: bigint;
            c1: bigint;
        };
    };
    C: {
        x: bigint;
        y: bigint;
    };
    PI: {
        x: bigint;
        y: bigint;
    };
    b_lines: {
        lambda: {
            c0: bigint;
            c1: bigint;
        };
        neg_mu: {
            c0: bigint;
            c1: bigint;
        };
    }[];
    pis: bigint[];
}>, "fromFields"> & {
    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    };
} & {
    fromValue: (value: {
        negA: G1Affine | {
            x: bigint | import("o1js").AlmostForeignField;
            y: bigint | import("o1js").AlmostForeignField;
        };
        B: G2Affine | {
            x: Fp2 | {
                c0: bigint | import("o1js").AlmostForeignField;
                c1: bigint | import("o1js").AlmostForeignField;
            };
            y: Fp2 | {
                c0: bigint | import("o1js").AlmostForeignField;
                c1: bigint | import("o1js").AlmostForeignField;
            };
        };
        C: G1Affine | {
            x: bigint | import("o1js").AlmostForeignField;
            y: bigint | import("o1js").AlmostForeignField;
        };
        PI: G1Affine | {
            x: bigint | import("o1js").AlmostForeignField;
            y: bigint | import("o1js").AlmostForeignField;
        };
        b_lines: G2Line[] | {
            lambda: {
                c0: bigint;
                c1: bigint;
            };
            neg_mu: {
                c0: bigint;
                c1: bigint;
            };
        }[];
        pis: import("o1js").CanonicalForeignField[] | bigint[];
    }) => {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    };
    toInput: (x: {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    }) => {
        fields?: import("o1js").Field[] | undefined;
        packed?: [import("o1js").Field, number][] | undefined;
    };
    toJSON: (x: {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    }) => {
        negA: {
            x: string;
            y: string;
        };
        B: {
            x: {
                c0: string;
                c1: string;
            };
            y: {
                c0: string;
                c1: string;
            };
        };
        C: {
            x: string;
            y: string;
        };
        PI: {
            x: string;
            y: string;
        };
        b_lines: {
            lambda: {
                c0: string;
                c1: string;
            };
            neg_mu: {
                c0: string;
                c1: string;
            };
        }[];
        pis: string[];
    };
    fromJSON: (x: {
        negA: {
            x: string;
            y: string;
        };
        B: {
            x: {
                c0: string;
                c1: string;
            };
            y: {
                c0: string;
                c1: string;
            };
        };
        C: {
            x: string;
            y: string;
        };
        PI: {
            x: string;
            y: string;
        };
        b_lines: {
            lambda: {
                c0: string;
                c1: string;
            };
            neg_mu: {
                c0: string;
                c1: string;
            };
        }[];
        pis: string[];
    }) => {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    };
    empty: () => {
        negA: G1Affine;
        B: G2Affine;
        C: G1Affine;
        PI: G1Affine;
        b_lines: G2Line[];
        pis: import("o1js").CanonicalForeignField[];
    };
};
declare class Proof extends Proof_base {
    static parse(vk: GrothVk, path: string): Proof;
}
export { Proof };