@proto-kit/module 0.1.1-develop.0

package/test/TestingRuntime.ts

@@ -0,0 +1,45 @@
+import { ModulesConfig } from "@proto-kit/common";
+import { StateServiceProvider } from "@proto-kit/protocol";
+import { container } from "tsyringe";
+
+import { InMemoryStateService, Runtime, RuntimeModulesRecord } from "../src";
+
+export function createTestingRuntime<Modules extends RuntimeModulesRecord>(
+  modules: Modules,
+  config: ModulesConfig<Modules>
+): {
+  runtime: Runtime<Modules>;
+  state: InMemoryStateService;
+} {
+  const state = new InMemoryStateService();
+
+  const Runtimeclass = Runtime.from({
+    modules,
+  });
+  const runtime = new Runtimeclass();
+
+  runtime.configure(config);
+
+  runtime.create(() => container.createChildContainer());
+
+  runtime.dependencyContainer.register("AreProofsEnabled", {
+    useValue: {
+      areProofsEnabled: false,
+
+      setProofsEnabled(areProofsEnabled: boolean) {
+        this.areProofsEnabled = areProofsEnabled;
+      },
+    },
+  });
+  runtime.registerValue({
+    StateServiceProvider: new StateServiceProvider(),
+    Runtime: runtime,
+  });
+
+  runtime.stateServiceProvider.setCurrentStateService(state);
+
+  return {
+    runtime,
+    state,
+  };
+}

package/test/method/MethodParameterEncoder.test.ts

@@ -0,0 +1,121 @@
+import {
+  Struct,
+  Field,
+  Bool,
+  PublicKey,
+  PrivateKey,
+  ZkProgram,
+  Proof,
+} from "o1js";
+import { NonMethods } from "@proto-kit/common";
+
+import { MethodParameterEncoder } from "../../src";
+
+class TestStruct extends Struct({
+  a: Field,
+  b: Bool,
+}) {}
+
+const TestProgram = ZkProgram({
+  name: "TestProgram",
+  publicInput: PublicKey,
+  publicOutput: TestStruct,
+  methods: {
+    foo: {
+      privateInputs: [],
+      method: async (input: PublicKey) => {
+        return {
+          a: Field(input.x),
+          b: Bool(input.isOdd),
+        };
+      },
+    },
+  },
+});
+class TestProof extends ZkProgram.Proof(TestProgram) {}
+
+describe("MethodParameterEncoder", () => {
+  it("should en/decode Structs correctly", async () => {
+    expect.assertions(7);
+
+    const encoder = new MethodParameterEncoder([TestStruct]);
+    const { fields, auxiliary } = encoder.encode([
+      { a: Field(2), b: Bool(true) },
+    ]);
+
+    expect(auxiliary).toHaveLength(0);
+    expect(fields).toHaveLength(2);
+    expect(fields[0].toString()).toBe("2");
+    expect(fields[1].toString()).toStrictEqual(Bool(true).toField().toString());
+
+    const decoded = await encoder.decode(fields, auxiliary);
+    expect(decoded).toHaveLength(1);
+    const decoded1 = decoded[0] as unknown as NonMethods<TestStruct>;
+    expect(decoded1.a.toString()).toStrictEqual("2");
+    expect(decoded1.b.toString()).toStrictEqual("true");
+  });
+
+  it("should en/decode CircuitValues correctly", async () => {
+    expect.assertions(6);
+
+    const encoder = new MethodParameterEncoder([PublicKey]);
+    const pk = PrivateKey.random().toPublicKey();
+
+    const { fields, auxiliary } = encoder.encode([pk]);
+
+    expect(auxiliary).toHaveLength(0);
+    expect(fields).toHaveLength(2);
+    expect(fields.map((x) => x.toString())).toStrictEqual(
+      pk.toFields().map((x) => x.toString())
+    );
+
+    const decoded = await encoder.decode(fields, auxiliary);
+    expect(decoded).toHaveLength(1);
+
+    const decoded1 = decoded[0] as unknown as PublicKey;
+    expect(decoded1.x.toString()).toStrictEqual(pk.x.toString());
+    expect(decoded1.isOdd.toString()).toStrictEqual(pk.isOdd.toString());
+  });
+
+  it("should en/decode Proofs correctly", async () => {
+    expect.assertions(13);
+
+    const encoder = new MethodParameterEncoder([TestProof]);
+    const input = PrivateKey.random().toPublicKey();
+    const output = { a: input.x, b: input.isOdd };
+    const dummy = await TestProof.dummy(input, output, 0);
+
+    const { fields, auxiliary } = encoder.encode([dummy]);
+
+    expect(auxiliary).toHaveLength(1);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const json = JSON.parse(auxiliary[0]);
+
+    expect(json).toHaveProperty("maxProofsVerified");
+    expect(json).toHaveProperty("proof");
+    expect(json.maxProofsVerified).toStrictEqual(0);
+    expect(json.proof.length).toBeGreaterThan(20);
+
+    expect(fields).toHaveLength(4);
+    expect(fields.map((x) => x.toString())).toStrictEqual(
+      [...input.toFields(), ...TestStruct.toFields(output)].map((x) =>
+        x.toString()
+      )
+    );
+
+    const decoded = await encoder.decode(fields, auxiliary);
+    expect(decoded).toHaveLength(1);
+
+    const decoded1 = decoded[0] as unknown as Proof<PublicKey, TestStruct>;
+    expect(decoded1.maxProofsVerified).toStrictEqual(0);
+    expect(decoded1.proof).toBeDefined();
+    expect(decoded1.publicInput.equals(input).toBoolean()).toStrictEqual(true);
+    expect(decoded1.publicOutput.a.equals(output.a).toBoolean()).toStrictEqual(
+      true
+    );
+    expect(decoded1.publicOutput.b.equals(output.b).toBoolean()).toStrictEqual(
+      true
+    );
+  }, 30000);
+});

