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

package/dist/state/protocol/ProtocolState.d.ts

@@ -0,0 +1,7 @@
+import { TransitioningProtocolModule } from "../../protocol/TransitioningProtocolModule";
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export declare function protocolState(): <TargetTransitioningModule extends TransitioningProtocolModule>(target: TargetTransitioningModule, propertyKey: string) => void;
+//# sourceMappingURL=ProtocolState.d.ts.map

package/dist/state/protocol/ProtocolState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolState.d.ts","sourceRoot":"","sources":["../../../src/state/protocol/ProtocolState.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAgBzF;;;GAGG;AACH,wBAAgB,aAAa,oHAGZ,MAAM,UAoCtB"}

package/dist/state/protocol/ProtocolState.js

@@ -0,0 +1,42 @@
+import { Path } from "../../model/Path";
+const errors = {
+    missingName: (className) => new Error(`Unable to provide a unique identifier for state, ${className} is missing a name. 
+      Did you forget to extend your block module with 'extends ...Hook'?`),
+    missingProtocol: (className) => new Error(`Unable to provide 'procotol' for state, ${className} is missing a name. 
+      Did you forget to extend your block module with 'extends ...Hook'?`),
+};
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export function protocolState() {
+    return (target, propertyKey) => {
+        // eslint-disable-next-line @typescript-eslint/init-declarations
+        let value;
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            get: function get() {
+                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const self = this;
+                if (self.name === undefined) {
+                    throw errors.missingName(self.constructor.name);
+                }
+                if (!self.protocol) {
+                    throw errors.missingProtocol(self.constructor.name);
+                }
+                // eslint-disable-next-line no-warning-comments
+                // TODO Add Prefix?
+                const path = Path.fromProperty(self.name, propertyKey);
+                if (value) {
+                    value.path = path;
+                    value.stateServiceProvider = self.protocol.stateServiceProvider;
+                }
+                return value;
+            },
+            set: (newValue) => {
+                value = newValue;
+            },
+        });
+    };
+}

package/dist/utils/merkletree/MemoryMerkleTreeStorage.d.ts

@@ -0,0 +1,26 @@
+import { type MerkleTreeStore, type SyncMerkleTreeStore } from "./RollupMerkleTree.js";
+export declare class NoOpMerkleTreeStorage implements SyncMerkleTreeStore {
+    parent: MerkleTreeStore;
+    openTransaction(): void;
+    commit(): void;
+    getNode(): bigint | undefined;
+    setNode(): void;
+    virtualize(): MerkleTreeStore;
+    getNodeAsync(): Promise<bigint | undefined>;
+    setNodeAsync(): Promise<void>;
+}
+export declare class MemoryMerkleTreeStorage implements SyncMerkleTreeStore {
+    private readonly nodes;
+    private readonly cache;
+    parent: SyncMerkleTreeStore;
+    constructor(parent?: SyncMerkleTreeStore | undefined);
+    openTransaction(): void;
+    commit(): void;
+    getNode(key: bigint, level: number): bigint | undefined;
+    setNode(key: bigint, level: number, value: bigint): void;
+    virtualize(): MerkleTreeStore;
+    getNodeAsync(key: bigint, level: number): Promise<bigint | undefined>;
+    setNodeAsync(key: bigint, level: number, value: bigint): Promise<void>;
+    cacheFromParent(index: bigint): Promise<void>;
+}
+//# sourceMappingURL=MemoryMerkleTreeStorage.d.ts.map

package/dist/utils/merkletree/MemoryMerkleTreeStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryMerkleTreeStorage.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/MemoryMerkleTreeStorage.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,qBAAa,qBAAsB,YAAW,mBAAmB;IACxD,MAAM,EAAE,eAAe,CAAQ;IAE/B,eAAe,IAAI,IAAI;IAIvB,MAAM,IAAI,IAAI;IAId,OAAO,IAAI,MAAM,GAAG,SAAS;IAI7B,OAAO,IAAI,IAAI;IAIf,UAAU,IAAI,eAAe;IAIvB,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI3C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAG3C;AAED,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGf;IAEP,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGf;IAEA,MAAM,EAAE,mBAAmB,CAAC;gBAEhB,MAAM,GAAE,mBAAmB,GAAG,SAAqB;IAI/D,eAAe,IAAI,IAAI;IAIvB,MAAM,IAAI,IAAI;IAId,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIxD,UAAU,IAAI,eAAe;IAIvB,YAAY,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAIjB,YAAY,CACvB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC;IAKH,eAAe,CAAC,KAAK,EAAE,MAAM;CAoB3C"}

