@proto-kit/module 0.1.1-develop.191 → 0.1.1-develop.211

package/src/runtime/Runtime.ts

@@ -13,19 +13,21 @@ import {
   WithZkProgrammable,
   AreProofsEnabled,
 } from "@proto-kit/common";
-import { MethodPublicOutput } from "@proto-kit/protocol";
+import {
+  MethodPublicOutput,
+  StateServiceProvider,
+  StateService,
+} from "@proto-kit/protocol";
 
 import {
   combineMethodName,
   isRuntimeMethod,
   toWrappedMethod,
   WrappedMethod,
-} from "../method/runtimeMethod.js";
-import { StateService } from "../state/InMemoryStateService.js";
-import { StateServiceProvider } from "../state/StateServiceProvider";
+} from "../method/runtimeMethod";
 import { MethodIdFactory } from "../factories/MethodIdFactory";
 
-import { RuntimeModule } from "./RuntimeModule.js";
+import { RuntimeModule } from "./RuntimeModule";
 import { MethodIdResolver } from "./MethodIdResolver";
 
 /**
@@ -47,7 +49,10 @@ const errors = {
  * Definition / required arguments for the Runtime class
  */
 export interface RuntimeDefinition<Modules extends RuntimeModulesRecord> {
-  state: StateService;
+  /**
+   * @deprecated
+   */
+  state?: StateService;
   modules: Modules;
   config?: ModulesConfig<Modules>;
 }
@@ -200,9 +205,8 @@ export class Runtime<Modules extends RuntimeModulesRecord>
 
   public zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput>;
 
-  // eslint-disable-next-line no-warning-comments
-  // TODO DI
   private readonly stateServiceProviderInstance = new StateServiceProvider(
+    // eslint-disable-next-line etc/no-deprecated
     this.definition.state
   );
 
@@ -215,8 +219,6 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     super(definition);
     this.definition = definition;
     this.zkProgrammable = new RuntimeZkProgrammable<Modules>(this);
-
-    // this.registerDependencyFactories([MethodIdFactory]);
   }
 
   // eslint-disable-next-line no-warning-comments

package/src/runtime/RuntimeModule.ts

@@ -1,12 +1,13 @@
 import { ConfigurableModule, Presets } from "@proto-kit/common";
 import { container, injectable } from "tsyringe";
