@proto-kit/protocol 0.1.1-develop.457 → 0.1.1-develop.651

package/dist/protocol/Protocol.d.ts

@@ -6,25 +6,27 @@ 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, BlockProvable {
+import { AccountStateHook } from "../hooks/AccountStateHook";
+import { BlockHeightHook } from "../hooks/BlockHeightHook";
+import { LastStateRootBlockHook } from "../hooks/LastStateRootBlockHook";
+export type ProtocolModulesRecord = ModulesRecord<TypedClass<ProtocolModule<unknown>>>;
+export interface BlockProverType extends ProtocolModule, BlockProvable {
 }
-interface StateTransitionProverType extends ProtocolModule, StateTransitionProvable {
+export interface StateTransitionProverType extends ProtocolModule, StateTransitionProvable {
 }
-export interface ProtocolCustomModulesRecord {
+export type MandatoryProtocolModulesRecord = {
     BlockProver: TypedClass<BlockProverType>;
     StateTransitionProver: TypedClass<StateTransitionProverType>;
-    AccountState: TypedClass<AccountStateModule>;
-}
-export interface ProtocolModulesRecord extends GenericProtocolModuleRecord, ProtocolCustomModulesRecord {
-}
+    AccountState: TypedClass<AccountStateHook>;
+    BlockHeight: TypedClass<BlockHeightHook>;
+    LastStateRoot: TypedClass<LastStateRootBlockHook>;
+};
 export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
     modules: Modules;
     config?: ModulesConfig<Modules>;
 }
-export declare class Protocol<Modules extends ProtocolModulesRecord> extends ModuleContainer<Modules> implements ProtocolEnvironment {
-    static from<Modules extends ProtocolModulesRecord>(modules: ProtocolDefinition<Modules>): TypedClass<Protocol<Modules>>;
+export declare class Protocol<Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord> extends ModuleContainer<Modules> implements ProtocolEnvironment {
+    static from<Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord>(modules: ProtocolDefinition<Modules>): TypedClass<Protocol<Modules>>;
     definition: ProtocolDefinition<Modules>;
     constructor(definition: ProtocolDefinition<Modules>);
     get stateService(): StateService;
@@ -37,9 +39,4 @@ export declare class Protocol<Modules extends ProtocolModulesRecord> extends Mod
     getAreProofsEnabled(): AreProofsEnabled;
     create(childContainerProvider: ChildContainerProvider): void;
 }
-export declare const VanillaProtocol: {
-    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;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"}
+{"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,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAG7D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAUzE,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAC/C,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CACpC,CAAC;AAEF,MAAM,WAAW,eAAgB,SAAQ,cAAc,EAAE,aAAa;CAAG;AAEzE,MAAM,WAAW,yBACf,SAAQ,cAAc,EACpB,uBAAuB;CAAG;AAE9B,MAAM,MAAM,8BAA8B,GAAG;IAC3C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;IAC7D,YAAY,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC3C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,aAAa,EAAE,UAAU,CAAC,sBAAsB,CAAC,CAAC;CACnD,CAAC;AAEF,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,CACjB,OAAO,SAAS,qBAAqB,GAAG,8BAA8B,CAExE,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,mBAAmB;WAEhB,IAAI,CAChB,OAAO,SAAS,qBAAqB,GAAG,8BAA8B,EACtE,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAQ/D,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;CAoD7D"}

package/dist/protocol/Protocol.js

@@ -1,19 +1,17 @@
 import { log, ModuleContainer, } from "@proto-kit/common";
 import { Lifecycle } from "tsyringe";
-import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
-import { BlockProver } from "../prover/block/BlockProver";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
-import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
-import { AccountStateModule } from "../blockmodules/AccountStateModule";
+import { NoopTransactionHook } from "../hooks/NoopTransactionHook";
 import { ProvableBlockHook } from "./ProvableBlockHook";
-import { NoopBlockHook } from "../blockmodules/NoopBlockHook";
-import { BlockHeightHook } from "../blockmodules/BlockHeightHook";
+import { NoopBlockHook } from "../hooks/NoopBlockHook";
+import { ProvableSettlementHook } from "../settlement/modularity/ProvableSettlementHook";
+import { NoopSettlementHook } from "../hooks/NoopSettlementHook";
 const PROTOCOL_INJECTION_TOKENS = {
     ProvableTransactionHook: "ProvableTransactionHook",
     ProvableBlockHook: "ProvableBlockHook",
+    ProvableSettlementHook: "ProvableSettlementHook",
 };
 export class Protocol extends ModuleContainer {
-    // .from() to create Protocol
     static from(modules) {
         return class ScopedProtocol extends Protocol {
             constructor() {
@@ -60,40 +58,29 @@ export class Protocol extends ModuleContainer {
         super.create(childContainerProvider);
         // 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(PROTOCOL_INJECTION_TOKENS.ProvableTransactionHook, { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
-                atLeastOneTransactionHookRegistered = true;
+        const ABSTRACT_MODULE_TYPES = [
+            { type: ProvableTransactionHook, defaultType: NoopTransactionHook },
+            { type: ProvableBlockHook, defaultType: NoopBlockHook },
+            { type: ProvableSettlementHook, defaultType: NoopSettlementHook },
+        ];
+        ABSTRACT_MODULE_TYPES.forEach((moduleTypeRegistration) => {
+            const abstractType = moduleTypeRegistration.type;
+            const implementingModules = Object.entries(this.definition.modules).filter(([, value]) => Object.prototype.isPrototypeOf.call(abstractType, value));
+            const newInjectionToken = PROTOCOL_INJECTION_TOKENS[abstractType.name];
+            if (newInjectionToken === undefined) {
+                log.error("Can't inject hook under the underlying hook token: Alias not found in mapping");
+                return;
             }
-            if (Object.prototype.isPrototypeOf.call(ProvableBlockHook, value)) {
-                this.container.register(PROTOCOL_INJECTION_TOKENS.ProvableBlockHook, { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
-                atLeastOneBlockHookRegistered = true;
+            implementingModules.forEach(([key]) => {
+                this.container.register(abstractType.name, { useToken: key }, { lifecycle: Lifecycle.ContainerScoped });
+            });
+            if (implementingModules.length === 0) {
+                // This type annotation shouldn't change anything but is necessary
+                // bcs tsyringe complains
+                const { defaultType } = moduleTypeRegistration;
+                // Register default (noop) version
+                this.container.register(abstractType.name, { useClass: defaultType }, { lifecycle: Lifecycle.ContainerScoped });
             }
         });
-        // We need this so that tsyringe doesn't throw when no hooks are registered
-        if (!atLeastOneTransactionHookRegistered) {
-            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({});
-    },
-    from(additionalModules) {
-        return Protocol.from({
-            modules: {
-                StateTransitionProver,
-                BlockProver,
-                AccountState: AccountStateModule,
-                BlockHeight: BlockHeightHook,
-                ...additionalModules,
-            },
-        });
-    },
-};

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,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"}
+{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,QAAQ,EAET,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

@@ -1,16 +1,8 @@
 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;
+    abstract beforeBlock(networkState: NetworkState, state: BlockProverState): NetworkState;
+    abstract afterBlock(networkState: NetworkState, state: BlockProverState): NetworkState;
 }
 //# sourceMappingURL=ProvableBlockHook.d.ts.map

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

@@ -1 +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"}
+{"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;AAG5E,8BAAsB,iBAAiB,CACrC,MAAM,CACN,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC3B,WAAW,CACzB,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,gBAAgB,GACtB,YAAY;aAEC,UAAU,CACxB,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,gBAAgB,GACtB,YAAY;CAChB"}

package/dist/protocol/ProvableBlockHook.js

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

package/dist/protocol/ProvableTransactionHook.d.ts

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

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;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"}
+{"version":3,"file":"ProvableTransactionHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableTransactionHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,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,7 +1,8 @@
 import { ProtocolModule } from "./ProtocolModule";
 /**
- * A Protocolmodule that enables it's implementing module to access to
- * StateTransitions and state
+ * TransitioningProtocolModule is a base interface that allows inheriting
+ * classes to use State and StateMap since it requires the implementation
+ * of a `name: string` property, which those classes need to function.
  */
 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;;;GAGG;AACH,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;;;;GAIG;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,7 +1,8 @@
 import { ProtocolModule } from "./ProtocolModule";
 /**
- * A Protocolmodule that enables it's implementing module to access to
- * StateTransitions and state
+ * TransitioningProtocolModule is a base interface that allows inheriting
+ * classes to use State and StateMap since it requires the implementation
+ * of a `name: string` property, which those classes need to function.
  */
 export class TransitioningProtocolModule extends ProtocolModule {
 }

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

@@ -1,29 +1,41 @@
-import { Proof } from "o1js";
+import { Bool, Field, Proof, Signature } from "o1js";
 import { WithZkProgrammable } from "@proto-kit/common";
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
-import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
-import { BlockTransactionPosition } from "./BlockTransactionPosition";
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
 declare const BlockProverPublicInput_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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: 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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: 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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: 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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: 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;
@@ -32,19 +44,31 @@ declare const BlockProverPublicInput_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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
     }) => {
         transactionsHash: string;
         stateRoot: string;
         networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
     };
     fromJSON: (x: {
         transactionsHash: string;
         stateRoot: string;
         networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: 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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
     };
 };
 export declare class BlockProverPublicInput extends BlockProverPublicInput_base {
@@ -53,21 +77,41 @@ 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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+    blockNumber: 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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+    blockNumber: 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;
+    blockHashRoot: import("o1js/dist/node/lib/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+    closed: import("o1js/dist/node/lib/bool").Bool;
+    blockNumber: 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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+        blockNumber: 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;
@@ -76,94 +120,128 @@ 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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/field").Field;
     }) => {
         transactionsHash: string;
         stateRoot: string;
         networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        closed: boolean;
+        blockNumber: string;
     };
     fromJSON: (x: {
         transactionsHash: string;
         stateRoot: string;
         networkStateHash: string;
+        blockHashRoot: string;
+        eternalTransactionsHash: string;
+        incomingMessagesHash: string;
+        closed: boolean;
+        blockNumber: 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;
+        blockHashRoot: import("o1js/dist/node/lib/field").Field;
+        eternalTransactionsHash: import("o1js/dist/node/lib/field").Field;
+        incomingMessagesHash: import("o1js/dist/node/lib/field").Field;
+        closed: import("o1js/dist/node/lib/bool").Bool;
+        blockNumber: import("o1js/dist/node/lib/field").Field;
     };
 };
 export declare class BlockProverPublicOutput extends BlockProverPublicOutput_base {
+    equals(input: BlockProverPublicInput, closed: Bool, blockNumber: Field): Bool;
 }
 export type BlockProverProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
 declare const BlockProverExecutionData_base: (new (value: {
-    transaction: ProtocolTransaction;
+    transaction: RuntimeTransaction;
+    signature: Signature;
     networkState: NetworkState;
-    transactionPosition: BlockTransactionPosition;
 }) => {
-    transaction: ProtocolTransaction;
+    transaction: RuntimeTransaction;
+    signature: Signature;
     networkState: NetworkState;
-    transactionPosition: BlockTransactionPosition;
 }) & {
     _isStruct: true;
-} & import("o1js/dist/node/snarky").ProvablePure<{
-    transaction: ProtocolTransaction;
+} & import("o1js/dist/node/lib/provable").Provable<{
+    transaction: RuntimeTransaction;
+    signature: Signature;
     networkState: NetworkState;
-    transactionPosition: BlockTransactionPosition;
 }> & {
     toInput: (x: {
-        transaction: ProtocolTransaction;
+        transaction: RuntimeTransaction;
+        signature: Signature;
         networkState: NetworkState;
-        transactionPosition: BlockTransactionPosition;
     }) => {
         fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
         packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        transaction: ProtocolTransaction;
+        transaction: RuntimeTransaction;
+        signature: Signature;
         networkState: NetworkState;
-        transactionPosition: BlockTransactionPosition;
     }) => {
         transaction: {
             methodId: string;
-            nonce: string;
-            sender: string;
             argsHash: string;
-            signature: any;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
         };
+        signature: any;
         networkState: {
             block: {
                 height: string;
             };
-        };
-        transactionPosition: {
-            type: string;
+            previous: {
+                rootHash: string;
+            };
         };
     };
     fromJSON: (x: {
         transaction: {
             methodId: string;
-            nonce: string;
-            sender: string;
             argsHash: string;
-            signature: any;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
         };
+        signature: any;
         networkState: {
             block: {
                 height: string;
             };
-        };
-        transactionPosition: {
-            type: string;
+            previous: {
+                rootHash: string;
+            };
         };
     }) => {
-        transaction: ProtocolTransaction;
+        transaction: RuntimeTransaction;
+        signature: Signature;
         networkState: NetworkState;
-        transactionPosition: BlockTransactionPosition;
     };
 };
 export declare class BlockProverExecutionData extends BlockProverExecutionData_base {
 }
 export interface BlockProvable extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
     proveTransaction: (publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData) => BlockProverPublicOutput;
+    proveBlock: (publicInput: BlockProverPublicInput, networkState: NetworkState, blockWitness: BlockHashMerkleTreeWitness, stateTransitionProof: StateTransitionProof, transactionProof: BlockProverProof) => BlockProverPublicOutput;
     merge: (publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof) => BlockProverPublicOutput;
 }
 export {};

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,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"}
+{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAU,MAAM,MAAM,CAAC;AAC7D,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,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjF,qBAAa,sBAAuB,SAAQ,2BAO1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAS3C;IACO,MAAM,CACX,KAAK,EAAE,sBAAsB,EAC7B,MAAM,EAAE,IAAI,EACZ,WAAW,EAAE,KAAK,GACjB,IAAI;CAWR;AAED,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,UAAU,EAAE,CACV,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,0BAA0B,EACxC,oBAAoB,EAAE,oBAAoB,EAC1C,gBAAgB,EAAE,gBAAgB,KAC/B,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,22 +1,40 @@
-import { Field, Struct } from "o1js";
-import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { Bool, Field, Signature, Struct } from "o1js";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
-import { BlockTransactionPosition } from "./BlockTransactionPosition";
 export class BlockProverPublicInput extends Struct({
     transactionsHash: Field,
     stateRoot: Field,
     networkStateHash: Field,
+    blockHashRoot: Field,
+    eternalTransactionsHash: Field,
+    incomingMessagesHash: Field,
 }) {
 }
 export class BlockProverPublicOutput extends Struct({
     transactionsHash: Field,
     stateRoot: Field,
     networkStateHash: Field,
+    blockHashRoot: Field,
+    eternalTransactionsHash: Field,
+    incomingMessagesHash: Field,
+    closed: Bool,
+    blockNumber: Field,
 }) {
+    equals(input, closed, blockNumber) {
+        const output2 = BlockProverPublicOutput.toFields({
+            ...input,
+            closed,
+            blockNumber,
+        });
+        const output1 = BlockProverPublicOutput.toFields(this);
+        return output1
+            .map((value1, index) => value1.equals(output2[index]))
+            .reduce((a, b) => a.and(b));
+    }
 }
 export class BlockProverExecutionData extends Struct({
-    transaction: ProtocolTransaction,
+    transaction: RuntimeTransaction,
+    signature: Signature,
     networkState: NetworkState,
-    transactionPosition: BlockTransactionPosition,
 }) {
 }