@proto-kit/protocol 0.1.1-develop.600 → 0.1.1-develop.833

package/{src → test}/state/assert/assert.test.ts

@@ -3,10 +3,10 @@ import "reflect-metadata";
 import { Bool } from "o1js";
 import { container } from "tsyringe";
 
-import { assert } from "./assert";
-import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
-import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
-import { NetworkState } from "../../model/network/NetworkState";
+import { assert } from "../../../src/state/assert/assert";
+import { RuntimeMethodExecutionContext } from "../../../src/state/context/RuntimeMethodExecutionContext";
+import { RuntimeTransaction } from "../../../src/model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../../src/model/network/NetworkState";
 
 describe("assert", () => {
   const defaultStatusMessage = "something went wrong";

package/test/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./../../../tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true
+  },
+  "include": ["../src/**/*.test.ts", "./**/*.ts", "./*.ts", "../src/**/*.ts"]
+}

package/test/utils/ProvableReductionHashList.test.ts

@@ -0,0 +1,117 @@
+import "reflect-metadata";
+import { Bool, Field, Poseidon } from "o1js";
+
+import {
+  StateTransitionReductionList,
+  reduceStateTransitions,
+} from "../../src/utils/StateTransitionReductionList";
+import {
+  DefaultProvableHashList,
+  ProvableStateTransition,
+  StateTransition,
+  Option,
+} from "../../src";
+
+interface UnprovableStateTransition {
+  path: number;
+  from: number;
+  to: { isSome: boolean; value: number };
+}
+
+describe("provableReductionHashList", () => {
+  function mapToProvable(
+    sts: UnprovableStateTransition[]
+  ): StateTransition<unknown>[] {
+    return sts.map(
+      (st) =>
+        new StateTransition(
+          Field(st.path),
+          new Option(Bool(true), Field(st.from), Field, Bool(false)),
+          new Option(Bool(st.to.isSome), Field(st.to.value), Field, Bool(false))
+        ) as StateTransition<unknown>
+    );
+  }
+
+  describe.each<[UnprovableStateTransition[], number]>([
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: true, value: 15 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+      ],
+      1,
+    ],
+    [
+      [
+        { path: 1, from: 5, to: { isSome: true, value: 10 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: false, value: 0 } },
+        { path: 5, from: 15, to: { isSome: true, value: 20 } },
+        { path: 1, from: 10, to: { isSome: false, value: 0 } },
+        { path: 5, from: 20, to: { isSome: true, value: 25 } },
+        { path: 5, from: 25, to: { isSome: true, value: 30 } },
+      ],
+      4,
+    ],
+  ])("should reduce and append correctly", (sts, reducedLength) => {
+    it("start from empty list", () => {
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition
+      );
+      const normalList = new DefaultProvableHashList(ProvableStateTransition);
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+
+    it("start from non-zero commitment - skip first reduction", () => {
+      const commitment = Poseidon.hash([Field(123_456)]);
+      const reductionList = new StateTransitionReductionList(
+        ProvableStateTransition,
+        commitment
+      );
+      const normalList = new DefaultProvableHashList(
+        ProvableStateTransition,
+        commitment
+      );
+
+      const provableSTs = mapToProvable(sts);
+
+      provableSTs.forEach((st) => {
+        reductionList.push(st.toProvable());
+      });
+
+      const reduced = reduceStateTransitions(provableSTs);
+      reduced.forEach((st) => {
+        normalList.push(st.toProvable());
+      });
+
+      expect(reduced).toHaveLength(reducedLength);
+      expect(normalList.commitment.toBigInt()).toStrictEqual(
+        reductionList.commitment.toBigInt()
+      );
+      expect(reductionList.unconstrainedList).toHaveLength(reduced.length);
+    });
+  });
+});

package/test/utils.test.ts

@@ -1,15 +1,12 @@
 import "reflect-metadata";
