@proto-kit/module 0.1.1-develop.0

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

package/test/modules/State.test.ts

@@ -0,0 +1,81 @@
+import "reflect-metadata";
+import { PublicKey, UInt64 } from "o1js";
+import { container } from "tsyringe";
+import {
+  NetworkState,
+  Option,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+} from "@proto-kit/protocol";
+import { expectDefined } from "@proto-kit/common";
+
+import { Runtime } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
+
+import { Admin } from "./Admin";
+import { Balances } from "./Balances";
+
+describe("state", () => {
+  let balances: Balances;
+
+  let runtime: Runtime<{
+    Admin: typeof Admin;
+    Balances: typeof Balances;
+  }>;
+
+  function createChain() {
+    ({ runtime } = createTestingRuntime(
+      {
+        Admin,
+        Balances,
+      },
+      {
+        Admin: {
+          publicKey: PublicKey.empty<typeof PublicKey>().toBase58(),
+        },
+        Balances: {},
+      }
+    ));
+
+    balances = runtime.resolve("Balances");
+  }
+
+  beforeEach(() => {
+    createChain();
+  });
+
+  describe("state decorator", () => {
+    it("should decorate state properties correctly", () => {
+      expectDefined(balances.totalSupply.path);
+    });
+  });
+
+  describe("transient state", () => {
+    it("should track previously set state", async () => {
+      expect.assertions(2);
+
+      const executionContext = container.resolve(RuntimeMethodExecutionContext);
+      executionContext.setup({
+        networkState: NetworkState.empty(),
+        transaction: RuntimeTransaction.dummyTransaction(),
+      });
+      await balances.transientState();
+
+      const stateTransitions = executionContext
+        .current()
+        .result.stateTransitions.map((stateTransition) =>
+          stateTransition.toProvable()
+        );
+
+      const expectedLastOption = Option.fromValue(
+        UInt64.from(200),
+        UInt64
+      ).toProvable();
+
+      const last = stateTransitions.at(-1);
+
+      expect(last).toBeDefined();
+      expect(last!.to.value).toStrictEqual(expectedLastOption.value);
+    });
+  });
+});

package/test/runtimeMethod.test.ts

