@proto-kit/module 0.1.1-develop.1086

package/test/method/MethodParameterEncoder.test.ts

@@ -0,0 +1,152 @@
+import {
+  Struct,
+  Field,
+  Bool,
+  PublicKey,
+  PrivateKey,
+  ZkProgram,
+  Proof,
+} from "o1js";
+import { NonMethods, noop } from "@proto-kit/common";
+
+import {
+  MethodParameterEncoder,
+  RuntimeModule,
+  runtimeModule,
+  runtimeMethod,
+} 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);
+});
+
+class TieredStruct extends TestStruct {}
+
+@runtimeModule()
+class TestModule extends RuntimeModule {
+  @runtimeMethod()
+  public async foo(
+    a: TieredStruct,
+    b: PublicKey,
+    c: Field,
+    d: TestProof,
+    e: string
+  ) {
+    noop();
+  }
+}
+
+describe("MethodParameterEncoder construction", () => {
+  it("should throw on non-provable method signature", () => {
+    const module = new TestModule();
+    module.name = "testModule";
+    expect(() => MethodParameterEncoder.fromMethod(module, "foo")).toThrowError(
+      "'testModule.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.appChain?.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.appChain?.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));
+  }
+}

package/test/modules/MethodIdResolver.test.ts

@@ -0,0 +1,73 @@
+import "reflect-metadata";
+import { assert } from "@proto-kit/protocol";
+import { Field } from "o1js";
+import { beforeAll } from "@jest/globals";
+import { container } from "tsyringe";
+
+import { Runtime } from "../../src/runtime/Runtime";
+import { MethodIdResolver } from "../../src/runtime/MethodIdResolver";
+import { runtimeMethod, RuntimeModule, runtimeModule } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
+
+import { Balances } from "./Balances";
+
+interface AdminConfig {}
+
+@runtimeModule()
+class Admin extends RuntimeModule<AdminConfig> {
+  @runtimeMethod()
+  public async isAdminWithAVeryVeryVeryVeryLongName() {
+    assert(Field(1).equals(Field(1)));
+  }
+}
+
+describe("methodId", () => {
+  let runtime: Runtime<{ Admin: typeof Admin; Balance: typeof Balances }>;
+  let resolver: MethodIdResolver;
+
+  beforeAll(() => {
+    container.clearInstances();
+
+    ({ runtime } = createTestingRuntime(
+      {
+        Admin,
+        Balance: Balances,
+      },
+      {
+        Admin: {},
+        Balance: {},
+      }
+    ));
+
+    resolver =
+      runtime.dependencyContainer.resolve<MethodIdResolver>("MethodIdResolver");
+  });
+
+  it.each([
+    ["Admin", "isAdminWithAVeryVeryVeryVeryLongName"],
+    ["Balance", "getTotalSupply"],
+    ["Balance", "getBalance"],
+  ])("should pass and encode correctly", (givenModuleName, givenMethodName) => {
+    expect.assertions(2);
+
+    const methodId = resolver.getMethodId(givenModuleName, givenMethodName);
+
+    const [moduleName, methodName] = resolver.getMethodNameFromId(methodId) ?? [
+      undefined,
+      undefined,
+    ];
+
+    expect(moduleName).toBe(givenModuleName);
+    expect(methodName).toBe(givenMethodName);
+  });
+
+  it("should fail for invalid module name", () => {
+    expect.assertions(1);
+
+    expect(() => {
+      resolver.getMethodId("Admin2", "isAdminWithAVeryVeryVeryVeryLongName");
+    }).toThrow(
+      "Only known module names are allowed, using unknown module name: Admin2"
+    );
+  });
+});