@proto-kit/protocol 0.1.1-develop.0

package/test/Protocol.test.ts

@@ -0,0 +1,37 @@
+import "reflect-metadata";
+import { beforeEach } from "@jest/globals";
+
+import { BlockProver } from "../src/prover/block/BlockProver";
+import { StateTransitionProver } from "../src/prover/statetransition/StateTransitionProver";
+import { ProvableTransactionHook } from "../src";
+
+import { createAndInitTestingProtocol } from "./TestingProtocol";
+
+describe("protocol", () => {
+  beforeEach(() => {});
+
+  it("should resolve all provers correctly", async () => {
+    expect.assertions(2);
+
+    const protocol = createAndInitTestingProtocol();
+
+    expect(protocol.blockProver instanceof BlockProver).toBe(true);
+    expect(
+      protocol.stateTransitionProver instanceof StateTransitionProver
+    ).toBe(true);
+  });
+
+  it("should initialize hooks correctly", () => {
+    expect.assertions(2);
+
+    const protocol = createAndInitTestingProtocol();
+
+    const hooks =
+      protocol.dependencyContainer.resolveAll<ProvableTransactionHook>(
+        "ProvableTransactionHook"
+      );
+
+    expect(hooks).toHaveLength(1);
+    expect(hooks[0].name).toBe("AccountState");
+  });
+});

package/test/State.test.ts

@@ -0,0 +1,45 @@
+import "reflect-metadata";
+import { noop } from "@proto-kit/common";
+import { Bool, Field, UInt64 } from "o1js";
+import { container } from "tsyringe";
+
+import {
+  NetworkState,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  State,
+  SimpleAsyncStateService,
+  StateServiceProvider,
+} from "../src";
+
+describe("state", () => {
+  beforeEach(() => {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+
+    executionContext.setup({
+      transaction: undefined as unknown as RuntimeTransaction,
+      networkState: undefined as unknown as NetworkState,
+    });
+  });
+
+  it("should decode state correctly", async () => {
+    expect.assertions(2);
+
+    const state = State.from<UInt64>(UInt64);
+    const stateService: SimpleAsyncStateService = {
+      get: async () => [Field(123)],
+
+      set: async () => {
+        noop();
+      },
+    };
+    state.stateServiceProvider = new StateServiceProvider();
+    state.stateServiceProvider.setCurrentStateService(stateService);
+    state.path = Field(1);
+
+    const retrieved = await state.get();
+
+    expect(retrieved.isSome).toStrictEqual(Bool(true));
+    expect(retrieved.value).toStrictEqual(UInt64.from(123));
+  });
+});

package/test/StateTransition.test.ts

