Live balances, transactions and prices

package.json

@@ -56,6 +56,9 @@
     "@rsksmart/rsk-utils": "^1.1.0",
     "axios": "^0.22.0",
     "dotenv": "^10.0.0",
-    "express": "^4.17.1"
+    "express": "^4.17.1",
+    "node-cache": "^5.1.2",
+    "socket.io": "^4.4.0",
+    "socket.io-client": "^2.4.0"
   }
 }

src/api/index.ts

@@ -3,7 +3,9 @@ import { RSKExplorerAPI } from '../rskExplorerApi'
 import { CoinMarketCapAPI } from '../coinmatketcap'
 import { registeredDapps as _registeredDapps } from '../registered_dapps'
 import { PricesQueryParams } from './types'
-import { validatePricesRequest } from '../coinmatketcap/validations'
+import { isConvertSupported, isTokenSupported } from '../coinmatketcap/validations'
+import NodeCache from 'node-cache'
+import { findInCache } from '../coinmatketcap/cache'
 
 const responseJsonOk = (res: Response) => res.status(200).json.bind(res)
 
@@ -22,11 +24,13 @@ type APIOptions = {
   rskExplorerApi: RSKExplorerAPI
   coinMarketCapApi: CoinMarketCapAPI
   registeredDapps: typeof _registeredDapps
+  cache: NodeCache
   logger?: any
+  chainId: number
 }
 
 export const setupApi = (app: Application, {
-  rskExplorerApi, coinMarketCapApi, registeredDapps, logger = { log: () => {}, error: () => {} }
+  rskExplorerApi, coinMarketCapApi, registeredDapps, cache, logger = { log: () => {}, error: () => {} }, chainId
 }: APIOptions) => {
   const makeRequest = makeRequestFactory(logger)
 
@@ -57,10 +61,27 @@ export const setupApi = (app: Application, {
     '/price',
     async (req: Request<{}, {}, {}, PricesQueryParams>, res: Response) => makeRequest(
       req, res, () => {
-        const addresses = req.query.addresses.split(',')
+        let addresses = req.query.addresses.split(',').filter((address) => isTokenSupported(address, chainId))
         const convert = req.query.convert
-        validatePricesRequest(addresses, convert)
-        return coinMarketCapApi.getQuotesLatest({ addresses, convert })
+
+        const isAddressesEmpty = addresses.length === 0
+        if (isAddressesEmpty) return ({})
+
+        if (!isConvertSupported(convert)) throw new Error('Convert not supported')
+
+        const pricesInCache = findInCache(addresses, cache)
+        addresses = addresses.filter(address => !Object.keys(pricesInCache).includes(address))
+        let prices = {}
+        if (addresses.length) {
+          prices = coinMarketCapApi.getQuotesLatest({ addresses, convert })
+        }
+        return Promise.all([pricesInCache, prices]).then(values => {
+          Object.keys(values[1]).forEach(address => cache.set(address, { [address]: values[1][address] }, 60))
+          return {
+            ...values[0],
+            ...values[1]
+          }
+        })
       }
     )
   )

src/coinmatketcap/cache.ts

@@ -0,0 +1,15 @@
+import NodeCache from 'node-cache'
+import { Prices } from '../api/types'
+
+export const findInCache = (addresses: string[], cache: NodeCache): Prices => {
+  let response = {}
+  addresses.forEach(address => {
+    if (cache.get(address)) {
+      response = {
+        ...response,
+        ...cache.get(address)
+      }
+    }
+  })
+  return response
+}

src/coinmatketcap/index.ts

@@ -1,20 +1,20 @@
 import _axios, { AxiosResponse } from 'axios'
 import { ICoinMarketCapQuoteParams, ICoinMarketCapQuoteResponse } from './types'
 import { addressToCoinmarketcapId } from './support'
+import { isTokenSupported } from '../coinmatketcap/validations'
 import { Prices } from '../api/types'
 
 type PricesQueryParams = { addresses: string[], convert: string }
 
-const coinmarketcapIdToAddress = Object.keys(addressToCoinmarketcapId)
-  .reduce((p, c) => ({ ...p, [addressToCoinmarketcapId[c]]: c }), {})
-
-const fromQueryParamsToRequestParams = (params: PricesQueryParams): ICoinMarketCapQuoteParams => ({
-  id: params.addresses.map(address => addressToCoinmarketcapId[address]).join(','),
+const fromQueryParamsToRequestParams = (params: PricesQueryParams, chaindId: number): ICoinMarketCapQuoteParams => ({
+  id: params.addresses
+    .filter((address) => isTokenSupported(address, chaindId))
+    .map(address => addressToCoinmarketcapId[chaindId][address]).join(','),
   convert: params.convert
 })
 
 const fromQuotesResponseToPrices =
-  (convert: string) =>
+  (convert: string, coinmarketcapIdToAddress: Record<string, string>) =>
     (response: AxiosResponse<ICoinMarketCapQuoteResponse>) =>
       Object.keys(response.data.data).reduce<Prices>((p, c) => ({
         ...p,
@@ -28,23 +28,29 @@ export class CoinMarketCapAPI {
   headers: { 'X-CMC_PRO_API_KEY': string }
   baseURL: string
   axios: typeof _axios
+  chainId: number
+  coinmarketcapIdToAddress: Record<string, string>
 
   constructor (
     url: string,
     version: string,
     apiKey: string,
-    axios: typeof _axios
+    axios: typeof _axios,
+    chainId: number
   ) {
     this.baseURL = `${url}/${version}`
     this.headers = {
       'X-CMC_PRO_API_KEY': apiKey
     }
     this.axios = axios
+    this.chainId = chainId
+    this.coinmarketcapIdToAddress = Object.keys(addressToCoinmarketcapId[chainId])
+      .reduce((p, c) => ({ ...p, [addressToCoinmarketcapId[chainId][c]]: c }), {})
   }
 
   getQuotesLatest = (queryParams: PricesQueryParams): Promise<Prices> => this.axios.get<ICoinMarketCapQuoteResponse>(
     `${this.baseURL}/cryptocurrency/quotes/latest`, {
       headers: this.headers,
-      params: fromQueryParamsToRequestParams(queryParams)
-    }).then(fromQuotesResponseToPrices(queryParams.convert!))
+      params: fromQueryParamsToRequestParams(queryParams, this.chainId)
+    }).then(fromQuotesResponseToPrices(queryParams.convert!, this.coinmarketcapIdToAddress))
 }

src/coinmatketcap/support.ts

@@ -1,6 +1,17 @@
 export const addressToCoinmarketcapId = {
-  '0x0000000000000000000000000000000000000000': '3626', // RBTC
-  '0x2acc95758f8b5f583470ba265eb685a8f45fc9d5': '3701'
+  30: {
+    '0x0000000000000000000000000000000000000000': '3626', // RBTC
+    '0x2acc95758f8b5f583470ba265eb685a8f45fc9d5': '3701', // RIF
+    '0xef213441a85df4d7acbdae0cf78004e1e486bb96': '825', // rUSDT
+    '0x4991516df6053121121274397a8c1dad608bc95b': '7785', // rBUND
+    '0xefc78fc7d48b64958315949279ba181c2114abbd': '8669' // SOV
+  },
+  31: {
+    '0x0000000000000000000000000000000000000000': '3626', // RBTC
+    '0x19f64674d8a5b4e652319f5e239efd3bc969a1fe': '3701', // tRIF
+    '0x4cfe225ce54c6609a525768b13f7d87432358c57': '825', // rKovUSDT
+    '0xe95afdfec031f7b9cd942eb7e60f053fb605dfcd': '7785' // rKovBUND
+  }
 }
 
 export const supportedFiat = ['USD']

src/coinmatketcap/validations.ts

@@ -1,9 +1,9 @@
 import { addressToCoinmarketcapId, supportedFiat } from './support'
 
-const isTokenSupported = (address: string) => addressToCoinmarketcapId[address] !== undefined
-const isConvertSupported = (convert: string) => supportedFiat.includes(convert)
+export const isTokenSupported = (address: string, chainId: number) => addressToCoinmarketcapId[chainId][address] !== undefined
+export const isConvertSupported = (convert: string) => supportedFiat.includes(convert)
 
-export const validatePricesRequest = (addresses: string[], convert: string) => {
-  addresses.forEach(address => { if (!isTokenSupported(address)) throw new Error('Token address not supported') })
+export const validatePricesRequest = (addresses: string[], convert: string, chainId: number) => {
+  addresses.forEach(address => { if (!isTokenSupported(address, chainId)) throw new Error('Token address not supported') })
   if (!isConvertSupported(convert)) throw new Error('Convert not supported')
 }

src/index.ts

@@ -6,6 +6,12 @@ import { CoinMarketCapAPI } from './coinmatketcap'
 import { RSKExplorerAPI } from './rskExplorerApi'
 import { registeredDapps } from './registered_dapps'
 import { setupApi } from './api'
+import { Server } from 'socket.io'
+import NodeCache from 'node-cache'
+import http from 'http'
+import pushNewBalances from './subscriptions/pushNewBalances'
+import pushNewPrices from './subscriptions/pushNewPrices'
+import pushNewTransactions from './subscriptions/pushNewTransactions'
 
 const environment = {
   // TODO: remove these defaults
@@ -16,21 +22,63 @@ const environment = {
   CHAIN_ID: parseInt(process.env.CHAIN_ID as string) || 31,
   COIN_MARKET_CAP_URL: process.env.COIN_MARKET_CAP_URL as string || 'https://pro-api.coinmarketcap.com',
   COIN_MARKET_CAP_VERSION: process.env.COIN_MARKET_CAP_VERSION as string || 'v1',
-  COIN_MARKET_CAP_KEY: process.env.COIN_MARKET_CAP_KEY! as string
+  COIN_MARKET_CAP_KEY: process.env.COIN_MARKET_CAP_KEY! as string,
+  DEFAULT_CONVERT_FIAT: process.env.DEFAULT_CONVERT_FIAT! as string
 }
 
-const app = express()
-
 const rskExplorerApi = new RSKExplorerAPI(environment.API_URL, environment.CHAIN_ID, axios)
-const coinMarketCapApi = new CoinMarketCapAPI(environment.COIN_MARKET_CAP_URL, environment.COIN_MARKET_CAP_VERSION, environment.COIN_MARKET_CAP_KEY, axios)
+const coinMarketCapApi = new CoinMarketCapAPI(
+  environment.COIN_MARKET_CAP_URL,
+  environment.COIN_MARKET_CAP_VERSION,
+  environment.COIN_MARKET_CAP_KEY,
+  axios,
+  environment.CHAIN_ID
+)
 
+const app = express()
+const cache = new NodeCache()
 setupApi(app, {
   rskExplorerApi,
   coinMarketCapApi,
   registeredDapps,
-  logger: console
+  cache,
+  logger: console,
+  chainId: environment.CHAIN_ID
+})
+
+const server = http.createServer(app)
+const io = new Server(server, {
+  // cors: {
+  //   origin: 'https://amritb.github.io'
+  // },
+  path: '/ws'
+})
+
+io.on('connection', (socket) => {
+  console.log('new user connected')
+
+  socket.on('subscribe', ({ address }: { address: string }) => {
+    console.log('new subscription with address: ', address)
+
+    const stopPushingNewBalances = pushNewBalances(socket, rskExplorerApi, address)
+    const stopPushingNewTransactions = pushNewTransactions(socket, address)
+    const stopPushingNewPrices = pushNewPrices(
+      socket,
+      rskExplorerApi,
+      coinMarketCapApi,
+      address,
+      environment.DEFAULT_CONVERT_FIAT,
+      environment.CHAIN_ID
+    )
+
+    socket.on('disconnect', () => {
+      stopPushingNewBalances()
+      stopPushingNewTransactions()
+      stopPushingNewPrices()
+    })
+  })
 })
 
-app.listen(environment.PORT, () => {
+server.listen(environment.PORT, () => {
   console.log(`RIF Wallet services running on port ${environment.PORT}.`)
 })

src/subscriptions/pushNewBalances.ts

@@ -0,0 +1,51 @@
+import { Socket } from 'socket.io'
+import { DefaultEventsMap } from 'socket.io/dist/typed-events'
+import { RSKExplorerAPI } from '../rskExplorerApi/index'
+
+interface ISentBalances {
+  [address: string]: {
+    [tokenAddress: string]: string
+  }
+}
+
+const EXECUTION_INTERVAL = 60000
+
+const sentBalances: ISentBalances = {}
+
+const pushNewBalances = (
+  socket: Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>,
+  api: RSKExplorerAPI,
+  address: string
+) => {
+  const execute = executeFactory(socket, api, address)
+
+  execute()
+
+  const timer = setInterval(execute, EXECUTION_INTERVAL)
+
+  return () => {
+    clearInterval(timer)
+    sentBalances[address] = {}
+  }
+}
+
+const executeFactory = (
+  socket: Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>,
+  api: RSKExplorerAPI,
+  address: string
+) => async () => {
+  if (!sentBalances[address]) {
+    sentBalances[address] = {}
+  }
+
+  const tokens = await api.getTokensByAddress(address.toLowerCase())
+
+  for (const token of tokens) {
+    if (sentBalances[address][token.contractAddress] !== token.balance) {
+      sentBalances[address][token.contractAddress] = token.balance
+      socket.emit('change', { type: 'newBalance', payload: token })
+    }
+  }
+}
+
+export default pushNewBalances

src/subscriptions/pushNewPrices.ts

@@ -0,0 +1,49 @@
+import { CoinMarketCapAPI } from '../coinmatketcap'
+import { DefaultEventsMap } from 'socket.io/dist/typed-events'
+import { RSKExplorerAPI } from '../rskExplorerApi/index'
+import { Socket } from 'socket.io'
+import { isTokenSupported } from '../coinmatketcap/validations'
+
+const EXECUTION_INTERVAL = 60000
+
+const pushNewPrices = (socket: Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>,
+  api: RSKExplorerAPI,
+  cmc: CoinMarketCapAPI,
+  address: string,
+  convert: string,
+  chainId: number
+) => {
+  const execute = getPricesByToken(socket, api, cmc, address, convert, chainId)
+
+  execute()
+
+  const timer = setInterval(execute, EXECUTION_INTERVAL)
+
+  return () => {
+    clearInterval(timer)
+  }
+}
+
+const getPricesByToken = (
+  socket: Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>,
+  api: RSKExplorerAPI,
+  cmc: CoinMarketCapAPI,
+  address: string,
+  convert: string,
+  chainId: number) => async () => {
+  const RBTC = '0x0000000000000000000000000000000000000000'
+  let prices = {}
+  const addresses = [RBTC, ...(await api.getTokensByAddress(address.toLowerCase()))
+    .map(token => token.contractAddress.toLocaleLowerCase())
+    .filter(token => isTokenSupported(token, chainId))]
+
+  const isAddressesEmpty = addresses.length === 0
+
+  if (!isAddressesEmpty) {
+    prices = await cmc.getQuotesLatest({ addresses, convert })
+  }
+
+  socket.emit('change', { type: 'newPrice', payload: prices })
+}
+
+export default pushNewPrices