@proto-kit/module 0.1.1-develop.211 → 0.1.1-develop.2137

package/dist/state/decorator.js

@@ -11,12 +11,10 @@ const errors = {
  */
 export function state() {
     return (target, propertyKey) => {
-        // eslint-disable-next-line @typescript-eslint/init-declarations
         let value;
         Object.defineProperty(target, propertyKey, {
             enumerable: true,
             get: function get() {
-                // eslint-disable-next-line max-len
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const self = this;
                 if (self.name === undefined) {
@@ -28,9 +26,8 @@ export function state() {
                 const path = Path.fromProperty(self.name, propertyKey);
                 if (value) {
                     value.path = path;
-                    // eslint-disable-next-line no-warning-comments
                     // TODO: why is this complaining about `any`?
-                    value.runtime = self.runtime;
+                    value.stateServiceProvider = self.runtime.stateServiceProvider;
                 }
                 return value;
             },
@@ -40,3 +37,4 @@ export function state() {
         });
     };
 }
+//# sourceMappingURL=decorator.js.map

package/dist/state/decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.js","sourceRoot":"","sources":["../../src/state/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAS,MAAM,qBAAqB,CAAC;AAIlD,MAAM,MAAM,GAAG;IACb,WAAW,EAAE,CAAC,SAAiB,EAAE,EAAE,CACjC,IAAI,KAAK,CACP,oDAAoD,SAAS;iFACc,CAC5E;IAEH,cAAc,EAAE,CAAC,SAAiB,EAAE,EAAE,CACpC,IAAI,KAAK,CACP,0CAA0C,SAAS;iFACwB,CAC5E;CACJ,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,KAAK;IACnB,OAAO,CACL,MAA2B,EAC3B,WAAmB,EACnB,EAAE;QACF,IAAI,KAAiC,CAAC;QAEtC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAEhB,GAAG,EAAE,SAAS,GAAG;gBACf,yEAAyE;gBACzE,MAAM,IAAI,GAAG,IAA2B,CAAC;gBAEzC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;oBAC3B,MAAM,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;iBACjD;gBAED,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;oBACjB,MAAM,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;iBACpD;gBAED,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;gBACvD,IAAI,KAAK,EAAE;oBACT,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;oBAElB,6CAA6C;oBAE7C,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC;iBAChE;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YAED,GAAG,EAAE,CAAC,QAAwB,EAAE,EAAE;gBAChC,KAAK,GAAG,QAAQ,CAAC;YACnB,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}

package/dist/testing/TestingRuntime.d.ts

@@ -0,0 +1,8 @@
+import { ModulesConfig } from "@proto-kit/common";
+import { Runtime, RuntimeModulesRecord } from "../runtime/Runtime";
+import { InMemoryStateService } from "../state/InMemoryStateService";
+export declare function createTestingRuntime<Modules extends RuntimeModulesRecord>(modules: Modules, config: ModulesConfig<Modules>): {
+    runtime: Runtime<Modules>;
+    state: InMemoryStateService;
+};
+//# sourceMappingURL=TestingRuntime.d.ts.map

package/dist/testing/TestingRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestingRuntime.d.ts","sourceRoot":"","sources":["../../src/testing/TestingRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIlD,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAErE,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,oBAAoB,EACvE,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAgCA"}

package/dist/testing/TestingRuntime.js

@@ -0,0 +1,31 @@
+import { StateServiceProvider } from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { Runtime } from "../runtime/Runtime";
+import { InMemoryStateService } from "../state/InMemoryStateService";
+export function createTestingRuntime(modules, config) {
+    const state = new InMemoryStateService();
+    const Runtimeclass = Runtime.from({
+        modules,
+    });
+    const runtime = new Runtimeclass();
+    runtime.configure(config);
+    runtime.create(() => container.createChildContainer());
+    runtime.dependencyContainer.register("AreProofsEnabled", {
+        useValue: {
+            areProofsEnabled: false,
+            setProofsEnabled(areProofsEnabled) {
+                this.areProofsEnabled = areProofsEnabled;
+            },
+        },
+    });
+    runtime.registerValue({
+        StateServiceProvider: new StateServiceProvider(),
+        Runtime: runtime,
+    });
+    runtime.stateServiceProvider.setCurrentStateService(state);
+    return {
+        runtime,
+        state,
+    };
+}
+//# sourceMappingURL=TestingRuntime.js.map

package/dist/testing/TestingRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestingRuntime.js","sourceRoot":"","sources":["../../src/testing/TestingRuntime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,OAAO,EAAwB,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,UAAU,oBAAoB,CAClC,OAAgB,EAChB,MAA8B;IAK9B,MAAM,KAAK,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAEzC,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;QAChC,OAAO;KACR,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,IAAI,YAAY,EAAE,CAAC;IAEnC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAE1B,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAEvD,OAAO,CAAC,mBAAmB,CAAC,QAAQ,CAAC,kBAAkB,EAAE;QACvD,QAAQ,EAAE;YACR,gBAAgB,EAAE,KAAK;YAEvB,gBAAgB,CAAC,gBAAyB;gBACxC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;YAC3C,CAAC;SACF;KACF,CAAC,CAAC;IACH,OAAO,CAAC,aAAa,CAAC;QACpB,oBAAoB,EAAE,IAAI,oBAAoB,EAAE;QAChD,OAAO,EAAE,OAAO;KACjB,CAAC,CAAC;IAEH,OAAO,CAAC,oBAAoB,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAE3D,OAAO;QACL,OAAO;QACP,KAAK;KACN,CAAC;AACJ,CAAC"}

package/jest.config.cjs

@@ -1 +1,12 @@
-module.exports = require("../../jest.config.cjs");
+// @ts-ignore
+const config = require("../../jest.config.cjs");
+
+module.exports = {
+  ...config,
+  collectCoverageFrom: [
+    "packages/module/src/**",
+    "!**/node_modules/**",
+    "!**/dist/**",
+  ],
+  coverageDirectory: "coverage/module",
+};

package/package.json

@@ -2,23 +2,21 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.211+662735c",
+  "version": "0.1.1-develop.2137+8a7eca31",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
     "lint": "eslint ./src ./test",
-    "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
-    "test": "npm run test:file -- ./src/** ./test/**",
-    "test:watch": "npm run test:file -- ./src/** ./test/** --watch"
+    "test:file": "node --experimental-vm-modules --experimental-wasm-modules ../../node_modules/jest/bin/jest.js",
+    "test": "npm run test:file -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
   },
   "main": "dist/index.js",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@proto-kit/common": "*",
-    "@proto-kit/protocol": "*",
     "lodash": "^4.17.21",
     "loglevel": "^1.8.1",
     "reflect-metadata": "^0.1.13"
@@ -28,8 +26,10 @@
     "@types/lodash": "^4.14.194"
   },
   "peerDependencies": {
-    "snarkyjs": "0.12.0",
-    "tsyringe": "^4.7.0"
+    "@proto-kit/common": "*",
+    "@proto-kit/protocol": "*",
+    "o1js": "^2.10.0",
+    "tsyringe": "^4.10.0"
   },
-  "gitHead": "662735cd072170aa01a9f6040e89293a3e3fc8a9"
+  "gitHead": "8a7eca319272a15162dc4ad04bdc134b1017716d"
 }

