@proto-kit/protocol 0.1.1-develop.0

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: {
+            path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+            isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+        } | VKTreeWitness;
+    }) => {
+        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/block/services/RuntimeVerificationKeyRootService.js

@@ -0,0 +1,23 @@
+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);
+//# 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

@@ -0,0 +1,172 @@
+import { Proof } from "o1js";
+import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+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>, CompilableModule {
+    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,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExF,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,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,16 @@
+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,
+}) {
+}
+//# 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;AAK5C,MAAM,OAAO,gCAAiC,SAAQ,MAAM,CAAC;IAC3D,oBAAoB,EAAE,KAAK;IAC3B,uBAAuB,EAAE,KAAK;IAC9B,SAAS,EAAE,KAAK;IAChB,iBAAiB,EAAE,KAAK;CACzB,CAAC;CAAG;AAEL,MAAM,OAAO,iCAAkC,SAAQ,MAAM,CAAC;IAC5D,oBAAoB,EAAE,KAAK;IAC3B,uBAAuB,EAAE,KAAK;IAC9B,SAAS,EAAE,KAAK;IAChB,iBAAiB,EAAE,KAAK;CACzB,CAAC;CAAG"}

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

@@ -0,0 +1,48 @@
+import { AreProofsEnabled, PlainZkProgram, RollupMerkleTreeWitness, ZkProgrammable, CompilableModule, type ArtifactRecord, type CompileRegistry } 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";
+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;
+    constructor(stateTransitionProver: StateTransitionProver);
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>[];
+    /**
+     * 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, merkleWitness: RollupMerkleTreeWitness, 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, CompilableModule {
+    zkProgrammable: StateTransitionProverProgrammable;
+    constructor();
+    compile(registry: CompileRegistry): Promise<void | ArtifactRecord>;
+    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,EAEd,uBAAuB,EACvB,cAAc,EACd,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,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;AA0BnC,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;gBAArB,qBAAqB,EAAE,qBAAqB;IAK/D,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC,EAAE;IAwDH;;;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;IAoCtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,aAAa,EAAE,uBAAuB,EACtC,KAAK,SAAI;IAwCX;;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,YACE,uBAAuB,EACvB,yBAAyB,EACzB,gBAAgB;IAEX,cAAc,EAAE,iCAAiC,CAAC;;IAO5C,OAAO,CAClB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC;IAI1B,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"}