Add country and exchange type info

.vscode/settings.json

@@ -1,2 +1,22 @@
 {
-}
+  "cSpell.words": [
+    "banxa",
+    "Bitrefill",
+    "Bity",
+    "Changelly",
+    "Faast",
+    "godex",
+    "Kado",
+    "Libertyx",
+    "Lifi",
+    "Paybis",
+    "Paytrie",
+    "Safello",
+    "Sideshift",
+    "Swapuz",
+    "Switchain",
+    "Transak",
+    "Wyre",
+    "Xanpool"
+  ]
+}

package.json

@@ -43,7 +43,7 @@
     "biggystring": "^4.1.3",
     "body-parser": "^1.19.0",
     "cleaner-config": "^0.1.10",
-    "cleaners": "^0.3.13",
+    "cleaners": "^0.3.17",
     "commander": "^6.1.0",
     "cors": "^2.8.5",
     "csv-stringify": "^6.2.0",

src/bin/migration.ts

@@ -151,7 +151,12 @@ async function migration(): Promise<void> {
                     cleanedShapeshiftTx.timestamp * 1000
                   ).toISOString(),
                   usdValue: -1,
-                  rawTx: tx
+                  rawTx: tx,
+                  // IDK what to do here...
+                  countryCode: null,
+                  direction: null,
+                  exchangeType: 'swap',
+                  paymentType: null
                 }
                 return await standardTxReformat(
                   newTx,
@@ -196,7 +201,12 @@ async function migration(): Promise<void> {
                 isoDate,
                 timestamp,
                 usdValue: -1,
-                rawTx: undefined
+                rawTx: undefined,
+                // IDK what to do here...
+                countryCode: null,
+                direction: null,
+                exchangeType: 'swap',
+                paymentType: null
               }
               return await standardTxReformat(
                 newTx,

src/config.ts

@@ -8,8 +8,12 @@ export const asConfig = asObject({
   ),
   httpPort: asOptional(asNumber, 8008),
   bog: asOptional(asObject({ apiKey: asString }), { apiKey: '' }),
+
+  /** Only run specific appIds (e.g. edge, coinhub, etc) */
   soloAppIds: asOptional(asArray(asString), null),
+  /** Only run specific partnerIds (e.g. moonpay, paybis, etc) */
   soloPartnerIds: asOptional(asArray(asString), null),
+
   timeoutOverrideMins: asOptional(asNumber, 1200),
   cacheLookbackMonths: asOptional(asNumber, 24)
 })

src/partners/banxa.ts

@@ -13,6 +13,7 @@ import { Response } from 'node-fetch'
 
 import {
   EDGE_APP_START_DATE,
+  FiatPaymentType,
   PartnerPlugin,
   PluginParams,
   PluginResult,
@@ -32,6 +33,7 @@ export const asBanxaParams = asObject({
   })
 })
 
