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

package/test/model/Option.test.ts

@@ -0,0 +1,72 @@
+import "reflect-metadata";
+
+import { Bool, Field, Poseidon } from "o1js";
+
+import { Option, ProvableOption } from "../../src";
+
+describe("option", () => {
+  it.each([
+    [Bool(true), Field(0), Field, true],
+    [Bool(false), Field(0), Field, false],
+  ])(
+    "should serialize to the correct tree value",
+    (isSome, value, valueType, shouldHash) => {
+      expect.assertions(1);
+
+      const option = Option.from(isSome, value, valueType);
+      const treeValue = shouldHash ? Poseidon.hash(value.toFields()) : Field(0);
+
+      expect(option.treeValue.toString()).toStrictEqual(treeValue.toString());
+    }
+  );
+
+  it.each([
+    [
+      Option.from(Bool(true), Field(5), Field),
+      { isSome: true, value: Poseidon.hash([Field(5)]) },
+      false,
+    ],
+    [
+      Option.from(Bool(true), Field(0), Field),
+      { isSome: true, value: Poseidon.hash([Field(0)]) },
+      false,
+    ],
+    [
+      Option.from(Bool(false), Field(0), Field),
+      { isSome: true, value: Field(0) },
+      true,
+    ],
+    [
+      Option.from(Bool(false), Field(1), Field),
+      { isSome: false, value: Field(0) },
+      false,
+    ],
+  ])(
+    "should encode to correct provable",
+    (option, provableTemplate, forceSome) => {
+      expect.assertions(4);
+
+      if (forceSome) {
+        option.forceSome();
+      }
+
+      const provableInput = new ProvableOption({
+        isSome: Bool(provableTemplate.isSome),
+        value: provableTemplate.value,
+      });
+
+      const provable = option.toProvable();
+      const fields = ProvableOption.toFields(provable);
+
+      expect(provable.value.toBigInt()).toStrictEqual(
+        provableInput.value.toBigInt()
+      );
+      expect(provable.isSome.toBoolean()).toStrictEqual(
+        provableInput.isSome.toBoolean()
+      );
+
+      expect(fields[0]).toStrictEqual(provableInput.isSome.toFields()[0]);
+      expect(fields[1]).toStrictEqual(provableInput.value);
+    }
+  );
+});

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/modularity/types.ts

