@proto-kit/protocol 0.1.1-develop.190 → 0.1.1-develop.2024

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,84 +1,173 @@
-import { Proof } from "snarkyjs";
-import { ZkProgrammable } 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;
-    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;
-    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;
-    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;
-        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;
-        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;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     };
     fromJSON: (x: {
-        stateTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     }) => {
-        stateTransitionsHash: 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;
-    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;
-    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;
-    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;
-        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;
-        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;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     };
     fromJSON: (x: {
-        stateTransitionsHash: string;
-        stateRoot: string;
+        batchesHash: string;
+        currentBatchStateHash: string;
+        root: string;
+        witnessedRootsHash: string;
     }) => {
-        stateTransitionsHash: 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 ZkProgrammable<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,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAGpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAGrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,cAAc,CACpB,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,11 +1,16 @@
-import { Field, Struct } from "snarkyjs";
+import { Field, Struct } from "o1js";
 export class StateTransitionProverPublicInput extends Struct({
-    stateTransitionsHash: Field,
-    stateRoot: Field,
+    batchesHash: Field,
+    currentBatchStateHash: Field,
+    root: Field,
+    witnessedRootsHash: Field,
 }) {
 }
 export class StateTransitionProverPublicOutput extends Struct({
-    stateTransitionsHash: 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"}

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

@@ -1,39 +1,51 @@
-import { Field } from "snarkyjs";
-import { PlainZkProgram } from "@proto-kit/common";
-import { ProvableHashList } from "../../utils/ProvableHashList";
+import { AreProofsEnabled, PlainZkProgram, ZkProgrammable, CompilableModule, type ArtifactRecord, type CompileRegistry, LinkedMerkleTreeWitness } from "@proto-kit/common";
+import { Field } from "o1js";
 import { ProvableStateTransition } from "../../model/StateTransition";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { MerkleWitnessBatch, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
-import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { WitnessedRootHashList } from "../accumulators/WitnessedRootHashList";
+import { AppliedBatchHashList } from "../accumulators/AppliedBatchHashList";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
+import { StateTransitionProof, StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
 interface StateTransitionProverExecutionState {
-    stateRoot: Field;
-    stateTransitionList: ProvableHashList<ProvableStateTransition>;
+    currentBatch: AppliedStateTransitionBatchState;
+    batchList: AppliedBatchHashList;
+    finalizedRoot: Field;
+    witnessedRoots: WitnessedRootHashList;
 }
 /**
  * StateTransitionProver is the prover that proves the application of some state
  * transitions and checks and updates their merkle-tree entries
  */
-export declare class StateTransitionProver extends ProtocolModule<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> implements StateTransitionProvable {
-    readonly witnessProviderReference: StateTransitionWitnessProviderReference;
-    constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
-    zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
-    private get witnessProvider();
+export declare class StateTransitionProverProgrammable extends ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
+    private readonly stateTransitionProver;
+    constructor(stateTransitionProver: Pick<StateTransitionProver, "areProofsEnabled">);
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>[];
+    private transitionToTreeWrite;
     /**
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
+    applyTransitions(state: StateTransitionProverExecutionState, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch): StateTransitionProverExecutionState;
     /**
      * Applies a single state transition to the given state
      * and mutates it in place
      */
-    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, index?: number): void;
+    applyTransition(currentBatch: AppliedStateTransitionBatchState, transition: ProvableStateTransition, witness: LinkedMerkleTreeWitness, index?: number): AppliedStateTransitionBatchState;
+    private applyTransitionToRoot;
     /**
      * Applies a whole batch of StateTransitions at once
      */
-    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
-    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
+    proveBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch, currentAppliedBatch: AppliedStateTransitionBatchState): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
+}
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable, CompilableModule {
+    zkProgrammable: StateTransitionProverProgrammable;
+    constructor();
+    compile(registry: CompileRegistry): Promise<void | ArtifactRecord>;
+    proveBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch, startingAppliedBatch: AppliedStateTransitionBatchState): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
 }
 export {};
 //# sourceMappingURL=StateTransitionProver.d.ts.map

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":"AAAA,OAAO,EAAgB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEpE,OAAO,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAMnE,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,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;AAmBpG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CAChE;AAOD;;;GAGG;AACH,qBACa,qBACX,SAAQ,cAAc,CACpB,gCAAgC,EAChC,iCAAiC,CAEnC,YAAW,uBAAuB;aAIhB,wBAAwB,EAAE,uCAAuC;gBAAjE,wBAAwB,EAAE,uCAAuC;IAK5E,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,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IAsBtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,KAAK,SAAI;IAgCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAc7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CA6BrC"}
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EAEd,cAAc,EACd,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,EAGpB,uBAAuB,EACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAI7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAE7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAE3F,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AAUnC,UAAU,mCAAmC;IAC3C,YAAY,EAAE,gCAAgC,CAAC;IAC/C,SAAS,EAAE,oBAAoB,CAAC;IAChC,aAAa,EAAE,KAAK,CAAC;IACrB,cAAc,EAAE,qBAAqB,CAAC;CACvC;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAEG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAArB,qBAAqB,EAAE,IAAI,CAC1C,qBAAqB,EACrB,kBAAkB,CACnB;IAKH,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC,EAAE;IAuEH,OAAO,CAAC,qBAAqB;IAqB7B;;;OAGG;IACI,gBAAgB,CACrB,KAAK,EAAE,mCAAmC,EAC1C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB;IA2F/B;;;OAGG;IACI,eAAe,CACpB,YAAY,EAAE,gCAAgC,EAC9C,UAAU,EAAE,uBAAuB,EACnC,OAAO,EAAE,uBAAuB,EAChC,KAAK,SAAI;IAuBX,OAAO,CAAC,qBAAqB;IAgB7B;;OAEG;IAEU,UAAU,CACrB,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,mBAAmB,EAAE,gCAAgC,GACpD,OAAO,CAAC,iCAAiC,CAAC;IAiChC,KAAK,CAChB,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAmE9C;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB,EAAE,gBAAgB;IAE7C,cAAc,EAAE,iCAAiC,CAAC;;IAO5C,OAAO,CAClB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC;IAI1B,UAAU,CACf,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,oBAAoB,EAAE,gCAAgC,GACrD,OAAO,CAAC,iCAAiC,CAAC;IAStC,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAG9C"}