chore: debounce build all tokens call

Author: saledjenic

src/app_service/service/general/debouncer.nim

@@ -1,5 +1,6 @@
 import nimqml, os
 
+import universal_container
 import app/core/tasks/[qt, threadpool]
 
 
@@ -8,22 +9,40 @@ include app_service/common/async_tasks
 QtObject:
   type Debouncer* = ref object of QObject
     threadpool: ThreadPool
-    callback: proc()
+    callback0: proc()
+    callback1Wrapper: proc()
+    callback2Wrapper: proc()
     delay: int
     checkInterval: int
     remaining: int
 
+    params: Container
+
 
   proc delete*(self: Debouncer)
-  proc newDebouncer*(threadpool: ThreadPool, delayMs: int, checkIntervalMs: int, callback: proc()): Debouncer =
+  proc newDebouncer*(threadpool: ThreadPool, delayMs: int, checkIntervalMs: int): Debouncer =
     new(result, delete)
     result.QObject.setup
     if checkIntervalMs > delayMs:
       raise newException(ValueError, "checkIntervalMs must be less than delayMs")
     result.threadpool = threadpool
-    result.callback = callback
     result.delay = delayMs
     result.checkInterval = checkIntervalMs
+    result.params = newContainer()
+
+  proc registerCall0*(self: Debouncer, callback: proc()) =
+    self.callback0 = callback
+
+  proc registerCall1*[T1](self: Debouncer, callback: proc(p1: T1)) =
+    self.callback1Wrapper = proc() =
+      let param0 = getValueAtPosition[T1](self.params, 0)
+      callback(param0)
+
+  proc registerCall2*[T1, T2](self: Debouncer, callback: proc(p1: T1, p2: T2)) =
+    self.callback2Wrapper = proc() =
+      let param0 = getValueAtPosition[T1](self.params, 0)
+      let param1 = getValueAtPosition[T2](self.params, 1)
+      callback(param0, param1)
 
   proc runTimer*(self: Debouncer) =
     let arg = TimerTaskArg(
@@ -37,15 +56,57 @@ QtObject:
   proc onTimeout(self: Debouncer, response: string) {.slot.} =
     self.remaining = self.remaining - self.checkInterval
     if self.remaining <= 0:
-      self.callback()
+      if not self.callback0.isNil:
+        self.callback0()
+      elif not self.callback1Wrapper.isNil:
+        self.callback1Wrapper()
+      elif not self.callback2Wrapper.isNil:
+        self.callback2Wrapper()
     else:
       self.runTimer()
 
   proc call*(self: Debouncer) =
     let busy = self.remaining > 0
     if busy:
       return
+    self.params.clear()
+    self.remaining = self.delay
+    self.runTimer()
 
+  proc call*[T1](self: Debouncer, param0: T1) =
+    let busy = self.remaining > 0
+    if busy:
+      return
+    self.params.clear()
+    self.params.add(param0)
+    self.remaining = self.delay
+    self.runTimer()
+
+  proc call*[T1, T2](self: Debouncer, param0: T1, param1: T2) =
+    let busy = self.remaining > 0
+    if busy:
+      ## params check, while the call is waiting to be called
+      ## TODO: if needed we can add the queue of pending params to be called after the current call is completed
+      ##
+      ## FOR NOW: since the only usage is for buildAllTokens, we add ONLY those accounts (which is the first param (on position 0))
+      ## to list of accounts if they are not in the list yet.
+      var currentAccounts = getValueAtPosition[T1](self.params, 0) # refers to accounts of the `buildAllTokens` call
+      let forceRefresh = getValueAtPosition[T2](self.params, 1) # refers to forceRefresh of the `buildAllTokens` call
+
+      var update = false
+      for account in param0:
+        if not currentAccounts.contains(account):
+          update = true
+          currentAccounts.add(account)
+
+      if update:
+        self.params.clear()
+        self.params.add(currentAccounts)
+        self.params.add(forceRefresh)
+      return
+    self.params.clear()
+    self.params.add(param0)
+    self.params.add(param1)
     self.remaining = self.delay
     self.runTimer()
 

src/app_service/service/general/universal_container.nim

@@ -0,0 +1,88 @@
+
+type
+  ItemKind* = enum
+    vkInt, vkString, vkFloat, vkBool, vkSeqInt, vkSeqString
+
+  Item* = object
+    case kind: ItemKind
+    of vkInt: intVal: int
+    of vkString: strVal: string
+    of vkFloat: floatVal: float
+    of vkBool: boolVal: bool
+    of vkSeqInt: seqIntVal: seq[int]
+    of vkSeqString: seqStringVal: seq[string]
+
+  Container* = ref object
+    items: seq[Item]
+
+proc newContainer*(): Container =
+  return new(Container)
+
+proc clear*(self: Container) =
+  self.items = @[]
+
+proc add*(self: Container, item: int) =
+  self.items.add(Item(kind: vkInt, intVal: item))
+
+proc add*(self: Container, item: string) =
+  self.items.add(Item(kind: vkString, strVal: item))
+
+proc add*(self: Container, item: float) =
+  self.items.add(Item(kind: vkFloat, floatVal: item))
+
+proc add*(self: Container, item: bool) =
+  self.items.add(Item(kind: vkBool, boolVal: item))
+
+proc add*(self: Container, item: seq[int]) =
+  self.items.add(Item(kind: vkSeqInt, seqIntVal: item))
+
+proc add*(self: Container, item: seq[string]) =
+  self.items.add(Item(kind: vkSeqString, seqStringVal: item))
+
+proc getInt(v: Item): int =
+  assert v.kind == vkInt, "Expected int but got " & $v.kind
+  return v.intVal
+
+proc getStr(v: Item): string =
+  assert v.kind == vkString, "Expected string but got " & $v.kind
+  return v.strVal
+
+proc getFloat(v: Item): float =
+  assert v.kind == vkFloat, "Expected float but got " & $v.kind
+  return v.floatVal
+
+proc getBool(v: Item): bool =
+  assert v.kind == vkBool, "Expected bool but got " & $v.kind
+  return v.boolVal
+
+proc getSeqInt(v: Item): seq[int] =
+  assert v.kind == vkSeqInt, "Expected seq[int] but got " & $v.kind
+  return v.seqIntVal
+
+proc getSeqString(v: Item): seq[string] =
+  assert v.kind == vkSeqString, "Expected seq[string] but got " & $v.kind
+  return v.seqStringVal
+
+proc extract*[T](v: Item): T =
+  when T is int:
+    return v.getInt()
+  elif T is string:
+    return v.getStr()
+  elif T is float:
+    return v.getFloat()
+  elif T is bool:
+    return v.getBool()
+  elif T is seq[int]:
+    return v.getSeqInt()
+  elif T is seq[string]:
+    return v.getSeqString()
+  else:
+    raise "Unsupported type for extraction"
+
+proc getItemAtPosition*(self: Container, position: int): Item =
+  assert position >= 0 and position < self.items.len
+  return self.items[position]
+
+proc getValueAtPosition*[T](self: Container, position: int): T =
+  let item = self.getItemAtPosition(position)
+  return extract[T](item)

src/app_service/service/token/service_main.nim

@@ -37,9 +37,9 @@ proc init*(self: Service) =
     # this is the delay before the first call to the callback, this is an action that doesn't need to be called immediately, but it's pretty expensive in terms of time/performances
     # for example `wallet-tick-reload` event is emitted for every single chain-account pair, and at the app start can be more such signals received from the statusgo side if the balance have changed.
     # Means it the app contains more accounts the likelihood of having more `wallet-tick-reload` signals is higher, so we need to delay the rebuildMarketData call to avoid unnecessary calls.
-    delayMs = 3000,
-    checkIntervalMs = 500,
-    callback = proc() = self.rebuildMarketDataInternal())
+    delayMs = 1500,
+    checkIntervalMs = 500)
+  self.rebuildMarketDataDebouncer.registerCall0(callback = proc() = self.rebuildMarketDataInternal())
 
   self.events.on(SignalType.Wallet.event) do(e:Args):
     var data = WalletSignal(e)