package/dist/utils/merkletree/MemoryMerkleTreeStorage.js

@@ -0,0 +1,79 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import noop from "lodash/noop";
+import { RollupMerkleTree, } from "./RollupMerkleTree.js";
+export class NoOpMerkleTreeStorage {
+    constructor() {
+        this.parent = this;
+    }
+    openTransaction() {
+        noop();
+    }
+    commit() {
+        noop();
+    }
+    getNode() {
+        return undefined;
+    }
+    setNode() {
+        noop();
+    }
+    virtualize() {
+        return this;
+    }
+    async getNodeAsync() {
+        return undefined;
+    }
+    async setNodeAsync() {
+        return undefined;
+    }
+}
+export class MemoryMerkleTreeStorage {
+    constructor(parent = undefined) {
+        this.nodes = {};
+        this.cache = {};
+        this.parent = parent ?? new NoOpMerkleTreeStorage();
+    }
+    openTransaction() {
+        noop();
+    }
+    commit() {
+        noop();
+    }
+    getNode(key, level) {
+        return (this.nodes[level]?.[key.toString()] ??
+            this.cache[level]?.[key.toString()] ??
+            this.parent.getNode(key, level));
+    }
+    setNode(key, level, value) {
+        var _a;
+        ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
+    }
+    virtualize() {
+        return new MemoryMerkleTreeStorage(this);
+    }
+    async getNodeAsync(key, level) {
+        return this.getNode(key, level);
+    }
+    async setNodeAsync(key, level, value) {
+        this.setNode(key, level, value);
+        return undefined;
+    }
+    async cacheFromParent(index) {
+        var _a;
+        // Algo from RollupMerkleTree.getWitness()
+        const { leafCount, height } = RollupMerkleTree;
+        if (index >= leafCount) {
+            index %= leafCount;
+        }
+        for (let level = 0; level < height - 1; level++) {
+            const isLeft = index % 2n === 0n;
+            const key = isLeft ? index + 1n : index - 1n;
+            // eslint-disable-next-line no-await-in-loop
+            const value = await this.parent.getNodeAsync(key, level);
+            if (value !== undefined) {
+                ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
+            }
+            index /= 2n;
+        }
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.191+554ba10",
+  "version": "0.1.1-develop.239+0bf6910",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -20,7 +20,9 @@
     "@proto-kit/common": "*",
     "lodash": "^4.17.21",
     "loglevel": "^1.8.1",
-    "reflect-metadata": "^0.1.13"
+    "reflect-metadata": "^0.1.13",
+    "ts-mixer": "^6.0.3",
+    "tsyringe": "^4.7.0"
   },
   "peerDependencies": {
     "snarkyjs": "0.12.0",
@@ -30,5 +32,5 @@
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "554ba102c48f41a62409ff01354582567ef4124a"
+  "gitHead": "0bf6910a100b9ae24fb00a253c9f58b5fd73ca55"
 }

package/src/blockmodules/AccountStateModule.ts

@@ -0,0 +1,31 @@
+import { Provable, PublicKey, Struct, UInt64 } from "snarkyjs";
+
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+import { StateMap } from "../state/StateMap";
+import { protocolState } from "../state/protocol/ProtocolState";
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+import { assert } from "../state/assert/assert";
+
+export class AccountState extends Struct({
+  nonce: UInt64,
+}) {}
+
+export class AccountStateModule extends ProvableTransactionHook {
+  @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(PublicKey, AccountState);
+
+  public onTransaction({ transaction }: BlockProverExecutionData): void {
+    const accountState = this.accountState
+      .get(transaction.sender)
+      .orElse(new AccountState({ nonce: UInt64.zero }));
+
+    const currentNonce = accountState.nonce;
+    Provable.log("Current Nonce", currentNonce);
+    Provable.log("Tx Nonce", transaction.nonce);
+    assert(currentNonce.equals(transaction.nonce), "Nonce not matching");
+
+    this.accountState.set(
+      transaction.sender,
+      new AccountState({ nonce: currentNonce.add(1) })
+    );
+  }
+}

package/src/blockmodules/NoopTransactionHook.ts

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

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./blockmodules/AccountStateModule";
 export * from "./utils/ProvableHashList";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
@@ -20,4 +21,15 @@ export * from "./model/MethodPublicOutput";
 export * from "./prover/statetransition/StateTransitionWitnessProviderReference";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
+export * from "./protocol/TransitioningProtocolModule";
+export * from "./protocol/ProvableTransactionHook";
+export * from "./state/context/ProtocolMethodExecutionContext";
+export * from "./state/context/TransitionMethodExecutionContext";
+export * from "./state/context/RuntimeMethodExecutionContext";
+export * from "./state/protocol/ProtocolState";
+export * from "./state/State";
+export * from "./state/StateMap";
+export * from "./state/StateService";
+export * from "./state/StateServiceProvider";
+export * from "./state/assert/assert";
 export { constants as ProtocolConstants } from "./Constants";

package/src/model/Option.ts

@@ -1,6 +1,7 @@
 import {
   Bool,
   Field,
+  FlexibleProvable,
   type FlexibleProvablePure,
   Poseidon,
   Provable,
@@ -17,6 +18,10 @@ export class ProvableOption extends Struct({
   }
 }
 
+export interface ToFieldable {
+  toFields: () => Field[];
+}
+
 /**
  * Option facilitating in-circuit values that may or may not exist.
  */
@@ -58,28 +63,6 @@ export class Option<Value> {
     return new Option(Bool(false), Field(0), Field);
   }
 
-  public static dummyValueFields<Value>(
-    valueType: FlexibleProvablePure<Value>
-  ): Field[] {
-    const length = valueType.sizeInFields();
-    return Array.from({ length }, () => Field(0));
-  }
-
-  /**
-   * Computes a dummy value for the given value type.
-   *
-   * @param valueType - Value type to generate the dummy value for
-   * @returns Dummy value for the given value type
-   */
-  public static dummyValue<Value>(
-    valueType: FlexibleProvablePure<Value>
-  ): Value {
-    const fields = Option.dummyValueFields(valueType);
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return valueType.fromFields(fields) as Value;
-  }
-
   public isForcedSome = Bool(false);
 
   public constructor(
@@ -131,6 +114,19 @@ export class Option<Value> {
     });
   }
 
+  /**
+   * @returns Returns the value of this option if it isSome,
+   * otherwise returns the given defaultValue
+   */
+  public orElse(defaultValue: Value): Value {
+    return Provable.if<Value>(
+      this.isSome,
+      this.valueType,
+      this.value,
+      defaultValue
+    );
+  }
+
   public toJSON() {
     const valueContent = this.valueType
       .toFields(this.value)

package/src/model/StateTransition.ts

@@ -1,6 +1,6 @@
 import { Field, Struct } from "snarkyjs";
 
-import { Option, ProvableOption } from "./Option.js";
+import { Option, ProvableOption, ToFieldable } from "./Option.js";
 
 /**
  * Provable representation of a State Transition, used to

package/src/model/StateTransitionProvableBatch.ts

@@ -1,32 +1,113 @@
-import { Provable, Struct } from "snarkyjs";
+import { Bool, Provable, Struct } from "snarkyjs";
 
 import { constants } from "../Constants";
 
 import { ProvableStateTransition } from "./StateTransition.js";
+import { range } from "@proto-kit/common";
+
+export class StateTransitionType {
+  public static readonly normal = true;
+  public static readonly protocol = false;
+
+  public static isNormal(type: boolean) {
+    return type === StateTransitionType.normal;
+  }
+
+  public static isProtocol(type: boolean) {
+    return type === StateTransitionType.protocol;
+  }
+}
+
+export class ProvableStateTransitionType extends Struct({
+  type: Bool,
+}) {
+  public static get normal(): ProvableStateTransitionType {
+    return new ProvableStateTransitionType({
+      type: Bool(StateTransitionType.normal),
+    });
+  }
+
+  public static get protocol(): ProvableStateTransitionType {
+    return new ProvableStateTransitionType({
+      type: Bool(StateTransitionType.protocol),
+    });
+  }
+
+  public isNormal(): Bool {
+    return this.type;
+  }
+
+  public isProtocol(): Bool {
+    return this.type.not();
+  }
+}
 
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
  */
 export class StateTransitionProvableBatch extends Struct({
   batch: Provable.Array(
     ProvableStateTransition,
     constants.stateTransitionProverBatchSize
   ),
+
+  transitionTypes: Provable.Array(
+    ProvableStateTransitionType,
+    constants.stateTransitionProverBatchSize
+  ),
 }) {
+  public static fromMappings(
+    transitions: {
+      transition: ProvableStateTransition;
+      type: ProvableStateTransitionType;
+    }[]
+  ): StateTransitionProvableBatch {
+    const batch = transitions.map((entry) => entry.transition);
+    const transitionTypes = transitions.map((entry) => entry.type);
+
+    while (batch.length < constants.stateTransitionProverBatchSize) {
+      batch.push(ProvableStateTransition.dummy());
+      transitionTypes.push(ProvableStateTransitionType.normal);
+    }
+    return new StateTransitionProvableBatch({
+      batch,
+      transitionTypes,
+    });
+  }
+
   public static fromTransitions(
-    transitions: ProvableStateTransition[]
+    transitions: ProvableStateTransition[],
+    protocolTransitions: ProvableStateTransition[]
   ): StateTransitionProvableBatch {
-    const array = transitions.slice();
+    const array = transitions.slice().concat(protocolTransitions);
+
+    const transitionTypes = range(0, transitions.length)
+      .map(() => ProvableStateTransitionType.normal)
+      .concat(
+        range(0, protocolTransitions.length).map(
+          () => ProvableStateTransitionType.protocol
+        )
+      );
 
     while (array.length < constants.stateTransitionProverBatchSize) {
       array.push(ProvableStateTransition.dummy());
+      transitionTypes.push(ProvableStateTransitionType.normal);
     }
 
-    return new StateTransitionProvableBatch({ batch: array });
+    return new StateTransitionProvableBatch({
+      batch: array,
+      transitionTypes,
+    });
   }
 
-  private constructor(object: { batch: ProvableStateTransition[] }) {
+  private constructor(object: {
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+  }) {
     super(object);
   }
 }

package/src/protocol/Protocol.ts

@@ -6,36 +6,27 @@ import {
   StringKeyOf,
   TypedClass,
 } from "@proto-kit/common";
-import { DependencyContainer } from "tsyringe";
+import { DependencyContainer, Lifecycle } from "tsyringe";
 
-import {
-  BlockProvable,
-  BlockProverPublicInput,
-  BlockProverPublicOutput,
-} from "../prover/block/BlockProvable";
+import { BlockProvable } from "../prover/block/BlockProvable";
 import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
-import {
-  StateTransitionProvable,
-  StateTransitionProverPublicInput,
-  StateTransitionProverPublicOutput,
-} from "../prover/statetransition/StateTransitionProvable";
+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 { ProvableTransactionHook } from "./ProvableTransactionHook";
+import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
 
 export type GenericProtocolModuleRecord = ModulesRecord<
-  TypedClass<ProtocolModule<any, any>>
+  TypedClass<ProtocolModule>
 >;
 
-interface BlockProverType
-  extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput>,
-    BlockProvable {}
+interface BlockProverType extends ProtocolModule, BlockProvable {}
 
 interface StateTransitionProverType
-  extends ProtocolModule<
-      StateTransitionProverPublicInput,
-      StateTransitionProverPublicOutput
-    >,
+  extends ProtocolModule,
     StateTransitionProvable {}
 
 export interface ProtocolCustomModulesRecord {
@@ -49,6 +40,11 @@ export interface ProtocolModulesRecord
 
 export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
   modules: Modules;
+
+  /**
+   * @deprecated
+   */
+  state?: StateService;
   // config: ModulesConfig<Modules>
 }
 
@@ -79,6 +75,52 @@ export class Protocol<
     return protocol;
   }
 
+  public definition: ProtocolDefinition<Modules>;
+
+  private readonly stateServiceProviderInstance = new StateServiceProvider(
+    // eslint-disable-next-line etc/no-deprecated
+    this.definition.state
+  );
+
+  public constructor(definition: ProtocolDefinition<Modules>) {
+    super(definition);
+    this.definition = definition;
+
+    // Register the BlockModules seperately since we need to
+    // inject them differently later
+    let atLeastOneTransactionHookRegistered = false;
+    Object.entries(definition.modules).forEach(([key, value]) => {
+      if (Object.prototype.isPrototypeOf.call(ProvableTransactionHook, value)) {
+        this.container.register(
+          "ProvableTransactionHook",
+          { useToken: key },
+          { lifecycle: Lifecycle.ContainerScoped }
+        );
+        atLeastOneTransactionHookRegistered = 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.afterResolution<ProvableTransactionHook>("ProvableTransactionHook", (token, result) => {
+    //   if ()
+    // })
+  }
+
+  public get stateService(): StateService {
+    return this.stateServiceProviderInstance.stateService;
+  }
+
+  public get stateServiceProvider(): StateServiceProvider {
+    return this.stateServiceProviderInstance;
+  }
+
   public decorateModule(
     moduleName: StringKeyOf<Modules>,
     containedModule: InstanceType<Modules[StringKeyOf<Modules>]>
@@ -86,6 +128,15 @@ export class Protocol<
     log.debug(`Decorated ${moduleName}`);
     containedModule.protocol = this;
 
+    log.debug(
+      "Is instanceof:",
+      containedModule instanceof ProvableTransactionHook
+    );
+    if (containedModule instanceof ProvableTransactionHook) {
+      console.log(`Setting name to ${moduleName}`);
+      containedModule.name = moduleName;
+    }
+
     super.decorateModule(moduleName, containedModule);
   }
 
@@ -115,15 +166,26 @@ export class Protocol<
 }
 
 export const VanillaProtocol = {
-  create(): Protocol<{
-    StateTransitionProver: typeof StateTransitionProver;
-    BlockProver: typeof BlockProver;
-  }> {
+  create(stateService?: StateService) {
+    return VanillaProtocol.from({}, stateService);
+  },
+
+  from<AdditonalModules extends GenericProtocolModuleRecord>(
+    additionalModules: AdditonalModules,
+    stateService?: StateService
+  ): Protocol<
+    AdditonalModules & {
+      StateTransitionProver: typeof StateTransitionProver;
+      BlockProver: typeof BlockProver;
+    }
+  > {
     return Protocol.from({
       modules: {
         StateTransitionProver,
         BlockProver,
+        ...additionalModules,
       },
+      state: stateService,
     });
   },
 };

package/src/protocol/ProtocolModule.ts

@@ -1,23 +1,17 @@
 import {
   AreProofsEnabled,
   Configurable,
-  ZkProgrammable,
 } from "@proto-kit/common";
 
 import type { Protocol, ProtocolModulesRecord } from "./Protocol";
 
-export abstract class ProtocolModule<PublicInput, PublicOutput>
-  extends ZkProgrammable<PublicInput, PublicOutput>
+export abstract class ProtocolModule
   implements Configurable<unknown>
 {
   public config = {};
 
   public protocol?: Protocol<ProtocolModulesRecord>;
 
-  public constructor() {
-    super();
-  }
-
   public get appChain(): AreProofsEnabled | undefined {
     return this.protocol?.dependencyContainer.resolve<AreProofsEnabled>(
       "AppChain"

package/src/protocol/ProvableTransactionHook.ts

@@ -0,0 +1,7 @@
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+
+export abstract class ProvableTransactionHook extends TransitioningProtocolModule {
+  public abstract onTransaction(executionData: BlockProverExecutionData): void;
+}

package/src/protocol/TransitioningProtocolModule.ts

@@ -0,0 +1,5 @@
+import { ProtocolModule } from "./ProtocolModule";
+
+export abstract class TransitioningProtocolModule extends ProtocolModule {
+  public name?: string;
+}

package/src/prover/block/BlockProvable.ts

@@ -1,5 +1,5 @@
 import { Field, Proof, Struct } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { WithZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
@@ -29,7 +29,7 @@ export class BlockProverExecutionData extends Struct({
 }) {}
 
 export interface BlockProvable
-  extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+  extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
   proveTransaction: (
     publicInput: BlockProverPublicInput,
     stateProof: StateTransitionProof,