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

package/dist/prover/block/BlockProver.js

@@ -11,24 +11,31 @@ 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 { 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 +56,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("", "", []);
@@ -106,68 +122,153 @@ export class BlockProverProgrammable extends ZkProgrammable {
         });
         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 DefaultProvableHashList(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 DefaultProvableHashList(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 = stateTransitionProof.publicInput.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 +277,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,
         });
     }
     /**
@@ -240,9 +393,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 +422,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(16) {
+}
+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/settlement/ProvableSettlementHook.d.ts

@@ -0,0 +1,26 @@
+import { Field, UInt32 } from "o1js";
+import type { BlockProof } from "../prover/block/BlockProver";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+import { NetworkState } from "../model/network/NetworkState";
+import type { SettlementContract } from "./SettlementContract";
+export type SettlementStateRecord = {
+    sequencerKey: Field;
+    lastSettlementL1Block: UInt32;
+    stateRoot: Field;
+    networkStateHash: Field;
+    blockHashRoot: Field;
+    promisedMessagesHash: Field;
+    honoredMessagesHash: Field;
+};
+export type SettlementHookInputs = {
+    blockProof: BlockProof;
+    fromNetworkState: NetworkState;
+    toNetworkState: NetworkState;
+    newPromisedMessagesHash: Field;
+    contractState: SettlementStateRecord;
+    currentL1Block: UInt32;
+};
+export declare abstract class ProvableSettlementHook<Config> extends ProtocolModule<Config> {
+    abstract beforeSettlement(smartContract: SettlementContract, inputs: SettlementHookInputs): void;
+}
+//# sourceMappingURL=ProvableSettlementHook.d.ts.map

package/dist/settlement/ProvableSettlementHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableSettlementHook.d.ts","sourceRoot":"","sources":["../../src/settlement/ProvableSettlementHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,KAAK,CAAC;IACpB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,SAAS,EAAE,KAAK,CAAC;IACjB,gBAAgB,EAAE,KAAK,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC;IAErB,oBAAoB,EAAE,KAAK,CAAC;IAC5B,mBAAmB,EAAE,KAAK,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,cAAc,EAAE,YAAY,CAAC;IAC7B,uBAAuB,EAAE,KAAK,CAAC;IAC/B,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,8BAAsB,sBAAsB,CAC1C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;aACd,gBAAgB,CAC9B,aAAa,EAAE,kBAAkB,EACjC,MAAM,EAAE,oBAAoB,GAC3B,IAAI;CACR"}

package/dist/settlement/ProvableSettlementHook.js

@@ -0,0 +1,3 @@
+import { ProtocolModule } from "../protocol/ProtocolModule";
+export class ProvableSettlementHook extends ProtocolModule {
+}