package/test/method/runtimeMethod-fail.test.ts

@@ -0,0 +1,50 @@
+import { Bool, Field, PublicKey, Struct, ZkProgram } from "o1js";
+import { noop } from "@proto-kit/common";
+
+import { runtimeMethod, RuntimeModule, runtimeModule } from "../../src";
+
+class TestStruct extends Struct({
+  a: Field,
+  b: Bool,
+}) {}
+class TieredStruct extends TestStruct {}
+const TestProgram = ZkProgram({
+  name: "TestProgram",
+  publicInput: PublicKey,
+  publicOutput: TestStruct,
+  methods: {
+    foo: {
+      privateInputs: [],
+      method: async (input: PublicKey) => {
+        return {
+          a: Field(input.x),
+          b: Bool(input.isOdd),
+        };
+      },
+    },
+  },
+});
+class TestProof extends ZkProgram.Proof(TestProgram) {}
+
+describe("Creating module with non-provable method argument", () => {
+  it("should throw on non-provable method signature", () => {
+    expect(() => {
+      @runtimeModule()
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      class TestModule extends RuntimeModule {
+        @runtimeMethod()
+        public async foo(
+          a: TieredStruct,
+          b: PublicKey,
+          c: Field,
+          d: TestProof,
+          e: string
+        ) {
+          noop();
+        }
+      }
+    }).toThrow(
+      "Not all arguments of method 'undefined.foo' are provable types or proofs (indizes: [4])"
+    );
+  });
+});

package/test/method/runtimeMethod.test.ts

