@proto-kit/module 0.1.1-develop.1086

package/dist/runtime/RuntimeModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeModule.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,0BAA0B,EAE3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAM1D,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC;AAE7D,KAAK,aAAa,CAAC,CAAC,SAAS,oBAAoB,CAAC,GAAG,CAAC,IACpD,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE1C,qBAAa,aAAa,CAAC,MAAM,SAAS,WAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE3C,MAAM,CAAC,GAAG,SAAS,MAAM,MAAM,EACpC,SAAS,EAAE,IAAI,EACf,SAAS,EAAE,GAAG,EACd,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAgB5B,IAAI,CAAC,GAAG,SAAS,MAAM,MAAM,EAClC,SAAS,EAAE,GAAG,EACd,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CAIpC;AAED;;GAEG;AACH,qBACa,aAAa,CACxB,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAClC,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAE7B,MAAM,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAa;;IAYxC,SAAS,IAAI,0BAA0B;IAa9C,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}

package/dist/runtime/RuntimeModule.js

@@ -0,0 +1,79 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ConfigurableModule } from "@proto-kit/common";
+import { container, injectable } from "tsyringe";
+import { RuntimeMethodExecutionContext, RuntimeMethodExecutionDataStruct, } from "@proto-kit/protocol";
+import { Provable, Bool } from "o1js";
+import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
+const errors = {
+    inputDataNotSet: () => new Error("Input data for runtime execution not set"),
+};
+export class RuntimeEvents {
+    constructor(events) {
+        this.events = events;
+    }
+    emitIf(condition, eventName, event) {
+        if (this.events === undefined) {
+            throw new Error("'events' property not defined, make sure to define the event types on your runtimemodule");
+        }
+        const eventType = this.events[eventName];
+        if (typeof eventName !== "string") {
+            throw new Error("Only string");
+        }
+        return container
+            .resolve(RuntimeMethodExecutionContext)
+            .addEvent(eventType, event, eventName, condition);
+    }
+    emit(eventName, event) {
+        this.emitIf(Bool(true), eventName, event);
+    }
+}
+/**
+ * Base class for runtime modules providing the necessary utilities.
+ */
+export let RuntimeModule = class RuntimeModule extends ConfigurableModule {
+    constructor() {
+        super();
+        /**
+         * Holds all method names that are callable throw transactions
+         */
+        this.runtimeMethodNames = [];
+        /**
+         * This property exists only to typecheck that the RuntimeModule
+         * was extended correctly in e.g. a decorator. We need at least
+         * one non-optional property in this class to make the typechecking work.
+         */
+        this.isRuntimeModule = true;
+        this.events = undefined;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const methodNames = Reflect.getMetadata(runtimeMethodNamesMetadataKey, this);
+        this.runtimeMethodNames = methodNames ?? [];
+    }
+    getInputs() {
+        return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+            const { input } = container.resolve(RuntimeMethodExecutionContext);
+            if (input === undefined) {
+                throw errors.inputDataNotSet();
+            }
+            return input;
+        });
+    }
+    get transaction() {
+        return this.getInputs().transaction;
+    }
+    get network() {
+        return this.getInputs().networkState;
+    }
+};
+RuntimeModule.presets = {};
+RuntimeModule = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], RuntimeModule);

package/dist/state/InMemoryStateService.d.ts

@@ -0,0 +1,15 @@
+import { Field } from "o1js";
+import { SimpleAsyncStateService } from "@proto-kit/protocol";
+/**
+ * Naive implementation of an in-memory variant of the StateService interface
+ */
+export declare class InMemoryStateService implements SimpleAsyncStateService {
+    /**
+     * This mapping container null values if the specific entry has been deleted.
+     * This is used by the CachedState service to keep track of deletions
+     */
+    values: Record<string, Field[] | null>;
+    get(key: Field): Promise<Field[] | undefined>;
+    set(key: Field, value: Field[] | undefined): Promise<void>;
+}
+//# sourceMappingURL=InMemoryStateService.d.ts.map

