@proto-kit/common 0.1.1-develop.153

package/dist/prover/block/BlockProver.d.ts

@@ -0,0 +1,199 @@
+import { Field, type Proof, SelfProof } from "snarkyjs";
+import { StateTransitionProver, type StateTransitionProverPublicInput } from "../statetransition/StateTransitionProver.js";
+import { MethodPublicInput } from "../../model/MethodPublicInput";
+import { Subclass } from "../../utils/utils";
+export interface BlockProverState {
+    stateRoot: Field;
+    /**
+     * The current commitment of the transaction-list which
+     * will at the end equal the bundle hash
+     */
+    transactionsHash: Field;
+}
+declare const BlockProverPublicInput_base: (new (value: {
+    fromTransactionsHash: Field;
+    toTransactionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}) => {
+    fromTransactionsHash: Field;
+    toTransactionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
+    fromTransactionsHash: Field;
+    toTransactionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}> & {
+    toInput: (x: {
+        fromTransactionsHash: Field;
+        toTransactionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        fromTransactionsHash: Field;
+        toTransactionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    }) => {
+        fromTransactionsHash: string;
+        toTransactionsHash: string;
+        fromStateRoot: string;
+        toStateRoot: string;
+    };
+    fromJSON: (x: {
+        fromTransactionsHash: string;
+        toTransactionsHash: string;
+        fromStateRoot: string;
+        toStateRoot: string;
+    }) => {
+        fromTransactionsHash: Field;
+        toTransactionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    };
+};
+export declare class BlockProverPublicInput extends BlockProverPublicInput_base {
+}
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export declare class BlockProver {
+    private readonly stateTransitionProver;
+    constructor(stateTransitionProver: StateTransitionProver);
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param appProof
+     * @returns The new BlockProver-state to be used as public output
+     */
+    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput>, appProof: Proof<MethodPublicInput>): BlockProverState;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: Proof<StateTransitionProverPublicInput>, appProof: Proof<MethodPublicInput>): void;
+    merge(publicInput: BlockProverPublicInput, proof1: SelfProof<BlockProverPublicInput>, proof2: SelfProof<BlockProverPublicInput>): void;
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * injected StateTransitionProver and the required AppChainProof class
+     */
+    createZkProgram(AppChainProof: Subclass<typeof Proof<MethodPublicInput>>): {
+        name: string;
+        compile: () => Promise<{
+            verificationKey: string;
+        }>;
+        verify: (proof: Proof<BlockProverPublicInput>) => Promise<boolean>;
+        digest: () => string;
+        analyzeMethods: () => {
+            rows: number;
+            digest: string;
+            result: unknown;
+            /**
+             * Creates the BlockProver ZkProgram.
+             * Recursive linking of proofs is done via the previously
+             * injected StateTransitionProver and the required AppChainProof class
+             */
+            gates: import("snarkyjs/dist/node/snarky.js").Gate[];
+            publicInputSize: number;
+        }[];
+        publicInputType: typeof BlockProverPublicInput;
+    } & {
+        proveTransaction: import("snarkyjs/dist/node/lib/proof_system.js").Prover<BlockProverPublicInput, [(new (...args: any) => Proof<StateTransitionProverPublicInput>) & {
+            prototype: Proof<any>;
+            publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+            tag: () => {
+                name: string;
+            };
+            fromJSON: typeof Proof.fromJSON;
+        } & {
+            prototype: Proof<StateTransitionProverPublicInput>;
+        } & {
+            publicInputType: import("../../utils/utils").TypedClassConstructor<StateTransitionProverPublicInput>;
+        }, Subclass<{
+            new ({ proof, publicInput, maxProofsVerified, }: {
+                proof: unknown;
+                publicInput: MethodPublicInput;
+                maxProofsVerified: 0 | 2 | 1;
+            }): Proof<MethodPublicInput>;
+            publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+            tag: () => {
+                name: string;
+            };
+            fromJSON<S extends (new (...args: any) => Proof<unknown>) & {
+                prototype: Proof<any>;
+                publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+                tag: () => {
+                    name: string;
+                };
+                fromJSON: typeof Proof.fromJSON;
+            } & {
+                prototype: Proof<unknown>;
+            }>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, }: {
+                publicInput: string[];
+                maxProofsVerified: 0 | 2 | 1;
+                proof: string;
+            }): Proof<import("snarkyjs/dist/node/lib/circuit_value.js").InferProvable<S["publicInputType"]>>;
+        }>]>;
+        merge: import("snarkyjs/dist/node/lib/proof_system.js").Prover<BlockProverPublicInput, [{
+            new ({ proof, publicInput, maxProofsVerified, }: {
+                proof: unknown;
+                publicInput: BlockProverPublicInput;
+                maxProofsVerified: 0 | 2 | 1;
+            }): SelfProof<BlockProverPublicInput>;
+            publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+            tag: () => {
+                name: string;
+            };
+            fromJSON<S extends (new (...args: any) => Proof<unknown>) & {
+                prototype: Proof<any>;
+                publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+                tag: () => {
+                    name: string;
+                };
+                fromJSON: typeof Proof.fromJSON;
+            } & {
+                prototype: Proof<unknown>;
+            }>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, }: {
+                publicInput: string[];
+                maxProofsVerified: 0 | 2 | 1;
+                proof: string;
+            }): Proof<import("snarkyjs/dist/node/lib/circuit_value.js").InferProvable<S["publicInputType"]>>;
+        }, {
+            new ({ proof, publicInput, maxProofsVerified, }: {
+                proof: unknown;
+                publicInput: BlockProverPublicInput;
+                maxProofsVerified: 0 | 2 | 1;
+            }): SelfProof<BlockProverPublicInput>;
+            publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+            tag: () => {
+                name: string;
+            };
+            fromJSON<S extends (new (...args: any) => Proof<unknown>) & {
+                prototype: Proof<any>;
+                publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
+                tag: () => {
+                    name: string;
+                };
+                fromJSON: typeof Proof.fromJSON;
+            } & {
+                prototype: Proof<unknown>;
+            }>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, }: {
+                publicInput: string[];
+                maxProofsVerified: 0 | 2 | 1;
+                proof: string;
+            }): Proof<import("snarkyjs/dist/node/lib/circuit_value.js").InferProvable<S["publicInputType"]>>;
+        }]>;
+    };
+}
+export {};
+//# sourceMappingURL=BlockProver.d.ts.map