-import { NetworkState, RuntimeTransaction } from "@proto-kit/protocol";
-
 import {
+  NetworkState,
+  RuntimeTransaction,
+  StateService,
   RuntimeMethodExecutionContext,
   RuntimeMethodExecutionData,
-} from "../method/RuntimeMethodExecutionContext";
-import { StateService } from "../state/InMemoryStateService";
+} from "@proto-kit/protocol";
+
 import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 
 import type {

package/src/state/InMemoryStateService.ts

@@ -1,9 +1,5 @@
 import { Field } from "snarkyjs";
-
-export interface StateService {
-  get: (key: Field) => Field[] | undefined;
-  set: (key: Field, value: Field[] | undefined) => void;
-}
+import { StateService } from "@proto-kit/protocol";
 
 /**
  * Naive implementation of a StateService for testing purposes

package/src/state/decorator.ts

@@ -1,9 +1,7 @@
-import { Path } from "@proto-kit/protocol";
+import { Path, State } from "@proto-kit/protocol";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 
-import type { State } from "./State.js";
-
 const errors = {
   missingName: (className: string) =>
     new Error(
@@ -52,7 +50,7 @@ export function state() {
           // eslint-disable-next-line no-warning-comments
           // TODO: why is this complaining about `any`?
 
-          value.runtime = self.runtime;
+          value.stateServiceProvider = self.runtime.stateServiceProvider;
         }
         return value;
       },

package/test/Runtime.test.ts

@@ -1,6 +1,6 @@
 import { Bool } from "snarkyjs";
 
-import { InMemoryStateService, Runtime } from "../src";
+import { InMemoryStateService, MethodIdResolver, Runtime } from "../src";
 
 import { Balances } from "./modules/Balances";
 
@@ -32,7 +32,7 @@ describe("runtime", () => {
     const moduleName = "Balances";
     const methodName = "getTotalSupply";
 
-    const methodId = runtime.methodIdResolver.getMethodId(
+    const methodId = runtime.dependencyContainer.resolve<MethodIdResolver>("MethodIdResolver").getMethodId(
       moduleName,
       methodName
     );

package/test/modules/Admin.ts

@@ -3,7 +3,7 @@ import { PublicKey } from "snarkyjs";
 import { runtimeModule } from "../../src/module/decorator.js";
 import { RuntimeModule } from "../../src/runtime/RuntimeModule.js";
 import { runtimeMethod } from "../../src/method/runtimeMethod.js";
-import { assert } from "../../src/method/assert.js";
+import { assert } from "@proto-kit/protocol";
 
 interface AdminConfig {
   publicKey: string;

package/test/modules/Balances.test.ts

@@ -10,14 +10,17 @@ import {
   UInt64,
 } from "snarkyjs";
 import { container } from "tsyringe";
-import { type ProvableStateTransition, Path } from "@proto-kit/protocol";
+import {
+  type ProvableStateTransition,
+  Path,
+  MethodPublicOutput,
+  StateService, NetworkState, RuntimeTransaction
+} from "@proto-kit/protocol";
 
 import {
   InMemoryStateService,
-  StateService,
 } from "../../src/state/InMemoryStateService.js";
 import {
-  MethodPublicOutput,
   Runtime,
   RuntimeMethodExecutionContext,
 } from "../../src";
@@ -61,13 +64,15 @@ describe("balances", () => {
       },
     });
 
-    runtime.appChain = {
-      areProofsEnabled: false,
+    runtime.dependencyContainer.register("AppChain", {
+      useValue: {
+        areProofsEnabled: false,
 
-      setProofsEnabled(areProofsEnabled) {
-        this.areProofsEnabled = areProofsEnabled;
+        setProofsEnabled(areProofsEnabled: boolean) {
+          this.areProofsEnabled = areProofsEnabled;
+        },
       },
-    };
+    });
 
     runtime.configure({
       Admin: {

package/test/modules/Balances.ts

@@ -2,9 +2,9 @@ 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 "../../../protocol/src/state/State.js";
 import { state } from "../../src/state/decorator.js";
-import { StateMap } from "../../src/state/StateMap.js";
+import { StateMap } from "../../../protocol/src/state/StateMap.js";
 import { RuntimeModule, runtimeMethod, runtimeModule } from "../../src";
 
 import { Admin } from "./Admin.js";
@@ -50,7 +50,11 @@ export class Balances extends RuntimeModule<BalancesConfig> {
   }
 
   @runtimeMethod()
-  public setBalanceIf() {
+  public transientState() {
+    const totalSupply = this.totalSupply.get();
+    this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(100));
 
+    const totalSupply2 = this.totalSupply.get();
+    this.totalSupply.set(totalSupply2.orElse(UInt64.zero).add(100));
   }
 }

package/test/modules/State.test.ts

@@ -0,0 +1,88 @@
+import "reflect-metadata";
+import { Bool, PublicKey, UInt64 } from "snarkyjs";
+import { container } from "tsyringe";
+import { NetworkState, Option, RuntimeTransaction, StateService } from "@proto-kit/protocol";
+
+import {
+  InMemoryStateService,
+  Runtime,
+  RuntimeMethodExecutionContext,
+} from "../../src";
+
+import { Admin } from "./Admin";
+import { Balances } from "./Balances";
+
+describe("transient 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: {
+        Admin,
+        Balances,
+      },
+    });
+
+    runtime.dependencyContainer.register("AppChain", {
+      useValue: {
+        areProofsEnabled: false,
+
+        setProofsEnabled(areProofsEnabled: boolean) {
+          this.areProofsEnabled = areProofsEnabled;
+        },
+      },
+    });
+
+    runtime.configure({
+      Admin: {
+        publicKey: PublicKey.empty().toBase58(),
+      },
+
+      Balances: {
+        test: Bool(true),
+      },
+    });
+
+    balances = runtime.resolve("Balances");
+  }
+
+  beforeEach(() => {
+    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,
+    });
+    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/modules/methodId.test.ts

@@ -56,7 +56,6 @@ describe("methodId", () => {
     ["Admin", "isAdminWithAVeryVeryVeryVeryLongName"],
     ["Balance", "getTotalSupply"],
     ["Balance", "getBalance"],
-    ["Balance", "setBalanceIf"],
   ])(
     "should pass and encode correctly",
     (givenModuleName, givenMethodName) => {

package/test/transaction.test.ts

@@ -11,7 +11,7 @@ import {
 import { runtimeModule } from "../src/module/decorator";
 import { RuntimeModule } from "../src/runtime/RuntimeModule";
 import { state } from "../src/state/decorator";
-import { StateMap } from "../src/state/StateMap";
+import { StateMap } from "@proto-kit/protocol";
 
 interface BalancesConfig {}
 @runtimeModule()

package/src/method/RuntimeMethodExecutionContext.ts

@@ -1,111 +0,0 @@
-import { Bool } from "snarkyjs";
-import { singleton } from "tsyringe";
-import type { StateTransition, NetworkState } from "@proto-kit/protocol";
-import {
-  ProvableMethodExecutionContext,
-  ProvableMethodExecutionResult,
-} from "@proto-kit/common";
-import { RuntimeTransaction } from "@proto-kit/protocol/src/model/transaction/RuntimeTransaction";
-
-const errors = {
-  setupNotCalled: () =>
-    new Error(
-      "Setup has not been called prior to executing a runtime method. Be sure to do that so that the Runtime is setup property for execution"
-    ),
-};
-
-export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public stateTransitions: StateTransition<any>[] = [];
-
-  public status: Bool = Bool(true);
-
-  public statusMessage?: string;
-}
-
-export interface RuntimeMethodExecutionData {
-  transaction: RuntimeTransaction;
-  networkState: NetworkState;
-}
-
-/**
- * Execution context used to wrap runtime module methods,
- * allowing them to post relevant information (such as execution status)
- * into the context without any unnecessary 'prop drilling'.
- */
-@singleton()
-export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
-  public methods: string[] = [];
-
-  public input: RuntimeMethodExecutionData | undefined;
-
-  // The input corresponding to the current result
-  private lastInput: RuntimeMethodExecutionData | undefined;
-
-  public override result = new RuntimeProvableMethodExecutionResult();
-
-  private assertSetupCalled(): asserts this is {
-    input: RuntimeMethodExecutionData;
-  } {
-    if (this.input === undefined) {
-      throw errors.setupNotCalled();
-    }
-  }
-
-  /**
-   * Adds an in-method generated state transition to the current context
-   * @param stateTransition - State transition to add to the context
-   */
-  public addStateTransition<Value>(stateTransition: StateTransition<Value>) {
-    this.assertSetupCalled();
-    this.result.stateTransitions.push(stateTransition);
-  }
-
-  /**
-   * @param message - Status message to acompany the current status
-   */
-  public setStatusMessage(message?: string) {
-    this.assertSetupCalled();
-    this.result.statusMessage ??= message;
-  }
-
-  /**
-   * @param status - Execution status of the current method
-   */
-  public setStatus(status: Bool) {
-    this.assertSetupCalled();
-    this.result.status = status;
-  }
-
-  /**
-   * @param input Input witness data required for a runtime execution
-   */
-  public setup(input: RuntimeMethodExecutionData) {
-    this.input = input;
-  }
-
-  /**
-   * Manually clears/resets the execution context
-   */
-  public clear() {
-    this.result = new RuntimeProvableMethodExecutionResult();
-  }
-
-  public afterMethod() {
-    super.afterMethod();
-    this.lastInput = this.input;
-    this.input = undefined;
-  }
-
-  /**
-   * Had to override current() otherwise it would not infer
-   * the type of result correctly (parent type would be reused)
-   */
-  public current() {
-    return {
-      isFinished: this.isFinished,
-      result: this.result,
-      input: this.lastInput,
-    };
-  }
-}

