@proto-kit/protocol 0.1.1-develop.165 → 0.1.1-develop.1665

package/dist/prover/block/BlockProver.js

@@ -10,96 +10,428 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-/* eslint-disable max-lines */
-import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
-import { inject, injectable } from "tsyringe";
-import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
-import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { Bool, Field, Provable, SelfProof, ZkProgram, } from "o1js";
+import { container, inject, injectable, injectAll } from "tsyringe";
+import { log, MAX_FIELD, provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
-import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
+import { ProvableStateTransition, } from "../../model/StateTransition";
+import { toProvableHookBlockState, } from "../../protocol/ProvableTransactionHook";
+import { RuntimeMethodExecutionContext, } from "../../state/context/RuntimeMethodExecutionContext";
+import { toAfterTransactionHookArgument, toBeforeTransactionHookArgument, } from "../../protocol/ProvableBlockHook";
+import { NetworkState } from "../../model/network/NetworkState";
+import { SignedTransaction } from "../../model/transaction/SignedTransaction";
+import { MinaActions } from "../../utils/MinaPrefixedProvableHashList";
+import { StateTransitionReductionList } from "../accumulators/StateTransitionReductionList";
+import { assertEqualsIf } from "../../utils/utils";
+import { WitnessedRootWitness } from "../accumulators/WitnessedRootHashList";
+import { StateServiceProvider } from "../../state/StateServiceProvider";
+import { AppliedStateTransitionBatch } from "../../model/AppliedStateTransitionBatch";
+import { BlockProverPublicInput, BlockProverPublicOutput, DynamicRuntimeProof, BlockProverMultiTransactionExecutionData, BlockProverSingleTransactionExecutionData, BlockProverStateCommitments, } from "./BlockProvable";
+import { BlockHashMerkleTreeWitness, BlockHashTreeEntry, } from "./accummulators/BlockHashMerkleTree";
+import { MethodVKConfigData, } from "./accummulators/RuntimeVerificationKeyTree";
+import { RuntimeVerificationKeyRootService } from "./services/RuntimeVerificationKeyRootService";
 const errors = {
-    stateProofNotStartingAtZero: () => "StateProof not starting ST-commitment at zero",
-    stateTransitionsHashNotEqual: () => "StateTransition list commitments are not equal",
+    propertyNotMatchingStep: (propertyName, step) => `${propertyName} not matching: ${step}`,
     propertyNotMatching: (propertyName) => `${propertyName} not matching`,
-    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
-    transactionsHashNotMatching: (step) => `transactions hash not matching ${step}`,
+    stateRootNotMatching: (step) => errors.propertyNotMatchingStep("StateRoots", step),
+    transactionsHashNotMatching: (step) => errors.propertyNotMatchingStep("Transactions hash", step),
+    networkStateHashNotMatching: (step) => errors.propertyNotMatchingStep("Network state hash", step),
+    invalidZkProgramTreeRoot: () => "Root hash of the provided zkProgram config witness is invalid",
 };
-/**
- * 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
- */
-let BlockProver = class BlockProver extends ProtocolModule {
-    constructor(stateTransitionProver, runtime) {
+export class BlockProverProgrammable extends ZkProgrammable {
+    constructor(prover, stateTransitionProver, transactionHooks, blockHooks, stateServiceProvider, verificationKeyService) {
         super();
+        this.prover = prover;
         this.stateTransitionProver = stateTransitionProver;
-        this.runtime = runtime;
+        this.transactionHooks = transactionHooks;
+        this.blockHooks = blockHooks;
+        this.stateServiceProvider = stateServiceProvider;
+        this.verificationKeyService = verificationKeyService;
+        this.name = "BlockProver";
+    }
+    get areProofsEnabled() {
+        return this.prover.areProofsEnabled;
     }
     /**
      * Applies and checks the two proofs and applies the corresponding state
-     * changes to the given state
+     * changes to the given state.
+     *
+     * The rough high level workflow of this function:
+     * 1. Execute beforeTransaction hooks, pushing the ST batch
+     * 2. Add Transaction to bundle, meaning appending it to all the respective commitments
+     * 3. Push the runtime ST batch
+     * 4. Execute afterTransaction hooks, pushing the ST batch
+     * 5. Some consistency checks and signature verification
      *
-     * @param state The from-state of the BlockProver
-     * @param stateTransitionProof
-     * @param appProof
+     * @param fromState The from-state of the BlockProver
+     * @param runtimeOutput
+     * @param executionData
+     * @param networkState
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state, stateTransitionProof, appProof, { transaction, networkState }) {
-        appProof.verify();
-        stateTransitionProof.verify();
-        const stateTo = { ...state };
-        // eslint-disable-next-line no-warning-comments
-        // TODO Check methodId?
-        // Checks for the stateTransitionProof and appProof matching
-        stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        appProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
-        // Apply state if status success
-        state.stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
-        stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicInput.stateRoot);
+    async applyTransaction(fromState, runtimeOutput, executionData, networkState) {
+        const { transaction, signature } = executionData;
+        let state = { ...fromState };
+        const { isMessage } = runtimeOutput;
+        const beforeTxHookArguments = toBeforeTransactionHookArgument(executionData, networkState, state);
+        // Apply beforeTransaction hook state transitions
+        const beforeBatch = await this.executeTransactionHooks(async (module, args) => await module.beforeTransaction(args), beforeTxHookArguments);
+        state = this.addTransactionToBundle(state, runtimeOutput.isMessage, transaction);
+        state.pendingSTBatches.push(beforeBatch);
+        state.pendingSTBatches.push({
+            batchHash: runtimeOutput.stateTransitionsHash,
+            applied: runtimeOutput.status,
+        });
+        // Apply afterTransaction hook state transitions
+        const afterTxHookArguments = toAfterTransactionHookArgument(executionData, networkState, state, runtimeOutput);
+        // Switch to different state set for afterTx hooks
+        this.stateServiceProvider.popCurrentStateService();
+        const afterBatch = await this.executeTransactionHooks(async (module, args) => await module.afterTransaction(args), afterTxHookArguments);
+        state.pendingSTBatches.push(afterBatch);
+        // Check transaction integrity against appProof
+        const blockTransactionHash = transaction.hash();
+        blockTransactionHash.assertEquals(runtimeOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
         // Check transaction signature
-        transaction
+        new SignedTransaction({
+            transaction,
+            signature,
+        })
             .validateSignature()
+            .or(isMessage)
             .assertTrue("Transaction signature not valid");
-        // Check if the methodId is correct
-        // to do
-        // Check transaction integrity against appProof
-        const blockTransactionHash = RuntimeTransaction.fromProtocolTransaction(transaction).hash();
-        blockTransactionHash.assertEquals(appProof.publicOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
+        // Validate layout of transaction witness
+        transaction.assertTransactionType(isMessage);
         // Check network state integrity against appProof
-        state.networkStateHash.assertEquals(appProof.publicOutput.networkStateHash, "Network state does not match state used in AppProof");
-        state.networkStateHash.assertEquals(networkState.hash(), "Network state provided to BlockProver does not match the publicInput");
+        state.networkState
+            .hash()
+            .assertEquals(runtimeOutput.networkStateHash, "Network state does not match state used in AppProof");
+        return state;
+    }
+    // eslint-disable-next-line max-len
+    // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
+    /**
+     * Constructs a AppliedBatch based on a list of STs and the flag whether to
+     * be applied or not. The AppliedBatch is a condensed commitment to a batch
+     * of STs.
+     */
+    constructBatch(stateTransitions, applied) {
+        const transitions = stateTransitions.map((transition) => transition.toProvable());
+        const hashList = new StateTransitionReductionList(ProvableStateTransition);
+        transitions.forEach((transition) => {
+            hashList.push(transition);
+        });
+        return new AppliedStateTransitionBatch({
+            batchHash: hashList.commitment,
+            applied,
+        });
+    }
+    async executeTransactionHooks(hook, hookArguments) {
+        const { batch } = await this.executeHooks(hookArguments, async () => {
+            for (const module of this.transactionHooks) {
+                // eslint-disable-next-line no-await-in-loop
+                await hook(module, hookArguments);
+            }
+        });
+        return batch;
+    }
+    async executeHooks(contextArguments, method) {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        executionContext.clear();
+        // Setup context for potential calls to runtime methods.
+        // This way they can use this.transaction etc. while still having provable
+        // integrity between data
+        executionContext.setup(contextArguments);
+        executionContext.beforeMethod("", "", []);
+        const result = await method();
+        executionContext.afterMethod();
+        const { stateTransitions, status, statusMessage } = executionContext.current().result;
+        status.assertTrue(`Transaction hook call failed: ${statusMessage ?? "-"}`);
+        return {
+            batch: this.constructBatch(stateTransitions, Bool(true)),
+            result,
+        };
+    }
+    async executeBlockHooks(hook, hookArguments, inputNetworkState) {
+        const transaction = RuntimeTransaction.dummyTransaction();
+        const startingInputs = {
+            transaction,
+            networkState: inputNetworkState,
+        };
+        return await this.executeHooks(startingInputs, async () => {
+            const executionContext = container.resolve(RuntimeMethodExecutionContext);
+            return await this.blockHooks.reduce(async (networkStatePromise, blockHook) => {
+                const networkState = await networkStatePromise;
+                // Setup context for potential calls to runtime methods.
+                // With the special case that we set the new networkstate for every hook
+                // We also have to put in a dummy transaction for network.transaction
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState,
+                });
+                return await hook(blockHook, networkState, hookArguments);
+            }, Promise.resolve(inputNetworkState));
+        });
+    }
+    addTransactionToBundle(state, isMessage, transaction) {
+        const transactionHash = transaction.hash();
         // Append tx to transaction list
-        const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
-        const { transactionHash } = appProof.publicOutput;
-        transactionList.push(transactionHash);
-        stateTo.transactionsHash = transactionList.commitment;
-        return stateTo;
-    }
-    proveTransaction(publicInput, stateProof, appProof, executionData) {
-        const state = {
-            transactionsHash: publicInput.transactionsHash,
-            stateRoot: publicInput.stateRoot,
-            networkStateHash: publicInput.networkStateHash,
+        state.transactionList.pushIf(transactionHash, isMessage.not());
+        // Append tx to eternal transaction list
+        // TODO Change that to the a sequence-state compatible transaction struct
+        state.eternalTransactionsList.push(transactionHash);
+        // Append tx to incomingMessagesHash
+        const actionHash = MinaActions.actionHash(transaction.hashData());
+        state.incomingMessages.pushIf(actionHash, isMessage);
+        return state;
+    }
+    verifyVerificationKeyAttestation(attestation, methodId) {
+        // Verify the [methodId, vk] tuple against the baked-in vk tree root
+        const { verificationKey, witness: verificationKeyTreeWitness } = attestation;
+        const root = Field(this.verificationKeyService.getRoot());
+        const calculatedRoot = verificationKeyTreeWitness.calculateRoot(new MethodVKConfigData({
+            methodId: methodId,
+            vkHash: verificationKey.hash,
+        }).hash());
+        root.assertEquals(calculatedRoot, errors.invalidZkProgramTreeRoot());
+        return verificationKey;
+    }
+    async proveTransactionInternal(fromState, runtimeProof, { transaction, networkState }) {
+        const verificationKey = this.verifyVerificationKeyAttestation(transaction.verificationKeyAttestation, transaction.transaction.methodId);
+        runtimeProof.verify(verificationKey);
+        return await this.applyTransaction(fromState, runtimeProof.publicOutput, transaction, networkState);
+    }
+    staticChecks(publicInput) {
+        publicInput.blockNumber.assertEquals(MAX_FIELD, "blockNumber has to be MAX for transaction proofs");
+    }
+    async proveTransaction(publicInput, runtimeProof, executionData) {
+        const state = BlockProverStateCommitments.toBlockProverState(publicInput, executionData.networkState);
+        this.staticChecks(publicInput);
+        const stateTo = await this.proveTransactionInternal(state, runtimeProof, executionData);
+        return new BlockProverPublicOutput({
+            ...BlockProverStateCommitments.fromBlockProverState(stateTo),
+            closed: Bool(false),
+        });
+    }
+    async proveTransactions(publicInput, runtimeProof1, runtimeProof2, executionData) {
+        const state = BlockProverStateCommitments.toBlockProverState(publicInput, executionData.networkState);
+        this.staticChecks(publicInput);
+        const state1 = await this.proveTransactionInternal(state, runtimeProof1, {
+            transaction: executionData.transaction1,
+            networkState: executionData.networkState,
+        });
+        // Switch to next state record for 2nd tx beforeTx hook
+        // TODO Can be prevented by merging 1st afterTx + 2nd beforeTx
+        this.stateServiceProvider.popCurrentStateService();
+        const stateTo = await this.proveTransactionInternal(state1, runtimeProof2, {
+            transaction: executionData.transaction2,
+            networkState: executionData.networkState,
+        });
+        return new BlockProverPublicOutput({
+            ...BlockProverStateCommitments.fromBlockProverState(stateTo),
+            closed: Bool(false),
+        });
+    }
+    includeSTProof(stateTransitionProof, apply, stateRoot, pendingSTBatchesHash, witnessedRootsHash) {
+        assertEqualsIf(stateTransitionProof.publicInput.currentBatchStateHash, Field(0), apply, "State for STProof has to be empty at the start");
+        assertEqualsIf(stateTransitionProof.publicOutput.currentBatchStateHash, Field(0), apply, "State for STProof has to be empty at the end");
+        assertEqualsIf(stateTransitionProof.publicInput.batchesHash, Field(0), apply, "Batcheshash doesn't start at 0");
+        // Assert from state root
+        assertEqualsIf(stateRoot, stateTransitionProof.publicInput.root, apply, errors.propertyNotMatching("from state root"));
+        // Assert the stBatchesHash executed is the same
+        assertEqualsIf(pendingSTBatchesHash, stateTransitionProof.publicOutput.batchesHash, apply, "Pending STBatches are not the same that have been executed by the ST proof");
+        // Assert root Accumulator
+        assertEqualsIf(Field(0), stateTransitionProof.publicInput.witnessedRootsHash, apply, errors.propertyNotMatching("from state root"));
+        // Assert the witnessedRootsHash created is the same
+        assertEqualsIf(witnessedRootsHash, stateTransitionProof.publicOutput.witnessedRootsHash, apply, "Root accumulator Commitment is not the same that have been executed by the ST proof");
+        // update root only if we didn't defer
+        const newRoot = Provable.if(apply, stateTransitionProof.publicOutput.root, stateRoot);
+        // Reset only if we didn't defer
+        const newBatchesHash = Provable.if(apply, Field(0), pendingSTBatchesHash);
+        const newWitnessedRootsHash = Provable.if(apply, Field(0), witnessedRootsHash);
+        return {
+            stateRoot: newRoot,
+            pendingSTBatchesHash: newBatchesHash,
+            witnessedRootsHash: newWitnessedRootsHash,
         };
-        const stateTo = this.applyTransaction(state, stateProof, appProof, executionData);
+    }
+    async proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, deferSTProof, afterBlockRootWitness, transactionProof) {
+        // 1. Make assertions about the inputs
+        publicInput.transactionsHash.assertEquals(Field(0), "Transactionshash has to start at 0");
+        // TransactionProof format checks
+        transactionProof.publicInput.blockHashRoot.assertEquals(Field(0), "TransactionProof cannot carry the blockHashRoot - publicInput");
+        transactionProof.publicOutput.blockHashRoot.assertEquals(Field(0), "TransactionProof cannot carry the blockHashRoot - publicOutput");
+        transactionProof.publicInput.networkStateHash.assertEquals(transactionProof.publicOutput.networkStateHash, "TransactionProof cannot alter the network state");
+        const state = BlockProverStateCommitments.toBlockProverState(publicInput, networkState);
+        // Verify Transaction proof if it has at least 1 tx - i.e. the
+        // input and output doesn't match fully
+        // We have to compare the whole input and output because we can make no
+        // assumptions about the values, since it can be an arbitrary dummy-proof
+        const txProofOutput = transactionProof.publicOutput;
+        const isEmptyTransition = txProofOutput.equals(transactionProof.publicInput, txProofOutput.closed);
+        const skipTransactionProofVerification = isEmptyTransition;
+        const verifyTransactionProof = isEmptyTransition.not();
+        log.provable.debug("VerifyIf TxProof", verifyTransactionProof);
+        transactionProof.verifyIf(verifyTransactionProof);
+        // 2. Execute beforeBlock hooks
+        const beforeBlockArgs = toProvableHookBlockState(state);
+        const beforeBlockResult = await this.executeBlockHooks(async (module, networkStateArg, args) => await module.beforeBlock(networkStateArg, args), beforeBlockArgs, networkState);
+        state.pendingSTBatches.push(beforeBlockResult.batch);
+        // 4. Apply TX-type BlockProof
+        transactionProof.publicInput.networkStateHash
+            .equals(beforeBlockResult.result.hash())
+            .or(skipTransactionProofVerification)
+            .assertTrue("TransactionProof networkstate hash not matching beforeBlock hook result");
+        transactionProof.publicInput.stateRoot.assertEquals(transactionProof.publicOutput.stateRoot, "TransactionProofs can't change the state root");
+        // Check that the transaction proof's STs start after the beforeBlock hook
+        transactionProof.publicInput.pendingSTBatchesHash.assertEquals(state.pendingSTBatches.commitment, "Transaction proof doesn't start their STs after the beforeBlockHook");
+        // Fast-forward the stBatchHashList to after all transactions appended
+        state.pendingSTBatches.commitment =
+            transactionProof.publicOutput.pendingSTBatchesHash;
+        // Fast-forward block content commitments by the results of the aggregated transaction proof
+        // Implicitly, the 'from' values here are asserted against the publicInput, since the hashlists
+        // are created out of the public input
+        state.transactionList.fastForward({
+            from: transactionProof.publicInput.transactionsHash,
+            to: transactionProof.publicOutput.transactionsHash,
+        });
+        state.eternalTransactionsList.fastForward({
+            from: transactionProof.publicInput.eternalTransactionsHash,
+            to: transactionProof.publicOutput.eternalTransactionsHash,
+        });
+        state.incomingMessages.fastForward({
+            from: transactionProof.publicInput.incomingMessagesHash,
+            to: transactionProof.publicOutput.incomingMessagesHash,
+        });
+        // Witness root
+        const isEmpty = state.pendingSTBatches.commitment.equals(0);
+        isEmpty
+            .implies(state.stateRoot.equals(afterBlockRootWitness.witnessedRoot))
+            .assertTrue();
+        state.witnessedRoots.witnessRoot({
+            appliedBatchListState: state.pendingSTBatches.commitment,
+            root: afterBlockRootWitness.witnessedRoot,
+        }, afterBlockRootWitness.preimage, isEmpty.not());
+        // 5. Calculate the new block tree hash
+        const blockIndex = blockWitness.calculateIndex();
+        blockIndex.assertEquals(publicInput.blockNumber);
+        blockWitness
+            .calculateRoot(Field(0))
+            .assertEquals(publicInput.blockHashRoot, "Supplied block hash witness not matching state root");
+        state.blockHashRoot = blockWitness.calculateRoot(new BlockHashTreeEntry({
+            block: {
+                index: blockIndex,
+                transactionListHash: state.transactionList.commitment,
+            },
+            closed: Bool(true),
+        }).hash());
+        // 6. Execute afterBlock hooks
+        // Switch state service to afterBlock one
+        this.stateServiceProvider.popCurrentStateService();
+        const afterBlockHookArgs = toProvableHookBlockState(state);
+        const afterBlockResult = await this.executeBlockHooks(async (module, networkStateArg, args) => await module.afterBlock(networkStateArg, args), {
+            ...afterBlockHookArgs,
+            stateRoot: afterBlockRootWitness.witnessedRoot,
+        }, beforeBlockResult.result);
+        state.pendingSTBatches.push(afterBlockResult.batch);
+        state.networkState = afterBlockResult.result;
+        // 7. Close block
+        // Verify ST Proof only if STs have been emitted,
+        // and we don't defer the verification of the STs
+        // otherwise we can input a dummy proof
+        const batchesEmpty = state.pendingSTBatches.commitment.equals(Field(0));
+        const verifyStProof = deferSTProof.not().and(batchesEmpty.not());
+        log.provable.debug("Verify STProof", verifyStProof);
+        stateTransitionProof.verifyIf(verifyStProof);
+        // Apply STProof if not deferred
+        const stateProofResult = this.includeSTProof(stateTransitionProof, verifyStProof, state.stateRoot, state.pendingSTBatches.commitment, state.witnessedRoots.commitment);
+        state.stateRoot = stateProofResult.stateRoot;
+        state.pendingSTBatches.commitment = stateProofResult.pendingSTBatchesHash;
+        state.witnessedRoots.commitment = stateProofResult.witnessedRootsHash;
+        state.blockNumber = blockIndex.add(1);
         return new BlockProverPublicOutput({
-            stateRoot: stateTo.stateRoot,
-            transactionsHash: stateTo.transactionsHash,
+            ...BlockProverStateCommitments.fromBlockProverState(state),
+            closed: Bool(true),
         });
     }
-    merge(publicInput, proof1, proof2) {
+    async merge(publicInput, proof1, proof2) {
         proof1.verify();
         proof2.verify();
         // Check state
         publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
         proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
-        // Check transaction list
-        publicInput.transactionsHash.assertEquals(proof1.publicInput.transactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.transactionsHash.assertEquals(proof2.publicInput.transactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check transaction list hash.
+        // Only assert them if these are tx proofs, skip for closed proofs
+        publicInput.transactionsHash
+            .equals(proof1.publicInput.transactionsHash)
+            .or(proof1.publicOutput.closed)
+            .assertTrue(errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.transactionsHash
+            .equals(proof2.publicInput.transactionsHash)
+            .or(proof1.publicOutput.closed)
+            .assertTrue(errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check networkhash
+        publicInput.networkStateHash.assertEquals(proof1.publicInput.networkStateHash, errors.networkStateHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.networkStateHash.assertEquals(proof2.publicInput.networkStateHash, errors.networkStateHashNotMatching("proof1.to -> proof2.from"));
+        // Check blockHashRoot
+        publicInput.blockHashRoot.assertEquals(proof1.publicInput.blockHashRoot, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.blockHashRoot.assertEquals(proof2.publicInput.blockHashRoot, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check eternalTransactionsHash
+        publicInput.eternalTransactionsHash.assertEquals(proof1.publicInput.eternalTransactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.eternalTransactionsHash.assertEquals(proof2.publicInput.eternalTransactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check incomingMessagesHash
+        publicInput.incomingMessagesHash.assertEquals(proof1.publicInput.incomingMessagesHash, errors.propertyNotMatchingStep("IncomingMessagesHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.incomingMessagesHash.assertEquals(proof2.publicInput.incomingMessagesHash, errors.propertyNotMatchingStep("IncomingMessagesHash", "proof1.to -> proof2.from"));
+        // Check pendingSTBatchesHash
+        publicInput.pendingSTBatchesHash.assertEquals(proof1.publicInput.pendingSTBatchesHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.pendingSTBatchesHash.assertEquals(proof2.publicInput.pendingSTBatchesHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check witnessedRootsHash
+        publicInput.witnessedRootsHash.assertEquals(proof1.publicInput.witnessedRootsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.witnessedRootsHash.assertEquals(proof2.publicInput.witnessedRootsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Assert closed indicator matches
+        // (i.e. we can only merge TX-Type and Block-Type with each other)
+        proof1.publicOutput.closed.assertEquals(proof2.publicOutput.closed, "Closed indicators not matching");
+        // Either
+        // blockNumbers are unset and proofs are unclosed or
+        // both blocks are closed, then they have to increment or
+        // one block is closed, then height has to be the same
+        // Imperative algo would look like
+        // if(proof1.height == MAX && proof2.height == MAX){
+        //   assert !proof1.closed && !proof2.closed;
+        // }else if(proof1.closed && proof2.closed){
+        //   assert proof1.height + 1 == proof2.height
+        // // next one is omitted for now
+        // }else if(proof1.closed || proof2.closed{
+        //   assert proof1.height == proof2.height
+        // }
+        const proof1Closed = proof1.publicOutput.closed;
+        const proof2Closed = proof2.publicOutput.closed;
+        const blockNumberProgressionValid = publicInput.blockNumber
+            .equals(proof1.publicInput.blockNumber)
+            .and(proof1.publicOutput.blockNumber.equals(proof2.publicInput.blockNumber));
+        // For tx proofs, we check that the progression starts and end with MAX
+        // in addition to that both proofs are non-closed
+        const isValidTransactionMerge = publicInput.blockNumber
+            .equals(MAX_FIELD)
+            .and(blockNumberProgressionValid)
+            .and(proof1Closed.or(proof2Closed).not());
+        const isValidClosedMerge = proof1Closed
+            .and(proof2Closed)
+            .and(blockNumberProgressionValid);
+        isValidTransactionMerge
+            .or(isValidClosedMerge)
+            .assertTrue("Invalid BlockProof merge");
         return new BlockProverPublicOutput({
             stateRoot: proof2.publicOutput.stateRoot,
             transactionsHash: proof2.publicOutput.transactionsHash,
+            networkStateHash: proof2.publicOutput.networkStateHash,
+            blockHashRoot: proof2.publicOutput.blockHashRoot,
+            eternalTransactionsHash: proof2.publicOutput.eternalTransactionsHash,
+            incomingMessagesHash: proof2.publicOutput.incomingMessagesHash,
+            closed: isValidClosedMerge,
+            blockNumber: proof2.publicOutput.blockNumber,
+            pendingSTBatchesHash: proof2.publicOutput.pendingSTBatchesHash,
+            witnessedRootsHash: proof2.publicOutput.witnessedRootsHash,
         });
     }
     /**
@@ -108,22 +440,47 @@ let BlockProver = class BlockProver extends ProtocolModule {
      * injected StateTransitionProver and the required AppChainProof class
      */
     zkProgramFactory() {
-        const StateTransitionProofClass = this.stateTransitionProver.zkProgram.Proof;
-        const RuntimeProofClass = this.runtime.zkProgrammable.zkProgram.Proof;
-        const proveTransaction = this.proveTransaction.bind(this);
-        const merge = this.merge.bind(this);
-        const program = Experimental.ZkProgram({
+        const { prover, stateTransitionProver } = this;
+        const StateTransitionProofClass = stateTransitionProver.zkProgram[0].Proof;
+        const proveTransaction = prover.proveTransaction.bind(prover);
+        const proveTransactions = prover.proveTransactions.bind(prover);
+        const proveBlock = prover.proveBlock.bind(prover);
+        const merge = prover.merge.bind(prover);
+        const program = ZkProgram({
+            name: "BlockProver",
             publicInput: BlockProverPublicInput,
             publicOutput: BlockProverPublicOutput,
             methods: {
                 proveTransaction: {
                     privateInputs: [
+                        DynamicRuntimeProof,
+                        BlockProverSingleTransactionExecutionData,
+                    ],
+                    async method(publicInput, runtimeProof, executionData) {
+                        return await proveTransaction(publicInput, runtimeProof, executionData);
+                    },
+                },
+                proveTransactions: {
+                    privateInputs: [
+                        DynamicRuntimeProof,
+                        DynamicRuntimeProof,
+                        BlockProverMultiTransactionExecutionData,
+                    ],
+                    async method(publicInput, runtimeProof1, runtimeProof2, executionData) {
+                        return await proveTransactions(publicInput, runtimeProof1, runtimeProof2, executionData);
+                    },
+                },
+                proveBlock: {
+                    privateInputs: [
+                        NetworkState,
+                        BlockHashMerkleTreeWitness,
                         StateTransitionProofClass,
-                        RuntimeProofClass,
-                        BlockProverExecutionData,
+                        Bool,
+                        WitnessedRootWitness,
+                        (SelfProof),
                     ],
-                    method(publicInput, stateProof, appProof, executionData) {
-                        return proveTransaction(publicInput, stateProof, appProof, executionData);
+                    async method(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof) {
+                        return await proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof);
                     },
                 },
                 merge: {
@@ -131,41 +488,103 @@ let BlockProver = class BlockProver extends ProtocolModule {
                         (SelfProof),
                         (SelfProof),
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return await merge(publicInput, proof1, proof2);
                     },
                 },
             },
         });
         const methods = {
             proveTransaction: program.proveTransaction,
+            proveTransactions: program.proveTransactions,
+            proveBlock: program.proveBlock,
             merge: program.merge,
         };
-        const SelfProofClass = Experimental.ZkProgram.Proof(program);
-        return {
-            compile: program.compile.bind(program),
-            verify: program.verify.bind(program),
-            Proof: SelfProofClass,
-            methods,
-        };
+        const SelfProofClass = ZkProgram.Proof(program);
+        return [
+            {
+                name: program.name,
+                compile: program.compile.bind(program),
+                verify: program.verify.bind(program),
+                analyzeMethods: program.analyzeMethods.bind(program),
+                Proof: SelfProofClass,
+                methods,
+            },
+        ];
     }
-};
+}
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        DynamicRuntimeProof,
+        BlockProverSingleTransactionExecutionData]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveTransaction", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Function, BlockProverExecutionData]),
-    __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "proveTransaction", null);
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        DynamicRuntimeProof,
+        DynamicRuntimeProof,
+        BlockProverMultiTransactionExecutionData]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveTransactions", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        NetworkState,
+        BlockHashMerkleTreeWitness, Object, Bool,
+        WitnessedRootWitness, Object]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveBlock", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
-    __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "merge", null);
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "merge", null);
+/**
+ * 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 let BlockProver = class BlockProver extends ProtocolModule {
+    constructor(stateTransitionProver, runtime, transactionHooks, blockHooks, stateServiceProvider, verificationKeyService) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.runtime = runtime;
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, transactionHooks, blockHooks, stateServiceProvider, verificationKeyService);
+    }
+    async compile(registry) {
+        return await registry.forceProverExists(async () => {
+            await this.stateTransitionProver.compile(registry);
+            await this.runtime.compile(registry);
+            return await this.zkProgrammable.compile(registry);
+        });
+    }
+    proveTransaction(publicInput, runtimeProof, executionData) {
+        return this.zkProgrammable.proveTransaction(publicInput, runtimeProof, executionData);
+    }
+    proveTransactions(publicInput, runtimeProof1, runtimeProof2, executionData) {
+        return this.zkProgrammable.proveTransactions(publicInput, runtimeProof1, runtimeProof2, executionData);
+    }
+    proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof) {
+        return this.zkProgrammable.proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+};
 BlockProver = __decorate([
     injectable(),
     __param(0, inject("StateTransitionProver")),
     __param(1, inject("Runtime")),
-    __metadata("design:paramtypes", [ZkProgrammable, Object])
+    __param(2, injectAll("ProvableTransactionHook")),
+    __param(3, injectAll("ProvableBlockHook")),
+    __param(4, inject("StateServiceProvider")),
+    __metadata("design:paramtypes", [Object, Object, Array, Array, StateServiceProvider,
+        RuntimeVerificationKeyRootService])
 ], BlockProver);
-export { BlockProver };
+//# sourceMappingURL=BlockProver.js.map