@proto-kit/protocol 0.1.1-develop.1315 → 0.1.1-develop.1343

package/dist/prover/block/BlockProver.js

@@ -10,41 +10,43 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Bool, Field, Poseidon, Provable, SelfProof, ZkProgram, } from "o1js";
+import { Bool, Field, Provable, SelfProof, ZkProgram, } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
-import { MAX_FIELD, provableMethod, ZkProgrammable, } from "@proto-kit/common";
-import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { log, MAX_FIELD, provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { ProvableStateTransition, } from "../../model/StateTransition";
-import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
+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, MinaActionsHashList, } from "../../utils/MinaPrefixedProvableHashList";
-import { StateTransitionReductionList } from "../../utils/StateTransitionReductionList";
-import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, DynamicRuntimeProof, } from "./BlockProvable";
+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, RuntimeVerificationKeyAttestation, } from "./accummulators/RuntimeVerificationKeyTree";
+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) => 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",
-    invalidZkProgramConfigMethodId: () => "Method id of the provided zkProgram config does not match the executed transaction method id",
 };
 export class BlockProverProgrammable extends ZkProgrammable {
-    constructor(prover, stateTransitionProver, runtime, transactionHooks, blockHooks, verificationKeyService) {
+    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";
     }
@@ -53,35 +55,43 @@ export class BlockProverProgrammable extends ZkProgrammable {
     }
     /**
      * 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 runtimeProof
+     * @param fromState The from-state of the BlockProver
+     * @param runtimeOutput
      * @param executionData
-     * @param verificationKey
+     * @param networkState
      * @returns The new BlockProver-state to be used as public output
      */
-    async applyTransaction(state, stateTransitionProof, runtimeProof, executionData, verificationKey) {
-        const { transaction, networkState, signature } = executionData;
-        const { isMessage } = runtimeProof.publicOutput;
-        runtimeProof.verify(verificationKey);
-        stateTransitionProof.verify();
-        const stateTo = { ...state };
-        // Checks for the stateTransitionProof and appProof matching
-        stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        stateTransitionProof.publicInput.protocolTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        runtimeProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
-        // Assert from state roots
-        state.stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
-        state.stateRoot.assertEquals(stateTransitionProof.publicInput.protocolStateRoot, errors.propertyNotMatching("from protocol state root"));
-        // Apply protocol state transitions
-        await this.assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof);
-        // Apply state if status success
-        stateTo.stateRoot = Provable.if(runtimeProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicOutput.protocolStateRoot);
+    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(runtimeProof.publicOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
+        blockTransactionHash.assertEquals(runtimeOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
         // Check transaction signature
         new SignedTransaction({
             transaction,
@@ -93,211 +103,254 @@ export class BlockProverProgrammable extends ZkProgrammable {
         // Validate layout of transaction witness
         transaction.assertTransactionType(isMessage);
         // Check network state integrity against appProof
-        state.networkStateHash.assertEquals(runtimeProof.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");
-        return stateTo;
+        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?
-    async assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof) {
-        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({
-            // That is why we should probably hide it from the transaction context inputs
-            transaction: executionData.transaction,
-            networkState: executionData.networkState,
-        });
-        executionContext.beforeMethod("", "", []);
-        for (const module of this.transactionHooks) {
-            // eslint-disable-next-line no-await-in-loop
-            await module.onTransaction(executionData);
-        }
-        executionContext.afterMethod();
-        const { stateTransitions, status, statusMessage } = executionContext.current().result;
-        status.assertTrue(statusMessage);
+    /**
+     * 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, stateTransitionProof.publicInput.protocolTransitionsHash);
+        const hashList = new StateTransitionReductionList(ProvableStateTransition);
         transitions.forEach((transition) => {
             hashList.push(transition);
         });
-        stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(hashList.commitment, "ProtocolTransitionsHash not matching the generated protocol transitions");
+        return new AppliedStateTransitionBatch({
+            batchHash: hashList.commitment,
+            applied,
+        });
     }
-    async executeBlockHooks(state, inputNetworkState, type) {
+    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 resultingNetworkState = 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,
-            });
-            if (type === "beforeBlock") {
-                return await blockHook.beforeBlock(networkState, state);
-            }
-            if (type === "afterBlock") {
-                return await blockHook.afterBlock(networkState, state);
-            }
-            throw new Error("Unreachable");
-        }, Promise.resolve(inputNetworkState));
+        const result = await method();
         executionContext.afterMethod();
         const { stateTransitions, status, statusMessage } = executionContext.current().result;
-        status.assertTrue(`Block hook call failed: ${statusMessage ?? "-"}`);
+        status.assertTrue(`Transaction hook call failed: ${statusMessage ?? "-"}`);
         return {
-            networkState: resultingNetworkState,
-            stateTransitions,
+            batch: this.constructBatch(stateTransitions, Bool(true)),
+            result,
         };
     }
-    addTransactionToBundle(state, isMessage, transaction) {
-        const stateTo = {
-            ...state,
+    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);
-        transactionList.pushIf(transactionHash, isMessage.not());
-        stateTo.transactionsHash = transactionList.commitment;
+        state.transactionList.pushIf(transactionHash, isMessage.not());
         // Append tx to eternal transaction list
         // TODO Change that to the a sequence-state compatible transaction struct
-        const eternalTransactionList = new DefaultProvableHashList(Field, state.eternalTransactionsHash);
-        eternalTransactionList.pushIf(transactionHash, isMessage.not());
-        stateTo.eternalTransactionsHash = eternalTransactionList.commitment;
+        state.eternalTransactionsList.pushIf(transactionHash, isMessage.not());
         // Append tx to incomingMessagesHash
         const actionHash = MinaActions.actionHash(transaction.hashData());
-        const incomingMessagesList = new MinaActionsHashList(state.incomingMessagesHash);
-        incomingMessagesList.pushIf(actionHash, isMessage);
-        stateTo.incomingMessagesHash = incomingMessagesList.commitment;
-        return stateTo;
+        state.incomingMessages.pushIf(actionHash, isMessage);
+        return state;
     }
-    async proveTransaction(publicInput, stateProof, runtimeProof, executionData, verificationKeyWitness) {
-        const state = {
-            ...publicInput,
-        };
-        state.networkStateHash.assertEquals(executionData.networkState.hash(), "ExecutionData Networkstate doesn't equal public input hash");
-        publicInput.blockNumber.assertEquals(MAX_FIELD, "blockNumber has to be MAX for transaction proofs");
+    verifyVerificationKeyAttestation(attestation, methodId) {
         // Verify the [methodId, vk] tuple against the baked-in vk tree root
-        const { verificationKey, witness: verificationKeyTreeWitness } = verificationKeyWitness;
+        const { verificationKey, witness: verificationKeyTreeWitness } = attestation;
         const root = Field(this.verificationKeyService.getRoot());
         const calculatedRoot = verificationKeyTreeWitness.calculateRoot(new MethodVKConfigData({
-            methodId: executionData.transaction.methodId,
+            methodId: methodId,
             vkHash: verificationKey.hash,
         }).hash());
         root.assertEquals(calculatedRoot, errors.invalidZkProgramTreeRoot());
-        const bundleInclusionState = this.addTransactionToBundle(state, runtimeProof.publicOutput.isMessage, executionData.transaction);
-        const stateTo = await this.applyTransaction(bundleInclusionState, stateProof, runtimeProof, executionData, verificationKey);
+        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({
-            ...stateTo,
-            blockNumber: publicInput.blockNumber,
+            ...BlockProverStateCommitments.fromBlockProverState(stateTo),
             closed: Bool(false),
         });
     }
-    assertSTProofInput(stateTransitionProof, stateRoot) {
-        stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        stateTransitionProof.publicInput.protocolTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        // Assert from state roots
-        stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
+    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),
+        });
     }
-    async proveBlock(publicInput, networkState, blockWitness, 
-    // stateTransitionProof: StateTransitionProof,
-    transactionProof) {
-        const state = {
-            ...publicInput,
+    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 roots
+        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,
         };
+    }
+    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");
-        publicInput.networkStateHash.assertEquals(networkState.hash(), "Wrong NetworkState supplied");
-        transactionProof.publicInput.transactionsHash.assertEquals(Field(0), "TransactionProof 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");
-        transactionProof.publicInput.eternalTransactionsHash.assertEquals(state.eternalTransactionsHash, "TransactionProof starting eternalTransactionHash not matching");
-        transactionProof.publicInput.incomingMessagesHash.assertEquals(state.incomingMessagesHash, "TransactionProof starting incomingMessagesHash not matching");
-        // TODO Reintroduce ST Proofs
-        // Verify ST Proof only if STs have been emitted,
-        // otherwise we can input a dummy proof
-        // const stsEmitted = stateTransitionProof.publicOutput.stateTransitionsHash
-        //   .equals(0)
-        //   .and(stateTransitionProof.publicOutput.protocolTransitionsHash.equals(0))
-        //   .not();
-        // Provable.log("VerifyIf 1", stsEmitted);
-        // stateTransitionProof.verifyIf(Bool(false));
-        // stateTransitionProof.verifyIf(stsEmitted);
+        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);
-        Provable.log("VerifyIf 2", isEmptyTransition.not());
-        transactionProof.verifyIf(isEmptyTransition.not());
+        const skipTransactionProofVerification = isEmptyTransition;
+        const verifyTransactionProof = isEmptyTransition.not();
+        log.provable.debug("VerifyIf TxProof", verifyTransactionProof);
+        transactionProof.verifyIf(verifyTransactionProof);
         // 2. Execute beforeBlock hooks
-        const beforeBlockResult = await this.executeBlockHooks(state, networkState, "beforeBlock");
-        // const beforeBlockHashList = new StateTransitionReductionList(
-        //   ProvableStateTransition
-        // );
-        // beforeBlockResult.stateTransitions.forEach((st) => {
-        //   beforeBlockHashList.push(st.toProvable());
-        // });
-        // We are reusing protocolSTs here as beforeBlock STs
-        // TODO Not possible atm bcs we can't have a seperation between protocol/runtime state roots,
-        // which we would for both before and after to be able to emit STs
-        // stateTransitionProof.publicInput.protocolTransitionsHash.assertEquals(
-        //   beforeBlockHashList.commitment
-        // );
-        // state.stateRoot = stateTransitionProof.publicInput.protocolStateRoot;
-        // TODO Only for now
-        // beforeBlockHashList.commitment.assertEquals(
-        //   Field(0),
-        //   "beforeBlock() cannot emit state transitions yet"
-        // );
+        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.assertEquals(beforeBlockResult.networkState.hash(), "TransactionProof networkstate hash not matching beforeBlock hook result");
-        transactionProof.publicInput.stateRoot.assertEquals(state.stateRoot, "TransactionProof input state root not matching blockprover state root");
-        state.stateRoot = transactionProof.publicOutput.stateRoot;
-        state.transactionsHash = transactionProof.publicOutput.transactionsHash;
-        state.eternalTransactionsHash =
-            transactionProof.publicOutput.eternalTransactionsHash;
-        state.incomingMessagesHash =
-            transactionProof.publicOutput.incomingMessagesHash;
-        // 5. Execute afterBlock hooks
-        // this.assertSTProofInput(stateTransitionProof, state.stateRoot);
-        const afterBlockResult = await this.executeBlockHooks(state, beforeBlockResult.networkState, "afterBlock");
-        const afterBlockHashList = new StateTransitionReductionList(ProvableStateTransition);
-        afterBlockResult.stateTransitions.forEach((st) => {
-            afterBlockHashList.push(st.toProvable());
+        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.networkStateHash = afterBlockResult.networkState.hash();
-        // We are reusing runtime STs here as afterBlock STs
-        // stateTransitionProof.publicInput.protocolTransitionsHash.assertEquals(
-        //   afterBlockHashList.commitment,
-        //   "STProof from-ST-hash not matching generated ST-hash from afterBlock hooks"
-        // );
-        // state.stateRoot = Provable.if(
-        //   stsEmitted,
-        //   stateTransitionProof.publicOutput.stateRoot,
-        //   state.stateRoot
-        // );
-        // 6. Close block
-        // Calculate the new block index
+        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({
-            // Mirroring UnprovenBlock.hash()
-            blockHash: Poseidon.hash([blockIndex, state.transactionsHash]),
+            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({
-            ...state,
-            blockNumber: blockIndex.add(1),
+            ...BlockProverStateCommitments.fromBlockProverState(state),
             closed: Bool(true),
         });
     }
@@ -329,6 +382,12 @@ export class BlockProverProgrammable extends ZkProgrammable {
         // 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");
@@ -371,6 +430,8 @@ export class BlockProverProgrammable extends ZkProgrammable {
             incomingMessagesHash: proof2.publicOutput.incomingMessagesHash,
             closed: isValidClosedMerge,
             blockNumber: proof2.publicOutput.blockNumber,
+            pendingSTBatchesHash: proof2.publicOutput.pendingSTBatchesHash,
+            witnessedRootsHash: proof2.publicOutput.witnessedRootsHash,
         });
     }
     /**
@@ -382,6 +443,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
         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({
@@ -391,28 +453,34 @@ export class BlockProverProgrammable extends ZkProgrammable {
             methods: {
                 proveTransaction: {
                     privateInputs: [
-                        StateTransitionProofClass,
                         DynamicRuntimeProof,
-                        BlockProverExecutionData,
-                        RuntimeVerificationKeyAttestation,
+                        BlockProverSingleTransactionExecutionData,
+                    ],
+                    async method(publicInput, runtimeProof, executionData) {
+                        return await proveTransaction(publicInput, runtimeProof, executionData);
+                    },
+                },
+                proveTransactions: {
+                    privateInputs: [
+                        DynamicRuntimeProof,
+                        DynamicRuntimeProof,
+                        BlockProverMultiTransactionExecutionData,
                     ],
-                    async method(publicInput, stateProof, appProof, executionData, verificationKeyAttestation) {
-                        return await proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation);
+                    async method(publicInput, runtimeProof1, runtimeProof2, executionData) {
+                        return await proveTransactions(publicInput, runtimeProof1, runtimeProof2, executionData);
                     },
                 },
                 proveBlock: {
                     privateInputs: [
                         NetworkState,
                         BlockHashMerkleTreeWitness,
-                        // StateTransitionProofClass,
+                        StateTransitionProofClass,
+                        Bool,
+                        WitnessedRootWitness,
                         (SelfProof),
                     ],
-                    async method(publicInput, networkState, blockWitness, 
-                    // stateTransitionProof: StateTransitionProof,
-                    transactionProof) {
-                        return await proveBlock(publicInput, networkState, blockWitness, 
-                        // stateTransitionProof,
-                        transactionProof);
+                    async method(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof) {
+                        return await proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, deferSTs, afterBlockRootWitness, transactionProof);
                     },
                 },
                 merge: {
@@ -428,6 +496,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
         });
         const methods = {
             proveTransaction: program.proveTransaction,
+            proveTransactions: program.proveTransactions,
             proveBlock: program.proveBlock,
             merge: program.merge,
         };
@@ -447,17 +516,27 @@ export class BlockProverProgrammable extends ZkProgrammable {
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [BlockProverPublicInput, Object, DynamicRuntimeProof,
-        BlockProverExecutionData,
-        RuntimeVerificationKeyAttestation]),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        DynamicRuntimeProof,
+        BlockProverSingleTransactionExecutionData]),
     __metadata("design:returntype", Promise)
 ], BlockProverProgrammable.prototype, "proveTransaction", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __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]),
+        BlockHashMerkleTreeWitness, Object, Bool,
+        WitnessedRootWitness, Object]),
     __metadata("design:returntype", Promise)
 ], BlockProverProgrammable.prototype, "proveBlock", null);
 __decorate([
@@ -472,11 +551,11 @@ __decorate([
  * then be merged to be committed to the base-layer contract
  */
 export let BlockProver = class BlockProver extends ProtocolModule {
-    constructor(stateTransitionProver, runtime, transactionHooks, blockHooks, verificationKeyService) {
+    constructor(stateTransitionProver, runtime, transactionHooks, blockHooks, stateServiceProvider, verificationKeyService) {
         super();
         this.stateTransitionProver = stateTransitionProver;
         this.runtime = runtime;
-        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks, blockHooks, verificationKeyService);
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, transactionHooks, blockHooks, stateServiceProvider, verificationKeyService);
     }
     async compile(registry) {
         await registry.forceProverExists(async () => {
@@ -485,15 +564,14 @@ export let BlockProver = class BlockProver extends ProtocolModule {
         });
         return await this.zkProgrammable.compile(registry);
     }
-    proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation) {
-        return this.zkProgrammable.proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation);
+    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: StateTransitionProof,
-    transactionProof) {
-        return this.zkProgrammable.proveBlock(publicInput, networkState, blockWitness, 
-        // stateTransitionProof,
-        transactionProof);
+    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);
@@ -505,6 +583,8 @@ BlockProver = __decorate([
     __param(1, inject("Runtime")),
     __param(2, injectAll("ProvableTransactionHook")),
     __param(3, injectAll("ProvableBlockHook")),
-    __metadata("design:paramtypes", [Object, Object, Array, Array, RuntimeVerificationKeyRootService])
+    __param(4, inject("StateServiceProvider")),
+    __metadata("design:paramtypes", [Object, Object, Array, Array, StateServiceProvider,
+        RuntimeVerificationKeyRootService])
 ], BlockProver);
 //# sourceMappingURL=BlockProver.js.map