@proto-kit/module 0.1.1-develop.600 → 0.1.1-develop.833

package/test/modules/Admin.ts

@@ -1,9 +1,9 @@
 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";
-import { assert } from "@proto-kit/protocol";
 
 interface AdminConfig {
   publicKey: string;
@@ -12,8 +12,8 @@ interface AdminConfig {
 @runtimeModule()
 export class Admin extends RuntimeModule<AdminConfig> {
   @runtimeMethod()
-  public isAdmin(publicKey: PublicKey) {
-    const admin = PublicKey.empty().toConstant();
+  public async isAdmin(publicKey: PublicKey) {
+    const admin = PublicKey.empty<typeof PublicKey>().toConstant();
     assert(admin.equals(publicKey));
   }
 }

package/test/modules/Balances.test.ts

@@ -1,25 +1,18 @@
-/* eslint-disable max-lines */
 import "reflect-metadata";
-import {
-  Bool,
-  Field,
-  Poseidon,
-  PrivateKey,
-  Proof,
-  PublicKey,
-  UInt64,
-} from "o1js";
+import { Field, Poseidon, PrivateKey, Proof, PublicKey, UInt64 } from "o1js";
 import { container } from "tsyringe";
 import {
   type ProvableStateTransition,
   Path,
   MethodPublicOutput,
-  StateService,
+  SimpleAsyncStateService,
   RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  NetworkState,
 } from "@proto-kit/protocol";
 
-import { InMemoryStateService } from "../../src/state/InMemoryStateService.js";
 import { Runtime } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
 
 import { Balances } from "./Balances.js";
 import { Admin } from "./Admin.js";
@@ -27,19 +20,19 @@ import { Admin } from "./Admin.js";
 describe("balances", () => {
   let balances: Balances;
 
-  let state: StateService;
+  let state: SimpleAsyncStateService;
 
   let runtime: Runtime<{
     Admin: typeof Admin;
     Balances: typeof Balances;
   }>;
 
-  function getStateValue(path: Field | undefined) {
+  async function getStateValue(path: Field | undefined) {
     if (!path) {
       throw new Error("Path not found");
     }
 
-    const stateValue = state.get(path);
+    const stateValue = await state.get(path);
 
     if (!stateValue) {
       throw new Error("stateValue is undefined");
@@ -49,47 +42,26 @@ describe("balances", () => {
   }
 
   function createChain() {
-    state = new InMemoryStateService();
-
-    runtime = Runtime.from({
-      state,
-
-      modules: {
-        Admin,
+    ({ runtime, state } = createTestingRuntime(
+      {
         Balances,
+        Admin,
       },
-    });
-
-    runtime.dependencyContainer.register("AreProofsEnabled", {
-      useValue: {
-        areProofsEnabled: false,
-
-        setProofsEnabled(areProofsEnabled: boolean) {
-          this.areProofsEnabled = areProofsEnabled;
+      {
+        Admin: {
+          publicKey: PublicKey.empty<typeof PublicKey>().toBase58(),
         },
-      },
-    });
 
-    runtime.configure({
-      Admin: {
-        publicKey: PublicKey.empty().toBase58(),
-      },
-
-      Balances: {
-        test: Bool(true),
-      },
-    });
+        Balances: {},
+      }
+    ));
 
     balances = runtime.resolve("Balances");
 
-    state.set(
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      balances.totalSupply.path!,
-      UInt64.from(10).toFields()
-    );
+    state.set(balances.totalSupply.path!, UInt64.from(10).toFields());
   }
 
-  describe("compile and prove", () => {
+  describe.skip("compile and prove", () => {
     beforeAll(createChain);
 
     // Disabled until we implement a mechanism to enable/disable compiling tests
@@ -99,13 +71,18 @@ describe("balances", () => {
       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.compile();
 
-      balances.getTotalSupply();
+      await balances.getTotalSupply();
 
       const { result } = executionContext.current();
 
@@ -130,11 +107,15 @@ describe("balances", () => {
     describe("state transitions", () => {
       let stateTransitions: ProvableStateTransition[];
 
-      beforeEach(() => {
+      beforeEach(async () => {
         const executionContext = container.resolve(
           RuntimeMethodExecutionContext
         );
-        balances.getTotalSupply();
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+        await balances.getTotalSupply();
 
         stateTransitions = executionContext
           .current()
@@ -158,13 +139,13 @@ describe("balances", () => {
         );
       });
 
-      it("should produce a from-only state transition", () => {
+      it("should produce a from-only state transition", async () => {
         expect.assertions(3);
 
         const [stateTransition] = stateTransitions;
 
         const value = UInt64.fromFields(
-          getStateValue(balances.totalSupply.path)
+          await getStateValue(balances.totalSupply.path)
         );
         const treeValue = Poseidon.hash(value.toFields());
 
@@ -181,15 +162,20 @@ describe("balances", () => {
 
       beforeAll(() => {
         createChain();
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+
         state.set(balances.totalSupply.path!, undefined);
       });
 
-      beforeEach(() => {
+      beforeEach(async () => {
         const executionContext = container.resolve(
           RuntimeMethodExecutionContext
         );
-        balances.getTotalSupply();
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.getTotalSupply();
 
         stateTransitions = executionContext
           .current()
@@ -235,11 +221,16 @@ describe("balances", () => {
     describe("state transitions", () => {
       let stateTransitions: ProvableStateTransition[];
 
-      beforeEach(() => {
+      beforeEach(async () => {
         const executionContext = container.resolve(
           RuntimeMethodExecutionContext
         );
-        balances.setTotalSupply();
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.setTotalSupply();
 
         stateTransitions = executionContext
           .current()
@@ -263,12 +254,12 @@ describe("balances", () => {
         );
       });
 
-      it("should produce a from-to state transition", () => {
+      it("should produce a from-to state transition", async () => {
         expect.assertions(4);
 
         const [stateTransition] = stateTransitions;
         const fromValue = UInt64.fromFields(
-          getStateValue(balances.totalSupply.path)
+          await getStateValue(balances.totalSupply.path)
         );
         const fromTreeValue = Poseidon.hash(fromValue.toFields());
 
@@ -295,11 +286,16 @@ describe("balances", () => {
       let stateTransitions: ProvableStateTransition[];
       const address = PrivateKey.random().toPublicKey();
 
-      beforeEach(() => {
+      beforeEach(async () => {
         const executionContext = container.resolve(
           RuntimeMethodExecutionContext
         );
-        balances.getBalance(address);
+        executionContext.setup({
+          transaction: RuntimeTransaction.dummyTransaction(),
+          networkState: NetworkState.empty(),
+        });
+
+        await balances.getBalance(address);
 
         stateTransitions = executionContext
           .current()

package/test/modules/Balances.ts

@@ -1,14 +1,12 @@
-import { Bool, PublicKey, UInt64 } from "o1js";
-import { Option, State, StateMap } from "@proto-kit/protocol";
+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 {
-  test: Bool;
-}
+interface BalancesConfig {}
 
 @runtimeModule()
 export class Balances extends RuntimeModule<BalancesConfig> {
@@ -30,28 +28,27 @@ export class Balances extends RuntimeModule<BalancesConfig> {
   }
 
   @runtimeMethod()
-  public getTotalSupply() {
-    this.totalSupply.get();
+  public async getTotalSupply() {
+    await this.totalSupply.get();
   }
 
   @runtimeMethod()
-  public setTotalSupply() {
-    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    this.totalSupply.set(UInt64.from(20));
-    this.admin.isAdmin(this.transaction.sender);
+  public async setTotalSupply() {
+    await this.totalSupply.set(UInt64.from(20));
+    await this.admin.isAdmin(this.transaction.sender.value);
   }
 
   @runtimeMethod()
-  public getBalance(address: PublicKey): Option<UInt64> {
-    return this.balances.get(address);
+  public async getBalance(address: PublicKey) {
+    (await this.balances.get(address)).orElse(UInt64.zero);
   }
 
   @runtimeMethod()
-  public transientState() {
-    const totalSupply = this.totalSupply.get();
-    this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(100));
+  public async transientState() {
+    const totalSupply = await this.totalSupply.get();
+    await this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(100));
 
-    const totalSupply2 = this.totalSupply.get();
-    this.totalSupply.set(totalSupply2.orElse(UInt64.zero).add(100));
+    const totalSupply2 = await this.totalSupply.get();
+    await this.totalSupply.set(totalSupply2.orElse(UInt64.zero).add(100));
   }
 }

package/test/modules/{methodId.test.ts → MethodIdResolver.test.ts}

@@ -1,17 +1,14 @@
 import "reflect-metadata";
-import { Bool, Field } from "o1js";
-import { beforeAll, beforeEach } from "@jest/globals";
+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 {
-  assert,
-  InMemoryStateService,
-  runtimeMethod,
-  RuntimeModule,
-  runtimeModule,
-} from "../../src";
-import { container } from "tsyringe";
+import { runtimeMethod, RuntimeModule, runtimeModule } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
+
 import { Balances } from "./Balances";
 
 interface AdminConfig {}
@@ -19,7 +16,7 @@ interface AdminConfig {}
 @runtimeModule()
 class Admin extends RuntimeModule<AdminConfig> {
   @runtimeMethod()
-  public isAdminWithAVeryVeryVeryVeryLongName() {
+  public async isAdminWithAVeryVeryVeryVeryLongName() {
     assert(Field(1).equals(Field(1)));
   }
 }
@@ -31,22 +28,16 @@ describe("methodId", () => {
   beforeAll(() => {
     container.clearInstances();
 
-    runtime = Runtime.from({
-      modules: {
+    ({ runtime } = createTestingRuntime(
+      {
         Admin,
         Balance: Balances,
       },
-
-      config: {
+      {
         Admin: {},
-        Balance: {
-          test: Bool(true),
-        },
-      },
-
-      state: new InMemoryStateService(),
-    });
-    runtime.start();
+        Balance: {},
+      }
+    ));
 
     resolver =
       runtime.dependencyContainer.resolve<MethodIdResolver>("MethodIdResolver");

package/test/modules/State.test.ts

@@ -1,60 +1,41 @@
 import "reflect-metadata";
-import { Bool, PublicKey, UInt64 } from "o1js";
+import { PublicKey, UInt64 } from "o1js";
 import { container } from "tsyringe";
 import {
   NetworkState,
   Option,
   RuntimeMethodExecutionContext,
   RuntimeTransaction,
-  StateService,
 } from "@proto-kit/protocol";
+import { expectDefined } from "@proto-kit/common";
 
-import { InMemoryStateService, Runtime } from "../../src";
+import { Runtime } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
 
 import { Admin } from "./Admin";
 import { Balances } from "./Balances";
 
-describe("transient state", () => {
+describe("state", () => {
   let balances: Balances;
 
-  let state: StateService;
-
   let runtime: Runtime<{
     Admin: typeof Admin;
     Balances: typeof Balances;
   }>;
 
   function createChain() {
-    state = new InMemoryStateService();
-
-    runtime = Runtime.from({
-      state,
-
-      modules: {
+    ({ runtime } = createTestingRuntime(
+      {
         Admin,
         Balances,
       },
-    });
-
-    runtime.dependencyContainer.register("AreProofsEnabled", {
-      useValue: {
-        areProofsEnabled: false,
-
-        setProofsEnabled(areProofsEnabled: boolean) {
-          this.areProofsEnabled = areProofsEnabled;
+      {
+        Admin: {
+          publicKey: PublicKey.empty<typeof PublicKey>().toBase58(),
         },
-      },
-    });
-
-    runtime.configure({
-      Admin: {
-        publicKey: PublicKey.empty().toBase58(),
-      },
-
-      Balances: {
-        test: Bool(true),
-      },
-    });
+        Balances: {},
+      }
+    ));
 
     balances = runtime.resolve("Balances");
   }
@@ -63,28 +44,38 @@ describe("transient state", () => {
     createChain();
   });
 
-  it("should track previously set state", () => {
-    const executionContext = container.resolve(RuntimeMethodExecutionContext);
-    executionContext.setup({
-      networkState: new NetworkState({ block: { height: UInt64.zero } }),
-      transaction: undefined as unknown as RuntimeTransaction,
+  describe("state decorator", () => {
+    it("should decorate state properties correctly", () => {
+      expectDefined(balances.totalSupply.path);
     });
-    balances.transientState();
+  });
+
+  describe("transient state", () => {
+    it("should track previously set state", async () => {
+      expect.assertions(2);
 
-    const stateTransitions = executionContext
-      .current()
-      .result.stateTransitions.map((stateTransition) =>
-        stateTransition.toProvable()
-      );
+      const executionContext = container.resolve(RuntimeMethodExecutionContext);
+      executionContext.setup({
+        networkState: NetworkState.empty(),
+        transaction: RuntimeTransaction.dummyTransaction(),
+      });
+      await balances.transientState();
 
-    const expectedLastOption = Option.fromValue(
-      UInt64.from(200),
-      UInt64
-    ).toProvable();
+      const stateTransitions = executionContext
+        .current()
+        .result.stateTransitions.map((stateTransition) =>
+          stateTransition.toProvable()
+        );
 
-    const last = stateTransitions.at(-1);
+      const expectedLastOption = Option.fromValue(
+        UInt64.from(200),
+        UInt64
+      ).toProvable();
 
-    expect(last).toBeDefined();
-    expect(last!.to.value).toStrictEqual(expectedLastOption.value);
+      const last = stateTransitions.at(-1);
+
+      expect(last).toBeDefined();
+      expect(last!.to.value).toStrictEqual(expectedLastOption.value);
+    });
   });
 });

package/test/runtimeMethod.test.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { Bool, Field, PublicKey, UInt64 } from "o1js";
+import { PublicKey } from "o1js";
 import {
   NetworkState,
   RuntimeMethodExecutionContext,
@@ -8,43 +8,37 @@ import {
 import { container } from "tsyringe";
 import { AreProofsEnabled, log } from "@proto-kit/common";
 
-import { InMemoryStateService, MethodIdResolver, Runtime } from "../src";
-import { MethodParameterEncoder } from "../src/method/MethodParameterEncoder";
+import { Runtime, MethodParameterEncoder } from "../src";
 
 import { Balances } from "./modules/Balances";
+import { createTestingRuntime } from "./TestingRuntime";
 
 describe("runtimeMethod", () => {
-  const parameters = [PublicKey.empty()];
+  const parameters = [PublicKey.empty<typeof PublicKey>()];
 
   let runtime: Runtime<{ Balances: typeof Balances }>;
 
   beforeEach(() => {
     log.setLevel(log.levels.DEBUG);
-    runtime = Runtime.from({
-      state: new InMemoryStateService(),
-
-      modules: {
+    ({ runtime } = createTestingRuntime(
+      {
         Balances,
       },
-
-      config: {
-        Balances: {
-          test: Bool(true),
-        },
-      },
-    });
-    runtime.start();
+      {
+        Balances: {},
+      }
+    ));
   });
 
-  it("should create correct param types", () => {
-    // eslint-disable-next-line jest/prefer-expect-assertions
+  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 = decoder.fromFields(
-      parameters.flatMap((x) => x.toFields())
+    const recodedParameters = await decoder.decode(
+      parameters.flatMap((x) => x.toFields()),
+      []
     );
 
     expect(parameters).toHaveLength(recodedParameters.length);
@@ -65,24 +59,17 @@ describe("runtimeMethod", () => {
       } as AreProofsEnabled,
     });
 
-    const transaction = new RuntimeTransaction({
-      methodId: Field(0),
-      nonce: UInt64.zero,
-      argsHash: Field(0),
-      sender: PublicKey.empty(),
-    });
-
     context.setup({
-      transaction,
-      networkState: new NetworkState({ block: { height: UInt64.zero } }),
+      transaction: RuntimeTransaction.dummyTransaction(),
+      networkState: NetworkState.empty(),
     });
 
     const module = runtime.resolve("Balances");
-    module.getBalance(PublicKey.empty());
+    await module.getBalance(PublicKey.empty<typeof PublicKey>());
 
     context.setup({
-      transaction,
-      networkState: new NetworkState({ block: { height: UInt64.zero } }),
+      transaction: RuntimeTransaction.dummyTransaction(),
+      networkState: NetworkState.empty(),
     });
 
     await expect(context.current().result.prover!()).rejects.toThrow(

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

@@ -3,6 +3,6 @@
   "compilerOptions": {
     "outDir": "./dist"
   },
-  "include": ["./src", "src/index.ts"],
-  "exclude": ["./dist/**/*.ts", "./**/*.test.ts", "./test/**/*.ts"]
+  "include": ["./src/index.ts"],
+  "exclude": ["./dist/**/*.ts"]
 }