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

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -5,6 +5,6 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";

package/dist/method/MethodParameterEncoder.d.ts

@@ -0,0 +1,17 @@
+import { Field, FlexibleProvable, ProvableExtended } from "o1js";
+import { ArgumentTypes } from "@proto-kit/common";
+import type { RuntimeModule } from "../runtime/RuntimeModule";
+export declare class MethodParameterEncoder {
+    private readonly types;
+    static fromMethod(target: RuntimeModule<unknown>, methodName: string): MethodParameterEncoder;
+    static fieldSize(type: ProvableExtended<unknown>): number | undefined;
+    private constructor();
+    decode(argsJSON: string[]): FlexibleProvable<unknown>[];
+    decodeFields(fields: Field[]): ArgumentTypes;
+    encode(args: ArgumentTypes): {
+        argsFields: Field[];
+        argsJSON: string[];
+    };
+    get fieldSize(): number;
+}
+//# sourceMappingURL=MethodParameterEncoder.d.ts.map

package/dist/method/MethodParameterEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodParameterEncoder.d.ts","sourceRoot":"","sources":["../../src/method/MethodParameterEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAS,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACxE,OAAO,EACL,aAAa,EAKd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAgB9D,qBAAa,sBAAsB;IAuBb,OAAO,CAAC,QAAQ,CAAC,KAAK;WAtB5B,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,MAAM;WAiB7D,SAAS,CAAC,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS;IAK5E,OAAO;IAEA,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAsBvD,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,aAAa;IAkB5C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG;QAClC,UAAU,EAAE,KAAK,EAAE,CAAC;QACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IAyCD,IAAW,SAAS,IAAI,MAAM,CAI7B;CACF"}

package/dist/method/MethodParameterEncoder.js

