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

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

package/src/state/StateMap.ts

@@ -1,69 +0,0 @@
-import type { Field, FlexibleProvablePure } from "snarkyjs";
-import { Path, type Option } from "@proto-kit/protocol";
-import { Mixin } from "ts-mixer";
-
-import { State, WithRuntime, WithPath } from "./State.js";
-
-/**
- * Map-like wrapper for state
- */
-// eslint-disable-next-line new-cap
-export class StateMap<KeyType, ValueType> extends Mixin(WithPath, WithRuntime) {
-  /**
-   * Create a new state map with the given key and value types
-   *
-   * @param keyType - Type to be used as a key
-   * @param valueType - Type to be stored as a value
-   * @returns State map with provided key and value types.
-   */
-  public static from<KeyType, ValueType>(
-    keyType: FlexibleProvablePure<KeyType>,
-    valueType: FlexibleProvablePure<ValueType>
-  ) {
-    return new StateMap<KeyType, ValueType>(keyType, valueType);
-  }
-
-  public constructor(
-    public keyType: FlexibleProvablePure<KeyType>,
-    public valueType: FlexibleProvablePure<ValueType>
-  ) {
-    super();
-  }
-
-  public getPath(key: KeyType): Field {
-    this.hasPathOrFail();
-    return Path.fromKey(this.path, this.keyType, key);
-  }
-
-  /**
-   * Obtains a value for the provided key in the current state map.
-   *
-   * @param key - Key to obtain the state for
-   * @returns Value for the provided key.
-   */
-  public get(key: KeyType): Option<ValueType> {
-    const state = State.from(this.valueType);
-    this.hasPathOrFail();
-    this.hasRuntimeOrFail();
-
-    state.path = this.getPath(key);
-    state.runtime = this.runtime;
-    return state.get();
-  }
-
-  /**
-   * Sets a value for the given key in the current state map.
-   *
-   * @param key - Key to store the value under
-   * @param value - Value to be stored under the given key
-   */
-  public set(key: KeyType, value: ValueType) {
-    const state = State.from(this.valueType);
-    this.hasPathOrFail();
-    this.hasRuntimeOrFail();
-
-    state.path = Path.fromKey(this.path, this.keyType, key);
-    state.runtime = this.runtime;
-    state.set(value);
-  }
-}

package/src/state/StateServiceProvider.ts

@@ -1,24 +0,0 @@
-import { inject, injectable } from "tsyringe";
-
-import { StateService } from "./InMemoryStateService";
-
-@injectable()
-export class StateServiceProvider {
-  private readonly defaultStateService: StateService = this.currentStateService;
-
-  public constructor(
-    @inject("StateService") private currentStateService: StateService
-  ) {}
-
-  public get stateService(): StateService {
-    return this.currentStateService;
-  }
-
-  public setCurrentStateService(service: StateService) {
-    this.currentStateService = service;
-  }
-
-  public resetToDefault() {
-    this.currentStateService = this.defaultStateService;
-  }
-}