@proto-kit/protocol 0.1.1-develop.1086

package/dist/prover/block/BlockProver.js

@@ -0,0 +1,472 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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 { 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 { ProvableStateTransition, } from "../../model/StateTransition";
+import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
+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 { BlockHashMerkleTreeWitness, BlockHashTreeEntry, } from "./accummulators/BlockHashMerkleTree";
+import { MethodVKConfigData, RuntimeVerificationKeyAttestation, } 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",
+};
+function maxField() {
+    return Field(Field.ORDER - 1n);
+}
+export class BlockProverProgrammable extends ZkProgrammable {
+    constructor(prover, stateTransitionProver, runtime, transactionHooks, blockHooks, verificationKeyService) {
+        super();
+        this.prover = prover;
+        this.stateTransitionProver = stateTransitionProver;
+        this.runtime = runtime;
+        this.transactionHooks = transactionHooks;
+        this.blockHooks = blockHooks;
+        this.verificationKeyService = verificationKeyService;
+    }
+    get appChain() {
+        return this.prover.appChain;
+    }
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param runtimeProof
+     * @param executionData
+     * @param verificationKey
+     * @returns The new BlockProver-state to be used as public output
+     */
+    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);
+        // 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
+        new SignedTransaction({
+            transaction,
+            signature,
+        })
+            .validateSignature()
+            .or(isMessage)
+            .assertTrue("Transaction signature not valid");
+        // 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;
+    }
+    // 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);
+        const transitions = stateTransitions.map((transition) => transition.toProvable());
+        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");
+    }
+    async executeBlockHooks(state, inputNetworkState, type) {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        executionContext.clear();
+        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));
+        executionContext.afterMethod();
+        const { stateTransitions, status, statusMessage } = executionContext.current().result;
+        status.assertTrue(`Block hook call failed: ${statusMessage ?? "-"}`);
+        return {
+            networkState: resultingNetworkState,
+            stateTransitions,
+        };
+    }
+    addTransactionToBundle(state, isMessage, transaction) {
+        const stateTo = {
+            ...state,
+        };
+        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;
+        // 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;
+        // 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;
+    }
+    async proveTransaction(publicInput, stateProof, runtimeProof, executionData, verificationKeyWitness) {
+        const state = {
+            ...publicInput,
+        };
+        state.networkStateHash.assertEquals(executionData.networkState.hash(), "ExecutionData Networkstate doesn't equal public input hash");
+        // Verify the [methodId, vk] tuple against the baked-in vk tree root
+        const { verificationKey, witness: verificationKeyTreeWitness } = verificationKeyWitness;
+        const root = Field(this.verificationKeyService.getRoot());
+        const calculatedRoot = verificationKeyTreeWitness.calculateRoot(new MethodVKConfigData({
+            methodId: executionData.transaction.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 new BlockProverPublicOutput({
+            ...stateTo,
+            blockNumber: maxField(),
+            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 proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
+        const state = {
+            ...publicInput,
+        };
+        // 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 = 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");
+        // 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());
+        });
+        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({
+            ...state,
+            blockNumber: blockIndex,
+            closed: Bool(true),
+        });
+    }
+    async merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        // Check transaction list hash.
+        // Only assert them if these are tx proofs, skip for closed proofs
+        publicInput.transactionsHash
+            .equals(proof1.publicInput.transactionsHash)
+            .or(proof1.publicOutput.closed)
+            .assertTrue(errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.transactionsHash
+            .equals(proof2.publicInput.transactionsHash)
+            .or(proof1.publicOutput.closed)
+            .assertTrue(errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check networkhash
+        publicInput.networkStateHash.assertEquals(proof1.publicInput.networkStateHash, errors.networkStateHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.networkStateHash.assertEquals(proof2.publicInput.networkStateHash, errors.networkStateHashNotMatching("proof1.to -> proof2.from"));
+        // Check blockHashRoot
+        publicInput.blockHashRoot.assertEquals(proof1.publicInput.blockHashRoot, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.blockHashRoot.assertEquals(proof2.publicInput.blockHashRoot, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check eternalTransactionsHash
+        publicInput.eternalTransactionsHash.assertEquals(proof1.publicInput.eternalTransactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.eternalTransactionsHash.assertEquals(proof2.publicInput.eternalTransactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check incomingMessagesHash
+        publicInput.incomingMessagesHash.assertEquals(proof1.publicInput.incomingMessagesHash, errors.propertyNotMatchingStep("IncomingMessagesHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.incomingMessagesHash.assertEquals(proof2.publicInput.incomingMessagesHash, errors.propertyNotMatchingStep("IncomingMessagesHash", "proof1.to -> proof2.from"));
+        // 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,
+        });
+    }
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * injected StateTransitionProver and the required AppChainProof class
+     */
+    zkProgramFactory() {
+        const { prover, stateTransitionProver } = this;
+        const StateTransitionProofClass = stateTransitionProver.zkProgram[0].Proof;
+        const RuntimeProofClass = DynamicRuntimeProof;
+        const proveTransaction = prover.proveTransaction.bind(prover);
+        const proveBlock = prover.proveBlock.bind(prover);
+        const merge = prover.merge.bind(prover);
+        const program = ZkProgram({
+            name: "BlockProver",
+            publicInput: BlockProverPublicInput,
+            publicOutput: BlockProverPublicOutput,
+            methods: {
+                proveTransaction: {
+                    privateInputs: [
+                        StateTransitionProofClass,
+                        RuntimeProofClass,
+                        BlockProverExecutionData,
+                        RuntimeVerificationKeyAttestation,
+                    ],
+                    async method(publicInput, stateProof, appProof, executionData, verificationKeyAttestation) {
+                        return await proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation);
+                    },
+                },
+                proveBlock: {
+                    privateInputs: [
+                        NetworkState,
+                        BlockHashMerkleTreeWitness,
+                        StateTransitionProofClass,
+                        (SelfProof),
+                    ],
+                    async method(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
+                        return await proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        (SelfProof),
+                        (SelfProof),
+                    ],
+                    async method(publicInput, proof1, proof2) {
+                        return await merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        });
+        const methods = {
+            proveTransaction: program.proveTransaction,
+            merge: program.merge,
+        };
+        const SelfProofClass = ZkProgram.Proof(program);
+        return [
+            {
+                compile: program.compile.bind(program),
+                verify: program.verify.bind(program),
+                analyzeMethods: program.analyzeMethods.bind(program),
+                Proof: SelfProofClass,
+                methods,
+            },
+        ];
+    }
+}
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput, Object, DynamicRuntimeProof,
+        BlockProverExecutionData,
+        RuntimeVerificationKeyAttestation]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveTransaction", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        NetworkState,
+        BlockHashMerkleTreeWitness, Object, Object]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveBlock", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "merge", null);
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export let BlockProver = class BlockProver extends ProtocolModule {
+    constructor(stateTransitionProver, runtime, transactionHooks, blockHooks, verificationKeyService) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.runtime = runtime;
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks, blockHooks, verificationKeyService);
+    }
+    proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation) {
+        return this.zkProgrammable.proveTransaction(publicInput, stateProof, appProof, executionData, verificationKeyAttestation);
+    }
+    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(),
+    __param(0, inject("StateTransitionProver")),
+    __param(1, inject("Runtime")),
+    __param(2, injectAll("ProvableTransactionHook")),
+    __param(3, injectAll("ProvableBlockHook")),
+    __metadata("design:paramtypes", [Object, Object, Array, Array, RuntimeVerificationKeyRootService])
+], BlockProver);

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

@@ -0,0 +1,64 @@
+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/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    blockHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    blockHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    blockHash: bigint;
+    closed: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        blockHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        closed: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        blockHash: string;
+        closed: boolean;
+    };
+    fromJSON: (x: {
+        blockHash: string;
+        closed: boolean;
+    }) => {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/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,EAAoB,MAAM,MAAM,CAAC;;AAErD,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()]);
+    }
+}