src/app_service/service/wallet_account/service.nim

@@ -4,6 +4,7 @@ import web3/eth_api_types
 
 import app/global/global_singleton
 
+import app_service/service/general/debouncer as debouncer_service
 import app_service/service/settings/service as settings_service
 import app_service/service/accounts/service as accounts_service
 import app_service/service/token/service as token_service
@@ -48,11 +49,11 @@ QtObject:
     keypairs: Table[string, KeypairDto] ## [keyUid, KeypairDto]
     groupedAssets: seq[AssetGroupItem]
     hasBalanceCache: bool
-    fetchingBalancesInProgress: bool
-    addressesWaitingForBalanceToFetch: seq[string]
+    buildTokensDebouncer: debouncer_service.Debouncer
 
   # Forward declaration
   proc buildAllTokens*(self: Service, accounts: seq[string], forceRefresh: bool)
+  proc buildAllTokensInternal(self: Service, accounts: seq[string], forceRefresh: bool)
   proc handleWalletAccount(self: Service, account: WalletAccountDto, notify: bool = true)
   proc handleKeypair(self: Service, keypair: KeypairDto)
   proc updateAccountsPositions(self: Service)

src/app_service/service/wallet_account/service_account.nim

@@ -138,6 +138,15 @@ proc startWallet(self: Service) =
 
 proc init*(self: Service) =
   try:
