@proto-kit/protocol 0.1.1-develop.340 → 0.1.1-develop.456

package/dist/prover/block/BlockProver.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 /* eslint-disable max-lines */
-import { Experimental, Field, Provable, SelfProof } from "o1js";
+import { Experimental, Field, Provable, SelfProof, } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { DefaultProvableHashList } from "../../utils/ProvableHashList";
@@ -20,6 +20,8 @@ import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
+import { NetworkState } from "../../model/network/NetworkState";
+import { BlockTransactionPosition } from "./BlockTransactionPosition";
 const errors = {
     stateProofNotStartingAtZero: () => "StateProof not starting ST-commitment at zero",
     stateTransitionsHashNotEqual: () => "StateTransition list commitments are not equal",
@@ -30,12 +32,13 @@ const errors = {
 export class BlockProverProgrammable extends ZkProgrammable {
     constructor(
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    prover, stateTransitionProver, runtime, blockModules) {
+    prover, stateTransitionProver, runtime, transactionHooks, blockHooks) {
         super();
         this.prover = prover;
         this.stateTransitionProver = stateTransitionProver;
         this.runtime = runtime;
-        this.blockModules = blockModules;
+        this.transactionHooks = transactionHooks;
+        this.blockHooks = blockHooks;
     }
     get appChain() {
         return this.prover.appChain;
@@ -75,11 +78,6 @@ export class BlockProverProgrammable extends ZkProgrammable {
         // 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;
     }
     // eslint-disable-next-line no-warning-comments, max-len
@@ -95,7 +93,7 @@ export class BlockProverProgrammable extends ZkProgrammable {
             networkState: executionData.networkState,
         });
         executionContext.beforeMethod("", "", []);
-        this.blockModules.forEach((module) => {
+        this.transactionHooks.forEach((module) => {
             module.onTransaction(executionData);
         });
         executionContext.afterMethod();
@@ -108,16 +106,68 @@ export class BlockProverProgrammable extends ZkProgrammable {
         });
         stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(hashList.commitment, "ProtocolTransitionsHash not matching the generated protocol transitions");
     }
+    getBeforeBlockNetworkState(state, networkState) {
+        return this.blockHooks.reduce((networkState, blockHook) => {
+            return blockHook.beforeBlock({
+                state,
+                networkState,
+            });
+        }, networkState);
+    }
+    getAfterBlockNetworkState(state, networkState) {
+        return this.blockHooks.reduce((networkState, blockHook) => {
+            return blockHook.afterBlock({
+                state,
+                networkState,
+            });
+        }, networkState);
+    }
+    addTransactionToBundle(state, stateTransitionProof, appProof, executionData) {
+        const { transactionPosition, networkState } = executionData;
+        const stateTo = {
+            ...state,
+        };
+        // Execute beforeBlook hooks and apply if it is the first tx of the bundle
+        const beforeHookResult = this.getBeforeBlockNetworkState(state, networkState);
+        const bundleOpened = transactionPosition.equals(BlockTransactionPosition.fromPositionType("FIRST"));
+        const resultingNetworkState = new NetworkState(Provable.if(bundleOpened, NetworkState, beforeHookResult, networkState));
+        stateTo.networkStateHash = resultingNetworkState.hash();
+        // TODO Modify bundle merkle tree as per specs
+        // Append tx to transaction list
+        const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
+        const { transactionHash } = appProof.publicOutput;
+        transactionList.push(transactionHash);
+        stateTo.transactionsHash = transactionList.commitment;
+        return {
+            state: stateTo,
+            networkState: resultingNetworkState,
+            bundleOpened,
+            bundleClosed: transactionPosition.equals(BlockTransactionPosition.fromPositionType("LAST")),
+        };
+    }
     proveTransaction(publicInput, stateProof, appProof, executionData) {
         const state = {
             transactionsHash: publicInput.transactionsHash,
             stateRoot: publicInput.stateRoot,
             networkStateHash: publicInput.networkStateHash,
         };
-        const stateTo = this.applyTransaction(state, stateProof, appProof, executionData);
+        const bundleInclusionResult = this.addTransactionToBundle(state, stateProof, appProof, executionData);
+        const stateTo = this.applyTransaction(bundleInclusionResult.state, stateProof, appProof, {
+            transaction: executionData.transaction,
+            transactionPosition: executionData.transactionPosition,
+            networkState: bundleInclusionResult.networkState,
+        });
+        // Apply afterBlock hooks
+        const afterBlockNetworkState = this.getAfterBlockNetworkState(stateTo, bundleInclusionResult.networkState);
+        const bundleClosed = executionData.transactionPosition.equals(BlockTransactionPosition.fromPositionType("LAST"));
+        // We only need the hash here since this computed networkstate
+        // is only used as an input in the next bundle
+        const resultingNetworkStateHash = Provable.if(bundleClosed, afterBlockNetworkState.hash(), stateTo.networkStateHash);
         return new BlockProverPublicOutput({
             stateRoot: stateTo.stateRoot,
             transactionsHash: stateTo.transactionsHash,
+            // eslint-disable-next-line putout/putout
+            networkStateHash: resultingNetworkStateHash,
         });
     }
     merge(publicInput, proof1, proof2) {
@@ -131,10 +181,11 @@ export class BlockProverProgrammable extends ZkProgrammable {
         proof1.publicOutput.transactionsHash.assertEquals(proof2.publicInput.transactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
         // Check networkhash
         publicInput.networkStateHash.assertEquals(proof1.publicInput.networkStateHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
-        publicInput.networkStateHash.assertEquals(proof2.publicInput.networkStateHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        proof1.publicOutput.networkStateHash.assertEquals(proof2.publicInput.networkStateHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
         return new BlockProverPublicOutput({
             stateRoot: proof2.publicOutput.stateRoot,
             transactionsHash: proof2.publicOutput.transactionsHash,
+            networkStateHash: proof2.publicOutput.networkStateHash,
         });
     }
     /**
@@ -204,13 +255,11 @@ __decorate([
  * then be merged to be committed to the base-layer contract
  */
 let BlockProver = class BlockProver extends ProtocolModule {
-    constructor(stateTransitionProver, runtime, transactionHooks) {
+    constructor(stateTransitionProver, runtime, transactionHooks, blockHooks) {
         super();
         this.stateTransitionProver = stateTransitionProver;
         this.runtime = runtime;
-        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks
-        // protocol.dependencyContainer.resolveAll("P rovableTransactionHook")
-        );
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks, blockHooks);
     }
     merge(publicInput, proof1, proof2) {
         return this.zkProgrammable.merge(publicInput, proof1, proof2);
@@ -224,6 +273,7 @@ BlockProver = __decorate([
     __param(0, inject("StateTransitionProver")),
     __param(1, inject("Runtime")),
     __param(2, injectAll("ProvableTransactionHook")),
-    __metadata("design:paramtypes", [Object, Object, Array])
+    __param(3, injectAll("ProvableBlockHook")),
+    __metadata("design:paramtypes", [Object, Object, Array, Array])
 ], BlockProver);
 export { BlockProver };

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

@@ -0,0 +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 {};
+//# sourceMappingURL=BlockTransactionPosition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlockTransactionPosition.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockTransactionPosition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiB,MAAM,MAAM,CAAC;AAG3C,MAAM,MAAM,4BAA4B,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvE,qBAAa,wBAAyB,SAAQ,6BAE5C;IACA,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAOlC;WAEY,gBAAgB,CAAC,IAAI,EAAE,4BAA4B;WAMnD,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAOhE,MAAM,CAAC,IAAI,EAAE,wBAAwB,GAAG,IAAI;CAGpD"}

package/dist/prover/block/BlockTransactionPosition.js

@@ -0,0 +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,
+};

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

@@ -39,7 +39,7 @@ export declare class StateTransitionProverProgrammable extends ZkProgrammable<St
     runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
     merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
 }
-export declare class StateTransitionProver extends ProtocolModule<object> implements StateTransitionProvable {
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable {
     readonly witnessProviderReference: StateTransitionWitnessProviderReference;
     readonly zkProgrammable: StateTransitionProverProgrammable;
     constructor(witnessProviderReference: StateTransitionWitnessProviderReference);

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

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,EAAuB,MAAM,MAAM,CAAC;AAEtE,OAAO,EACL,gBAAgB,EAEhB,cAAc,EAEd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAqDX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAkB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAqErC;AAED,qBACa,qBACX,SAAQ,cAAc,CAAC,MAAM,CAC7B,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,EAAuB,MAAM,MAAM,CAAC;AAEtE,OAAO,EACL,gBAAgB,EAEhB,cAAc,EAGd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAiDX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAkB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAqErC;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -10,8 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 /* eslint-disable max-lines */
 import { Experimental, Field, Provable, SelfProof } from "o1js";
 import { injectable } from "tsyringe";
-import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
-import { MerkleTreeUtils, RollupMerkleWitness, } from "../../utils/merkletree/RollupMerkleTree.js";
+import { provableMethod, RollupMerkleTreeWitness, ZkProgrammable, } from "@proto-kit/common";
 import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import { StateTransitionProvableBatch, } from "../../model/StateTransitionProvableBatch";
@@ -107,12 +106,12 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
      * and mutates it in place
      */
     applyTransition(state, transition, type, index = 0) {
-        const treeWitness = Provable.witness(RollupMerkleWitness, () => this.witnessProvider.getWitness(transition.path));
-        const membershipValid = MerkleTreeUtils.checkMembership(treeWitness, state.stateRoot, transition.path, transition.from.value);
+        const witness = Provable.witness(RollupMerkleTreeWitness, () => this.witnessProvider.getWitness(transition.path));
+        const membershipValid = witness.checkMembership(state.stateRoot, transition.path, transition.from.value);
         membershipValid
             .or(transition.from.isSome.not())
             .assertTrue(errors.merkleWitnessNotCorrect(index, type.isNormal().toBoolean() ? "normal" : "protocol"));
-        const newRoot = MerkleTreeUtils.computeRoot(treeWitness, transition.to.value);
+        const newRoot = witness.calculateRoot(transition.to.value);
         state.stateRoot = Provable.if(transition.to.isSome, newRoot, state.stateRoot);
         // Only update protocol state root if ST is also of type protocol
         // Since protocol STs are all at the start of the batch, this works

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

@@ -1,5 +1,5 @@
 import type { Field } from "o1js";
-import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
 /**
  * Interface for providing merkle witnesses to the state-transition prover
  */
@@ -8,9 +8,9 @@ export interface StateTransitionWitnessProvider {
      * Provides the merkle witness corresponding to the given key
      * @param key Merkle-tree key
      */
-    getWitness: (key: Field) => RollupMerkleWitness;
+    getWitness: (key: Field) => RollupMerkleTreeWitness;
 }
 export declare class NoOpStateTransitionWitnessProvider implements StateTransitionWitnessProvider {
-    getWitness(): RollupMerkleWitness;
+    getWitness(): RollupMerkleTreeWitness;
 }
 //# sourceMappingURL=StateTransitionWitnessProvider.d.ts.map

package/dist/prover/statetransition/StateTransitionWitnessProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionWitnessProvider.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionWitnessProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAGlC,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,mBAAmB,CAAC;CACjD;AAED,qBACa,kCACX,YAAW,8BAA8B;IAElC,UAAU,IAAI,mBAAmB;CAGzC"}
+{"version":3,"file":"StateTransitionWitnessProvider.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionWitnessProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,uBAAuB,CAAC;CACrD;AAED,qBACa,kCACX,YAAW,8BAA8B;IAElC,UAAU,IAAI,uBAAuB;CAG7C"}

package/dist/prover/statetransition/StateTransitionWitnessProvider.js

@@ -5,10 +5,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from "tsyringe";
-import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
 let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
     getWitness() {
-        return new RollupMerkleWitness({ path: [], isLeft: [] });
+        return new RollupMerkleTreeWitness({ path: [], isLeft: [] });
     }
 };
 NoOpStateTransitionWitnessProvider = __decorate([

package/dist/state/State.d.ts

@@ -28,6 +28,13 @@ export declare class State<Value> extends State_base {
      */
     static from<Value>(valueType: FlexibleProvablePure<Value>): State<Value>;
     constructor(valueType: FlexibleProvablePure<Value>);
+    /**
+     * Returns the state that is currently the current state tree
+     * value: The value-fields, or if not state was found, dummy values
+     * isSome: Whether the values where found in the state or not
+     * (Basically, whether the value-fields are dummy values or actual values
+     * @private
+     */
     private getState;
     /**
      * Provides an in-circuit witness for the current state representation,
@@ -35,7 +42,7 @@ export declare class State<Value> extends State_base {
      *
      * @returns Optional value of the current state
      */
-    private witnessState;
+    private witnessFromState;
     /**
      * Retrieves the current state and creates a state transition
      * anchoring the use of the current state value in the circuit.

package/dist/state/State.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAIxE,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,wBAAwB;IAC5B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAE5C,qBAAqB,IAAI,OAAO,CAAC,IAAI,IAAI;QAC9C,oBAAoB,EAAE,oBAAoB,CAAC;KAC5C;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAAyC;IAW/C,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAVhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;gBAItC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE,OAAO,CAAC,QAAQ;IAuChB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;OAKG;IACI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;IAc3B;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK;CAiBxB"}
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAIxE,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,wBAAwB;IAC5B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAE5C,qBAAqB,IAAI,OAAO,CAAC,IAAI,IAAI;QAC9C,oBAAoB,EAAE,oBAAoB,CAAC;KAC5C;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAAyC;IAW/C,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAVhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;gBAItC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAuChB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;OAKG;IACI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;IAc3B;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK;CAiBxB"}

package/dist/state/State.js

@@ -36,6 +36,13 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
         super();
         this.valueType = valueType;
     }
+    /**
+     * Returns the state that is currently the current state tree
+     * value: The value-fields, or if not state was found, dummy values
+     * isSome: Whether the values where found in the state or not
+     * (Basically, whether the value-fields are dummy values or actual values
+     * @private
+     */
     getState() {
         this.hasStateServiceOrFail();
         this.hasPathOrFail();
@@ -70,7 +77,7 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @returns Optional value of the current state
      */
-    witnessState() {
+    witnessFromState() {
         // get the value from storage, or return a dummy value instead
         const value = Provable.witness(this.valueType, () => this.getState().value);
         // check if the value exists in the storage or not
@@ -84,7 +91,7 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      * @returns Option representation of the current state.
      */
     get() {
-        const option = this.witnessState();
+        const option = this.witnessFromState();
         this.hasPathOrFail();
         const stateTransition = StateTransition.from(this.path, option);
         container
@@ -105,8 +112,8 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      */
     set(value) {
         // link the transition to the current state
-        const fromOption = this.witnessState();
-        const toOption = Option.from(Bool(true), value, this.valueType);
+        const fromOption = this.witnessFromState();
+        const toOption = Option.fromValue(value, this.valueType);
         this.hasPathOrFail();
         const stateTransition = StateTransition.fromTo(this.path, fromOption, toOption);
         container

package/dist/state/StateServiceProvider.d.ts

@@ -1,8 +1,6 @@
 import { StateService } from "./StateService";
 export declare class StateServiceProvider {
-    private readonly baseStateService?;
     private readonly stateServiceStack;
-    constructor(baseStateService?: StateService | undefined);
     get stateService(): StateService;
     setCurrentStateService(service: StateService): void;
     popCurrentStateService(): void;

package/dist/state/StateServiceProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAU9C,qBACa,oBAAoB;IAIL,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAH5D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;gBAGb,gBAAgB,CAAC,0BAAc;IAO1E,IAAW,YAAY,IAAI,YAAY,CAQtC;IAEM,sBAAsB,CAAC,OAAO,EAAE,YAAY;IAI5C,sBAAsB;CAO9B"}
+{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAU9C,qBACa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;IAExD,IAAW,YAAY,IAAI,YAAY,CAQtC;IAEM,sBAAsB,CAAC,OAAO,EAAE,YAAY;IAI5C,sBAAsB;CAO9B"}

package/dist/state/StateServiceProvider.js

@@ -4,24 +4,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { inject, injectable } from "tsyringe";
+import { injectable } from "tsyringe";
 import { log } from "@proto-kit/common";
 const errors = {
     stateServiceNotSet: () => new Error("StateService has not been set yet. Be sure to either call your runtime or protocol function by creating them with an AppChain or by setting the stateService manually."),
 };
 let StateServiceProvider = class StateServiceProvider {
-    constructor(baseStateService) {
-        this.baseStateService = baseStateService;
+    constructor() {
         this.stateServiceStack = [];
-        if (baseStateService !== undefined) {
-            this.stateServiceStack.push(baseStateService);
-        }
     }
     get stateService() {
         if (this.stateServiceStack.length === 0) {
@@ -35,16 +25,14 @@ let StateServiceProvider = class StateServiceProvider {
         this.stateServiceStack.push(service);
     }
     popCurrentStateService() {
-        if (this.stateServiceStack.length === 1) {
-            log.trace("Trying to pop last available (root) stateservice");
+        if (this.stateServiceStack.length === 0) {
+            log.trace("Trying to pop from empty state-service stack");
             return;
         }
         this.stateServiceStack.pop();
     }
 };
 StateServiceProvider = __decorate([
-    injectable(),
-    __param(0, inject("StateService")),
-    __metadata("design:paramtypes", [Object])
+    injectable()
 ], StateServiceProvider);
 export { StateServiceProvider };

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.340+730512d",
+  "version": "0.1.1-develop.456+bdb345d",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -25,11 +25,12 @@
   "peerDependencies": {
     "@proto-kit/common": "*",
     "o1js": "0.13.1",
+    "ts-pattern": "^4.3.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "730512da45bf47d359a259ea24b357a17f610548"
+  "gitHead": "bdb345d9e6132387a870c8a4236d8fe295502ce4"
 }

package/src/blockmodules/AccountStateModule.ts

@@ -1,4 +1,4 @@
-import { Provable, PublicKey, Struct, UInt64 } from "o1js";
+import { PublicKey, Struct, UInt64 } from "o1js";
 
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 import { StateMap } from "../state/StateMap";
@@ -10,7 +10,7 @@ export class AccountState extends Struct({
   nonce: UInt64,
 }) {}
 
-export class AccountStateModule extends ProvableTransactionHook<Record<string, never>> {
+export class AccountStateModule extends ProvableTransactionHook {
   @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
     PublicKey,
     AccountState

package/src/blockmodules/BlockHeightHook.ts

@@ -0,0 +1,21 @@
+import { Provable } from "o1js";
+import { NetworkState } from "../model/network/NetworkState";
+import {
+  AfterBlockParameters,
+  BeforeBlockParameters,
+  ProvableBlockHook,
+} from "../protocol/ProvableBlockHook";
+
+export class BlockHeightHook extends ProvableBlockHook<Record<string, never>> {
+  public afterBlock({ networkState }: AfterBlockParameters): NetworkState {
+    return new NetworkState({
+      block: {
+        height: networkState.block.height.add(1),
+      },
+    });
+  }
+
+  public beforeBlock(blockData: BeforeBlockParameters): NetworkState {
+    return blockData.networkState;
+  }
+}

package/src/blockmodules/NoopBlockHook.ts

@@ -0,0 +1,16 @@
+import {
+  AfterBlockParameters,
+  BeforeBlockParameters,
+  ProvableBlockHook
+} from "../protocol/ProvableBlockHook";
+import { NetworkState } from "../model/network/NetworkState";
+
+export class NoopBlockHook extends ProvableBlockHook<Record<string, never>>{
+  public afterBlock(blockData: AfterBlockParameters): NetworkState {
+    return blockData.networkState;
+  }
+
+  public beforeBlock(blockData: BeforeBlockParameters): NetworkState {
+    return blockData.networkState;
+  }
+}

package/src/blockmodules/NoopTransactionHook.ts

@@ -1,7 +1,6 @@
 import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 
-export class NoopTransactionHook extends ProvableTransactionHook<object> {
-  public onTransaction(executionData: BlockProverExecutionData): void {
-  }
-}
+export class NoopTransactionHook extends ProvableTransactionHook {
+  public onTransaction(executionData: BlockProverExecutionData): void {}
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./blockmodules/AccountStateModule";
+export * from "./blockmodules/BlockHeightHook";
 export * from "./utils/ProvableHashList";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
@@ -11,18 +12,17 @@ export * from "./utils/PrefixedProvableHashList.js";
 export * from "./utils/utils";
 export * from "./prover/block/BlockProver";
 export * from "./prover/block/BlockProvable";
+export * from "./prover/block/BlockTransactionPosition";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
 export * from "./prover/statetransition/StateTransitionWitnessProvider";
-export * from "./utils/merkletree/MerkleTreeStore";
-export * from "./utils/merkletree/InMemoryMerkleTreeStorage";
-export * from "./utils/merkletree/RollupMerkleTree";
 export * from "./model/MethodPublicOutput";
 export * from "./prover/statetransition/StateTransitionWitnessProviderReference";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
-export * from "./protocol/TransitioningProtocolModule";
+export * from "./protocol/ProtocolEnvironment";
 export * from "./protocol/ProvableTransactionHook";
+export * from "./protocol/ProvableBlockHook";
 export * from "./state/context/ProtocolMethodExecutionContext";
 export * from "./state/context/TransitionMethodExecutionContext";
 export * from "./state/context/RuntimeMethodExecutionContext";