Improve Realm access and replacing many publishers with async/await calls to block less when app launches.

Author: hboon

AlphaWallet/Accounts/ViewModels/AccountsViewModel.swift

@@ -147,7 +147,7 @@ final class AccountsViewModel {
 
     private func buildAccountRowViewModel(wallet: Wallet) -> AnyPublisher<AccountRowViewModel, Never> {
         let balance = walletBalanceService.walletBalance(for: wallet)
-        let blockieImage = blockiesGenerator.getBlockieOrEnsAvatarImage(address: wallet.address, fallbackImage: BlockiesImage.defaulBlockieImage)
+        let blockieImage = asFuture { await self.blockiesGenerator.getBlockieOrEnsAvatarImage(address: wallet.address, fallbackImage: BlockiesImage.defaulBlockieImage) }
             .handleEvents(receiveOutput: { [analytics] value in
                 guard value.isEnsAvatar else { return }
                 analytics.setUser(property: Analytics.UserProperties.hasEnsAvatar, value: true)

AlphaWallet/ActiveWalletCoordinator.swift

@@ -775,41 +775,45 @@ extension ActiveWalletCoordinator: ActivityViewControllerDelegate {
     }
 
     func speedupTransaction(transactionId: String, server: RPCServer, viewController: ActivityViewController) {
-        guard let transaction = transactionsDataStore.transaction(withTransactionId: transactionId, forServer: server) else { return }
-        guard let session = sessionsProvider.session(for: transaction.server) else { return }
-        guard let coordinator = ReplaceTransactionCoordinator(
-            analytics: analytics,
-            domainResolutionService: domainResolutionService,
-            keystore: keystore,
-            presentingViewController: viewController,
-            session: session,
-            transaction: transaction,
-            mode: .speedup,
-            tokensService: tokensPipeline,
-            networkService: networkService) else { return }
+        Task { @MainActor in
+            guard let transaction = await transactionsDataStore.transaction(withTransactionId: transactionId, forServer: server) else { return }
+            guard let session = sessionsProvider.session(for: transaction.server) else { return }
+            guard let coordinator = ReplaceTransactionCoordinator(
+                analytics: analytics,
+                domainResolutionService: domainResolutionService,
+                keystore: keystore,
+                presentingViewController: viewController,
+                session: session,
+                transaction: transaction,
+                mode: .speedup,
+                tokensService: tokensPipeline,
+                networkService: networkService) else { return }
 
-        coordinator.delegate = self
-        coordinator.start()
-        addCoordinator(coordinator)
+            coordinator.delegate = self
+            coordinator.start()
+            addCoordinator(coordinator)
+        }
     }
 
     func cancelTransaction(transactionId: String, server: RPCServer, viewController: ActivityViewController) {
-        guard let transaction = transactionsDataStore.transaction(withTransactionId: transactionId, forServer: server) else { return }
-        guard let session = sessionsProvider.session(for: transaction.server) else { return }
-        guard let coordinator = ReplaceTransactionCoordinator(
-            analytics: analytics,
-            domainResolutionService: domainResolutionService,
-            keystore: keystore,
-            presentingViewController: viewController,
-            session: session,
-            transaction: transaction,
-            mode: .cancel,
-            tokensService: tokensPipeline,
-            networkService: networkService) else { return }
+        Task { @MainActor in
+            guard let transaction = await transactionsDataStore.transaction(withTransactionId: transactionId, forServer: server) else { return }
+            guard let session = sessionsProvider.session(for: transaction.server) else { return }
+            guard let coordinator = ReplaceTransactionCoordinator(
+                analytics: analytics,
+                domainResolutionService: domainResolutionService,
+                keystore: keystore,
+                presentingViewController: viewController,
+                session: session,
+                transaction: transaction,
+                mode: .cancel,
+                tokensService: tokensPipeline,
+                networkService: networkService) else { return }
 
-        coordinator.delegate = self
-        coordinator.start()
-        addCoordinator(coordinator)
+            coordinator.delegate = self
+            coordinator.start()
+            addCoordinator(coordinator)
+        }
     }
 
     func goToTransaction(viewController: ActivityViewController) {

AlphaWallet/Activities/Coordinators/ActivitiesCoordinator.swift

@@ -56,7 +56,7 @@ class ActivitiesCoordinator: NSObject, Coordinator {
         let viewModel = ActivitiesViewModel(collection: .init())
         let controller = ActivitiesViewController(analytics: analytics, keystore: keystore, wallet: wallet, viewModel: viewModel, sessionsProvider: sessionsProvider, assetDefinitionStore: assetDefinitionStore, tokenImageFetcher: tokenImageFetcher)
         controller.delegate = self
-        
+
         return controller
     }
 

AlphaWallet/Activities/ViewControllers/ActivitiesViewController.swift

@@ -21,14 +21,7 @@ class ActivitiesViewController: UIViewController {
     private var activitiesView: ActivitiesView
     weak var delegate: ActivitiesViewControllerDelegate?
 
-    init(analytics: AnalyticsLogger,
-         keystore: Keystore,
-         wallet: Wallet,
-         viewModel: ActivitiesViewModel,
-         sessionsProvider: SessionsProvider,
-         assetDefinitionStore: AssetDefinitionStore,
-         tokenImageFetcher: TokenImageFetcher) {
-
+    init(analytics: AnalyticsLogger, keystore: Keystore, wallet: Wallet, viewModel: ActivitiesViewModel, sessionsProvider: SessionsProvider, assetDefinitionStore: AssetDefinitionStore, tokenImageFetcher: TokenImageFetcher) {
         self.viewModel = viewModel
         searchController = UISearchController(searchResultsController: nil)
         activitiesView = ActivitiesView(
@@ -159,7 +152,7 @@ extension ActivitiesViewController {
     private func configureSearchBarOnce() {
         guard !isSearchBarConfigured else { return }
         isSearchBarConfigured = true
-        
+
         UISearchBar.configure(searchBar: searchController.searchBar)
     }
 }

AlphaWallet/Browser/Coordinators/QRCodeResolutionCoordinator.swift

@@ -79,10 +79,10 @@ extension QRCodeResolutionCoordinator: ScanQRCodeCoordinatorDelegate {
         resolveScanResult(result, decodedValue: decodedValue)
     }
 
-    private func availableActions(forContract contract: AlphaWallet.Address) -> [ScanQRCodeAction] {
+    private func availableActions(forContract contract: AlphaWallet.Address) async -> [ScanQRCodeAction] {
         switch usage {
         case .all(let tokensDataStore, _):
-            let isTokenFound = tokensDataStore.token(for: contract, server: .main) != nil
+            let isTokenFound = await tokensDataStore.token(for: contract, server: .main) != nil
             if isTokenFound {
                 return [.sendToAddress, .watchWallet, .openInEtherscan]
             } else {
@@ -104,7 +104,7 @@ extension QRCodeResolutionCoordinator: ScanQRCodeCoordinatorDelegate {
                 switch value {
                 case .address(let contract):
                     guard supportedResolutions.contains(.address) else { return }
-                    let actions = availableActions(forContract: contract)
+                    let actions = await availableActions(forContract: contract)
                     if actions.count == 1 {
                         delegate.coordinator(self, didResolve: .address(address: contract, action: actions[0]))
                     } else {

AlphaWallet/Common/Initializers/ConfigureApp.swift

@@ -16,15 +16,7 @@ public class ConfigureApp: Initializer {
 
         Attestation.isLoggingEnabled = true
         Attestation.callSmartContract = { chainId, contract, functionName, abiString, parameters in
-            return try await withCheckedThrowingContinuation { continuation in
-                firstly {
-                    callSmartContract(withServer: RPCServer(chainID: chainId), contract: contract, functionName: functionName, abiString: abiString, parameters: parameters)
-                }.done { result in
-                    continuation.resume(returning: result)
-                }.catch {
-                    continuation.resume(throwing: $0)
-                }
-            }
+            return try await callSmartContractAsync(withServer: RPCServer(chainID: chainId), contract: contract, functionName: functionName, abiString: abiString, parameters: parameters)
         }
     }
 }

AlphaWallet/Common/Services/MediaContentNetworking.swift

@@ -6,10 +6,11 @@
 //
 
 import Foundation
-import Alamofire
-import AlphaWalletFoundation
 import Combine
+import AlphaWalletCore
+import AlphaWalletFoundation
 import AlphaWalletOpenSea
+import Alamofire
 
 protocol MediaContentNetworking {
     func dataTaskPublisher(_ request: URLRequestConvertible) -> AnyPublisher<URLRequest.Response, SessionTaskError>

AlphaWallet/Common/Views/AddressOrEnsNameLabel.swift

@@ -136,23 +136,23 @@ class AddressOrEnsNameLabel: UILabel {
 
         let promise = Promise<BlockieAndAddressOrEnsResolution> { seal in
             if let address = AlphaWallet.Address(string: value) {
-                cancelable?.cancel()
-                cancelable = domainResolutionService.resolveEnsAndBlockie(address: address, server: server)
-                    .sink(receiveCompletion: { _ in
-                        seal.fulfill((nil, .resolved(.none)))
-                    }, receiveValue: { value in
+                Task { @MainActor in
+                    do {
+                        let blockieAndResolution = try await domainResolutionService.resolveEnsAndBlockie(address: address, server: server)
+                        seal.fulfill(blockieAndResolution)
+                    } catch {
                         self.clearCurrentlyResolvingIf(value: valueArg)
-                        seal.fulfill(value)
-                    })
+                    }
+                }
             } else if value.contains(".") {
-                cancelable?.cancel()
-                cancelable = domainResolutionService.resolveAddressAndBlockie(string: value)
-                    .sink(receiveCompletion: { _ in
-                        seal.fulfill((nil, .resolved(.none)))
-                    }, receiveValue: { value in
+                Task { @MainActor in
+                    do {
+                        let blockieAndResolution = try await domainResolutionService.resolveAddressAndBlockie(string: value)
+                        seal.fulfill(blockieAndResolution)
+                    } catch {
                         self.clearCurrentlyResolvingIf(value: valueArg)
-                        seal.fulfill(value)
-                    })
+                    }
+                }
             } else {
                 seal.fulfill((nil, .resolved(.none)))
             }

AlphaWallet/Market/ImportMagicLinkController.swift

@@ -305,20 +305,19 @@ final class ImportMagicLinkController {
     }
 
     private func makeTokenHolder(_ bytes32Tokens: [String], _ contractAddress: AlphaWallet.Address) {
-        assetDefinitionStore.fetchXML(forContract: contractAddress, server: server, useCacheAndFetch: true) { [weak self, session] _ in
-            guard let strongSelf = self else { return }
-
-            func makeTokenHolder(name: String, symbol: String, type: TokenType? = nil) {
-                strongSelf.makeTokenHolderImpl(name: name, symbol: symbol, type: type, bytes32Tokens: bytes32Tokens, contractAddress: contractAddress)
-                strongSelf.updateTokenFields()
+        Task { @MainActor in
+            _ = await assetDefinitionStore.fetchXMLAsync(forContract: contractAddress, server: server, useCacheAndFetch: true)
+            func makeTokenHolder(name: String, symbol: String, type: TokenType? = nil) async {
+                await makeTokenHolderImpl(name: name, symbol: symbol, type: type, bytes32Tokens: bytes32Tokens, contractAddress: contractAddress)
+                updateTokenFields()
             }
 
-            if let existingToken = strongSelf.tokensService.tokenViewModel(for: contractAddress, server: strongSelf.server) {
-                let name = XMLHandler(token: existingToken, assetDefinitionStore: strongSelf.assetDefinitionStore).getLabel(fallback: existingToken.name)
-                makeTokenHolder(name: name, symbol: existingToken.symbol)
+            if let existingToken = await tokensService.tokenViewModel(for: contractAddress, server: server) {
+                let name = XMLHandler(token: existingToken, assetDefinitionStore: assetDefinitionStore).getLabel(fallback: existingToken.name)
+                await makeTokenHolder(name: name, symbol: existingToken.symbol)
             } else {
                 let localizedTokenTypeName = R.string.localizable.tokensTitlecase()
-                makeTokenHolder(name: localizedTokenTypeName, symbol: "")
+                await makeTokenHolder(name: localizedTokenTypeName, symbol: "")
 
                 let getContractName = session.tokenProvider.getContractName(for: contractAddress)
                 let getContractSymbol = session.tokenProvider.getContractSymbol(for: contractAddress)
@@ -328,15 +327,21 @@ final class ImportMagicLinkController {
                     .sinkAsync(receiveCompletion: { _ in
                         //no-op
                     }, receiveValue: { name, symbol, type in
-                        makeTokenHolder(name: name, symbol: symbol, type: type)
+                        Task { @MainActor in
+                            await makeTokenHolder(name: name, symbol: symbol, type: type)
+                        }
                     })
             }
         }
     }
 
-    private func makeTokenHolderImpl(name: String, symbol: String, type: TokenType? = nil, bytes32Tokens: [String], contractAddress: AlphaWallet.Address) {
+    private func makeTokenHolderImpl(name: String, symbol: String, type: TokenType? = nil, bytes32Tokens: [String], contractAddress: AlphaWallet.Address) async {
         //TODO pass in the wallet instead
-        guard let tokenType = type ?? (tokensService.tokenViewModel(for: contractAddress, server: server)?.type) else { return }
+        var tokenType1: TokenType? = type
+        if tokenType1 == nil {
+            tokenType1 = await tokensService.tokenViewModel(for: contractAddress, server: server)?.type
+        }
+        guard let tokenType = tokenType1 else { return }
         var tokens = [TokenScript.Token]()
         let xmlHandler = XMLHandler(contract: contractAddress, tokenType: tokenType, assetDefinitionStore: assetDefinitionStore)
         for i in 0..<bytes32Tokens.count {