@@ -0,0 +1,46 @@
+import "reflect-metadata";
+
+import { Bool, Field } from "o1js";
+import { Option, StateTransition } from "@proto-kit/protocol";
+
+import { toStateTransitionsHash } from "../../src/method/runtimeMethod";
+
+describe.skip("toStateTransitionsHash", () => {
+  const noneStateTransition = StateTransition.from(
+    Field(0),
+    new Option(Bool(false), Field(0), Field)
+  );
+
+  const someStateTransition = StateTransition.from(
+    Field(0),
+    new Option(Bool(true), Field(0), Field)
+  );
+
+  it.each([
+    [
+      [noneStateTransition],
+      "7067243248312463521220230733411703436580237248681301130001246160136823979683",
+    ],
+    [
+      [someStateTransition],
+      "12841542804403638489097503092490970035615082088155587790175618374946575398395",
+    ],
+    [
+      [noneStateTransition, someStateTransition],
+      "20641278138648130746922286021889771603940136555847557324578879341962747943601",
+    ],
+    [
+      [someStateTransition, noneStateTransition],
+      "10362098987098600767020985423446775093761176563902435645494178193997179006954",
+    ],
+  ])(
+    "should calculate a hash of all provided state transitions",
+    (stateTransitions, expectedHash) => {
+      expect.assertions(1);
+
+      const hash = toStateTransitionsHash(stateTransitions).toString();
+
+      expect(hash).toBe(expectedHash);
+    }
+  );
+});

package/test/modules/Admin.ts

@@ -0,0 +1,19 @@
+import { PublicKey } from "o1js";
+import { assert } from "@proto-kit/protocol";
+
+import { runtimeModule } from "../../src/module/decorator.js";
+import { RuntimeModule } from "../../src/runtime/RuntimeModule.js";
+import { runtimeMethod } from "../../src/method/runtimeMethod.js";
+
+interface AdminConfig {
+  publicKey: string;
+}
+
+@runtimeModule()
+export class Admin extends RuntimeModule<AdminConfig> {
+  @runtimeMethod()
+  public async isAdmin(publicKey: PublicKey) {
+    const admin = PublicKey.empty<typeof PublicKey>().toConstant();
+    assert(admin.equals(publicKey));
+  }
+}

package/test/modules/Balances.test.ts