package/dist/prover/block/BlockProver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,EACL,KAAK,KAAK,EACV,SAAS,EAEV,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,qBAAqB,EACrB,KAAK,gCAAgC,EACtC,MAAM,6CAA6C,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAiB7C,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,KAAK,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;CACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAK1C;CAAG;AAEL;;;;GAIG;AACH,qBACa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAArB,qBAAqB,EAAE,qBAAqB;IAG/D;;;;;;;;OAQG;IACI,gBAAgB,CACrB,KAAK,EAAE,gBAAgB,EACvB,oBAAoB,EAAE,KAAK,CAAC,gCAAgC,CAAC,EAC7D,QAAQ,EAAE,KAAK,CAAC,iBAAiB,CAAC,GACjC,gBAAgB;IA0CZ,gBAAgB,CACrB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,KAAK,CAAC,gCAAgC,CAAC,EACnD,QAAQ,EAAE,KAAK,CAAC,iBAAiB,CAAC;IAmB7B,KAAK,CACV,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,SAAS,CAAC,sBAAsB,CAAC,EACzC,MAAM,EAAE,SAAS,CAAC,sBAAsB,CAAC;IAkC3C;;;;OAIG;IACI,eAAe,CACpB,aAAa,EAAE,QAAQ,CAAC,OAAO,KAAK,CAAC,iBAAiB,CAAC,CAAC;;;;;;;;;;;YAN1D;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCJ"}

package/dist/prover/block/BlockProver.js

