@proto-kit/protocol 0.1.1-develop.1316 → 0.1.1-develop.1347

package/src/utils/ProvableHashList.ts

@@ -1,4 +1,23 @@
-import { Field, Poseidon, Bool, Provable, ProvablePure } from "o1js";
+import {
+  Field,
+  Poseidon,
+  Bool,
+  Provable,
+  ProvablePure,
+  Unconstrained,
+} from "o1js";
+
+import { NonMethods } from "./utils";
+
+export type ProvableHashListData<Value> = {
+  preimage: Field;
+  value: NonMethods<Value>;
+};
+
+export type VerifiedTransition<T> = {
+  from: T;
+  to: T;
+};
 
 /**
  * Utilities for creating a hash list from a given value type.
@@ -6,11 +25,49 @@ import { Field, Poseidon, Bool, Provable, ProvablePure } from "o1js";
 export abstract class ProvableHashList<Value> {
   public constructor(
     protected readonly valueType: ProvablePure<Value>,
-    public commitment: Field = Field(0)
+    public commitment: Field = Field(0),
+    private unconstrainedList: Unconstrained<
+      ProvableHashListData<Value>[]
+    > = Unconstrained.from([])
   ) {}
 
   protected abstract hash(elements: Field[]): Field;
 
+  private pushUnconstrained(preimage: Field, value: Value) {
+    const valueConstant = this.valueType.fromFields(
+      this.valueType.toFields(value).map((field) => field.toConstant())
+    );
+    this.unconstrainedList.get().push({
+      preimage: preimage.toConstant(),
+      value: valueConstant,
+    });
+  }
+
+  /**
+   * Fast-forwards the state of the hashlist to a specified new tip.
+   * This assumes the transition (from -> to) to be already verified somewhere
+   * else that is outside this scope.
+   */
+  public fastForward(
+    transition: VerifiedTransition<Field>,
+    message: string = "some hashlist"
+  ) {
+    const { from, to } = transition;
+    from.assertEquals(
+      this.commitment,
+      `From-commitment for ${message} not matching`
+    );
+
+    this.commitment = to;
+  }
+
+  public witnessTip(preimage: Field, value: Value): Bool {
+    return this.hash([
+      this.commitment,
+      ...this.valueType.toFields(value),
+    ]).equals(this.commitment);
+  }
+
   /**
    * Converts the provided value to Field[] and appends it to
    * the current hashlist.
@@ -19,19 +76,31 @@ export abstract class ProvableHashList<Value> {
    * @returns Current hash list.
    */
   public push(value: Value) {
+    Provable.asProver(() => {
+      this.pushUnconstrained(this.commitment, value);
+    });
+
     this.commitment = this.hash([
       this.commitment,
       ...this.valueType.toFields(value),
     ]);
+
     return this;
   }
 
   public pushIf(value: Value, condition: Bool) {
+    Provable.asProver(() => {
+      if (condition.toBoolean()) {
+        this.pushUnconstrained(this.commitment, value);
+      }
+    });
+
     const newCommitment = this.hash([
       this.commitment,
       ...this.valueType.toFields(value),
     ]);
     this.commitment = Provable.if(condition, newCommitment, this.commitment);
+
     return this;
   }
 
