@proto-kit/protocol 0.1.1-develop.1086

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,20 @@
+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));
+    }
+}

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/block/services/RuntimeVerificationKeyRootService.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable, Lifecycle, scoped } from "tsyringe";
+export let RuntimeVerificationKeyRootService = class RuntimeVerificationKeyRootService {
+    setRoot(root) {
+        this.injectedRoot = root;
+    }
+    getRoot() {
+        if (this.injectedRoot === undefined) {
+            throw new Error("VKTree root not set");
+        }
+        return this.injectedRoot;
+    }
+};
+RuntimeVerificationKeyRootService = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], RuntimeVerificationKeyRootService);

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

@@ -0,0 +1,174 @@
+import { Proof } from "o1js";
+import { WithZkProgrammable } from "@proto-kit/common";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+declare const StateTransitionProverPublicInput_base: (new (value: {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    stateTransitionsHash: bigint;
+    protocolTransitionsHash: bigint;
+    stateRoot: bigint;
+    protocolStateRoot: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        stateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: 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: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: string;
+        protocolTransitionsHash: string;
+        stateRoot: string;
+        protocolStateRoot: string;
+    };
+    fromJSON: (x: {
+        stateTransitionsHash: string;
+        protocolTransitionsHash: string;
+        stateRoot: string;
+        protocolStateRoot: string;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
+}
+declare const StateTransitionProverPublicOutput_base: (new (value: {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    stateTransitionsHash: bigint;
+    protocolTransitionsHash: bigint;
+    stateRoot: bigint;
+    protocolStateRoot: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        stateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: 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: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: string;
+        protocolTransitionsHash: string;
+        stateRoot: string;
+        protocolStateRoot: string;
+    };
+    fromJSON: (x: {
+        stateTransitionsHash: string;
+        protocolTransitionsHash: string;
+        stateRoot: string;
+        protocolStateRoot: string;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        protocolTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+        protocolStateRoot: 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) => 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

@@ -0,0 +1 @@
+{"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,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,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

@@ -0,0 +1,15 @@
+import { Field, Struct } from "o1js";
+export class StateTransitionProverPublicInput extends Struct({
+    stateTransitionsHash: Field,
+    protocolTransitionsHash: Field,
+    stateRoot: Field,
+    protocolStateRoot: Field,
+}) {
+}
+export class StateTransitionProverPublicOutput extends Struct({
+    stateTransitionsHash: Field,
+    protocolTransitionsHash: Field,
+    stateRoot: Field,
+    protocolStateRoot: Field,
+}) {
+}

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

@@ -0,0 +1,51 @@
+import { AreProofsEnabled, PlainZkProgram, ZkProgrammable } from "@proto-kit/common";
+import { Field } from "o1js";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { ProvableStateTransitionType, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { StateTransitionProverType } from "../../protocol/Protocol";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { ProvableHashList } from "../../utils/ProvableHashList";
+import { StateTransitionProof, StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
+import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+interface StateTransitionProverExecutionState {
+    stateRoot: Field;
+    protocolStateRoot: Field;
+    stateTransitionList: ProvableHashList<ProvableStateTransition>;
+    protocolTransitionList: ProvableHashList<ProvableStateTransition>;
+}
+/**
+ * StateTransitionProver is the prover that proves the application of some state
+ * transitions and checks and updates their merkle-tree entries
+ */
+export declare class StateTransitionProverProgrammable extends ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
+    private readonly stateTransitionProver;
+    readonly witnessProviderReference: StateTransitionWitnessProviderReference;
+    constructor(stateTransitionProver: StateTransitionProver, witnessProviderReference: StateTransitionWitnessProviderReference);
+    get appChain(): AreProofsEnabled | undefined;
+    zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>[];
+    private get witnessProvider();
+    /**
+     * Applies the state transitions to the current stateRoot
+     * and returns the new prover state
+     */
+    applyTransitions(stateRoot: Field, protocolStateRoot: Field, stateTransitionCommitmentFrom: Field, protocolTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, type: ProvableStateTransitionType, index?: number): void;
+    /**
+     * Applies a whole batch of StateTransitions at once
+     */
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
+}
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable, StateTransitionProverType {
+    readonly witnessProviderReference: StateTransitionWitnessProviderReference;
+    zkProgrammable: StateTransitionProverProgrammable;
+    constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): 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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EAGd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAI7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAepG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,iBAAiB,EAAE,KAAK,CAAC;IACzB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAEG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC,EAAE;IAuDH,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,iBAAiB,EAAE,KAAK,EACxB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA6BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAiDX;;OAEG;IAEU,QAAQ,CACnB,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,iCAAiC,CAAC;IAkBhC,KAAK,CAChB,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAqE9C;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB,EAAE,yBAAyB;aAM3C,wBAAwB,EAAE,uCAAuC;IAJ5E,cAAc,EAAE,iCAAiC,CAAC;gBAIvC,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,iCAAiC,CAAC;IAItC,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAG9C"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -0,0 +1,188 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { provableMethod, RollupMerkleTreeWitness, ZkProgrammable, } from "@proto-kit/common";
+import { Field, Provable, SelfProof, ZkProgram } from "o1js";
+import { injectable } from "tsyringe";
+import { constants } from "../../Constants";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { StateTransitionProvableBatch, } from "../../model/StateTransitionProvableBatch";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
+import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
+import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+const errors = {
+    propertyNotMatching: (property, step) => `${property} not matching ${step}`,
+    merkleWitnessNotCorrect: (index, type) => `MerkleWitness not valid for StateTransition (${index}, type ${type})`,
+    noWitnessProviderSet: () => new Error("WitnessProvider not set, set it before you use StateTransitionProvider"),
+};
+const StateTransitionSelfProofClass = (SelfProof);
+/**
+ * StateTransitionProver is the prover that proves the application of some state
+ * transitions and checks and updates their merkle-tree entries
+ */
+export class StateTransitionProverProgrammable extends ZkProgrammable {
+    constructor(stateTransitionProver, witnessProviderReference) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.witnessProviderReference = witnessProviderReference;
+    }
+    get appChain() {
+        return this.stateTransitionProver.appChain;
+    }
+    zkProgramFactory() {
+        const instance = this;
+        const program = ZkProgram({
+            name: "StateTransitionProver",
+            publicInput: StateTransitionProverPublicInput,
+            publicOutput: StateTransitionProverPublicOutput,
+            methods: {
+                proveBatch: {
+                    privateInputs: [StateTransitionProvableBatch],
+                    async method(publicInput, batch) {
+                        return await instance.runBatch(publicInput, batch);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        StateTransitionSelfProofClass,
+                        StateTransitionSelfProofClass,
+                    ],
+                    async method(publicInput, proof1, proof2) {
+                        return await instance.merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        });
+        const methods = {
+            proveBatch: program.proveBatch.bind(program),
+            merge: program.merge.bind(program),
+        };
+        const SelfProofClass = ZkProgram.Proof(program);
+        return [
+            {
+                compile: program.compile.bind(program),
+                verify: program.verify.bind(program),
+                analyzeMethods: program.analyzeMethods.bind(program),
+                Proof: SelfProofClass,
+                methods,
+            },
+        ];
+    }
+    get witnessProvider() {
+        const provider = this.witnessProviderReference.getWitnessProvider();
+        if (provider === undefined) {
+            throw errors.noWitnessProviderSet();
+        }
+        return provider;
+    }
+    /**
+     * Applies the state transitions to the current stateRoot
+     * and returns the new prover state
+     */
+    applyTransitions(stateRoot, protocolStateRoot, stateTransitionCommitmentFrom, protocolTransitionCommitmentFrom, transitionBatch) {
+        const state = {
+            stateRoot,
+            protocolStateRoot,
+            stateTransitionList: new DefaultProvableHashList(ProvableStateTransition, stateTransitionCommitmentFrom),
+            protocolTransitionList: new DefaultProvableHashList(ProvableStateTransition, protocolTransitionCommitmentFrom),
+        };
+        const transitions = transitionBatch.batch;
+        const types = transitionBatch.transitionTypes;
+        for (let index = 0; index < constants.stateTransitionProverBatchSize; index++) {
+            this.applyTransition(state, transitions[index], types[index], index);
+        }
+        return state;
+    }
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state, transition, type, index = 0) {
+        const witness = Provable.witness(RollupMerkleTreeWitness, () => this.witnessProvider.getWitness(transition.path));
+        const membershipValid = witness.checkMembership(state.stateRoot, transition.path, transition.from.value);
+        membershipValid
+            .or(transition.from.isSome.not())
+            .assertTrue(errors.merkleWitnessNotCorrect(index, type.isNormal().toBoolean() ? "normal" : "protocol"));
+        const newRoot = witness.calculateRoot(transition.to.value);
+        state.stateRoot = Provable.if(transition.to.isSome, newRoot, state.stateRoot);
+        // Only update protocol state root if ST is also of type protocol
+        // Since protocol STs are all at the start of the batch, this works
+        state.protocolStateRoot = Provable.if(transition.to.isSome.and(type.isProtocol()), newRoot, state.protocolStateRoot);
+        const isNotDummy = transition.path.equals(Field(0)).not();
+        state.stateTransitionList.pushIf(transition, isNotDummy.and(type.isNormal()));
+        state.protocolTransitionList.pushIf(transition, isNotDummy.and(type.isProtocol()));
+    }
+    /**
+     * Applies a whole batch of StateTransitions at once
+     */
+    async runBatch(publicInput, batch) {
+        const result = this.applyTransitions(publicInput.stateRoot, publicInput.protocolStateRoot, publicInput.stateTransitionsHash, publicInput.protocolTransitionsHash, batch);
+        return new StateTransitionProverPublicOutput({
+            stateRoot: result.stateRoot,
+            stateTransitionsHash: result.stateTransitionList.commitment,
+            protocolTransitionsHash: result.protocolTransitionList.commitment,
+            protocolStateRoot: result.protocolStateRoot,
+        });
+    }
+    async merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.propertyNotMatching("stateRoot", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.propertyNotMatching("stateRoot", "proof1.to -> proof2.from"));
+        // Check ST list
+        publicInput.stateTransitionsHash.assertEquals(proof1.publicInput.stateTransitionsHash, errors.propertyNotMatching("stateTransitionsHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateTransitionsHash.assertEquals(proof2.publicInput.stateTransitionsHash, errors.propertyNotMatching("stateTransitionsHash", "proof1.to -> proof2.from"));
+        // Check Protocol ST list
+        publicInput.protocolTransitionsHash.assertEquals(proof1.publicInput.protocolTransitionsHash, errors.propertyNotMatching("protocolTransitionsHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.protocolTransitionsHash.assertEquals(proof2.publicInput.protocolTransitionsHash, errors.propertyNotMatching("protocolTransitionsHash", "proof1.to -> proof2.from"));
+        // Check protocol state root
+        publicInput.protocolStateRoot.assertEquals(proof1.publicInput.protocolStateRoot, errors.propertyNotMatching("protocolStateRoot", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.protocolStateRoot.assertEquals(proof2.publicInput.protocolStateRoot, errors.propertyNotMatching("protocolStateRoot", "proof1.to -> proof2.from"));
+        return new StateTransitionProverPublicInput({
+            stateRoot: proof2.publicOutput.stateRoot,
+            stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
+            protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
+            protocolStateRoot: proof2.publicOutput.protocolStateRoot,
+        });
+    }
+}
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StateTransitionProverPublicInput,
+        StateTransitionProvableBatch]),
+    __metadata("design:returntype", Promise)
+], StateTransitionProverProgrammable.prototype, "runBatch", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StateTransitionProverPublicInput, Object, Object]),
+    __metadata("design:returntype", Promise)
+], StateTransitionProverProgrammable.prototype, "merge", null);
+export let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
+    constructor(
+    // Injected
+    witnessProviderReference) {
+        super();
+        this.witnessProviderReference = witnessProviderReference;
+        this.zkProgrammable = new StateTransitionProverProgrammable(this, witnessProviderReference);
+    }
+    runBatch(publicInput, batch) {
+        return this.zkProgrammable.runBatch(publicInput, batch);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+};
+StateTransitionProver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [StateTransitionWitnessProviderReference])
+], StateTransitionProver);