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

package/dist/model/transaction/RuntimeTransaction.js

@@ -1,4 +1,6 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
+import { Bool, Field, Poseidon, PublicKey, Struct, UInt64, } from "o1js";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
+import { EMPTY_PUBLICKEY, EMPTY_PUBLICKEY_X } from "@proto-kit/common";
 /**
  * This struct is used to expose transaction information to the runtime method
  * execution. This class has not all data included in transactions on purpose.
@@ -6,24 +8,79 @@ import { Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
  */
 export class RuntimeTransaction extends Struct({
     methodId: Field,
-    nonce: UInt64,
-    sender: PublicKey,
     argsHash: Field,
+    nonce: UInt64Option,
+    sender: PublicKeyOption,
 }) {
-    static fromProtocolTransaction({ methodId, nonce, sender, argsHash, }) {
+    static fromTransaction(input) {
+        return new RuntimeTransaction({
+            methodId: input.methodId,
+            argsHash: input.argsHash,
+            nonce: UInt64Option.fromValue(input.nonce),
+            sender: PublicKeyOption.fromValue(input.sender),
+        });
+    }
+    static fromMessage({ methodId, argsHash, }) {
         return new RuntimeTransaction({
             methodId,
-            nonce,
-            sender,
             argsHash,
+            nonce: UInt64Option.none(UInt64.zero),
+            sender: PublicKeyOption.none(EMPTY_PUBLICKEY),
         });
     }
-    hash() {
-        return Poseidon.hash([
+    static dummyTransaction() {
+        return new RuntimeTransaction({
+            methodId: Field(0),
+            nonce: new UInt64Option({
+                isSome: Bool(true),
+                value: UInt64.zero,
+            }),
+            sender: new PublicKeyOption({
+                isSome: Bool(true),
+                value: EMPTY_PUBLICKEY,
+            }),
+            argsHash: Field(0),
+        });
+    }
+    assertTransactionType(isMessage) {
+        const isTransaction = isMessage.not();
+        // isSome has to be true when it is a transaction, otherwise false
+        this.nonce.isSome
+            .equals(isTransaction)
+            .assertTrue("Nonce is not right option isSome for type");
+        this.sender.isSome
+            .equals(isTransaction)
+            .assertTrue("Sender is not right option isSome for type");
+        this.sender.value.x
+            .equals(EMPTY_PUBLICKEY_X)
+            .equals(isMessage)
+            .assertTrue("Transaction sender is not set to dummy");
+    }
+    hashData() {
+        return [
             this.methodId,
-            ...this.sender.toFields(),
-            ...this.nonce.toFields(),
+            ...this.sender.value.toFields(),
+            ...this.nonce.value.toFields(),
             this.argsHash,
-        ]);
+        ];
+    }
+    static fromHashData(fields) {
+        // sender is 2nd and the first element is x (2nd isOdd)
+        const isMessage = fields[1].equals(EMPTY_PUBLICKEY_X);
+        return new RuntimeTransaction({
+            methodId: fields[0],
+            sender: new PublicKeyOption({
+                isSome: isMessage.not(),
+                value: PublicKey.fromFields([fields[1], fields[2]]),
+            }),
+            nonce: new UInt64Option({
+                isSome: isMessage.not(),
+                value: UInt64.fromFields([fields[3]]),
+            }),
+            argsHash: fields[4],
+        });
+    }
+    hash() {
+        return Poseidon.hash(this.hashData());
     }
 }

package/dist/model/transaction/SignedTransaction.d.ts

@@ -0,0 +1,71 @@
+import { Bool, Field, Signature, UInt64 } from "o1js";
+import { RuntimeTransaction } from "./RuntimeTransaction";
+declare const SignedTransaction_base: (new (value: {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}) => {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/lib/provable").Provable<{
+    transaction: RuntimeTransaction;
+    signature: Signature;
+}> & {
+    toInput: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    }) => {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+    };
+    fromJSON: (x: {
+        transaction: {
+            methodId: string;
+            argsHash: string;
+            nonce: {
+                isSome: boolean;
+                value: any;
+            };
+            sender: {
+                isSome: boolean;
+                value: any;
+            };
+        };
+        signature: any;
+    }) => {
+        transaction: RuntimeTransaction;
+        signature: Signature;
+    };
+};
+export declare class SignedTransaction extends SignedTransaction_base {
+    static getSignatureData(args: {
+        methodId: Field;
+        nonce: UInt64;
+        argsHash: Field;
+    }): Field[];
+    static dummy(): SignedTransaction;
+    hash(): Field;
+    getSignatureData(): Field[];
+    validateSignature(): Bool;
+}
+export {};
+//# sourceMappingURL=SignedTransaction.d.ts.map

package/dist/model/transaction/SignedTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignedTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/SignedTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EAEL,SAAS,EAET,MAAM,EACP,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1D,qBAAa,iBAAkB,SAAQ,sBAGrC;WACc,gBAAgB,CAAC,IAAI,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,KAAK,CAAC;KACjB,GAAG,KAAK,EAAE;WAIG,KAAK,IAAI,iBAAiB;IAWjC,IAAI,IAAI,KAAK;IAIb,gBAAgB,IAAI,KAAK,EAAE;IAS3B,iBAAiB,IAAI,IAAI;CAMjC"}

package/dist/model/transaction/SignedTransaction.js

@@ -0,0 +1,33 @@
+import { Field, Scalar, Signature, Struct, } from "o1js";
+import { RuntimeTransaction } from "./RuntimeTransaction";
+export class SignedTransaction extends Struct({
+    transaction: RuntimeTransaction,
+    signature: Signature,
+}) {
+    static getSignatureData(args) {
+        return [args.methodId, ...args.nonce.value.toFields(), args.argsHash];
+    }
+    static dummy() {
+        return new SignedTransaction({
+            transaction: RuntimeTransaction.dummyTransaction(),
+            signature: Signature.fromObject({
+                s: Scalar.from(0),
+                r: Field(0),
+            }),
+        });
+    }
+    hash() {
+        return this.transaction.hash();
+    }
+    getSignatureData() {
+        const { methodId, argsHash, nonce } = this.transaction;
+        return SignedTransaction.getSignatureData({
+            nonce: nonce.value,
+            methodId,
+            argsHash,
+        });
+    }
+    validateSignature() {
+        return this.signature.verify(this.transaction.sender.value, this.getSignatureData());
+    }
+}

package/dist/model/transaction/ValueOption.d.ts

@@ -0,0 +1,119 @@
+import { PublicKey, UInt64 } from "o1js";
+declare const UInt64Option_base: {
+    new (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    fromValue(value: UInt64): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    none(value: UInt64): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    _isStruct: true;
+    toFields: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => import("o1js/dist/node/lib/field").Field[];
+    toAuxiliary: (value?: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    } | undefined) => any[];
+    fromFields: (fields: import("o1js/dist/node/lib/field").Field[], aux: any[]) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+    sizeInFields(): number;
+    check: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => void;
+    toInput: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    }) => {
+        isSome: boolean;
+        value: any;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: any;
+    }) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: UInt64;
+    };
+};
+export declare class UInt64Option extends UInt64Option_base {
+}
+declare const PublicKeyOption_base: {
+    new (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    fromValue(value: PublicKey): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    none(value: PublicKey): {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    _isStruct: true;
+    toFields: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => import("o1js/dist/node/lib/field").Field[];
+    toAuxiliary: (value?: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    } | undefined) => any[];
+    fromFields: (fields: import("o1js/dist/node/lib/field").Field[], aux: any[]) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+    sizeInFields(): number;
+    check: (value: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => void;
+    toInput: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    }) => {
+        isSome: boolean;
+        value: any;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: any;
+    }) => {
+        isSome: import("o1js/dist/node/lib/bool").Bool;
+        value: PublicKey;
+    };
+};
+export declare class PublicKeyOption extends PublicKeyOption_base {
+}
+export {};
+//# sourceMappingURL=ValueOption.d.ts.map