package/src/factories/MethodIdFactory.ts

@@ -1,22 +1,15 @@
-import {
-  dependency, dependencyFactory,
-  DependencyFactory
-} from "@proto-kit/common";
-import { inject, injectable } from "tsyringe";
+import { DependencyFactory, DependencyRecord } from "@proto-kit/common";
 
 import { MethodIdResolver } from "../runtime/MethodIdResolver";
-import type { Runtime, RuntimeModulesRecord } from "../runtime/Runtime";
 
-@dependencyFactory()
-export class MethodIdFactory extends DependencyFactory {
-  public constructor(
-    @inject("Runtime") private readonly runtime: Runtime<RuntimeModulesRecord>
-  ) {
-    super();
-  }
-
-  @dependency()
-  public methodIdResolver(): MethodIdResolver {
-    return new MethodIdResolver(this.runtime, this.runtime.definition.modules);
+export class MethodIdFactory {
+  public static dependencies() {
+    return {
+      methodIdResolver: {
+        useClass: MethodIdResolver,
+      },
+    } satisfies DependencyRecord;
   }
 }
+
+MethodIdFactory satisfies DependencyFactory;

package/src/index.ts

@@ -1,10 +1,10 @@
-export * from "../../protocol/src/state/assert/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 "@proto-kit/protocol/src/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,124 @@
+import {
+  Field,
+  FlexibleProvablePure,
+  InferProvable,
+  Poseidon,
+  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 };
+    // TODO Salt/prefix
+    const messageType = Poseidon.hash([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,262 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import {
+  Field,
+  Proof,
+  Provable,
+  DynamicProof,
+  FlexibleProvablePure,
+  FlexibleProvable,
+} 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 =
+  | FlexibleProvable<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 FlexibleProvable<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 FlexibleProvable<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 */