@proto-kit/protocol 0.1.1-develop.191 → 0.1.1-develop.2024

package/dist/prover/block/BlockProver.js

@@ -10,97 +10,240 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-/* eslint-disable max-lines */
-import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
-import { inject, injectable } from "tsyringe";
-import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
-import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { Bool, Field, Provable, SelfProof, ZkProgram } from "o1js";
+import { container, inject, injectable, injectAll } from "tsyringe";
+import { log, provableMethod, reduceSequential, ZkProgrammable, } from "@proto-kit/common";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
-import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
+import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
+import { toAfterBlockHookArgument, toBeforeBlockHookArgument, } from "../../protocol/ProvableBlockHook";
+import { NetworkState } from "../../model/network/NetworkState";
+import { assertEqualsIf } from "../../utils/utils";
+import { StateServiceProvider } from "../../state/StateServiceProvider";
+import { executeHooks } from "../utils";
+import { Bundle } from "../accumulators/BlockHashList";
+import { BlockArgumentsBatch, BlockProverPublicInput, BlockProverPublicOutput, BlockProverState, BlockProverStateInput, } 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}`,
 };
-/**
- * BlockProver class, which aggregates a AppChainProof and
- * a StateTransitionProof into a single BlockProof, that can
- * then be merged to be committed to the base-layer contract
- */
-let BlockProver = class BlockProver extends ProtocolModule {
-    constructor(stateTransitionProver, runtime) {
+export class BlockProverProgrammable extends ZkProgrammable {
+    constructor(prover, stateTransitionProver, transactionProver, blockHooks, stateServiceProvider) {
         super();
+        this.prover = prover;
         this.stateTransitionProver = stateTransitionProver;
-        this.runtime = runtime;
+        this.transactionProver = transactionProver;
+        this.blockHooks = blockHooks;
+        this.stateServiceProvider = stateServiceProvider;
+        this.name = "BlockProver";
     }
-    /**
-     * 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 appProof
-     * @returns The new BlockProver-state to be used as public output
-     */
-    applyTransaction(state, stateTransitionProof, appProof, { transaction, networkState }) {
-        appProof.verify();
-        stateTransitionProof.verify();
-        const stateTo = { ...state };
-        // eslint-disable-next-line no-warning-comments
-        // TODO Check methodId?
-        // Checks for the stateTransitionProof and appProof matching
-        stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
-        appProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
-        // Apply state if status success
-        state.stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
-        stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicInput.stateRoot);
-        // Check transaction signature
-        transaction
-            .validateSignature()
-            .assertTrue("Transaction signature not valid");
-        // Check if the methodId is correct
-        // to do
-        // Check transaction integrity against appProof
-        const blockTransactionHash = RuntimeTransaction.fromProtocolTransaction(transaction).hash();
-        blockTransactionHash.assertEquals(appProof.publicOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
-        // Check network state integrity against appProof
-        state.networkStateHash.assertEquals(appProof.publicOutput.networkStateHash, "Network state does not match state used in AppProof");
-        state.networkStateHash.assertEquals(networkState.hash(), "Network state provided to BlockProver does not match the publicInput");
-        // Append tx to transaction list
-        const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
-        const { transactionHash } = appProof.publicOutput;
-        transactionList.push(transactionHash);
-        stateTo.transactionsHash = transactionList.commitment;
-        return stateTo;
-    }
-    proveTransaction(publicInput, stateProof, appProof, executionData) {
-        const state = {
-            transactionsHash: publicInput.transactionsHash,
-            stateRoot: publicInput.stateRoot,
-            networkStateHash: publicInput.networkStateHash,
+    get areProofsEnabled() {
+        return this.prover.areProofsEnabled;
+    }
+    async executeBlockHooks(type, hook, hookArguments, inputNetworkState, isDummy) {
+        const transaction = RuntimeTransaction.dummyTransaction();
+        const startingInputs = {
+            transaction,
+            networkState: inputNetworkState,
+        };
+        return await executeHooks(startingInputs, `${type}Block`, async () => {
+            const executionContext = container.resolve(RuntimeMethodExecutionContext);
+            return await this.blockHooks.reduce(async (networkStatePromise, blockHook) => {
+                const networkState = await networkStatePromise;
+                // Setup context for potential calls to runtime methods.
+                // With the special case that we set the new networkstate for every hook
+                // We also have to put in a dummy transaction for network.transaction
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState,
+                });
+                return await hook(blockHook, networkState, hookArguments);
+            }, Promise.resolve(inputNetworkState));
+        }, isDummy);
+    }
+    includeSTProof(stateTransitionProof, apply, stateRoot, pendingSTBatchesHash, witnessedRootsHash) {
+        assertEqualsIf(stateTransitionProof.publicInput.currentBatchStateHash, Field(0), apply, "State for STProof has to be empty at the start");
+        assertEqualsIf(stateTransitionProof.publicOutput.currentBatchStateHash, Field(0), apply, "State for STProof has to be empty at the end");
+        assertEqualsIf(stateTransitionProof.publicInput.batchesHash, Field(0), apply, "Batcheshash doesn't start at 0");
+        // Assert from state root
+        assertEqualsIf(stateRoot, stateTransitionProof.publicInput.root, apply, errors.propertyNotMatching("from state root"));
+        // Assert the stBatchesHash executed is the same
+        assertEqualsIf(pendingSTBatchesHash, stateTransitionProof.publicOutput.batchesHash, apply, "Pending STBatches are not the same that have been executed by the ST proof");
+        // Assert root Accumulator
+        assertEqualsIf(Field(0), stateTransitionProof.publicInput.witnessedRootsHash, apply, errors.propertyNotMatching("from state root"));
+        // Assert the witnessedRootsHash created is the same
+        assertEqualsIf(witnessedRootsHash, stateTransitionProof.publicOutput.witnessedRootsHash, apply, "Root accumulator Commitment is not the same that have been executed by the ST proof");
+        // update root only if we didn't defer
+        const newRoot = Provable.if(apply, stateTransitionProof.publicOutput.root, stateRoot);
+        // Reset only if we didn't defer
+        const newBatchesHash = Provable.if(apply, Field(0), pendingSTBatchesHash);
+        const newWitnessedRootsHash = Provable.if(apply, Field(0), witnessedRootsHash);
+        return {
+            stateRoot: newRoot,
+            pendingSTBatchesHash: newBatchesHash,
+            witnessedRootsHash: newWitnessedRootsHash,
         };
-        const stateTo = this.applyTransaction(state, stateProof, appProof, executionData);
-        return new BlockProverPublicOutput({
-            stateRoot: stateTo.stateRoot,
-            transactionsHash: stateTo.transactionsHash,
+    }
+    verifySTProof(state, stateTransitionProof, deferSTProof) {
+        // Verify ST Proof only if STs have been emitted,
+        // and we don't defer the verification of the STs
+        // otherwise we can input a dummy proof
+        const batchesEmpty = state.pendingSTBatches.commitment.equals(Field(0));
+        const verifyStProof = deferSTProof.not().and(batchesEmpty.not());
+        log.provable.debug("Verify STProof", verifyStProof);
+        stateTransitionProof.verifyIf(verifyStProof);
+        // Apply STProof if not deferred
+        const stateProofResult = this.includeSTProof(stateTransitionProof, verifyStProof, state.stateRoot, state.pendingSTBatches.commitment, state.witnessedRoots.commitment);
+        state.stateRoot = stateProofResult.stateRoot;
+        state.pendingSTBatches.commitment = stateProofResult.pendingSTBatchesHash;
+        state.witnessedRoots.commitment = stateProofResult.witnessedRootsHash;
+    }
+    verifyTransactionProof(state, transactionProof, deferTransactionProof) {
+        // Verify Transaction proof if it has at least 1 tx and it isn't deferred
+        const finalizeBlockProof = deferTransactionProof.not();
+        const verifyTransactionProof = finalizeBlockProof.and(state.bundleList.isEmpty().not());
+        transactionProof.verifyIf(verifyTransactionProof);
+        // Fast-forward transaction trackers by the results of the aggregated transaction proof
+        // Implicitly, the 'from' values here are asserted against the publicInput, since the hashlists
+        // are created out of the public input
+        state.eternalTransactionsList.fastForwardIf({
+            from: transactionProof.publicInput.eternalTransactionsHash,
+            to: transactionProof.publicOutput.eternalTransactionsHash,
+        }, verifyTransactionProof, "eternalTransactionsList");
+        state.incomingMessages.fastForwardIf({
+            from: transactionProof.publicInput.incomingMessagesHash,
+            to: transactionProof.publicOutput.incomingMessagesHash,
+        }, verifyTransactionProof, "incomingMessages");
+        // Cancel out remainders for transaction proof
+        assertEqualsIf(transactionProof.publicInput.bundlesHash, Field(0), verifyTransactionProof, "TransactionProof has to start bundles at 0");
+        // Fast Backwards actually, but logic holds
+        state.bundleList.fastForwardIf({
+            from: transactionProof.publicOutput.bundlesHash,
+            to: state.bundleList.empty(),
+        }, verifyTransactionProof, "bundles hash");
+    }
+    parseState(publicInput, stateWitness, networkState, blockWitness) {
+        const hasNoStateRemained = publicInput.proverStateRemainder.equals(0);
+        // If the state is supplied as a witness, we check that it is equals the PI's stateHash
+        stateWitness
+            .hash()
+            .equals(publicInput.proverStateRemainder)
+            .or(hasNoStateRemained)
+            .assertTrue("Input state witness is invalid");
+        const stateInputs = Provable.if(hasNoStateRemained, BlockProverStateInput, BlockProverStateInput.fromPublicInput(publicInput), stateWitness);
+        stateInputs.networkStateHash.assertEquals(networkState.hash(), "Network state not valid");
+        const state = BlockProverState.blockProverFromCommitments(stateInputs, networkState, blockWitness);
+        // Verify block witness validity
+        const blockIndex = blockWitness.calculateIndex();
+        blockIndex.assertEquals(stateInputs.blockNumber);
+        blockWitness
+            .calculateRoot(Field(0))
+            .assertEquals(stateInputs.blockHashRoot, "Supplied block hash witness not matching state root");
+        return state;
+    }
+    computeOutput(publicInput, state, finalizeBlockProof) {
+        const finalizedOutput = state.toCommitments();
+        const deferredOutput = {
+            ...publicInput,
+        };
+        deferredOutput.proverStateRemainder = finalizedOutput.hash();
+        return new BlockProverPublicOutput(Provable.if(finalizeBlockProof, BlockProverPublicOutput, finalizedOutput.finalize(finalizeBlockProof), deferredOutput));
+    }
+    async proveBlockBatchNoProofs(publicInput, stateWitness, networkState, blockWitness, batch, finalize) {
+        return await this.proveBlockBatch(false, publicInput, stateWitness, networkState, blockWitness, batch, Bool(true), Bool(true), finalize);
+    }
+    async proveBlockBatchWithProofs(publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, stateTransitionProof, transactionProof) {
+        const finalize = deferTransactionProof.or(deferSTProof).not();
+        return await this.proveBlockBatch(true, publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, finalize, stateTransitionProof, transactionProof);
+    }
+    async proveBlockBatch(doProofVerification, publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, finalize, stateTransitionProof, transactionProof) {
+        let state = this.parseState(publicInput, stateWitness, networkState, blockWitness);
+        // Prove blocks iteratively
+        state = await reduceSequential(batch.batch, async (current, block) => {
+            const result = await this.proveBlock(current.copy(), block);
+            this.stateServiceProvider.popCurrentStateService();
+            return BlockProverState.choose(block.isDummy, current, result);
+        }, state);
+        if (doProofVerification) {
+            this.verifyTransactionProof(state, transactionProof, deferTransactionProof);
+            this.verifySTProof(state, stateTransitionProof, deferSTProof);
+        }
+        return this.computeOutput(publicInput, state, finalize);
+    }
+    async proveBlock(state, args) {
+        const { networkState, blockWitness } = state;
+        const { afterBlockRootWitness, transactionsHash, isDummy } = args;
+        const startingPendingStBatches = state.pendingSTBatches.commitment;
+        // 1. Execute beforeBlock hooks
+        const beforeBlockArgs = toBeforeBlockHookArgument(state);
+        const beforeBlockResult = await this.executeBlockHooks("before", async (module, networkStateArg, hookArgs) => await module.beforeBlock(networkStateArg, hookArgs), beforeBlockArgs, networkState, isDummy);
+        state.pendingSTBatches.push(beforeBlockResult.batch);
+        // 2. "Apply" TX-type BlockProof
+        args.pendingSTBatchesHash.from.assertEquals(state.pendingSTBatches.commitment);
+        args.witnessedRootsHash.from.assertEquals(state.witnessedRoots.commitment);
+        const isEmptyBlock = transactionsHash.equals(Field(0));
+        const isNotEmptyBlock = isEmptyBlock.not();
+        // Check & fast-forward the stBatchHashList to after all transactions appended
+        state.pendingSTBatches.fastForward(args.pendingSTBatchesHash, "Transaction proof doesn't start their STs after the beforeBlockHook");
+        // Same for witnessedRootsHash
+        state.witnessedRoots.fastForward(args.witnessedRootsHash, "Transaction proof doesn't start with correct witnessed roots hash");
+        // Add block to bundles list
+        const bundle = new Bundle({
+            transactionsHash: transactionsHash,
+            networkStateHash: beforeBlockResult.result.hash(),
+            pendingSTBatchesHash: args.pendingSTBatchesHash,
+            witnessedRootsHash: args.witnessedRootsHash,
         });
+        state.bundleList.pushIf(bundle, isNotEmptyBlock);
+        // 3.
+        // Calculate new block tree root and increment witness
+        // Blocknumber as the index here is already authenticated previously
+        const [root, newWitness] = blockWitness.calculateRootIncrement(state.blockNumber, new BlockHashTreeEntry({
+            block: {
+                index: state.blockNumber,
+                transactionListHash: transactionsHash,
+            },
+            closed: Bool(true),
+        }).hash());
+        state.blockHashRoot = root;
+        state.blockWitness = newWitness;
+        state.blockNumber = state.blockNumber.add(1);
+        // 4. Execute afterBlock hooks
+        // Witness root
+        const hasNoSTBatches = state.pendingSTBatches.commitment.equals(startingPendingStBatches);
+        // TODO Cover case when we witness root but pendingSTBatches is completely empty
+        state.witnessedRoots.witnessRoot({
+            appliedBatchListState: state.pendingSTBatches.commitment,
+            root: afterBlockRootWitness.witnessedRoot,
+        }, hasNoSTBatches.not());
+        // Switch state service to afterBlock one
+        this.stateServiceProvider.popCurrentStateService();
+        // Execute hooks
+        const afterBlockHookArgs = toAfterBlockHookArgument(state, afterBlockRootWitness.witnessedRoot, transactionsHash);
+        const afterBlockResult = await this.executeBlockHooks("after", async (module, networkStateArg, hookArgs) => await module.afterBlock(networkStateArg, hookArgs), {
+            ...afterBlockHookArgs,
+        }, beforeBlockResult.result, isDummy);
+        // Apply state and network state changes
+        state.pendingSTBatches.push(afterBlockResult.batch);
+        state.networkState = afterBlockResult.result;
+        return state;
     }
-    merge(publicInput, proof1, proof2) {
+    async merge(publicInput, proof1, proof2) {
         proof1.verify();
         proof2.verify();
-        // Check state
-        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
-        // Check transaction list
-        publicInput.transactionsHash.assertEquals(proof1.publicInput.transactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.transactionsHash.assertEquals(proof2.publicInput.transactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
-        return new BlockProverPublicOutput({
-            stateRoot: proof2.publicOutput.stateRoot,
-            transactionsHash: proof2.publicOutput.transactionsHash,
-        });
+        function checkProperty(key) {
+            // Check state
+            publicInput[key].assertEquals(proof1.publicInput[key], errors.propertyNotMatchingStep(key, "publicInput.from -> proof1.from"));
+            proof1.publicOutput[key].assertEquals(proof2.publicInput[key], errors.propertyNotMatchingStep(key, "proof1.to -> proof2.from"));
+        }
+        checkProperty("stateRoot");
+        checkProperty("networkStateHash");
+        checkProperty("blockHashRoot");
+        checkProperty("eternalTransactionsHash");
+        checkProperty("incomingMessagesHash");
+        checkProperty("proverStateRemainder");
+        return proof2.publicOutput;
     }
     /**
      * Creates the BlockProver ZkProgram.
@@ -108,22 +251,46 @@ let BlockProver = class BlockProver extends ProtocolModule {
      * injected StateTransitionProver and the required AppChainProof class
      */
     zkProgramFactory() {
-        const StateTransitionProofClass = this.stateTransitionProver.zkProgram.Proof;
-        const RuntimeProofClass = this.runtime.zkProgrammable.zkProgram.Proof;
-        const proveTransaction = this.proveTransaction.bind(this);
-        const merge = this.merge.bind(this);
-        const program = Experimental.ZkProgram({
+        const { prover, stateTransitionProver, transactionProver } = this;
+        const StateTransitionProofClass = stateTransitionProver.zkProgram[0].Proof;
+        const TransactionProofClass = transactionProver.zkProgram[0].Proof;
+        const proveBlockBatchWithProofs = prover.proveBlockBatchWithProofs.bind(prover);
+        const proveBlockBatchNoProofs = prover.proveBlockBatchNoProofs.bind(prover);
+        const merge = prover.merge.bind(prover);
+        const program = ZkProgram({
+            name: "BlockProver",
             publicInput: BlockProverPublicInput,
             publicOutput: BlockProverPublicOutput,
             methods: {
-                proveTransaction: {
+                proveBlockBatchWithProofs: {
                     privateInputs: [
+                        BlockProverStateInput,
+                        NetworkState,
+                        BlockHashMerkleTreeWitness,
+                        BlockArgumentsBatch,
+                        Bool,
+                        Bool,
                         StateTransitionProofClass,
-                        RuntimeProofClass,
-                        BlockProverExecutionData,
+                        TransactionProofClass,
                     ],
-                    method(publicInput, stateProof, appProof, executionData) {
-                        return proveTransaction(publicInput, stateProof, appProof, executionData);
+                    async method(publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, stateTransitionProof, transactionProof) {
+                        return {
+                            publicOutput: await proveBlockBatchWithProofs(publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, stateTransitionProof, transactionProof),
+                        };
+                    },
+                },
+                proveBlockBatchNoProofs: {
+                    privateInputs: [
+                        BlockProverStateInput,
+                        NetworkState,
+                        BlockHashMerkleTreeWitness,
+                        BlockArgumentsBatch,
+                        Bool,
+                    ],
+                    async method(publicInput, stateWitness, networkState, blockWitness, batch, finalize) {
+                        return {
+                            publicOutput: await proveBlockBatchNoProofs(publicInput, stateWitness, networkState, blockWitness, batch, finalize),
+                        };
                     },
                 },
                 merge: {
@@ -131,41 +298,94 @@ let BlockProver = class BlockProver extends ProtocolModule {
                         (SelfProof),
                         (SelfProof),
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return { publicOutput: await merge(publicInput, proof1, proof2) };
                     },
                 },
             },
         });
         const methods = {
-            proveTransaction: program.proveTransaction,
+            proveBlockBatchWithProofs: program.proveBlockBatchWithProofs,
+            proveBlockBatchNoProofs: program.proveBlockBatchNoProofs,
             merge: program.merge,
         };
-        const SelfProofClass = Experimental.ZkProgram.Proof(program);
-        return {
-            compile: program.compile.bind(program),
-            verify: program.verify.bind(program),
-            Proof: SelfProofClass,
-            methods,
-        };
+        const SelfProofClass = ZkProgram.Proof(program);
+        return [
+            {
+                name: program.name,
+                compile: program.compile.bind(program),
+                verify: program.verify.bind(program),
+                analyzeMethods: program.analyzeMethods.bind(program),
+                Proof: SelfProofClass,
+                methods,
+            },
+        ];
     }
-};
+}
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Function, BlockProverExecutionData]),
-    __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "proveTransaction", null);
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        BlockProverStateInput,
+        NetworkState,
+        BlockHashMerkleTreeWitness,
+        BlockArgumentsBatch,
+        Bool]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveBlockBatchNoProofs", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput,
+        BlockProverStateInput,
+        NetworkState,
+        BlockHashMerkleTreeWitness,
+        BlockArgumentsBatch,
+        Bool,
+        Bool, Object, Object]),
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "proveBlockBatchWithProofs", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
-    __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "merge", null);
+    __metadata("design:returntype", Promise)
+], BlockProverProgrammable.prototype, "merge", null);
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export let BlockProver = class BlockProver extends ProtocolModule {
+    constructor(stateTransitionProver, transactionProver, blockHooks, stateServiceProvider) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.transactionProver = transactionProver;
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, transactionProver.zkProgrammable, blockHooks, stateServiceProvider);
+    }
+    async compile(registry) {
+        return await registry.forceProverExists(async () => {
+            await this.stateTransitionProver.compile(registry);
+            await this.transactionProver.compile(registry);
+            return await this.zkProgrammable.compile(registry);
+        });
+    }
+    proveBlockBatchNoProofs(publicInput, stateWitness, networkState, blockWitness, batch, finalize) {
+        return this.zkProgrammable.proveBlockBatchNoProofs(publicInput, stateWitness, networkState, blockWitness, batch, finalize);
+    }
+    proveBlockBatchWithProofs(publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, stateTransitionProof, transactionProof) {
+        return this.zkProgrammable.proveBlockBatchWithProofs(publicInput, stateWitness, networkState, blockWitness, batch, deferSTProof, deferTransactionProof, stateTransitionProof, transactionProof);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+};
 BlockProver = __decorate([
     injectable(),
     __param(0, inject("StateTransitionProver")),
-    __param(1, inject("Runtime")),
-    __metadata("design:paramtypes", [ZkProgrammable, Object])
+    __param(1, inject("TransactionProver")),
+    __param(2, injectAll("ProvableBlockHook")),
+    __param(3, inject("StateServiceProvider")),
+    __metadata("design:paramtypes", [Object, Object, Array, StateServiceProvider])
 ], BlockProver);
-export { BlockProver };
+//# sourceMappingURL=BlockProver.js.map

package/dist/prover/block/BlockProver.js.map

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

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

@@ -0,0 +1,106 @@
+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: {
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: 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<{
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    block: {
+        index: bigint;
+        transactionListHash: bigint;
+    };
+    closed: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        } | {
+            index: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: 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: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        block: {
+            index: string;
+            transactionListHash: string;
+        };
+        closed: boolean;
+    };
+    fromJSON: (x: {
+        block: {
+            index: string;
+            transactionListHash: string;
+        };
+        closed: boolean;
+    }) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: 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,uBAQtC;IACO,IAAI,IAAI,KAAK;CAQrB"}