-import { Field } from "o1js";
 
 import { stringToField } from "../src";
 
 describe("stringToField", () => {
   const stringToFieldInputs: string[] = [];
 
-  // eslint-disable-next-line jest/require-hook
   [31, 32, 33, 63, 64, 65, 1000].forEach((length) => {
     stringToFieldInputs.push(
-      // eslint-disable-next-line array-func/from-map
       Array.from({ length })
         .map(() => "A")
         .reduce((a, b) => a + b)

package/dist/hooks/TransactionFeeHook.d.ts

@@ -1,16 +0,0 @@
-import { Runtime, RuntimeModulesRecord } from "@proto-kit/module";
-import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
-import { BlockProverExecutionData } from "../prover/block/BlockProvable";
-export declare const treeFeeHeight = 10;
-declare const FeeTree_base: import("@proto-kit/common").AbstractMerkleTreeClass;
-export declare class FeeTree extends FeeTree_base {
-}
-export declare class TransactionFeeHook extends ProvableTransactionHook {
-    runtime: Runtime<RuntimeModulesRecord>;
-    constructor(runtime: Runtime<RuntimeModulesRecord>);
-    feeTree: FeeTree;
-    createFeeTree(): FeeTree;
-    onTransaction(executionData: BlockProverExecutionData): void;
-}
-export {};
-//# sourceMappingURL=TransactionFeeHook.d.ts.map

package/dist/hooks/TransactionFeeHook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionFeeHook.d.ts","sourceRoot":"","sources":["../../src/hooks/TransactionFeeHook.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,OAAO,EACP,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,eAAO,MAAM,aAAa,KAAK,CAAC;;AAChC,qBAAa,OAAQ,SAAQ,YAA+B;CAAG;AAE/D,qBAAa,kBAAmB,SAAQ,uBAAuB;IAEjC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;gBAAtC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAK3D,OAAO,EAAE,OAAO,CAAwB;IAExC,aAAa;IASb,aAAa,CAAC,aAAa,EAAE,wBAAwB,GAAG,IAAI;CACpE"}

package/src/blockmodules/SequenceStateTransactionModule.ts

@@ -1,25 +0,0 @@
-import { Field } from "o1js";
-
-import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
-import { BlockProverExecutionData } from "../prover/block/BlockProvable";
-import { protocolState } from "../state/protocol/ProtocolState";
-import { State } from "../state/State";
-import { DefaultProvableHashList } from "../utils/ProvableHashList";
-import { SignedTransaction } from "../model/transaction/SignedTransaction";
-
-// Future idea to add this functionality as a module
-// This is currently hardcoded in tracing however
-class SequenceStateTransactionModule extends ProvableTransactionHook {
-  @protocolState() sequenceStateTransactionsList = State.from(Field);
-
-  public onTransaction(executionData: BlockProverExecutionData): void {
-    const hashList = new DefaultProvableHashList(
-      SignedTransaction,
-      this.sequenceStateTransactionsList.get().orElse(Field(0))
-    );
-
-    hashList.push(executionData.transaction);
-
-    this.sequenceStateTransactionsList.set(hashList.commitment);
-  }
-}

package/src/model/Option.test.ts

@@ -1,21 +0,0 @@
-import { Bool, Field, Poseidon } from "o1js";
-
-import { Option } from "./Option";
-
-describe("option", () => {
-  it.each([
-    [Bool(true), Field(0), Field, true],
-    [Bool(false), Field(0), Field, false],
-  ])(
-    "should serialize to the correct tree value",
-    (isSome, value, valueType, shouldHash) => {
-      expect.assertions(1);
-
-      const option = Option.from(isSome, value, valueType);
-      // eslint-disable-next-line jest/no-conditional-in-test
-      const treeValue = shouldHash ? Poseidon.hash(value.toFields()) : Field(0);
-
-      expect(option.treeValue.toString()).toStrictEqual(treeValue.toString());
-    }
-  );
-});

package/src/settlement/SettlementContract.ts

@@ -1,444 +0,0 @@
-import {
-  AccountUpdate,
-  Bool,
-  Field,
-  method,
-  Mina,
-  Poseidon,
-  Proof,
-  Provable,
-  ProvableExtended,
-  PublicKey,
-  Reducer,
-  Signature,
-  SmartContract,
-  State,
-  state,
-  Struct,
-  TokenId,
-  UInt32,
-  UInt64,
-} from "o1js";
-import {
-  EMPTY_PUBLICKEY,
-  prefixToField,
-  RollupMerkleTree,
-  RollupMerkleTreeWitness,
-} from "@proto-kit/common";
-import { inject, injectable, injectAll } from "tsyringe";
-
-import { ProtocolModule } from "../protocol/ProtocolModule";
-import { BlockProver } from "../prover/block/BlockProver";
-import {
-  BlockProvable,
-  BlockProverPublicInput,
-  BlockProverPublicOutput,
-} from "../prover/block/BlockProvable";
-import { NetworkState } from "../model/network/NetworkState";
-import { BlockHashMerkleTree } from "../prover/block/accummulators/BlockHashMerkleTree";
-import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
-import { Path } from "../model/Path";
-import { MinaActions, MinaEvents } from "../utils/MinaPrefixedProvableHashList";
-
-import {
-  ProvableSettlementHook,
-  SettlementHookInputs,
-  SettlementStateRecord,
-} from "./ProvableSettlementHook";
-
-class LazyBlockProof extends Proof<
-  BlockProverPublicInput,
-  BlockProverPublicOutput
-> {
-  public static publicInputType = BlockProverPublicInput;
-
-  public static publicOutputType = BlockProverPublicOutput;
-
-  public static tag: () => { name: string } = () => {
-    throw new Error("Tag not initialized yet");
-  };
-}
-
-export type SettlementMethodIdMapping = Record<`${string}.${string}`, bigint>;
-
-export class Deposit extends Struct({
-  address: PublicKey,
-  amount: UInt64,
-}) {}
-
-export class Withdrawal extends Struct({
-  address: PublicKey,
-  amount: UInt64,
-}) {
-  static dummy() {
-    return new Withdrawal({
-      address: EMPTY_PUBLICKEY,
-      amount: UInt64.from(0),
-    });
-  }
-}
-
-export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
-
-export class OutgoingMessageArgument extends Struct({
-  witness: RollupMerkleTreeWitness,
-  value: Withdrawal,
-}) {
-  public static dummy(): OutgoingMessageArgument {
-    return new OutgoingMessageArgument({
-      witness: RollupMerkleTreeWitness.dummy(),
-      value: Withdrawal.dummy(),
-    });
-  }
-}
-
-export class OutgoingMessageArgumentBatch extends Struct({
-  arguments: Provable.Array(
-    OutgoingMessageArgument,
-    OUTGOING_MESSAGE_BATCH_SIZE
-  ),
-
-  isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
-}) {
-  public static fromMessages(providedArguments: OutgoingMessageArgument[]) {
-    const batch = providedArguments.slice();
-    const isDummys = batch.map(() => Bool(false));
-
-    while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
-      batch.push(OutgoingMessageArgument.dummy());
-      isDummys.push(Bool(true));
-    }
-
-    return new OutgoingMessageArgumentBatch({
-      arguments: batch,
-      isDummys,
-    });
-  }
-}
-
-// Some random prefix for the sequencer signature
-export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
-
-export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
-
-export class SettlementContract extends SmartContract {
-  @state(Field) public sequencerKey = State<Field>();
-  @state(UInt32) public lastSettlementL1Block = State<UInt32>();
-
-  @state(Field) public stateRoot = State<Field>();
-  @state(Field) public networkStateHash = State<Field>();
-  @state(Field) public blockHashRoot = State<Field>();
-
-  @state(Field) public promisedMessagesHash = State<Field>();
-  @state(Field) public honoredMessagesHash = State<Field>();
-
-  @state(Field) public outgoingMessageCursor = State<Field>();
-
-  public constructor(
-    address: PublicKey,
-    private readonly methodIdMappings: Record<string, bigint>,
-    private readonly hooks: ProvableSettlementHook<unknown>[],
-    private readonly withdrawalStatePath: [string, string],
-    private readonly incomingMessagesPaths: Record<
-      string,
-      `${string}.${string}`
-    >,
-    // 24 hours
-    private readonly escapeHatchSlotsInterval = (60 / 3) * 24
-  ) {
-    super(address);
-  }
-
-  @method
-  public initialize(sequencer: PublicKey) {
-    this.sequencerKey.getAndAssertEquals().assertEquals(Field(0));
-    this.stateRoot.getAndAssertEquals().assertEquals(Field(0));
-    this.blockHashRoot.getAndAssertEquals().assertEquals(Field(0));
-    this.networkStateHash.getAndAssertEquals().assertEquals(Field(0));
-    this.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
-    this.honoredMessagesHash.getAndAssertEquals().assertEquals(Field(0));
-
-    this.sequencerKey.set(sequencer.x);
-    this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
-    this.blockHashRoot.set(Field(BlockHashMerkleTree.EMPTY_ROOT));
-    this.networkStateHash.set(NetworkState.empty().hash());
-    this.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
-    this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
-  }
-
-  @method
-  public settle(
-    blockProof: LazyBlockProof,
-    signature: Signature,
-    publicKey: PublicKey,
-    inputNetworkState: NetworkState,
-    outputNetworkState: NetworkState,
-    newPromisedMessagesHash: Field
-  ) {
-    // Verify the blockproof
-    blockProof.verify();
-
-    // Get and assert on-chain values
-    const stateRoot = this.stateRoot.getAndAssertEquals();
-    const networkStateHash = this.networkStateHash.getAndAssertEquals();
-    const blockHashRoot = this.blockHashRoot.getAndAssertEquals();
-    const sequencerKey = this.sequencerKey.getAndAssertEquals();
-    const promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
-    const honoredMessagesHash = this.honoredMessagesHash.getAndAssertEquals();
-    const lastSettlementL1Block =
-      this.lastSettlementL1Block.getAndAssertEquals();
-
-    // Get block height and use the lower bound for all ops
-    const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
-    this.network.globalSlotSinceGenesis.assertBetween(
-      minBlockIncluded,
-      minBlockIncluded.add(20)
-    );
-
-    // Check signature/escape catch
-    publicKey.x.assertEquals(
-      sequencerKey,
-      "Sequencer public key witness not matching"
-    );
-    const signatureValid = signature.verify(publicKey, [
-      BATCH_SIGNATURE_PREFIX,
-      lastSettlementL1Block.value,
-    ]);
-    const escapeHatchActivated = lastSettlementL1Block
-      .add(UInt32.from(this.escapeHatchSlotsInterval))
-      .lessThan(minBlockIncluded);
-    signatureValid
-      .or(escapeHatchActivated)
-      .assertTrue(
-        "Sequencer signature not valid and escape hatch not activated"
-      );
-
-    // Assert correctness of networkState witness
-    inputNetworkState
-      .hash()
-      .assertEquals(networkStateHash, "InputNetworkState witness not valid");
-    outputNetworkState
-      .hash()
-      .assertEquals(
-        blockProof.publicOutput.networkStateHash,
-        "OutputNetworkState witness not valid"
-      );
-
-    blockProof.publicOutput.closed.assertEquals(
-      Bool(true),
-      "Supplied proof is not a closed BlockProof"
-    );
-
-    // Execute onSettlementHooks for additional checks
-    const stateRecord: SettlementStateRecord = {
-      blockHashRoot,
-      stateRoot,
-      networkStateHash,
-      honoredMessagesHash,
-      lastSettlementL1Block,
-      promisedMessagesHash,
-      sequencerKey,
-    };
-    const inputs: SettlementHookInputs = {
-      blockProof,
-      contractState: stateRecord,
-      newPromisedMessagesHash,
-      fromNetworkState: inputNetworkState,
-      toNetworkState: outputNetworkState,
-      currentL1Block: minBlockIncluded,
-    };
-    this.hooks.forEach((hook) => {
-      hook.beforeSettlement(this, inputs);
-    });
-
-    // Apply blockProof
-    stateRoot.assertEquals(
-      blockProof.publicInput.stateRoot,
-      "Input state root not matching"
-    );
-    networkStateHash.assertEquals(
-      blockProof.publicInput.networkStateHash,
-      "Input networkStateHash not matching"
-    );
-    blockHashRoot.assertEquals(
-      blockProof.publicInput.blockHashRoot,
-      "Input blockHashRoot not matching"
-    );
-    this.stateRoot.set(blockProof.publicOutput.stateRoot);
-    this.networkStateHash.set(blockProof.publicOutput.networkStateHash);
-    this.blockHashRoot.set(blockProof.publicOutput.blockHashRoot);
-
-    // Assert and apply deposit commitments
-    promisedMessagesHash.assertEquals(
-      blockProof.publicOutput.incomingMessagesHash,
-      "Promised messages not honored"
-    );
-    this.honoredMessagesHash.set(promisedMessagesHash);
-
-    // Assert and apply new promisedMessagesHash
-    this.self.account.actionState.assertEquals(newPromisedMessagesHash);
-    this.promisedMessagesHash.set(newPromisedMessagesHash);
-
-    this.lastSettlementL1Block.set(minBlockIncluded);
-  }
-
-  private dispatchMessage<Type>(
-    methodId: Field,
-    value: Type,
-    valueType: ProvableExtended<Type>
-  ) {
-    const args = valueType.toFields(value);
-    // Should be the same as RuntimeTransaction.hash
-    const argsHash = Poseidon.hash(args);
-    const runtimeTransaction = RuntimeTransaction.fromMessage({
-      methodId,
-      argsHash,
-    });
-
-    // Append tx to incomingMessagesHash
-    const actionData = runtimeTransaction.hashData();
-    const actionHash = MinaActions.actionHash(actionData);
-
-    this.self.body.actions = {
-      hash: actionHash,
-      data: [actionData],
-    };
-
-    const eventHash = MinaEvents.eventHash(args);
-    this.self.body.events = {
-      hash: eventHash,
-      data: [args],
-    };
-  }
-
-  @method
-  public deposit(amount: UInt64) {
-    // Save this, since otherwise it would be a second witness later,
-    // which could be a different values than the first
-    const sender = this.sender;
-
-    // Credit the amount to the bridge contract
-    this.self.balance.addInPlace(amount);
-
-    const action = new Deposit({
-      address: sender,
-      amount,
-    });
-    const methodId = Field(
-      this.methodIdMappings[this.incomingMessagesPaths["deposit"]]
-    );
-    this.dispatchMessage(methodId.toConstant(), action, Deposit);
-  }
-
-  @method
-  public rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
-    let counter = this.outgoingMessageCursor.getAndAssertEquals();
-    const stateRoot = this.stateRoot.getAndAssertEquals();
-
-    const [withdrawalModule, withdrawalStateName] = this.withdrawalStatePath;
-    const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
-
-    let accountCreationFeePaid = Field(0);
-
-    for (let i = 0; i < OUTGOING_MESSAGE_BATCH_SIZE; i++) {
-      const args = batch.arguments[i];
-
-      // Check witness
-      const path = Path.fromKey(mapPath, Field, counter);
-
-      args.witness
-        .checkMembership(
-          stateRoot,
-          path,
-          Poseidon.hash(Withdrawal.toFields(args.value))
-        )
-        .assertTrue("Provided Withdrawal witness not valid");
-
-      // Process message
-      const { address, amount } = args.value;
-      const isDummy = address.equals(this.address);
-
-      const tokenAu = this.token.mint({ address, amount });
-      const isNewAccount = tokenAu.account.isNew.getAndAssertEquals();
-      tokenAu.body.balanceChange.magnitude =
-        tokenAu.body.balanceChange.magnitude.sub(
-          Provable.if(
-            isNewAccount,
-            Mina.accountCreationFee().toConstant(),
-            UInt64.zero
-          )
-        );
-
-      accountCreationFeePaid = accountCreationFeePaid.add(
-        Provable.if(isNewAccount, Field(1e9), Field(0))
-      );
-
-      counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
-    }
-
-    this.balance.subInPlace(UInt64.from(accountCreationFeePaid));
-
-    this.outgoingMessageCursor.set(counter);
-  }
-
-  @method
-  public redeem(additionUpdate: AccountUpdate) {
-    additionUpdate.body.tokenId.assertEquals(
-      TokenId.default,
-      "Tokenid not default token"
-    );
-    additionUpdate.body.balanceChange.sgn
-      .isPositive()
-      .assertTrue("Sign not correct");
-    const amount = additionUpdate.body.balanceChange.magnitude;
-
-    // Burn tokens
-    this.token.burn({
-      address: additionUpdate.publicKey,
-      amount,
-    });
-
-    // Send mina
-    this.approve(additionUpdate);
-    this.balance.subInPlace(amount);
-  }
-}
-
-export interface SettlementContractModuleConfig {
-  withdrawalStatePath: `${string}.${string}`;
-  withdrawalMethodPath: `${string}.${string}`;
-  incomingMessagesMethods: Record<string, `${string}.${string}`>;
-}
-
-@injectable()
-export class SettlementContractModule extends ProtocolModule<SettlementContractModuleConfig> {
-  public constructor(
-    @injectAll("ProvableSettlementHook")
-    private readonly hooks: ProvableSettlementHook<unknown>[],
-    @inject("BlockProver")
-    private readonly blockProver: BlockProvable
-  ) {
-    super();
-    LazyBlockProof.tag = blockProver.zkProgrammable.zkProgram.Proof.tag;
-  }
-
-  public getContractClass(): typeof SettlementContract {
-    return SettlementContract;
-  }
-
-  public createContract(
-    address: PublicKey,
-    methodIdMappings: SettlementMethodIdMapping
-  ): SettlementContract {
-    // We know that this returns [string, string], but TS can't infer that
-    const withdrawalPath = this.config.withdrawalStatePath.split(".");
-
-    return new SettlementContract(
-      address,
-      methodIdMappings,
-      this.hooks,
-      [withdrawalPath[0], withdrawalPath[1]],
-      this.config.incomingMessagesMethods
-    );
-  }
-}