@proto-kit/module 0.1.1-develop.153

package/test/modules/Balances.ts

@@ -0,0 +1,51 @@
+import { Bool, PublicKey, UInt64 } from "snarkyjs";
+import { Option } 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;
+}
+
+@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 getTotalSupply() {
+    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);
+  }
+
+  @runtimeMethod()
+  public getBalance(address: PublicKey): Option<UInt64> {
+    return this.balances.get(address);
+  }
+}

package/test/runtimeMethod.test.ts

@@ -0,0 +1,43 @@
+import "reflect-metadata";
+import { Bool, PublicKey } from "snarkyjs";
+
+import { InMemoryStateService, Runtime } from "../src";
+import { MethodParameterDecoder } from "../src/method/MethodParameterDecoder";
+
+import { Balances } from "./modules/Balances";
+
+describe("runtimeMethod", () => {
+  const parameters = [PublicKey.empty()];
+
+  it("should create correct param types", () => {
+    // eslint-disable-next-line jest/prefer-expect-assertions
+    expect.assertions(1 + parameters.length);
+
+    const runtime = Runtime.from({
+      state: new InMemoryStateService(),
+
+      modules: {
+        Balances,
+      },
+
+      config: {
+        Balances: {
+          test: Bool(true),
+        },
+      },
+    });
+
+    const module = runtime.resolve("Balances");
+
+    const decoder = MethodParameterDecoder.fromMethod(module, "getBalance");
+    const recodedParameters = decoder.fromFields(
+      parameters.flatMap((x) => x.toFields())
+    );
+
+    expect(parameters).toHaveLength(recodedParameters.length);
+
+    parameters.forEach((parameter, index) => {
+      expect(parameter).toStrictEqual(recodedParameters[index]);
+    });
+  });
+});

package/test/transaction.test.ts

@@ -0,0 +1,82 @@
+import "reflect-metadata";
+import { PrivateKey, Proof, PublicKey, UInt64 } from "snarkyjs";
+import { container } from "tsyringe";
+import {
+  InMemoryStateService,
+  MethodPublicOutput,
+  Runtime,
+  runtimeMethod,
+  RuntimeMethodExecutionContext,
+} from "../src";
+import { runtimeModule } from "../src/module/decorator";
+import { RuntimeModule } from "../src/runtime/RuntimeModule";
+import { state } from "../src/state/decorator";
+import { StateMap } from "../src/state/StateMap";
+
+interface BalancesConfig {}
+@runtimeModule()
+class Balances extends RuntimeModule<BalancesConfig> {
+  @state() public balances = StateMap.from<PublicKey, UInt64>(
+    PublicKey,
+    UInt64
+  );
+
+  @runtimeMethod()
+  public setBalance(to: PublicKey, amount: UInt64) {
+    this.balances.set(to, amount);
+  }
+
+  @runtimeMethod()
+  public transfer(from: PublicKey, to: PublicKey, amount: UInt64) {
+    const fromBalance = this.balances.get(from);
+    const toBalance = this.balances.get(to);
+
+    this.balances.set(from, fromBalance.value.sub(amount));
+    this.balances.set(to, toBalance.value.add(amount));
+  }
+}
+
+describe("transaction", () => {
+  it("should update the state", async () => {
+    expect.assertions(0);
+
+    const runtime = Runtime.from({
+      modules: {
+        Balances,
+      },
+
+      config: {
+        Balances: {},
+      },
+
+      state: new InMemoryStateService(),
+    });
+
+    const alice = PrivateKey.random().toPublicKey();
+    const bob = PrivateKey.random().toPublicKey();
+
+    const balances = runtime.resolve("Balances");
+
+    runtime.transaction(() => {
+      balances.setBalance(alice, UInt64.from(1000));
+    });
+
+    runtime.transaction(() => {
+      balances.transfer(alice, bob, UInt64.from(100));
+    });
+
+    const executionContext = container.resolve<RuntimeMethodExecutionContext>(
+      RuntimeMethodExecutionContext
+    );
+
+    const balanceAlice = balances.balances.get(alice);
+    const balanceBob = balances.balances.get(bob);
+
+    console.log("balances", {
+      // 900
+      alice: balanceAlice.value.toString(),
+      // 100
+      bob: balanceBob.value.toString(),
+    });
+  });
+});

package/tsconfig.json

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

package/tsconfig.test.json

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