@@ -0,0 +1,174 @@
+import "reflect-metadata";
+import { InMemoryMerkleTreeStorage } from "@proto-kit/common";
+import { Bool, Field } from "o1js";
+
+import { Option, ProvableStateTransition } from "../src/index";
+import { RollupMerkleTree } from "../../common/src/trees/RollupMerkleTree.js";
+
+// TODO Not worth fixing rn because we will revamp the STProver very soon
+
+describe.skip("stateTransition", () => {
+  async function checkTransitions(
+    tree: RollupMerkleTree,
+    transitions: ProvableStateTransition[]
+  ) {
+    // const batch = StateTransitionProvableBatch.fromTransitions(transitions, []);
+    //
+    // const temporaryTree = new RollupMerkleTree(
+    //   new CachedMerkleTreeStore(tree.store)
+    // );
+    // const startRoot = temporaryTree.getRoot();
+    //
+    // const hashList = new DefaultProvableHashList(ProvableStateTransition);
+    //
+    // batch.batch.forEach((item) => {
+    //   if (item.to.isSome.toBoolean()) {
+    //     temporaryTree.setLeaf(item.path.toBigInt(), item.to.value);
+    //   }
+    //   hashList.push(item);
+    // });
+    //
+    // const endRoot = temporaryTree.getRoot();
+    //
+    // class DummySTWP implements StateTransitionWitnessProvider {
+    //   private i = 0;
+    //
+    //   public constructor(private readonly witnessTree: RollupMerkleTree) {}
+    //
+    //   public getWitness(key: Field): RollupMerkleTreeWitness {
+    //     const witness = this.witnessTree.getWitness(key.toBigInt());
+    //     const set = batch.batch[this.i];
+    //     if (set.to.isSome.toBoolean()) {
+    //       this.witnessTree.setLeaf(key.toBigInt(), set.to.value);
+    //     }
+    //     this.i += 1;
+    //     return witness;
+    //   }
+    // }
+    //
+    // const childContainer = container.createChildContainer();
+    // childContainer.registerInstance(
+    //   "StateTransitionWitnessProvider",
+    //   new DummySTWP(tree)
+    // );
+    // const prover = childContainer.resolve(StateTransitionProver);
+    //
+    // const state = prover.applyTransitions(startRoot, Field(0), batch);
+    //
+    // expect(state.stateRoot).toStrictEqual(endRoot);
+    // expect(state.stateTransitionList.commitment).toStrictEqual(
+    //   hashList.commitment
+    // );
+    //
+    // await childContainer.dispose();
+  }
+
+  it.each([
+    [
+      [
+        new ProvableStateTransition({
+          from: Option.fromValue(Field(1), Field).toProvable(),
+          to: Option.fromValue(Field(14), Field).toProvable(),
+          path: Field(1),
+        }),
+        new ProvableStateTransition({
+          from: Option.fromValue(Field(14), Field).toProvable(),
+          to: Option.fromValue(Field(4), Field).toProvable(),
+          path: Field(1),
+        }),
+      ],
+    ],
+    [
+      [
+        new ProvableStateTransition({
+          from: Option.none().toProvable(),
+          to: Option.from(Bool(true), Field(4), Field).toProvable(),
+          path: Field(1),
+        }),
+        new ProvableStateTransition({
+          from: Option.from(Bool(true), Field(5), Field).toProvable(),
+          to: Option.from(Bool(true), Field(2), Field).toProvable(),
+          path: Field(2),
+        }),
+        new ProvableStateTransition({
+          from: Option.from(Bool(true), Field(2), Field).toProvable(),
+          to: Option.none().toProvable(),
+          path: Field(2),
+        }),
+      ],
+    ],
+  ])("should pass without throwing", async (transitions) => {
+    // expect.assertions(2);
+
+    const tree = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+
+    // Is ignored because overwritten by first transition
+    tree.setLeaf(1n, Option.fromValue(Field(1), Field).treeValue);
+    tree.setLeaf(2n, Option.fromValue(Field(5), Field).treeValue);
+
+    await checkTransitions(tree, transitions);
+  });
+
+  it.each([
+    [
+      [
+        new ProvableStateTransition({
+          // fail
+          from: Option.from(Bool(true), Field(2), Field).toProvable(),
+          to: Option.none().toProvable(),
+          path: Field(1),
+        }),
+      ],
+      0,
+    ],
+    [
+      [
+        new ProvableStateTransition({
+          // success
+          from: Option.from(Bool(true), Field(1), Field).toProvable(),
+          to: Option.from(Bool(true), Field(14), Field).toProvable(),
+          path: Field(1),
+        }),
+        new ProvableStateTransition({
+          // fail
+          from: Option.from(Bool(true), Field(6), Field).toProvable(),
+          to: Option.none().toProvable(),
+          path: Field(2),
+        }),
+      ],
+      1,
+    ],
+    [
+      [
+        new ProvableStateTransition({
+          // success
+          from: Option.from(Bool(true), Field(1), Field).toProvable(),
+          to: Option.from(Bool(true), Field(14), Field).toProvable(),
+          path: Field(1),
+        }),
+        new ProvableStateTransition({
+          // fail
+          from: Option.from(Bool(true), Field(15), Field).toProvable(),
+          to: Option.none().toProvable(),
+          path: Field(1),
+        }),
+      ],
+      1,
+    ],
+  ])(
+    "should throw because of failing precondition",
+    async (transitions, index) => {
+      expect.assertions(1);
+
+      const tree = new RollupMerkleTree(new InMemoryMerkleTreeStorage());
+
+      // Is ignored because overwritten by first transition
+      tree.setLeaf(1n, Option.fromValue(Field(1), Field).treeValue);
+      tree.setLeaf(2n, Option.fromValue(Field(5), Field).treeValue);
+
+      await expect(checkTransitions(tree, transitions)).rejects.toThrow(
+        `MerkleWitness not valid for StateTransition (${index})`
+      );
+    }
+  );
+});

package/test/TestingProtocol.ts