@@ -41,6 +110,12 @@ export abstract class ProvableHashList<Value> {
   public toField() {
     return this.commitment;
   }
+
+  public getUnconstrainedValues(): Unconstrained<
+    ProvableHashListData<Value>[]
+  > {
+    return this.unconstrainedList;
+  }
 }
 
 export class DefaultProvableHashList<Value> extends ProvableHashList<Value> {

package/src/utils/ProvableReductionHashList.ts

@@ -1,8 +1,13 @@
-import { Bool, Field, Poseidon, Provable } from "o1js";
+import { Bool, Field, Poseidon, Provable, ProvablePure } from "o1js";
 
-import { ProvableHashList } from "./ProvableHashList";
+import { NonMethods } from "./utils";
+
+export class ProvableReductionHashList<Value> {
+  public constructor(
+    protected readonly valueType: ProvablePure<Value>,
+    public commitment: Field = Field(0)
+  ) {}
 
-export class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
   public unconstrainedList: Value[] = [];
 
   private constrainedLastValue: Value | undefined = undefined;
@@ -65,4 +70,8 @@ export class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
   public hash(elements: Field[]): Field {
     return Poseidon.hash(elements);
   }
+
+  public getUnconstrainedValues(): NonMethods<Value>[] {
+    return this.unconstrainedList;
+  }
 }

package/src/utils/utils.ts

@@ -1,4 +1,4 @@
-import { Field, Poseidon, Provable } from "o1js";
+import { Bool, Field, Poseidon, Provable } from "o1js";
 import floor from "lodash/floor";
 
 export type ReturnType<FunctionType extends Function> = FunctionType extends (
@@ -73,3 +73,20 @@ export function singleFieldToString(value: Field | bigint): string {
   }
   return fieldValue.toString();
 }
+
+type NonMethodKeys<T> = {
+  [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonMethods<T> = Pick<T, NonMethodKeys<T>>;
+
+/**
+ * Asserts the equality of a and b, but only if doAssertion is true, otherwise it will assert 0 = 0
+ */
+export function assertEqualsIf(
+  a: Field,
+  b: Field,
+  doAssertion: Bool,
+  msg: string
+) {
+  a.mul(doAssertion.toField()).assertEquals(b.mul(doAssertion.toField()), msg);
+}

package/test/BlockProver.test.ts

@@ -70,6 +70,7 @@ describe("blockProver", () => {
 
   const protocol = createAndInitTestingProtocol();
 
+  /*
   function generateTestProofs(
     fromStateRoot: Field,
     toStateRoot: Field,
@@ -120,6 +121,7 @@ describe("blockProver", () => {
 
     return [appProof, stProof];
   }
+  */
 
   it("dummy", () => {
     expect(1).toBe(1);

package/test/TestingProtocol.ts

@@ -9,6 +9,7 @@ import {
   BlockProver,
   LastStateRootBlockHook,
   Protocol,
+  StateServiceProvider,
   StateTransitionProver,
 } from "../src";
 
@@ -48,5 +49,9 @@ export function createAndInitTestingProtocol() {
   });
   protocol.create(() => appChain.createChildContainer());
 
+  protocol.registerValue({
+    StateServiceProvider: new StateServiceProvider(),
+  });
+
   return protocol;
 }

package/test/model/StateTransitionProvableBatch.test.ts

@@ -0,0 +1,137 @@
+import "reflect-metadata";
+import { Bool, Field } from "o1js";
+
+import {
+  ProvableOption,
+  ProvableStateTransition,
+  ProvableStateTransitionType,
+  StateTransitionProvableBatch,
+} from "../../src";
+
+describe("StateTransitionProvableBatch", () => {
+  function createST(path: Field, from: Field, to: Field) {
+    return new ProvableStateTransition({
+      path,
+      from: new ProvableOption({
+        isSome: Bool(true),
+        value: from,
+      }),
+      to: new ProvableOption({
+        isSome: Bool(true),
+        value: to,
+      }),
+    });
+  }
+
+  it("should place witnessRoots correctly on empty batch", () => {
+    const st = createST(Field(1), Field(2), Field(3));
+    const data = [
+      {
+        stateTransitions: [st, st],
+        applied: Bool(true),
+        witnessRoot: Bool(false),
+      },
+      {
+        stateTransitions: [],
+        applied: Bool(true),
+        witnessRoot: Bool(true),
+      },
+    ];
+
+    const batches = StateTransitionProvableBatch.fromBatches(data);
+    expect(batches).toHaveLength(1);
+
+    const { batch } = batches[0];
+    expect(batch[0].witnessRoot.toBoolean()).toBe(false);
+    expect(batch[1].witnessRoot.toBoolean()).toBe(true);
+    // Should be dummy
+    expect(batch[2].witnessRoot.toBoolean()).toBe(false);
+  });
+
+  it("should place witnessRoots correctly on empty batch", () => {
+    const st = createST(Field(1), Field(2), Field(3));
+    const data = [
+      {
+        stateTransitions: [st, st],
+        applied: Bool(true),
+        witnessRoot: Bool(false),
+      },
+      {
+        stateTransitions: [st],
+        applied: Bool(false),
+        witnessRoot: Bool(true),
+      },
+    ];
+
+    const batches = StateTransitionProvableBatch.fromBatches(data);
+    expect(batches).toHaveLength(1);
+
+    const { batch } = batches[0];
+    expect(batch[0].witnessRoot.toBoolean()).toBe(false);
+    expect(batch[1].witnessRoot.toBoolean()).toBe(false);
+    expect(batch[2].witnessRoot.toBoolean()).toBe(true);
+  });
+
+  it("should transform correctly", () => {
+    const st = createST(Field(1), Field(2), Field(3));
+    const data = [
+      {
+        stateTransitions: [st, st, st, st, st],
+        applied: Bool(true),
+        witnessRoot: Bool(true),
+      },
+      {
+        stateTransitions: [st, st],
+        applied: Bool(false),
+        witnessRoot: Bool(false),
+      },
+    ];
+
+    const batches = StateTransitionProvableBatch.fromBatches(data);
+    expect(batches).toHaveLength(2);
+    const { nothing, closeAndThrowAway, closeAndApply } =
+      ProvableStateTransitionType;
+
+    const types = batches[0].batch.map(({ type }) => type);
+    const stateTransitions = batches[0].batch.map(
+      ({ stateTransition }) => stateTransition
+    );
+    const witnessRoots = batches[0].batch.map(({ witnessRoot }) => witnessRoot);
+
+    const types2 = batches[1].batch.map(({ type }) => type);
+    const stateTransitions2 = batches[1].batch.map(
+      ({ stateTransition }) => stateTransition
+    );
+    const witnessRoots2 = batches[1].batch.map(
+      ({ witnessRoot }) => witnessRoot
+    );
+
+    expect(types).toStrictEqual([nothing, nothing, nothing, nothing]);
+    expect(stateTransitions).toStrictEqual([st, st, st, st]);
+    expect(witnessRoots).toStrictEqual([
+      Bool(false),
+      Bool(false),
+      Bool(false),
+      Bool(false),
+    ]);
+
+    expect(stateTransitions2).toStrictEqual([
+      st,
+      st,
+      st,
+      ProvableStateTransition.dummy(),
+    ]);
+    expect(types2).toStrictEqual([
+      closeAndApply,
+      nothing,
+      closeAndThrowAway,
+      nothing,
+    ]);
+    expect(witnessRoots2).toStrictEqual([
+      Bool(true),
+      Bool(false),
+      Bool(false),
+      Bool(false),
+    ]);
+  });
+});

package/test/prover/block/BlockProver.test.ts

@@ -0,0 +1,18 @@
+/* eslint-disable max-len */
+/**
+ * Testing strategy:
+ *
+ * - Test that hooks are executed and batches are created correctly
+ *    - Transaction
+ *    - Block
+ * - Test the various static checks on the transaction (signature, verificationKey, network state hash)
+ * - Test correct construction of the batch and list commitments
+ * - Test correct integration of the STProof - both defer and notDefer
+ * - proveBlock: correct blockNumber progression, closed flag (doesn't accepts closed proofs as tx proofs)
+ */
+
+/* eslint-enable max-len */
+
+it("dummy", () => {
+  expect(1).toBe(1);
+});

package/test/prover/statetransition/StateTransitionProver.test.ts

@@ -0,0 +1,240 @@
+import { InMemoryAreProofsEnabled } from "@proto-kit/sdk";
+import { Bool, Field } from "o1js";
+import {
+  InMemoryMerkleTreeStorage,
+  padArray,
+  RollupMerkleTree,
+  RollupMerkleTreeWitness,
+} from "@proto-kit/common";
+
+import {
+  AppliedStateTransitionBatchState,
+  ProvableOption,
+  ProvableStateTransition,
+  StateTransitionProvableBatch,
+  StateTransitionProverProgrammable,
+} from "../../../src";
+
+describe("StateTransitionProver", () => {
+  let prover: StateTransitionProverProgrammable;
+
+  function setup() {
+    prover = new StateTransitionProverProgrammable({
+      get areProofsEnabled() {
+        return new InMemoryAreProofsEnabled();
+      },
+    });
+  }
+
+  beforeEach(() => {
+    setup();
+  });
+
+  function createST(path: Field, from: Field, to: Field) {
+    return new ProvableStateTransition({
+      path,
+      from: new ProvableOption({
+        isSome: Bool(true),
+        value: from,
+      }),
+      to: new ProvableOption({
+        isSome: Bool(true),
+        value: to,
+      }),
+    });
+  }
+
+  // function applyToTree(
+  //   tree: RollupMerkleTree,
+  //   batches: StateTransitionProvableBatch[],
+  //   indizes: number[]
+  // ) {
+  //   const flat = batches.flatMap((batch) => batch.batch);
+  //   indizes.forEach((index) => {
+  //     const st = flat[index].stateTransition;
+  //     if (st.to.isSome) {
+  //       tree.setLeaf(st.path.toBigInt(), st.to.value);
+  //     }
+  //   });
+  // }
+
+  describe("currentBatchHash", () => {
+    it.each([
+      [true, true],
+      [true, false],
+      [false, false],
+    ])(
+      "should retain empty currentBatchHash for padded dummies",
+      async (applied, witnessRoot) => {
+        const batch = StateTransitionProvableBatch.fromBatches([
+          {
+            stateTransitions: [createST(Field(1), Field(0), Field(2))],
+            applied: Bool(applied),
+            witnessRoot: Bool(witnessRoot),
+          },
+        ]);
+
+        const tree = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+        const witness = tree.getWitness(1n);
+
+        const result = await prover.proveBatch(
+          {
+            root: tree.getRoot(),
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: padArray([witness], 4, () =>
+              RollupMerkleTreeWitness.dummy()
+            ),
+          },
+          new AppliedStateTransitionBatchState({
+            root: tree.getRoot(),
+            batchHash: Field(0),
+          })
+        );
+
+        expect(result.currentBatchStateHash.toString()).toStrictEqual("0");
+      }
+    );
+  });
+
+  describe("dummies", () => {
+    it("should fail if dummy is type close", async () => {
+      expect.assertions(1);
+
+      const batch = StateTransitionProvableBatch.fromBatches([
+        {
+          stateTransitions: [ProvableStateTransition.dummy()],
+          applied: Bool(true),
+          witnessRoot: Bool(true),
+        },
+      ]);
+
+      const prove = async () =>
+        await prover.proveBatch(
+          {
+            root: Field(RollupMerkleTree.EMPTY_ROOT),
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: padArray([], 4, RollupMerkleTreeWitness.dummy),
+          },
+          new AppliedStateTransitionBatchState({
+            root: Field(RollupMerkleTree.EMPTY_ROOT),
+            batchHash: Field(0),
+          })
+        );
+
+      await expect(prove).rejects.toThrow(
+        /Dummies have to be of type 'nothing'.*/
+      );
+    });
+
+    it("should fail if dummy is in the middle", async () => {
+      expect.assertions(1);
+
+      const batch = StateTransitionProvableBatch.fromBatches([
+        {
+          stateTransitions: [
+            createST(Field(1), Field(0), Field(2)),
+            ProvableStateTransition.dummy(),
+            createST(Field(2), Field(0), Field(3)),
+          ],
+          applied: Bool(true),
+          witnessRoot: Bool(true),
+        },
+      ]);
+
+      const tree = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+
+      const inputRoot = tree.getRoot();
+
+      const witness = tree.getWitness(1n);
+      tree.setLeaf(1n, Field(2));
+      const witness2 = tree.getWitness(2n);
+
+      const prove = async () =>
+        await prover.proveBatch(
+          {
+            root: inputRoot,
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: [
+              witness,
+              RollupMerkleTreeWitness.dummy(),
+              witness2,
+              RollupMerkleTreeWitness.dummy(),
+            ],
+          },
+          new AppliedStateTransitionBatchState({
+            root: inputRoot,
+            batchHash: Field(0),
+          })
+        );
+
+      await expect(prove).rejects.toThrow(
+        /Dummies can only be placed on closed batchLists.*/
+      );
+    });
+  });
+
+  describe("batch progression", () => {
+    it("should throw away non-applied batches", async () => {
+      const batch = StateTransitionProvableBatch.fromBatches([
+        {
+          stateTransitions: [
+            createST(Field(1), Field(0), Field(2)),
+            createST(Field(2), Field(0), Field(3)),
+          ],
+          applied: Bool(true),
+          witnessRoot: Bool(true),
+        },
+        {
+          stateTransitions: [
+            createST(Field(2), Field(3), Field(4)),
+            createST(Field(2), Field(4), Field(5)),
+          ],
+          applied: Bool(false),
+          witnessRoot: Bool(true),
+        },
+      ]);
+
+      const tree = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+
+      const witness1 = tree.getWitness(1n);
+      tree.setLeaf(1n, Field(2));
+      const witness2 = tree.getWitness(2n);
+      tree.setLeaf(2n, Field(3));
+
+      const result = await prover.proveBatch(
+        {
+          root: Field(RollupMerkleTree.EMPTY_ROOT),
+          witnessedRootsHash: Field(0),
+          batchesHash: Field(0),
+          currentBatchStateHash: Field(0),
+        },
+        batch[0],
+        {
+          witnesses: [witness1, witness2, witness2, witness2],
+        },
+        new AppliedStateTransitionBatchState({
+          root: Field(RollupMerkleTree.EMPTY_ROOT),
+          batchHash: Field(0),
+        })
+      );
+
+      expect(result.root.toString()).toStrictEqual(tree.getRoot().toString());
+      expect(result.currentBatchStateHash.toString()).toStrictEqual("0");
+    });
+  });
+});

package/test/utils/ProvableHashList.test.ts

@@ -0,0 +1,44 @@
+import "reflect-metadata";
+import { Bool, Field, Poseidon } from "o1js";
+
+import { DefaultProvableHashList } from "../../src";
+
+describe("defaultProvableHashList", () => {
+  describe.each([
+    [0, [{ value: 1n, push: true }]],
+    // [
+    //   10,
+    //   [
+    //     { value: 1n, push: true },
+    //     { value: 5n, push: false },
+    //   ],
+    // ],
+    // [
+    //   10,
+    //   [
+    //     { value: 1n, push: true },
+    //     { value: 5n, push: false },
+    //     { value: 6n, push: true },
+    //   ],
+    // ],
+  ])("should correctly append and save", (start, elements) => {
+    it("Using only pushIf", () => {
+      const hashList = new DefaultProvableHashList(Field, Field(start));
+
+      // eslint-disable-next-line sonarjs/no-unused-collection
+      const appended: bigint[] = [];
+      let hash = Field(start);
+
+      for (const element of elements) {
+        hashList.pushIf(Field(element.value), Bool(element.push));
+        if (element.push) {
+          appended.push(element.value);
+
+          hash = Poseidon.hash([hash, Field(element.value)]);
+        }
+      }
+
+      expect(hash.toString()).toStrictEqual(hashList.commitment.toString());
+    });
+  });
+});

package/test/utils/ProvableReductionHashList.test.ts

@@ -4,7 +4,7 @@ import { Bool, Field, Poseidon } from "o1js";
 import {
   StateTransitionReductionList,
   reduceStateTransitions,
-} from "../../src/utils/StateTransitionReductionList";
+} from "../../src/prover/accumulators/StateTransitionReductionList";
 import {
   DefaultProvableHashList,
   ProvableStateTransition,

package/dist/utils/StateTransitionReductionList.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/utils/StateTransitionReductionList.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"StateTransitionReductionList.js","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"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"}