+type BanxaStatus = ReturnType<typeof asBanxaStatus>
 const asBanxaStatus = asMaybe(
   asValue(
     'complete',
@@ -44,15 +46,18 @@ const asBanxaStatus = asMaybe(
   'other'
 )
 
+type BanxaTx = ReturnType<typeof asBanxaTx>
 const asBanxaTx = asObject({
   id: asString,
   status: asBanxaStatus,
   created_at: asString,
+  country: asString,
   fiat_amount: asNumber,
   fiat_code: asString,
   coin_amount: asNumber,
   coin_code: asString,
   order_type: asString,
+  payment_type: asString,
   wallet_address: asMaybe(asString, '')
 })
 
@@ -67,9 +72,6 @@ const PAGE_LIMIT = 100
 const ONE_DAY_MS = 1000 * 60 * 60 * 24
 const ROLLBACK = ONE_DAY_MS * 7 // 7 days
 
-type BanxaTx = ReturnType<typeof asBanxaTx>
-type BanxaStatus = ReturnType<typeof asBanxaStatus>
-
 const statusMap: { [key in BanxaStatus]: Status } = {
   complete: 'complete',
   expired: 'expired',
@@ -202,61 +204,33 @@ async function fetchBanxaAPI(
   return await retryFetch(`${partnerUrl}${apiQuery}`, { headers: headers })
 }
 
-function processBanxaOrders(rawtxs, ssFormatTxs): void {
+function processBanxaOrders(
+  rawtxs: unknown[],
+  ssFormatTxs: StandardTx[]
+): void {
   let numComplete = 0
   let newestIsoDate = new Date(0).toISOString()
   let oldestIsoDate = new Date(9999999999999).toISOString()
   for (const rawTx of rawtxs) {
-    let tx: BanxaTx
+    let standardTx: StandardTx
     try {
-      tx = asBanxaTx(rawTx)
+      standardTx = processBanxaTx(rawTx)
     } catch (e) {
       datelog(String(e))
       throw e
     }
-    if (tx.status === 'complete') {
-      numComplete++
-    }
-    const { isoDate, timestamp } = smartIsoDateFromTimestamp(tx.created_at)
 
-    if (isoDate > newestIsoDate) {
-      newestIsoDate = isoDate
-    }
-    if (isoDate < oldestIsoDate) {
-      oldestIsoDate = isoDate
+    ssFormatTxs.push(standardTx)
+
+    if (standardTx.status === 'complete') {
+      numComplete++
     }
-    // Flip the amounts if the order is a SELL
-    let payoutAddress
-    let inputAmount = tx.fiat_amount
-    let inputCurrency = tx.fiat_code
-    let outputAmount = tx.coin_amount
-    let outputCurrency = tx.coin_code
-    if (tx.order_type === 'CRYPTO-SELL') {
-      inputAmount = tx.coin_amount
-      inputCurrency = tx.coin_code
-      outputAmount = tx.fiat_amount
-      outputCurrency = tx.fiat_code
-    } else {
-      payoutAddress = tx.wallet_address
+    if (standardTx.isoDate > newestIsoDate) {
+      newestIsoDate = standardTx.isoDate
     }
-
-    const ssTx: StandardTx = {
-      status: statusMap[tx.status],
-      orderId: tx.id,
-      depositTxid: undefined,
-      depositAddress: undefined,
-      depositCurrency: inputCurrency,
-      depositAmount: inputAmount,
-      payoutTxid: undefined,
-      payoutAddress,
-      payoutCurrency: outputCurrency,
-      payoutAmount: outputAmount,
-      timestamp,
-      isoDate,
-      usdValue: -1,
-      rawTx
+    if (standardTx.isoDate < oldestIsoDate) {
+      oldestIsoDate = standardTx.isoDate
     }
-    ssFormatTxs.push(ssTx)
   }
   if (rawtxs.length > 1) {
     datelog(
@@ -271,3 +245,87 @@ function processBanxaOrders(rawtxs, ssFormatTxs): void {
     datelog(`BANXA: Processed ${rawtxs.length}`)
   }
 }
+
+export function processBanxaTx(rawTx: unknown): StandardTx {
+  const banxaTx: BanxaTx = asBanxaTx(rawTx)
+  const { isoDate, timestamp } = smartIsoDateFromTimestamp(banxaTx.created_at)
+
+  // Flip the amounts if the order is a SELL
+  let payoutAddress
+  let inputAmount = banxaTx.fiat_amount
+  let inputCurrency = banxaTx.fiat_code
+  let outputAmount = banxaTx.coin_amount
+  let outputCurrency = banxaTx.coin_code
+  if (banxaTx.order_type === 'CRYPTO-SELL') {
+    inputAmount = banxaTx.coin_amount
+    inputCurrency = banxaTx.coin_code
+    outputAmount = banxaTx.fiat_amount
+    outputCurrency = banxaTx.fiat_code
+  } else {
+    payoutAddress = banxaTx.wallet_address
+  }
+
+  const direction = banxaTx.order_type === 'CRYPTO-SELL' ? 'sell' : 'buy'
+
+  const paymentType = getFiatPaymentType(banxaTx)
+
+  const standardTx: StandardTx = {
+    status: statusMap[banxaTx.status],
+    orderId: banxaTx.id,
+    countryCode: banxaTx.country,
+    depositTxid: undefined,
+    depositAddress: undefined,
+    depositCurrency: inputCurrency,
+    depositAmount: inputAmount,
+    direction,
+    exchangeType: 'fiat',
+    paymentType,
+    payoutTxid: undefined,
+    payoutAddress,
+    payoutCurrency: outputCurrency,
+    payoutAmount: outputAmount,
+    timestamp,
+    isoDate,
+    usdValue: -1,
+    rawTx
+  }
+
+  return standardTx
+}
+
+function getFiatPaymentType(tx: BanxaTx): FiatPaymentType {
+  switch (tx.payment_type) {
+    case 'AusPost Retail':
+    case 'BPay':
+    case 'Blueshyft Online':
+    case 'POLi Transfer':
+    case 'Sofort Transfer':
+      return 'directtobank'
+    case 'Checkout Credit Card':
+    case 'WorldPay Credit Card':
+      return 'credit'
+    case 'ClearJunction Fast Pay':
+    case 'ClearJunction Sell Fast Pay':
+      return 'fasterpayments'
+    case 'ClearJunction Sepa':
+    case 'Ten31 Sepa':
+      return 'sepa'
+    case 'DCBank Interac':
+    case 'DCBank Interac Sell':
+      return 'interac'
+    case 'Enumis Transfer':
+      return 'wire'
+    case 'Monoova Sell':
+    case 'NPP PayID':
+    case 'PayID via Monoova':
+      return 'payid'
+    case 'WorldPay ApplePay':
+      return 'applepay'
+    case 'WorldPay GooglePay':
+      return 'googlepay'
+    case 'iDEAL Transfer':
+      return 'ideal'
+    default:
+      throw new Error(`Unknown payment method: ${tx.payment_type} for ${tx.id}`)
+  }
+}