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

package/dist/blockmodules/AccountStateModule.d.ts

@@ -0,0 +1,38 @@
+import { PublicKey, UInt64 } from "snarkyjs";
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+import { StateMap } from "../state/StateMap";
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+declare const AccountState_base: (new (value: {
+    nonce: UInt64;
+}) => {
+    nonce: UInt64;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    nonce: UInt64;
+}> & {
+    toInput: (x: {
+        nonce: UInt64;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        nonce: UInt64;
+    }) => {
+        nonce: string;
+    };
+    fromJSON: (x: {
+        nonce: string;
+    }) => {
+        nonce: UInt64;
+    };
+};
+export declare class AccountState extends AccountState_base {
+}
+export declare class AccountStateModule extends ProvableTransactionHook {
+    accountState: StateMap<PublicKey, AccountState>;
+    onTransaction({ transaction }: BlockProverExecutionData): void;
+}
+export {};
+//# sourceMappingURL=AccountStateModule.d.ts.map

package/dist/blockmodules/AccountStateModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountStateModule.d.ts","sourceRoot":"","sources":["../../src/blockmodules/AccountStateModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9E,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;AAEL,qBAAa,kBAAmB,SAAQ,uBAAuB;IACrC,YAAY,oCAAmE;IAEhG,aAAa,CAAC,EAAE,WAAW,EAAE,EAAE,wBAAwB,GAAG,IAAI;CAetE"}

package/dist/blockmodules/AccountStateModule.js

@@ -0,0 +1,38 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Provable, PublicKey, Struct, UInt64 } from "snarkyjs";
+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 {
+    constructor() {
+        super(...arguments);
+        this.accountState = StateMap.from(PublicKey, AccountState);
+    }
+    onTransaction({ transaction }) {
+        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) }));
+    }
+}
+__decorate([
+    protocolState(),
+    __metadata("design:type", Object)
+], AccountStateModule.prototype, "accountState", void 0);

package/dist/blockmodules/NoopTransactionHook.d.ts

@@ -0,0 +1,6 @@
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+export declare class NoopTransactionHook extends ProvableTransactionHook {
+    onTransaction(executionData: BlockProverExecutionData): void;
+}
+//# sourceMappingURL=NoopTransactionHook.d.ts.map

package/dist/blockmodules/NoopTransactionHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoopTransactionHook.d.ts","sourceRoot":"","sources":["../../src/blockmodules/NoopTransactionHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,qBAAa,mBAAoB,SAAQ,uBAAuB;IACvD,aAAa,CAAC,aAAa,EAAE,wBAAwB,GAAG,IAAI;CAEpE"}

package/dist/blockmodules/NoopTransactionHook.js

