chore(@desktop/wallet): Wallet: explore streamlining "all tokens mode…

…l" spread across different sections

closes #12424

src/app/modules/main/communities/module.nim

@@ -589,7 +589,7 @@ proc buildTokensAndCollectiblesFromWallet(self: Module) =
       key = token.symbol,
       name = token.name,
       symbol = token.symbol,
-      color = token.color,
+      color = "",
       communityId = token.communityId,
       image = "",
       category = ord(TokenListItemCategory.General),

src/app/modules/main/module.nim

@@ -252,7 +252,7 @@ method delete*[T](self: Module[T]) =
   self.view.delete
   self.viewVariant.delete
 
-proc createTokenItem[T](self: Module[T], tokenDto: CommunityTokenDto) : TokenItem =
+proc createTokenItem[T](self: Module[T], tokenDto: CommunityTokenDto) : token_item.TokenItem =
   let network = self.controller.getNetwork(tokenDto.chainId)
   let tokenOwners = self.controller.getCommunityTokenOwners(tokenDto.communityId, tokenDto.chainId, tokenDto.address)
   let ownerAddressName = if len(tokenDto.deployer) > 0: self.controller.getCommunityTokenOwnerName(tokenDto.deployer) else: ""
@@ -262,7 +262,7 @@ proc createTokenItem[T](self: Module[T], tokenDto: CommunityTokenDto) : TokenIte
   let destructedAmount = self.controller.getRemoteDestructedAmount(tokenDto.chainId, tokenDto.address)
   result = initTokenItem(tokenDto, network, tokenOwners, ownerAddressName, burnState, remoteDestructedAddresses, remainingSupply, destructedAmount)
 
-proc createTokenItemImproved[T](self: Module[T], tokenDto: CommunityTokenDto, communityTokenJsonItems: JsonNode) : TokenItem =
+proc createTokenItemImproved[T](self: Module[T], tokenDto: CommunityTokenDto, communityTokenJsonItems: JsonNode) : token_item.TokenItem =
   # These 3 values come from local caches so they can be done sync
   let network = self.controller.getNetwork(tokenDto.chainId)
   let tokenOwners = self.controller.getCommunityTokenOwners(tokenDto.communityId, tokenDto.chainId, tokenDto.address)

src/app/modules/main/profile_section/ens_usernames/controller.nim

@@ -155,10 +155,13 @@ proc getPrice*(self: Controller, crypto: string, fiat: string): float64 =
 proc getStatusToken*(self: Controller): string =
   let token = self.ensService.getStatusToken()
 
+  if token == nil:
+    return $ %*{}
+
   let jsonObj = %* {
     "name": token.name,
     "symbol": token.symbol,
-    "address": token.addressAsString()
+    "address": token.address
   }
   return $jsonObj
 

src/app/modules/main/stickers/controller.nim

@@ -165,10 +165,13 @@ proc getChainIdForStickers*(self: Controller): int =
 proc getStatusToken*(self: Controller): string =
   let token = self.stickerService.getStatusToken()
 
+  if token == nil:
+    return $ %*{}
+
   let jsonObj = %* {
     "name": token.name,
     "symbol": token.symbol,
-    "address": token.addressAsString()
+    "address": token.address
   }
   return $jsonObj
 

src/app/modules/main/wallet_section/activity/controller.nim

@@ -18,6 +18,7 @@ import app/core/signals/types
 import backend/activity as backend_activity
 import backend/backend as backend
 
+import app_service/common/conversion
 import app_service/service/currency/service as currency_service
 import app_service/service/transaction/service as transaction_service
 import app_service/service/token/service as token_service
@@ -361,7 +362,7 @@ QtObject:
           assets.add(backend_activity.Token(
             tokenType: tokenType,
             chainId: backend_activity.ChainId(token.chainId),
-            address: some(token.address)
+            address: some(parseAddress(token.address))
           ))
 
     self.currentActivityFilter.assets = assets

src/app/modules/main/wallet_section/all_tokens/address_per_chain_model.nim

