@proto-kit/protocol 0.1.1-develop.244 → 0.1.1-develop.254

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

@@ -1 +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"}
+{"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,oCAGlC;IAEK,aAAa,CAAC,EAAE,WAAW,EAAE,EAAE,wBAAwB,GAAG,IAAI;CActE"}

package/dist/blockmodules/AccountStateModule.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { PublicKey, Struct, UInt64 } from "snarkyjs";
 import { StateMap } from "../state/StateMap";
 import { protocolState } from "../state/protocol/ProtocolState";
 import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
@@ -26,8 +26,6 @@ export class AccountStateModule extends ProvableTransactionHook {
             .get(transaction.sender)
             .orElse(new AccountState({ nonce: UInt64.zero }));
         const currentNonce = accountState.nonce;
-        Provable.log("Current Nonce", currentNonce);
-        Provable.log("Tx Nonce", transaction.nonce);
         assert(currentNonce.equals(transaction.nonce), "Nonce not matching");
         this.accountState.set(transaction.sender, new AccountState({ nonce: currentNonce.add(1) }));
     }

package/dist/model/Option.d.ts

@@ -36,9 +36,6 @@ 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.
  */

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,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"}
+{"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;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/StateTransition.d.ts

@@ -1,30 +1,30 @@
 import { Field } from "snarkyjs";
-import { Option, ProvableOption } from "./Option.js";
+import { Option, ProvableOption } from "./Option";
 declare const ProvableStateTransition_base: (new (value: {
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+    path: import("snarkyjs/dist/node/lib/field").Field;
     from: ProvableOption;
     to: ProvableOption;
 }) => {
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+    path: import("snarkyjs/dist/node/lib/field").Field;
     from: ProvableOption;
     to: ProvableOption;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    path: import("snarkyjs/dist/node/lib/field").Field;
     from: ProvableOption;
     to: ProvableOption;
 }> & {
     toInput: (x: {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("snarkyjs/dist/node/lib/field").Field;
         from: ProvableOption;
         to: ProvableOption;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field.js").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field.js").Field, number][] | undefined;
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("snarkyjs/dist/node/lib/field").Field;
         from: ProvableOption;
         to: ProvableOption;
     }) => {
@@ -49,7 +49,7 @@ declare const ProvableStateTransition_base: (new (value: {
             value: string;
         };
     }) => {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("snarkyjs/dist/node/lib/field").Field;
         from: ProvableOption;
         to: ProvableOption;
     };
@@ -73,8 +73,8 @@ export declare class StateTransition<Value> {
     static from<Value>(path: Field, fromValue: Option<Value>): StateTransition<Value>;
     static fromTo<Value>(path: Field, fromValue: Option<Value>, toValue: Option<Value>): StateTransition<Value>;
     constructor(path: Field, fromValue: Option<Field> | Option<Value>, toValue: Option<Field> | Option<Value>);
-    get from(): Option<import("snarkyjs/dist/node/lib/field.js").Field> | Option<Value>;
-    get to(): Option<import("snarkyjs/dist/node/lib/field.js").Field> | Option<Value>;
+    get from(): Option<import("snarkyjs/dist/node/lib/field").Field> | Option<Value>;
+    get to(): Option<import("snarkyjs/dist/node/lib/field").Field> | Option<Value>;
     /**
      * Converts a StateTransition to a ProvableStateTransition,
      * while enforcing the 'from' property to be 'Some' in all cases.

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;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,yEAId;IAED,IAAW,EAAE,yEAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;CAOd"}

package/dist/model/StateTransition.js

@@ -1,5 +1,5 @@
 import { Field, Struct } from "snarkyjs";
-import { Option, ProvableOption } from "./Option.js";
+import { Option, ProvableOption } from "./Option";
 /**
  * Provable representation of a State Transition, used to
  * normalize state transitions of various value types for

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,UAAU,CAAC;AAKlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,mBAAmB;IAC9B,gBAAuB,MAAM,QAAQ;IAErC,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;WAyBjB,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,EACtC,mBAAmB,EAAE,uBAAuB,EAAE,GAC7C,4BAA4B;IAsB/B,OAAO;CAMR"}

package/dist/model/StateTransitionProvableBatch.js

@@ -1,7 +1,7 @@
 import { Bool, Provable, Struct } from "snarkyjs";
+import { range } from "@proto-kit/common";
 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;
@@ -46,6 +46,16 @@ export class StateTransitionProvableBatch extends Struct({
     static fromMappings(transitions) {
         const batch = transitions.map((entry) => entry.transition);
         const transitionTypes = transitions.map((entry) => entry.type);
+        // Check that order is correct
+        let normalSTsStarted = false;
+        transitionTypes.forEach((x) => {
+            if (!normalSTsStarted && x.isNormal().toBoolean()) {
+                normalSTsStarted = true;
+            }
+            if (normalSTsStarted && x.isProtocol().toBoolean()) {
+                throw new Error("Order in initializing STBatch not correct");
+            }
+        });
         while (batch.length < constants.stateTransitionProverBatchSize) {
             batch.push(ProvableStateTransition.dummy());
             transitionTypes.push(ProvableStateTransitionType.normal);

package/dist/prover/block/BlockProver.js

@@ -55,22 +55,20 @@ export class BlockProverProgrammable extends ZkProgrammable {
         appProof.verify();
         stateTransitionProof.verify();
         const stateTo = { ...state };
-        // eslint-disable-next-line no-warning-comments
-        // TODO Check methodId?
         // Checks for the stateTransitionProof and appProof matching
         stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
         appProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
-        // Apply state if status success
+        // Assert from state roots
         state.stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
-        stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicInput.stateRoot);
+        state.stateRoot.assertEquals(stateTransitionProof.publicInput.protocolStateRoot, errors.propertyNotMatching("from protocol state root"));
+        // Apply state if status success
+        stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicOutput.protocolStateRoot);
         // Apply protocol state transitions
         this.assertProtocolTransitions(stateTransitionProof, executionData);
         // Check transaction signature
         transaction
             .validateSignature()
             .assertTrue("Transaction signature not valid");
-        // Check if the methodId is correct
-        // to do
         // Check transaction integrity against appProof
         const blockTransactionHash = RuntimeTransaction.fromProtocolTransaction(transaction).hash();
         blockTransactionHash.assertEquals(appProof.publicOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");

package/dist/prover/statetransition/StateTransitionProvable.d.ts

@@ -6,21 +6,25 @@ declare const StateTransitionProverPublicInput_base: (new (value: {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) => {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) & {
     _isStruct: true;
 } & import("snarkyjs/dist/node/snarky").ProvablePure<{
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }> & {
     toInput: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
         packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
@@ -29,19 +33,23 @@ declare const StateTransitionProverPublicInput_base: (new (value: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
         stateRoot: string;
+        protocolStateRoot: string;
     };
     fromJSON: (x: {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
         stateRoot: string;
+        protocolStateRoot: string;
     }) => {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     };
 };
 export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
@@ -50,21 +58,25 @@ declare const StateTransitionProverPublicOutput_base: (new (value: {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) => {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) & {
     _isStruct: true;
 } & import("snarkyjs/dist/node/snarky").ProvablePure<{
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }> & {
     toInput: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
         packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
@@ -73,19 +85,23 @@ declare const StateTransitionProverPublicOutput_base: (new (value: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
         stateRoot: string;
+        protocolStateRoot: string;
     };
     fromJSON: (x: {
         stateTransitionsHash: string;
         protocolTransitionsHash: string;
         stateRoot: string;
+        protocolStateRoot: string;
     }) => {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        protocolStateRoot: import("snarkyjs/dist/node/lib/field").Field;
     };
 };
 export declare class StateTransitionProverPublicOutput extends StateTransitionProverPublicOutput_base {

package/dist/prover/statetransition/StateTransitionProvable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAIpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAIrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,iCAAiC,CAAC;IAEvC,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,iCAAiC,CAAC;CACxC"}
+{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,iCAAiC,CAAC;IAEvC,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,iCAAiC,CAAC;CACxC"}

package/dist/prover/statetransition/StateTransitionProvable.js

@@ -3,11 +3,13 @@ export class StateTransitionProverPublicInput extends Struct({
     stateTransitionsHash: Field,
     protocolTransitionsHash: Field,
     stateRoot: Field,
+    protocolStateRoot: Field,
 }) {
 }
 export class StateTransitionProverPublicOutput extends Struct({
     stateTransitionsHash: Field,
     protocolTransitionsHash: Field,
     stateRoot: Field,
+    protocolStateRoot: Field,
 }) {
 }

package/dist/prover/statetransition/StateTransitionProver.d.ts

@@ -8,6 +8,7 @@ import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransit
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 interface StateTransitionProverExecutionState {
     stateRoot: Field;
+    protocolStateRoot: Field;
     stateTransitionList: ProvableHashList<ProvableStateTransition>;
     protocolTransitionList: ProvableHashList<ProvableStateTransition>;
 }
@@ -26,7 +27,7 @@ export declare class StateTransitionProverProgrammable extends ZkProgrammable<St
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, protocolTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
+    applyTransitions(stateRoot: Field, protocolStateRoot: Field, stateTransitionCommitmentFrom: Field, protocolTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
     /**
      * Applies a single state transition to the given state
      * and mutates it in place

package/dist/prover/statetransition/StateTransitionProver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEpE,OAAO,EACL,gBAAgB,EAChB,cAAc,EAEd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAsBpG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA4BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAyCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAgB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CA0CrC;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAE1E,OAAO,EACL,gBAAgB,EAEhB,cAAc,EAEd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAqDX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAkB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAqErC;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -20,12 +20,9 @@ import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 const errors = {
-    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
-    stateTransitionsHashNotMatching: (step) => `State transitions hash not matching ${step}`,
-    protocolTransitionsHashNotMatching: (step) => `Protocol transitions hash not matching ${step}`,
-    merkleWitnessNotCorrect: (index) => `MerkleWitness not valid for StateTransition (${index})`,
+    propertyNotMatching: (property, step) => `${property} not matching ${step}`,
+    merkleWitnessNotCorrect: (index, type) => `MerkleWitness not valid for StateTransition (${index}, type ${type})`,
     noWitnessProviderSet: () => new Error("WitnessProvider not set, set it before you use StateTransitionProvider"),
-    propertyNotMatching: (propertyName) => `${propertyName} not matching`,
 };
 const StateTransitionSelfProofClass = (SelfProof);
 /**
@@ -91,9 +88,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot, stateTransitionCommitmentFrom, protocolTransitionCommitmentFrom, transitionBatch) {
+    applyTransitions(stateRoot, protocolStateRoot, stateTransitionCommitmentFrom, protocolTransitionCommitmentFrom, transitionBatch) {
         const state = {
             stateRoot,
+            protocolStateRoot,
             stateTransitionList: new DefaultProvableHashList(ProvableStateTransition, stateTransitionCommitmentFrom),
             protocolTransitionList: new DefaultProvableHashList(ProvableStateTransition, protocolTransitionCommitmentFrom),
         };
@@ -113,11 +111,12 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
         const membershipValid = MerkleTreeUtils.checkMembership(treeWitness, state.stateRoot, transition.path, transition.from.value);
         membershipValid
             .or(transition.from.isSome.not())
-            .assertTrue(errors.merkleWitnessNotCorrect(index));
-        const t = Date.now();
+            .assertTrue(errors.merkleWitnessNotCorrect(index, type.isNormal().toBoolean() ? "normal" : "protocol"));
         const newRoot = MerkleTreeUtils.computeRoot(treeWitness, transition.to.value);
-        Provable.log("Compute root took", Date.now() - t, "ms");
         state.stateRoot = Provable.if(transition.to.isSome, newRoot, state.stateRoot);
+        // Only update protocol state root if ST is also of type protocol
+        // Since protocol STs are all at the start of the batch, this works
+        state.protocolStateRoot = Provable.if(transition.to.isSome.and(type.isProtocol()), newRoot, state.protocolStateRoot);
         const isNotDummy = transition.path.equals(Field(0)).not();
         state.stateTransitionList.pushIf(transition, isNotDummy.and(type.isNormal()));
         state.protocolTransitionList.pushIf(transition, isNotDummy.and(type.isProtocol()));
@@ -126,29 +125,34 @@ export class StateTransitionProverProgrammable extends ZkProgrammable {
      * Applies a whole batch of StateTransitions at once
      */
     runBatch(publicInput, batch) {
-        const result = this.applyTransitions(publicInput.stateRoot, publicInput.stateTransitionsHash, publicInput.protocolTransitionsHash, batch);
+        const result = this.applyTransitions(publicInput.stateRoot, publicInput.protocolStateRoot, publicInput.stateTransitionsHash, publicInput.protocolTransitionsHash, batch);
         return new StateTransitionProverPublicOutput({
             stateRoot: result.stateRoot,
             stateTransitionsHash: result.stateTransitionList.commitment,
             protocolTransitionsHash: result.protocolTransitionList.commitment,
+            protocolStateRoot: result.protocolStateRoot,
         });
     }
     merge(publicInput, proof1, proof2) {
         proof1.verify();
         proof2.verify();
         // Check state
-        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.propertyNotMatching("stateRoot", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.propertyNotMatching("stateRoot", "proof1.to -> proof2.from"));
         // Check ST list
-        publicInput.stateTransitionsHash.assertEquals(proof1.publicInput.stateTransitionsHash, errors.stateTransitionsHashNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.stateTransitionsHash.assertEquals(proof2.publicInput.stateTransitionsHash, errors.stateTransitionsHashNotMatching("proof1.to -> proof2.from"));
+        publicInput.stateTransitionsHash.assertEquals(proof1.publicInput.stateTransitionsHash, errors.propertyNotMatching("stateTransitionsHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateTransitionsHash.assertEquals(proof2.publicInput.stateTransitionsHash, errors.propertyNotMatching("stateTransitionsHash", "proof1.to -> proof2.from"));
         // Check Protocol ST list
-        publicInput.protocolTransitionsHash.assertEquals(proof1.publicInput.protocolTransitionsHash, errors.protocolTransitionsHashNotMatching("publicInput.from -> proof1.from"));
-        proof1.publicOutput.protocolTransitionsHash.assertEquals(proof2.publicInput.protocolTransitionsHash, errors.protocolTransitionsHashNotMatching("proof1.to -> proof2.from"));
+        publicInput.protocolTransitionsHash.assertEquals(proof1.publicInput.protocolTransitionsHash, errors.propertyNotMatching("protocolTransitionsHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.protocolTransitionsHash.assertEquals(proof2.publicInput.protocolTransitionsHash, errors.propertyNotMatching("protocolTransitionsHash", "proof1.to -> proof2.from"));
+        // Check protocol state root
+        publicInput.protocolStateRoot.assertEquals(proof1.publicInput.protocolStateRoot, errors.propertyNotMatching("protocolStateRoot", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.protocolStateRoot.assertEquals(proof2.publicInput.protocolStateRoot, errors.propertyNotMatching("protocolStateRoot", "proof1.to -> proof2.from"));
         return new StateTransitionProverPublicInput({
             stateRoot: proof2.publicOutput.stateRoot,
             stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
             protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
+            protocolStateRoot: proof2.publicOutput.protocolStateRoot,
         });
     }
 }

package/dist/state/assert/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/state/assert/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAO1C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAWvD"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/state/assert/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAMhC;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAWvD"}

package/dist/state/assert/assert.js

@@ -1,4 +1,3 @@
-import { Bool, Provable } from "snarkyjs";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
@@ -14,7 +13,7 @@ import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecution
 export function assert(condition, message) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const previousStatus = executionContext.current().result.status;
-    const status = Provable.if(previousStatus, Bool, condition, previousStatus);
+    const status = condition.and(previousStatus);
     if (!condition.toBoolean()) {
         log.debug("Assertion failed: ", message);
         executionContext.setStatusMessage(message);

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

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

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.244+5a8dddf",
+  "version": "0.1.1-develop.254+2fba72e",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -31,5 +31,5 @@
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "5a8dddf57ba06ef3cd067c9f1ad97c4e32a3223d"
+  "gitHead": "2fba72ec580c20289658d5c831430ca601ea5a71"
 }

package/src/blockmodules/AccountStateModule.ts

@@ -11,7 +11,10 @@ export class AccountState extends Struct({
 }) {}
 
 export class AccountStateModule extends ProvableTransactionHook {
-  @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(PublicKey, AccountState);
+  @protocolState() public accountState = StateMap.from<PublicKey, AccountState>(
+    PublicKey,
+    AccountState
+  );
 
   public onTransaction({ transaction }: BlockProverExecutionData): void {
     const accountState = this.accountState
@@ -19,8 +22,7 @@ export class AccountStateModule extends ProvableTransactionHook {
       .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(

package/src/model/Option.ts

@@ -1,7 +1,6 @@
 import {
   Bool,
   Field,
-  FlexibleProvable,
   type FlexibleProvablePure,
   Poseidon,
   Provable,
@@ -18,10 +17,6 @@ export class ProvableOption extends Struct({
   }
 }
 
-export interface ToFieldable {
-  toFields: () => Field[];
-}
-
 /**
  * Option facilitating in-circuit values that may or may not exist.
  */

package/src/model/StateTransition.ts

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

package/src/model/StateTransitionProvableBatch.ts

@@ -1,12 +1,13 @@
 import { Bool, Provable, Struct } from "snarkyjs";
+import { range } from "@proto-kit/common";
 
 import { constants } from "../Constants";
 
 import { ProvableStateTransition } from "./StateTransition.js";
-import { range } from "@proto-kit/common";
 
 export class StateTransitionType {
   public static readonly normal = true;
+
   public static readonly protocol = false;
 
   public static isNormal(type: boolean) {
@@ -69,6 +70,17 @@ export class StateTransitionProvableBatch extends Struct({
     const batch = transitions.map((entry) => entry.transition);
     const transitionTypes = transitions.map((entry) => entry.type);
 
+    // Check that order is correct
+    let normalSTsStarted = false;
+    transitionTypes.forEach((x) => {
+      if (!normalSTsStarted && x.isNormal().toBoolean()) {
+        normalSTsStarted = true;
+      }
+      if (normalSTsStarted && x.isProtocol().toBoolean()) {
+        throw new Error("Order in initializing STBatch not correct");
+      }
+    });
+
     while (batch.length < constants.stateTransitionProverBatchSize) {
       batch.push(ProvableStateTransition.dummy());
       transitionTypes.push(ProvableStateTransitionType.normal);

package/src/prover/block/BlockProver.ts

@@ -110,9 +110,6 @@ export class BlockProverProgrammable extends ZkProgrammable<
 
     const stateTo = { ...state };
 
-    // eslint-disable-next-line no-warning-comments
-    // TODO Check methodId?
-
     // Checks for the stateTransitionProof and appProof matching
     stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(
       Field(0),
@@ -124,15 +121,21 @@ export class BlockProverProgrammable extends ZkProgrammable<
       errors.stateTransitionsHashNotEqual()
     );
 
-    // Apply state if status success
+    // Assert from state roots
     state.stateRoot.assertEquals(
       stateTransitionProof.publicInput.stateRoot,
       errors.propertyNotMatching("from state root")
     );
+    state.stateRoot.assertEquals(
+      stateTransitionProof.publicInput.protocolStateRoot,
+      errors.propertyNotMatching("from protocol state root")
+    );
+
+    // Apply state if status success
     stateTo.stateRoot = Provable.if(
       appProof.publicOutput.status,
       stateTransitionProof.publicOutput.stateRoot,
-      stateTransitionProof.publicInput.stateRoot
+      stateTransitionProof.publicOutput.protocolStateRoot
     );
 
     // Apply protocol state transitions
@@ -143,9 +146,6 @@ export class BlockProverProgrammable extends ZkProgrammable<
       .validateSignature()
       .assertTrue("Transaction signature not valid");
 
-    // Check if the methodId is correct
-    // to do
-
     // Check transaction integrity against appProof
     const blockTransactionHash =
       RuntimeTransaction.fromProtocolTransaction(transaction).hash();

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -9,12 +9,14 @@ export class StateTransitionProverPublicInput extends Struct({
   stateTransitionsHash: Field,
   protocolTransitionsHash: Field,
   stateRoot: Field,
+  protocolStateRoot: Field,
 }) {}
 
 export class StateTransitionProverPublicOutput extends Struct({
   stateTransitionsHash: Field,
   protocolTransitionsHash: Field,
   stateRoot: Field,
+  protocolStateRoot: Field,
 }) {}
 
 export type StateTransitionProof = Proof<

package/src/prover/statetransition/StateTransitionProver.ts

@@ -1,8 +1,9 @@
 /* eslint-disable max-lines */
-import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
+import { Bool, Experimental, Field, Provable, SelfProof } from "snarkyjs";
 import { injectable } from "tsyringe";
 import {
   AreProofsEnabled,
+  log,
   PlainZkProgram,
   provableMethod,
   ZkProgrammable,
@@ -34,27 +35,21 @@ import {
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 
 const errors = {
-  stateRootNotMatching: (step: string) => `StateRoots not matching ${step}`,
+  propertyNotMatching: (property: string, step: string) =>
+    `${property} not matching ${step}`,
 
-  stateTransitionsHashNotMatching: (step: string) =>
-    `State transitions hash not matching ${step}`,
-
-  protocolTransitionsHashNotMatching: (step: string) =>
-    `Protocol transitions hash not matching ${step}`,
-
-  merkleWitnessNotCorrect: (index: number) =>
-    `MerkleWitness not valid for StateTransition (${index})`,
+  merkleWitnessNotCorrect: (index: number, type: string) =>
+    `MerkleWitness not valid for StateTransition (${index}, type ${type})`,
 
   noWitnessProviderSet: () =>
     new Error(
       "WitnessProvider not set, set it before you use StateTransitionProvider"
     ),
-
-  propertyNotMatching: (propertyName: string) => `${propertyName} not matching`,
 };
 
 interface StateTransitionProverExecutionState {
   stateRoot: Field;
+  protocolStateRoot: Field;
   stateTransitionList: ProvableHashList<ProvableStateTransition>;
   protocolTransitionList: ProvableHashList<ProvableStateTransition>;
 }
@@ -154,12 +149,14 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
    */
   public applyTransitions(
     stateRoot: Field,
+    protocolStateRoot: Field,
     stateTransitionCommitmentFrom: Field,
     protocolTransitionCommitmentFrom: Field,
     transitionBatch: StateTransitionProvableBatch
   ): StateTransitionProverExecutionState {
     const state: StateTransitionProverExecutionState = {
       stateRoot,
+      protocolStateRoot,
 
       stateTransitionList: new DefaultProvableHashList(
         ProvableStateTransition,
@@ -205,16 +202,20 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       transition.path,
       transition.from.value
     );
+
     membershipValid
       .or(transition.from.isSome.not())
-      .assertTrue(errors.merkleWitnessNotCorrect(index));
+      .assertTrue(
+        errors.merkleWitnessNotCorrect(
+          index,
+          type.isNormal().toBoolean() ? "normal" : "protocol"
+        )
+      );
 
-    const t = Date.now();
     const newRoot = MerkleTreeUtils.computeRoot(
       treeWitness,
       transition.to.value
     );
-    Provable.log("Compute root took", Date.now() - t, "ms");
 
     state.stateRoot = Provable.if(
       transition.to.isSome,
@@ -222,6 +223,14 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       state.stateRoot
     );
 
+    // Only update protocol state root if ST is also of type protocol
+    // Since protocol STs are all at the start of the batch, this works
+    state.protocolStateRoot = Provable.if(
+      transition.to.isSome.and(type.isProtocol()),
+      newRoot,
+      state.protocolStateRoot
+    );
+
     const isNotDummy = transition.path.equals(Field(0)).not();
 
     state.stateTransitionList.pushIf(
@@ -244,6 +253,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   ): StateTransitionProverPublicOutput {
     const result = this.applyTransitions(
       publicInput.stateRoot,
+      publicInput.protocolStateRoot,
       publicInput.stateTransitionsHash,
       publicInput.protocolTransitionsHash,
       batch
@@ -253,6 +263,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       stateRoot: result.stateRoot,
       stateTransitionsHash: result.stateTransitionList.commitment,
       protocolTransitionsHash: result.protocolTransitionList.commitment,
+      protocolStateRoot: result.protocolStateRoot,
     });
   }
 
@@ -268,39 +279,66 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     // Check state
     publicInput.stateRoot.assertEquals(
       proof1.publicInput.stateRoot,
-      errors.stateRootNotMatching("publicInput.from -> proof1.from")
+      errors.propertyNotMatching("stateRoot", "publicInput.from -> proof1.from")
     );
     proof1.publicOutput.stateRoot.assertEquals(
       proof2.publicInput.stateRoot,
-      errors.stateRootNotMatching("proof1.to -> proof2.from")
+      errors.propertyNotMatching("stateRoot", "proof1.to -> proof2.from")
     );
 
     // Check ST list
     publicInput.stateTransitionsHash.assertEquals(
       proof1.publicInput.stateTransitionsHash,
-      errors.stateTransitionsHashNotMatching("publicInput.from -> proof1.from")
+      errors.propertyNotMatching(
+        "stateTransitionsHash",
+        "publicInput.from -> proof1.from"
+      )
     );
     proof1.publicOutput.stateTransitionsHash.assertEquals(
       proof2.publicInput.stateTransitionsHash,
-      errors.stateTransitionsHashNotMatching("proof1.to -> proof2.from")
+      errors.propertyNotMatching(
+        "stateTransitionsHash",
+        "proof1.to -> proof2.from"
+      )
     );
 
     // Check Protocol ST list
     publicInput.protocolTransitionsHash.assertEquals(
       proof1.publicInput.protocolTransitionsHash,
-      errors.protocolTransitionsHashNotMatching(
+      errors.propertyNotMatching(
+        "protocolTransitionsHash",
         "publicInput.from -> proof1.from"
       )
     );
     proof1.publicOutput.protocolTransitionsHash.assertEquals(
       proof2.publicInput.protocolTransitionsHash,
-      errors.protocolTransitionsHashNotMatching("proof1.to -> proof2.from")
+      errors.propertyNotMatching(
+        "protocolTransitionsHash",
+        "proof1.to -> proof2.from"
+      )
+    );
+
+    // Check protocol state root
+    publicInput.protocolStateRoot.assertEquals(
+      proof1.publicInput.protocolStateRoot,
+      errors.propertyNotMatching(
+        "protocolStateRoot",
+        "publicInput.from -> proof1.from"
+      )
+    );
+    proof1.publicOutput.protocolStateRoot.assertEquals(
+      proof2.publicInput.protocolStateRoot,
+      errors.propertyNotMatching(
+        "protocolStateRoot",
+        "proof1.to -> proof2.from"
+      )
     );
 
     return new StateTransitionProverPublicInput({
       stateRoot: proof2.publicOutput.stateRoot,
       stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
       protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
+      protocolStateRoot: proof2.publicOutput.protocolStateRoot,
     });
   }
 }

package/src/state/assert/assert.test.ts

@@ -5,6 +5,8 @@ import { container } from "tsyringe";
 
 import { assert } from "./assert";
 import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
 
 describe("assert", () => {
   const defaultStatusMessage = "something went wrong";
@@ -12,6 +14,11 @@ describe("assert", () => {
 
   beforeEach(() => {
     executionContext.beforeMethod("testConstructor", "test", []);
+
+    executionContext.setup({
+      transaction: undefined as unknown as RuntimeTransaction,
+      networkState: undefined as unknown as NetworkState,
+    });
   });
 
   afterEach(() => {

package/src/state/assert/assert.ts

@@ -1,9 +1,8 @@
-import { Bool, Provable } from "snarkyjs";
+import { Bool } from "snarkyjs";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 
 import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
-import { exec } from "child_process";
 
 /**
  * Maintains an execution status of the current runtime module method,
@@ -17,7 +16,7 @@ import { exec } from "child_process";
 export function assert(condition: Bool, message?: string) {
   const executionContext = container.resolve(RuntimeMethodExecutionContext);
   const previousStatus = executionContext.current().result.status;
-  const status = Provable.if(previousStatus, Bool, condition, previousStatus);
+  const status = condition.and(previousStatus);
 
   if (!condition.toBoolean()) {
     log.debug("Assertion failed: ", message);

package/src/state/protocol/ProtocolState.ts

@@ -1,5 +1,4 @@
 import { State } from "../State";
-import { ToFieldable } from "../../model/Option";
 import { Path } from "../../model/Path";
 import { TransitioningProtocolModule } from "../../protocol/TransitioningProtocolModule";
 

package/test/State.test.ts

@@ -0,0 +1,45 @@
+import "reflect-metadata";
+import { Bool, Field, Provable, UInt64 } from "snarkyjs";
+import { container } from "tsyringe";
+
+import {
+  NetworkState,
+  noop,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  State,
+  StateService,
+  StateServiceProvider,
+} from "../src";
+
+describe("state", () => {
+  beforeEach(() => {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+
+    executionContext.setup({
+      transaction: undefined as unknown as RuntimeTransaction,
+      networkState: undefined as unknown as NetworkState,
+    });
+  });
+
+  it("should decode state correctly", () => {
+    expect.assertions(2);
+
+    const state = State.from<UInt64>(UInt64);
+    const stateService: StateService = {
+      get: () => [Field(123)],
+
+      set: () => {
+        noop();
+      },
+    };
+    state.stateServiceProvider = new StateServiceProvider();
+    state.stateServiceProvider.setCurrentStateService(stateService);
+    state.path = Field(1);
+
+    const retrieved = state.get();
+
+    expect(retrieved.isSome).toStrictEqual(Bool(true));
+    expect(retrieved.value).toStrictEqual(UInt64.from(123));
+  });
+});

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

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

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

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

package/dist/utils/merkletree/MemoryMerkleTreeStorage.js

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