Added cache for balances

Author: Patrick Banks

src/trader/apis/binance.ts

@@ -13,7 +13,11 @@ const sandbox = process.env.NODE_ENV === "staging"
 
 // Used to track when the last buy / sell / borrow / repay occurred to allow for balance sync
 // This should always be updated before and after the transaction is executed on Binance
-let lastChangeTime = 0
+const lastChangeTimes: Dictionary<Number> = {}
+
+// Cached balances for better performance, especially for the fall back wallet that is not used often
+const balances: Dictionary<ccxt.Balances> = {}
+const balanceTimestamps: Dictionary<Number> = {}
 
 if (process.env.NODE_ENV !== "test") {
     binanceClient = new ccxt.binance({
@@ -56,13 +60,24 @@ export async function fetchBalance(type: WalletType): Promise<ccxt.Balances> {
     // Hack, as you can't look up margin balances on testnet (NotSupported error), but this is only for testing
     if (sandbox) type = WalletType.SPOT
 
+    // If a wallet has been touched then it will already be cleared from the cache
+    if (balances.hasOwnProperty(type)) {
+        // Check that the cached balances are less than 24 hours old
+        const elapsed = Date.now() - (balanceTimestamps[type] as number)
+        if (elapsed >=0 && elapsed < 24 * 60 * 60 * 1000) {
+            // Use the cache
+            logger.debug(`Using cached ${type} balances.`)
+            return balances[type]
+        }
+    }
+
     // According to Binance support it can take from 1 to 10 seconds for the balances to sync after making a trade
     // Therefore if there are a lot of signals happening at the same time it can give the wrong results, so we're just going to slow it down a bit
     // The recommended subscribing to the web socket for user updates, but that would be more work, and hopefully this won't happen too often
     // Just in case another trade happens while waiting, check again after waiting
-    while (timeSinceLastChange() < env().BALANCE_SYNC_DELAY) {
+    while (timeSinceLastChange(type) < env().BALANCE_SYNC_DELAY) {
         // Add an extra 10ms just so we don't go around again
-        const delay = (env().BALANCE_SYNC_DELAY - timeSinceLastChange()) + 10
+        const delay = (env().BALANCE_SYNC_DELAY - timeSinceLastChange(type)) + 10
 
         logger.debug(`Waiting ${delay} milliseconds to allow balances to synchronise.`)
 
@@ -112,65 +127,83 @@ export function getMarginLoans(marginBalance: ccxt.Balances): Dictionary<Loan> {
     }
 }
 
-// Calculate how much time has elapsed since the balances were changed in Binance
-function timeSinceLastChange(): number {
+// Calculate how much time has elapsed since the balances were changed in Binance for the specified wallet
+function timeSinceLastChange(type: WalletType): number {
     const now = Date.now()
 
+    // Initialise
+    if (!lastChangeTimes.hasOwnProperty(type)) lastChangeTimes[type] = 0
+
     // Maybe a time update, so we can't trust it anymore
-    if (now < lastChangeTime) lastChangeTime = 0
+    if (now < lastChangeTimes[type]) lastChangeTimes[type] = 0
 
-    return now - lastChangeTime
+    return now - (lastChangeTimes[type] as number)
 }
 
+// Update the time of last change and reset the balances for a specified wallet
+function balanceChanged(type: WalletType) {
+    lastChangeTimes[type] = Date.now()
+
+    if (balances.hasOwnProperty(type)) {
+        delete balances[type]
+        delete balanceTimestamps[type]
+    }
+}
+
+// Places a market order for a symbol pair on the specified wallet
 export async function createMarketOrder(
     symbol: string,
     side: "buy" | "sell",
     amount: BigNumber,
-    price?: BigNumber,
-    params?: ccxt.Params
+    walletType: WalletType,
+    price?: BigNumber
 ): Promise<ccxt.Order> {
     if (!binanceClient) return Promise.reject(logBinanceUndefined)
-    lastChangeTime = Date.now()
+    balanceChanged(walletType)
     return binanceClient.createMarketOrder(
         symbol,
         side,
         amount.toNumber(),
         price?.toNumber(),
-        params
+        {
+            type: walletType
+        }
     ).then((result) => {
-        lastChangeTime = Date.now()
+        balanceChanged(walletType)
         return result
     })
 }
 
+// Borrows an asset on the cross margin wallet
 export async function marginBorrow(
     asset: string,
     amount: BigNumber
 ): Promise<LoanTransaction> {
     if (!binanceClient) return Promise.reject(logBinanceUndefined)
-    lastChangeTime = Date.now()
+    balanceChanged(WalletType.MARGIN)
     return binanceClient.sapiPostMarginLoan({
         asset,
         //isIsolated: 'FALSE', // "FALSE" for cross margin borrow without specification of a symbol.
         amount: amount.toFixed()
     }).then((result: LoanTransaction) => {
-        lastChangeTime = Date.now()
+        balanceChanged(WalletType.MARGIN)
         return result
     })
 }
 
+// Repays an asset on the cross margin wallet
 export async function marginRepay(
     asset: string,
     amount: BigNumber
 ): Promise<LoanTransaction> {
     if (!binanceClient) return Promise.reject(logBinanceUndefined)
-    lastChangeTime = Date.now()
+    balanceChanged(WalletType.MARGIN)
     return binanceClient.sapiPostMarginRepay({
         asset,
         //isIsolated: 'FALSE', // "FALSE" for cross margin repay without specification of a symbol.
         amount: amount.toFixed()
     }).then((result: LoanTransaction) => {
-        lastChangeTime = Date.now()
+        balanceChanged(WalletType.MARGIN)
         return result
     })
 }

src/trader/trader.ts

@@ -1039,10 +1039,7 @@ async function executeTradeAction(
                     symbolAsset,
                     action,
                     quantity,
-                    undefined,
-                    {
-                        type: tradeOpen.wallet!,
-                    }
+                    tradeOpen.wallet!
                 )
             :
                 createVirtualOrder(
@@ -2413,7 +2410,7 @@ async function sellEverything(base: string, fraction: number) {
         if (market && balances[quote].free) {
             const qty = balances[quote].free * fraction
             logger.debug(`Selling ${qty} ${quote}.`)
-            logger.debug(await createMarketOrder(quote + "/" + base, "sell", new BigNumber(qty)).then(order => `${order.status} ${order.cost}`).catch(e => e.name))
+            logger.debug(await createMarketOrder(quote + "/" + base, "sell", new BigNumber(qty), WalletType.SPOT).then(order => `${order.status} ${order.cost}`).catch(e => e.name))
         }
     }
     await fetchBalance(WalletType.SPOT)