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

package/dist/prover/block/accummulators/BlockHashMerkleTree.d.ts

@@ -0,0 +1,106 @@
+import { Field } from "o1js";
+declare const BlockHashMerkleTree_base: import("@proto-kit/common").AbstractMerkleTreeClass;
+export declare class BlockHashMerkleTree extends BlockHashMerkleTree_base {
+}
+export declare class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
+}
+declare const BlockHashTreeEntry_base: (new (value: {
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    block: {
+        index: import("o1js/dist/node/lib/provable/field").Field;
+        transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    closed: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    block: {
+        index: bigint;
+        transactionListHash: bigint;
+    };
+    closed: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        } | {
+            index: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: 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: {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        block: {
+            index: string;
+            transactionListHash: string;
+        };
+        closed: boolean;
+    };
+    fromJSON: (x: {
+        block: {
+            index: string;
+            transactionListHash: string;
+        };
+        closed: boolean;
+    }) => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        block: {
+            index: import("o1js/dist/node/lib/provable/field").Field;
+            transactionListHash: import("o1js/dist/node/lib/provable/field").Field;
+        };
+        closed: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+};
+export declare class BlockHashTreeEntry extends BlockHashTreeEntry_base {
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=BlockHashMerkleTree.d.ts.map

package/dist/prover/block/accummulators/BlockHashMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashMerkleTree.d.ts","sourceRoot":"","sources":["../../../../src/prover/block/accummulators/BlockHashMerkleTree.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAoB,MAAM,MAAM,CAAC;;AAErD,qBAAa,mBAAoB,SAAQ,wBAAoB;CAAG;AAChE,qBAAa,0BAA2B,SAAQ,mBAAmB,CAAC,OAAO;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E,qBAAa,kBAAmB,SAAQ,uBAQtC;IACO,IAAI,IAAI,KAAK;CAQrB"}

package/dist/prover/block/accummulators/BlockHashMerkleTree.js

@@ -0,0 +1,25 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Struct } from "o1js";
+export class BlockHashMerkleTree extends createMerkleTree(40) {
+}
+export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {
+}
+export class BlockHashTreeEntry extends Struct({
+    block: Struct({
+        index: Field,
+        transactionListHash: Field,
+    }),
+    closed: Bool,
+    // TODO We could add startingEternalTransactionsHash here to offer
+    //  a more trivial connection to the sequence state
+}) {
+    hash() {
+        // Mirroring Block.hash()
+        const blockHash = Poseidon.hash([
+            this.block.index,
+            this.block.transactionListHash,
+        ]);
+        return Poseidon.hash([blockHash, ...this.closed.toFields()]);
+    }
+}
+//# sourceMappingURL=BlockHashMerkleTree.js.map

package/dist/prover/block/accummulators/BlockHashMerkleTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashMerkleTree.js","sourceRoot":"","sources":["../../../../src/prover/block/accummulators/BlockHashMerkleTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErD,MAAM,OAAO,mBAAoB,SAAQ,gBAAgB,CAAC,EAAE,CAAC;CAAG;AAChE,MAAM,OAAO,0BAA2B,SAAQ,mBAAmB,CAAC,OAAO;CAAG;AAE9E,MAAM,OAAO,kBAAmB,SAAQ,MAAM,CAAC;IAC7C,KAAK,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,KAAK;QACZ,mBAAmB,EAAE,KAAK;KAC3B,CAAC;IACF,MAAM,EAAE,IAAI;IACZ,kEAAkE;IAClE,mDAAmD;CACpD,CAAC;IACO,IAAI;QACT,yBAAyB;QACzB,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,KAAK;YAChB,IAAI,CAAC,KAAK,CAAC,mBAAmB;SAC/B,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;CACF"}

package/dist/prover/block/accummulators/RuntimeVerificationKeyTree.d.ts

@@ -0,0 +1,139 @@
+import { VerificationKey } from "o1js";
+export declare const treeFeeHeight = 10;
+declare const VKTree_base: import("@proto-kit/common").AbstractMerkleTreeClass;
+export declare class VKTree extends VKTree_base {
+}
+export declare class VKTreeWitness extends VKTree.WITNESS {
+}
+declare const RuntimeVerificationKeyAttestation_base: (new (value: {
+    verificationKey: VerificationKey;
+    witness: VKTreeWitness;
+}) => {
+    verificationKey: VerificationKey;
+    witness: VKTreeWitness;
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/lib/provable/provable").Provable<{
+    verificationKey: VerificationKey;
+    witness: VKTreeWitness;
+}, {
+    verificationKey: {
+        data: string;
+        hash: bigint;
+    };
+    witness: {
+        path: bigint[];
+        isLeft: boolean[];
+    };
+}> & {
+    fromValue: (value: {
+        verificationKey: VerificationKey | {
+            data: string;
+            hash: import("o1js/dist/node/lib/provable/field").Field;
+        } | {
+            data: string;
+            hash: bigint;
+        };
+        witness: VKTreeWitness | {
+            path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+            isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+        };
+    }) => {
+        verificationKey: VerificationKey;
+        witness: VKTreeWitness;
+    };
+    toInput: (x: {
+        verificationKey: VerificationKey;
+        witness: VKTreeWitness;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        verificationKey: VerificationKey;
+        witness: VKTreeWitness;
+    }) => {
+        verificationKey: string;
+        witness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+    };
+    fromJSON: (x: {
+        verificationKey: string;
+        witness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+    }) => {
+        verificationKey: VerificationKey;
+        witness: VKTreeWitness;
+    };
+    empty: () => {
+        verificationKey: VerificationKey;
+        witness: VKTreeWitness;
+    };
+};
+export declare class RuntimeVerificationKeyAttestation extends RuntimeVerificationKeyAttestation_base {
+}
+declare const MethodVKConfigData_base: (new (value: {
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    vkHash: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    vkHash: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    methodId: import("o1js/dist/node/lib/provable/field").Field;
+    vkHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    methodId: bigint;
+    vkHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        methodId: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        methodId: string;
+        vkHash: string;
+    };
+    fromJSON: (x: {
+        methodId: string;
+        vkHash: string;
+    }) => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        methodId: import("o1js/dist/node/lib/provable/field").Field;
+        vkHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class MethodVKConfigData extends MethodVKConfigData_base {
+    hash(): import("o1js/dist/node/lib/provable/field").Field;
+}
+export interface MinimalVKTreeService {
+    getRoot: () => bigint;
+}
+export {};
+//# sourceMappingURL=RuntimeVerificationKeyTree.d.ts.map

package/dist/prover/block/accummulators/RuntimeVerificationKeyTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeVerificationKeyTree.d.ts","sourceRoot":"","sources":["../../../../src/prover/block/accummulators/RuntimeVerificationKeyTree.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,eAAe,EAAE,MAAM,MAAM,CAAC;AAEhE,eAAO,MAAM,aAAa,KAAK,CAAC;;AAChC,qBAAa,MAAO,SAAQ,WAA+B;CAAG;AAC9D,qBAAa,aAAc,SAAQ,MAAM,CAAC,OAAO;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpD,qBAAa,iCAAkC,SAAQ,sCAGrD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAGtC;IACO,IAAI;CAGZ;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB"}

package/dist/prover/block/accummulators/RuntimeVerificationKeyTree.js

@@ -0,0 +1,21 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Field, Poseidon, Struct, VerificationKey } from "o1js";
+export const treeFeeHeight = 10;
+export class VKTree extends createMerkleTree(treeFeeHeight) {
+}
+export class VKTreeWitness extends VKTree.WITNESS {
+}
+export class RuntimeVerificationKeyAttestation extends Struct({
+    verificationKey: VerificationKey,
+    witness: VKTreeWitness,
+}) {
+}
+export class MethodVKConfigData extends Struct({
+    methodId: Field,
+    vkHash: Field,
+}) {
+    hash() {
+        return Poseidon.hash(MethodVKConfigData.toFields(this));
+    }
+}
+//# sourceMappingURL=RuntimeVerificationKeyTree.js.map

package/dist/prover/block/accummulators/RuntimeVerificationKeyTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeVerificationKeyTree.js","sourceRoot":"","sources":["../../../../src/prover/block/accummulators/RuntimeVerificationKeyTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEhE,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAChC,MAAM,OAAO,MAAO,SAAQ,gBAAgB,CAAC,aAAa,CAAC;CAAG;AAC9D,MAAM,OAAO,aAAc,SAAQ,MAAM,CAAC,OAAO;CAAG;AAEpD,MAAM,OAAO,iCAAkC,SAAQ,MAAM,CAAC;IAC5D,eAAe,EAAE,eAAe;IAChC,OAAO,EAAE,aAAa;CACvB,CAAC;CAAG;AAEL,MAAM,OAAO,kBAAmB,SAAQ,MAAM,CAAC;IAC7C,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,KAAK;CACd,CAAC;IACO,IAAI;QACT,OAAO,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1D,CAAC;CACF"}

package/dist/prover/block/services/RuntimeVerificationKeyRootService.d.ts

@@ -0,0 +1,7 @@
+import { MinimalVKTreeService } from "../accummulators/RuntimeVerificationKeyTree";
+export declare class RuntimeVerificationKeyRootService implements MinimalVKTreeService {
+    private injectedRoot?;
+    setRoot(root: bigint): void;
+    getRoot(): bigint;
+}
+//# sourceMappingURL=RuntimeVerificationKeyRootService.d.ts.map

package/dist/prover/block/services/RuntimeVerificationKeyRootService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeVerificationKeyRootService.d.ts","sourceRoot":"","sources":["../../../../src/prover/block/services/RuntimeVerificationKeyRootService.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAEnF,qBAEa,iCAAkC,YAAW,oBAAoB;IAC5E,OAAO,CAAC,YAAY,CAAC,CAAS;IAEvB,OAAO,CAAC,IAAI,EAAE,MAAM;IAIpB,OAAO;CAMf"}

package/dist/prover/{statetransition/StateTransitionWitnessProviderReference.js → block/services/RuntimeVerificationKeyRootService.js}

@@ -5,16 +5,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable, Lifecycle, scoped } from "tsyringe";
-let StateTransitionWitnessProviderReference = class StateTransitionWitnessProviderReference {
-    setWitnessProvider(provider) {
-        this.witnessProvider = provider;
+export let RuntimeVerificationKeyRootService = class RuntimeVerificationKeyRootService {
+    setRoot(root) {
+        this.injectedRoot = root;
     }
-    getWitnessProvider() {
-        return this.witnessProvider;
+    getRoot() {
+        if (this.injectedRoot === undefined) {
+            throw new Error("VKTree root not set");
+        }
+        return this.injectedRoot;
     }
 };
-StateTransitionWitnessProviderReference = __decorate([
+RuntimeVerificationKeyRootService = __decorate([
     injectable(),
     scoped(Lifecycle.ContainerScoped)
-], StateTransitionWitnessProviderReference);
-export { StateTransitionWitnessProviderReference };
+], RuntimeVerificationKeyRootService);
+//# sourceMappingURL=RuntimeVerificationKeyRootService.js.map

package/dist/prover/block/services/RuntimeVerificationKeyRootService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeVerificationKeyRootService.js","sourceRoot":"","sources":["../../../../src/prover/block/services/RuntimeVerificationKeyRootService.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAMlD,WAAM,iCAAiC,GAAvC,MAAM,iCAAiC;IAGrC,OAAO,CAAC,IAAY;QACzB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAEM,OAAO;QACZ,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;YACnC,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;SACxC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF,CAAA;AAbY,iCAAiC;IAF7C,UAAU,EAAE;IACZ,MAAM,CAAC,SAAS,CAAC,eAAe,CAAC;GACrB,iCAAiC,CAa7C"}

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

@@ -1,100 +1,173 @@
-import { Proof } from "snarkyjs";
-import { WithZkProgrammable } from "@proto-kit/common";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { Proof } from "o1js";
+import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
+import { MerkleWitnessBatch, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
 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;
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    batchesHash: bigint;
+    currentBatchStateHash: bigint;
+    root: bigint;
+    witnessedRootsHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        batchesHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        root: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").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: {
-        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
-        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        stateTransitionsHash: string;
-        protocolTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     };
     fromJSON: (x: {
-        stateTransitionsHash: string;
-        protocolTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: 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;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     };
 };
 export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
 }
 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;
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+    currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    batchesHash: bigint;
+    currentBatchStateHash: bigint;
+    root: bigint;
+    witnessedRootsHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        batchesHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        root: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/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;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").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: {
-        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
-        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
-        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        stateTransitionsHash: string;
-        protocolTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     };
     fromJSON: (x: {
-        stateTransitionsHash: string;
-        protocolTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: 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;
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        batchesHash: import("o1js/dist/node/lib/provable/field").Field;
+        currentBatchStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        witnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
     };
 };
 export declare class StateTransitionProverPublicOutput extends StateTransitionProverPublicOutput_base {
 }
 export type StateTransitionProof = Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
-export interface StateTransitionProvable extends WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
-    witnessProviderReference: StateTransitionWitnessProviderReference;
-    runBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch) => StateTransitionProverPublicOutput;
-    merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => StateTransitionProverPublicOutput;
+export interface StateTransitionProvable extends WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, CompilableModule {
+    proveBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch, currentAppliedBatch: AppliedStateTransitionBatchState) => Promise<StateTransitionProverPublicOutput>;
+    merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => Promise<StateTransitionProverPublicOutput>;
 }
 export {};
 //# sourceMappingURL=StateTransitionProvable.d.ts.map

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,MAAM,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3F,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,CACtB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,gBAAgB;IAClB,UAAU,EAAE,CACV,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,mBAAmB,EAAE,gCAAgC,KAClD,OAAO,CAAC,iCAAiC,CAAC,CAAC;IAEhD,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,OAAO,CAAC,iCAAiC,CAAC,CAAC;CACjD"}

package/dist/prover/statetransition/StateTransitionProvable.js

@@ -1,13 +1,16 @@
-import { Field, Struct } from "snarkyjs";
+import { Field, Struct } from "o1js";
 export class StateTransitionProverPublicInput extends Struct({
-    stateTransitionsHash: Field,
-    protocolTransitionsHash: Field,
-    stateRoot: Field,
+    batchesHash: Field,
+    currentBatchStateHash: Field,
+    root: Field,
+    witnessedRootsHash: Field,
 }) {
 }
 export class StateTransitionProverPublicOutput extends Struct({
-    stateTransitionsHash: Field,
-    protocolTransitionsHash: Field,
-    stateRoot: Field,
+    batchesHash: Field,
+    currentBatchStateHash: Field,
+    root: Field,
+    witnessedRootsHash: Field,
 }) {
 }
+//# sourceMappingURL=StateTransitionProvable.js.map

package/dist/prover/statetransition/StateTransitionProvable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvable.js","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAS,MAAM,EAAE,MAAM,MAAM,CAAC;AAS5C,MAAM,OAAO,gCAAiC,SAAQ,MAAM,CAAC;IAC3D,WAAW,EAAE,KAAK;IAClB,qBAAqB,EAAE,KAAK;IAC5B,IAAI,EAAE,KAAK;IACX,kBAAkB,EAAE,KAAK;CAC1B,CAAC;CAAG;AAEL,MAAM,OAAO,iCAAkC,SAAQ,MAAM,CAAC;IAC5D,WAAW,EAAE,KAAK;IAClB,qBAAqB,EAAE,KAAK;IAC5B,IAAI,EAAE,KAAK;IACX,kBAAkB,EAAE,KAAK;CAC1B,CAAC;CAAG"}