@@ -0,0 +1,55 @@
+import NimQml, Tables, strutils
+
+import ./io_interface
+
+type
+  ModelRole {.pure.} = enum
+    ChainId = UserRole + 1
+    Address
+
+QtObject:
+  type AddressPerChainModel* = ref object of QAbstractListModel
+    delegate: io_interface.TokenBySymbolModelDataSource
+    index: int
+
+  proc setup(self: AddressPerChainModel) =
+    self.QAbstractListModel.setup
+    self.index = 0
+
+  proc delete(self: AddressPerChainModel) =
+    self.QAbstractListModel.delete
+
+  proc newAddressPerChainModel*(delegate: io_interface.TokenBySymbolModelDataSource, index: int): AddressPerChainModel =
+    new(result, delete)
+    result.setup
+    result.delegate = delegate
+    result.index = index
+
+  method rowCount(self: AddressPerChainModel, index: QModelIndex = nil): int =
+    return self.delegate.getTokenBySymbolList()[self.index].addressPerChainId.len
+
+  proc countChanged(self: AddressPerChainModel) {.signal.}
+  proc getCount(self: AddressPerChainModel): int {.slot.} =
+    return self.rowCount()
+  QtProperty[int] count:
+    read = getCount
+    notify = countChanged
+
+  method roleNames(self: AddressPerChainModel): Table[int, string] =
+    {
+      ModelRole.ChainId.int:"chainId",
+      ModelRole.Address.int:"address",
+    }.toTable
+
+  method data(self: AddressPerChainModel, index: QModelIndex, role: int): QVariant =
+    if not index.isValid:
+      return
+    if index.row < 0 or index.row >= self.rowCount():
+      return
+    let item = self.delegate.getTokenBySymbolList()[self.index].addressPerChainId[index.row]
+    let enumRole = role.ModelRole
+    case enumRole:
+      of ModelRole.ChainId:
+        result = newQVariant(item.chainId)
+      of ModelRole.Address:
+        result = newQVariant(item.address)

src/app/modules/main/wallet_section/all_tokens/controller.nim

