@proto-kit/module 0.1.1-develop.190 → 0.1.1-develop.2024

package/test/modules/Balances.test.ts

@@ -1,26 +1,19 @@
-/* eslint-disable max-lines */
 import "reflect-metadata";
-import {
-  Bool,
-  Field,
-  Poseidon,
-  PrivateKey,
-  Proof,
-  PublicKey,
-  UInt64,
-} from "snarkyjs";
+import { Field, Poseidon, PrivateKey, Proof, PublicKey, UInt64 } from "o1js";
 import { container } from "tsyringe";
-import { type ProvableStateTransition, Path } from "@proto-kit/protocol";
-
-import {
-  InMemoryStateService,
-  StateService,
-} from "../../src/state/InMemoryStateService.js";
 import {
+  type ProvableStateTransition,
+  Path,
   MethodPublicOutput,
-  Runtime,
+  SimpleAsyncStateService,
   RuntimeMethodExecutionContext,
-} from "../../src";
+  RuntimeTransaction,
+  NetworkState,
+  PROTOKIT_PREFIXES,
+} from "@proto-kit/protocol";
+
+import { Runtime } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
 
 import { Balances } from "./Balances.js";
 import { Admin } from "./Admin.js";
@@ -28,19 +21,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,70 +42,56 @@ describe("balances", () => {
     return stateValue;
   }
 
-  function createChain() {
-    state = new InMemoryStateService();
-
-    runtime = Runtime.from({
-      state,
-
-      modules: {
-        Admin,
+  async function createChain() {
+    ({ runtime, state } = createTestingRuntime(
+      {
         Balances,
+        Admin,
       },
-    });
-
-    runtime.appChain = {
-      areProofsEnabled: false,
-
-      setProofsEnabled(areProofsEnabled) {
-        this.areProofsEnabled = areProofsEnabled;
-      },
-    };
-
-    runtime.configure({
-      Admin: {
-        publicKey: PublicKey.empty().toBase58(),
-      },
+      {
+        Admin: {
+          publicKey: PublicKey.empty<typeof PublicKey>().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()
-    );
+    await 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
     it("should compile and prove a method execution", async () => {
       expect.assertions(3);
 
-      runtime.zkProgrammable.appChain?.setProofsEnabled(true);
+      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.compile();
+      await runtime.zkProgrammable.zkProgram[0].compile();
 
-      balances.getTotalSupply();
+      await balances.getTotalSupply();
 
       const { result } = executionContext.current();
 
       const proof = await result.prove<Proof<undefined, MethodPublicOutput>>();
 
-      const verified = await runtime.zkProgrammable.zkProgram.verify(proof);
+      const verified = await runtime.zkProgrammable.zkProgram[0].verify(proof);
 
-      runtime.zkProgrammable.appChain?.setProofsEnabled(false);
+      runtime.zkProgrammable.areProofsEnabled?.setProofsEnabled(false);
 
       expect(verified).toBe(true);
 
@@ -129,11 +108,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()
@@ -150,20 +133,24 @@ describe("balances", () => {
       it("should have a state transition for the correct path", () => {
         expect.assertions(1);
 
-        const path = Path.fromProperty("Balances", "totalSupply");
+        const path = Path.fromProperty(
+          "Balances",
+          "totalSupply",
+          PROTOKIT_PREFIXES.STATE_RUNTIME
+        );
 
         expect(stateTransitions[0].path.toString()).toStrictEqual(
           path.toString()
         );
       });
 
-      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());
 
@@ -178,17 +165,22 @@ describe("balances", () => {
     describe("state transitions from empty state", () => {
       let stateTransitions: ProvableStateTransition[];
 
-      beforeAll(() => {
-        createChain();
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        state.set(balances.totalSupply.path!, undefined);
+      beforeAll(async () => {
+        await createChain();
+
+        await 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()
@@ -205,7 +197,11 @@ describe("balances", () => {
       it("should have a state transition for the correct path", () => {
         expect.assertions(1);
 
-        const path = Path.fromProperty("Balances", "totalSupply");
+        const path = Path.fromProperty(
+          "Balances",
+          "totalSupply",
+          PROTOKIT_PREFIXES.STATE_RUNTIME
+        );
 
         expect(stateTransitions[0].path.toString()).toStrictEqual(
           path.toString()
@@ -234,11 +230,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()
@@ -255,19 +256,23 @@ describe("balances", () => {
       it("should have a state transition for the correct path", () => {
         expect.assertions(1);
 
-        const path = Path.fromProperty("Balances", "totalSupply");
+        const path = Path.fromProperty(
+          "Balances",
+          "totalSupply",
+          PROTOKIT_PREFIXES.STATE_RUNTIME
+        );
 
         expect(stateTransitions[0].path.toString()).toStrictEqual(
           path.toString()
         );
       });
 
-      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());
 
@@ -294,11 +299,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()
@@ -316,7 +326,11 @@ describe("balances", () => {
         expect.assertions(1);
 
         const path = Path.fromKey<PublicKey>(
-          Path.fromProperty("Balances", "balances"),
+          Path.fromProperty(
+            "Balances",
+            "balances",
+            PROTOKIT_PREFIXES.STATE_RUNTIME
+          ),
           PublicKey,
           address
         );

package/test/modules/Balances.ts

@@ -1,17 +1,12 @@
-import { Bool, PublicKey, UInt64 } from "snarkyjs";
-import { Option } from "@proto-kit/protocol";
+import { PublicKey, UInt64 } from "o1js";
+import { State, StateMap, state } from "@proto-kit/protocol";
 import { Presets } from "@proto-kit/common";
 
-import { State } from "../../src/state/State.js";
-import { state } from "../../src/state/decorator.js";
-import { StateMap } from "../../src/state/StateMap.js";
 import { RuntimeModule, runtimeMethod, runtimeModule } from "../../src";
 
 import { Admin } from "./Admin.js";
 
-interface BalancesConfig {
-  test: Bool;
-}
+interface BalancesConfig {}
 
 @runtimeModule()
 export class Balances extends RuntimeModule<BalancesConfig> {
@@ -33,24 +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 setBalanceIf() {
+  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/{methodId.test.ts → MethodIdResolver.test.ts}

@@ -1,17 +1,14 @@
 import "reflect-metadata";
-import { Bool, Field } from "snarkyjs";
-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");
@@ -56,22 +47,19 @@ describe("methodId", () => {
     ["Admin", "isAdminWithAVeryVeryVeryVeryLongName"],
     ["Balance", "getTotalSupply"],
     ["Balance", "getBalance"],
-    ["Balance", "setBalanceIf"],
-  ])(
-    "should pass and encode correctly",
-    (givenModuleName, givenMethodName) => {
-      expect.assertions(2);
+  ])("should pass and encode correctly", (givenModuleName, givenMethodName) => {
+    expect.assertions(2);
 
-      const methodId = resolver.getMethodId(givenModuleName, givenMethodName);
+    const methodId = resolver.getMethodId(givenModuleName, givenMethodName);
 
-      const [moduleName, methodName] = resolver.getMethodNameFromId(
-        methodId
-      ) ?? [undefined, undefined];
+    const [moduleName, methodName] = resolver.getMethodNameFromId(methodId) ?? [
+      undefined,
+      undefined,
+    ];
 
-      expect(moduleName).toBe(givenModuleName);
-      expect(methodName).toBe(givenMethodName);
-    }
-  );
+    expect(moduleName).toBe(givenModuleName);
+    expect(methodName).toBe(givenMethodName);
+  });
 
   it("should fail for invalid module name", () => {
     expect.assertions(1);

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