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

package/dist/prover/block/BlockProver.js

@@ -10,8 +10,7 @@ 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 { Bool, Experimental, Field, Poseidon, Provable, SelfProof } from "o1js";
+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";
@@ -21,7 +20,8 @@ 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 { MinaActions, MinaActionsHashList, } from "../../utils/MinaPrefixedProvableHashList";
+import { StateTransitionReductionList } from "../../utils/StateTransitionReductionList";
 import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
 import { BlockHashMerkleTreeWitness, BlockHashTreeEntry, } from "./accummulators/BlockHashMerkleTree";
 const errors = {
@@ -37,9 +37,7 @@ function maxField() {
     return Field(Field.ORDER - 1n);
 }
 export class BlockProverProgrammable extends ZkProgrammable {
-    constructor(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    prover, stateTransitionProver, runtime, transactionHooks, blockHooks) {
+    constructor(prover, stateTransitionProver, runtime, transactionHooks, blockHooks) {
         super();
         this.prover = prover;
         this.stateTransitionProver = stateTransitionProver;
@@ -60,9 +58,9 @@ export class BlockProverProgrammable extends ZkProgrammable {
      * @param executionData
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state, stateTransitionProof, runtimeProof, executionData) {
+    async applyTransaction(state, stateTransitionProof, runtimeProof, executionData) {
         const { transaction, networkState, signature } = executionData;
-        const isMessage = runtimeProof.publicOutput.isMessage;
+        const { isMessage } = runtimeProof.publicOutput;
         runtimeProof.verify();
         stateTransitionProof.verify();
         const stateTo = { ...state };
@@ -74,7 +72,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
         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
-        this.assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof);
+        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
@@ -95,9 +93,9 @@ export class BlockProverProgrammable extends ZkProgrammable {
         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
+    // eslint-disable-next-line max-len
     // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
-    assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof) {
+    async assertProtocolTransitions(stateTransitionProof, executionData, runtimeProof) {
         const executionContext = container.resolve(RuntimeMethodExecutionContext);
         executionContext.clear();
         // Setup context for potential calls to runtime methods.
@@ -109,24 +107,26 @@ export class BlockProverProgrammable extends ZkProgrammable {
             networkState: executionData.networkState,
         });
         executionContext.beforeMethod("", "", []);
-        this.transactionHooks.forEach((module) => {
-            module.onTransaction(executionData);
-        });
+        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 DefaultProvableHashList(ProvableStateTransition, stateTransitionProof.publicInput.protocolTransitionsHash);
+        const hashList = new StateTransitionReductionList(ProvableStateTransition, stateTransitionProof.publicInput.protocolTransitionsHash);
         transitions.forEach((transition) => {
             hashList.push(transition);
         });
         stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(hashList.commitment, "ProtocolTransitionsHash not matching the generated protocol transitions");
     }
-    executeBlockHooks(state, inputNetworkState, type) {
+    async executeBlockHooks(state, inputNetworkState, type) {
         const executionContext = container.resolve(RuntimeMethodExecutionContext);
         executionContext.clear();
         executionContext.beforeMethod("", "", []);
-        const resultingNetworkState = this.blockHooks.reduce((networkState, blockHook) => {
+        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
@@ -135,15 +135,13 @@ export class BlockProverProgrammable extends ZkProgrammable {
                 networkState,
             });
             if (type === "beforeBlock") {
-                return blockHook.beforeBlock(networkState, state);
-            }
-            else if (type === "afterBlock") {
-                return blockHook.afterBlock(networkState, state);
+                return await blockHook.beforeBlock(networkState, state);
             }
-            else {
-                throw new Error("Unreachable");
+            if (type === "afterBlock") {
+                return await blockHook.afterBlock(networkState, state);
             }
-        }, inputNetworkState);
+            throw new Error("Unreachable");
+        }, Promise.resolve(inputNetworkState));
         executionContext.afterMethod();
         const { stateTransitions, status, statusMessage } = executionContext.current().result;
         status.assertTrue(`Block hook call failed: ${statusMessage ?? "-"}`);
@@ -162,7 +160,6 @@ export class BlockProverProgrammable extends ZkProgrammable {
         transactionList.pushIf(transactionHash, isMessage.not());
         stateTo.transactionsHash = transactionList.commitment;
         // 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());
@@ -174,13 +171,13 @@ export class BlockProverProgrammable extends ZkProgrammable {
         stateTo.incomingMessagesHash = incomingMessagesList.commitment;
         return stateTo;
     }
-    proveTransaction(publicInput, stateProof, runtimeProof, executionData) {
+    async 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);
+        const stateTo = await this.applyTransaction(bundleInclusionState, stateProof, runtimeProof, executionData);
         return new BlockProverPublicOutput({
             ...stateTo,
             blockNumber: maxField(),
@@ -193,7 +190,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
         // Assert from state roots
         stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
     }
-    proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
+    async proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
         const state = {
             ...publicInput,
         };
@@ -220,8 +217,8 @@ export class BlockProverProgrammable extends ZkProgrammable {
         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);
+        const beforeBlockResult = await this.executeBlockHooks(state, networkState, "beforeBlock");
+        const beforeBlockHashList = new StateTransitionReductionList(ProvableStateTransition);
         beforeBlockResult.stateTransitions.forEach((st) => {
             beforeBlockHashList.push(st.toProvable());
         });
@@ -245,15 +242,15 @@ export class BlockProverProgrammable extends ZkProgrammable {
             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);
+        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 = stateTransitionProof.publicInput.stateRoot;
+        state.stateRoot = Provable.if(stsEmitted, stateTransitionProof.publicOutput.stateRoot, state.stateRoot);
         // 6. Close block
         // Calculate the new block index
         const blockIndex = blockWitness.calculateIndex();
@@ -271,7 +268,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
             closed: Bool(true),
         });
     }
-    merge(publicInput, proof1, proof2) {
+    async merge(publicInput, proof1, proof2) {
         proof1.verify();
         proof2.verify();
         // Check state
@@ -351,8 +348,10 @@ export class BlockProverProgrammable extends ZkProgrammable {
         const StateTransitionProofClass = stateTransitionProver.zkProgram.Proof;
         const RuntimeProofClass = runtime.zkProgram.Proof;
         const proveTransaction = prover.proveTransaction.bind(prover);
+        const proveBlock = prover.proveBlock.bind(prover);
         const merge = prover.merge.bind(prover);
-        const program = Experimental.ZkProgram({
+        const program = ZkProgram({
+            name: "BlockProver",
             publicInput: BlockProverPublicInput,
             publicOutput: BlockProverPublicOutput,
             methods: {
@@ -362,8 +361,19 @@ export class BlockProverProgrammable extends ZkProgrammable {
                         RuntimeProofClass,
                         BlockProverExecutionData,
                     ],
-                    method(publicInput, stateProof, appProof, executionData) {
-                        return proveTransaction(publicInput, stateProof, appProof, executionData);
+                    async method(publicInput, stateProof, appProof, executionData) {
+                        return await proveTransaction(publicInput, stateProof, appProof, executionData);
+                    },
+                },
+                proveBlock: {
+                    privateInputs: [
+                        NetworkState,
+                        BlockHashMerkleTreeWitness,
+                        StateTransitionProofClass,
+                        (SelfProof),
+                    ],
+                    async method(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof) {
+                        return await proveBlock(publicInput, networkState, blockWitness, stateTransitionProof, transactionProof);
                     },
                 },
                 merge: {
@@ -371,8 +381,8 @@ export class BlockProverProgrammable extends ZkProgrammable {
                         (SelfProof),
                         (SelfProof),
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return await merge(publicInput, proof1, proof2);
                     },
                 },
             },
@@ -381,10 +391,11 @@ export class BlockProverProgrammable extends ZkProgrammable {
             proveTransaction: program.proveTransaction,
             merge: program.merge,
         };
-        const SelfProofClass = Experimental.ZkProgram.Proof(program);
+        const SelfProofClass = ZkProgram.Proof(program);
         return {
             compile: program.compile.bind(program),
             verify: program.verify.bind(program),
+            analyzeMethods: program.analyzeMethods.bind(program),
             Proof: SelfProofClass,
             methods,
         };
@@ -394,7 +405,7 @@ __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object, BlockProverExecutionData]),
-    __metadata("design:returntype", BlockProverPublicOutput)
+    __metadata("design:returntype", Promise)
 ], BlockProverProgrammable.prototype, "proveTransaction", null);
 __decorate([
     provableMethod(),
@@ -402,20 +413,20 @@ __decorate([
     __metadata("design:paramtypes", [BlockProverPublicInput,
         NetworkState,
         BlockHashMerkleTreeWitness, Object, Object]),
-    __metadata("design:returntype", BlockProverPublicOutput)
+    __metadata("design:returntype", Promise)
 ], BlockProverProgrammable.prototype, "proveBlock", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
-    __metadata("design:returntype", BlockProverPublicOutput)
+    __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
  */
-let BlockProver = class BlockProver extends ProtocolModule {
+export let BlockProver = class BlockProver extends ProtocolModule {
     constructor(stateTransitionProver, runtime, transactionHooks, blockHooks) {
         super();
         this.stateTransitionProver = stateTransitionProver;
@@ -440,4 +451,3 @@ BlockProver = __decorate([
     __param(3, injectAll("ProvableBlockHook")),
     __metadata("design:paramtypes", [Object, Object, Array, Array])
 ], BlockProver);
-export { BlockProver };

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

@@ -1,36 +1,36 @@
-import { Bool } from "o1js";
-export type BlockTransactionPositionType = "FIRST" | "LAST" | "MIDDLE";
-declare const BlockTransactionPosition_base: (new (value: {
-    type: import("o1js/dist/node/lib/field").Field;
-}) => {
-    type: import("o1js/dist/node/lib/field").Field;
-}) & {
-    _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
-    type: import("o1js/dist/node/lib/field").Field;
-}> & {
-    toInput: (x: {
-        type: import("o1js/dist/node/lib/field").Field;
-    }) => {
-        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
-    };
-    toJSON: (x: {
-        type: import("o1js/dist/node/lib/field").Field;
-    }) => {
-        type: string;
-    };
-    fromJSON: (x: {
-        type: string;
-    }) => {
-        type: import("o1js/dist/node/lib/field").Field;
-    };
-};
-export declare class BlockTransactionPosition extends BlockTransactionPosition_base {
-    private static readonly fieldMapping;
-    static fromPositionType(type: BlockTransactionPositionType): BlockTransactionPosition;
-    static positionTypeFromIndex(index: number, bundleLength: number): BlockTransactionPositionType;
-    equals(type: BlockTransactionPosition): Bool;
-}
-export {};
+import { Bool } from "o1js";
+export type BlockTransactionPositionType = "FIRST" | "LAST" | "MIDDLE";
+declare const BlockTransactionPosition_base: (new (value: {
+    type: import("o1js/dist/node/lib/field").Field;
+}) => {
+    type: import("o1js/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    type: import("o1js/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        type: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        type: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        type: string;
+    };
+    fromJSON: (x: {
+        type: string;
+    }) => {
+        type: import("o1js/dist/node/lib/field").Field;
+    };
+};
+export declare class BlockTransactionPosition extends BlockTransactionPosition_base {
+    private static readonly fieldMapping;
+    static fromPositionType(type: BlockTransactionPositionType): BlockTransactionPosition;
+    static positionTypeFromIndex(index: number, bundleLength: number): BlockTransactionPositionType;
+    equals(type: BlockTransactionPosition): Bool;
+}
+export {};
 //# sourceMappingURL=BlockTransactionPosition.d.ts.map

package/dist/prover/block/BlockTransactionPosition.js

@@ -1,25 +1,25 @@
-import { Field, Struct } from "o1js";
-import { match } from "ts-pattern";
-export class BlockTransactionPosition extends Struct({
-    type: Field,
-}) {
-    static fromPositionType(type) {
-        return new BlockTransactionPosition({
-            type: Field(BlockTransactionPosition.fieldMapping[type]).toConstant(),
-        });
-    }
-    static positionTypeFromIndex(index, bundleLength) {
-        return match(index)
-            .with(0, () => "FIRST")
-            .with(bundleLength - 1, () => "LAST")
-            .otherwise(() => "MIDDLE");
-    }
-    equals(type) {
-        return this.type.equals(type.type);
-    }
-}
-BlockTransactionPosition.fieldMapping = {
-    FIRST: 0,
-    MIDDLE: 1,
-    LAST: 2,
-};
+import { Field, Struct } from "o1js";
+import { match } from "ts-pattern";
+export class BlockTransactionPosition extends Struct({
+    type: Field,
+}) {
+    static fromPositionType(type) {
+        return new BlockTransactionPosition({
+            type: Field(BlockTransactionPosition.fieldMapping[type]).toConstant(),
+        });
+    }
+    static positionTypeFromIndex(index, bundleLength) {
+        return match(index)
+            .with(0, () => "FIRST")
+            .with(bundleLength - 1, () => "LAST")
+            .otherwise(() => "MIDDLE");
+    }
+    equals(type) {
+        return this.type.equals(type.type);
+    }
+}
+BlockTransactionPosition.fieldMapping = {
+    FIRST: 0,
+    MIDDLE: 1,
+    LAST: 2,
+};

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

@@ -0,0 +1,36 @@
+import { Bool } from "o1js";
+export type BundleTransactionPositionType = "FIRST" | "LAST" | "MIDDLE";
+declare const BundleTransactionPosition_base: (new (value: {
+    type: import("o1js/dist/node/lib/field").Field;
+}) => {
+    type: import("o1js/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    type: import("o1js/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        type: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        type: import("o1js/dist/node/lib/field").Field;
+    }) => {
+        type: string;
+    };
+    fromJSON: (x: {
+        type: string;
+    }) => {
+        type: import("o1js/dist/node/lib/field").Field;
+    };
+};
+export declare class BundleTransactionPosition extends BundleTransactionPosition_base {
+    private static fieldMapping;
+    equals(type: BundleTransactionPosition): Bool;
+    static fromPositionType(type: BundleTransactionPositionType): BundleTransactionPosition;
+    static positionTypeFromIndex(index: number, bundleLength: number): BundleTransactionPositionType;
+}
+export {};
+//# sourceMappingURL=BundleTransactionPosition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BundleTransactionPosition.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BundleTransactionPosition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiB,MAAM,MAAM,CAAC;AAG3C,MAAM,MAAM,6BAA6B,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExE,qBAAa,yBAA0B,SAAQ,8BAE7C;IACA,OAAO,CAAC,MAAM,CAAC,YAAY,CAIzB;IAEK,MAAM,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI;WAItC,gBAAgB,CAAC,IAAI,EAAE,6BAA6B;WAMpD,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAMxE"}

package/dist/prover/block/BundleTransactionPosition.js

@@ -0,0 +1,25 @@
+import { Field, Struct } from "o1js";
+import { match } from "ts-pattern";
+export class BundleTransactionPosition extends Struct({
+    type: Field,
+}) {
+    equals(type) {
+        return this.type.equals(type.type);
+    }
+    static fromPositionType(type) {
+        return new BundleTransactionPosition({
+            type: Field(BundleTransactionPosition.fieldMapping[type]).toConstant(),
+        });
+    }
+    static positionTypeFromIndex(index, bundleLength) {
+        return match(index)
+            .with(0, () => "FIRST")
+            .with(bundleLength - 1, () => "LAST")
+            .otherwise(() => "MIDDLE");
+    }
+}
+BundleTransactionPosition.fieldMapping = {
+    FIRST: 0,
+    MIDDLE: 1,
+    LAST: 2,
+};

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

@@ -0,0 +1,11 @@
+import { StateService } from "../../state/StateService";
+/**
+ * This is an extension of the StateService, that allows the BlockProver
+ * to get state based on two different starting states. This is needed
+ * because the BlockProver executed before and after hooks on different roots
+ * and therefore needs the corresponding states, which change during execution
+ */
+export interface SplitPrefilledStateService extends StateService {
+    changeStateService: (index: number) => void;
+}
+//# sourceMappingURL=SplitPrefilledStateService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SplitPrefilledStateService.d.ts","sourceRoot":"","sources":["../../../src/prover/block/SplitPrefilledStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,0BAA2B,SAAQ,YAAY;IAC9D,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C"}

package/dist/prover/block/SplitPrefilledStateService.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import { StateService } from "../../state/StateService";
+/**
+ * This is an extension of the StateService, that allows the BlockProver
+ * to get state based on two different starting states. This is needed
+ * because the BlockProver executed before and after hooks on different roots
+ * and therefore needs the corresponding states, which change during execution
+ */
+export interface SplitStateService extends StateService {
+    changeStateService: (index: number) => void;
+}
+//# sourceMappingURL=SplitStateService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SplitStateService.d.ts","sourceRoot":"","sources":["../../../src/prover/block/SplitStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACrD,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C"}

package/dist/prover/block/SplitStateService.js

@@ -0,0 +1 @@
+export {};

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

@@ -5,27 +5,42 @@ 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/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
 }) => {
-    blockHash: import("o1js/dist/node/lib/field").Field;
-    closed: import("o1js/dist/node/lib/bool").Bool;
+    blockHash: import("o1js/dist/node/lib/provable/field").Field;
+    closed: import("o1js/dist/node/lib/provable/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;
-}> & {
+} & 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/field").Field;
-        closed: import("o1js/dist/node/lib/bool").Bool;
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
     }) => {
-        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+        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/field").Field;
-        closed: import("o1js/dist/node/lib/bool").Bool;
+        blockHash: import("o1js/dist/node/lib/provable/field").Field;
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
     }) => {
         blockHash: string;
         closed: boolean;
@@ -34,8 +49,12 @@ declare const BlockHashTreeEntry_base: (new (value: {
         blockHash: string;
         closed: boolean;
     }) => {
-        blockHash: import("o1js/dist/node/lib/field").Field;
-        closed: import("o1js/dist/node/lib/bool").Bool;
+        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 {

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

@@ -1 +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"}
+{"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

@@ -1,6 +1,6 @@
 import { createMerkleTree } from "@proto-kit/common";
 import { Bool, Field, Poseidon, Struct } from "o1js";
-export class BlockHashMerkleTree extends createMerkleTree(16) {
+export class BlockHashMerkleTree extends createMerkleTree(40) {
 }
 export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
 }

package/dist/prover/block/acummulators/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: {
+    transactionsHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}) => {
+    transactionsHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    transactionsHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+}> & {
+    toInput: (x: {
+        transactionsHash: 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: {
+        transactionsHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+    }) => {
+        transactionsHash: string;
+        closed: boolean;
+    };
+    fromJSON: (x: {
+        transactionsHash: string;
+        closed: boolean;
+    }) => {
+        transactionsHash: 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