@@ -0,0 +1,52 @@
+import { container } from "tsyringe";
+import { Runtime } from "@proto-kit/module";
+import { Balance } from "@proto-kit/sequencer/test/integration/mocks/Balance";
+import { NoopRuntime } from "@proto-kit/sequencer/test/integration/mocks/NoopRuntime";
+
+import {
+  AccountStateHook,
+  BlockHeightHook,
+  BlockProver,
+  LastStateRootBlockHook,
+  Protocol,
+  StateTransitionProver,
+} from "../src";
+
+export function createAndInitTestingProtocol() {
+  const ProtocolClass = Protocol.from({
+    modules: {
+      StateTransitionProver: StateTransitionProver,
+      BlockProver: BlockProver,
+      AccountState: AccountStateHook,
+      BlockHeight: BlockHeightHook,
+      LastStateRoot: LastStateRootBlockHook,
+    },
+  });
+  const protocol = new ProtocolClass();
+
+  protocol.configure({
+    BlockProver: {},
+    AccountState: {},
+    BlockHeight: {},
+    StateTransitionProver: {},
+    LastStateRoot: {},
+  });
+
+  const appChain = container.createChildContainer();
+
+  appChain.register("Runtime", {
+    useClass: Runtime.from({
+      modules: {
+        Balance,
+        NoopRuntime,
+      },
+      config: {
+        Balance: {},
+        NoopRuntime: {},
+      },
+    }),
+  });
+  protocol.create(() => appChain.createChildContainer());
+
+  return protocol;
+}

package/test/compiling/types.ts

@@ -0,0 +1,28 @@
+import { Field, VerificationKey } from "o1js";
+
+import { CompileRegistry, InferDependencyArtifacts } from "../../src";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+type TestModule = {
+  compile(
+    registry: CompileRegistry
+  ): Promise<{ bar: { verificationKey: VerificationKey } }>;
+};
+
+type Inferred = InferDependencyArtifacts<{ foo: TestModule }>;
+const typeAssignmentTest: Inferred = {
+  foo: {
+    bar: {
+      verificationKey: {
+        data: "",
+        hash: Field(1),
+      },
+    },
+  },
+};
+
+const typePropertyTest: Inferred["foo"]["bar"]["verificationKey"] extends VerificationKey
+  ? true
+  : false = true;
+
+/* eslint-enable @typescript-eslint/no-unused-vars */

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/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/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/ProvableReductionHashList.test.ts

@@ -0,0 +1,117 @@
+import "reflect-metadata";
+import { Bool, Field, Poseidon } from "o1js";
+
+import {
+  StateTransitionReductionList,
+  reduceStateTransitions,
+} from "../../src/utils/StateTransitionReductionList";
+import {
+  DefaultProvableHashList,
+  ProvableStateTransition,
+  StateTransition,
+  Option,
+} from "../../src";
+
+interface UnprovableStateTransition {
+  path: number;
+  from: number;
+  to: { isSome: boolean; value: number };
+}
+
+describe("provableReductionHashList", () => {
+  function mapToProvable(
+    sts: UnprovableStateTransition[]
+  ): StateTransition<unknown>[] {
+    return sts.map(
+      (st) =>
+        new StateTransition(
+          Field(st.path),
+          new Option(Bool(true), Field(st.from), Field, Bool(false)),
+          new Option(Bool(st.to.isSome), Field(st.to.value), Field, Bool(false))
+        ) as StateTransition<unknown>
+    );
+  }
+
+  describe.each<[UnprovableStateTransition[], number]>([
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: true, value: 15 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: true, value: 20 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 20, to: { isSome: true, value: 25 } },
+        { path: 5, from: 25, to: { isSome: true, value: 30 } },
+      ],
+      4,
+    ],
+  ])("should reduce and append correctly", (sts, reducedLength) => {
+    it("start from empty list", () => {
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition
+      );
+      const normalList = new DefaultProvableHashList(ProvableStateTransition);
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+
+    it("start from non-zero commitment - skip first reduction", () => {
+      const commitment = Poseidon.hash([Field(123_456)]);
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition,
+        commitment
+      );
+      const normalList = new DefaultProvableHashList(
+        ProvableStateTransition,
+        commitment
+      );
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,27 @@
+import "reflect-metadata";
+
+import { stringToField } from "../src";
+
+describe("stringToField", () => {
+  const stringToFieldInputs: string[] = [];
+
+  [31, 32, 33, 63, 64, 65, 1000].forEach((length) => {
+    stringToFieldInputs.push(
+      Array.from({ length })
+        .map(() => "A")
+        .reduce((a, b) => a + b)
+    );
+  });
+
+  it.each(
+    ["", "a", "Helloasdlsdaglsdiousdioagiosadgoisaudogiusadogusoadgds"].concat(
+      stringToFieldInputs
+    )
+  )("should encode without errors", (input) => {
+    expect.assertions(1);
+
+    const field = stringToField(input);
+
+    expect(field.toBigInt()).toBeGreaterThan(0n);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["./src/index.ts"],
+  "exclude": ["./dist/**/*.ts"]
+}