@@ -44,4 +44,13 @@ method getHistoricalDataForToken*(self: Controller, symbol: string, currency: st
   self.tokenService.getHistoricalDataForToken(symbol, currency, range)
 
 method fetchHistoricalBalanceForTokenAsJson*(self: Controller, address: string, tokenSymbol: string, currencySymbol: string, timeIntervalEnum: int) =
-  self.tokenService.fetchHistoricalBalanceForTokenAsJson(address, tokenSymbol, currencySymbol, BalanceHistoryTimeInterval(timeIntervalEnum))
+  self.tokenService.fetchHistoricalBalanceForTokenAsJson(address, tokenSymbol, currencySymbol, BalanceHistoryTimeInterval(timeIntervalEnum))
+
+proc getSourcesOfTokensList*(self: Controller): var seq[SupportedSourcesItem] =
+  return self.tokenService.getSourcesOfTokensList()
+
+proc getFlatTokensList*(self: Controller): var seq[TokenItem] =
+  return self.tokenService.getFlatTokensList()
+
+proc getTokenBySymbolList*(self: Controller): var seq[TokenBySymbolItem] =
+  return self.tokenService.getTokenBySymbolList()

src/app/modules/main/wallet_section/all_tokens/flat_tokens_model.nim

@@ -0,0 +1,116 @@
+import NimQml, Tables, strutils
+
+import ./io_interface
+
+const SOURCES_DELIMITER = ";"
+
+type
+  ModelRole {.pure.} = enum
+    # The key is built as a concatenation of chainId and address
+    # to create a unique key for each element in the flat tokens list
+    Key = UserRole + 1
+    Name
+    Symbol
+    # uniswap/status/custom seq[string]
+    # returned as a string as nim doesnt support returning a StringList
+    # using join api and semicolon (;) as a delimiter
+    Sources
+    ChainId
+    Address
+    Decimals
+    Image
+    # Native, Erc20, Erc721
+    Type
+    # only be valid if source is custom
+    CommunityId
+    # everything below should be lazy loaded
+    Description
+    # properties below this are optional and may not exist in case of community minted assets
+    # built from chainId and address using networks service
+    WebsiteUrl
+    MarketValues
+
+QtObject:
+  type FlatTokensModel* = ref object of QAbstractListModel
+    delegate: io_interface.FlatTokenModelDataSource
+
+  proc setup(self: FlatTokensModel) =
+    self.QAbstractListModel.setup
+
+  proc delete(self: FlatTokensModel) =
+    self.QAbstractListModel.delete
+
+  proc newFlatTokensModel*(delegate: io_interface.FlatTokenModelDataSource): FlatTokensModel =
+    new(result, delete)
+    result.setup
+    result.delegate = delegate
+
+  method rowCount(self: FlatTokensModel, index: QModelIndex = nil): int =
+    return self.delegate.getFlatTokensList().len
+
+  proc countChanged(self: FlatTokensModel) {.signal.}
+  proc getCount(self: FlatTokensModel): int {.slot.} =
+    return self.rowCount()
+  QtProperty[int] count:
+    read = getCount
+    notify = countChanged
+
+  method roleNames(self: FlatTokensModel): Table[int, string] =
+    {
+      ModelRole.Key.int:"key",
+      ModelRole.Name.int:"name",
+      ModelRole.Symbol.int:"symbol",
+      ModelRole.Sources.int:"sources",
+      ModelRole.ChainId.int:"chainId",
+      ModelRole.Address.int:"address",
+      ModelRole.Decimals.int:"decimals",
+      ModelRole.Image.int:"image",
+      ModelRole.Type.int:"type",
+      ModelRole.CommunityId.int:"communityId",
+      ModelRole.Description.int:"description",
+      ModelRole.WebsiteUrl.int:"websiteUrl",
+      ModelRole.MarketValues.int:"marketValues",
+    }.toTable
+
+  method data(self: FlatTokensModel, index: QModelIndex, role: int): QVariant =
+    if not index.isValid:
+      return
+    if index.row < 0 or index.row >= self.rowCount():
+      return
+    # the only way to read items from service is by this single method getFlatTokensList
+    let item = self.delegate.getFlatTokensList()[index.row]
+    let enumRole = role.ModelRole
+    case enumRole:
+      of ModelRole.Key:
+        result = newQVariant(item.key)
+      of ModelRole.Name:
+        result = newQVariant(item.name)
+      of ModelRole.Symbol:
+        result = newQVariant(item.symbol)
+      of ModelRole.Sources:
+        result = newQVariant(SOURCES_DELIMITER & item.sources.join(SOURCES_DELIMITER) & SOURCES_DELIMITER)
+      of ModelRole.ChainId:
+        result = newQVariant(item.chainId)
+      of ModelRole.Address:
+        result = newQVariant(item.address)
+      of ModelRole.Decimals:
+        result = newQVariant(item.decimals)
+      of ModelRole.Image:
+        result = newQVariant(item.image)
+      of ModelRole.Type:
+        result = newQVariant(ord(item.`type`))
+      of ModelRole.CommunityId:
+        result = newQVariant(item.communityId)
+      # ToDo fetching of market values not done yet
+      of ModelRole.Description:
+        result = newQVariant("")
+      of ModelRole.WebsiteUrl:
+        result = newQVariant("")
+      of ModelRole.MarketValues:
+        result = newQVariant("")
+
+  proc modelsAboutToUpdate*(self: FlatTokensModel) =
+      self.beginResetModel()
+
+  proc modelsUpdated*(self: FlatTokensModel) =
+      self.endResetModel()

src/app/modules/main/wallet_section/all_tokens/io_interface.nim

@@ -1,3 +1,17 @@
+import app_service/service/token/service_items
+
+type
+  SourcesOfTokensModelDataSource* = tuple[
+    getSourcesOfTokensList: proc(): var seq[SupportedSourcesItem]
+  ]
+type
+  FlatTokenModelDataSource* = tuple[
+    getFlatTokensList: proc(): var seq[TokenItem]
+  ]
+type
+  TokenBySymbolModelDataSource* = tuple[
+    getTokenBySymbolList: proc(): var seq[TokenBySymbolItem]
+  ]
 type
   AccessInterface* {.pure inheritable.} = ref object of RootObj
   ## Abstract class for any input/interaction with this module.
@@ -26,6 +40,15 @@ method fetchHistoricalBalanceForTokenAsJson*(self: AccessInterface, address: str
 method tokenBalanceHistoryDataResolved*(self: AccessInterface, balanceHistoryJson: string) {.base.} =
   raise newException(ValueError, "No implementation available")
 
+method getSourcesOfTokensModelDataSource*(self: AccessInterface): SourcesOfTokensModelDataSource {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getFlatTokenModelDataSource*(self: AccessInterface): FlatTokenModelDataSource {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method getTokenBySymbolModelDataSource*(self: AccessInterface): TokenBySymbolModelDataSource {.base.} =
+  raise newException(ValueError, "No implementation available")
+
 # View Delegate Interface
 # Delegate for the view must be declared here due to use of QtObject and multi
 # inheritance, which is not well supported in Nim.

src/app/modules/main/wallet_section/all_tokens/module.nim

@@ -39,6 +39,12 @@ method delete*(self: Module) =
 method load*(self: Module) =
   singletonInstance.engine.setRootContextProperty("walletSectionAllTokens", newQVariant(self.view))
 
+  # Passing on the events for changes in model to abstract model
+  self.events.on(SIGNAL_TOKENS_LIST_ABOUT_TO_BE_UPDATED) do(e: Args):
+    self.view.modelsAboutToUpdate()
+  self.events.on(SIGNAL_TOKENS_LIST_UPDATED) do(e: Args):
+    self.view.modelsUpdated()
+
   self.controller.init()
   self.view.load()
 
@@ -62,9 +68,34 @@ method getHistoricalDataForToken*(self: Module, symbol: string, currency: string
 method tokenHistoricalDataResolved*(self: Module, tokenDetails: string) =
   self.view.setTokenHistoricalDataReady(tokenDetails)
 
-
 method fetchHistoricalBalanceForTokenAsJson*(self: Module, address: string, tokenSymbol: string, currencySymbol: string, timeIntervalEnum: int) =
   self.controller.fetchHistoricalBalanceForTokenAsJson(address, tokenSymbol, currencySymbol,timeIntervalEnum)
 
 method tokenBalanceHistoryDataResolved*(self: Module, balanceHistoryJson: string) =
   self.view.setTokenBalanceHistoryDataReady(balanceHistoryJson)
+
+method getFlatTokensList*(self: Module): var seq[TokenItem]  =
+  return self.controller.getFlatTokensList()
+
+method getTokenBySymbolList*(self: Module): var seq[TokenBySymbolItem] =
+  return self.controller.getTokenBySymbolList()
+
+method getSourcesOfTokensList*(self: Module): var seq[SupportedSourcesItem] =
+  return self.controller.getSourcesOfTokensList()
+
+# Interfaces for getting lists from the service files into the abstract models
+
+method getSourcesOfTokensModelDataSource*(self: Module): SourcesOfTokensModelDataSource =
+  return (
+    getSourcesOfTokensList: proc(): var seq[SupportedSourcesItem] = self.getSourcesOfTokensList()
+  )
+
+method getFlatTokenModelDataSource*(self: Module): FlatTokenModelDataSource =
+  return (
+    getFlatTokensList: proc(): var seq[TokenItem] = self.getFlatTokensList()
+  )
+
+method getTokenBySymbolModelDataSource*(self: Module): TokenBySymbolModelDataSource =
+  return (
+    getTokenBySymbolList: proc(): var seq[TokenBySymbolItem] = self.getTokenBySymbolList()
+  )