@proto-kit/protocol 0.1.1-develop.165 → 0.1.1-develop.1665

package/dist/model/Path.js

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-import { Field, Poseidon } from "snarkyjs";
+import { Field, Poseidon } from "o1js";
+import { hashWithPrefix } from "@proto-kit/common";
 import { stringToField } from "../utils/utils";
 /**
  * Helps manage path (key) identifiers for key-values in trees.
@@ -20,10 +19,11 @@ export class Path {
      *
      * @param className
      * @param propertyKey
+     * @param prefix
      * @returns Field representation of class name + property name
      */
-    static fromProperty(className, propertyKey) {
-        return Poseidon.hash([
+    static fromProperty(className, propertyKey, prefix) {
+        return hashWithPrefix(prefix, [
             Path.toField(className),
             Path.toField(propertyKey),
             Field(0),
@@ -42,3 +42,4 @@ export class Path {
         return Poseidon.hash([path, keyHash]);
     }
 }
+//# sourceMappingURL=Path.js.map

package/dist/model/Path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Path.js","sourceRoot":"","sources":["../../src/model/Path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA6B,QAAQ,EAAE,MAAM,MAAM,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;GAEG;AACH,MAAM,OAAO,IAAI;IACf;;;;;OAKG;IACI,MAAM,CAAC,OAAO,CAAC,KAAa;QACjC,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,YAAY,CACxB,SAAiB,EACjB,WAAmB,EACnB,MAAc;QAEd,OAAO,cAAc,CAAC,MAAM,EAAE;YAC5B,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;YACvB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;YACzB,KAAK,CAAC,CAAC,CAAC;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,OAAO,CACnB,IAAW,EACX,OAAsC,EACtC,GAAY;QAEZ,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;QACrD,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IACxC,CAAC;CACF"}

package/dist/model/RuntimeLike.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeLike.d.ts","sourceRoot":"","sources":["../../src/model/RuntimeLike.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAAG,MAAM,CACzC,GAAG,MAAM,IAAI,MAAM,EAAE,EACrB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,2BAA2B,CAAA;CAAE,CACxD,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,gBAAgB,IAAI;QACtB,WAAW,EAAE,MAAM,sBAAsB,CAAC;KAC3C,CAAC;CACH"}

package/dist/model/RuntimeLike.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RuntimeLike.js.map

package/dist/model/RuntimeLike.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeLike.js","sourceRoot":"","sources":["../../src/model/RuntimeLike.ts"],"names":[],"mappings":""}

package/dist/model/StateTransition.d.ts

@@ -1,30 +1,61 @@
-import { Field } from "snarkyjs";
-import { Option, ProvableOption } from "./Option.js";
+import { Field } from "o1js";
+import { Option, ProvableOption } from "./Option";
 declare const ProvableStateTransition_base: (new (value: {
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+    path: import("o1js/dist/node/lib/provable/field").Field;
     from: ProvableOption;
     to: ProvableOption;
 }) => {
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+    path: import("o1js/dist/node/lib/provable/field").Field;
     from: ProvableOption;
     to: ProvableOption;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
-    path: import("snarkyjs/dist/node/lib/field.js").Field;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    path: import("o1js/dist/node/lib/provable/field").Field;
     from: ProvableOption;
     to: ProvableOption;
-}> & {
+}, {
+    path: bigint;
+    from: {
+        isSome: boolean;
+        value: bigint;
+    };
+    to: {
+        isSome: boolean;
+        value: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+} & {
+    fromValue: (value: {
+        path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        to: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
     toInput: (x: {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("o1js/dist/node/lib/provable/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("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
         from: ProvableOption;
         to: ProvableOption;
     }) => {
@@ -49,7 +80,12 @@ declare const ProvableStateTransition_base: (new (value: {
             value: string;
         };
     }) => {
-        path: import("snarkyjs/dist/node/lib/field.js").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+    empty: () => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
         from: ProvableOption;
         to: ProvableOption;
     };
@@ -61,6 +97,7 @@ declare const ProvableStateTransition_base: (new (value: {
  */
 export declare class ProvableStateTransition extends ProvableStateTransition_base {
     static dummy(): ProvableStateTransition;
+    static isDummy(stateTransition: ProvableStateTransition): import("o1js/dist/node/lib/provable/bool").Bool;
 }
 /**
  * Generic state transition that constraints the current method circuit
@@ -68,18 +105,32 @@ export declare class ProvableStateTransition extends ProvableStateTransition_bas
  */
 export declare class StateTransition<Value> {
     path: Field;
-    fromValue: Option<Field> | Option<Value>;
+    fromValue: Option<Value>;
     toValue: Option<Field> | Option<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>;
+    constructor(path: Field, fromValue: Option<Value>, toValue: Option<Field> | Option<Value>);
+    get from(): Option<Value>;
+    get to(): Option<import("o1js/dist/node/lib/provable/field").Field> | Option<Value>;
     /**
      * Converts a StateTransition to a ProvableStateTransition,
      * while enforcing the 'from' property to be 'Some' in all cases.
      */
     toProvable(): ProvableStateTransition;
+    toJSON(): {
+        path: string;
+        from: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+        to: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+    };
+    toConstant(): StateTransition<Value>;
 }
 export {};
 //# sourceMappingURL=StateTransition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,4EAId;IAED,IAAW,EAAE,4EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;CAO7C"}
+{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;WAQhC,OAAO,CAAC,eAAe,EAAE,uBAAuB;CAK/D;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;IACxB,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,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,kBAId;IAED,IAAW,EAAE,8EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;;;IAQN,UAAU,IAAI,eAAe,CAAC,KAAK,CAAC;CAO5C"}

package/dist/model/StateTransition.js

@@ -1,5 +1,5 @@
-import { Field, Struct } from "snarkyjs";
-import { Option, ProvableOption } from "./Option.js";
+import { Field, Struct } from "o1js";
+import { Option, ProvableOption } from "./Option";
 /**
  * Provable representation of a State Transition, used to
  * normalize state transitions of various value types for
@@ -19,6 +19,11 @@ export class ProvableStateTransition extends Struct({
             to: Option.none().toProvable(),
         });
     }
+    static isDummy(stateTransition) {
+        return stateTransition.path
+            .equals(0)
+            .and(stateTransition.from.isSome.not());
+    }
 }
 /**
  * Generic state transition that constraints the current method circuit
@@ -55,4 +60,15 @@ export class StateTransition {
             to: this.to.toProvable(),
         });
     }
+    toJSON() {
+        return {
+            path: this.path.toString(),
+            from: this.fromValue.toJSON(),
+            to: this.toValue.toJSON(),
+        };
+    }
+    toConstant() {
+        return new StateTransition(this.path.toConstant(), this.fromValue.toConstant(), this.toValue.toConstant());
+    }
 }
+//# sourceMappingURL=StateTransition.js.map

package/dist/model/StateTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransition.js","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAElD;;;;GAIG;AACH,MAAM,OAAO,uBAAwB,SAAQ,MAAM,CAAC;IAClD,IAAI,EAAE,KAAK;IAEX,iCAAiC;IACjC,IAAI,EAAE,cAAc;IAEpB,4BAA4B;IAC5B,EAAE,EAAE,cAAc;CACnB,CAAC;IACO,MAAM,CAAC,KAAK;QACjB,OAAO,IAAI,uBAAuB,CAAC;YACjC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;YACd,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE;YAChC,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE;SAC/B,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,OAAO,CAAC,eAAwC;QAC5D,OAAO,eAAe,CAAC,IAAI;aACxB,MAAM,CAAC,CAAC,CAAC;aACT,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;IAC5C,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,eAAe;IACnB,MAAM,CAAC,IAAI,CAAQ,IAAW,EAAE,SAAwB;QAC7D,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IAEM,MAAM,CAAC,MAAM,CAClB,IAAW,EACX,SAAwB,EACxB,OAAsB;QAEtB,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAED,YACS,IAAW,EACX,SAAwB,EACxB,OAAsC;QAFtC,SAAI,GAAJ,IAAI,CAAO;QACX,cAAS,GAAT,SAAS,CAAe;QACxB,YAAO,GAAP,OAAO,CAA+B;IAC5C,CAAC;IAEJ,IAAW,IAAI;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACpC,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAW,EAAE;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACI,UAAU;QACf,OAAO,IAAI,uBAAuB,CAAC;YACjC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAC5B,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE;SACzB,CAAC,CAAC;IACL,CAAC;IAEM,MAAM;QACX,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC1B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YAC7B,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;SAC1B,CAAC;IACJ,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,eAAe,CACxB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EACtB,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,EAC3B,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAC1B,CAAC;IACJ,CAAC;CACF"}

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -1,23 +1,268 @@
+import { Bool } from "o1js";
+import { LinkedMerkleTreeWitness } from "@proto-kit/common";
 import { ProvableStateTransition } from "./StateTransition.js";
-declare const StateTransitionProvableBatch_base: (new (value: {
-    batch: ProvableStateTransition[];
+export declare class StateTransitionType {
+    static readonly nothing = 2;
+    static readonly closeAndApply = 1;
+    static readonly closeAndThrowAway = 0;
+}
+declare const ProvableStateTransitionType_base: (new (value: {
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) => {
-    batch: ProvableStateTransition[];
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
-    batch: ProvableStateTransition[];
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    type: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    type: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
     toInput: (x: {
-        batch: ProvableStateTransition[];
+        type: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field.js").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field.js").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
-        batch: ProvableStateTransition[];
+        type: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        batch: {
+        type: string;
+    };
+    fromJSON: (x: {
+        type: string;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+/**
+ * STType is encoding both the type and whether it should be accumulated or not in one field
+ */
+export declare class ProvableStateTransitionType extends ProvableStateTransitionType_base {
+    static get nothing(): ProvableStateTransitionType;
+    static get closeAndApply(): ProvableStateTransitionType;
+    static get closeAndThrowAway(): ProvableStateTransitionType;
+    private static from;
+    isClosing(): import("o1js/dist/node/lib/provable/bool").Bool;
+    isNothing(): import("o1js/dist/node/lib/provable/bool").Bool;
+}
+declare const MerkleWitnessBatch_base: (new (value: {
+    witnesses: LinkedMerkleTreeWitness[];
+}) => {
+    witnesses: LinkedMerkleTreeWitness[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    witnesses: LinkedMerkleTreeWitness[];
+}, {
+    witnesses: {
+        leafPrevious: {
+            leaf: {
+                value: bigint;
+                path: bigint;
+                nextPath: bigint;
+            };
+            merkleWitness: {
+                path: bigint[];
+                isLeft: boolean[];
+            };
+        };
+        leafCurrent: {
+            leaf: {
+                value: bigint;
+                path: bigint;
+                nextPath: bigint;
+            };
+            merkleWitness: {
+                path: bigint[];
+                isLeft: boolean[];
+            };
+        };
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+} & {
+    fromValue: (value: {
+        witnesses: LinkedMerkleTreeWitness[] | {
+            leafPrevious: {
+                leaf: {
+                    value: bigint;
+                    path: bigint;
+                    nextPath: bigint;
+                };
+                merkleWitness: {
+                    path: bigint[];
+                    isLeft: boolean[];
+                };
+            };
+            leafCurrent: {
+                leaf: {
+                    value: bigint;
+                    path: bigint;
+                    nextPath: bigint;
+                };
+                merkleWitness: {
+                    path: bigint[];
+                    isLeft: boolean[];
+                };
+            };
+        }[];
+    }) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+    toInput: (x: {
+        witnesses: LinkedMerkleTreeWitness[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        witnesses: LinkedMerkleTreeWitness[];
+    }) => {
+        witnesses: {
+            leafPrevious: {
+                leaf: {
+                    value: string;
+                    path: string;
+                    nextPath: string;
+                };
+                merkleWitness: {
+                    path: string[];
+                    isLeft: boolean[];
+                };
+            };
+            leafCurrent: {
+                leaf: {
+                    value: string;
+                    path: string;
+                    nextPath: string;
+                };
+                merkleWitness: {
+                    path: string[];
+                    isLeft: boolean[];
+                };
+            };
+        }[];
+    };
+    fromJSON: (x: {
+        witnesses: {
+            leafPrevious: {
+                leaf: {
+                    value: string;
+                    path: string;
+                    nextPath: string;
+                };
+                merkleWitness: {
+                    path: string[];
+                    isLeft: boolean[];
+                };
+            };
+            leafCurrent: {
+                leaf: {
+                    value: string;
+                    path: string;
+                    nextPath: string;
+                };
+                merkleWitness: {
+                    path: string[];
+                    isLeft: boolean[];
+                };
+            };
+        }[];
+    }) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+    empty: () => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+};
+export declare class MerkleWitnessBatch extends MerkleWitnessBatch_base {
+}
+declare const ProvableStateTransitionEntry_base: (new (value: {
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    stateTransition: {
+        path: bigint;
+        from: {
+            isSome: boolean;
+            value: bigint;
+        };
+        to: {
+            isSome: boolean;
+            value: bigint;
+        };
+    };
+    type: {
+        type: bigint;
+    };
+    witnessRoot: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        stateTransition: ProvableStateTransition | {
+            path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            from: import("./Option").ProvableOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+            to: import("./Option").ProvableOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+        };
+        type: ProvableStateTransitionType | {
+            type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        witnessRoot: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -27,10 +272,14 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 isSome: boolean;
                 value: string;
             };
-        }[];
+        };
+        type: {
+            type: string;
+        };
+        witnessRoot: boolean;
     };
     fromJSON: (x: {
-        batch: {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -40,18 +289,142 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 isSome: boolean;
                 value: string;
             };
+        };
+        type: {
+            type: string;
+        };
+        witnessRoot: boolean;
+    }) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+};
+export declare class ProvableStateTransitionEntry extends ProvableStateTransitionEntry_base {
+    static dummy(): ProvableStateTransitionEntry;
+}
+declare const StateTransitionProvableBatch_base: (new (value: {
+    batch: ProvableStateTransitionEntry[];
+}) => {
+    batch: ProvableStateTransitionEntry[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batch: ProvableStateTransitionEntry[];
+}, {
+    batch: {
+        stateTransition: {
+            path: bigint;
+            from: {
+                isSome: boolean;
+                value: bigint;
+            };
+            to: {
+                isSome: boolean;
+                value: bigint;
+            };
+        };
+        type: {
+            type: bigint;
+        };
+        witnessRoot: boolean;
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batch: ProvableStateTransitionEntry[];
+    };
+} & {
+    fromValue: (value: {
+        batch: ProvableStateTransitionEntry[] | {
+            stateTransition: {
+                path: bigint;
+                from: {
+                    isSome: boolean;
+                    value: bigint;
+                };
+                to: {
+                    isSome: boolean;
+                    value: bigint;
+                };
+            };
+            type: {
+                type: bigint;
+            };
+            witnessRoot: boolean;
+        }[];
+    }) => {
+        batch: ProvableStateTransitionEntry[];
+    };
+    toInput: (x: {
+        batch: ProvableStateTransitionEntry[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        batch: ProvableStateTransitionEntry[];
+    }) => {
+        batch: {
+            stateTransition: {
+                path: string;
+                from: {
+                    isSome: boolean;
+                    value: string;
+                };
+                to: {
+                    isSome: boolean;
+                    value: string;
+                };
+            };
+            type: {
+                type: string;
+            };
+            witnessRoot: boolean;
+        }[];
+    };
+    fromJSON: (x: {
+        batch: {
+            stateTransition: {
+                path: string;
+                from: {
+                    isSome: boolean;
+                    value: string;
+                };
+                to: {
+                    isSome: boolean;
+                    value: string;
+                };
+            };
+            type: {
+                type: string;
+            };
+            witnessRoot: boolean;
         }[];
     }) => {
-        batch: ProvableStateTransition[];
+        batch: ProvableStateTransitionEntry[];
+    };
+    empty: () => {
+        batch: ProvableStateTransitionEntry[];
     };
 };
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
+ *
+ * The batch is formed as an array fo ProvableSTEntries, which have a type and
+ * witnessesRoot flag attached to them.
  */
 export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
-    private constructor();
-    static fromTransitions(transitions: ProvableStateTransition[]): StateTransitionProvableBatch;
+    static fromBatches(batches: {
+        stateTransitions: ProvableStateTransition[];
+        applied: Bool;
+        witnessRoot: Bool;
+    }[]): StateTransitionProvableBatch[];
 }
 export {};
 //# sourceMappingURL=StateTransitionProvableBatch.d.ts.map