@proto-kit/module 0.1.1-develop.165 → 0.1.1-develop.1661

package/src/method/runtimeMethod.ts

@@ -1,16 +1,25 @@
-import { Bool, Field, FlexibleProvable, Struct } from "snarkyjs";
+import { Bool, Field, FlexibleProvablePure, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import {
-  StateTransition,
-  DefaultProvableHashList,
   ProvableStateTransition,
   MethodPublicOutput,
+  RuntimeMethodExecutionContext,
+  StateTransitionReductionList,
+  DefaultProvableHashList,
 } from "@proto-kit/protocol";
-import { DecoratedMethod, toProver, ZkProgrammable } from "@proto-kit/common";
+import {
+  DecoratedMethod,
+  toProver,
+  ZkProgrammable,
+  ArgumentTypes,
+} from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext.js";
+import {
+  MethodParameterEncoder,
+  checkArgsProvable,
+} from "./MethodParameterEncoder";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -20,13 +29,19 @@ const errors = {
     new Error(
       "Method execution inputs not provided, provide them via context.inputs"
     ),
+
+  runtimeNameNotSet: () => new Error("Runtime name was not set"),
+
+  fieldNotConstant: (name: string) =>
+    new Error(
+      `In-circuit field ${name} not a constant, this is likely a framework bug`
+    ),
 };
 
 export function toStateTransitionsHash(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  stateTransitions: StateTransition<any>[]
+  stateTransitions: { toProvable: () => ProvableStateTransition }[]
 ) {
-  const stateTransitionsHashList = new DefaultProvableHashList(
+  const stateTransitionsHashList = new StateTransitionReductionList(
     ProvableStateTransition
   );
 
@@ -40,39 +55,102 @@ export function toStateTransitionsHash(
     .toField();
 }
 
-// eslint-disable-next-line etc/prefer-interface
-export type WrappedMethod = (...args: unknown[]) => MethodPublicOutput;
+export function toEventsHash(
+  events: {
+    eventType: FlexibleProvablePure<any>;
+    event: any;
+    eventName: string;
+    condition: Bool;
+  }[]
+) {
+  return events.reduce((acc, event) => {
+    const hashList = new DefaultProvableHashList(event.eventType, acc);
+    hashList.pushIf(event.event, event.condition);
+    return hashList.commitment;
+  }, Field(0));
+}
+
+export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
+export type AsyncWrappedMethod = (
+  ...args: ArgumentTypes
+) => Promise<MethodPublicOutput>;
 
 export function toWrappedMethod(
   this: RuntimeModule<unknown>,
   methodName: string,
-  moduleMethod: (...args: unknown[]) => 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 },
-      input,
+      result: { stateTransitions, status, events },
     } = executionContext.current();
 
     const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+    const eventsHash = toEventsHash(events);
+
+    const { name, parent: runtime } = this;
+
+    if (name === undefined) {
+      throw errors.runtimeNameNotSet();
+    }
+    if (runtime === undefined) {
+      throw errors.runtimeNotProvided(name);
+    }
+
+    const { transaction, networkState } = executionContext.witnessInput();
+    const { methodIdResolver } = runtime;
 
-    if (input === undefined) {
-      throw errors.methodInputsNotProvided();
+    // Assert that the given transaction has the correct methodId
+    const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
+    if (!thisMethodId.isConstant()) {
+      throw errors.fieldNotConstant("methodId");
     }
 
-    const transactionHash = input.transaction.hash();
-    const networkStateHash = input.networkState.hash();
+    transaction.methodId.assertEquals(
+      thisMethodId,
+      "Runtimemethod called with wrong methodId on the transaction object"
+    );
+
+    /**
+     * Use the type info obtained previously to convert
+     * the args passed to fields
+     */
+    const { fields } = MethodParameterEncoder.fromMethod(
+      this,
+      methodName
+    ).encode(args);
+
+    // Assert that the argsHash that has been signed matches the given arguments
+    const argsHash = Poseidon.hash(fields);
+
+    transaction.argsHash.assertEquals(
+      argsHash,
+      "argsHash and therefore arguments of transaction and runtime call does not match"
+    );
+
+    const isMessage = Bool(options.invocationType === "INCOMING_MESSAGE");
+    transaction.assertTransactionType(Bool(isMessage));
+
+    const transactionHash = transaction.hash();
+    const networkStateHash = networkState.hash();
 
     return new MethodPublicOutput({
       stateTransitionsHash,
       status,
       transactionHash,
       networkStateHash,
+      isMessage,
+      eventsHash,
     });
   };
 
@@ -92,6 +170,8 @@ export function combineMethodName(
 }
 
 export const runtimeMethodMetadataKey = "yab-method";
+export const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
+export const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-type";
 
 /**
  * Checks the metadata of the provided runtime module and its method,
@@ -110,26 +190,50 @@ export function isRuntimeMethod(
   );
 }
 
-export function runtimeMethod() {
+export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
+
+function runtimeMethodInternal(options: {
+  invocationType: RuntimeMethodInvocationType;
+}) {
   return (
     target: RuntimeModule<unknown>,
     methodName: string,
-    descriptor: PropertyDescriptor
+    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>
   ) => {
+    checkArgsProvable(target, methodName);
     const executionContext = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext
     );
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    let data: string[] | undefined = Reflect.getMetadata(
+      runtimeMethodNamesMetadataKey,
+      target
+    );
+    if (data !== undefined) {
+      data.push(methodName);
+    } else {
+      data = [methodName];
+    }
+    Reflect.defineMetadata(runtimeMethodNamesMetadataKey, data, target);
+
     Reflect.defineMetadata(runtimeMethodMetadataKey, true, target, methodName);
 
+    Reflect.defineMetadata(
+      runtimeMethodTypeMetadataKey,
+      options.invocationType,
+      target,
+      methodName
+    );
+
     // 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: FlexibleProvable<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,
@@ -141,6 +245,7 @@ export function runtimeMethod() {
       const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
         methodName,
         simulatedMethod,
+        options,
       ]);
 
       /**
@@ -148,7 +253,7 @@ export function runtimeMethod() {
        * 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(
@@ -157,7 +262,6 @@ export function runtimeMethod() {
           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
@@ -172,16 +276,15 @@ export function runtimeMethod() {
       executionContext.beforeMethod(constructorName, methodName, args);
 
       if (executionContext.isTopLevel) {
-        if (!this.runtime) {
+        if (!this.parent) {
           throw errors.runtimeNotProvided(constructorName);
         }
-        executionContext.setProver(prover.bind(this.runtime.zkProgrammable));
+        executionContext.setProver(prover.bind(this.parent.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();
       }
@@ -190,3 +293,15 @@ export function runtimeMethod() {
     };
   };
 }
+
+export function runtimeMessage() {
+  return runtimeMethodInternal({
+    invocationType: "INCOMING_MESSAGE",
+  });
+}
+
+export function runtimeMethod() {
+  return runtimeMethodInternal({
+    invocationType: "SIGNATURE",
+  });
+}

package/src/runtime/MethodIdResolver.ts

@@ -0,0 +1,108 @@
+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";
+
+/**
+ * Please see `getMethodId` to learn more about
+ * methodId encoding
+ */
+@injectable()
+export class MethodIdResolver {
+  private readonly dictionary: {
+    [key: string]: { moduleName: string; methodName: string };
+  } = {};
+
+  public constructor(
+    @inject("Runtime") private readonly runtime: Runtime<RuntimeModulesRecord>
+  ) {
+    this.dictionary = runtime.runtimeModuleNames.reduce<
+      Record<string, { moduleName: string; methodName: string }>
+    >((dict, moduleName) => {
+      this.runtime.assertIsValidModuleName(moduleName);
+
+      runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
+        dict[this.getMethodId(moduleName, methodName).toString()] = {
+          moduleName,
+          methodName,
+        };
+      });
+
+      return dict;
+    }, {});
+  }
+
+  /**
+   * 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()];
+
+    if (methodPath === undefined) {
+      return undefined;
+    }
+
+    const { moduleName, methodName } = methodPath;
+
+    this.runtime.assertIsValidModuleName(moduleName);
+
+    return [moduleName, methodName];
+  }
+
+  public getMethodId(moduleName: string, methodName: string): bigint {
+    this.runtime.assertIsValidModuleName(moduleName);
+
+    return Poseidon.hash([
+      stringToField(moduleName),
+      stringToField(methodName),
+    ]).toBigInt();
+  }
+}