@@ -0,0 +1,119 @@
+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 { Circuit, Experimental, Field, SelfProof, Struct, } from "snarkyjs";
+import { injectable } from "tsyringe";
+import { StateTransitionProver, } from "../statetransition/StateTransitionProver.js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+const errors = {
+    stateProofNotStartingAtZero: () => "StateProof not starting ST-commitment at zero",
+    stateTransitionsHashNotEqual: () => "StateTransition list commitments are not equal",
+    propertyNotMatching: (propertyName) => `${propertyName} not matching`,
+    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
+    transactionsHashNotMatching: (step) => `transactions hash not matching ${step}`,
+};
+export class BlockProverPublicInput extends Struct({
+    fromTransactionsHash: Field,
+    toTransactionsHash: Field,
+    fromStateRoot: Field,
+    toStateRoot: Field,
+}) {
+}
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+let BlockProver = class BlockProver {
+    constructor(stateTransitionProver) {
+        this.stateTransitionProver = stateTransitionProver;
+    }
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param appProof
+     * @returns The new BlockProver-state to be used as public output
+     */
+    applyTransaction(state, stateTransitionProof, appProof) {
+        appProof.verify();
+        stateTransitionProof.verify();
+        const stateTo = { ...state };
+        // Checks for the stateTransitionProof and appProof matching
+        stateTransitionProof.publicInput.fromStateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
+        appProof.publicInput.stateTransitionsHash.assertEquals(stateTransitionProof.publicInput.toStateTransitionsHash, errors.stateTransitionsHashNotEqual());
+        // Apply state if status success
+        state.stateRoot.assertEquals(stateTransitionProof.publicInput.fromStateRoot, errors.propertyNotMatching("from state root"));
+        stateTo.stateRoot = Circuit.if(appProof.publicInput.status, stateTransitionProof.publicInput.toStateRoot, stateTransitionProof.publicInput.fromStateRoot);
+        // Append tx to transaction list
+        const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
+        const { transactionHash } = appProof.publicInput;
+        transactionList.push(transactionHash);
+        stateTo.transactionsHash = transactionList.commitment;
+        return stateTo;
+    }
+    proveTransaction(publicInput, stateProof, appProof) {
+        const state = {
+            transactionsHash: publicInput.fromTransactionsHash,
+            stateRoot: publicInput.fromStateRoot,
+        };
+        this.applyTransaction(state, stateProof, appProof);
+        publicInput.toStateRoot.assertEquals(state.stateRoot, errors.propertyNotMatching("to state root"));
+        publicInput.toTransactionsHash.assertEquals(state.transactionsHash, errors.propertyNotMatching("to transactions hash and computed hash"));
+    }
+    merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.fromStateRoot.assertEquals(proof1.publicInput.fromStateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicInput.toStateRoot.assertEquals(proof2.publicInput.fromStateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        proof2.publicInput.toStateRoot.assertEquals(publicInput.toStateRoot, errors.stateRootNotMatching("proof2.to -> publicInput.to"));
+        // Check transaction list
+        publicInput.fromTransactionsHash.assertEquals(proof1.publicInput.fromTransactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicInput.toTransactionsHash.assertEquals(proof2.publicInput.fromTransactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        proof2.publicInput.toTransactionsHash.assertEquals(publicInput.fromTransactionsHash, errors.transactionsHashNotMatching("proof2.to -> publicInput.to"));
+    }
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * injected StateTransitionProver and the required AppChainProof class
+     */
+    createZkProgram(AppChainProof) {
+        const ZkProgramProof = this.stateTransitionProver.getProofType();
+        const proveTransaction = this.proveTransaction.bind(this);
+        const merge = this.merge.bind(this);
+        return Experimental.ZkProgram({
+            publicInput: BlockProverPublicInput,
+            methods: {
+                proveTransaction: {
+                    privateInputs: [ZkProgramProof, AppChainProof],
+                    method(publicInput, stateProof, appProof) {
+                        proveTransaction(publicInput, stateProof, appProof);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        (SelfProof),
+                        (SelfProof),
+                    ],
+                    method(publicInput, proof1, proof2) {
+                        merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        });
+    }
+};
+BlockProver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [StateTransitionProver])
+], BlockProver);
+export { BlockProver };

package/dist/prover/block/BlockScopedModule.d.ts

@@ -0,0 +1,3 @@
+declare const nothing = 1;
+export { nothing };
+//# sourceMappingURL=BlockScopedModule.d.ts.map

package/dist/prover/block/BlockScopedModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockScopedModule.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockScopedModule.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,OAAO,IAAI,CAAC;AAClB,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/prover/block/BlockScopedModule.js

@@ -0,0 +1,6 @@
+// Placeholder for a future module architecture that can plug into the BlockProver
+// export interface BlockScopedModule {
+//
+// }
+const nothing = 1;
+export { nothing };

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

@@ -0,0 +1,92 @@
+import { Field, Proof, SelfProof } from "snarkyjs";
+import { ProvableHashList } from "../../utils/ProvableHashList";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { Subclass, TypedClassConstructor, ZkProgramType } from "../../utils/utils";
+import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider.js";
+interface StateTransitionProverState {
+    stateRoot: Field;
+    stateTransitionList: ProvableHashList<ProvableStateTransition>;
+}
+declare const StateTransitionProverPublicInput_base: (new (value: {
+    fromStateTransitionsHash: Field;
+    toStateTransitionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}) => {
+    fromStateTransitionsHash: Field;
+    toStateTransitionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
+    fromStateTransitionsHash: Field;
+    toStateTransitionsHash: Field;
+    fromStateRoot: Field;
+    toStateRoot: Field;
+}> & {
+    toInput: (x: {
+        fromStateTransitionsHash: Field;
+        toStateTransitionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        fromStateTransitionsHash: Field;
+        toStateTransitionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    }) => {
+        fromStateTransitionsHash: string;
+        toStateTransitionsHash: string;
+        fromStateRoot: string;
+        toStateRoot: string;
+    };
+    fromJSON: (x: {
+        fromStateTransitionsHash: string;
+        toStateTransitionsHash: string;
+        fromStateRoot: string;
+        toStateRoot: string;
+    }) => {
+        fromStateTransitionsHash: Field;
+        toStateTransitionsHash: Field;
+        fromStateRoot: Field;
+        toStateRoot: Field;
+    };
+};
+export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
+}
+/**
+ * StateTransitionProver is the prover that proves the application of some state
+ * transitions and checks and updates their merkle-tree entries
+ */
+export declare class StateTransitionProver {
+    private readonly witnessProvider;
+    private readonly program;
+    constructor(witnessProvider: StateTransitionWitnessProvider);
+    /**
+     * Applies the state transitions to the current stateRoot
+     * and returns the new prover state
+     */
+    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverState;
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state: StateTransitionProverState, transition: ProvableStateTransition, index?: number): void;
+    /**
+     * Applies a whole batch of StateTransitions at once
+     */
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): void;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: SelfProof<StateTransitionProverPublicInput>, proof2: SelfProof<StateTransitionProverPublicInput>): void;
+    getZkProgram(): ZkProgramType<StateTransitionProverPublicInput>;
+    getProofType(): Subclass<typeof Proof<StateTransitionProverPublicInput>> & {
+        publicInputType: TypedClassConstructor<StateTransitionProverPublicInput>;
+    };
+}
+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,EAGL,KAAK,EACL,KAAK,EACL,SAAS,EAEV,MAAM,UAAU,CAAC;AAOlB,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,EACL,QAAQ,EACR,qBAAqB,EACrB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AAcrF,UAAU,0BAA0B;IAClC,SAAS,EAAE,KAAK,CAAC;IACjB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CAChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACD,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;AAEL;;;GAGG;AACH,qBACa,qBAAqB;IAqC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAnClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CA+BZ;gBAIO,eAAe,EAAE,8BAA8B;IAGlE;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,6BAA6B,EAAE,KAAK,EACpC,eAAe,EAAE,4BAA4B,GAC5C,0BAA0B;IAsB7B;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,0BAA0B,EACjC,UAAU,EAAE,uBAAuB,EACnC,KAAK,SAAI;IA4BX;;OAEG;IACI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B;IAkB9B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,SAAS,CAAC,gCAAgC,CAAC,EACnD,MAAM,EAAE,SAAS,CAAC,gCAAgC,CAAC;IAkC9C,YAAY,IAAI,aAAa,CAAC,gCAAgC,CAAC;IAI/D,YAAY,IAAI,QAAQ,CAC7B,OAAO,KAAK,CAAC,gCAAgC,CAAC,CAC/C,GAAG;QACF,eAAe,EAAE,qBAAqB,CAAC,gCAAgC,CAAC,CAAC;KAC1E;CAQF"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -0,0 +1,127 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Circuit, Experimental, Field, Proof, SelfProof, Struct, } from "snarkyjs";
+import { inject, injectable } from "tsyringe";
+import { MerkleTreeUtils, RollupMerkleWitness, } from "../../utils/merkletree/RollupMerkleTree.js";
+import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { constants } from "../../Constants";
+const errors = {
+    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
+    stateTransitionsHashNotMatching: (step) => `State transitions hash not matching ${step}`,
+    merkleWitnessNotCorrect: (index) => `MerkleWitness not valid for StateTransition (${index})`,
+    propertyNotMatching: (propertyName) => `${propertyName} not matching`,
+};
+export class StateTransitionProverPublicInput extends Struct({
+    fromStateTransitionsHash: Field,
+    toStateTransitionsHash: Field,
+    fromStateRoot: Field,
+    toStateRoot: Field,
+}) {
+}
+/**
+ * StateTransitionProver is the prover that proves the application of some state
+ * transitions and checks and updates their merkle-tree entries
+ */
+let StateTransitionProver = class StateTransitionProver {
+    constructor(witnessProvider) {
+        this.witnessProvider = witnessProvider;
+        // eslint-disable-next-line unicorn/consistent-function-scoping
+        this.program = ((instance) => Experimental.ZkProgram({
+            publicInput: StateTransitionProverPublicInput,
+            methods: {
+                proveBatch: {
+                    privateInputs: [StateTransitionProvableBatch],
+                    method(publicInput, batch) {
+                        instance.runBatch(publicInput, batch);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        (SelfProof),
+                        (SelfProof),
+                    ],
+                    method(publicInput, proof1, proof2) {
+                        instance.merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        }))(this);
+    }
+    /**
+     * Applies the state transitions to the current stateRoot
+     * and returns the new prover state
+     */
+    applyTransitions(stateRoot, stateTransitionCommitmentFrom, transitionBatch) {
+        const state = {
+            stateRoot,
+            stateTransitionList: new DefaultProvableHashList(ProvableStateTransition, stateTransitionCommitmentFrom),
+        };
+        const transitions = transitionBatch.batch;
+        for (let index = 0; index < constants.stateTransitionProverBatchSize; index++) {
+            this.applyTransition(state, transitions[index], index);
+        }
+        return state;
+    }
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state, transition, index = 0) {
+        const treeWitness = Circuit.witness(RollupMerkleWitness, () => this.witnessProvider.getWitness(transition.path));
+        const membershipValid = MerkleTreeUtils.checkMembership(treeWitness, state.stateRoot, transition.path, transition.from.value);
+        membershipValid
+            .or(transition.from.isSome.not())
+            .assertTrue(errors.merkleWitnessNotCorrect(index));
+        const newRoot = MerkleTreeUtils.computeRoot(treeWitness, transition.to.value);
+        state.stateRoot = Circuit.if(transition.to.isSome, newRoot, state.stateRoot);
+        state.stateTransitionList.push(transition);
+    }
+    /**
+     * Applies a whole batch of StateTransitions at once
+     */
+    runBatch(publicInput, batch) {
+        const result = this.applyTransitions(publicInput.fromStateRoot, publicInput.fromStateTransitionsHash, batch);
+        publicInput.toStateRoot.assertEquals(result.stateRoot, errors.propertyNotMatching("resulting state-root"));
+        publicInput.toStateTransitionsHash.assertEquals(result.stateTransitionList.commitment, errors.propertyNotMatching("resulting state transition commitment"));
+    }
+    merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.fromStateRoot.assertEquals(proof1.publicInput.fromStateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicInput.toStateRoot.assertEquals(proof2.publicInput.fromStateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        proof2.publicInput.toStateRoot.assertEquals(publicInput.toStateRoot, errors.stateRootNotMatching("proof2.to -> publicInput.to"));
+        // Check ST list
+        publicInput.fromStateTransitionsHash.assertEquals(proof1.publicInput.fromStateTransitionsHash, errors.stateTransitionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicInput.toStateTransitionsHash.assertEquals(proof2.publicInput.fromStateTransitionsHash, errors.stateTransitionsHashNotMatching("proof1.to -> proof2.from"));
+        proof2.publicInput.toStateTransitionsHash.assertEquals(publicInput.toStateTransitionsHash, errors.stateTransitionsHashNotMatching("proof2.to -> publicInput.to"));
+    }
+    getZkProgram() {
+        return this.program;
+    }
+    getProofType() {
+        return ((instance) => { var _a; return _a = class StateTransitionProof extends Proof {
+            },
+            _a.publicInputType = StateTransitionProverPublicInput,
+            _a.tag = () => instance.getZkProgram(),
+            _a; })(this);
+    }
+};
+StateTransitionProver = __decorate([
+    injectable(),
+    __param(0, inject("StateTransitionWitnessProvider")),
+    __metadata("design:paramtypes", [Object])
+], StateTransitionProver);
+export { StateTransitionProver };

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

@@ -0,0 +1,16 @@
+import type { Field } from "snarkyjs";
+import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+/**
+ * Interface for providing merkle witnesses to the state-transition prover
+ */
+export interface StateTransitionWitnessProvider {
+    /**
+     * Provides the merkle witness corresponding to the given key
+     * @param key Merkle-tree key
+     */
+    getWitness: (key: Field) => RollupMerkleWitness;
+}
+export declare class NoOpStateTransitionWitnessProvider implements StateTransitionWitnessProvider {
+    getWitness(): RollupMerkleWitness;
+}
+//# sourceMappingURL=StateTransitionWitnessProvider.d.ts.map

package/dist/prover/statetransition/StateTransitionWitnessProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionWitnessProvider.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionWitnessProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,mBAAmB,CAAC;CACjD;AAED,qBACa,kCACX,YAAW,8BAA8B;IAElC,UAAU,IAAI,mBAAmB;CAGzC"}

package/dist/prover/statetransition/StateTransitionWitnessProvider.js

@@ -0,0 +1,17 @@
+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 } from "tsyringe";
+import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
+    getWitness() {
+        return new RollupMerkleWitness({ path: [], isLeft: [] });
+    }
+};
+NoOpStateTransitionWitnessProvider = __decorate([
+    injectable()
+], NoOpStateTransitionWitnessProvider);
+export { NoOpStateTransitionWitnessProvider };