package/dist/model/transaction/ValueOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueOption.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/ValueOption.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBzE,qBAAa,YAAa,SAAQ,iBAAoC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzE,qBAAa,eAAgB,SAAQ,oBAEpC;CAAG"}

package/dist/model/transaction/ValueOption.js

@@ -0,0 +1,24 @@
+import { Bool, PublicKey, Struct, UInt64 } from "o1js";
+function genericOptionFactory(valueType) {
+    return class Generic extends Struct({
+        isSome: Bool,
+        value: valueType,
+    }) {
+        static fromValue(value) {
+            return new Generic({
+                isSome: Bool(true),
+                value,
+            });
+        }
+        static none(value) {
+            return new Generic({
+                isSome: Bool(false),
+                value,
+            });
+        }
+    };
+}
+export class UInt64Option extends genericOptionFactory(UInt64) {
+}
+export class PublicKeyOption extends genericOptionFactory(PublicKey) {
+}

package/dist/protocol/Protocol.d.ts

@@ -7,15 +7,19 @@ import { StateService } from "../state/StateService";
 import { ProtocolModule } from "./ProtocolModule";
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
 import { AccountStateModule } from "../blockmodules/AccountStateModule";
+import { BlockHeightHook } from "../blockmodules/BlockHeightHook";
+import { LastStateRootBlockHook } from "../blockmodules/LastStateRootBlockHook";
 export type GenericProtocolModuleRecord = ModulesRecord<TypedClass<ProtocolModule<unknown>>>;
 interface BlockProverType extends ProtocolModule, BlockProvable {
 }
 interface StateTransitionProverType extends ProtocolModule, StateTransitionProvable {
 }
