@proto-kit/protocol 0.1.1-develop.336 → 0.1.1-develop.455

package/dist/protocol/Protocol.d.ts

@@ -1,18 +1,16 @@
 import { AreProofsEnabled, ChildContainerProvider, ModuleContainer, ModulesConfig, ModulesRecord, StringKeyOf, TypedClass } from "@proto-kit/common";
 import { DependencyContainer } from "tsyringe";
 import { BlockProvable } from "../prover/block/BlockProvable";
-import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
 import { StateTransitionProvable } from "../prover/statetransition/StateTransitionProvable";
-import { BlockProver } from "../prover/block/BlockProver";
 import { StateServiceProvider } from "../state/StateServiceProvider";
 import { StateService } from "../state/StateService";
 import { ProtocolModule } from "./ProtocolModule";
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
 import { AccountStateModule } from "../blockmodules/AccountStateModule";
 export type GenericProtocolModuleRecord = ModulesRecord<TypedClass<ProtocolModule<unknown>>>;
-interface BlockProverType extends ProtocolModule<object>, BlockProvable {
+interface BlockProverType extends ProtocolModule, BlockProvable {
 }
-interface StateTransitionProverType extends ProtocolModule<object>, StateTransitionProvable {
+interface StateTransitionProverType extends ProtocolModule, StateTransitionProvable {
 }
 export interface ProtocolCustomModulesRecord {
     BlockProver: TypedClass<BlockProverType>;
@@ -40,20 +38,8 @@ export declare class Protocol<Modules extends ProtocolModulesRecord> extends Mod
     create(childContainerProvider: ChildContainerProvider): void;
 }
 export declare const VanillaProtocol: {
-    create(): TypedClass<Protocol<{
-        StateTransitionProver: typeof StateTransitionProver;
-        BlockProver: typeof BlockProver;
-        AccountState: typeof AccountStateModule;
-    }>>;
-    from<AdditonalModules extends GenericProtocolModuleRecord>(additionalModules: AdditonalModules, config: ModulesConfig<AdditonalModules & {
-        StateTransitionProver: typeof StateTransitionProver;
-        BlockProver: typeof BlockProver;
-        AccountState: typeof AccountStateModule;
-    }>): TypedClass<Protocol<AdditonalModules & {
-        StateTransitionProver: typeof StateTransitionProver;
-        BlockProver: typeof BlockProver;
-        AccountState: typeof AccountStateModule;
-    }>>;
+    create(): TypedClass<Protocol<ProtocolModulesRecord>>;
+    from<AdditonalModules extends GenericProtocolModuleRecord>(additionalModules: AdditonalModules): TypedClass<Protocol<ProtocolModulesRecord>>;
 };
 export {};
 //# sourceMappingURL=Protocol.d.ts.map

package/dist/protocol/Protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../src/protocol/Protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EAEtB,eAAe,EACf,aAAa,EACb,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAa,MAAM,UAAU,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AACxF,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC5F,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CACpC,CAAC;AAEF,UAAU,eAAgB,SAAQ,cAAc,CAAC,MAAM,CAAC,EAAE,aAAa;CAAG;AAE1E,UAAU,yBACR,SAAQ,cAAc,CAAC,MAAM,CAAC,EAC5B,uBAAuB;CAAG;AAE9B,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;IAC7D,YAAY,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,qBACf,SAAQ,2BAA2B,EACjC,2BAA2B;CAAG;AAElC,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,qBAAqB;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,QAAQ,CAAC,OAAO,SAAS,qBAAqB,CACzD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,mBAAmB;WAGhB,IAAI,CAAC,OAAO,SAAS,qBAAqB,EACtD,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC,GACnC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAQzB,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;gBAE5B,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC;IAK1D,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAEM,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAY9D,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED,OAAO,CAAC,QAAQ;IAMhB,IAAW,WAAW,IAAI,aAAa,CAMtC;IAED,IAAW,qBAAqB,IAAI,uBAAuB,CAI1D;IAEM,mBAAmB,IAAI,gBAAgB;IAIvC,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;CA0B7D;AAED,eAAO,MAAM,eAAe;;+BAwBG,4BAA4B;qBACtC,kBAAkB;sBACjB,yBAAyB;;;+BAVhB,4BAA4B;qBACtC,kBAAkB;sBACjB,yBAAyB;;+BAMhB,4BAA4B;qBACtC,kBAAkB;sBACjB,yBAAyB;;CAe9C,CAAC"}
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../src/protocol/Protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EAEtB,eAAe,EACf,aAAa,EACb,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAa,MAAM,UAAU,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAE5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAUxE,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CACpC,CAAC;AAEF,UAAU,eAAgB,SAAQ,cAAc,EAAE,aAAa;CAAG;AAElE,UAAU,yBACR,SAAQ,cAAc,EACpB,uBAAuB;CAAG;AAE9B,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;IAC7D,YAAY,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,qBACf,SAAQ,2BAA2B,EACjC,2BAA2B;CAAG;AAElC,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,qBAAqB;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,QAAQ,CAAC,OAAO,SAAS,qBAAqB,CACzD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,mBAAmB;WAGhB,IAAI,CAAC,OAAO,SAAS,qBAAqB,EACtD,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC,GACnC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAQzB,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;gBAE5B,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC;IAK1D,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAEM,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAY9D,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED,OAAO,CAAC,QAAQ;IAMhB,IAAW,WAAW,IAAI,aAAa,CAMtC;IAED,IAAW,qBAAqB,IAAI,uBAAuB,CAI1D;IAEM,mBAAmB,IAAI,gBAAgB;IAIvC,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;CA0C7D;AAED,eAAO,MAAM,eAAe;;qGAOvB,WAAW,SAAS,qBAAqB,CAAC,CAAC;CAW/C,CAAC"}

package/dist/protocol/Protocol.js

@@ -5,6 +5,13 @@ import { BlockProver } from "../prover/block/BlockProver";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
 import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
 import { AccountStateModule } from "../blockmodules/AccountStateModule";
+import { ProvableBlockHook } from "./ProvableBlockHook";
+import { NoopBlockHook } from "../blockmodules/NoopBlockHook";
+import { BlockHeightHook } from "../blockmodules/BlockHeightHook";
+const PROTOCOL_INJECTION_TOKENS = {
+    ProvableTransactionHook: "ProvableTransactionHook",
+    ProvableBlockHook: "ProvableBlockHook",
+};
 export class Protocol extends ModuleContainer {
     // .from() to create Protocol
     static from(modules) {
@@ -54,35 +61,39 @@ export class Protocol extends ModuleContainer {
         // Register the BlockModules seperately since we need to
         // inject them differently later
         let atLeastOneTransactionHookRegistered = false;
+        let atLeastOneBlockHookRegistered = false;
         Object.entries(this.definition.modules).forEach(([key, value]) => {
             if (Object.prototype.isPrototypeOf.call(ProvableTransactionHook, value)) {
-                this.container.register("ProvableTransactionHook", { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
+                this.container.register(PROTOCOL_INJECTION_TOKENS.ProvableTransactionHook, { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
                 atLeastOneTransactionHookRegistered = true;
             }
+            if (Object.prototype.isPrototypeOf.call(ProvableBlockHook, value)) {
+                this.container.register(PROTOCOL_INJECTION_TOKENS.ProvableBlockHook, { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
+                atLeastOneBlockHookRegistered = true;
+            }
         });
         // We need this so that tsyringe doesn't throw when no hooks are registered
         if (!atLeastOneTransactionHookRegistered) {
-            this.container.register("ProvableTransactionHook", { useClass: NoopTransactionHook }, { lifecycle: Lifecycle.ContainerScoped });
+            this.container.register(PROTOCOL_INJECTION_TOKENS.ProvableTransactionHook, { useClass: NoopTransactionHook }, { lifecycle: Lifecycle.ContainerScoped });
+        }
+        if (!atLeastOneBlockHookRegistered) {
+            this.container.register(PROTOCOL_INJECTION_TOKENS.ProvableBlockHook, { useClass: NoopBlockHook }, { lifecycle: Lifecycle.ContainerScoped });
         }
     }
 }
 export const VanillaProtocol = {
     create() {
-        return VanillaProtocol.from({}, {
-            BlockProver: {},
-            StateTransitionProver: {},
-            AccountState: {},
-        });
+        return VanillaProtocol.from({});
     },
-    from(additionalModules, config) {
+    from(additionalModules) {
         return Protocol.from({
             modules: {
                 StateTransitionProver,
                 BlockProver,
                 AccountState: AccountStateModule,
+                BlockHeight: BlockHeightHook,
                 ...additionalModules,
             },
-            config,
         });
     },
 };

package/dist/protocol/ProtocolModule.d.ts

@@ -1,6 +1,6 @@
-import { AreProofsEnabled, ChildContainerProvider, ConfigurableModule } from "@proto-kit/common";
+import { AreProofsEnabled, ChildContainerProvider, ConfigurableModule, NoConfig } from "@proto-kit/common";
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
-export declare abstract class ProtocolModule<Config> extends ConfigurableModule<Config> {
+export declare abstract class ProtocolModule<Config = NoConfig> extends ConfigurableModule<Config> {
     protocol?: ProtocolEnvironment;
     get appChain(): AreProofsEnabled | undefined;
     create(childContainerProvider: ChildContainerProvider): void;

package/dist/protocol/ProtocolModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,8BAAsB,cAAc,CAClC,MAAM,CACN,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAEtC,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAGM,MAAM,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,IAAI;CAGpE"}
+{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAAE,QAAQ,EAE7B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,8BAAsB,cAAc,CAClC,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAEtC,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAGM,MAAM,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,IAAI;CAGpE"}

package/dist/protocol/ProtocolModule.js

@@ -1,4 +1,4 @@
-import { ConfigurableModule, noop, } from "@proto-kit/common";
+import { ConfigurableModule, noop } from "@proto-kit/common";
 export class ProtocolModule extends ConfigurableModule {
     get appChain() {
         return this.protocol?.getAreProofsEnabled();

package/dist/protocol/ProvableBlockHook.d.ts

@@ -0,0 +1,16 @@
+import type { BlockProverState } from "../prover/block/BlockProver";
+import { NetworkState } from "../model/network/NetworkState";
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export interface BeforeBlockParameters {
+    state: BlockProverState;
+    networkState: NetworkState;
+}
+export interface AfterBlockParameters {
+    state: BlockProverState;
+    networkState: NetworkState;
+}
+export declare abstract class ProvableBlockHook<Config> extends TransitioningProtocolModule<Config> {
+    abstract beforeBlock(blockData: BeforeBlockParameters): NetworkState;
+    abstract afterBlock(blockData: AfterBlockParameters): NetworkState;
+}
+//# sourceMappingURL=ProvableBlockHook.d.ts.map

package/dist/protocol/ProvableBlockHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableBlockHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableBlockHook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,gBAAgB,CAAC;IACxB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,gBAAgB,CAAC;IACxB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAGD,8BAAsB,iBAAiB,CACrC,MAAM,CACN,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC3B,WAAW,CAAC,SAAS,EAAE,qBAAqB,GAAG,YAAY;aAC3D,UAAU,CAAC,SAAS,EAAE,oBAAoB,GAAG,YAAY;CAC1E"}

package/dist/protocol/ProvableBlockHook.js

@@ -0,0 +1,4 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+// Purpose is to validate transition from -> to network state
+export class ProvableBlockHook extends TransitioningProtocolModule {
+}

package/dist/protocol/ProvableTransactionHook.d.ts

@@ -1,6 +1,7 @@
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
-export declare abstract class ProvableTransactionHook<Config> extends TransitioningProtocolModule<Config> {
+import { NoConfig } from "@proto-kit/common";
+export declare abstract class ProvableTransactionHook<Config = NoConfig> extends TransitioningProtocolModule<Config> {
     abstract onTransaction(executionData: BlockProverExecutionData): void;
 }
 //# sourceMappingURL=ProvableTransactionHook.d.ts.map

package/dist/protocol/ProvableTransactionHook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProvableTransactionHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableTransactionHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,8BAAsB,uBAAuB,CAAC,MAAM,CAAE,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC/E,aAAa,CAAC,aAAa,EAAE,wBAAwB,GAAG,IAAI;CAC7E"}
+{"version":3,"file":"ProvableTransactionHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableTransactionHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,8BAAsB,uBAAuB,CAC3C,MAAM,GAAG,QAAQ,CACjB,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC3B,aAAa,CAAC,aAAa,EAAE,wBAAwB,GAAG,IAAI;CAC7E"}

package/dist/protocol/TransitioningProtocolModule.d.ts

@@ -1,4 +1,8 @@
 import { ProtocolModule } from "./ProtocolModule";
+/**
+ * A Protocolmodule that enables it's implementing module to access to
+ * StateTransitions and state
+ */
 export declare abstract class TransitioningProtocolModule<Config> extends ProtocolModule<Config> {
     name?: string;
 }

package/dist/protocol/TransitioningProtocolModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransitioningProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/TransitioningProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,8BAAsB,2BAA2B,CAC/C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACtB"}
+{"version":3,"file":"TransitioningProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/TransitioningProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;GAGG;AACH,8BAAsB,2BAA2B,CAC/C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/protocol/TransitioningProtocolModule.js

@@ -1,3 +1,7 @@
 import { ProtocolModule } from "./ProtocolModule";
+/**
+ * A Protocolmodule that enables it's implementing module to access to
+ * StateTransitions and state
+ */
 export class TransitioningProtocolModule extends ProtocolModule {
 }

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

@@ -4,6 +4,7 @@ import { StateTransitionProof } from "../statetransition/StateTransitionProvable
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
 import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
+import { BlockTransactionPosition } from "./BlockTransactionPosition";
 declare const BlockProverPublicInput_base: (new (value: {
     transactionsHash: import("o1js/dist/node/lib/field").Field;
     stateRoot: import("o1js/dist/node/lib/field").Field;
@@ -51,18 +52,22 @@ export declare class BlockProverPublicInput extends BlockProverPublicInput_base
 declare const BlockProverPublicOutput_base: (new (value: {
     transactionsHash: import("o1js/dist/node/lib/field").Field;
     stateRoot: import("o1js/dist/node/lib/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/field").Field;
 }) => {
     transactionsHash: import("o1js/dist/node/lib/field").Field;
     stateRoot: import("o1js/dist/node/lib/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/field").Field;
 }) & {
     _isStruct: true;
 } & import("o1js/dist/node/snarky").ProvablePure<{
     transactionsHash: import("o1js/dist/node/lib/field").Field;
     stateRoot: import("o1js/dist/node/lib/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/field").Field;
 }> & {
     toInput: (x: {
         transactionsHash: import("o1js/dist/node/lib/field").Field;
         stateRoot: import("o1js/dist/node/lib/field").Field;
+        networkStateHash: 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;
@@ -70,16 +75,20 @@ declare const BlockProverPublicOutput_base: (new (value: {
     toJSON: (x: {
         transactionsHash: import("o1js/dist/node/lib/field").Field;
         stateRoot: import("o1js/dist/node/lib/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/field").Field;
     }) => {
         transactionsHash: string;
         stateRoot: string;
+        networkStateHash: string;
     };
     fromJSON: (x: {
         transactionsHash: string;
         stateRoot: string;
+        networkStateHash: string;
     }) => {
         transactionsHash: import("o1js/dist/node/lib/field").Field;
         stateRoot: import("o1js/dist/node/lib/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/field").Field;
     };
 };
 export declare class BlockProverPublicOutput extends BlockProverPublicOutput_base {
@@ -88,18 +97,22 @@ export type BlockProverProof = Proof<BlockProverPublicInput, BlockProverPublicOu
 declare const BlockProverExecutionData_base: (new (value: {
     transaction: ProtocolTransaction;
     networkState: NetworkState;
+    transactionPosition: BlockTransactionPosition;
 }) => {
     transaction: ProtocolTransaction;
     networkState: NetworkState;
+    transactionPosition: BlockTransactionPosition;
 }) & {
     _isStruct: true;
 } & import("o1js/dist/node/snarky").ProvablePure<{
     transaction: ProtocolTransaction;
     networkState: NetworkState;
+    transactionPosition: BlockTransactionPosition;
 }> & {
     toInput: (x: {
         transaction: ProtocolTransaction;
         networkState: NetworkState;
+        transactionPosition: BlockTransactionPosition;
     }) => {
         fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
         packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
@@ -107,6 +120,7 @@ declare const BlockProverExecutionData_base: (new (value: {
     toJSON: (x: {
         transaction: ProtocolTransaction;
         networkState: NetworkState;
+        transactionPosition: BlockTransactionPosition;
     }) => {
         transaction: {
             methodId: string;
@@ -120,6 +134,9 @@ declare const BlockProverExecutionData_base: (new (value: {
                 height: string;
             };
         };
+        transactionPosition: {
+            type: string;
+        };
     };
     fromJSON: (x: {
         transaction: {
@@ -134,9 +151,13 @@ declare const BlockProverExecutionData_base: (new (value: {
                 height: string;
             };
         };
+        transactionPosition: {
+            type: string;
+        };
     }) => {
         transaction: ProtocolTransaction;
         networkState: NetworkState;
+        transactionPosition: BlockTransactionPosition;
     };
 };
 export declare class BlockProverExecutionData extends BlockProverExecutionData_base {

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

@@ -1 +1 @@
-{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAG3C;CAAG;AAEL,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,MAAM,WAAW,aACf,SAAQ,kBAAkB,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IAC3E,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,KACpC,uBAAuB,CAAC;IAE7B,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,uBAAuB,CAAC;CAC9B"}
+{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAAU,MAAM,MAAM,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAI3C;CAAG;AAEL,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,MAAM,WAAW,aACf,SAAQ,kBAAkB,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IAC3E,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,KACpC,uBAAuB,CAAC;IAE7B,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,uBAAuB,CAAC;CAC9B"}

package/dist/prover/block/BlockProvable.js

@@ -1,6 +1,7 @@
 import { Field, Struct } from "o1js";
 import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
+import { BlockTransactionPosition } from "./BlockTransactionPosition";
 export class BlockProverPublicInput extends Struct({
     transactionsHash: Field,
     stateRoot: Field,
@@ -10,11 +11,12 @@ export class BlockProverPublicInput extends Struct({
 export class BlockProverPublicOutput extends Struct({
     transactionsHash: Field,
     stateRoot: Field,
+    networkStateHash: Field,
 }) {
 }
 export class BlockProverExecutionData extends Struct({
     transaction: ProtocolTransaction,
     networkState: NetworkState,
-    // accountstate
+    transactionPosition: BlockTransactionPosition,
 }) {
 }

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

@@ -5,6 +5,7 @@ import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProof, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../statetransition/StateTransitionProvable";
 import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput } from "./BlockProvable";
 import { ProvableTransactionHook } from "../../protocol/ProvableTransactionHook";
+import { ProvableBlockHook } from "../../protocol/ProvableBlockHook";
 export interface BlockProverState {
     stateRoot: Field;
     /**
@@ -22,8 +23,9 @@ export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverP
     private readonly prover;
     readonly stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
     readonly runtime: ZkProgrammable<undefined, MethodPublicOutput>;
-    private readonly blockModules;
-    constructor(prover: BlockProver, stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: ZkProgrammable<undefined, MethodPublicOutput>, blockModules: ProvableTransactionHook<unknown>[]);
+    private readonly transactionHooks;
+    private readonly blockHooks;
+    constructor(prover: BlockProver, stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: ZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook<unknown>[], blockHooks: ProvableBlockHook<unknown>[]);
     get appChain(): AreProofsEnabled | undefined;
     /**
      * Applies and checks the two proofs and applies the corresponding state
@@ -37,6 +39,9 @@ export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverP
      */
     applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverState;
     assertProtocolTransitions(stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, executionData: BlockProverExecutionData): void;
+    private getBeforeBlockNetworkState;
+    private getAfterBlockNetworkState;
+    private addTransactionToBundle;
     proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
     merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
     /**
@@ -51,11 +56,11 @@ export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverP
  * a StateTransitionProof into a single BlockProof, that can
  * then be merged to be committed to the base-layer contract
  */
-export declare class BlockProver extends ProtocolModule<object> implements BlockProvable {
+export declare class BlockProver extends ProtocolModule implements BlockProvable {
     readonly stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
     readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput>;
     zkProgrammable: BlockProverProgrammable;
-    constructor(stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook<unknown>[]);
+    constructor(stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook<unknown>[], blockHooks: ProvableBlockHook<unknown>[]);
     merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
     proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,EACL,KAAK,KAAK,EAIX,MAAM,MAAM,CAAC;AAEd,OAAO,EACL,gBAAgB,EAChB,cAAc,EAEd,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,4CAA4C,CAAC;AAGpD,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAmBrE,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,KAAK,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;IAExB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;CACzB;AAED,qBAAa,uBAAwB,SAAQ,cAAc,CACzD,sBAAsB,EACtB,uBAAuB,CACxB;IAGG,OAAO,CAAC,QAAQ,CAAC,MAAM;aACP,qBAAqB,EAAE,cAAc,CACnD,gCAAgC,EAChC,iCAAiC,CAClC;aACe,OAAO,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACtE,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAPV,MAAM,EAAE,WAAW,EACpB,qBAAqB,EAAE,cAAc,CACnD,gCAAgC,EAChC,iCAAiC,CAClC,EACe,OAAO,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,EACrD,gBAAgB,EAAE,uBAAuB,CAAC,OAAO,CAAC,EAAE,EACpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAK3D,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED;;;;;;;;;OASG;IACI,gBAAgB,CACrB,KAAK,EAAE,gBAAgB,EACvB,oBAAoB,EAAE,KAAK,CACzB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,GACtC,gBAAgB;IAqEZ,yBAAyB,CAC9B,oBAAoB,EAAE,KAAK,CACzB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,aAAa,EAAE,wBAAwB;IA+CzC,OAAO,CAAC,0BAA0B;IAYlC,OAAO,CAAC,yBAAyB;IAYjC,OAAO,CAAC,sBAAsB;IAsDvB,gBAAgB,CACrB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,GACtC,uBAAuB;IAmDnB,KAAK,CACV,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,GACvB,uBAAuB;IAyC1B;;;;OAIG;IACI,gBAAgB,IAAI,cAAc,CACvC,sBAAsB,EACtB,uBAAuB,CACxB;CAkEF;AAED;;;;GAIG;AACH,qBACa,WACX,SAAQ,cACR,YAAW,aAAa;aAMN,qBAAqB,EAAE,kBAAkB,CACvD,gCAAgC,EAChC,iCAAiC,CAClC;aAEe,OAAO,EAAE,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC;IATrE,cAAc,EAAE,uBAAuB,CAAC;gBAI7B,qBAAqB,EAAE,kBAAkB,CACvD,gCAAgC,EAChC,iCAAiC,CAClC,EAEe,OAAO,EAAE,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC,EAE1E,gBAAgB,EAAE,uBAAuB,CAAC,OAAO,CAAC,EAAE,EAEpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAYnC,KAAK,CACV,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,GACvB,uBAAuB;IAInB,gBAAgB,CACrB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,GACtC,uBAAuB;CAQ3B"}

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"}