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

package/src/method/MethodParameterEncoder.ts

@@ -1,17 +1,17 @@
-/* eslint-disable no-underscore-dangle */
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
 import {
   Field,
-  FlexibleProvable,
   Proof,
   Provable,
-  ProvableExtended,
+  DynamicProof,
+  FlexibleProvablePure,
 } from "o1js";
 import {
   ArgumentTypes,
   ProofTypes,
-  ToFieldable,
   ToFieldableStatic,
-  ToJSONableStatic,
+  TypedClass,
+  filterNonUndefined,
 } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule";
@@ -28,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
@@ -45,106 +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);
-    });
-
-    let argsJSON: string[] = [];
-    Provable.asProver(() => {
-      argsJSON = args.map((argument, index) => {
-        if (argument instanceof Proof) {
-          return JSON.stringify(argument.toJSON());
+    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 ToJSONableStatic;
-        return JSON.stringify(argumentType.toJSON(argument));
-      });
-    });
-
-    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,4 +1,3 @@
-/* eslint-disable max-statements */
 import { Bool, Field, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import {
@@ -6,25 +5,17 @@ import {
   ProvableStateTransition,
   MethodPublicOutput,
   RuntimeMethodExecutionContext,
-  RuntimeMethodExecutionDataStruct,
-  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 { MethodIdResolver } from "../runtime/MethodIdResolver";
-import { state } from "../state/decorator.js";
+
 import { MethodParameterEncoder } from "./MethodParameterEncoder";
 
 const errors = {
@@ -45,7 +36,6 @@ const errors = {
 };
 
 export function toStateTransitionsHash(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   stateTransitions: StateTransition<any>[]
 ) {
   const stateTransitionsHashList = new StateTransitionReductionList(
@@ -62,31 +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,
+  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 },
     } = executionContext.current();
 
     const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
 
-    const input = this.getInputs();
-
     const { name, runtime } = this;
 
     if (name === undefined) {
@@ -114,17 +106,13 @@ export function toWrappedMethod(
      * Use the type info obtained previously to convert
      * the args passed to fields
      */
-    const { argsFields } = MethodParameterEncoder.fromMethod(
+    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 args are statically sized
-    // i.e. the result of the if-statement will be the same for all executions
-    // of this method
-    const argsHash =
-      (args ?? []).length > 0 ? Poseidon.hash(argsFields) : Field(0);
+    const argsHash = Poseidon.hash(fields);
 
     transaction.argsHash.assertEquals(
       argsHash,
@@ -190,7 +178,10 @@ function runtimeMethodInternal(options: {
   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
@@ -220,7 +211,7 @@ function runtimeMethodInternal(options: {
     // 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
     ) {
@@ -244,7 +235,7 @@ function runtimeMethodInternal(options: {
        * 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(
@@ -253,7 +244,6 @@ function runtimeMethodInternal(options: {
           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
@@ -274,10 +264,9 @@ function runtimeMethodInternal(options: {
         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

@@ -53,6 +53,7 @@ export class 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,

package/src/runtime/Runtime.ts

@@ -1,6 +1,5 @@
-// eslint-disable-next-line max-len
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,max-lines */
-import { Experimental } from "o1js";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */
+import { ZkProgram } from "o1js";
 import { DependencyContainer, injectable } from "tsyringe";
 import {
   StringKeyOf,
@@ -16,7 +15,7 @@ import {
 import {
   MethodPublicOutput,
   StateServiceProvider,
-  StateService,
+  SimpleAsyncStateService,
 } from "@proto-kit/protocol";
 
 import {
@@ -24,7 +23,7 @@ import {
   isRuntimeMethod,
   runtimeMethodTypeMetadataKey,
   toWrappedMethod,
-  WrappedMethod,
+  AsyncWrappedMethod,
 } from "../method/runtimeMethod";
 import { MethodIdFactory } from "../factories/MethodIdFactory";
 
@@ -33,14 +32,16 @@ import { MethodIdResolver } from "./MethodIdResolver";
 import { RuntimeEnvironment } from "./RuntimeEnvironment";
 
 export function getAllPropertyNames(obj: any) {
+  let currentPrototype: any | undefined = obj;
   let keys: (string | symbol)[] = [];
   // if primitive (primitives still have keys) skip the first iteration
   if (!(obj instanceof Object)) {
-    obj = Object.getPrototypeOf(obj);
+    currentPrototype = Object.getPrototypeOf(obj);
   }
-  while (obj) {
-    keys = keys.concat(Reflect.ownKeys(obj));
-    obj = Object.getPrototypeOf(obj);
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  while (currentPrototype) {
+    keys = keys.concat(Reflect.ownKeys(currentPrototype));
+    currentPrototype = Object.getPrototypeOf(currentPrototype);
   }
   return keys;
 }
@@ -69,9 +70,8 @@ export interface RuntimeDefinition<Modules extends RuntimeModulesRecord> {
 }
 
 export class RuntimeZkProgrammable<
-  Modules extends RuntimeModulesRecord
+  Modules extends RuntimeModulesRecord,
 > extends ZkProgrammable<undefined, MethodPublicOutput> {
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define
   public constructor(public runtime: Runtime<Modules>) {
     super();
   }
@@ -85,13 +85,13 @@ export class RuntimeZkProgrammable<
       string,
       {
         privateInputs: any;
-        method: WrappedMethod;
+        method: AsyncWrappedMethod;
       }
     >;
     // We need to use explicit type annotations here,
     // therefore we can't use destructuring
-    // eslint-disable-next-line max-len
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define,prefer-destructuring,putout/putout
+
+    // eslint-disable-next-line prefer-destructuring
     const runtime: Runtime<Modules> = this.runtime;
 
     const runtimeMethods = runtime.runtimeModuleNames.reduce<Methods>(
@@ -106,15 +106,15 @@ export class RuntimeZkProgrammable<
          * regarding resolving only known modules. We assert in the line above
          * but we cast it to any anyways to satisfy the proof system.
          */
-        // eslint-disable-next-line max-len
+
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const runtimeModule = runtime.resolve(runtimeModuleName as any);
 
-        // eslint-disable-next-line max-len
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const modulePrototype = Object.getPrototypeOf(runtimeModule) as Record<
           string,
-          (...args: unknown[]) => unknown
+          // Technically not all methods have to be async, but for this context it's ok
+          (...args: unknown[]) => Promise<unknown>
         >;
 
         const modulePrototypeMethods = getAllPropertyNames(runtimeModule).map(
@@ -135,13 +135,12 @@ export class RuntimeZkProgrammable<
                 methodName
               );
 
-              const wrappedMethod = Reflect.apply(
+              const wrappedMethod: AsyncWrappedMethod = Reflect.apply(
                 toWrappedMethod,
                 runtimeModule,
                 [methodName, method, { invocationType }]
               );
 
-              // eslint-disable-next-line no-warning-comments
               // TODO: find out how to import the Tuple type
 
               const privateInputs = Reflect.getMetadata(
@@ -174,16 +173,16 @@ export class RuntimeZkProgrammable<
     );
 
     const sortedRuntimeMethods = Object.fromEntries(
-      // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
       Object.entries(runtimeMethods).sort()
     );
 
-    const program = Experimental.ZkProgram({
+    const program = ZkProgram({
+      name: "RuntimeProgram",
       publicOutput: MethodPublicOutput,
       methods: sortedRuntimeMethods,
     });
 
-    const SelfProof = Experimental.ZkProgram.Proof(program);
+    const SelfProof = ZkProgram.Proof(program);
 
     const methods = Object.keys(sortedRuntimeMethods).reduce<
       Record<string, any>
@@ -222,7 +221,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
   }
 
   // runtime modules composed into a ZkProgram
-  public program?: ReturnType<typeof Experimental.ZkProgram>;
+  public program?: ReturnType<typeof ZkProgram>;
 
   public definition: RuntimeDefinition<Modules>;
 
@@ -239,7 +238,6 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     this.zkProgrammable = new RuntimeZkProgrammable<Modules>(this);
   }
 
-  // eslint-disable-next-line no-warning-comments
   // TODO Remove after changing DFs to type-based approach
   public create(childContainerProvider: ChildContainerProvider) {
     super.create(childContainerProvider);
@@ -257,7 +255,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     );
   }
 
-  public get stateService(): StateService {
+  public get stateService(): SimpleAsyncStateService {
     return this.stateServiceProvider.stateService;
   }
 
@@ -278,7 +276,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
    */
   public getMethodById(
     methodId: bigint
-  ): ((...args: unknown[]) => unknown) | undefined {
+  ): ((...args: unknown[]) => Promise<unknown>) | undefined {
     const methodDescriptor =
       this.methodIdResolver.getMethodNameFromId(methodId);
 
@@ -290,15 +288,14 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     this.assertIsValidModuleName(moduleName);
     const module = this.resolve(moduleName);
 
-    // eslint-disable-next-line max-len
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,@typescript-eslint/no-unsafe-member-access
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const method = (module as any)[methodName];
     if (method === undefined) {
       throw errors.methodNotFound(`${moduleName}.${methodName}`);
     }
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (method as (...args: unknown[]) => unknown).bind(module);
+    return (method as (...args: unknown[]) => Promise<unknown>).bind(module);
   }
 
   /**
@@ -325,3 +322,4 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     return Object.keys(this.definition.modules);
   }
 }
+/* eslint-enable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */