@actual-app/sync-server 25.4.0-alpha.0

package/src/app-gocardless/banks/berliner_sparkasse_beladebexxx.js

@@ -0,0 +1,61 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['BERLINER_SPARKASSE_BELADEBEXXX'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    let remittanceInformationUnstructured;
+
+    if (transaction.remittanceInformationUnstructured) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationUnstructured;
+    } else if (transaction.remittanceInformationStructured) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationStructured;
+    } else if (transaction.remittanceInformationStructuredArray?.length > 0) {
+      remittanceInformationUnstructured =
+        transaction.remittanceInformationStructuredArray?.join(' ');
+    }
+
+    if (transaction.additionalInformation) {
+      remittanceInformationUnstructured +=
+        ' ' + transaction.additionalInformation;
+    }
+
+    const usefulCreditorName =
+      transaction.ultimateCreditor ||
+      transaction.creditorName ||
+      transaction.debtorName;
+
+    editedTrans.creditorName = usefulCreditorName;
+    editedTrans.remittanceInformationUnstructured =
+      remittanceInformationUnstructured;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  /**
+   *  For SANDBOXFINANCE_SFIN0000 we don't know what balance was
+   *  after each transaction so we have to calculate it by getting
+   *  current balance from the account and subtract all the transactions
+   *
+   *  As a current balance we use `interimBooked` balance type because
+   *  it includes transaction placed during current day
+   */
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimAvailable' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/bnp_be_gebabebb.js

@@ -0,0 +1,73 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: [
+    'FINTRO_BE_GEBABEBB',
+    'HELLO_BE_GEBABEBB',
+    'BNP_BE_GEBABEBB',
+  ],
+
+  /** BNP_BE_GEBABEBB provides a lot of useful information via the 'additionalField'
+   *  There does not seem to be a specification of this field, but the following information is contained in its subfields:
+   *  - for pending transactions: the 'atmPosName'
+   *  - for booked transactions: the 'narrative'.
+   *  This narrative subfield is most useful as it contains information required to identify the transaction,
+   *  especially in case of debit card or instant payment transactions.
+   *  Do note that the narrative subfield ALSO contains the remittance information if any.
+   *  The goal of the  normalization is to place any relevant information of the additionalInformation
+   *  field in the remittanceInformationUnstructuredArray field.
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // Extract the creditor name to fill it in with information from the
+    // additionalInformation field in case it's not yet defined.
+    let creditorName = transaction.creditorName;
+
+    if (transaction.additionalInformation) {
+      const additionalInformationObject = {};
+      const additionalInfoRegex = /(, )?([^:]+): ((\[.*?\])|([^,]*))/g;
+      const matches =
+        transaction.additionalInformation.matchAll(additionalInfoRegex);
+      if (matches) {
+        let creditorNameFromNarrative; // Possible value for creditorName
+        for (const match of matches) {
+          const key = match[2].trim();
+          let value = (match[4] || match[5]).trim();
+          if (key === 'narrative') {
+            // Set narrativeName to the first element in the "narrative" array.
+            const first_value = value.matchAll(/'(.+?)'/g)?.next().value;
+            creditorNameFromNarrative = first_value
+              ? first_value[1].trim()
+              : undefined;
+          }
+          // Remove square brackets and single quotes and commas
+          value = value.replace(/[[\]',]/g, '');
+          additionalInformationObject[key] = value;
+        }
+        // Keep existing unstructuredArray and add atmPosName and narrative
+        editedTrans.remittanceInformationUnstructuredArray = [
+          transaction.remittanceInformationUnstructuredArray ?? '',
+          additionalInformationObject?.atmPosName ?? '',
+          additionalInformationObject?.narrative ?? '',
+        ].filter(Boolean);
+
+        // If the creditor name doesn't exist in the original transactions,
+        // set it to the atmPosName or narrativeName if they exist; otherwise
+        // leave empty and let the default rules handle it.
+        creditorName =
+          creditorName ??
+          additionalInformationObject?.atmPosName ??
+          creditorNameFromNarrative ??
+          null;
+      }
+    }
+
+    editedTrans.creditorName = creditorName;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/cbc_cregbebb.js

@@ -0,0 +1,34 @@
+import Fallback from './integration-bank.js';
+import { extractPayeeNameFromRemittanceInfo } from './util/extract-payeeName-from-remittanceInfo.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['CBC_CREGBEBB'],
+
+  /**
+   * For negative amounts, the only payee information we have is returned in
+   * remittanceInformationUnstructured.
+   */
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    if (Number(transaction.transactionAmount.amount) > 0) {
+      editedTrans.payeeName =
+        transaction.debtorName ||
+        transaction.remittanceInformationUnstructured ||
+        'undefined';
+    } else {
+      editedTrans.payeeName =
+        transaction.creditorName ||
+        extractPayeeNameFromRemittanceInfo(
+          transaction.remittanceInformationUnstructured,
+          ['Paiement', 'Domiciliation', 'Transfert', 'Ordre permanent'],
+        ) ||
+        'undefined';
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/commerzbank_cobadeff.js

@@ -0,0 +1,51 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['COMMERZBANK_COBADEFF'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // remittanceInformationUnstructured is limited to 140 chars thus ...
+    // ... missing information form remittanceInformationUnstructuredArray ...
+    // ... so we recreate it.
+    editedTrans.remittanceInformationUnstructured =
+      transaction.remittanceInformationUnstructuredArray.join(' ');
+
+    // The limitations of remittanceInformationUnstructuredArray ...
+    // ... can result in split keywords. We fix these. Other ...
+    // ... splits will need to be fixed by user with rules.
+    const keywords = [
+      'End-to-End-Ref.:',
+      'Mandatsref:',
+      'Gläubiger-ID:',
+      'SEPA-BASISLASTSCHRIFT',
+      'Kartenzahlung',
+      'Dauerauftrag',
+    ];
+    keywords.forEach(keyword => {
+      editedTrans.remittanceInformationUnstructured =
+        editedTrans.remittanceInformationUnstructured.replace(
+          // There can be spaces in keywords
+          RegExp(keyword.split('').join('\\s*'), 'gi'),
+          ', ' + keyword + ' ',
+        );
+    });
+
+    // Clean up remittanceInformation, deduplicate payee (removing slashes ...
+    // ... that are added to the remittanceInformation field), and ...
+    // ... remove clutter like "End-to-End-Ref.: NOTPROVIDED"
+    const payee = transaction.creditorName || transaction.debtorName || '';
+    editedTrans.remittanceInformationUnstructured =
+      editedTrans.remittanceInformationUnstructured
+        .replace(/\s*(,)?\s+/g, '$1 ')
+        .replace(RegExp(payee.split(' ').join('(/*| )'), 'gi'), ' ')
+        .replace(', End-to-End-Ref.: NOTPROVIDED', '')
+        .trim();
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/danskebank_dabno22.js

@@ -0,0 +1,39 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['DANSKEBANK_DABANO22'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    /**
+     * Danske Bank appends the EndToEndID: NOTPROVIDED to
+     * remittanceInformationUnstructured, cluttering the data.
+     *
+     * We clean thais up by removing any instances of this string from all transactions.
+     *
+     */
+    editedTrans.remittanceInformationUnstructured =
+      transaction.remittanceInformationUnstructured.replace(
+        '\nEndToEndID: NOTPROVIDED',
+        '',
+      );
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => balance.balanceType === 'interimAvailable',
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/direkt_heladef1822.js

@@ -0,0 +1,18 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['DIREKT_HELADEF1822'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    editedTrans.remittanceInformationUnstructured =
+      transaction.remittanceInformationUnstructured ??
+      transaction.remittanceInformationStructured;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/easybank_bawaatww.js

@@ -0,0 +1,50 @@
+import d from 'date-fns';
+
+import { formatPayeeName } from '../../util/payee-name.js';
+import { title } from '../../util/title/index.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['EASYBANK_BAWAATWW'],
+
+  // If date is same, sort by transactionId
+  sortTransactions: (transactions = []) =>
+    transactions.sort((a, b) => {
+      const diff =
+        +new Date(b.valueDate || b.bookingDate) -
+        +new Date(a.valueDate || a.bookingDate);
+      if (diff !== 0) return diff;
+      return parseInt(b.transactionId) - parseInt(a.transactionId);
+    }),
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    let payeeName = formatPayeeName(transaction);
+    if (!payeeName) payeeName = extractPayeeName(transaction);
+    editedTrans.payeeName = payeeName;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};
+
+/**
+ * Extracts the payee name from the remittanceInformationStructured
+ * @param {import('../gocardless-node.types.js').Transaction} transaction
+ */
+function extractPayeeName(transaction) {
+  const structured = transaction.remittanceInformationStructured;
+  // The payee name is betweeen the transaction timestamp (11.07. 11:36) and the location, that starts with \\
+  const regex = /\d{2}\.\d{2}\. \d{2}:\d{2}(.*)\\\\/;
+  const matches = structured.match(regex);
+  if (matches && matches.length > 1 && matches[1]) {
+    return title(matches[1]);
+  } else {
+    // As a fallback if still no payee is found, the whole information is used
+    return structured;
+  }
+}

package/src/app-gocardless/banks/entercard_swednokk.js

@@ -0,0 +1,40 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['ENTERCARD_SWEDNOKK'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // GoCardless's Entercard integration returns forex transactions with the
+    // foreign amount in `transactionAmount`, but at least the amount actually
+    // billed to the account is now available in
+    // `remittanceInformationUnstructured`.
+    const remittanceInformationUnstructured =
+      transaction.remittanceInformationUnstructured;
+    if (remittanceInformationUnstructured.startsWith('billingAmount: ')) {
+      transaction.transactionAmount = {
+        amount: remittanceInformationUnstructured.substring(15),
+        currency: 'SEK',
+      };
+    }
+
+    editedTrans.date = transaction.valueDate;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    return sortedTransactions.reduce(
+      (total, trans) => {
+        return total - amountToInteger(trans.transactionAmount.amount);
+      },
+      amountToInteger(balances[0]?.balanceAmount?.amount || 0),
+    );
+  },
+};

package/src/app-gocardless/banks/fortuneo_ftnofrp1xxx.js

@@ -0,0 +1,46 @@
+import { formatPayeeName } from '../../util/payee-name.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['FORTUNEO_FTNOFRP1XXX'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    // Most of the information from the transaction is in the remittanceInformationUnstructuredArray field.
+    // We extract the creditor and debtor names from this field.
+    // The remittanceInformationUnstructuredArray field usually contain keywords like "Vir" for
+    // bank transfers or "Carte 03/06" for card payments, as well as the date.
+    // We remove these keywords to get a cleaner payee name.
+    const keywordsToRemove = [
+      'VIR INST',
+      'VIR',
+      'PRLV',
+      'ANN CARTE',
+      'CARTE \\d{2}\\/\\d{2}',
+    ];
+
+    const details =
+      transaction.remittanceInformationUnstructuredArray.join(' ');
+    const amount = transaction.transactionAmount.amount;
+
+    const regex = new RegExp(keywordsToRemove.join('|'), 'g');
+    const payeeName = details.replace(regex, '').trim();
+
+    // The amount is negative for outgoing transactions, positive for incoming transactions.
+    const isCreditorPayee = parseFloat(amount) < 0;
+
+    // The payee name is the creditor name for outgoing transactions and the debtor name for incoming transactions.
+    const creditorName = isCreditorPayee ? payeeName : null;
+    const debtorName = isCreditorPayee ? null : payeeName;
+
+    editedTrans.creditorName = creditorName;
+    editedTrans.debtorName = debtorName;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/hype_hyeeit22.js

@@ -0,0 +1,74 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['HYPE_HYEEIT22'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    /** Online card payments - identified by "crd" transaction code
+     *  always start with PAGAMENTO PRESSO + <payee name>
+     */
+    if (transaction.proprietaryBankTransactionCode === 'crd') {
+      // remove PAGAMENTO PRESSO and set payee name
+      editedTrans.debtorName =
+        transaction.remittanceInformationUnstructured?.slice(
+          'PAGAMENTO PRESSO '.length,
+        );
+    }
+    /**
+     * In-app money transfers (p2p) and bank transfers (bon) have remittance info structure like
+     * DENARO (INVIATO/RICEVUTO) (A/DA) {payee_name} - {payment_info} (p2p)
+     * HAI (INVIATO/RICEVUTO) UN BONIFICO (A/DA) {payee_name} - {payment_info} (bon)
+     */
+    if (
+      transaction.proprietaryBankTransactionCode === 'p2p' ||
+      transaction.proprietaryBankTransactionCode === 'bon'
+    ) {
+      // keep only {payment_info} portion of remittance info
+      // NOTE: if {payee_name} contains dashes (unlikely / impossible?), this probably gets bugged!
+      const infoIdx =
+        transaction.remittanceInformationUnstructured.indexOf(' - ') + 3;
+      editedTrans.remittanceInformationUnstructured =
+        infoIdx === -1
+          ? transaction.remittanceInformationUnstructured
+          : transaction.remittanceInformationUnstructured.slice(infoIdx).trim();
+    }
+    /**
+     * CONVERT ESCAPED UNICODE TO CODEPOINTS
+     * p2p payments allow user to write arbitrary unicode strings as messages
+     * gocardless reports unicode codepoints as \Uxxxx
+     * so it groups them in 4bytes bundles
+     * the code below assumes this is always the case
+     */
+    if (transaction.proprietaryBankTransactionCode === 'p2p') {
+      let str = transaction.remittanceInformationUnstructured;
+      let idx = str.indexOf('\\U');
+      let start_idx = idx;
+      let codepoints = [];
+      while (idx !== -1) {
+        codepoints.push(parseInt(str.slice(idx + 2, idx + 6), 16));
+        const next_idx = str.indexOf('\\U', idx + 6);
+        if (next_idx === idx + 6) {
+          idx = next_idx;
+          continue;
+        }
+        str =
+          str.slice(0, start_idx) +
+          String.fromCodePoint(...codepoints) +
+          str.slice(idx + 6);
+        codepoints = [];
+        idx = str.indexOf('\\U'); // slight inefficiency?
+        start_idx = idx;
+      }
+      editedTrans.remittanceInformationUnstructured = str;
+    }
+
+    editedTrans.date = transaction.valueDate || transaction.bookingDate;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/ing_ingbrobu.js

@@ -0,0 +1,70 @@
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['ING_INGBROBU'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    //Merchant transactions all have the same transactionId of 'NOTPROVIDED'.
+    //For booked transactions, this can be set to the internalTransactionId
+    //For pending transactions, this needs to be removed for them to show up in Actual
+
+    //For deduplication to work better, payeeName needs to be standardized
+    //and converted from a pending transaction form ("payeeName":"Card no: xxxxxxxxxxxx1111"') to a booked transaction form ("payeeName":"Card no: Xxxx Xxxx Xxxx 1111")
+    if (transaction.transactionId === 'NOTPROVIDED') {
+      //Some corner case transactions only have the `proprietaryBankTransactionCode` field, this need to be copied to `remittanceInformationUnstructured`
+      if (
+        transaction.proprietaryBankTransactionCode &&
+        !transaction.remittanceInformationUnstructured
+      ) {
+        editedTrans.remittanceInformationUnstructured =
+          transaction.proprietaryBankTransactionCode;
+      }
+
+      if (booked) {
+        transaction.transactionId = transaction.internalTransactionId;
+        if (
+          transaction.remittanceInformationUnstructured &&
+          transaction.remittanceInformationUnstructured
+            .toLowerCase()
+            .includes('card no:')
+        ) {
+          editedTrans.creditorName =
+            transaction.remittanceInformationUnstructured.split(',')[0];
+          //Catch all case for other types of payees
+        } else {
+          editedTrans.creditorName =
+            transaction.remittanceInformationUnstructured;
+        }
+      } else {
+        transaction.transactionId = null;
+
+        if (
+          transaction.remittanceInformationUnstructured &&
+          transaction.remittanceInformationUnstructured
+            .toLowerCase()
+            .includes('card no:')
+        ) {
+          editedTrans.creditorName =
+            transaction.remittanceInformationUnstructured.replace(
+              /x{4}/g,
+              'Xxxx ',
+            );
+          //Catch all case for other types of payees
+        } else {
+          editedTrans.creditorName =
+            transaction.remittanceInformationUnstructured;
+        }
+        //Remove remittanceInformationUnstructured from pending transactions, so the `notes` field remains empty (there is no merchant information)
+        //Once booked, the right `notes` (containing the merchant) will be populated
+        editedTrans.remittanceInformationUnstructured = null;
+      }
+    }
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+};

package/src/app-gocardless/banks/ing_ingddeff.js

@@ -0,0 +1,47 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['ING_INGDDEFF'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    const remittanceInformationMatch = /remittanceinformation:(.*)$/.exec(
+      transaction.remittanceInformationUnstructured,
+    );
+
+    editedTrans.remittanceInformationUnstructured = remittanceInformationMatch
+      ? remittanceInformationMatch[1]
+      : transaction.remittanceInformationUnstructured;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  sortTransactions(transactions = []) {
+    return transactions.sort((a, b) => {
+      const diff =
+        +new Date(b.valueDate || b.bookingDate) -
+        +new Date(a.valueDate || a.bookingDate);
+      if (diff) return diff;
+      const idA = parseInt(a.transactionId);
+      const idB = parseInt(b.transactionId);
+      if (!isNaN(idA) && !isNaN(idB)) return idB - idA;
+      return 0;
+    });
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    const currentBalance = balances.find(
+      balance => 'interimBooked' === balance.balanceType,
+    );
+
+    return sortedTransactions.reduce((total, trans) => {
+      return total - amountToInteger(trans.transactionAmount.amount);
+    }, amountToInteger(currentBalance.balanceAmount.amount));
+  },
+};

package/src/app-gocardless/banks/ing_pl_ingbplpw.js

@@ -0,0 +1,46 @@
+import { amountToInteger } from '../utils.js';
+
+import Fallback from './integration-bank.js';
+
+/** @type {import('./bank.interface.js').IBank} */
+export default {
+  ...Fallback,
+
+  institutionIds: ['ING_PL_INGBPLPW'],
+
+  normalizeTransaction(transaction, booked) {
+    const editedTrans = { ...transaction };
+
+    editedTrans.date = transaction.valueDate;
+
+    return Fallback.normalizeTransaction(transaction, booked, editedTrans);
+  },
+
+  sortTransactions(transactions = []) {
+    return transactions.sort((a, b) => {
+      return (
+        Number(b.transactionId.substr(2)) - Number(a.transactionId.substr(2))
+      );
+    });
+  },
+
+  calculateStartingBalance(sortedTransactions = [], balances = []) {
+    if (sortedTransactions.length) {
+      const oldestTransaction =
+        sortedTransactions[sortedTransactions.length - 1];
+      const oldestKnownBalance = amountToInteger(
+        oldestTransaction.balanceAfterTransaction.balanceAmount.amount,
+      );
+      const oldestTransactionAmount = amountToInteger(
+        oldestTransaction.transactionAmount.amount,
+      );
+
+      return oldestKnownBalance - oldestTransactionAmount;
+    } else {
+      return amountToInteger(
+        balances.find(balance => 'interimBooked' === balance.balanceType)
+          .balanceAmount.amount,
+      );
+    }
+  },
+};