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

package/dist/utils/MinaPrefixedProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtB,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}
+{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EACd,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}

package/dist/utils/PrefixedProvableHashList.d.ts

@@ -1,8 +1,8 @@
-import { Field, FlexibleProvablePure } from "o1js";
+import { Field, ProvablePure } from "o1js";
 import { ProvableHashList } from "./ProvableHashList.js";
 export declare class PrefixedProvableHashList<Value> extends ProvableHashList<Value> {
     private readonly prefix;
-    constructor(valueType: FlexibleProvablePure<Value>, prefix: string, internalCommitment?: Field);
+    constructor(valueType: ProvablePure<Value>, prefix: string, internalCommitment?: Field);
     protected hash(elements: Field[]): Field;
 }
 //# sourceMappingURL=PrefixedProvableHashList.d.ts.map

package/dist/utils/PrefixedProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/PrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAG7B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,KAAgB;IAMtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGzC"}
+{"version":3,"file":"PrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/PrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAY,MAAM,MAAM,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAG7B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,KAAgB;IAMtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGzC"}

package/dist/utils/ProvableHashList.d.ts

@@ -1,11 +1,11 @@
-import { Field, FlexibleProvablePure, Bool } from "o1js";
+import { Field, Bool, ProvablePure } from "o1js";
 /**
  * Utilities for creating a hash list from a given value type.
  */
 export declare abstract class ProvableHashList<Value> {
-    private readonly valueType;
+    protected readonly valueType: ProvablePure<Value>;
     commitment: Field;
-    constructor(valueType: FlexibleProvablePure<Value>, commitment?: Field);
+    constructor(valueType: ProvablePure<Value>, commitment?: Field);
     protected abstract hash(elements: Field[]): Field;
     /**
      * Converts the provided value to Field[] and appends it to

package/dist/utils/ProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,oBAAoB,EAAE,IAAI,EAAY,MAAM,MAAM,CAAC;AAE7E;;GAEG;AACH,8BAAsB,gBAAgB,CAAC,KAAK;IAExC,OAAO,CAAC,QAAQ,CAAC,SAAS;IACnB,UAAU,EAAE,KAAK;gBADP,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAChD,UAAU,GAAE,KAAgB;IAGrC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;IAEjD;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,KAAK;IAQjB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAS3C;;OAEG;IACI,OAAO;CAGf;AAED,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAClE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}
+{"version":3,"file":"ProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,IAAI,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAErE;;GAEG;AACH,8BAAsB,gBAAgB,CAAC,KAAK;IAExC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC;IAC1C,UAAU,EAAE,KAAK;gBADL,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1C,UAAU,GAAE,KAAgB;IAGrC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;IAEjD;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,KAAK;IAQjB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAS3C;;OAEG;IACI,OAAO;CAGf;AAED,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAClE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}

package/dist/utils/ProvableReductionHashList.d.ts

@@ -0,0 +1,14 @@
+import { Bool, Field } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export declare class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
+    unconstrainedList: Value[];
+    private constrainedLastValue;
+    private preimage;
+    pushAndReduce(value: Value, reduce: (previous: Value) => [Value, Bool]): {
+        popLast: Bool;
+        value: Value;
+    };
+    pushIf(value: Value, condition: Bool): this;
+    hash(elements: Field[]): Field;
+}
+//# sourceMappingURL=ProvableReductionHashList.d.ts.map

package/dist/utils/ProvableReductionHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableReductionHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableReductionHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAsB,MAAM,MAAM,CAAC;AAEvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,yBAAyB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IACpE,iBAAiB,EAAE,KAAK,EAAE,CAAM;IAEvC,OAAO,CAAC,oBAAoB,CAAgC;IAE5D,OAAO,CAAC,QAAQ,CAA0B;IAEnC,aAAa,CAClB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,GACzC;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE;IA4C3B,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAMpC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}

package/dist/utils/ProvableReductionHashList.js

@@ -0,0 +1,50 @@
+import { Bool, Poseidon, Provable } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export class ProvableReductionHashList extends ProvableHashList {
+    constructor() {
+        super(...arguments);
+        this.unconstrainedList = [];
+        this.constrainedLastValue = undefined;
+        this.preimage = this.commitment;
+    }
+    pushAndReduce(value, reduce) {
+        let valueToPush = value;
+        let popLast = Bool(false);
+        // Theoretically, we can feed the preimage + last value as a witness
+        // for non-zero commitment starts (like used in the BlockProver), because
+        // currently it won't reduce across chunks. But this is okay for now I think
+        if (this.constrainedLastValue !== undefined) {
+            [valueToPush, popLast] = reduce(this.constrainedLastValue);
+        }
+        Provable.asProver(() => {
+            if (popLast.toBoolean()) {
+                this.unconstrainedList.pop();
+            }
+            const valueAsConstant = this.valueType.fromFields(this.valueType.toFields(valueToPush).map((field) => field.toConstant()));
+            this.unconstrainedList.push(valueAsConstant);
+        });
+        const currentCommitment = this.commitment;
+        const noPopCommitment = this.hash([
+            currentCommitment,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        const popCommitment = this.hash([
+            this.preimage,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        this.commitment = Provable.if(popLast, popCommitment, noPopCommitment);
+        this.constrainedLastValue = valueToPush;
+        this.preimage = Provable.if(popLast, this.preimage, currentCommitment);
+        return {
+            popLast,
+            value: valueToPush,
+        };
+    }
+    pushIf(value, condition) {
+        throw new Error("pushIf is not implemented for ReducedHashList");
+        return this;
+    }
+    hash(elements) {
+        return Poseidon.hash(elements);
+    }
+}

package/dist/utils/StateTransitionReductionList.d.ts

@@ -0,0 +1,11 @@
+import { ProvableStateTransition, StateTransition } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export declare class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+    push(value: ProvableStateTransition): this;
+    pushWithMetadata(value: ProvableStateTransition): {
+        popLast: import("o1js/dist/node/lib/bool").Bool;
+        value: ProvableStateTransition;
+    };
+}
+export declare function reduceStateTransitions(transitions: StateTransition<unknown>[]): StateTransition<unknown>[];
+//# sourceMappingURL=StateTransitionReductionList.d.ts.map

package/dist/utils/StateTransitionReductionList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/utils/StateTransitionReductionList.js

@@ -0,0 +1,60 @@
+import { Provable } from "o1js";
+import { ProvableOption } from "../model/Option";
+import { ProvableStateTransition, StateTransition, } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export class StateTransitionReductionList extends ProvableReductionHashList {
+    push(value) {
+        this.pushWithMetadata(value);
+        return this;
+    }
+    pushWithMetadata(value) {
+        return this.pushAndReduce(value, (previous) => {
+            const pathsMatch = previous.path.equals(value.path);
+            // Take the previous.from if the paths match, otherwise leave ST as is
+            const from = Provable.if(pathsMatch, ProvableOption, previous.from, value.from);
+            // In case we have a layout like
+            // { from: 5, to: 10 }, { from: 10, to: none }
+            // we just take the first and discard the second
+            const to = Provable.if(value.to.isSome.or(pathsMatch.not()), ProvableOption, value.to, previous.to);
+            const transition = new ProvableStateTransition({
+                path: value.path,
+                from: new ProvableOption(from),
+                to: new ProvableOption(to),
+            });
+            // Assert that connection is correct
+            previous.to.value
+                .equals(value.from.value)
+                .or(previous.to.isSome
+                .not()
+                .and(previous.from.value.equals(value.from.value)))
+                .or(pathsMatch.not())
+                .assertTrue();
+            return [transition, pathsMatch];
+        });
+    }
+}
+export function reduceStateTransitions(transitions) {
+    const reduced = [];
+    for (const st of transitions) {
+        if (reduced.length === 0) {
+            reduced.push(st);
+            continue;
+        }
+        const last = reduced.at(-1);
+        if (last.path.equals(st.path).toBoolean()) {
+            if (st.toValue.isSome.toBoolean()) {
+                reduced.pop();
+                reduced.push(new StateTransition(st.path, last.fromValue, st.toValue));
+            }
+            else {
+                // Do nothing, because we discard that ST
+                // { from: 5, to: 10 }, { from: 10, to: none }
+                // cancel the 2nd
+            }
+        }
+        else {
+            reduced.push(st);
+        }
+    }
+    return reduced;
+}

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.600+699a7df",
+  "version": "0.1.1-develop.651+7591cb6",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -32,5 +32,5 @@
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "699a7dfa3b5d3415ab4500f0cd495d6781365c6a"
+  "gitHead": "7591cb6bdf58a6cd525a10902c25bc292efcfc6b"
 }

package/src/{blockmodules/AccountStateModule.ts → hooks/AccountStateHook.ts}

@@ -5,12 +5,14 @@ import { StateMap } from "../state/StateMap";
 import { protocolState } from "../state/protocol/ProtocolState";
 import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
 import { assert } from "../state/assert/assert";
+import { injectable } from "tsyringe";
 
 export class AccountState extends Struct({
   nonce: UInt64,
 }) {}
 
-export class AccountStateModule extends ProvableTransactionHook {
+@injectable()
+export class AccountStateHook extends ProvableTransactionHook {
   @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
     PublicKey,
     AccountState

package/src/{blockmodules → hooks}/NoopSettlementHook.ts

@@ -2,11 +2,10 @@ import { injectable } from "tsyringe";
 import { noop } from "@proto-kit/common";
 import { SmartContract } from "o1js";
 
-import { BlockProof } from "../prover/block/BlockProver";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
-} from "../settlement/ProvableSettlementHook";
+} from "../settlement/modularity/ProvableSettlementHook";
 
 @injectable()
 export class NoopSettlementHook extends ProvableSettlementHook<

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from "./blockmodules/AccountStateModule";
-export * from "./blockmodules/BlockHeightHook";
-export * from "./blockmodules/LastStateRootBlockHook";
+export * from "./hooks/AccountStateHook";
+export * from "./hooks/BlockHeightHook";
 export * from "./utils/ProvableHashList";
+export * from "./hooks/LastStateRootBlockHook";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
 export * from "./model/Option";
@@ -10,8 +10,13 @@ export * from "./model/network/NetworkState";
 export * from "./model/transaction/SignedTransaction";
 export * from "./model/transaction/RuntimeTransaction";
 export * from "./model/transaction/ValueOption";
+export * from "./model/MethodPublicOutput";
+export * from "./model/RuntimeLike";
+export * from "./utils/ProvableHashList";
 export * from "./utils/PrefixedProvableHashList";
 export * from "./utils/MinaPrefixedProvableHashList";
+export * from "./utils/ProvableReductionHashList";
+export * from "./utils/StateTransitionReductionList";
 export * from "./utils/utils";
 export * from "./prover/block/BlockProver";
 export * from "./prover/block/BlockProvable";
@@ -19,7 +24,6 @@ export * from "./prover/block/accummulators/BlockHashMerkleTree";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
 export * from "./prover/statetransition/StateTransitionWitnessProvider";
-export * from "./model/MethodPublicOutput";
 export * from "./prover/statetransition/StateTransitionWitnessProviderReference";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
@@ -35,7 +39,15 @@ export * from "./state/StateMap";
 export * from "./state/StateService";
 export * from "./state/StateServiceProvider";
 export * from "./state/assert/assert";
-export * from "./settlement/SettlementContract";
-export * from "./settlement/ProvableSettlementHook";
+export * from "./settlement/contracts/SettlementSmartContract";
+export * from "./settlement/contracts/SettlementContractProtocolModule";
+export * from "./settlement/contracts/DispatchSmartContract";
+export * from "./settlement/contracts/DispatchContractProtocolModule";
+export * from "./settlement/SettlementContractModule";
+export * from "./settlement/ContractModule";
+export * from "./settlement/modularity/ProvableSettlementHook";
+export * from "./settlement/messages/OutgoingMessageArgument";
 export * from "./settlement/modules/NetworkStateSettlementModule";
+export * from "./settlement/messages/Deposit";
+export * from "./settlement/messages/Withdrawal";
 export { constants as ProtocolConstants } from "./Constants";

package/src/model/Option.ts

@@ -4,6 +4,7 @@ import {
   type FlexibleProvablePure,
   Poseidon,
   Provable,
+  ProvablePure,
   Struct,
 } from "o1js";
 
@@ -149,4 +150,19 @@ export class Option<Value> extends OptionBase {
       defaultValue
     );
   }
+
+  public toConstant() {
+    const valueConstant = (this.valueType as ProvablePure<Value>).fromFields(
+      this.valueType.toFields(this.value).map((field) => field.toConstant())
+    );
+    const boolConstant = (bool: Bool) =>
+      Bool.fromFields([bool.toField().toConstant()]);
+
+    return new Option(
+      boolConstant(this.isSome),
+      valueConstant,
+      this.valueType,
+      boolConstant(this.isForcedSome)
+    );
+  }
 }

package/src/model/RuntimeLike.ts

@@ -0,0 +1,12 @@
+export type RuntimeMethodInvocationType = "INCOMING_MESSAGE" | "SIGNATURE";
+
+export type RuntimeMethodIdMapping = Record<
+  `${string}.${string}`,
+  { methodId: bigint; type: RuntimeMethodInvocationType }
+>;
+
+export interface RuntimeLike {
+  get methodIdResolver(): {
+    methodIdMap: () => RuntimeMethodIdMapping;
+  };
+}

package/src/model/StateTransition.ts

@@ -1,4 +1,4 @@
-import { Field, Struct } from "o1js";
+import { Bool, Field, ProvablePure, Struct } from "o1js";
 
 import { Option, ProvableOption } from "./Option";
 
@@ -44,7 +44,7 @@ export class StateTransition<Value> {
 
   public constructor(
     public path: Field,
-    public fromValue: Option<Field> | Option<Value>,
+    public fromValue: Option<Value>,
     public toValue: Option<Field> | Option<Value>
   ) {}
 
@@ -77,4 +77,12 @@ export class StateTransition<Value> {
       to: this.toValue.toJSON(),
     };
   }
+
+  public toConstant(): StateTransition<Value> {
+    return new StateTransition<Value>(
+      this.path.toConstant(),
+      this.fromValue.toConstant(),
+      this.toValue.toConstant()
+    );
+  }
 }

package/src/protocol/Protocol.ts

@@ -19,15 +19,15 @@ import { StateService } from "../state/StateService";
 
 import { ProtocolModule } from "./ProtocolModule";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
-import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
+import { NoopTransactionHook } from "../hooks/NoopTransactionHook";
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
-import { AccountStateModule } from "../blockmodules/AccountStateModule";
+import { AccountStateHook } from "../hooks/AccountStateHook";
 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";
+import { NoopBlockHook } from "../hooks/NoopBlockHook";
+import { BlockHeightHook } from "../hooks/BlockHeightHook";
+import { LastStateRootBlockHook } from "../hooks/LastStateRootBlockHook";
+import { ProvableSettlementHook } from "../settlement/modularity/ProvableSettlementHook";
+import { NoopSettlementHook } from "../hooks/NoopSettlementHook";
 
 const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableTransactionHook: "ProvableTransactionHook",
@@ -35,42 +35,38 @@ const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableSettlementHook: "ProvableSettlementHook",
 };
 
-export type GenericProtocolModuleRecord = ModulesRecord<
+export type ProtocolModulesRecord = ModulesRecord<
   TypedClass<ProtocolModule<unknown>>
 >;
 
-interface BlockProverType extends ProtocolModule, BlockProvable {}
+export interface BlockProverType extends ProtocolModule, BlockProvable {}
 
-interface StateTransitionProverType
+export interface StateTransitionProverType
   extends ProtocolModule,
     StateTransitionProvable {}
 
-export interface ProtocolCustomModulesRecord
-  extends GenericProtocolModuleRecord {
+export type MandatoryProtocolModulesRecord = {
   BlockProver: TypedClass<BlockProverType>;
   StateTransitionProver: TypedClass<StateTransitionProverType>;
-  AccountState: TypedClass<AccountStateModule>;
+  AccountState: TypedClass<AccountStateHook>;
   BlockHeight: TypedClass<BlockHeightHook>;
   LastStateRoot: TypedClass<LastStateRootBlockHook>;
-}
-
-export interface ProtocolModulesRecord
-  extends GenericProtocolModuleRecord,
-    ProtocolCustomModulesRecord {}
+};
 
 export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
   modules: Modules;
   config?: ModulesConfig<Modules>;
 }
 
-export class Protocol<Modules extends ProtocolModulesRecord>
+export class Protocol<
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord
+  >
   extends ModuleContainer<Modules>
   implements ProtocolEnvironment
 {
-  // .from() to create Protocol
-  public static from<Modules extends ProtocolModulesRecord>(
-    modules: ProtocolDefinition<Modules>
-  ): TypedClass<Protocol<Modules>> {
+  public static from<
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord
+  >(modules: ProtocolDefinition<Modules>): TypedClass<Protocol<Modules>> {
     return class ScopedProtocol extends Protocol<Modules> {
       public constructor() {
         super(modules);
@@ -188,24 +184,3 @@ export class Protocol<Modules extends ProtocolModulesRecord>
     });
   }
 }
-
-export const VanillaProtocol = {
-  create() {
-    return VanillaProtocol.from({});
-  },
-
-  from<AdditonalModules extends GenericProtocolModuleRecord>(
-    additionalModules: AdditonalModules
-  ): TypedClass<Protocol<ProtocolCustomModulesRecord & AdditonalModules>> {
-    return Protocol.from<ProtocolCustomModulesRecord & AdditonalModules>({
-      modules: {
-        StateTransitionProver,
-        BlockProver,
-        AccountState: AccountStateModule,
-        BlockHeight: BlockHeightHook,
-        LastStateRoot: LastStateRootBlockHook,
-        ...additionalModules,
-      },
-    });
-  },
-};

package/src/protocol/ProtocolModule.ts

@@ -1,8 +1,9 @@
 import {
   AreProofsEnabled,
   ChildContainerProvider,
-  ConfigurableModule, NoConfig,
-  noop
+  ConfigurableModule,
+  NoConfig,
+  noop,
 } from "@proto-kit/common";
 
 import { ProtocolEnvironment } from "./ProtocolEnvironment";

package/src/prover/block/BlockProver.ts

@@ -2,10 +2,11 @@
 import {
   Bool,
   Experimental,
-  Field, Poseidon,
+  Field,
+  Poseidon,
   type Proof,
   Provable,
-  SelfProof
+  SelfProof,
 } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import {
@@ -35,7 +36,11 @@ import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethod
 import { ProvableBlockHook } from "../../protocol/ProvableBlockHook";
 import { NetworkState } from "../../model/network/NetworkState";
 import { SignedTransaction } from "../../model/transaction/SignedTransaction";
-import { MinaActions, MinaActionsHashList } from "../../utils/MinaPrefixedProvableHashList";
+import {
+  MinaActions,
+  MinaActionsHashList,
+} from "../../utils/MinaPrefixedProvableHashList";
+import { StateTransitionReductionList } from "../../utils/StateTransitionReductionList";
 
 import {
   BlockProvable,
@@ -274,7 +279,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       transition.toProvable()
     );
 
-    const hashList = new DefaultProvableHashList(
+    const hashList = new StateTransitionReductionList(
       ProvableStateTransition,
       stateTransitionProof.publicInput.protocolTransitionsHash
     );
@@ -369,7 +374,9 @@ export class BlockProverProgrammable extends ZkProgrammable<
     // Append tx to incomingMessagesHash
     const actionHash = MinaActions.actionHash(transaction.hashData());
 
-    const incomingMessagesList = new MinaActionsHashList(state.incomingMessagesHash);
+    const incomingMessagesList = new MinaActionsHashList(
+      state.incomingMessagesHash
+    );
     incomingMessagesList.pushIf(actionHash, isMessage);
 
     stateTo.incomingMessagesHash = incomingMessagesList.commitment;
@@ -506,7 +513,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       "beforeBlock"
     );
 
-    const beforeBlockHashList = new DefaultProvableHashList(
+    const beforeBlockHashList = new StateTransitionReductionList(
       ProvableStateTransition
     );
     beforeBlockResult.stateTransitions.forEach((st) => {
@@ -554,7 +561,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       "afterBlock"
     );
 
-    const afterBlockHashList = new DefaultProvableHashList(
+    const afterBlockHashList = new StateTransitionReductionList(
       ProvableStateTransition
     );
     afterBlockResult.stateTransitions.forEach((st) => {
@@ -568,7 +575,11 @@ export class BlockProverProgrammable extends ZkProgrammable<
       afterBlockHashList.commitment,
       "STProof from-ST-hash not matching generated ST-hash from afterBlock hooks"
     );
-    state.stateRoot = stateTransitionProof.publicInput.stateRoot;
+    state.stateRoot = Provable.if(
+      stsEmitted,
+      stateTransitionProof.publicOutput.stateRoot,
+      state.stateRoot
+    );
 
     // 6. Close block
 
@@ -800,6 +811,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     return {
       compile: program.compile.bind(program),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProofClass,
       methods,
     };

package/src/prover/block/accummulators/BlockHashMerkleTree.ts

@@ -1,7 +1,7 @@
 import { createMerkleTree } from "@proto-kit/common";
 import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
 
-export class BlockHashMerkleTree extends createMerkleTree(16) {}
+export class BlockHashMerkleTree extends createMerkleTree(40) {}
 export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}
 
 export class BlockHashTreeEntry extends Struct({

package/src/prover/statetransition/StateTransitionProver.ts

@@ -30,6 +30,7 @@ import {
   StateTransitionProverPublicOutput,
 } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 
 const errors = {
   propertyNotMatching: (property: string, step: string) =>
@@ -127,6 +128,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     return {
       compile: program.compile.bind(program),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProofClass,
       methods,
     };
@@ -339,9 +341,9 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
 @injectable()
 export class StateTransitionProver
   extends ProtocolModule
-  implements StateTransitionProvable
+  implements StateTransitionProvable, StateTransitionProverType
 {
-  public readonly zkProgrammable: StateTransitionProverProgrammable;
+  public zkProgrammable: StateTransitionProverProgrammable;
 
   public constructor(
     // Injected

package/src/settlement/ContractModule.ts

@@ -0,0 +1,24 @@
+import { ConfigurableModule, NoConfig, TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+
+export type SmartContractClassFromInterface<Type> = typeof SmartContract &
+  TypedClass<Type>;
+
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export abstract class ContractModule<
+  ContractType,
+  // undefined = no args
+  Arguments = undefined,
+  Config = NoConfig
+> extends ConfigurableModule<Config> {
+  public abstract contractFactory(
+    args: Arguments
+  ): SmartContractClassFromInterface<ContractType>;
+}