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

package/src/index.ts

@@ -1,12 +1,10 @@
-export * from "./method/RuntimeMethodExecutionContext";
-export * from "./method/assert";
 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/State";
-export * from "./state/StateMap";
-export * from "./state/StateServiceProvider";
-export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
+export * from "./runtime/MethodIdResolver";
+export * from "./factories/MethodIdFactory";
+export * from "./messages/OutgoingMessages";

package/src/messages/OutgoingMessages.ts

@@ -0,0 +1,122 @@
+import {
+  Field,
+  FlexibleProvablePure,
+  InferProvable,
+  Struct,
+  TokenId,
+} from "o1js";
+import {
+  OutgoingMessageEvent,
+  OutgoingMessageKeyStruct,
+  PROTOKIT_FIELD_PREFIXES,
+  RuntimeMethodExecutionContext,
+  state as stateDecorator,
+  StateMap,
+  WithPath,
+  WithStateServiceProvider,
+} from "@proto-kit/protocol";
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Mixin } from "ts-mixer";
+import { prefixToField, StringKeyOf } from "@proto-kit/common";
+import { container } from "tsyringe";
+
+export type OutgoingMessagesRecord = Record<string, FlexibleProvablePure<any>>;
+
+export const outgoingMessage = stateDecorator;
+
+export class OutgoingMessages<
+  Messages extends OutgoingMessagesRecord,
+> extends Mixin(WithPath, WithStateServiceProvider) {
+  public readonly eventTypes: Record<
+    string,
+    {
+      messageType: FlexibleProvablePure<{ messageType: Field; value: any }>;
+      eventType: FlexibleProvablePure<{
+        key: OutgoingMessageKeyStruct;
+        value: any;
+        messageType: Field;
+      }>;
+    }
+  >;
+
+  public constructor(private readonly messages: Messages) {
+    super();
+    this.eventTypes = this.computeEventTypes();
+  }
+
+  private counterState() {
+    const state = new StateMap(Field, Field);
+    state.path = PROTOKIT_FIELD_PREFIXES.OUTGOING_MESSAGE_COUNTER_PATH;
+    state.stateServiceProvider = this.stateServiceProvider;
+    return state;
+  }
+
+  public static getEventName(key: string) {
+    return `outgoing-${key}`;
+  }
+
+  public computeEventTypes() {
+    return Object.fromEntries(
+      Object.entries(this.messages).map(([key, type]) => {
+        class OutgoingMessageEventStruct extends Struct({
+          key: OutgoingMessageKeyStruct,
+          value: type,
+          messageType: Field,
+        }) {}
+
+        class OutgoingMessageStruct extends Struct({
+          value: type,
+          messageType: Field,
+        }) {}
+
+        return [
+          OutgoingMessages.getEventName(key),
+          {
+            messageType: OutgoingMessageStruct,
+            eventType: OutgoingMessageEventStruct,
+          },
+        ];
+      })
+    );
+  }
+
+  private emitEvent<Key extends StringKeyOf<Messages>>(
+    eventName: string,
+    value: OutgoingMessageEvent<InferProvable<Messages[Key]>>
+  ) {
+    const outgoingMessageType = this.eventTypes[eventName].eventType;
+
+    return container
+      .resolve(RuntimeMethodExecutionContext)
+      .addEvent<
+        OutgoingMessageEvent<InferProvable<Messages[Key]>>
+      >(outgoingMessageType, value, eventName);
+  }
+
+  public async emitMessage<Key extends StringKeyOf<Messages>>(
+    key: Key,
+    value: InferProvable<Messages[Key]>,
+    tokenId: Field = TokenId.default
+  ) {
+    const eventName = OutgoingMessages.getEventName(key);
+
+    const stateMap = new StateMap(
+      OutgoingMessageKeyStruct,
+      this.eventTypes[eventName].messageType
+    );
+    stateMap.path = PROTOKIT_FIELD_PREFIXES.OUTGOING_MESSAGE_BASE_PATH;
+    stateMap.stateServiceProvider = this.stateServiceProvider;
+
+    const counterState = this.counterState();
+    const counterOption = await counterState.get(tokenId);
+    const counter = counterOption.orElse(Field(0));
+
+    const messageKey = { index: counter, tokenId };
+    const messageType = prefixToField(key);
+
+    await counterState.set(tokenId, counter.add(1));
+    await stateMap.set(messageKey, { messageType, value });
+
+    this.emitEvent(eventName, { key: messageKey, value, messageType });
+  }
+}

package/src/method/MethodParameterEncoder.ts

@@ -0,0 +1,260 @@
+/* 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))
+  );
+}
+
+export 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 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`
+    );
+  }
+
+  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 paramtypes;
+}
+
+export class MethodParameterEncoder {
+  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
+    const paramtypes = checkArgsProvable(target, methodName);
+
+    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 */

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",
+  });
+}