@mojaloop/central-ledger 17.7.8 → 17.8.0-orb.1

package/src/handlers/transfers/validator.js

@@ -42,6 +42,9 @@ const Decimal = require('decimal.js')
 const Config = require('../../lib/config')
 const Participant = require('../../domain/participant')
 const Transfer = require('../../domain/transfer')
+const FxTransferModel = require('../../models/fxTransfer')
+// const TransferStateChangeModel = require('../../models/transfer/transferStateChange')
+const FxTransferStateChangeModel = require('../../models/fxTransfer/stateChange')
 const CryptoConditions = require('../../cryptoConditions')
 const Crypto = require('crypto')
 const base64url = require('base64url')
@@ -87,9 +90,9 @@ const validatePositionAccountByNameAndCurrency = async function (participantName
   return validationPassed
 }
 
-const validateDifferentDfsp = (payload) => {
+const validateDifferentDfsp = (payerFsp, payeeFsp) => {
   if (!Config.ENABLE_ON_US_TRANSFERS) {
-    const isPayerAndPayeeDifferent = (payload.payerFsp.toLowerCase() !== payload.payeeFsp.toLowerCase())
+    const isPayerAndPayeeDifferent = (payerFsp.toLowerCase() !== payeeFsp.toLowerCase())
     if (!isPayerAndPayeeDifferent) {
       reasons.push('Payer FSP and Payee FSP should be different, unless on-us tranfers are allowed by the Scheme')
       return false
@@ -98,8 +101,8 @@ const validateDifferentDfsp = (payload) => {
   return true
 }
 
-const validateFspiopSourceMatchesPayer = (payload, headers) => {
-  const matched = (headers && headers['fspiop-source'] && headers['fspiop-source'] === payload.payerFsp)
+const validateFspiopSourceMatchesPayer = (payer, headers) => {
+  const matched = (headers && headers['fspiop-source'] && headers['fspiop-source'] === payer)
   if (!matched) {
     reasons.push('FSPIOP-Source header should match Payer')
     return false
@@ -185,7 +188,11 @@ const validateConditionAndExpiration = async (payload) => {
   return true
 }
 
-const validatePrepare = async (payload, headers) => {
+const isAmountValid = (payload, isFx) => isFx
+  ? validateAmount(payload.sourceAmount) && validateAmount(payload.targetAmount)
+  : validateAmount(payload.amount)
+
+const validatePrepare = async (payload, headers, isFx = false, determiningTransferCheckResult, proxyObligation) => {
   const histTimerValidatePrepareEnd = Metrics.getHistogram(
     'handlers_transfer_validator',
     'validatePrepare - Metrics for transfer handler',
@@ -199,15 +206,59 @@ const validatePrepare = async (payload, headers) => {
     validationPassed = false
     return { validationPassed, reasons }
   }
-  validationPassed = (validateFspiopSourceMatchesPayer(payload, headers) &&
-    await validateParticipantByName(payload.payerFsp) &&
-    await validatePositionAccountByNameAndCurrency(payload.payerFsp, payload.amount.currency) &&
-    await validateParticipantByName(payload.payeeFsp) &&
-    await validatePositionAccountByNameAndCurrency(payload.payeeFsp, payload.amount.currency) &&
-    validateAmount(payload.amount) &&
-    await validateConditionAndExpiration(payload) &&
-    validateDifferentDfsp(payload))
+
+  const initiatingFsp = isFx ? payload.initiatingFsp : payload.payerFsp
+  const counterPartyFsp = isFx ? payload.counterPartyFsp : payload.payeeFsp
+
+  // Check if determining transfers are failed
+  if (determiningTransferCheckResult.watchListRecords && determiningTransferCheckResult.watchListRecords.length > 0) {
+    // Iterate through determiningTransferCheckResult.watchListRecords
+    for (const watchListRecord of determiningTransferCheckResult.watchListRecords) {
+      if (isFx) {
+        // TODO: Check the transfer state of determiningTransferId
+        // const latestTransferStateChange = await TransferStateChangeModel.getByTransferId(watchListRecord.determiningTransferId)
+        // if (latestTransferStateChange.transferStateId !== Enum.Transfers.TransferInternalState.RESERVED) {
+        //   reasons.push('Related Transfer is not in reserved state')
+        //   validationPassed = false
+        //   return { validationPassed, reasons }
+        // }
+      } else {
+        // Check the transfer state of commitRequestId
+        const latestFxTransferStateChange = await FxTransferStateChangeModel.getByCommitRequestId(watchListRecord.commitRequestId)
+        if (latestFxTransferStateChange.transferStateId !== Enum.Transfers.TransferInternalState.RECEIVED_FULFIL_DEPENDENT) {
+          reasons.push('Related FX Transfer is not fulfilled')
+          validationPassed = false
+          return { validationPassed, reasons }
+        }
+      }
+    }
+  }
+
+  // Skip usual validation if preparing a proxy transfer or fxTransfer
+  if (!(proxyObligation?.isInitiatingFspProxy || proxyObligation?.isCounterPartyFspProxy)) {
+    validationPassed = (
+      validateFspiopSourceMatchesPayer(initiatingFsp, headers) &&
+      isAmountValid(payload, isFx) &&
+      await validateParticipantByName(initiatingFsp) &&
+      await validateParticipantByName(counterPartyFsp) &&
+      await validateConditionAndExpiration(payload) &&
+      validateDifferentDfsp(initiatingFsp, counterPartyFsp)
+    )
+  } else {
+    validationPassed = true
+  }
+
+  // validate participant accounts from determiningTransferCheckResult
+  if (validationPassed && determiningTransferCheckResult) {
+    for (const participantCurrency of determiningTransferCheckResult.participantCurrencyValidationList) {
+      if (!await validatePositionAccountByNameAndCurrency(participantCurrency.participantName, participantCurrency.currencyId)) {
+        validationPassed = false
+        break // Exit the loop if validation fails
+      }
+    }
+  }
   histTimerValidatePrepareEnd({ success: true, funcName: 'validatePrepare' })
+
   return {
     validationPassed,
     reasons
@@ -241,11 +292,21 @@ const validateParticipantTransferId = async function (participantName, transferI
   return validationPassed
 }
 
+const validateParticipantForCommitRequestId = async function (participantName, commitRequestId) {
+  const fxTransferParticipants = await FxTransferModel.fxTransfer.getFxTransferParticipant(participantName, commitRequestId)
+  let validationPassed = false
+  if (Array.isArray(fxTransferParticipants) && fxTransferParticipants.length > 0) {
+    validationPassed = true
+  }
+  return validationPassed
+}
+
 module.exports = {
   validatePrepare,
   validateById,
   validateFulfilCondition,
   validateParticipantByName,
   reasons,
-  validateParticipantTransferId
+  validateParticipantTransferId,
+  validateParticipantForCommitRequestId
 }

package/src/lib/cache.js

@@ -74,7 +74,7 @@ const initCache = async function () {
 }
 
 const destroyCache = async function () {
-  catboxMemoryClient.stop()
+  catboxMemoryClient?.stop()
   catboxMemoryClient = null
 }
 

package/src/lib/config.js

@@ -1,4 +1,4 @@
-const RC = require('rc')('CLEDG', require('../../config/default.json'))
+const RC = require('parse-strings-in-object')(require('rc')('CLEDG', require('../../config/default.json')))
 
 module.exports = {
   HOSTNAME: RC.HOSTNAME.replace(/\/$/, ''),
@@ -9,8 +9,8 @@ module.exports = {
   MONGODB_USER: RC.MONGODB.USER,
   MONGODB_PASSWORD: RC.MONGODB.PASSWORD,
   MONGODB_DATABASE: RC.MONGODB.DATABASE,
-  MONGODB_DEBUG: (RC.MONGODB.DEBUG === true || RC.MONGODB.DEBUG === 'true'),
-  MONGODB_DISABLED: (RC.MONGODB.DISABLED === true || RC.MONGODB.DISABLED === 'true'),
+  MONGODB_DEBUG: RC.MONGODB.DEBUG === true,
+  MONGODB_DISABLED: RC.MONGODB.DISABLED === true,
   AMOUNT: RC.AMOUNT,
   EXPIRES_TIMEOUT: RC.EXPIRES_TIMEOUT,
   ERROR_HANDLING: RC.ERROR_HANDLING,
@@ -23,6 +23,7 @@ module.exports = {
   HANDLERS_TIMEOUT_TIMEXP: RC.HANDLERS.TIMEOUT.TIMEXP,
   HANDLERS_TIMEOUT_TIMEZONE: RC.HANDLERS.TIMEOUT.TIMEZONE,
   CACHE_CONFIG: RC.CACHE,
+  PROXY_CACHE_CONFIG: RC.PROXY_CACHE,
   KAFKA_CONFIG: RC.KAFKA,
   PARTICIPANT_INITIAL_POSITION: RC.PARTICIPANT_INITIAL_POSITION,
   RUN_MIGRATIONS: !RC.MIGRATIONS.DISABLED,
@@ -69,5 +70,7 @@ module.exports = {
     debug: RC.DATABASE.DEBUG
   },
   API_DOC_ENDPOINTS_ENABLED: RC.API_DOC_ENDPOINTS_ENABLED || false,
+  // If this is set to true, payee side currency conversion will not be allowed due to a limitation in the current implementation
+  PAYEE_PARTICIPANT_CURRENCY_VALIDATION_ENABLED: (RC.PAYEE_PARTICIPANT_CURRENCY_VALIDATION_ENABLED === true || RC.PAYEE_PARTICIPANT_CURRENCY_VALIDATION_ENABLED === 'true'),
   SETTLEMENT_MODELS: RC.SETTLEMENT_MODELS
 }

package/src/lib/healthCheck/subServiceHealth.js

@@ -26,7 +26,7 @@
 const { statusEnum, serviceName } = require('@mojaloop/central-services-shared').HealthCheck.HealthCheckEnums
 const Logger = require('@mojaloop/central-services-logger')
 const Consumer = require('@mojaloop/central-services-stream').Util.Consumer
-
+const ProxyCache = require('../proxyCache')
 const MigrationLockModel = require('../../models/misc/migrationLock')
 
 /**
@@ -82,7 +82,17 @@ const getSubServiceHealthDatastore = async () => {
   }
 }
 
+const getSubServiceHealthProxyCache = async () => {
+  const proxyCache = ProxyCache.getCache()
+  const healthCheck = await proxyCache.healthCheck()
+  return {
+    name: 'proxyCache',
+    status: healthCheck ? statusEnum.OK : statusEnum.DOWN
+  }
+}
+
 module.exports = {
   getSubServiceHealthBroker,
-  getSubServiceHealthDatastore
+  getSubServiceHealthDatastore,
+  getSubServiceHealthProxyCache
 }

package/src/lib/proxyCache.js

@@ -0,0 +1,131 @@
+'use strict'
+const { createProxyCache } = require('@mojaloop/inter-scheme-proxy-cache-lib')
+const { Enum } = require('@mojaloop/central-services-shared')
+const ParticipantService = require('../../src/domain/participant')
+const Config = require('./config.js')
+const { logger } = require('../../src/shared/logger')
+
+let proxyCache
+
+const init = () => {
+  const { type, proxyConfig } = Config.PROXY_CACHE_CONFIG
+  proxyCache = createProxyCache(type, proxyConfig)
+}
+
+const connect = async () => {
+  return !proxyCache?.isConnected && getCache().connect()
+}
+
+const disconnect = async () => {
+  proxyCache?.isConnected && await proxyCache.disconnect()
+  proxyCache = null
+}
+
+const reset = async () => {
+  await disconnect()
+  proxyCache = null
+}
+
+const getCache = () => {
+  if (!proxyCache) {
+    init()
+  }
+  return proxyCache
+}
+
+/**
+ * @typedef {Object} ProxyOrParticipant - An object containing the inScheme status, proxyId and FSP name
+ *
+ * @property {boolean} inScheme - Is FSP in the scheme.
+ * @property {string|null} proxyId - Proxy, associated with the FSP, if FSP is not in the scheme.
+ * @property {string} name - FSP name.
+ */
+
+/**
+ * Checks if dfspId is in scheme or proxy.
+ *
+ * @param {string} dfspId - The DFSP ID to check.
+ * @param {Object} [options] - { validateCurrencyAccounts: boolean, accounts: [ { currency: string, accountType: Enum.Accounts.LedgerAccountType } ] }
+ * @returns {ProxyOrParticipant} proxyOrParticipant details
+ */
+const getFSPProxy = async (dfspId, options = null) => {
+  logger.debug('Checking if dfspId is in scheme or proxy', { dfspId })
+  const participant = await ParticipantService.getByName(dfspId)
+  let inScheme = !!participant
+
+  if (inScheme && options?.validateCurrencyAccounts) {
+    logger.debug('Checking if participant currency accounts are active', { dfspId, options, participant })
+    let accountsAreActive = false
+    for (const account of options.accounts) {
+      accountsAreActive = participant.currencyList.some((currAccount) => {
+        return (
+          currAccount.currencyId === account.currency &&
+          currAccount.ledgerAccountTypeId === account.accountType &&
+          currAccount.isActive === 1
+        )
+      })
+      if (!accountsAreActive) break
+    }
+    inScheme = accountsAreActive
+  }
+
+  return {
+    inScheme,
+    proxyId: !participant ? await getCache().lookupProxyByDfspId(dfspId) : null,
+    name: dfspId
+  }
+}
+
+const checkSameCreditorDebtorProxy = async (debtorDfspId, creditorDfspId) => {
+  logger.debug('Checking if debtorDfspId and creditorDfspId are using the same proxy', { debtorDfspId, creditorDfspId })
+  const [debtorProxyId, creditorProxyId] = await Promise.all([
+    getCache().lookupProxyByDfspId(debtorDfspId),
+    getCache().lookupProxyByDfspId(creditorDfspId)
+  ])
+  return debtorProxyId && creditorProxyId ? debtorProxyId === creditorProxyId : false
+}
+
+const getProxyParticipantAccountDetails = async (fspName, currency) => {
+  logger.debug('Getting account details for fspName and currency', { fspName, currency })
+  const proxyLookupResult = await getFSPProxy(fspName)
+  if (proxyLookupResult.inScheme) {
+    const participantCurrency = await ParticipantService.getAccountByNameAndCurrency(
+      fspName,
+      currency,
+      Enum.Accounts.LedgerAccountType.POSITION
+    )
+    logger.debug("Account details for fspName's currency", { fspName, currency, participantCurrency })
+    return {
+      inScheme: true,
+      participantCurrencyId: participantCurrency?.participantCurrencyId || null
+    }
+  } else {
+    if (proxyLookupResult.proxyId) {
+      const participantCurrency = await ParticipantService.getAccountByNameAndCurrency(
+        proxyLookupResult.proxyId,
+        currency,
+        Enum.Accounts.LedgerAccountType.POSITION
+      )
+      logger.debug('Account details for proxy\'s currency', { proxyId: proxyLookupResult.proxyId, currency, participantCurrency })
+      return {
+        inScheme: false,
+        participantCurrencyId: participantCurrency?.participantCurrencyId || null
+      }
+    }
+    logger.debug('No proxy found for fspName', { fspName })
+    return {
+      inScheme: false,
+      participantCurrencyId: null
+    }
+  }
+}
+
+module.exports = {
+  reset, // for testing
+  connect,
+  disconnect,
+  getCache,
+  getFSPProxy,
+  getProxyParticipantAccountDetails,
+  checkSameCreditorDebtorProxy
+}

package/src/models/bulkTransfer/facade.js

@@ -51,25 +51,19 @@ const saveBulkTransferReceived = async (payload, participants, stateReason = nul
 
     const knex = await Db.getKnex()
     return await knex.transaction(async (trx) => {
-      try {
-        await knex('bulkTransfer').transacting(trx).insert(bulkTransferRecord)
-        if (payload.extensionList && payload.extensionList.extension) {
-          const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
-            return {
-              bulkTransferId: payload.bulkTransferId,
-              key: ext.key,
-              value: ext.value
-            }
-          })
-          await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
-        }
-        await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
-        await trx.commit
-        return state
-      } catch (err) {
-        await trx.rollback
-        throw err
+      await knex('bulkTransfer').transacting(trx).insert(bulkTransferRecord)
+      if (payload.extensionList && payload.extensionList.extension) {
+        const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
+          return {
+            bulkTransferId: payload.bulkTransferId,
+            key: ext.key,
+            value: ext.value
+          }
+        })
+        await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
       }
+      await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
+      return state
     })
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(err)
@@ -95,26 +89,20 @@ const saveBulkTransferProcessing = async (payload, stateReason = null, isValid =
 
     const knex = await Db.getKnex()
     return await knex.transaction(async (trx) => {
-      try {
-        await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
-        if (payload.extensionList && payload.extensionList.extension) {
-          const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
-            return {
-              bulkTransferId: payload.bulkTransferId,
-              isFulfilment: true,
-              key: ext.key,
-              value: ext.value
-            }
-          })
-          await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
-        }
-        await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
-        await trx.commit
-        return state
-      } catch (err) {
-        await trx.rollback
-        throw err
+      await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
+      if (payload.extensionList && payload.extensionList.extension) {
+        const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
+          return {
+            bulkTransferId: payload.bulkTransferId,
+            isFulfilment: true,
+            key: ext.key,
+            value: ext.value
+          }
+        })
+        await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
       }
+      await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
+      return state
     })
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(err)
@@ -138,33 +126,27 @@ const saveBulkTransferErrorProcessing = async (payload, stateReason = null, isVa
 
     const knex = await Db.getKnex()
     return await knex.transaction(async (trx) => {
-      try {
-        await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
-        if (payload.errorInformation.extensionList && payload.errorInformation.extensionList.extension) {
-          const bulkTransferExtensionsRecordList = payload.errorInformation.extensionList.extension.map(ext => {
-            return {
-              bulkTransferId: payload.bulkTransferId,
-              isFulfilment: true,
-              key: ext.key,
-              value: ext.value
-            }
-          })
-          await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
-        }
-        const returnedInsertIds = await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord).returning('bulkTransferStateChangeId')
-        const bulkTransferStateChangeId = returnedInsertIds[0]
-        const bulkTransferErrorRecord = {
-          bulkTransferStateChangeId,
-          errorCode: payload.errorInformation.errorCode,
-          errorDescription: payload.errorInformation.errorDescription
-        }
-        await knex('bulkTransferError').transacting(trx).insert(bulkTransferErrorRecord)
-        await trx.commit
-        return state
-      } catch (err) {
-        await trx.rollback
-        throw err
+      await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
+      if (payload.errorInformation.extensionList && payload.errorInformation.extensionList.extension) {
+        const bulkTransferExtensionsRecordList = payload.errorInformation.extensionList.extension.map(ext => {
+          return {
+            bulkTransferId: payload.bulkTransferId,
+            isFulfilment: true,
+            key: ext.key,
+            value: ext.value
+          }
+        })
+        await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
       }
+      const returnedInsertIds = await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord).returning('bulkTransferStateChangeId')
+      const bulkTransferStateChangeId = returnedInsertIds[0]
+      const bulkTransferErrorRecord = {
+        bulkTransferStateChangeId,
+        errorCode: payload.errorInformation.errorCode,
+        errorDescription: payload.errorInformation.errorDescription
+      }
+      await knex('bulkTransferError').transacting(trx).insert(bulkTransferErrorRecord)
+      return state
     })
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(err)
@@ -188,26 +170,20 @@ const saveBulkTransferAborting = async (payload, stateReason = null) => {
 
     const knex = await Db.getKnex()
     return await knex.transaction(async (trx) => {
-      try {
-        await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
-        if (payload.extensionList && payload.extensionList.extension) {
-          const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
-            return {
-              bulkTransferId: payload.bulkTransferId,
-              isFulfilment: true,
-              key: ext.key,
-              value: ext.value
-            }
-          })
-          await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
-        }
-        await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
-        await trx.commit
-        return state
-      } catch (err) {
-        await trx.rollback
-        throw err
+      await knex('bulkTransferFulfilment').transacting(trx).insert(bulkTransferFulfilmentRecord)
+      if (payload.extensionList && payload.extensionList.extension) {
+        const bulkTransferExtensionsRecordList = payload.extensionList.extension.map(ext => {
+          return {
+            bulkTransferId: payload.bulkTransferId,
+            isFulfilment: true,
+            key: ext.key,
+            value: ext.value
+          }
+        })
+        await knex.batchInsert('bulkTransferExtension', bulkTransferExtensionsRecordList).transacting(trx)
       }
+      await knex('bulkTransferStateChange').transacting(trx).insert(bulkTransferStateChangeRecord)
+      return state
     })
   } catch (err) {
     Logger.isErrorEnabled && Logger.error(err)

package/src/models/fxTransfer/duplicateCheck.js

@@ -0,0 +1,153 @@
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
+const Db = require('../../lib/db')
+const { logger } = require('../../shared/logger')
+const { TABLE_NAMES } = require('../../shared/constants')
+
+const histName = 'model_fx_transfer'
+
+const getOneByCommitRequestId = async ({ commitRequestId, table, queryName }) => {
+  const histTimerEnd = Metrics.getHistogram(
+    histName,
+    `${queryName} - Metrics for fxTransfer duplicate check model`,
+    ['success', 'queryName']
+  ).startTimer()
+  logger.debug('get duplicate record', { commitRequestId, table, queryName })
+
+  try {
+    const result = await Db.from(table).findOne({ commitRequestId })
+    histTimerEnd({ success: true, queryName })
+    return result
+  } catch (err) {
+    histTimerEnd({ success: false, queryName })
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
+const saveCommitRequestIdAndHash = async ({ commitRequestId, hash, table, queryName }) => {
+  const histTimerEnd = Metrics.getHistogram(
+    histName,
+    `${queryName} - Metrics for fxTransfer duplicate check model`,
+    ['success', 'queryName']
+  ).startTimer()
+  logger.debug('save duplicate record', { commitRequestId, hash, table })
+
+  try {
+    const result = await Db.from(table).insert({ commitRequestId, hash })
+    histTimerEnd({ success: true, queryName })
+    return result
+  } catch (err) {
+    histTimerEnd({ success: false, queryName })
+    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+  }
+}
+
+/**
+ * @function GetTransferDuplicateCheck
+ *
+ * @async
+ * @description This retrieves the fxTransferDuplicateCheck table record if present
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ *
+ * @returns {object} - Returns the record from fxTransferDuplicateCheck table, or throws an error if failed
+ */
+const getFxTransferDuplicateCheck = async (commitRequestId) => {
+  const table = TABLE_NAMES.fxTransferDuplicateCheck
+  const queryName = `${table}_getFxTransferDuplicateCheck`
+  return getOneByCommitRequestId({ commitRequestId, table, queryName })
+}
+
+/**
+ * @function SaveTransferDuplicateCheck
+ *
+ * @async
+ * @description This inserts a record into fxTransferDuplicateCheck table
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ * @param {string} hash - the hash of the fxTransfer request payload
+ *
+ * @returns {integer} - Returns the database id of the inserted row, or throws an error if failed
+ */
+const saveFxTransferDuplicateCheck = async (commitRequestId, hash) => {
+  const table = TABLE_NAMES.fxTransferDuplicateCheck
+  const queryName = `${table}_saveFxTransferDuplicateCheck`
+  return saveCommitRequestIdAndHash({ commitRequestId, hash, table, queryName })
+}
+
+/**
+ * @function getFxTransferErrorDuplicateCheck
+ *
+ * @async
+ * @description This retrieves the fxTransferErrorDuplicateCheck table record if present
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ *
+ * @returns {object} - Returns the record from fxTransferDuplicateCheck table, or throws an error if failed
+ */
+const getFxTransferErrorDuplicateCheck = async (commitRequestId) => {
+  const table = TABLE_NAMES.fxTransferErrorDuplicateCheck
+  const queryName = `${table}_getFxTransferErrorDuplicateCheck`
+  return getOneByCommitRequestId({ commitRequestId, table, queryName })
+}
+
+/**
+ * @function saveFxTransferErrorDuplicateCheck
+ *
+ * @async
+ * @description This inserts a record into fxTransferErrorDuplicateCheck table
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ * @param {string} hash - the hash of the fxTransfer request payload
+ *
+ * @returns {integer} - Returns the database id of the inserted row, or throws an error if failed
+ */
+const saveFxTransferErrorDuplicateCheck = async (commitRequestId, hash) => {
+  const table = TABLE_NAMES.fxTransferErrorDuplicateCheck
+  const queryName = `${table}_saveFxTransferErrorDuplicateCheck`
+  return saveCommitRequestIdAndHash({ commitRequestId, hash, table, queryName })
+}
+
+/**
+ * @function getFxTransferFulfilmentDuplicateCheck
+ *
+ * @async
+ * @description This retrieves the fxTransferFulfilmentDuplicateCheck table record if present
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ *
+ * @returns {object} - Returns the record from fxTransferFulfilmentDuplicateCheck table, or throws an error if failed
+ */
+const getFxTransferFulfilmentDuplicateCheck = async (commitRequestId) => {
+  const table = TABLE_NAMES.fxTransferFulfilmentDuplicateCheck
+  const queryName = `${table}_getFxTransferFulfilmentDuplicateCheck`
+  return getOneByCommitRequestId({ commitRequestId, table, queryName })
+}
+
+/**
+ * @function saveFxTransferFulfilmentDuplicateCheck
+ *
+ * @async
+ * @description This inserts a record into fxTransferFulfilmentDuplicateCheck table
+ *
+ * @param {string} commitRequestId - the fxTransfer commitRequestId
+ * @param {string} hash - the hash of the fxTransfer request payload
+ *
+ * @returns {integer} - Returns the database id of the inserted row, or throws an error if failed
+ */
+const saveFxTransferFulfilmentDuplicateCheck = async (commitRequestId, hash) => {
+  const table = TABLE_NAMES.fxTransferFulfilmentDuplicateCheck
+  const queryName = `${table}_saveFxTransferFulfilmentDuplicateCheck`
+  return saveCommitRequestIdAndHash({ commitRequestId, hash, table, queryName })
+}
+
+module.exports = {
+  getFxTransferDuplicateCheck,
+  saveFxTransferDuplicateCheck,
+
+  getFxTransferErrorDuplicateCheck,
+  saveFxTransferErrorDuplicateCheck,
+
+  getFxTransferFulfilmentDuplicateCheck,
+  saveFxTransferFulfilmentDuplicateCheck
+}