Add code to check types

Author: ejMina226

packages/module/src/method/MethodParameterEncoder.ts

@@ -62,7 +62,7 @@ function getAllPropertyNamesOfPrototypeChain(type: unknown): string[] {
   );
 }
 
-function isFlexibleProvablePure(
+export function isFlexibleProvablePure(
   type: unknown
 ): type is FlexibleProvablePure<unknown> {
   // The required properties are defined on the prototype for Structs and CircuitValues
@@ -73,35 +73,43 @@ function isFlexibleProvablePure(
   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
+export function checkArgsProvable(
+  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`
     );
+  }
 
-    if (paramtypes === undefined) {
-      throw new Error(
-        `Method with name ${methodName} doesn't exist on this module`
-      );
-    }
+  const indizes = paramtypes
+    .map((type, index) => {
+      if (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 paramtypes;
+}
 
-    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}])`
-      );
-    }
+export class MethodParameterEncoder {
+  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
+    const paramtypes = checkArgsProvable(target, methodName);
 
     return new MethodParameterEncoder(paramtypes);
   }

packages/module/src/method/runtimeMethod.ts

@@ -13,12 +13,14 @@ import {
   toProver,
   ZkProgrammable,
   ArgumentTypes,
-  TypedClass,
 } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 
-import { MethodParameterEncoder } from "./MethodParameterEncoder";
+import {
+  MethodParameterEncoder,
+  checkArgsProvable,
+} from "./MethodParameterEncoder";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -191,13 +193,6 @@ export function isRuntimeMethod(
 
 export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
 
-function isSubtypeOfName(clas: TypedClass<unknown>, name: string): boolean {
-  if (clas.name === name) {
-    return true;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-  return isSubtypeOfName(Object.getPrototypeOf(clas), name);
-}
 function runtimeMethodInternal(options: {
   invocationType: RuntimeMethodInvocationType;
 }) {
@@ -206,6 +201,7 @@ function runtimeMethodInternal(options: {
     methodName: string,
     descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>
   ) => {
+    checkArgsProvable(target, methodName);
     const executionContext = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext
     );
@@ -238,15 +234,6 @@ function runtimeMethodInternal(options: {
       this: RuntimeModule<unknown>,
       ...args: ArgumentTypes
     ) {
-      args.forEach((arg) => {
-        const argData: any | undefined = Reflect.getMetadata(
-          runtimeMethodNamesMetadataKey,
-          arg
-        );
-        if (isSubtypeOfName(argData, "FlexibleProvablePure")) {
-          throw Error("Argument to method not of type FlexibleProvablePure.");
-        }
-      });
       const constructorName = this.name!;
 
       /**