@proto-kit/module 0.1.1-develop.600 → 0.1.1-develop.833

package/package.json

@@ -2,15 +2,15 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.600+699a7df",
+  "version": "0.1.1-develop.833+397881ed",
   "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 -- ./src/** ./test/**",
-    "test:watch": "npm run test:file -- ./src/** ./test/** --watch"
+    "test": "npm run test:file -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
   },
   "main": "dist/index.js",
   "publishConfig": {
@@ -28,8 +28,8 @@
   "peerDependencies": {
     "@proto-kit/common": "*",
     "@proto-kit/protocol": "*",
-    "o1js": "0.13.1",
+    "o1js": "^1.1.0",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "699a7dfa3b5d3415ab4500f0cd495d6781365c6a"
+  "gitHead": "397881ed5d8f98f5005bcd7be7f5a12b3bc6f956"
 }

package/src/method/MethodParameterEncoder.ts

@@ -1,11 +1,17 @@
-/* eslint-disable no-underscore-dangle */
-import { Field, FlexibleProvable, Proof, ProvableExtended } from "o1js";
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import {
+  Field,
+  Proof,
+  Provable,
+  DynamicProof,
+  FlexibleProvablePure,
+} from "o1js";
 import {
   ArgumentTypes,
   ProofTypes,
-  ToFieldable,
   ToFieldableStatic,
-  ToJSONableStatic,
+  TypedClass,
+  filterNonUndefined,
 } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule";
@@ -22,12 +28,55 @@ const errors = {
     ),
 };
 
-type ArgsArray = ProvableExtended<unknown>[];
+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: ArgsArray = Reflect.getMetadata(
+    const paramtypes: ArgTypeArray = Reflect.getMetadata(
       "design:paramtypes",
       target,
       methodName
@@ -39,103 +88,165 @@ export class MethodParameterEncoder {
       );
     }
 
+    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: ProvableExtended<unknown>): number | undefined {
+  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 any).prototype._fields?.length ?? type.sizeInFields?.();
+    return (type as FlexibleProvablePure<unknown>).sizeInFields();
   }
 
-  private constructor(private readonly types: ArgsArray) {}
-
-  public decode(argsJSON: string[]): FlexibleProvable<unknown>[] {
-    return this.types.map((type, index) => {
-      // eslint-disable-next-line @typescript-eslint/init-declarations
-      let value: FlexibleProvable<unknown>;
-
-      try {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        value = type.fromJSON(
-          JSON.parse(argsJSON[index])
-        ) as FlexibleProvable<unknown>;
-      } catch (e: unknown) {
-        if (e instanceof Error) {
-          throw errors.typeNotCompatible(type.constructor.name, e.message);
-        }
-        throw errors.typeNotCompatible(type.constructor.name);
-      }
-
-      return value;
-    });
-  }
+  public constructor(private readonly types: ArgTypeArray) {}
 
-  public decodeFields(fields: Field[]): ArgumentTypes {
-    if (fields.length < this.fieldSize) {
-      throw errors.fieldLengthNotMatching(this.fieldSize, fields.length);
+  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 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);
-      return type.fromFields(structFields, []) as ToFieldable;
-    });
+    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;
+      })
+    );
   }
 
-  public encode(args: ArgumentTypes): {
-    argsFields: Field[];
-    argsJSON: string[];
-  } {
+  /**
+   * 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
      */
-    const argsFields = args.flatMap((argument, index) => {
-      if (argument instanceof Proof) {
-        const argumentType = this.types[index] as ProofTypes;
-
-        const publicOutputType = argumentType?.publicOutputType;
-
-        const publicInputType = argumentType?.publicInputType;
-
-        const inputFields =
-          publicInputType?.toFields(argument.publicInput) ?? [];
-
-        const outputFields =
-          publicOutputType?.toFields(argument.publicOutput) ?? [];
-
-        return [...inputFields, ...outputFields];
-      }
-
-      const argumentType = this.types[index] as ToFieldableStatic;
-      return argumentType.toFields(argument);
-    });
-
-    const argsJSON = args.map((argument, index) => {
-      if (argument instanceof Proof) {
-        return JSON.stringify(argument.toJSON());
-      }
-
-      const argumentType = this.types[index] as ToJSONableStatic;
-      return JSON.stringify(argumentType.toJSON(argument));
-    });
+    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,
+          };
+        }
 