+    self.buildTokensDebouncer = debouncer_service.newDebouncer(
+      self.threadpool,
+      # this is the delay before the first call to the callback, this is an action that doesn't need to be called immediately, but it's pretty expensive in terms of time/performances
+      # for example `wallet-tick-reload` event is emitted for every single chain-account pair, and at the app start can be more such signals received from the statusgo side if the balance have changed.
+      # Means it the app contains more accounts the likelihood of having more `wallet-tick-reload` signals is higher, so we need to delay the rebuildMarketData call to avoid unnecessary calls.
+      delayMs = 3000,
+      checkIntervalMs = 1000)
+    self.buildTokensDebouncer.registerCall2(callback = proc(accounts: seq[string], forceRefresh: bool) = self.buildAllTokensInternal(accounts, forceRefresh))
+
     var addressesToGetENSName: seq[string] = @[]
     let chainId = self.networkService.getAppNetwork().chainId
     let woAccounts = getWatchOnlyAccountsFromDb()

src/app_service/service/wallet_account/service_token.nim

@@ -5,19 +5,13 @@ proc onAllTokensBuilt(self: Service, response: string) {.slot.} =
   var accountAddresses: seq[string] = @[]
   var groupedAssets: seq[AssetGroupItem] = @[]
   defer:
-    self.fetchingBalancesInProgress = false
     let timestamp = getTime().toUnix()
     self.events.emit(SIGNAL_WALLET_ACCOUNT_TOKENS_REBUILT, TokensPerAccountArgs(
       accountAddresses:accountAddresses,
       assets: groupedAssets,
       timestamp: timestamp
     ))
 
-    if self.addressesWaitingForBalanceToFetch.len > 0:
-      let addressesToFetch = self.addressesWaitingForBalanceToFetch
-      self.addressesWaitingForBalanceToFetch = @[]
-      self.buildAllTokens(addressesToFetch, forceRefresh = true)
-
   try:
     let responseObj = response.parseJson
     var resultObj: JsonNode
@@ -91,17 +85,11 @@ proc onAllTokensBuilt(self: Service, response: string) {.slot.} =
   except Exception as e:
     error "error: ", procName="onAllTokensBuilt", errName = e.name, errDesription = e.msg
 
-proc buildAllTokens*(self: Service, accounts: seq[string], forceRefresh: bool) =
+proc buildAllTokensInternal(self: Service, accounts: seq[string], forceRefresh: bool) =
   if not main_constants.WALLET_ENABLED or
     accounts.len == 0:
       return
 
-  if self.fetchingBalancesInProgress:
-    self.addressesWaitingForBalanceToFetch.add(accounts)
-    return
-
-  self.fetchingBalancesInProgress = true
-
   # set assetsLoading to true as the tokens are being loaded
   for waddress in accounts:
     self.updateAssetsLoadingState(waddress, true)
@@ -116,6 +104,9 @@ proc buildAllTokens*(self: Service, accounts: seq[string], forceRefresh: bool) =
   )
   self.threadpool.start(arg)
 
+proc buildAllTokens*(self: Service, accounts: seq[string], forceRefresh: bool) =
+  self.buildTokensDebouncer.call(accounts, forceRefresh)
+
 # Returns the total currency balance for the given wallet accounts and chain ids
 proc getTotalCurrencyBalance*(self: Service, walletAccounts: seq[string], chainIds: seq[int]): float64 =
   var totalBalance: float64 = 0.0