package/src/method/assert.test.ts

@@ -1,49 +0,0 @@
-import "reflect-metadata";
-
-import { Bool } from "snarkyjs";
-import { container } from "tsyringe";
-
-import { assert } from "./assert.js";
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext.js";
-
-describe("assert", () => {
-  const defaultStatusMessage = "something went wrong";
-  const executionContext = container.resolve(RuntimeMethodExecutionContext);
-
-  beforeEach(() => {
-    executionContext.beforeMethod("testConstructor", "test");
-  });
-
-  afterEach(() => {
-    executionContext.afterMethod();
-  });
-
-  describe.each([
-    [true, undefined],
-    [false, undefined],
-    [false, defaultStatusMessage],
-  ])("status and message propagation", (status, statusMessage) => {
-    it("should propagate the assertion status and message", () => {
-      expect.assertions(2);
-
-      assert(Bool(status), statusMessage);
-
-      const { status: resultStatus, statusMessage: resultStatusMessage } =
-        executionContext.current().result;
-
-      expect(status).toBe(resultStatus.toBoolean());
-      expect(statusMessage).toBe(resultStatusMessage);
-    });
-  });
-
-  it("should keep a false status, once it was already set", () => {
-    expect.assertions(1);
-
-    assert(Bool(false));
-    assert(Bool(true));
-
-    const { status } = executionContext.current().result;
-
-    expect(status.toBoolean()).toBe(false);
-  });
-});

package/src/method/assert.ts

@@ -1,27 +0,0 @@
-import { Bool, Provable } from "snarkyjs";
-import { container } from "tsyringe";
-
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext";
-import { log } from "@proto-kit/common";
-
-/**
- * Maintains an execution status of the current runtime module method,
- * while prioritizing one-time failures. The assertion won't change the
- * execution status if it has previously failed at least once within the
- * same method execution context.
- *
- * @param condition - Result of the assertion made about the execution status
- * @param message - Optional message describing the prior status
- */
-export function assert(condition: Bool, message?: string) {
-  const executionContext = container.resolve(RuntimeMethodExecutionContext);
-  const previousStatus = executionContext.current().result.status;
-  const status = Provable.if(previousStatus, Bool, condition, previousStatus);
-
-  if (!condition.toBoolean()) {
-    log.debug("Assertion failed: ", message);
-    executionContext.setStatusMessage(message);
-  }
-
-  executionContext.setStatus(status);
-}