@@ -0,0 +1,215 @@
+import "reflect-metadata";
+import {
+  PublicKey,
+  Struct,
+  Bool,
+  PrivateKey,
+  Field,
+  UInt64,
+  Poseidon,
+} from "o1js";
+import {
+  MethodPublicOutput,
+  NetworkState,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+} from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { AreProofsEnabled, log } from "@proto-kit/common";
+
+import {
+  Runtime,
+  MethodParameterEncoder,
+  runtimeModule,
+  RuntimeModule,
+  runtimeMethod,
+  toEventsHash,
+  RuntimeEvents,
+} from "../src";
+
+import { Balances } from "./modules/Balances";
+import { createTestingRuntime } from "./TestingRuntime";
+
+export class PrimaryTestEvent extends Struct({
+  message: Bool,
+}) {}
+
+export class SecondaryTestEvent extends Struct({
+  message: Bool,
+}) {}
+
+@runtimeModule()
+class EventMaker extends RuntimeModule {
+  public constructor() {
+    super();
+  }
+
+  public events = new RuntimeEvents({
+    primary: PrimaryTestEvent,
+    secondary: SecondaryTestEvent,
+  });
+
+  @runtimeMethod()
+  public async makeEvent() {
+    this.events.emit("primary", new PrimaryTestEvent({ message: Bool(false) }));
+    // Should not emit as condition is false.
+    this.events.emitIf(
+      Bool(false),
+      "primary",
+      new PrimaryTestEvent({ message: Bool(false) })
+    );
+    this.events.emit(
+      "secondary",
+      new SecondaryTestEvent({ message: Bool(true) })
+    );
+  }
+}
+
+describe("runtimeMethod", () => {
+  const parameters = [PublicKey.empty<typeof PublicKey>()];
+
+  let runtime: Runtime<{
+    Balances: typeof Balances;
+    EventMaker: typeof EventMaker;
+  }>;
+
+  beforeEach(() => {
+    log.setLevel(log.levels.DEBUG);
+    ({ runtime } = createTestingRuntime(
+      {
+        Balances,
+        EventMaker,
+      },
+      {
+        Balances: {},
+        EventMaker: {},
+      }
+    ));
+  });
+
+  it("should create correct param types", async () => {
+    expect.assertions(1 + parameters.length);
+
+    const module = runtime.resolve("Balances");
+
+    const decoder = MethodParameterEncoder.fromMethod(module, "getBalance");
+    const recodedParameters = await decoder.decode(
+      parameters.flatMap((x) => x.toFields()),
+      []
+    );
+
+    expect(parameters).toHaveLength(recodedParameters.length);
+
+    parameters.forEach((parameter, index) => {
+      expect(parameter).toStrictEqual(recodedParameters[index]);
+    });
+  });
+
+  it("should throw on incorrect methodId on tx", async () => {
+    expect.assertions(1);
+
+    const context = container.resolve(RuntimeMethodExecutionContext);
+
+    runtime.registerValue({
+      AppChain: {
+        areProofsEnabled: false,
+      } as AreProofsEnabled,
+    });
+
+    context.setup({
+      transaction: RuntimeTransaction.dummyTransaction(),
+      networkState: NetworkState.empty(),
+    });
+
+    const module = runtime.resolve("Balances");
+    await module.getBalance(PublicKey.empty<typeof PublicKey>());
+
+    context.setup({
+      transaction: RuntimeTransaction.dummyTransaction(),
+      networkState: NetworkState.empty(),
+    });
+
+    await expect(context.current().result.prover!()).rejects.toThrow(
+      "Runtimemethod called with wrong methodId on the transaction object"
+    );
+  });
+
+  it("should capture event", async () => {
+    expect.assertions(5);
+
+    const context = container.resolve(RuntimeMethodExecutionContext);
+
+    runtime.registerValue({
+      AppChain: {
+        areProofsEnabled: false,
+      } as AreProofsEnabled,
+    });
+
+    const eventMakerMethodId = runtime.methodIdResolver.getMethodId(
+      "EventMaker",
+      "makeEvent"
+    );
+
+    const privateKey = PrivateKey.random();
+    context.setup({
+      transaction: RuntimeTransaction.fromTransaction({
+        sender: privateKey.toPublicKey(),
+        nonce: UInt64.from(0),
+        methodId: Field(eventMakerMethodId),
+        argsHash: Poseidon.hash([]),
+      }),
+      networkState: NetworkState.empty(),
+    });
+
+    const module = runtime.resolve("EventMaker");
+    await module.makeEvent();
+
+    const firstExpectedEvent = {
+      eventType: PrimaryTestEvent,
+      event: new PrimaryTestEvent({
+        message: Bool(false),
+      }),
+      eventName: "primary",
+      condition: Bool(true),
+    };
+
+    const secondExpectedEvent = {
+      eventType: PrimaryTestEvent,
+      event: new PrimaryTestEvent({
+        message: Bool(false),
+      }),
+      eventName: "primary",
+      condition: Bool(false),
+    };
+
+    const thirdExpectedEvent = {
+      eventType: SecondaryTestEvent,
+      event: new SecondaryTestEvent({
+        message: Bool(true),
+      }),
+      eventName: "secondary",
+      condition: Bool(true),
+    };
+
+    const eventsResults = context.current().result.events;
+    expect(eventsResults).toHaveLength(3);
+    expect(eventsResults[0]).toStrictEqual(firstExpectedEvent);
+    expect(eventsResults[1]).toStrictEqual(secondExpectedEvent);
+    expect(eventsResults[2]).toStrictEqual(thirdExpectedEvent);
+
+    context.afterMethod();
+
+    const proof = await context.current().result.prover!();
+    const publicOuput = proof.publicOutput as MethodPublicOutput;
+    const { eventsHash } = publicOuput;
+    //  Note that we omit the second event from below as it was
+    //  not emitted due to the condition being false.
+    expect(eventsHash).toStrictEqual(
+      toEventsHash([
+        { ...firstExpectedEvent, condition: Bool(true) },
+        { ...secondExpectedEvent, condition: Bool(false) },
+        { ...thirdExpectedEvent, condition: Bool(true) },
+      ])
+    );
+  });
+});

package/test/tsconfig.json

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

package/tsconfig.json

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