@@ -0,0 +1,337 @@
+import "reflect-metadata";
+import { Field, Poseidon, PrivateKey, Proof, PublicKey, UInt64 } from "o1js";
+import { container } from "tsyringe";
+import {
+  type ProvableStateTransition,
+  Path,
+  MethodPublicOutput,
+  SimpleAsyncStateService,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  NetworkState,
+} from "@proto-kit/protocol";
+
+import { Runtime } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
+
+import { Balances } from "./Balances.js";
+import { Admin } from "./Admin.js";
+
+describe("balances", () => {
+  let balances: Balances;
+
+  let state: SimpleAsyncStateService;
+
+  let runtime: Runtime<{
+    Admin: typeof Admin;
+    Balances: typeof Balances;
+  }>;
+
+  async function getStateValue(path: Field | undefined) {
+    if (!path) {
+      throw new Error("Path not found");
+    }
+
+    const stateValue = await state.get(path);
+
+    if (!stateValue) {
+      throw new Error("stateValue is undefined");
+    }
+
+    return stateValue;
+  }
+
+  async function createChain() {
+    ({ runtime, state } = createTestingRuntime(
+      {
+        Balances,
+        Admin,
+      },
+      {
+        Admin: {
+          publicKey: PublicKey.empty<typeof PublicKey>().toBase58(),
+        },
+
+        Balances: {},
+      }
+    ));
+
+    balances = runtime.resolve("Balances");
+
+    await state.set(balances.totalSupply.path!, UInt64.from(10).toFields());
+  }
+
+  describe.skip("compile and prove", () => {
+    beforeAll(createChain);
+
+    // Disabled until we implement a mechanism to enable/disable compiling tests
+    it("should compile and prove a method execution", async () => {
+      expect.assertions(3);
+
+      runtime.zkProgrammable.areProofsEnabled?.setProofsEnabled(true);
+
+      const executionContext = container.resolve(RuntimeMethodExecutionContext);
+      executionContext.setup({
+        transaction: RuntimeTransaction.dummyTransaction(),
+        networkState: NetworkState.empty(),
+      });
+
+      const expectedStateTransitionsHash =
+        "1439144406936083177718146178121957896974210157062549589517697792374542035761";
+      const expectedStatus = true;
+
+      await runtime.zkProgrammable.zkProgram[0].compile();
+
+      await balances.getTotalSupply();
+
+      const { result } = executionContext.current();
+
+      const proof = await result.prove<Proof<undefined, MethodPublicOutput>>();
+
+      const verified = await runtime.zkProgrammable.zkProgram[0].verify(proof);
+
+      runtime.zkProgrammable.areProofsEnabled?.setProofsEnabled(false);
+
+      expect(verified).toBe(true);
+
+      expect(proof.publicOutput.stateTransitionsHash.toString()).toStrictEqual(
+        expectedStateTransitionsHash
+      );
+      expect(proof.publicOutput.status.toBoolean()).toBe(expectedStatus);
+    }, 180_000);
+  });
+
+  describe("getTotalSupply", () => {
+    beforeAll(createChain);
+
+    describe("state transitions", () => {
+      let stateTransitions: ProvableStateTransition[];
+
+      beforeEach(async () => {
+        const executionContext = container.resolve(
+          RuntimeMethodExecutionContext
+        );
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+        await balances.getTotalSupply();
+
+        stateTransitions = executionContext
+          .current()
+          .result.stateTransitions.map((stateTransition) =>
+            stateTransition.toProvable()
+          );
+      });
+
+      it("should return a single state transition", () => {
+        expect.assertions(1);
+        expect(stateTransitions).toHaveLength(1);
+      });
+
+      it("should have a state transition for the correct path", () => {
+        expect.assertions(1);
+
+        const path = Path.fromProperty("Balances", "totalSupply");
+
+        expect(stateTransitions[0].path.toString()).toStrictEqual(
+          path.toString()
+        );
+      });
+
+      it("should produce a from-only state transition", async () => {
+        expect.assertions(3);
+
+        const [stateTransition] = stateTransitions;
+
+        const value = UInt64.fromFields(
+          await getStateValue(balances.totalSupply.path)
+        );
+        const treeValue = Poseidon.hash(value.toFields());
+
+        expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+        expect(stateTransition.from.value.toString()).toBe(
+          treeValue.toString()
+        );
+        expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+      });
+    });
+
+    describe("state transitions from empty state", () => {
+      let stateTransitions: ProvableStateTransition[];
+
+      beforeAll(async () => {
+        await createChain();
+
+        await state.set(balances.totalSupply.path!, undefined);
+      });
+
+      beforeEach(async () => {
+        const executionContext = container.resolve(
+          RuntimeMethodExecutionContext
+        );
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.getTotalSupply();
+
+        stateTransitions = executionContext
+          .current()
+          .result.stateTransitions.map((stateTransition) =>
+            stateTransition.toProvable()
+          );
+      });
+
+      it("should return a single state transition", () => {
+        expect.assertions(1);
+        expect(stateTransitions).toHaveLength(1);
+      });
+
+      it("should have a state transition for the correct path", () => {
+        expect.assertions(1);
+
+        const path = Path.fromProperty("Balances", "totalSupply");
+
+        expect(stateTransitions[0].path.toString()).toStrictEqual(
+          path.toString()
+        );
+      });
+
+      it("should produce a from-only state transition", () => {
+        expect.assertions(3);
+
+        const [stateTransition] = stateTransitions;
+
+        const treeValue = Field(0);
+
+        expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+        expect(stateTransition.from.value.toString()).toBe(
+          treeValue.toString()
+        );
+        expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+      });
+    });
+  });
+
+  describe("setTotalSupply", () => {
+    beforeAll(createChain);
+
+    describe("state transitions", () => {
+      let stateTransitions: ProvableStateTransition[];
+
+      beforeEach(async () => {
+        const executionContext = container.resolve(
+          RuntimeMethodExecutionContext
+        );
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.setTotalSupply();
+
+        stateTransitions = executionContext
+          .current()
+          .result.stateTransitions.map((stateTransition) =>
+            stateTransition.toProvable()
+          );
+      });
+
+      it("should return a single state transition", () => {
+        expect.assertions(1);
+        expect(stateTransitions).toHaveLength(1);
+      });
+
+      it("should have a state transition for the correct path", () => {
+        expect.assertions(1);
+
+        const path = Path.fromProperty("Balances", "totalSupply");
+
+        expect(stateTransitions[0].path.toString()).toStrictEqual(
+          path.toString()
+        );
+      });
+
+      it("should produce a from-to state transition", async () => {
+        expect.assertions(4);
+
+        const [stateTransition] = stateTransitions;
+        const fromValue = UInt64.fromFields(
+          await getStateValue(balances.totalSupply.path)
+        );
+        const fromTreeValue = Poseidon.hash(fromValue.toFields());
+
+        const toValue = UInt64.from(20);
+        const toTreeValue = Poseidon.hash(toValue.toFields());
+
+        expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+        expect(stateTransition.from.value.toString()).toBe(
+          fromTreeValue.toString()
+        );
+
+        expect(stateTransition.to.isSome.toBoolean()).toBe(true);
+        expect(stateTransition.to.value.toString()).toBe(
+          toTreeValue.toString()
+        );
+      });
+    });
+  });
+
+  describe("getBalance", () => {
+    beforeAll(createChain);
+
+    describe("state transitions", () => {
+      let stateTransitions: ProvableStateTransition[];
+      const address = PrivateKey.random().toPublicKey();
+
+      beforeEach(async () => {
+        const executionContext = container.resolve(
+          RuntimeMethodExecutionContext
+        );
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.getBalance(address);
+
+        stateTransitions = executionContext
+          .current()
+          .result.stateTransitions.map((stateTransition) =>
+            stateTransition.toProvable()
+          );
+      });
+
+      it("should return a single state transition", () => {
+        expect.assertions(1);
+        expect(stateTransitions).toHaveLength(1);
+      });
+
+      it("should have a state transition for the correct path", () => {
+        expect.assertions(1);
+
+        const path = Path.fromKey<PublicKey>(
+          Path.fromProperty("Balances", "balances"),
+          PublicKey,
+          address
+        );
+
+        expect(stateTransitions[0].path.toString()).toStrictEqual(
+          path.toString()
+        );
+      });
+
+      it("should produce a from-only state transition, for non-existing state", () => {
+        expect.assertions(3);
+
+        const [stateTransition] = stateTransitions;
+
+        expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+        expect(stateTransition.from.value.toString()).toBe(Field(0).toString());
+        expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+      });
+    });
+  });
+});