-export interface ProtocolCustomModulesRecord {
+export interface ProtocolCustomModulesRecord extends GenericProtocolModuleRecord {
     BlockProver: TypedClass<BlockProverType>;
     StateTransitionProver: TypedClass<StateTransitionProverType>;
     AccountState: TypedClass<AccountStateModule>;
+    BlockHeight: TypedClass<BlockHeightHook>;
+    LastStateRoot: TypedClass<LastStateRootBlockHook>;
 }
 export interface ProtocolModulesRecord extends GenericProtocolModuleRecord, ProtocolCustomModulesRecord {
 }
@@ -38,8 +42,8 @@ export declare class Protocol<Modules extends ProtocolModulesRecord> extends Mod
     create(childContainerProvider: ChildContainerProvider): void;
 }
 export declare const VanillaProtocol: {
-    create(): TypedClass<Protocol<ProtocolModulesRecord>>;
-    from<AdditonalModules extends GenericProtocolModuleRecord>(additionalModules: AdditonalModules): TypedClass<Protocol<ProtocolModulesRecord>>;
+    create(): TypedClass<Protocol<ProtocolCustomModulesRecord>>;
+    from<AdditonalModules extends GenericProtocolModuleRecord>(additionalModules: AdditonalModules): TypedClass<Protocol<ProtocolCustomModulesRecord & AdditonalModules>>;
 };
 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,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAUhF,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,2BACf,SAAQ,2BAA2B;IACnC,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,qBAAqB,EAAE,UAAU,CAAC,yBAAyB,CAAC,CAAC;IAC7D,YAAY,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC7C,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IACzC,aAAa,EAAE,UAAU,CAAC,sBAAsB,CAAC,CAAC;CACnD;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;CAoD7D;AAED,eAAO,MAAM,eAAe;;;CAmB3B,CAAC"}

package/dist/protocol/Protocol.js

@@ -8,9 +8,13 @@ import { AccountStateModule } from "../blockmodules/AccountStateModule";
 import { ProvableBlockHook } from "./ProvableBlockHook";
 import { NoopBlockHook } from "../blockmodules/NoopBlockHook";
 import { BlockHeightHook } from "../blockmodules/BlockHeightHook";
+import { LastStateRootBlockHook } from "../blockmodules/LastStateRootBlockHook";
+import { ProvableSettlementHook } from "../settlement/ProvableSettlementHook";
+import { NoopSettlementHook } from "../blockmodules/NoopSettlementHook";
 const PROTOCOL_INJECTION_TOKENS = {
     ProvableTransactionHook: "ProvableTransactionHook",
     ProvableBlockHook: "ProvableBlockHook",
+    ProvableSettlementHook: "ProvableSettlementHook",
 };
 export class Protocol extends ModuleContainer {
     // .from() to create Protocol
@@ -60,25 +64,30 @@ 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 = {
@@ -92,6 +101,7 @@ export const VanillaProtocol = {
                 BlockProver,
                 AccountState: AccountStateModule,
                 BlockHeight: BlockHeightHook,
+                LastStateRoot: LastStateRootBlockHook,
                 ...additionalModules,
             },
         });

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