@proto-kit/protocol 0.1.1-develop.457 → 0.1.1-develop.651

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

@@ -3,10 +3,15 @@ import { AreProofsEnabled, PlainZkProgram, WithZkProgrammable, ZkProgrammable }
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProof, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../statetransition/StateTransitionProvable";
-import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput } from "./BlockProvable";
 import { ProvableTransactionHook } from "../../protocol/ProvableTransactionHook";
 import { ProvableBlockHook } from "../../protocol/ProvableBlockHook";
+import { NetworkState } from "../../model/network/NetworkState";
+import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput } from "./BlockProvable";
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
 export interface BlockProverState {
+    /**
+     * The current state root of the block prover
+     */
     stateRoot: Field;
     /**
      * The current commitment of the transaction-list which
@@ -18,7 +23,21 @@ export interface BlockProverState {
      * 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>;
@@ -33,16 +52,17 @@ export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverP
      *
      * @param state The from-state of the BlockProver
      * @param stateTransitionProof
-     * @param appProof
+     * @param runtimeProof
      * @param executionData
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverState;
-    assertProtocolTransitions(stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, executionData: BlockProverExecutionData): void;
-    private getBeforeBlockNetworkState;
-    private getAfterBlockNetworkState;
+    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtimeProof: RuntimeProof, executionData: BlockProverExecutionData): BlockProverState;
+    assertProtocolTransitions(stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, executionData: BlockProverExecutionData, runtimeProof: Proof<void, MethodPublicOutput>): void;
+    private executeBlockHooks;
     private addTransactionToBundle;
-    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, runtimeProof: RuntimeProof, executionData: BlockProverExecutionData): BlockProverPublicOutput;
+    private assertSTProofInput;
+    proveBlock(publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, stateTransitionProof: StateTransitionProof, transactionProof: BlockProverProof): BlockProverPublicOutput;
     merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
     /**
      * Creates the BlockProver ZkProgram.
@@ -61,7 +81,8 @@ export declare class BlockProver extends ProtocolModule implements BlockProvable
     readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput>;
     zkProgrammable: BlockProverProgrammable;
     constructor(stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook<unknown>[], blockHooks: ProvableBlockHook<unknown>[]);
-    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
     proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
+    proveBlock(publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, stateTransitionProof: StateTransitionProof, transactionProof: BlockProverProof): BlockProverPublicOutput;
+    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
 }
 //# sourceMappingURL=BlockProver.d.ts.map

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

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

package/dist/prover/block/BlockProver.js

@@ -11,24 +11,32 @@ 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 "o1js";
+import { Bool, Experimental, Field, Poseidon, Provable, SelfProof, } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { DefaultProvableHashList } from "../../utils/ProvableHashList";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
-import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
-import { ProvableStateTransition } from "../../model/StateTransition";
+import { ProvableStateTransition, } from "../../model/StateTransition";
 import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
 import { NetworkState } from "../../model/network/NetworkState";
-import { BlockTransactionPosition } from "./BlockTransactionPosition";
+import { SignedTransaction } from "../../model/transaction/SignedTransaction";
+import { MinaActions, MinaActionsHashList, } from "../../utils/MinaPrefixedProvableHashList";
+import { StateTransitionReductionList } from "../../utils/StateTransitionReductionList";
+import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
+import { BlockHashMerkleTreeWitness, BlockHashTreeEntry, } from "./accummulators/BlockHashMerkleTree";
 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),
 };
+function maxField() {
+    return Field(Field.ORDER - 1n);
+}
 export class BlockProverProgrammable extends ZkProgrammable {
     constructor(
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
@@ -49,47 +57,56 @@ export class BlockProverProgrammable extends ZkProgrammable {
      *
      * @param state The from-state of the BlockProver
      * @param stateTransitionProof
-     * @param appProof
+     * @param runtimeProof
      * @param executionData
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state, stateTransitionProof, appProof, executionData) {
-        const { transaction, networkState } = executionData;
-        appProof.verify();
+    applyTransaction(state, stateTransitionProof, runtimeProof, executionData) {
+        const { transaction, networkState, signature } = executionData;
+        const isMessage = runtimeProof.publicOutput.isMessage;
+        runtimeProof.verify();
         stateTransitionProof.verify();
         const stateTo = { ...state };
         // Checks for the stateTransitionProof and appProof matching
         stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        appProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
+        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 state if status success
-        stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicOutput.protocolStateRoot);
         // Apply protocol state transitions
-        this.assertProtocolTransitions(stateTransitionProof, executionData);
+        this.assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof);
+        // Apply state if status success
+        stateTo.stateRoot = Provable.if(runtimeProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicOutput.protocolStateRoot);
+        // Check transaction integrity against appProof
+        const blockTransactionHash = transaction.hash();
+        blockTransactionHash.assertEquals(runtimeProof.publicOutput.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 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(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;
     }
     // eslint-disable-next-line no-warning-comments, max-len
     // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
-    assertProtocolTransitions(stateTransitionProof, executionData) {
+    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({
-            transaction: RuntimeTransaction.fromProtocolTransaction(executionData.transaction),
+            // That is why we should probably hide it from the transaction context inputs
+            transaction: executionData.transaction,
             networkState: executionData.networkState,
         });
         executionContext.beforeMethod("", "", []);
@@ -100,74 +117,159 @@ export class BlockProverProgrammable extends ZkProgrammable {
         const { stateTransitions, status, statusMessage } = executionContext.current().result;
         status.assertTrue(statusMessage);
         const transitions = stateTransitions.map((transition) => transition.toProvable());
-        const hashList = new DefaultProvableHashList(ProvableStateTransition, stateTransitionProof.publicInput.protocolTransitionsHash);
+        const hashList = new StateTransitionReductionList(ProvableStateTransition, stateTransitionProof.publicInput.protocolTransitionsHash);
         transitions.forEach((transition) => {
             hashList.push(transition);
         });
         stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(hashList.commitment, "ProtocolTransitionsHash not matching the generated protocol transitions");
     }
-    getBeforeBlockNetworkState(state, networkState) {
-        return this.blockHooks.reduce((networkState, blockHook) => {
-            return blockHook.beforeBlock({
-                state,
-                networkState,
-            });
-        }, networkState);
-    }
-    getAfterBlockNetworkState(state, networkState) {
-        return this.blockHooks.reduce((networkState, blockHook) => {
-            return blockHook.afterBlock({
-                state,
+    executeBlockHooks(state, inputNetworkState, type) {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        executionContext.clear();
+        executionContext.beforeMethod("", "", []);
+        const resultingNetworkState = this.blockHooks.reduce((networkState, blockHook) => {
+            // 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,
             });
-        }, networkState);
+            if (type === "beforeBlock") {
+                return blockHook.beforeBlock(networkState, state);
+            }
+            else if (type === "afterBlock") {
+                return blockHook.afterBlock(networkState, state);
+            }
+            else {
+                throw new Error("Unreachable");
+            }
+        }, inputNetworkState);
+        executionContext.afterMethod();
+        const { stateTransitions, status, statusMessage } = executionContext.current().result;
+        status.assertTrue(`Block hook call failed: ${statusMessage ?? "-"}`);
+        return {
+            networkState: resultingNetworkState,
+            stateTransitions,
+        };
     }
-    addTransactionToBundle(state, stateTransitionProof, appProof, executionData) {
-        const { transactionPosition, networkState } = executionData;
+    addTransactionToBundle(state, isMessage, transaction) {
         const stateTo = {
             ...state,
         };
-        // Execute beforeBlook hooks and apply if it is the first tx of the bundle
-        const beforeHookResult = this.getBeforeBlockNetworkState(state, networkState);
-        const bundleOpened = transactionPosition.equals(BlockTransactionPosition.fromPositionType("FIRST"));
-        const resultingNetworkState = new NetworkState(Provable.if(bundleOpened, NetworkState, beforeHookResult, networkState));
-        stateTo.networkStateHash = resultingNetworkState.hash();
-        // TODO Modify bundle merkle tree as per specs
+        const transactionHash = transaction.hash();
         // Append tx to transaction list
         const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
-        const { transactionHash } = appProof.publicOutput;
-        transactionList.push(transactionHash);
+        transactionList.pushIf(transactionHash, isMessage.not());
         stateTo.transactionsHash = transactionList.commitment;
-        return {
-            state: stateTo,
-            networkState: resultingNetworkState,
-            bundleOpened,
-            bundleClosed: transactionPosition.equals(BlockTransactionPosition.fromPositionType("LAST")),
+        // Append tx to eternal transaction list
+        // eslint-disable-next-line no-warning-comments
+        // 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;
+        // 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;
+    }
+    proveTransaction(publicInput, stateProof, runtimeProof, executionData) {
+        const state = {
+            ...publicInput,
         };
+        state.networkStateHash.assertEquals(executionData.networkState.hash(), "ExecutionData Networkstate doesn't equal public input hash");
+        const bundleInclusionState = this.addTransactionToBundle(state, runtimeProof.publicOutput.isMessage, executionData.transaction);
+        const stateTo = this.applyTransaction(bundleInclusionState, stateProof, runtimeProof, executionData);
+        return new BlockProverPublicOutput({
+            ...stateTo,
+            blockNumber: maxField(),
+            closed: Bool(false),
+        });
     }
-    proveTransaction(publicInput, stateProof, appProof, executionData) {
+    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"));
+    }
+    proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
         const state = {
-            transactionsHash: publicInput.transactionsHash,
-            stateRoot: publicInput.stateRoot,
-            networkStateHash: publicInput.networkStateHash,
+            ...publicInput,
         };
-        const bundleInclusionResult = this.addTransactionToBundle(state, stateProof, appProof, executionData);
-        const stateTo = this.applyTransaction(bundleInclusionResult.state, stateProof, appProof, {
-            transaction: executionData.transaction,
-            transactionPosition: executionData.transactionPosition,
-            networkState: bundleInclusionResult.networkState,
+        // 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.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");
+        // 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();
+        stateTransitionProof.verifyIf(stsEmitted);
+        // Verify Transaction proof if it has at least 1 tx
+        // 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 verifyTransactionProof = txProofOutput.equals(transactionProof.publicInput, txProofOutput.closed, txProofOutput.blockNumber);
+        transactionProof.verifyIf(verifyTransactionProof);
+        // 2. Execute beforeBlock hooks
+        const beforeBlockResult = this.executeBlockHooks(state, networkState, "beforeBlock");
+        const beforeBlockHashList = new StateTransitionReductionList(ProvableStateTransition);
+        beforeBlockResult.stateTransitions.forEach((st) => {
+            beforeBlockHashList.push(st.toProvable());
         });
-        // Apply afterBlock hooks
-        const afterBlockNetworkState = this.getAfterBlockNetworkState(stateTo, bundleInclusionResult.networkState);
-        const bundleClosed = executionData.transactionPosition.equals(BlockTransactionPosition.fromPositionType("LAST"));
-        // We only need the hash here since this computed networkstate
-        // is only used as an input in the next bundle
-        const resultingNetworkStateHash = Provable.if(bundleClosed, afterBlockNetworkState.hash(), stateTo.networkStateHash);
+        // 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");
+        // 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 = this.executeBlockHooks(state, beforeBlockResult.networkState, "afterBlock");
+        const afterBlockHashList = new StateTransitionReductionList(ProvableStateTransition);
+        afterBlockResult.stateTransitions.forEach((st) => {
+            afterBlockHashList.push(st.toProvable());
+        });
+        state.networkStateHash = afterBlockResult.networkState.hash();
+        // We are reusing runtime STs here as afterBlock STs
+        stateTransitionProof.publicInput.stateTransitionsHash.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
+        const blockIndex = blockWitness.calculateIndex();
+        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]),
+            closed: Bool(true),
+        }).hash());
         return new BlockProverPublicOutput({
-            stateRoot: stateTo.stateRoot,
-            transactionsHash: stateTo.transactionsHash,
-            // eslint-disable-next-line putout/putout
-            networkStateHash: resultingNetworkStateHash,
+            ...state,
+            blockNumber: blockIndex,
+            closed: Bool(true),
         });
     }
     merge(publicInput, proof1, proof2) {
@@ -176,16 +278,68 @@ export class BlockProverProgrammable extends ZkProgrammable {
         // 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.transactionsHashNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.networkStateHash.assertEquals(proof2.publicInput.networkStateHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        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"));
+        // 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 proof1Height = proof1.publicOutput.blockNumber;
+        const proof1Closed = proof1.publicOutput.closed;
+        const proof2Height = proof2.publicOutput.blockNumber;
+        const proof2Closed = proof2.publicOutput.closed;
+        const isValidTransactionMerge = proof1Height
+            .equals(maxField())
+            .and(proof2Height.equals(proof1Height))
+            .and(proof1Closed.or(proof2Closed).not());
+        const isValidClosedMerge = proof1Closed
+            .and(proof2Closed)
+            .and(proof1Height.add(1).equals(proof2Height));
+        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,
+            // Provable.if(isValidClosedMerge, Bool(true), Bool(false));
+            closed: isValidClosedMerge,
+            blockNumber: proof2Height,
         });
     }
     /**
@@ -232,6 +386,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
         return {
             compile: program.compile.bind(program),
             verify: program.verify.bind(program),
+            analyzeMethods: program.analyzeMethods.bind(program),
             Proof: SelfProofClass,
             methods,
         };
@@ -240,9 +395,17 @@ export class BlockProverProgrammable extends ZkProgrammable {
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Function, BlockProverExecutionData]),
+    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object, BlockProverExecutionData]),
     __metadata("design:returntype", BlockProverPublicOutput)
 ], BlockProverProgrammable.prototype, "proveTransaction", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        NetworkState,
+        BlockHashMerkleTreeWitness, Object, Object]),
+    __metadata("design:returntype", BlockProverPublicOutput)
+], BlockProverProgrammable.prototype, "proveBlock", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
@@ -261,12 +424,15 @@ let BlockProver = class BlockProver extends ProtocolModule {
         this.runtime = runtime;
         this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks, blockHooks);
     }
-    merge(publicInput, proof1, proof2) {
-        return this.zkProgrammable.merge(publicInput, proof1, proof2);
-    }
     proveTransaction(publicInput, stateProof, appProof, executionData) {
         return this.zkProgrammable.proveTransaction(publicInput, stateProof, appProof, executionData);
     }
+    proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
+        return this.zkProgrammable.proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
 };
 BlockProver = __decorate([
     injectable(),

package/dist/prover/block/accummulators/BlockHashMerkleTree.d.ts

@@ -0,0 +1,45 @@
+import { Field } from "o1js";
+declare const BlockHashMerkleTree_base: import("@proto-kit/common").AbstractMerkleTreeClass;
+export declare class BlockHashMerkleTree extends BlockHashMerkleTree_base {
+}
+export declare class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
+}
+declare const BlockHashTreeEntry_base: (new (value: {
+    blockHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}) => {
+    blockHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    blockHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}> & {
+    toInput: (x: {
+        blockHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        blockHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+    }) => {
+        blockHash: string;
+        closed: boolean;
+    };
+    fromJSON: (x: {
+        blockHash: string;
+        closed: boolean;
+    }) => {
+        blockHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+    };
+};
+export declare class BlockHashTreeEntry extends BlockHashTreeEntry_base {
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=BlockHashMerkleTree.d.ts.map

package/dist/prover/block/accummulators/BlockHashMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashMerkleTree.d.ts","sourceRoot":"","sources":["../../../../src/prover/block/accummulators/BlockHashMerkleTree.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAA8B,MAAM,MAAM,CAAC;;AAE/D,qBAAa,mBAAoB,SAAQ,wBAAoB;CAAG;AAChE,qBAAa,0BAA2B,SAAQ,mBAAmB,CAAC,OAAO;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E,qBAAa,kBAAmB,SAAQ,uBAKtC;IACO,IAAI,IAAI,KAAK;CAGrB"}

package/dist/prover/block/accummulators/BlockHashMerkleTree.js

@@ -0,0 +1,16 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Struct } from "o1js";
+export class BlockHashMerkleTree extends createMerkleTree(40) {
+}
+export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
+}
+export class BlockHashTreeEntry extends Struct({
+    blockHash: Field,
+    closed: Bool,
+    // TODO We could add startingEternalTransactionsHash here to offer
+    // a more trivial connection to the sequence state
+}) {
+    hash() {
+        return Poseidon.hash([this.blockHash, ...this.closed.toFields()]);
+    }
+}

package/dist/prover/statetransition/StateTransitionProver.d.ts

@@ -6,6 +6,7 @@ import { ProvableStateTransitionType, StateTransitionProvableBatch } from "../..
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 interface StateTransitionProverExecutionState {
     stateRoot: Field;
     protocolStateRoot: Field;
@@ -39,9 +40,9 @@ export declare class StateTransitionProverProgrammable extends ZkProgrammable<St
     runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
     merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
 }
-export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable {
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable, StateTransitionProverType {
     readonly witnessProviderReference: StateTransitionWitnessProviderReference;
-    readonly zkProgrammable: StateTransitionProverProgrammable;
+    zkProgrammable: StateTransitionProverProgrammable;
     constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
     runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
     merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;