package/test/modules/Balances.ts

@@ -0,0 +1,54 @@
+import { PublicKey, UInt64 } from "o1js";
+import { State, StateMap } from "@proto-kit/protocol";
+import { Presets } from "@proto-kit/common";
+
+import { RuntimeModule, runtimeMethod, runtimeModule, state } from "../../src";
+
+import { Admin } from "./Admin.js";
+
+interface BalancesConfig {}
+
+@runtimeModule()
+export class Balances extends RuntimeModule<BalancesConfig> {
+  /**
+   * We use `satisfies` here in order to be able to access
+   * presets by key in a type safe way.
+   */
+  public static presets = {} satisfies Presets<BalancesConfig>;
+
+  @state() public totalSupply = State.from<UInt64>(UInt64);
+
+  @state() public balances = StateMap.from<PublicKey, UInt64>(
+    PublicKey,
+    UInt64
+  );
+
+  public constructor(public admin: Admin) {
+    super();
+  }
+
+  @runtimeMethod()
+  public async getTotalSupply() {
+    await this.totalSupply.get();
+  }
+
+  @runtimeMethod()
+  public async setTotalSupply() {
+    await this.totalSupply.set(UInt64.from(20));
+    await this.admin.isAdmin(this.transaction.sender.value);
+  }
+
+  @runtimeMethod()
+  public async getBalance(address: PublicKey) {
+    (await this.balances.get(address)).orElse(UInt64.zero);
+  }
+
+  @runtimeMethod()
+  public async transientState() {
+    const totalSupply = await this.totalSupply.get();
+    await this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(100));
+
+    const totalSupply2 = await this.totalSupply.get();
+    await this.totalSupply.set(totalSupply2.orElse(UInt64.zero).add(100));
+  }
+}