package/dist/state/InMemoryStateService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryStateService.d.ts","sourceRoot":"","sources":["../../src/state/InMemoryStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;GAEG;AACH,qBAAa,oBAAqB,YAAW,uBAAuB;IAClE;;;OAGG;IACI,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAM;IAEtC,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,SAAS,CAAC;IAI7C,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS;CAOxD"}

package/dist/state/InMemoryStateService.js

@@ -0,0 +1,23 @@
+/**
+ * Naive implementation of an in-memory variant of the StateService interface
+ */
+export class InMemoryStateService {
+    constructor() {
+        /**
+         * This mapping container null values if the specific entry has been deleted.
+         * This is used by the CachedState service to keep track of deletions
+         */
+        this.values = {};
+    }
+    async get(key) {
+        return this.values[key.toString()] ?? undefined;
+    }
+    async set(key, value) {
+        if (value === undefined) {
+            this.values[key.toString()] = null;
+        }
+        else {
+            this.values[key.toString()] = value;
+        }
+    }
+}

package/dist/state/decorator.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export declare function state(): <TargetRuntimeModule extends RuntimeModule<unknown>>(target: TargetRuntimeModule, propertyKey: string) => void;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/state/decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/state/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAgBjE;;;GAGG;AACH,wBAAgB,KAAK,mGAGJ,MAAM,UAmCtB"}

package/dist/state/decorator.js

@@ -0,0 +1,39 @@
+import { Path } from "@proto-kit/protocol";
+const errors = {
+    missingName: (className) => new Error(`Unable to provide a unique identifier for state, ${className} is missing a name. 
+      Did you forget to extend your runtime module with 'extends RuntimeModule'?`),
+    missingRuntime: (className) => new Error(`Unable to provide 'runtime' for state, ${className} is missing a name. 
+      Did you forget to extend your runtime module with 'extends RuntimeModule'?`),
+};
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export function state() {
+    return (target, propertyKey) => {
+        let value;
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            get: function get() {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const self = this;
+                if (self.name === undefined) {
+                    throw errors.missingName(self.constructor.name);
+                }
+                if (!self.runtime) {
+                    throw errors.missingRuntime(self.constructor.name);
+                }
+                const path = Path.fromProperty(self.name, propertyKey);
+                if (value) {
+                    value.path = path;
+                    // TODO: why is this complaining about `any`?
+                    value.stateServiceProvider = self.runtime.stateServiceProvider;
+                }
+                return value;
+            },
+            set: (newValue) => {
+                value = newValue;
+            },
+        });
+    };
+}

package/jest.config.cjs

@@ -0,0 +1 @@
+module.exports = require("../../jest.config.cjs");

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@proto-kit/module",
+  "license": "MIT",
+  "private": false,
+  "version": "0.1.1-develop.1086+eeb4563a",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint ./src ./test",
+    "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
+    "test": "npm run test:file -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
+  },
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "loglevel": "^1.8.1",
+    "reflect-metadata": "^0.1.13"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/lodash": "^4.14.194"
+  },
+  "peerDependencies": {
+    "@proto-kit/common": "*",
+    "@proto-kit/protocol": "*",
+    "o1js": "^1.1.0",
+    "tsyringe": "^4.7.0"
+  },
+  "gitHead": "eeb4563a685b29525358ec7404fa9f0251d258d4"
+}

package/src/factories/MethodIdFactory.ts