-    return {
-      argsFields,
-      argsJSON,
-    };
+        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 get fieldSize(): number {
+  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 */

package/src/method/runtimeMethod.ts

@@ -1,34 +1,21 @@
-/* eslint-disable max-statements */
-import {
-  Bool,
-  Field,
-  FlexibleProvable,
-  Poseidon,
-  Proof,
-  ProvableExtended,
-} from "o1js";
+import { Bool, Field, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import {
   StateTransition,
-  DefaultProvableHashList,
   ProvableStateTransition,
   MethodPublicOutput,
   RuntimeMethodExecutionContext,
-  SignedTransaction,
+  StateTransitionReductionList,
 } from "@proto-kit/protocol";
 import {
   DecoratedMethod,
   toProver,
   ZkProgrammable,
-  ToFieldable,
-  ToFieldableStatic,
-  ProofTypes,
   ArgumentTypes,
-  TypedClass,
-  O1JSPrimitive,
 } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+
 import { MethodParameterEncoder } from "./MethodParameterEncoder";
 
 const errors = {
@@ -49,10 +36,9 @@ const errors = {
 };
 
 export function toStateTransitionsHash(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   stateTransitions: StateTransition<any>[]
 ) {
-  const stateTransitionsHashList = new DefaultProvableHashList(
+  const stateTransitionsHashList = new StateTransitionReductionList(
     ProvableStateTransition
   );
 
@@ -66,35 +52,33 @@ export function toStateTransitionsHash(
     .toField();
 }
 
-// eslint-disable-next-line etc/prefer-interface
 export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
+export type AsyncWrappedMethod = (
+  ...args: ArgumentTypes
+) => Promise<MethodPublicOutput>;
 
 export function toWrappedMethod(
   this: RuntimeModule<unknown>,
   methodName: string,
-  moduleMethod: (...args: ArgumentTypes) => unknown,
-  methodArguments: ArgumentTypes,
+  moduleMethod: (...args: ArgumentTypes) => Promise<any>,
   options: {
     invocationType: RuntimeMethodInvocationType;
   }
-) {
+): AsyncWrappedMethod {
   const executionContext = container.resolve<RuntimeMethodExecutionContext>(
     RuntimeMethodExecutionContext
   );
 
-  const wrappedMethod: WrappedMethod = (...args): MethodPublicOutput => {
-    Reflect.apply(moduleMethod, this, args);
+  const wrappedMethod: AsyncWrappedMethod = async (
+    ...args
+  ): Promise<MethodPublicOutput> => {
+    await Reflect.apply(moduleMethod, this, args);
     const {
       result: { stateTransitions, status },
-      input,
     } = executionContext.current();
 
     const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
 
-    if (input === undefined) {
-      throw errors.methodInputsNotProvided();
-    }
-
     const { name, runtime } = this;
 
     if (name === undefined) {
@@ -122,14 +106,13 @@ export function toWrappedMethod(
      * Use the type info obtained previously to convert
      * the args passed to fields
      */
-    const { argsFields } = MethodParameterEncoder.fromMethod(this, methodName).encode(args);
+    const { fields } = MethodParameterEncoder.fromMethod(
+      this,
+      methodName
+    ).encode(args);
 
     // Assert that the argsHash that has been signed matches the given arguments
-    // We can use js-if here, because methodArguments is statically sizes
-    // i.e. the result of the if-statement will be the same for all executions
-    // of this method
-    const argsHash =
-      methodArguments.length > 0 ? Poseidon.hash(argsFields) : Field(0);
+    const argsHash = Poseidon.hash(fields);
 
     transaction.argsHash.assertEquals(
       argsHash,
@@ -189,11 +172,16 @@ export function isRuntimeMethod(
 
 export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
 
-function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocationType }) {
+function runtimeMethodInternal(options: {
+  invocationType: RuntimeMethodInvocationType;
+}) {
   return (
     target: RuntimeModule<unknown>,
     methodName: string,
-    descriptor: PropertyDescriptor
+    descriptor: TypedPropertyDescriptor<
+      // TODO Limit possible parameter types
+      (...args: any[]) => Promise<any>
+    >
   ) => {
     const executionContext = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext
@@ -223,11 +211,11 @@ function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocatio
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const simulatedMethod = descriptor.value as DecoratedMethod;
 
-    descriptor.value = function value(
+    descriptor.value = async function value(
       this: RuntimeModule<unknown>,
       ...args: ArgumentTypes
     ) {
-      const constructorName = this.constructor.name;
+      const constructorName = this.name!;
 
       /**
        * If its a top level method call, wrap it into a wrapped method,
@@ -239,7 +227,6 @@ function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocatio
       const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
         methodName,
         simulatedMethod,
-        args,
         options,
       ]);
 
@@ -248,7 +235,7 @@ function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocatio
        * RuntimeMethodExecutionContext state, meaning it enters and exits
        * the context properly.
        */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
       async function prover(this: ZkProgrammable<any, any>) {
         executionContext.beforeMethod(constructorName, methodName, args);
         const innerProver = toProver(
@@ -257,7 +244,6 @@ function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocatio
           false,
           ...args
         ).bind(this);
-        // eslint-disable-next-line @typescript-eslint/init-declarations
         let result: Awaited<ReturnType<typeof innerProver>>;
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -278,10 +264,9 @@ function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocatio
         executionContext.setProver(prover.bind(this.runtime.zkProgrammable));
       }
 
-      // eslint-disable-next-line @typescript-eslint/init-declarations
       let result: unknown;
       try {
-        result = Reflect.apply(simulatedMethod, this, args);
+        result = await Reflect.apply(simulatedMethod, this, args);
       } finally {
         executionContext.afterMethod();
       }

package/src/runtime/MethodIdResolver.ts

@@ -1,7 +1,13 @@
-import { stringToField } from "@proto-kit/protocol";
+import { filterNonUndefined } from "@proto-kit/common";
+import { stringToField, RuntimeMethodIdMapping } from "@proto-kit/protocol";
 import { Poseidon } from "o1js";
 import { inject, injectable } from "tsyringe";
 
+import {
+  RuntimeMethodInvocationType,
+  runtimeMethodTypeMetadataKey,
+} from "../method/runtimeMethod";
+
 import type { Runtime, RuntimeModulesRecord } from "./Runtime";
 
 /**
@@ -33,6 +39,50 @@ export class MethodIdResolver {
     }, {});
   }
 
+  /**
+   * The purpose of this method is to provide a dictionary where
+   * we can look up properties like methodId and invocationType
+   * for each runtimeMethod using their module name and method name
+   */
+  public methodIdMap(): RuntimeMethodIdMapping {
+    const methodIdResolver =
+      this.runtime.dependencyContainer.resolve<MethodIdResolver>(
+        "MethodIdResolver"
+      );
+
+    const rawMappings = this.runtime.moduleNames.flatMap((moduleName) => {
+      const module = this.runtime.resolve(moduleName);
+      return module.runtimeMethodNames.map((method) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const type = Reflect.getMetadata(
+          runtimeMethodTypeMetadataKey,
+          module,
+          method
+        ) as RuntimeMethodInvocationType | undefined;
+
+        if (type !== undefined) {
+          return {
+            name: `${moduleName}.${method}`,
+            methodId: methodIdResolver.getMethodId(moduleName, method),
+            type,
+          } as const;
+        }
+
+        return undefined;
+      });
+    });
+
+    return rawMappings
+      .filter(filterNonUndefined)
+      .reduce<RuntimeMethodIdMapping>((acc, entry) => {
+        acc[entry.name] = {
+          methodId: entry.methodId,
+          type: entry.type,
+        };
+        return acc;
+      }, {});
+  }
+
   public getMethodNameFromId(methodId: bigint): [string, string] | undefined {
     const methodPath = this.dictionary[methodId.toString()];