@@ -0,0 +1,90 @@
+/* eslint-disable no-underscore-dangle */
+import { Proof } from "o1js";
+const errors = {
+    fieldLengthNotMatching: (expected, actual) => new Error(`Expected ${expected} field elements, got ${actual}`),
+    typeNotCompatible: (name, error) => new Error(`Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type.${error !== undefined ? `Caused by: ${error}` : ""}`),
+};
+export class MethodParameterEncoder {
+    static fromMethod(target, methodName) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const paramtypes = Reflect.getMetadata("design:paramtypes", target, methodName);
+        if (paramtypes === undefined) {
+            throw new Error(`Method with name ${methodName} doesn't exist on this module`);
+        }
+        return new MethodParameterEncoder(paramtypes);
+    }
+    static fieldSize(type) {
+        // as any, since we shouldn't be using this workaround in the first place
+        return type.prototype._fields?.length ?? type.sizeInFields?.();
+    }
+    constructor(types) {
+        this.types = types;
+    }
+    decode(argsJSON) {
+        return this.types.map((type, index) => {
+            // eslint-disable-next-line @typescript-eslint/init-declarations
+            let value;
+            try {
+                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                value = type.fromJSON(JSON.parse(argsJSON[index]));
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    throw errors.typeNotCompatible(type.constructor.name, e.message);
+                }
+                throw errors.typeNotCompatible(type.constructor.name);
+            }
+            return value;
+        });
+    }
+    decodeFields(fields) {
+        if (fields.length < this.fieldSize) {
+            throw errors.fieldLengthNotMatching(this.fieldSize, fields.length);
+        }
+        let stack = fields.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, []);
+        });
+    }
+    encode(args) {
+        /**
+         * 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];
+                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];
+            return argumentType.toFields(argument);
+        });
+        const argsJSON = args.map((argument, index) => {
+            if (argument instanceof Proof) {
+                return JSON.stringify(argument.toJSON());
+            }
+            const argumentType = this.types[index];
+            return JSON.stringify(argumentType.toJSON(argument));
+        });
+        return {
+            argsFields,
+            argsJSON,
+        };
+    }
+    get fieldSize() {
+        return this.types
+            .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
+            .reduce((a, b) => a + b, 0);
+    }
+}

package/dist/method/runtimeMethod.d.ts

@@ -3,10 +3,13 @@ import { ArgumentTypes } from "@proto-kit/common";
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): import("o1js/dist/node/lib/field.js").Field;
 export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
-export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => unknown, methodArguments: ArgumentTypes): WrappedMethod;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => unknown, methodArguments: ArgumentTypes, options: {
+    invocationType: RuntimeMethodInvocationType;
+}): WrappedMethod;
 export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
 export declare const runtimeMethodMetadataKey = "yab-method";
 export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
+export declare const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-type";
 /**
  * Checks the metadata of the provided runtime module and its method,
  * to see if it has been decorated with @runtimeMethod()
@@ -16,5 +19,7 @@ export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods"
  * @returns - If the provided method name is a runtime method or not
  */
 export declare function isRuntimeMethod(target: RuntimeModule<unknown>, propertyKey: string): boolean;
+export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
+export declare function runtimeMessage(): (target: RuntimeModule<unknown>, methodName: string, descriptor: PropertyDescriptor) => void;
 export declare function runtimeMethod(): (target: RuntimeModule<unknown>, methodName: string, descriptor: PropertyDescriptor) => void;
 //# sourceMappingURL=runtimeMethod.d.ts.map

package/dist/method/runtimeMethod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AASA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAOL,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAoBjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,+CAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,kBAAkB,CAAC;AAE3E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,EACjD,eAAe,EAAE,aAAa,iBAqG/B;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UAwFjC"}
+{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAGnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAOL,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAoBjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,+CAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,kBAAkB,CAAC;AAE3E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,EACjD,eAAe,EAAE,aAAa,EAC9B,OAAO,EAAE;IACP,cAAc,EAAE,2BAA2B,CAAC;CAC7C,iBAiFF;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AACzE,eAAO,MAAM,4BAA4B,kCAAkC,CAAC;AAE5E;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,MAAM,MAAM,2BAA2B,GAAG,WAAW,GAAG,kBAAkB,CAAC;AAwG3E,wBAAgB,cAAc,iGAI7B;AAED,wBAAgB,aAAa,iGAI5B"}

package/dist/method/runtimeMethod.js

@@ -1,8 +1,9 @@
 /* eslint-disable max-statements */
-import { Field, Poseidon, Proof, } from "o1js";
+import { Bool, Field, Poseidon, } from "o1js";
 import { container } from "tsyringe";
 import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, } from "@proto-kit/protocol";
 import { toProver, } from "@proto-kit/common";
+import { MethodParameterEncoder } from "./MethodParameterEncoder";
 const errors = {
     runtimeNotProvided: (name) => new Error(`Runtime was not provided for module: ${name}`),
     methodInputsNotProvided: () => new Error("Method execution inputs not provided, provide them via context.inputs"),
@@ -18,7 +19,7 @@ stateTransitions) {
         .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
         .toField();
 }
-export function toWrappedMethod(methodName, moduleMethod, methodArguments) {
+export function toWrappedMethod(methodName, moduleMethod, methodArguments, options) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const wrappedMethod = (...args) => {
         Reflect.apply(moduleMethod, this, args);
@@ -34,47 +35,35 @@ export function toWrappedMethod(methodName, moduleMethod, methodArguments) {
         if (runtime === undefined) {
             throw errors.runtimeNotProvided(name);
         }
-        // Assert that the given transaction has the correct methodId
+        const { transaction, networkState } = executionContext.witnessInput();
         const { methodIdResolver } = runtime;
+        // Assert that the given transaction has the correct methodId
         const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
         if (!thisMethodId.isConstant()) {
             throw errors.fieldNotConstant("methodId");
         }
-        input.transaction.methodId.assertEquals(thisMethodId, "Runtimemethod called with wrong methodId on the transaction object");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const parameterTypes = Reflect.getMetadata("design:paramtypes", this, methodName);
+        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 argsFields = args.flatMap((argument, index) => {
-            if (argument instanceof Proof) {
-                // eslint-disable-next-line max-len
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const argumentType = parameterTypes[index];
-                const publicOutputType = argumentType?.publicOutputType;
-                const publicInputType = argumentType?.publicInputType;
-                const inputFields = publicInputType?.toFields(argument.publicInput) ?? [];
-                const outputFields = publicOutputType?.toFields(argument.publicOutput) ?? [];
-                return [...inputFields, ...outputFields];
-            }
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const argumentType = parameterTypes[index];
-            return argumentType.toFields(argument);
-        });
+        const { argsFields } = 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);
-        input.transaction.argsHash.assertEquals(argsHash, "argsHash and therefore arguments of transaction and runtime call does not match");
-        const transactionHash = input.transaction.hash();
-        const networkStateHash = input.networkState.hash();
+        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,
         });
     };
     Object.defineProperty(wrappedMethod, "name", {
@@ -88,6 +77,7 @@ export function combineMethodName(runtimeModuleName, methodName) {
 }
 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,
  * to see if it has been decorated with @runtimeMethod()
@@ -99,7 +89,7 @@ export const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
 export function isRuntimeMethod(target, propertyKey) {
     return Boolean(Reflect.getMetadata(runtimeMethodMetadataKey, target, propertyKey));
 }
-export function runtimeMethod() {
+function runtimeMethodInternal(options) {
     return (target, methodName, descriptor) => {
         const executionContext = container.resolve(RuntimeMethodExecutionContext);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -112,6 +102,7 @@ export function runtimeMethod() {
         }
         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;
         descriptor.value = function value(...args) {
@@ -127,6 +118,7 @@ export function runtimeMethod() {
                 methodName,
                 simulatedMethod,
                 args,
+                options,
             ]);
             /**
              * Before the prover runs, make sure it is operating on the correct
@@ -167,3 +159,13 @@ export function runtimeMethod() {
         };
     };
 }
+export function runtimeMessage() {
+    return runtimeMethodInternal({
+        invocationType: "INCOMING_MESSAGE",
+    });
+}
+export function runtimeMethod() {
+    return runtimeMethodInternal({
+        invocationType: "SIGNATURE",
+    });
+}

package/dist/runtime/MethodIdResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D;;;GAGG;AACH,qBACa,gBAAgB;IAMN,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEpB;gBAG+B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAoBrE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAiBnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAWnE"}
+{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D;;;GAGG;AACH,qBACa,gBAAgB;IAMN,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEpB;gBAG+B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAkBrE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAcnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAQnE"}

package/dist/runtime/MethodIdResolver.js

@@ -21,9 +21,8 @@ let MethodIdResolver = class MethodIdResolver {
     constructor(runtime) {
         this.runtime = runtime;
         this.dictionary = {};
-        const { modules } = runtime.definition;
         this.dictionary = runtime.runtimeModuleNames.reduce((dict, moduleName) => {
-            this.runtime.assertIsValidModuleName(modules, moduleName);
+            this.runtime.assertIsValidModuleName(moduleName);
             runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
                 dict[this.getMethodId(moduleName, methodName).toString()] = {
                     moduleName,
@@ -39,11 +38,11 @@ let MethodIdResolver = class MethodIdResolver {
             return undefined;
         }
         const { moduleName, methodName } = methodPath;
-        this.runtime.assertIsValidModuleName(this.runtime.definition.modules, moduleName);
+        this.runtime.assertIsValidModuleName(moduleName);
         return [moduleName, methodName];
     }
     getMethodId(moduleName, methodName) {
-        this.runtime.assertIsValidModuleName(this.runtime.definition.modules, moduleName);
+        this.runtime.assertIsValidModuleName(moduleName);
         return Poseidon.hash([
             stringToField(moduleName),
             stringToField(methodName),

package/dist/runtime/Runtime.js

@@ -147,7 +147,7 @@ let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
             return undefined;
         }
         const [moduleName, methodName] = methodDescriptor;
-        this.assertIsValidModuleName(this.definition.modules, moduleName);
+        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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.456+bdb345d",
+  "version": "0.1.1-develop.600+699a7df",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -31,5 +31,5 @@
     "o1js": "0.13.1",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "bdb345d9e6132387a870c8a4236d8fe295502ce4"
+  "gitHead": "699a7dfa3b5d3415ab4500f0cd495d6781365c6a"
 }

package/src/index.ts

@@ -5,6 +5,6 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";

package/src/method/MethodParameterEncoder.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-underscore-dangle */
+import { Field, FlexibleProvable, Proof, ProvableExtended } from "o1js";
+import {
+  ArgumentTypes,
+  ProofTypes,
+  ToFieldable,
+  ToFieldableStatic,
+  ToJSONableStatic,
+} 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 ArgsArray = ProvableExtended<unknown>[];
+
+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(
+      "design:paramtypes",
+      target,
+      methodName
+    );
+
+    if (paramtypes === undefined) {
+      throw new Error(
+        `Method with name ${methodName} doesn't exist on this module`
+      );
+    }
+
+    return new MethodParameterEncoder(paramtypes);
+  }
+
+  public static fieldSize(type: ProvableExtended<unknown>): number | undefined {
+    // as any, since we shouldn't be using this workaround in the first place
+    return (type as any).prototype._fields?.length ?? type.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 decodeFields(fields: Field[]): ArgumentTypes {
+    if (fields.length < this.fieldSize) {
+      throw errors.fieldLengthNotMatching(this.fieldSize, fields.length);
+    }
+
+    let stack = fields.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;
+    });
+  }
+
+  public encode(args: ArgumentTypes): {
+    argsFields: Field[];
+    argsJSON: string[];
+  } {
+    /**
+     * 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 {
+      argsFields,
+      argsJSON,
+    };
+  }
+
+  public get fieldSize(): number {
+    return this.types
+      .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
+      .reduce((a, b) => a + b, 0);
+  }
+}

package/src/method/runtimeMethod.ts

@@ -1,5 +1,6 @@
 /* eslint-disable max-statements */
 import {
+  Bool,
   Field,
   FlexibleProvable,
   Poseidon,
@@ -13,6 +14,7 @@ import {
   ProvableStateTransition,
   MethodPublicOutput,
   RuntimeMethodExecutionContext,
+  SignedTransaction,
 } from "@proto-kit/protocol";
 import {
   DecoratedMethod,
@@ -27,7 +29,7 @@ import {
 } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
-import { MethodIdResolver } from "../runtime/MethodIdResolver";
+import { MethodParameterEncoder } from "./MethodParameterEncoder";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -71,7 +73,10 @@ export function toWrappedMethod(
   this: RuntimeModule<unknown>,
   methodName: string,
   moduleMethod: (...args: ArgumentTypes) => unknown,
-  methodArguments: ArgumentTypes
+  methodArguments: ArgumentTypes,
+  options: {
+    invocationType: RuntimeMethodInvocationType;
+  }
 ) {
   const executionContext = container.resolve<RuntimeMethodExecutionContext>(
     RuntimeMethodExecutionContext
@@ -99,49 +104,25 @@ export function toWrappedMethod(
       throw errors.runtimeNotProvided(name);
     }
 
-    // Assert that the given transaction has the correct methodId
+    const { transaction, networkState } = executionContext.witnessInput();
     const { methodIdResolver } = runtime;
+
+    // Assert that the given transaction has the correct methodId
     const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
     if (!thisMethodId.isConstant()) {
       throw errors.fieldNotConstant("methodId");
     }
 
-    input.transaction.methodId.assertEquals(
+    transaction.methodId.assertEquals(
       thisMethodId,
       "Runtimemethod called with wrong methodId on the transaction object"
     );
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const parameterTypes: ProofTypes[] | ToFieldableStatic[] =
-      Reflect.getMetadata("design:paramtypes", this, methodName);
-
     /**
      * Use the type info obtained previously to convert
      * the args passed to fields
      */
-    const argsFields = args.flatMap((argument, index) => {
-      if (argument instanceof Proof) {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const argumentType = parameterTypes[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];
-      }
-
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const argumentType = parameterTypes[index] as ToFieldableStatic;
-      return argumentType.toFields(argument);
-    });
+    const { argsFields } = 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
@@ -150,19 +131,23 @@ export function toWrappedMethod(
     const argsHash =
       methodArguments.length > 0 ? Poseidon.hash(argsFields) : Field(0);
 
-    input.transaction.argsHash.assertEquals(
+    transaction.argsHash.assertEquals(
       argsHash,
       "argsHash and therefore arguments of transaction and runtime call does not match"
     );
 
-    const transactionHash = input.transaction.hash();
-    const networkStateHash = input.networkState.hash();
+    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,
     });
   };
 
@@ -183,6 +168,7 @@ 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,
@@ -201,7 +187,9 @@ export function isRuntimeMethod(
   );
 }
 
-export function runtimeMethod() {
+export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
+
+function runtimeMethodInternal(options: { invocationType: RuntimeMethodInvocationType }) {
   return (
     target: RuntimeModule<unknown>,
     methodName: string,
@@ -225,6 +213,13 @@ export function runtimeMethod() {
 
     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;
 
@@ -245,6 +240,7 @@ export function runtimeMethod() {
         methodName,
         simulatedMethod,
         args,
+        options,
       ]);
 
       /**
@@ -294,3 +290,15 @@ export function runtimeMethod() {
     };
   };
 }
+
+export function runtimeMessage() {
+  return runtimeMethodInternal({
+    invocationType: "INCOMING_MESSAGE",
+  });
+}
+
+export function runtimeMethod() {
+  return runtimeMethodInternal({
+    invocationType: "SIGNATURE",
+  });
+}

package/src/runtime/MethodIdResolver.ts

@@ -17,12 +17,10 @@ export class MethodIdResolver {
   public constructor(
     @inject("Runtime") private readonly runtime: Runtime<RuntimeModulesRecord>
   ) {
-    const { modules } = runtime.definition;
-
     this.dictionary = runtime.runtimeModuleNames.reduce<
       Record<string, { moduleName: string; methodName: string }>
     >((dict, moduleName) => {
-      this.runtime.assertIsValidModuleName(modules, moduleName);
+      this.runtime.assertIsValidModuleName(moduleName);
 
       runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
         dict[this.getMethodId(moduleName, methodName).toString()] = {
@@ -44,19 +42,13 @@ export class MethodIdResolver {
 
     const { moduleName, methodName } = methodPath;
 
-    this.runtime.assertIsValidModuleName(
-      this.runtime.definition.modules,
-      moduleName
-    );
+    this.runtime.assertIsValidModuleName(moduleName);
 
     return [moduleName, methodName];
   }
 
   public getMethodId(moduleName: string, methodName: string): bigint {
-    this.runtime.assertIsValidModuleName(
-      this.runtime.definition.modules,
-      moduleName
-    );
+    this.runtime.assertIsValidModuleName(moduleName);
 
     return Poseidon.hash([
       stringToField(moduleName),

package/src/runtime/Runtime.ts

@@ -266,7 +266,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     }
     const [moduleName, methodName] = methodDescriptor;
 
-    this.assertIsValidModuleName(this.definition.modules, moduleName);
+    this.assertIsValidModuleName(moduleName);
     const module = this.resolve(moduleName);
 
     // eslint-disable-next-line max-len

package/test/runtimeMethod.test.ts

@@ -9,7 +9,7 @@ import { container } from "tsyringe";
 import { AreProofsEnabled, log } from "@proto-kit/common";
 
 import { InMemoryStateService, MethodIdResolver, Runtime } from "../src";
-import { MethodParameterDecoder } from "../src/method/MethodParameterDecoder";
+import { MethodParameterEncoder } from "../src/method/MethodParameterEncoder";
 
 import { Balances } from "./modules/Balances";
 
@@ -42,7 +42,7 @@ describe("runtimeMethod", () => {
 
     const module = runtime.resolve("Balances");
 
-    const decoder = MethodParameterDecoder.fromMethod(module, "getBalance");
+    const decoder = MethodParameterEncoder.fromMethod(module, "getBalance");
     const recodedParameters = decoder.fromFields(
       parameters.flatMap((x) => x.toFields())
     );

package/src/method/MethodParameterDecoder.ts

@@ -1,62 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-import { FlexibleProvable, ProvableExtended } from "o1js";
-
-import { RuntimeModule } from "../runtime/RuntimeModule";
-
-const errors = {
-  typeNotCompatible: (name: string) =>
-    new Error(
-      `Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type`
-    ),
-};
-
-export class MethodParameterDecoder {
-  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const paramtypes: ProvableExtended<unknown>[] = Reflect.getMetadata(
-      "design:paramtypes",
-      target,
-      methodName
-    );
-
-    if (paramtypes === undefined) {
-      throw new Error(
-        `Method with name ${methodName} doesn't exist on this module`
-      );
-    }
-
-    return new MethodParameterDecoder(paramtypes);
-  }
-
-  public static fieldSize(type: ProvableExtended<unknown>): number | undefined {
-    // as any, since we shouldn't be using this workaround in the first place
-    return (type as any).prototype._fields?.length ?? type.sizeInFields?.();
-  }
-
-  private constructor(private readonly types: ProvableExtended<unknown>[]) {}
-
-  public fromJSON(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 {
-        throw errors.typeNotCompatible(type.constructor.name);
-      }
-
-      return value;
-    });
-  }
-
-  public get fieldSize(): number {
-    return this.types
-      .map((type) => MethodParameterDecoder.fieldSize(type) ?? 0)
-      .reduce((a, b) => a + b, 0);
-  }
-}