@@ -0,0 +1,35 @@
+import { SmartContract } from "o1js";
+import { TypedClass } from "@proto-kit/common";
+
+import { GetContracts } from "../../src/settlement/modularity/types";
+import {
+  BridgeContractType,
+  MandatorySettlementModulesRecord,
+  SettlementContractType,
+} from "../../src";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// Goal of this "test" is that it compiles. By compiling this file checks that
+// certain types are inferred correctly
+
+type Inferred = GetContracts<MandatorySettlementModulesRecord>;
+
+// Get inferred Bridge Type
+type Bridge = Inferred["BridgeContract"];
+// Get inferred Settlement Contract Type
+type Settlement = Inferred["SettlementContract"];
+
+// Check that the Bridge type is of the correct type
+const bridgeSuccessful: Bridge extends TypedClass<
+  SmartContract & BridgeContractType
+>
+  ? true
+  : false = true;
+
+const settlementSuccessful: Settlement extends TypedClass<
+  SmartContract & SettlementContractType
+>
+  ? true
+  : false = true;
+
+/* eslint-enable @typescript-eslint/no-unused-vars */

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,261 @@
+import { Bool, Field } from "o1js";
+import {
+  InMemoryLinkedLeafStore,
+  InMemoryMerkleTreeStorage,
+  LinkedMerkleTree,
+  padArray,
+} from "@proto-kit/common";
+import { InMemoryAreProofsEnabled } from "@proto-kit/sequencer";
+
+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 LinkedMerkleTree(
+          new InMemoryMerkleTreeStorage(),
+          new InMemoryLinkedLeafStore()
+        );
+        const witness = LinkedMerkleTree.WITNESS.fromReadWitness(
+          tree.getReadWitness(1n)
+        );
+
+        const result = await prover.proveBatch(
+          {
+            root: tree.getRoot(),
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: padArray([witness], 4, () =>
+              LinkedMerkleTree.dummyWitness()
+            ),
+          },
+          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(LinkedMerkleTree.EMPTY_ROOT),
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: padArray([], 4, () => LinkedMerkleTree.dummyWitness()),
+          },
+          new AppliedStateTransitionBatchState({
+            root: Field(LinkedMerkleTree.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 LinkedMerkleTree(
+        new InMemoryMerkleTreeStorage(),
+        new InMemoryLinkedLeafStore()
+      );
+
+      const inputRoot = tree.getRoot();
+
+      const witness = LinkedMerkleTree.WITNESS.fromReadWitness(
+        tree.getReadWitness(1n)
+      );
+      tree.setLeaf(1n, 2n);
+      const witness2 = LinkedMerkleTree.WITNESS.fromReadWitness(
+        tree.getReadWitness(2n)
+      );
+
+      const prove = async () =>
+        await prover.proveBatch(
+          {
+            root: inputRoot,
+            witnessedRootsHash: Field(0),
+            batchesHash: Field(0),
+            currentBatchStateHash: Field(0),
+          },
+          batch[0],
+          {
+            witnesses: [
+              witness,
+              LinkedMerkleTree.dummyWitness(),
+              witness2,
+              LinkedMerkleTree.dummyWitness(),
+            ],
+          },
+          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 LinkedMerkleTree(
+        new InMemoryMerkleTreeStorage(),
+        new InMemoryLinkedLeafStore()
+      );
+
+      const witness1 = tree.setLeaf(1n, 2n);
+      const witness2 = tree.setLeaf(2n, 3n);
+
+      const resultRoot = tree.getRoot();
+
+      const witness3 = tree.setLeaf(2n, 4n);
+      const witness4 = tree.setLeaf(2n, 5n);
+
+      const result = await prover.proveBatch(
+        {
+          root: Field(LinkedMerkleTree.EMPTY_ROOT),
+          witnessedRootsHash: Field(0),
+          batchesHash: Field(0),
+          currentBatchStateHash: Field(0),
+        },
+        batch[0],
+        {
+          witnesses: [witness1, witness2, witness3, witness4],
+          //   .map((x) =>
+          //   LinkedMerkleTree.WITNESS.fromReadWitness(x)
+          // ),
+        },
+        new AppliedStateTransitionBatchState({
+          root: Field(LinkedMerkleTree.EMPTY_ROOT),
+          batchHash: Field(0),
+        })
+      );
+
+      expect(result.root.toString()).toStrictEqual(resultRoot.toString());
+      expect(result.currentBatchStateHash.toString()).toStrictEqual("0");
+    });
+  });
+});

package/test/state/assert/assert.test.ts

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+
+import { Bool } from "o1js";
+import { container } from "tsyringe";
+
+import { assert } from "../../../src/state/assert/assert";
+import { RuntimeMethodExecutionContext } from "../../../src/state/context/RuntimeMethodExecutionContext";
+import { RuntimeTransaction } from "../../../src/model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../../src/model/network/NetworkState";
+
+describe("assert", () => {
+  const defaultStatusMessage = "something went wrong";
+  const executionContext = container.resolve(RuntimeMethodExecutionContext);
+
+  beforeEach(() => {
+    executionContext.beforeMethod("testConstructor", "test", []);
+
+    executionContext.setup({
+      transaction: undefined as unknown as RuntimeTransaction,
+      networkState: undefined as unknown as NetworkState,
+    });
+  });
+
+  afterEach(() => {
+    executionContext.afterMethod();
+  });
+
+  describe.each([
+    [true, undefined],
+    [false, undefined],
+    [false, defaultStatusMessage],
+  ])("status and message propagation", (status, statusMessage) => {
+    it("should propagate the assertion status and message", () => {
+      expect.assertions(2);
+
+      assert(Bool(status), statusMessage);
+
+      const { status: resultStatus, statusMessage: resultStatusMessage } =
+        executionContext.current().result;
+
+      expect(status).toBe(resultStatus.toBoolean());
+      expect(statusMessage).toBe(resultStatusMessage);
+    });
+  });
+
+  it("should keep a false status, once it was already set", () => {
+    expect.assertions(1);
+
+    assert(Bool(false));
+    assert(Bool(true));
+
+    const { status } = executionContext.current().result;
+
+    expect(status.toBoolean()).toBe(false);
+  });
+});

package/test/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./../../../tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true
+  },
+  "include": ["../src/**/*.test.ts", "./**/*.ts", "./*.ts", "../src/**/*.ts"]
+}

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());
+    });
+  });
+});