@@ -0,0 +1,13 @@
+import { DependencyFactory, DependencyRecord } from "@proto-kit/common";
+
+import { MethodIdResolver } from "../runtime/MethodIdResolver";
+
+export class MethodIdFactory implements DependencyFactory {
+  public dependencies() {
+    return {
+      methodIdResolver: {
+        useClass: MethodIdResolver,
+      },
+    } satisfies DependencyRecord;
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./method/runtimeMethod";
+export * from "./module/decorator";
+export * from "./runtime/RuntimeModule";
+export * from "./runtime/RuntimeEnvironment";
+export * from "./runtime/Runtime";
+export * from "./state/InMemoryStateService";
+export * from "./state/decorator";
+export * from "./method/MethodParameterEncoder";
+export * from "./runtime/MethodIdResolver";
+export * from "./factories/MethodIdFactory";

package/src/method/MethodParameterEncoder.ts

@@ -0,0 +1,252 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import {
+  Field,
+  Proof,
+  Provable,
+  DynamicProof,
+  FlexibleProvablePure,
+} from "o1js";
+import {
+  ArgumentTypes,
+  ProofTypes,
+  ToFieldableStatic,
+  TypedClass,
+  filterNonUndefined,
+} from "@proto-kit/common";
+
+import type { RuntimeModule } from "../runtime/RuntimeModule";
+
+const errors = {
+  fieldLengthNotMatching: (expected: number, actual: number) =>
+    new Error(`Expected ${expected} field elements, got ${actual}`),
+
+  typeNotCompatible: (name: string, error?: string) =>
+    new Error(
+      `Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type.${
+        error !== undefined ? `Caused by: ${error}` : ""
+      }`
+    ),
+};
+
+type ArgumentType =
+  | FlexibleProvablePure<any>
+  | typeof Proof<unknown, unknown>
+  | typeof DynamicProof<unknown, unknown>;
+
+type ArgTypeArray = ArgumentType[];
+
+type ArgArray = ArgumentTypes[];
+
+function isProofType(type: unknown): type is typeof Proof {
+  return (type as unknown as TypedClass<unknown>).prototype instanceof Proof;
+}
+
+function isDynamicProofType(type: unknown): type is typeof DynamicProof {
+  return (
+    (type as unknown as TypedClass<unknown>).prototype instanceof DynamicProof
+  );
+}
+
+function isProofBaseType(
+  type: unknown
+): type is typeof Proof | typeof DynamicProof {
+  return isProofType(type) || isDynamicProofType(type);
+}
+
+function getAllPropertyNamesOfPrototypeChain(type: unknown): string[] {
+  if (type === undefined || type === null) {
+    return [];
+  }
+  return Object.getOwnPropertyNames(type).concat(
+    ...getAllPropertyNamesOfPrototypeChain(Object.getPrototypeOf(type))
+  );
+}
+
+function isFlexibleProvablePure(
+  type: unknown
+): type is FlexibleProvablePure<unknown> {
+  // The required properties are defined on the prototype for Structs and CircuitValues
+  // but on the constructor function itself for Field and Bool
+  // For aliases like Balance in library, it can even be 2 steps upwards the prototype chain
+  const props = getAllPropertyNamesOfPrototypeChain(type);
+  const mandatory = ["toFields", "fromFields", "sizeInFields"];
+  return mandatory.every((prop) => props.includes(prop));
+}
+
+export class MethodParameterEncoder {
+  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const paramtypes: ArgTypeArray = Reflect.getMetadata(
+      "design:paramtypes",
+      target,
+      methodName
+    );
+
+    if (paramtypes === undefined) {
+      throw new Error(
+        `Method with name ${methodName} doesn't exist on this module`
+      );
+    }
+
+    const indizes = paramtypes
+      .map((type, index) => {
+        if (isProofBaseType(type) || isFlexibleProvablePure(type)) {
+          return undefined;
+        }
+        return `${index}`;
+      })
+      .filter(filterNonUndefined);
+    if (indizes.length > 0) {
+      const indexString = indizes.reduce((a, b) => `${a}, ${b}`);
+      throw new Error(
+        `Not all arguments of method '${target.name}.${methodName}' are provable types or proofs (indizes: [${indexString}])`
+      );
+    }
+
+    return new MethodParameterEncoder(paramtypes);
+  }
+
+  public static fieldSize(type: ArgumentType): number | undefined {
+    if (isProofBaseType(type)) {
+      return (
+        (MethodParameterEncoder.fieldSize(type.publicInputType) ?? 0) +
+        (MethodParameterEncoder.fieldSize(type.publicOutputType) ?? 0)
+      );
+    }
+    // as any, since we shouldn't be using this workaround in the first place
+    return (type as FlexibleProvablePure<unknown>).sizeInFields();
+  }
+
+  public constructor(private readonly types: ArgTypeArray) {}
+
+  public decode(fields: Field[], auxiliary: string[]): Promise<ArgArray> {
+    if (fields.length < this.fieldSize()) {
+      throw errors.fieldLengthNotMatching(this.fieldSize(), fields.length);
+    }
+
+    let stack = fields.slice();
+    const auxiliaryStack = auxiliary.slice();
+
+    return Promise.all(
+      this.types.map((type) => {
+        const numberFieldsNeeded = MethodParameterEncoder.fieldSize(type) ?? -1;
+        if (numberFieldsNeeded === -1) {
+          throw errors.typeNotCompatible(type.constructor.name);
+        }
+        const structFields = stack.slice(0, numberFieldsNeeded);
+        stack = stack.slice(numberFieldsNeeded);
+
+        // Decode proof
+        if (isProofBaseType(type)) {
+          const auxiliaryData = auxiliaryStack.shift();
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const proofData: { proof: string; maxProofsVerified: 0 | 1 | 2 } =
+            JSON.parse(auxiliaryData!);
+
+          const inputFieldSize = MethodParameterEncoder.fieldSize(
+            type.publicInputType
+          )!;
+          const input = structFields
+            .slice(0, inputFieldSize)
+            .map((x) => x.toString());
+          const output = structFields
+            .slice(inputFieldSize)
+            .map((x) => x.toString());
+
+          // fromJSON has incompatible signature for Proof and DynamicProof
+          if (isProofType(type)) {
+            return type.fromJSON({
+              ...proofData,
+              publicInput: input,
+              publicOutput: output,
+            });
+          }
+          if (isDynamicProofType(type)) {
+            return type.fromJSON({
+              ...proofData,
+              publicInput: input,
+              publicOutput: output,
+            });
+          }
+        }
+
+        return (type as FlexibleProvablePure<unknown>).fromFields(
+          structFields
+        ) as any;
+      })
+    );
+  }
+
+  /**
+   * Variant of encode() for provable code that skips the unprovable
+   * json encoding
+   */
+  public encode(args: ArgumentTypes) {
+    /**
+     * Use the type info obtained previously to convert
+     * the args passed to fields
+     */
+    return args
+      .map((argument, index) => {
+        if (argument instanceof Proof || argument instanceof DynamicProof) {
+          const argumentType = this.types[index] as ProofTypes;
+
+          const { publicOutputType, publicInputType } = argumentType;
+
+          const inputFields =
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            publicInputType?.toFields(argument.publicInput as any) ?? [];
+
+          const outputFields =
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            publicOutputType?.toFields(argument.publicOutput as any) ?? [];
+
+          let auxiliary = "";
+
+          // Has to be asProver, because this function will be called by runtimeMethod
+          // to transform the args into a Field[] to compute the argsHash
+          // In this case, the auxiliary might be empty, but it isn't used by that method anyways
+          Provable.asProver(() => {
+            const jsonProof = argument.toJSON();
+            auxiliary = JSON.stringify({
+              proof: jsonProof.proof,
+              maxProofsVerified: jsonProof.maxProofsVerified,
+            });
+          });
+
+          return {
+            fields: [...inputFields, ...outputFields],
+            auxiliary,
+          };
+        }
+
+        const argumentType = this.types[index] as ToFieldableStatic;
+        return {
+          fields: argumentType.toFields(argument),
+          auxiliary: undefined,
+        };
+      })
+      .reduce<{
+        fields: Field[];
+        auxiliary: string[];
+      }>(
+        (a, b) => {
+          return {
+            fields: [...a.fields, ...b.fields],
+            auxiliary:
+              b.auxiliary !== undefined
+                ? [...a.auxiliary, b.auxiliary]
+                : a.auxiliary,
+          };
+        },
+        { fields: [], auxiliary: [] }
+      );
+  }
+
+  public fieldSize(): number {
+    return this.types
+      .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
+      .reduce((a, b) => a + b, 0);
+  }
+}
+/* eslint-enable @typescript-eslint/consistent-type-assertions */