@proto-kit/protocol 0.1.1-develop.0

package/dist/prover/block/BlockProvable.d.ts

@@ -0,0 +1,409 @@
+import { Bool, DynamicProof, Proof, Signature, Void } from "o1js";
+import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
+import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
+import { RuntimeVerificationKeyAttestation } from "./accummulators/RuntimeVerificationKeyTree";
+declare const BlockProverPublicInput_base: (new (value: {
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    transactionsHash: bigint;
+    stateRoot: bigint;
+    networkStateHash: bigint;
+    blockHashRoot: bigint;
+    eternalTransactionsHash: bigint;
+    incomingMessagesHash: bigint;
+    blockNumber: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        transactionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        blockNumber: string;
+    };
+    fromJSON: (x: {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        blockNumber: string;
+    }) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class BlockProverPublicInput extends BlockProverPublicInput_base {
+}
+declare const BlockProverPublicOutput_base: (new (value: {
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    transactionsHash: bigint;
+    stateRoot: bigint;
+    networkStateHash: bigint;
+    blockHashRoot: bigint;
+    eternalTransactionsHash: bigint;
+    incomingMessagesHash: bigint;
+    closed: boolean;
+    blockNumber: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        transactionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        closed: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        closed: boolean;
+        blockNumber: string;
+    };
+    fromJSON: (x: {
+        transactionsHash: string;
+        stateRoot: string;
+        networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        closed: boolean;
+        blockNumber: string;
+    }) => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class BlockProverPublicOutput extends BlockProverPublicOutput_base {
+    equals(input: BlockProverPublicInput, closed: Bool): Bool;
+}
+export type BlockProverProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
+declare const BlockProverExecutionData_base: (new (value: {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+    networkState: NetworkState;
+}) => {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+    networkState: NetworkState;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/lib/provable/provable").Provable<{
+    transaction: RuntimeTransaction;
+    signature: Signature;
+    networkState: NetworkState;
+}, {
+    transaction: {
+        methodId: bigint;
+        argsHash: bigint;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
+    };
+    signature: any;
+    networkState: {
+        block: {
+            height: bigint;
+        };
+        previous: {
+            rootHash: bigint;
+        };
+    };
+}> & {
+    fromValue: (value: {
+        transaction: RuntimeTransaction | {
+            methodId: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            argsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            nonce: import("../..").UInt64Option | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: any;
+            };
+            sender: import("../..").PublicKeyOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: any;
+            };
+        };
+        signature: any;
+        networkState: NetworkState | {
+            block: import("../../model/network/NetworkState").CurrentBlock | {
+                height: bigint | import("o1js/dist/node/lib/provable/int").UInt64;
+            };
+            previous: import("../../model/network/NetworkState").PreviousBlock | {
+                rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+        };
+    }) => {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+        networkState: NetworkState;
+    };
+    toInput: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+        networkState: NetworkState;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+        networkState: NetworkState;
+    }) => {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+        networkState: {
+            block: {
+                height: string;
+            };
+            previous: {
+                rootHash: string;
+            };
+        };
+    };
+    fromJSON: (x: {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+        networkState: {
+            block: {
+                height: string;
+            };
+            previous: {
+                rootHash: string;
+            };
+        };
+    }) => {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+        networkState: NetworkState;
+    };
+    empty: () => {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+        networkState: NetworkState;
+    };
+};
+export declare class BlockProverExecutionData extends BlockProverExecutionData_base {
+}
+export declare class DynamicRuntimeProof extends DynamicProof<Void, MethodPublicOutput> {
+    static publicInputType: import("o1js/dist/node/lib/provable/types/struct").ProvablePureExtended<void, void, null>;
+    static publicOutputType: typeof MethodPublicOutput;
+    static maxProofsVerified: 0;
+}
+export interface BlockProvable extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput>, CompilableModule {
+    proveTransaction: (publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: DynamicRuntimeProof, executionData: BlockProverExecutionData, verificationKeyAttestation: RuntimeVerificationKeyAttestation) => Promise<BlockProverPublicOutput>;
+    proveBlock: (publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, transactionProof: BlockProverProof) => Promise<BlockProverPublicOutput>;
+    merge: (publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof) => Promise<BlockProverPublicOutput>;
+}
+export {};
+//# sourceMappingURL=BlockProvable.d.ts.map

package/dist/prover/block/BlockProvable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,YAAY,EAEZ,KAAK,EACL,SAAS,EAET,IAAI,EACL,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/F,qBAAa,sBAAuB,SAAQ,2BAQ1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAS3C;IACO,MAAM,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI;CAUjE;AAED,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,qBAAa,mBAAoB,SAAQ,YAAY,CACnD,IAAI,EACJ,kBAAkB,CACnB;IACC,MAAM,CAAC,eAAe,4FAAQ;IAE9B,MAAM,CAAC,gBAAgB,4BAAsB;IAG7C,MAAM,CAAC,iBAAiB,IAAc;CACvC;AAED,MAAM,WAAW,aACf,SAAQ,kBAAkB,CAAC,sBAAsB,EAAE,uBAAuB,CAAC,EACzE,gBAAgB;IAClB,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,mBAAmB,EAC7B,aAAa,EAAE,wBAAwB,EACvC,0BAA0B,EAAE,iCAAiC,KAC1D,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEtC,UAAU,EAAE,CACV,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,0BAA0B,EAExC,gBAAgB,EAAE,gBAAgB,KAC/B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEtC,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACvC"}

package/dist/prover/block/BlockProvable.js

@@ -0,0 +1,48 @@
+import { Bool, DynamicProof, Field, Signature, Struct, Void, } from "o1js";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+export class BlockProverPublicInput extends Struct({
+    transactionsHash: Field,
+    stateRoot: Field,
+    networkStateHash: Field,
+    blockHashRoot: Field,
+    eternalTransactionsHash: Field,
+    incomingMessagesHash: Field,
+    blockNumber: Field,
+}) {
+}
+export class BlockProverPublicOutput extends Struct({
+    transactionsHash: Field,
+    stateRoot: Field,
+    networkStateHash: Field,
+    blockHashRoot: Field,
+    eternalTransactionsHash: Field,
+    incomingMessagesHash: Field,
+    closed: Bool,
+    blockNumber: Field,
+}) {
+    equals(input, closed) {
+        const output2 = BlockProverPublicOutput.toFields({
+            ...input,
+            closed,
+        });
+        const output1 = BlockProverPublicOutput.toFields(this);
+        return output1
+            .map((value1, index) => value1.equals(output2[index]))
+            .reduce((a, b) => a.and(b));
+    }
+}
+export class BlockProverExecutionData extends Struct({
+    transaction: RuntimeTransaction,
+    signature: Signature,
+    networkState: NetworkState,
+}) {
+}
+export class DynamicRuntimeProof extends DynamicProof {
+}
+DynamicRuntimeProof.publicInputType = Void;
+DynamicRuntimeProof.publicOutputType = MethodPublicOutput;
+// TODO this won't be 0 for proofs-as-args
+DynamicRuntimeProof.maxProofsVerified = 0;
+//# sourceMappingURL=BlockProvable.js.map

package/dist/prover/block/BlockProvable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProvable.js","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,YAAY,EACZ,KAAK,EAEL,SAAS,EACT,MAAM,EACN,IAAI,GACL,MAAM,MAAM,CAAC;AAId,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAKhE,MAAM,OAAO,sBAAuB,SAAQ,MAAM,CAAC;IACjD,gBAAgB,EAAE,KAAK;IACvB,SAAS,EAAE,KAAK;IAChB,gBAAgB,EAAE,KAAK;IACvB,aAAa,EAAE,KAAK;IACpB,uBAAuB,EAAE,KAAK;IAC9B,oBAAoB,EAAE,KAAK;IAC3B,WAAW,EAAE,KAAK;CACnB,CAAC;CAAG;AAEL,MAAM,OAAO,uBAAwB,SAAQ,MAAM,CAAC;IAClD,gBAAgB,EAAE,KAAK;IACvB,SAAS,EAAE,KAAK;IAChB,gBAAgB,EAAE,KAAK;IACvB,aAAa,EAAE,KAAK;IACpB,uBAAuB,EAAE,KAAK;IAC9B,oBAAoB,EAAE,KAAK;IAC3B,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,KAAK;CACnB,CAAC;IACO,MAAM,CAAC,KAA6B,EAAE,MAAY;QACvD,MAAM,OAAO,GAAG,uBAAuB,CAAC,QAAQ,CAAC;YAC/C,GAAG,KAAK;YACR,MAAM;SACP,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,uBAAuB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvD,OAAO,OAAO;aACX,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;aACrD,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;CACF;AAOD,MAAM,OAAO,wBAAyB,SAAQ,MAAM,CAAC;IACnD,WAAW,EAAE,kBAAkB;IAC/B,SAAS,EAAE,SAAS;IACpB,YAAY,EAAE,YAAY;CAC3B,CAAC;CAAG;AAEL,MAAM,OAAO,mBAAoB,SAAQ,YAGxC;;AACQ,mCAAe,GAAG,IAAI,CAAC;AAEvB,oCAAgB,GAAG,kBAAkB,CAAC;AAE7C,0CAA0C;AACnC,qCAAiB,GAAG,CAAU,CAAC"}

package/dist/prover/block/BlockProver.d.ts

@@ -0,0 +1,94 @@
+import { DynamicProof, Field, Proof, VerificationKey } from "o1js";
+import { AreProofsEnabled, CompilableModule, CompileArtifact, CompileRegistry, PlainZkProgram, WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { StateTransitionProof, StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../statetransition/StateTransitionProvable";
+import { ProvableTransactionHook } from "../../protocol/ProvableTransactionHook";
+import { ProvableBlockHook } from "../../protocol/ProvableBlockHook";
+import { NetworkState } from "../../model/network/NetworkState";
+import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput, DynamicRuntimeProof } from "./BlockProvable";
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
+import { MinimalVKTreeService, RuntimeVerificationKeyAttestation } from "./accummulators/RuntimeVerificationKeyTree";
+import { RuntimeVerificationKeyRootService } from "./services/RuntimeVerificationKeyRootService";
+export interface BlockProverState {
+    /**
+     * The current state root of the block prover
+     */
+    stateRoot: Field;
+    /**
+     * The current commitment of the transaction-list which
+     * will at the end equal the bundle hash
+     */
+    transactionsHash: Field;
+    /**
+     * The network state which gives access to values such as blockHeight
+     * This value is the same for the whole batch (L2 block)
+     */
+    networkStateHash: Field;
+    /**
+     * The root of the merkle tree encoding all block hashes,
+     * see `BlockHashMerkleTree`
+     */
+    blockHashRoot: Field;
+    /**
+     * A variant of the transactionsHash that is never reset.
+     * Thought for usage in the sequence state mempool.
+     * In comparison, transactionsHash restarts at 0 for every new block
+     */
+    eternalTransactionsHash: Field;
+    incomingMessagesHash: Field;
+}
+export type BlockProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
+export type RuntimeProof = Proof<void, MethodPublicOutput>;
+export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+    private readonly prover;
+    readonly stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
+    readonly runtime: ZkProgrammable<undefined, MethodPublicOutput>;
+    private readonly transactionHooks;
+    private readonly blockHooks;
+    private readonly verificationKeyService;
+    constructor(prover: BlockProver, stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: ZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook<unknown>[], blockHooks: ProvableBlockHook<unknown>[], verificationKeyService: MinimalVKTreeService);
+    name: string;
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param runtimeProof
+     * @param executionData
+     * @param verificationKey
+     * @returns The new BlockProver-state to be used as public output
+     */
+    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtimeProof: DynamicRuntimeProof, executionData: BlockProverExecutionData, verificationKey: VerificationKey): Promise<BlockProverState>;
+    assertProtocolTransitions(stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, executionData: BlockProverExecutionData, runtimeProof: DynamicProof<void, MethodPublicOutput>): Promise<void>;
+    private executeBlockHooks;
+    private addTransactionToBundle;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, runtimeProof: DynamicRuntimeProof, executionData: BlockProverExecutionData, verificationKeyWitness: RuntimeVerificationKeyAttestation): Promise<BlockProverPublicOutput>;
+    private assertSTProofInput;
+    proveBlock(publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, transactionProof: BlockProverProof): Promise<BlockProverPublicOutput>;
+    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): Promise<BlockProverPublicOutput>;
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * injected StateTransitionProver and the required AppChainProof class
+     */
+    zkProgramFactory(): PlainZkProgram<BlockProverPublicInput, BlockProverPublicOutput>[];
+}
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export declare class BlockProver extends ProtocolModule implements BlockProvable, CompilableModule {
+    readonly stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> & StateTransitionProvable;
+    readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput> & CompilableModule;
+    zkProgrammable: BlockProverProgrammable;
+    constructor(stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> & StateTransitionProvable, runtime: WithZkProgrammable<undefined, MethodPublicOutput> & CompilableModule, transactionHooks: ProvableTransactionHook<unknown>[], blockHooks: ProvableBlockHook<unknown>[], verificationKeyService: RuntimeVerificationKeyRootService);
+    compile(registry: CompileRegistry): Promise<Record<string, CompileArtifact> | undefined>;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: DynamicRuntimeProof, executionData: BlockProverExecutionData, verificationKeyAttestation: RuntimeVerificationKeyAttestation): Promise<BlockProverPublicOutput>;
+    proveBlock(publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, transactionProof: BlockProverProof): Promise<BlockProverPublicOutput>;
+    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): Promise<BlockProverPublicOutput>;
+}
+//# sourceMappingURL=BlockProver.d.ts.map

package/dist/prover/block/BlockProver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"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"}