package/src/state/State.ts

@@ -1,154 +0,0 @@
-/* eslint-disable new-cap */
-
-import { Mixin } from "ts-mixer";
-import { Bool, Field, Provable, type FlexibleProvablePure } from "snarkyjs";
-import { container } from "tsyringe";
-import { Option, StateTransition, type Path } from "@proto-kit/protocol";
-
-import { PartialRuntime } from "../runtime/RuntimeModule.js";
-import { RuntimeMethodExecutionContext } from "../method/RuntimeMethodExecutionContext.js";
-
-export class WithPath {
-  public path?: Field;
-
-  public hasPathOrFail(): asserts this is { path: Path } {
-    if (!this.path) {
-      throw new Error(
-        "Could not find 'path', did you forget to add '@state' to your state property?"
-      );
-    }
-  }
-}
-
-export class WithRuntime {
-  public runtime?: PartialRuntime;
-
-  public hasRuntimeOrFail(): asserts this is {
-    runtime: PartialRuntime;
-  } {
-    if (!this.runtime) {
-      throw new Error(
-        "Could not find 'runtime', did you forget to add '@state' to your state property?"
-      );
-    }
-  }
-}
-
-/**
- * Utilities for runtime module state, such as get/set
- */
-export class State<Value> extends Mixin(WithPath, WithRuntime) {
-  /**
-   * Creates a new state wrapper for the provided value type.
-   *
-   * @param valueType - Type of value to be stored (e.g. UInt64, Struct, ...)
-   * @returns New state for the given value type.
-   */
-  public static from<Value>(valueType: FlexibleProvablePure<Value>) {
-    return new State<Value>(valueType);
-  }
-
-  /**
-   * Computes a dummy value for the given value type.
-   *
-   * @param valueType - Value type to generate the dummy value for
-   * @returns Dummy value for the given value type
-   */
-  public static dummyValue<Value>(
-    valueType: FlexibleProvablePure<Value>
-  ): Value {
-    const length = valueType.sizeInFields();
-    const fields = Array.from({ length }, () => Field(0));
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return valueType.fromFields(fields) as Value;
-  }
-
-  public constructor(public valueType: FlexibleProvablePure<Value>) {
-    super();
-  }
-
-  /**
-   * Provides an in-circuit witness for the current state representation,
-   * and constructs an Option out of it.
-   *
-   * @returns Optional value of the current state
-   */
-  private witnessState() {
-    // get the value from storage, or return a dummy value instead
-    const value = Provable.witness(this.valueType, () => {
-      this.hasRuntimeOrFail();
-      this.hasPathOrFail();
-
-      const fields = this.runtime.stateService.get(this.path);
-      if (fields) {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return this.valueType.fromFields(fields) as Value;
-      }
-
-      return State.dummyValue(this.valueType);
-    });
-
-    // check if the value exists in the storage or not
-    const isSome = Provable.witness(Bool, () => {
-      this.hasRuntimeOrFail();
-      this.hasPathOrFail();
-
-      const fields = this.runtime.stateService.get(this.path);
-
-      return Bool(fields !== undefined);
-    });
-
-    return Option.from(isSome, value, this.valueType);
-  }
-
-  /**
-   * Retrieves the current state and creates a state transition
-   * anchoring the use of the current state value in the circuit.
-   *
-   * @returns Option representation of the current state.
-   */
-  public get(): Option<Value> {
-    const option = this.witnessState();
-
-    this.hasPathOrFail();
-
-    const stateTransition = StateTransition.from(this.path, option);
-
-    container
-      .resolve(RuntimeMethodExecutionContext)
-      .addStateTransition(stateTransition);
-
-    return option;
-  }
-
-  /**
-   * Sets a new state value by creating a state transition from
-   * the current value to the newly set value.
-   *
-   * The newly set value isn't available via state.get(), since the
-   * state transitions are not applied within the same circuit.
-   * You can however store and access your new value in
-   * a separate circuit variable.
-   *
-   * @param value - Value to be set as the current state
-   */
-  public set(value: Value) {
-    // link the transition to the current state
-    const fromOption = this.witnessState();
-    const toOption = Option.from(Bool(true), value, this.valueType);
-
-    this.hasPathOrFail();
-
-    const stateTransition = StateTransition.fromTo(
-      this.path,
-      fromOption,
-      toOption
-    );
-
-    container
-      .resolve(RuntimeMethodExecutionContext)
-      .addStateTransition(stateTransition);
-  }
-}