@@ -0,0 +1,5 @@
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+export class NoopTransactionHook extends ProvableTransactionHook {
+    onTransaction(executionData) {
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./blockmodules/AccountStateModule";
 export * from "./utils/ProvableHashList";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
@@ -20,5 +21,16 @@ 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/assert/assert";
+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 { constants as ProtocolConstants } from "./Constants";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,cAAc,wCAAwC,CAAC;AACvD,cAAc,qCAAqC,CAAC;AACpD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,yDAAyD,CAAC;AACxE,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,qCAAqC,CAAC;AACpD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kEAAkE,CAAC;AACjF,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,SAAS,IAAI,iBAAiB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,cAAc,wCAAwC,CAAC;AACvD,cAAc,qCAAqC,CAAC;AACpD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,yDAAyD,CAAC;AACxE,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,qCAAqC,CAAC;AACpD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kEAAkE,CAAC;AACjF,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,OAAO,EAAE,SAAS,IAAI,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -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/assert/assert";
+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 { constants as ProtocolConstants } from "./Constants";

package/dist/model/Option.d.ts

@@ -36,6 +36,9 @@ declare const ProvableOption_base: (new (value: {
 export declare class ProvableOption extends ProvableOption_base {
     toSome(): this;
 }
+export interface ToFieldable {
+    toFields: () => Field[];
+}
 /**
  * Option facilitating in-circuit values that may or may not exist.
  */
@@ -64,14 +67,6 @@ export declare class Option<Value> {
      * @returns Empty / none option
      */
     static none(): Option<import("snarkyjs/dist/node/lib/field").Field>;
-    static dummyValueFields<Value>(valueType: FlexibleProvablePure<Value>): Field[];
-    /**
-     * 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
-     */
-    static dummyValue<Value>(valueType: FlexibleProvablePure<Value>): Value;
     isForcedSome: import("snarkyjs/dist/node/lib/bool").Bool;
     constructor(isSome: Bool, value: Value, valueType: FlexibleProvablePure<Value>);
     clone(): Option<Value>;
@@ -89,6 +84,11 @@ export declare class Option<Value> {
      * @returns Provable representation of the current option.
      */
     toProvable(): ProvableOption;
+    /**
+     * @returns Returns the value of this option if it isSome,
+     * otherwise returns the given defaultValue
+     */
+    orElse(defaultValue: Value): Value;
     toJSON(): {
         isSome: boolean;
         value: string;

package/dist/model/Option.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../src/model/Option.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EACL,KAAK,oBAAoB,EAI1B,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB,qBAAa,cAAe,SAAQ,mBAGlC;IACO,MAAM;CAId;AAED;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK;IA+Dd,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAhE/C;;;;;;;OAOG;WACW,IAAI,CAAC,KAAK,EACtB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;;;;;OAMG;WACW,SAAS,CAAC,KAAK,EAC3B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;OAEG;WACW,IAAI;WAIJ,gBAAgB,CAAC,KAAK,EAClC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,GACrC,KAAK,EAAE;IAKV;;;;;OAKG;WACW,UAAU,CAAC,KAAK,EAC5B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,GACrC,KAAK;IAOD,YAAY,6CAAe;gBAGzB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAGxC,KAAK;IAIL,SAAS;IAKhB;;OAEG;IACH,IAAW,SAAS,iDAQnB;IAED;;;OAGG;IACI,QAAQ,IAAI,KAAK,EAAE;IAO1B;;OAEG;IACI,UAAU;IAOV,MAAM;;;;CAYd"}
+{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../src/model/Option.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EAEL,KAAK,oBAAoB,EAI1B,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB,qBAAa,cAAe,SAAQ,mBAGlC;IACO,MAAM;CAId;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,KAAK,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK;IAyCd,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IA1C/C;;;;;;;OAOG;WACW,IAAI,CAAC,KAAK,EACtB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;;;;;OAMG;WACW,SAAS,CAAC,KAAK,EAC3B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;OAEG;WACW,IAAI;IAIX,YAAY,6CAAe;gBAGzB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAGxC,KAAK;IAIL,SAAS;IAKhB;;OAEG;IACH,IAAW,SAAS,iDAQnB;IAED;;;OAGG;IACI,QAAQ,IAAI,KAAK,EAAE;IAO1B;;OAEG;IACI,UAAU;IAOjB;;;OAGG;IACI,MAAM,CAAC,YAAY,EAAE,KAAK,GAAG,KAAK;IASlC,MAAM;;;;CAYd"}

package/dist/model/Option.js

@@ -39,21 +39,6 @@ export class Option {
     static none() {
         return new Option(Bool(false), Field(0), Field);
     }
-    static dummyValueFields(valueType) {
-        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
-     */
-    static dummyValue(valueType) {
-        const fields = Option.dummyValueFields(valueType);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return valueType.fromFields(fields);
-    }
     constructor(isSome, value, valueType) {
         this.isSome = isSome;
         this.value = value;
@@ -93,6 +78,13 @@ export class Option {
             value: this.treeValue,
         });
     }
+    /**
+     * @returns Returns the value of this option if it isSome,
+     * otherwise returns the given defaultValue
+     */
+    orElse(defaultValue) {
+        return Provable.if(this.isSome, this.valueType, this.value, defaultValue);
+    }
     toJSON() {
         const valueContent = this.valueType
             .toFields(this.value)

package/dist/model/StateTransition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,4EAId;IAED,IAAW,EAAE,4EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;CAOd"}
+{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAe,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElE;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,4EAId;IAED,IAAW,EAAE,4EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;CAOd"}

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -1,21 +1,65 @@
+import { Bool } from "snarkyjs";
 import { ProvableStateTransition } from "./StateTransition.js";
+export declare class StateTransitionType {
+    static readonly normal = true;
+    static readonly protocol = false;
+    static isNormal(type: boolean): boolean;
+    static isProtocol(type: boolean): boolean;
+}
+declare const ProvableStateTransitionType_base: (new (value: {
+    type: import("snarkyjs/dist/node/lib/bool").Bool;
+}) => {
+    type: import("snarkyjs/dist/node/lib/bool").Bool;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    type: import("snarkyjs/dist/node/lib/bool").Bool;
+}> & {
+    toInput: (x: {
+        type: import("snarkyjs/dist/node/lib/bool").Bool;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        type: import("snarkyjs/dist/node/lib/bool").Bool;
+    }) => {
+        type: boolean;
+    };
+    fromJSON: (x: {
+        type: boolean;
+    }) => {
+        type: import("snarkyjs/dist/node/lib/bool").Bool;
+    };
+};
+export declare class ProvableStateTransitionType extends ProvableStateTransitionType_base {
+    static get normal(): ProvableStateTransitionType;
+    static get protocol(): ProvableStateTransitionType;
+    isNormal(): Bool;
+    isProtocol(): Bool;
+}
 declare const StateTransitionProvableBatch_base: (new (value: {
     batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
 }) => {
     batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
 }) & {
     _isStruct: true;
 } & import("snarkyjs/dist/node/snarky").ProvablePure<{
     batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
 }> & {
     toInput: (x: {
         batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
     }) => {
         fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
         packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
     };
     toJSON: (x: {
         batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
     }) => {
         batch: {
             path: string;
@@ -28,6 +72,9 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 value: string;
             };
         }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
     };
     fromJSON: (x: {
         batch: {
@@ -41,16 +88,27 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 value: string;
             };
         }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
     }) => {
         batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
     };
 };
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
  */
 export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
-    static fromTransitions(transitions: ProvableStateTransition[]): StateTransitionProvableBatch;
+    static fromMappings(transitions: {
+        transition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+    }[]): StateTransitionProvableBatch;
+    static fromTransitions(transitions: ProvableStateTransition[], protocolTransitions: ProvableStateTransition[]): StateTransitionProvableBatch;
     private constructor();
 }
 export {};

package/dist/model/StateTransitionProvableBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/D;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,iCAKhD;WACc,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,GACrC,4BAA4B;IAU/B,OAAO;CAGR"}
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,UAAU,CAAC;AAIlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAG/D,qBAAa,mBAAmB;IAC9B,gBAAuB,MAAM,QAAQ;IACrC,gBAAuB,QAAQ,SAAS;WAE1B,QAAQ,CAAC,IAAI,EAAE,OAAO;WAItB,UAAU,CAAC,IAAI,EAAE,OAAO;CAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,2BAA4B,SAAQ,gCAE/C;IACA,WAAkB,MAAM,IAAI,2BAA2B,CAItD;IAED,WAAkB,QAAQ,IAAI,2BAA2B,CAIxD;IAEM,QAAQ,IAAI,IAAI;IAIhB,UAAU,IAAI,IAAI;CAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,iCAUhD;WACc,YAAY,CACxB,WAAW,EAAE;QACX,UAAU,EAAE,uBAAuB,CAAC;QACpC,IAAI,EAAE,2BAA2B,CAAC;KACnC,EAAE,GACF,4BAA4B;WAcjB,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,EACtC,mBAAmB,EAAE,uBAAuB,EAAE,GAC7C,4BAA4B;IAsB/B,OAAO;CAMR"}

package/dist/model/StateTransitionProvableBatch.js

@@ -1,19 +1,73 @@
-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 {
+    static isNormal(type) {
+        return type === StateTransitionType.normal;
+    }
+    static isProtocol(type) {
+        return type === StateTransitionType.protocol;
+    }
+}
+StateTransitionType.normal = true;
+StateTransitionType.protocol = false;
+export class ProvableStateTransitionType extends Struct({
+    type: Bool,
+}) {
+    static get normal() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.normal),
+        });
+    }
+    static get protocol() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.protocol),
+        });
+    }
+    isNormal() {
+        return this.type;
+    }
+    isProtocol() {
+        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),
 }) {
-    static fromTransitions(transitions) {
-        const array = transitions.slice();
+    static fromMappings(transitions) {
+        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,
+        });
+    }
+    static fromTransitions(transitions, protocolTransitions) {
+        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,
+        });
     }
     constructor(object) {
         super(object);

package/dist/protocol/Protocol.d.ts

@@ -1,14 +1,16 @@
 import { ModuleContainer, ModulesRecord, StringKeyOf, TypedClass } from "@proto-kit/common";
 import { DependencyContainer } 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";
-export type GenericProtocolModuleRecord = ModulesRecord<TypedClass<ProtocolModule<any, any>>>;
-interface BlockProverType extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput>, BlockProvable {
+export type GenericProtocolModuleRecord = ModulesRecord<TypedClass<ProtocolModule>>;
+interface BlockProverType extends ProtocolModule, BlockProvable {
 }
-interface StateTransitionProverType extends ProtocolModule<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, StateTransitionProvable {
+interface StateTransitionProverType extends ProtocolModule, StateTransitionProvable {
 }
 export interface ProtocolCustomModulesRecord {
     BlockProver: TypedClass<BlockProverType>;
@@ -18,9 +20,18 @@ export interface ProtocolModulesRecord extends GenericProtocolModuleRecord, Prot
 }
 export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
     modules: Modules;
+    /**
+     * @deprecated
+     */
+    state?: StateService;
 }
 export declare class Protocol<Modules extends ProtocolModulesRecord> extends ModuleContainer<Modules> {
     static from<Modules extends ProtocolModulesRecord>(modules: ProtocolDefinition<Modules>): Protocol<Modules>;
+    definition: ProtocolDefinition<Modules>;
+    private readonly stateServiceProviderInstance;
+    constructor(definition: ProtocolDefinition<Modules>);
+    get stateService(): StateService;
+    get stateServiceProvider(): StateServiceProvider;
     decorateModule(moduleName: StringKeyOf<Modules>, containedModule: InstanceType<Modules[StringKeyOf<Modules>]>): void;
     get dependencyContainer(): DependencyContainer;
     private isModule;
@@ -28,7 +39,11 @@ export declare class Protocol<Modules extends ProtocolModulesRecord> extends Mod
     get stateTransitionProver(): StateTransitionProvable;
 }
 export declare const VanillaProtocol: {
-    create(): Protocol<{
+    create(stateService?: StateService): Protocol<{
+        StateTransitionProver: typeof StateTransitionProver;
+        BlockProver: typeof BlockProver;
+    }>;
+    from<AdditonalModules extends GenericProtocolModuleRecord>(additionalModules: AdditonalModules, stateService?: StateService): Protocol<AdditonalModules & {
         StateTransitionProver: typeof StateTransitionProver;
         BlockProver: typeof BlockProver;
     }>;

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,EAEL,eAAe,EAEf,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AACxF,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,UAAU,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CACrC,CAAC;AAEF,UAAU,eACR,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CAAC,EACrE,aAAa;CAAG;AAEpB,UAAU,yBACR,SAAQ,cAAc,CAClB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,uBAAuB;CAAG;AAE9B,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,qBACf,SAAQ,2BAA2B,EACjC,2BAA2B;CAAG;AAElC,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,qBAAqB;IACvE,OAAO,EAAE,OAAO,CAAC;CAElB;AAED,qBAAa,QAAQ,CACnB,OAAO,SAAS,qBAAqB,CACrC,SAAQ,eAAe,CAAC,OAAO,CAAC;WAElB,IAAI,CAAC,OAAO,SAAS,qBAAqB,EACtD,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC;IAsB/B,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED,OAAO,CAAC,QAAQ;IAMhB,IAAW,WAAW,IAAI,aAAa,CAMtC;IAED,IAAW,qBAAqB,IAAI,uBAAuB,CAI1D;CACF;AAED,eAAO,MAAM,eAAe;cAChB,SAAS;QACjB,uBAAuB,4BAA4B,CAAC;QACpD,aAAa,kBAAkB,CAAC;KACjC,CAAC;CAQH,CAAC"}
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../src/protocol/Protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EAEf,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;AAIlD,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,UAAU,CAAC,cAAc,CAAC,CAC3B,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;CAC9D;AAED,MAAM,WAAW,qBACf,SAAQ,2BAA2B,EACjC,2BAA2B;CAAG;AAElC,MAAM,WAAW,kBAAkB,CAAC,OAAO,SAAS,qBAAqB;IACvE,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;CAEtB;AAED,qBAAa,QAAQ,CACnB,OAAO,SAAS,qBAAqB,CACrC,SAAQ,eAAe,CAAC,OAAO,CAAC;WAElB,IAAI,CAAC,OAAO,SAAS,qBAAqB,EACtD,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC;IAsB/B,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAE/C,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAG3C;gBAEiB,UAAU,EAAE,kBAAkB,CAAC,OAAO,CAAC;IA+B1D,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;IAiB9D,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED,OAAO,CAAC,QAAQ;IAMhB,IAAW,WAAW,IAAI,aAAa,CAMtC;IAED,IAAW,qBAAqB,IAAI,uBAAuB,CAI1D;CACF;AAED,eAAO,MAAM,eAAe;0BACJ,YAAY;+BASP,4BAA4B;qBACtC,kBAAkB;;mHAJlB,YAAY;+BAGF,4BAA4B;qBACtC,kBAAkB;;CAYpC,CAAC"}

package/dist/protocol/Protocol.js

@@ -1,6 +1,10 @@
 import { log, ModuleContainer, } from "@proto-kit/common";
+import { Lifecycle } from "tsyringe";
 import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
 import { BlockProver } from "../prover/block/BlockProver";
+import { StateServiceProvider } from "../state/StateServiceProvider";
+import { ProvableTransactionHook } from "./ProvableTransactionHook";
+import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
 export class Protocol extends ModuleContainer {
     // .from() to create Protocol
     static from(modules) {
@@ -18,9 +22,43 @@ export class Protocol extends ModuleContainer {
         protocol.configure(emptyConfig);
         return protocol;
     }
+    constructor(definition) {
+        super(definition);
+        this.stateServiceProviderInstance = new StateServiceProvider(
+        // eslint-disable-next-line etc/no-deprecated
+        this.definition.state);
+        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 ()
+        // })
+    }
+    get stateService() {
+        return this.stateServiceProviderInstance.stateService;
+    }
+    get stateServiceProvider() {
+        return this.stateServiceProviderInstance;
+    }
     decorateModule(moduleName, containedModule) {
         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);
     }
     get dependencyContainer() {
@@ -39,12 +77,17 @@ export class Protocol extends ModuleContainer {
     }
 }
 export const VanillaProtocol = {
-    create() {
+    create(stateService) {
+        return VanillaProtocol.from({}, stateService);
+    },
+    from(additionalModules, stateService) {
         return Protocol.from({
             modules: {
                 StateTransitionProver,
                 BlockProver,
+                ...additionalModules,
             },
+            state: stateService,
         });
     },
 };

package/dist/protocol/ProtocolModule.d.ts

@@ -1,9 +1,8 @@
-import { AreProofsEnabled, Configurable, ZkProgrammable } from "@proto-kit/common";
+import { AreProofsEnabled, Configurable } from "@proto-kit/common";
 import type { Protocol, ProtocolModulesRecord } from "./Protocol";
-export declare abstract class ProtocolModule<PublicInput, PublicOutput> extends ZkProgrammable<PublicInput, PublicOutput> implements Configurable<unknown> {
+export declare abstract class ProtocolModule implements Configurable<unknown> {
     config: {};
     protocol?: Protocol<ProtocolModulesRecord>;
-    constructor();
     get appChain(): AreProofsEnabled | undefined;
 }
 //# sourceMappingURL=ProtocolModule.d.ts.map

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,YAAY,EACZ,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAElE,8BAAsB,cAAc,CAAC,WAAW,EAAE,YAAY,CAC5D,SAAQ,cAAc,CAAC,WAAW,EAAE,YAAY,CAChD,YAAW,YAAY,CAAC,OAAO,CAAC;IAEzB,MAAM,KAAM;IAEZ,QAAQ,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;;IAMlD,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAIlD;CACF"}
+{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,YAAY,EACb,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAElE,8BAAsB,cACpB,YAAW,YAAY,CAAC,OAAO,CAAC;IAEzB,MAAM,KAAM;IAEZ,QAAQ,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;IAElD,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAIlD;CACF"}

package/dist/protocol/ProtocolModule.js

@@ -1,7 +1,5 @@
-import { ZkProgrammable, } from "@proto-kit/common";
-export class ProtocolModule extends ZkProgrammable {
+export class ProtocolModule {
     constructor() {
-        super();
         this.config = {};
     }
     get appChain() {

package/dist/protocol/ProvableTransactionHook.d.ts

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

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

@@ -0,0 +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,uBAAwB,SAAQ,2BAA2B;aAC/D,aAAa,CAAC,aAAa,EAAE,wBAAwB,GAAG,IAAI;CAC7E"}

package/dist/protocol/ProvableTransactionHook.js

@@ -0,0 +1,3 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export class ProvableTransactionHook extends TransitioningProtocolModule {
+}

package/dist/protocol/TransitioningProtocolModule.d.ts

@@ -0,0 +1,5 @@
+import { ProtocolModule } from "./ProtocolModule";
+export declare abstract class TransitioningProtocolModule extends ProtocolModule {
+    name?: string;
+}
+//# sourceMappingURL=TransitioningProtocolModule.d.ts.map

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

@@ -0,0 +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,2BAA4B,SAAQ,cAAc;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/protocol/TransitioningProtocolModule.js

@@ -0,0 +1,3 @@
+import { ProtocolModule } from "./ProtocolModule";
+export class TransitioningProtocolModule extends ProtocolModule {
+}