Refactor: Introduce action matchers

src/actions/actionMatchers.ts

@@ -0,0 +1,53 @@
+import { ContractEventsSignatures } from '~types';
+import { handleExpenditureAddedAction } from './handlers/expenditureAdded';
+import { handleMintTokensAction } from './handlers/mintTokens';
+import { handlePaymentAction } from './handlers/payment';
+import { ActionMatcher } from './types';
+
+export const actionMatchers: ActionMatcher[] = [
+  {
+    eventSignatures: [ContractEventsSignatures.TokensMinted],
+    handler: handleMintTokensAction,
+  },
+  {
+    matcherFn: (events) => {
+      if (
+        events[0].signature !== ContractEventsSignatures.ExpenditureAdded ||
+        events[events.length - 1].signature !==
+          ContractEventsSignatures.OneTxPaymentMade
+      ) {
+        return false;
+      }
+
+      const remainingEvents = events.slice(1, -1);
+
+      if (
+        remainingEvents.some((event) =>
+          [
+            ContractEventsSignatures.ExpenditureAdded,
+            ContractEventsSignatures.OneTxPaymentMade,
+          ].includes(event.signature as ContractEventsSignatures),
+        )
+      ) {
+        return false;
+      }
+
+      // @TODO: Adding another listener has a potential to break this
+      return remainingEvents.every((event) =>
+        [
+          ContractEventsSignatures.ColonyFundsMovedBetweenFundingPots,
+          ContractEventsSignatures.ExpenditureStateChanged,
+          ContractEventsSignatures.ExpenditurePayoutSet,
+          ContractEventsSignatures.ExpenditureFinalized,
+          ContractEventsSignatures.ExpenditureRecipientSet,
+          ContractEventsSignatures.ExpenditurePayoutClaimed,
+        ].includes(event.signature as ContractEventsSignatures),
+      );
+    },
+    handler: handlePaymentAction,
+  },
+  {
+    eventSignatures: [ContractEventsSignatures.ExpenditureAdded],
+    handler: handleExpenditureAddedAction,
+  },
+];

src/actions/handlers/expenditureAdded.ts

@@ -0,0 +1,89 @@
+import { ActionHandler } from '~actions/types';
+import { mutate } from '~amplifyClient';
+import {
+  ColonyActionType,
+  CreateExpenditureDocument,
+  CreateExpenditureMutation,
+  CreateExpenditureMutationVariables,
+  ExpenditureStatus,
+  ExpenditureType,
+  NotificationType,
+} from '~graphql';
+// @TODO: Move closer to the handler
+import { getExpenditure } from '~handlers/expenditures/helpers';
+import {
+  getDomainDatabaseId,
+  getExpenditureDatabaseId,
+  output,
+  toNumber,
+  verbose,
+  writeActionFromEvent,
+} from '~utils';
+
+import { sendExpenditureUpdateNotifications } from '~utils/notifications';
+
+export const handleExpenditureAddedAction: ActionHandler = async (events) => {
+  const { contractAddress: colonyAddress, transactionHash } = events[0];
+  const { agent: ownerAddress, expenditureId } = events[0].args;
+  const convertedExpenditureId = toNumber(expenditureId);
+
+  const expenditure = await getExpenditure(
+    colonyAddress,
+    convertedExpenditureId,
+  );
+  if (!expenditure) {
+    output(
+      `Could not get expenditure with ID ${convertedExpenditureId} in colony ${colonyAddress}`,
+    );
+    return;
+  }
+
+  const domainId = toNumber(expenditure.domainId);
+  const fundingPotId = toNumber(expenditure.fundingPotId);
+
+  verbose(
+    'Expenditure with ID',
+    convertedExpenditureId,
+    'added in Colony:',
+    colonyAddress,
+  );
+
+  const databaseId = getExpenditureDatabaseId(
+    colonyAddress,
+    convertedExpenditureId,
+  );
+
+  await mutate<CreateExpenditureMutation, CreateExpenditureMutationVariables>(
+    CreateExpenditureDocument,
+    {
+      input: {
+        id: databaseId,
+        type: ExpenditureType.PaymentBuilder,
+        colonyId: colonyAddress,
+        nativeId: convertedExpenditureId,
+        ownerAddress,
+        status: ExpenditureStatus.Draft,
+        slots: [],
+        nativeFundingPotId: fundingPotId,
+        nativeDomainId: domainId,
+        isStaked: false,
+        balances: [],
+      },
+    },
+  );
+
+  await writeActionFromEvent(events[0], colonyAddress, {
+    type: ColonyActionType.CreateExpenditure,
+    initiatorAddress: ownerAddress,
+    expenditureId: databaseId,
+    fromDomainId: getDomainDatabaseId(colonyAddress, domainId),
+  });
+
+  sendExpenditureUpdateNotifications({
+    colonyAddress,
+    creator: ownerAddress,
+    notificationType: NotificationType.ExpenditureReadyForReview,
+    transactionHash,
+    expenditureID: databaseId,
+  });
+};

src/actions/handlers/mintTokens.ts

@@ -0,0 +1,52 @@
+import { Id } from '@colony/colony-js';
+
+import { ColonyActionType } from '~graphql';
+import { NotificationCategory } from '~types/notifications';
+import {
+  writeActionFromEvent,
+  getColonyTokenAddress,
+  getDomainDatabaseId,
+  verbose,
+} from '~utils';
+import { sendPermissionsActionNotifications } from '~utils/notifications';
+import { ActionHandler } from '../types';
+
+export const handleMintTokensAction: ActionHandler = async (events) => {
+  const { contractAddress: colonyAddress, transactionHash } = events[0];
+  const {
+    agent: initiatorAddress,
+    who: recipientAddress,
+    amount,
+  } = events[0].args;
+
+  const tokenAddress = await getColonyTokenAddress(colonyAddress);
+
+  if (!tokenAddress) {
+    verbose(`Unable to find ERC20 token address for colony: ${colonyAddress}`);
+    return;
+  }
+
+  if (amount && amount.toString() !== '0') {
+    await writeActionFromEvent(events[0], colonyAddress, {
+      type: ColonyActionType.MintTokens,
+      initiatorAddress,
+      recipientAddress,
+      amount: amount.toString(),
+      tokenAddress,
+      fromDomainId: getDomainDatabaseId(colonyAddress, Id.RootDomain),
+    });
+
+    sendPermissionsActionNotifications({
+      creator: initiatorAddress,
+      colonyAddress,
+      transactionHash,
+      notificationCategory: NotificationCategory.Payment,
+    });
+  } else {
+    verbose(
+      `Detected Mint Tokens event but its amount was ${
+        amount ? amount.toString() : amount
+      }`,
+    );
+  }
+};