Fix #7723: Selected Account Refactor & Bump BraveCore to v1.58.26 (#7725

)

* Resolve account selection, network selection, buy, send, swap, DApp connections, other stores.

* Resolve unit tests.

* Update BraveCore to v1.58.10

* Update BraveCore to v1.58.26

Sources/Brave/Extensions/Rewards/BraveLedgerExtensions.swift

@@ -9,7 +9,7 @@ import Shared
 import BraveShared
 import os.log
 
-extension BraveLedger {
+extension BraveRewardsAPI {
 
   public var isLedgerTransferExpired: Bool {
     if Locale.current.regionCode != "JP" {
@@ -149,7 +149,7 @@ extension BraveLedger {
     }
     return await withCheckedContinuation { c in
       self.claimPromotion(promotion.id, publicKey: attestation.publicKeyHash) { result, nonce in
-        if result != .ledgerOk {
+        if result != .ok {
           c.resume(returning: false)
           return
         }
@@ -161,7 +161,7 @@ extension BraveLedger {
           solution.blob = try verification.attestationBlob.bsonData().base64EncodedString()
 
           self.attestPromotion(promotion.id, solution: solution) { result, promotion in
-            if result == .ledgerOk {
+            if result == .ok {
               self.updatePendingAndFinishedPromotions {
                 c.resume(returning: true)
               }

Sources/Brave/Frontend/Brave Rewards/Panel/BraveRewardsViewController.swift

@@ -20,7 +20,7 @@ class BraveRewardsViewController: UIViewController, PopoverContentComponent {
   let rewards: BraveRewards
   var actionHandler: ((Action) -> Void)?
 
-  private var ledgerObserver: LedgerObserver?
+  private var rewardsObserver: RewardsObserver?
   private var publisher: BraveCore.BraveRewards.PublisherInfo? {
     didSet {
       let isVerified = publisher?.status != .notVerified
@@ -65,7 +65,7 @@ class BraveRewardsViewController: UIViewController, PopoverContentComponent {
   }
 
   private func reloadData() {
-    guard let ledger = self.rewards.ledger else {
+    guard let rewardsAPI = self.rewards.rewardsAPI else {
       self.rewardsView.statusView.setVisibleStatus(status: .rewardsOff, animated: false)
       return
     }
@@ -76,12 +76,12 @@ class BraveRewardsViewController: UIViewController, PopoverContentComponent {
       if let url = self.tab.url, !url.isLocal, !InternalURL.isValid(url: url) {
         self.rewardsView.publisherView.isHidden = false
         self.rewardsView.publisherView.hostLabel.text = url.baseDomain
-        ledger.fetchPublisherActivity(from: url, faviconURL: nil, publisherBlob: nil, tabId: UInt64(self.tab.rewardsId))
+        rewardsAPI.fetchPublisherActivity(from: url, faviconURL: nil, publisherBlob: nil, tabId: UInt64(self.tab.rewardsId))
       } else {
         self.rewardsView.publisherView.isHidden = true
       }
-      ledger.fetchPromotions(nil)
-      ledger.listAutoContributePublishers { [weak self] list in
+      rewardsAPI.fetchPromotions(nil)
+      rewardsAPI.listAutoContributePublishers { [weak self] list in
         guard let self = self else { return }
         self.supportedListCount = list.count
         self.rewardsView.statusView.setVisibleStatus(status: list.isEmpty ? .rewardsOnNoCount : .rewardsOn, animated: false)
@@ -101,12 +101,12 @@ class BraveRewardsViewController: UIViewController, PopoverContentComponent {
 
     rewardsView.rewardsToggle.isOn = rewards.isEnabled
 
-    rewards.startLedgerService { [weak self] in
+    rewards.startRewardsService { [weak self] in
       guard let self = self else { return }
-      if let ledger = self.rewards.ledger {
-        let observer = LedgerObserver(ledger: ledger)
-        ledger.add(observer)
-        self.ledgerObserver = observer
+      if let rewardsAPI = self.rewards.rewardsAPI {
+        let observer = RewardsObserver(rewardsAPI: rewardsAPI)
+        rewardsAPI.add(observer)
+        self.rewardsObserver = observer
 
         observer.fetchedPanelPublisher = { [weak self] publisher, tabId in
           guard let self = self else { return }
@@ -166,7 +166,7 @@ class BraveRewardsViewController: UIViewController, PopoverContentComponent {
   @objc private func tappedHostLabel(_ gesture: UITapGestureRecognizer) {
     if gesture.state != .ended { return }
     guard let publisher = publisher else { return }
-    rewards.ledger?.refreshPublisher(withId: publisher.id) { [weak self] status in
+    rewards.rewardsAPI?.refreshPublisher(withId: publisher.id) { [weak self] status in
       guard let self = self else { return }
       let copy = publisher.copy() as! BraveCore.BraveRewards.PublisherInfo  // swiftlint:disable:this force_cast
       copy.status = status

Sources/Brave/Frontend/Browser/BrowserViewController.swift

@@ -217,7 +217,7 @@ public class BrowserViewController: UIViewController {
   private var cancellables: Set<AnyCancellable> = []
 
   let rewards: BraveRewards
-  var ledgerObserver: LedgerObserver?
+  var rewardsObserver: RewardsObserver?
   var promotionFetchTimer: Timer?
   private var notificationsHandler: AdsNotificationHandler?
   let notificationsPresenter = BraveNotificationsPresenter()
@@ -336,16 +336,16 @@ public class BrowserViewController: UIViewController {
     super.init(nibName: nil, bundle: nil)
     didInit()
 
-    rewards.ledgerServiceDidStart = { [weak self] _ in
+    rewards.rewardsServiceDidStart = { [weak self] _ in
       self?.setupLedger()
     }
 
     rewards.ads.captchaHandler = self
     let shouldStartAds = rewards.ads.isEnabled || Preferences.BraveNews.isEnabled.value
     if shouldStartAds {
-      // Only start ledger service automatically if ads is enabled
+      // Only start rewards service automatically if ads is enabled
       if rewards.isEnabled {
-        rewards.startLedgerService(nil)
+        rewards.startRewardsService(nil)
       } else {
         rewards.ads.initialize(walletInfo: .init()) { _ in }
       }
@@ -470,7 +470,7 @@ public class BrowserViewController: UIViewController {
     Preferences.PrivacyReports.captureVPNAlerts.observe(from: self)
     Preferences.Wallet.defaultEthWallet.observe(from: self)
 
-    if rewards.ledger != nil {
+    if rewards.rewardsAPI != nil {
       // Ledger was started immediately due to user having ads enabled
       setupLedger()
     }
@@ -1078,8 +1078,8 @@ public class BrowserViewController: UIViewController {
     super.viewWillAppear(animated)
     updateToolbarUsingTabManager(tabManager)
 
-    if let tabId = tabManager.selectedTab?.rewardsId, rewards.ledger?.selectedTabId == 0 {
-      rewards.ledger?.selectedTabId = tabId
+    if let tabId = tabManager.selectedTab?.rewardsId, rewards.rewardsAPI?.selectedTabId == 0 {
+      rewards.rewardsAPI?.selectedTabId = tabId
     }
   }
 
@@ -1170,7 +1170,7 @@ public class BrowserViewController: UIViewController {
     screenshotHelper.viewIsVisible = false
     super.viewWillDisappear(animated)
 
-    rewards.ledger?.selectedTabId = 0
+    rewards.rewardsAPI?.selectedTabId = 0
     view.window?.windowScene?.userActivity = nil
   }
 

Sources/Brave/Frontend/Browser/BrowserViewController/BVC+Rewards.swift

@@ -73,27 +73,27 @@ extension BrowserViewController {
     popover.present(from: topToolbar.locationView.rewardsButton, on: self)
     popover.popoverDidDismiss = { [weak self] _ in
       guard let self = self else { return }
-      if let tabId = self.tabManager.selectedTab?.rewardsId, self.rewards.ledger?.selectedTabId == 0 {
+      if let tabId = self.tabManager.selectedTab?.rewardsId, self.rewards.rewardsAPI?.selectedTabId == 0 {
         // Show the tab currently visible
-        self.rewards.ledger?.selectedTabId = tabId
+        self.rewards.rewardsAPI?.selectedTabId = tabId
       }
     }
     // Hide the current tab
-    rewards.ledger?.selectedTabId = 0
+    rewards.rewardsAPI?.selectedTabId = 0
     // Fetch new promotions
-    rewards.ledger?.fetchPromotions(nil)
+    rewards.rewardsAPI?.fetchPromotions(nil)
   }
 
   func claimPendingPromotions() {
     guard
-      let ledger = rewards.ledger,
-      case let promotions = ledger.pendingPromotions.filter({ $0.status == .active }),
+      let rewardsAPI = rewards.rewardsAPI,
+      case let promotions = rewardsAPI.pendingPromotions.filter({ $0.status == .active }),
       !promotions.isEmpty else {
       return
     }
     Task {
       for promo in promotions {
-        let success = await ledger.claimPromotion(promo)
+        let success = await rewardsAPI.claimPromotion(promo)
         adsRewardsLog.info("[BraveRewards] Auto-Claim Promotion - \(success) for \(promo.approximateValue)")
       }
     }
@@ -133,21 +133,21 @@ extension BrowserViewController {
   }
 
   func setupLedger() {
-    guard let ledger = rewards.ledger else { return }
+    guard let rewardsAPI = rewards.rewardsAPI else { return }
     // Update defaults
-    ledger.setMinimumVisitDuration(8)
-    ledger.setMinimumNumberOfVisits(1)
-    ledger.setContributionAmount(Double.greatestFiniteMagnitude)
+    rewardsAPI.setMinimumVisitDuration(8)
+    rewardsAPI.setMinimumNumberOfVisits(1)
+    rewardsAPI.setContributionAmount(Double.greatestFiniteMagnitude)
 
-    // Create ledger observer
-    let rewardsObserver = LedgerObserver(ledger: ledger)
-    ledger.add(rewardsObserver)
-    ledgerObserver = rewardsObserver
+    // Create rewards observer
+    let rewardsObserver = RewardsObserver(rewardsAPI: rewardsAPI)
+    rewardsAPI.add(rewardsObserver)
+    self.rewardsObserver = rewardsObserver
 
     rewardsObserver.walletInitalized = { [weak self] result in
       guard let self = self, let client = self.deviceCheckClient else { return }
-      if result == .ledgerOk, !DeviceCheckClient.isDeviceEnrolled() {
-        ledger.setupDeviceCheckEnrollment(client) {}
+      if result == .ok, !DeviceCheckClient.isDeviceEnrolled() {
+        rewardsAPI.setupDeviceCheckEnrollment(client) {}
         self.updateRewardsButtonState()
       }
     }
@@ -164,10 +164,10 @@ extension BrowserViewController {
     promotionFetchTimer = Timer.scheduledTimer(
       withTimeInterval: 1.hours,
       repeats: true,
-      block: { [weak self, weak ledger] _ in
-        guard let self = self, let ledger = ledger else { return }
+      block: { [weak self, weak rewardsAPI] _ in
+        guard let self = self, let rewardsAPI = rewardsAPI else { return }
         if self.rewards.isEnabled {
-          ledger.fetchPromotions(nil)
+          rewardsAPI.fetchPromotions(nil)
         }
       }
     )
@@ -222,7 +222,7 @@ extension BrowserViewController: BraveAdsCaptchaHandler {
     }
     Task {
       do {
-        try await rewards.ledger?.solveAdaptiveCaptcha(paymentId: paymentId, captchaId: captchaId)
+        try await rewards.rewardsAPI?.solveAdaptiveCaptcha(paymentId: paymentId, captchaId: captchaId)
       } catch {
         // Increase failure count, stop attempting attestation altogether passed a specific count
         Preferences.Rewards.adaptiveCaptchaFailureCount.value += 1

Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+Wallet.swift

@@ -262,7 +262,7 @@ extension Tab: BraveWalletProviderDelegate {
   }
 
   /// Returns the selected account if present in `allowedAccounts`, otherwise returns `allowedAccounts`
-  private func filterAllowedAccounts(
+  func filterAllowedAccounts(
     _ allowedAccounts: [String],
     selectedAccount: String?
   ) -> [String] {
@@ -271,22 +271,6 @@ extension Tab: BraveWalletProviderDelegate {
     }
     return allowedAccounts
   }
-
-  /// Helper to fetch the allowed accounts for the current coin. Unlike `allowedAccounts(_:accounts:)`
-  /// this will filter the selected account to the front of the array if it is an allowed/permitted account
-  @MainActor func allowedAccountsForCurrentCoin() async -> [String] {
-    guard let keyringService = BraveWallet.KeyringServiceFactory.get(privateMode: false),
-          let walletService = BraveWallet.ServiceFactory.get(privateMode: false) else {
-      return []
-    }
-    let coin = await walletService.selectedCoin()
-    let allAccounts = await keyringService.keyringInfo(coin.keyringId).accountInfos.map(\.address)
-    guard let allowedAccounts = getAllowedAccounts(coin, accounts: allAccounts) else {
-      return []
-    }
-    let selectedAccounts = await keyringService.selectedAccount(coin)
-    return filterAllowedAccounts(allowedAccounts, selectedAccount: selectedAccounts)
-  }
 
   /// Fetches all allowed accounts for the current origin.
   func getAllowedAccounts(_ type: BraveWallet.CoinType, accounts: [String]) -> [String]? {
@@ -479,18 +463,21 @@ extension Tab: BraveWalletEventsListener {
       asFunction: false
     )
 
-    let coin: BraveWallet.CoinType = .eth
-    let keyring = await keyringService.keyringInfo(coin.keyringId)
+    let isKeyringLocked = await keyringService.isLocked()
     let selectedAccount: String
-    if keyring.isLocked {
+    if isKeyringLocked {
       // Check for locked status before assigning account address.
       // `getAllowedAccounts` is not async, can't check locked status.
       selectedAccount = valueOrUndefined(Optional<String>.none)
     } else {
-      let allAccounts = keyring.accountInfos.map(\.address)
-      if let allowedAccounts = getAllowedAccounts(coin, accounts: allAccounts) {
-        let selectedAccountForCoin = await keyringService.selectedAccount(coin)
-        let filteredAllowedAccounts = filterAllowedAccounts(allowedAccounts, selectedAccount: selectedAccountForCoin)
+      let allAccounts = await keyringService.allAccounts()
+      let allEthAccounts = allAccounts.accounts.filter { $0.coin == .eth }
+      if let allowedAccounts = getAllowedAccounts(.eth, accounts: allEthAccounts.map(\.address)) {
+        let selectedAccountForCoin = allAccounts.ethDappSelectedAccount
+        let filteredAllowedAccounts = filterAllowedAccounts(
+          allowedAccounts,
+          selectedAccount: selectedAccountForCoin?.address
+        )
         selectedAccount = valueOrUndefined(filteredAllowedAccounts.first)
       } else {
         selectedAccount = valueOrUndefined(Optional<String>.none)
@@ -567,7 +554,7 @@ extension Tab: BraveWalletSolanaEventsListener {
     )
     // publicKey
     if let keyringService = walletKeyringService,
-       let publicKey = await keyringService.selectedAccount(.sol),
+       let publicKey = await keyringService.allAccounts().solDappSelectedAccount?.address,
        self.isSolanaAccountConnected(publicKey) {
       await webView.evaluateSafeJavaScript(
         functionName: """
@@ -606,19 +593,24 @@ extension Tab: BraveWalletKeyringServiceObserver {
   }
 
   func unlocked() {
-    guard let origin = url?.origin else { return }
+    guard let origin = url?.origin,
+          let keyringService = walletKeyringService else { return }
     Task { @MainActor in
       // check domain already has some permitted accounts for this Tab's URLOrigin
       let permissionRequestManager = WalletProviderPermissionRequestsManager.shared
-      if permissionRequestManager.hasPendingRequest(for: origin, coinType: .eth) {
-        let pendingRequests = permissionRequestManager.pendingRequests(for: origin, coinType: .eth)
-        let accounts = await allowedAccountsForCurrentCoin()
-        if !accounts.isEmpty {
-          for request in pendingRequests {
-            // cancel the requests if `allowedAccounts` is not empty for this domain
-            permissionRequestManager.cancelRequest(request)
-            // let wallet provider know we have allowed accounts for this domain
-            request.providerHandler?(.none, accounts)
+      let allAccounts = await keyringService.allAccounts().accounts
+      for coin in WalletConstants.supportedCoinTypes {
+        let allAccountsForCoin = allAccounts.filter { $0.coin == coin }
+        if permissionRequestManager.hasPendingRequest(for: origin, coinType: coin) {
+          let pendingRequests = permissionRequestManager.pendingRequests(for: origin, coinType: coin)
+          let accounts = getAllowedAccounts(coin, accounts: allAccountsForCoin.map(\.address)) ?? []
+          if !accounts.isEmpty {
+            for request in pendingRequests {
+              // cancel the requests if `allowedAccounts` is not empty for this domain
+              permissionRequestManager.cancelRequest(request)
+              // let wallet provider know we have allowed accounts for this domain
+              request.providerHandler?(.none, accounts)
+            }
           }
         }
       }
@@ -634,7 +626,10 @@ extension Tab: BraveWalletKeyringServiceObserver {
   func autoLockMinutesChanged() {
   }
 
-  func selectedAccountChanged(_ coin: BraveWallet.CoinType) {
+  func selectedWalletAccountChanged(_ account: BraveWallet.AccountInfo) {
+  }
+
+  func selectedDappAccountChanged(_ coin: BraveWallet.CoinType, account: BraveWallet.AccountInfo?) {
   }
 
   func accountsAdded(_ addedAccounts: [BraveWallet.AccountInfo]) {

Sources/Brave/Frontend/Browser/TabManager.swift

@@ -1240,16 +1240,21 @@ extension TabManager: NSFetchedResultsControllerDelegate {
       tabsForDomain.forEach { tab in
         Task { @MainActor in
           let privateMode = privateBrowsingManager.isPrivateBrowsing
+          guard let keyringService = BraveWallet.KeyringServiceFactory.get(privateMode: privateMode) else {
+            return
+          }
+          let allAccounts = await keyringService.allAccounts()
           // iOS does not have `HostContentSettingsMap`, so we must
           // implement `SolanaProviderImpl::OnContentSettingChanged`
-          if let keyringService = BraveWallet.KeyringServiceFactory.get(privateMode: privateMode),
-             let selectedSolAccount = await keyringService.selectedAccount(.sol),
-             tab.isSolanaAccountConnected(selectedSolAccount), // currently connected
-             !tab.isAccountAllowed(.sol, account: selectedSolAccount) { // user revoked access
+          if let selectedSolAccount = allAccounts.solDappSelectedAccount,
+             tab.isSolanaAccountConnected(selectedSolAccount.address), // currently connected
+             !tab.isAccountAllowed(.sol, account: selectedSolAccount.address) { // user revoked access
             tab.walletSolProvider?.disconnect()
           }
-          let accounts = await tab.allowedAccountsForCurrentCoin()
-          tab.accountsChangedEvent(Array(accounts))
+
+          let ethAccountAddressess = allAccounts.accounts.filter { $0.coin == .eth }.map(\.address)
+          let allowedEthAccountAddresses = tab.getAllowedAccounts(.eth, accounts: ethAccountAddressess) ?? []
+          tab.accountsChangedEvent(Array(allowedEthAccountAddresses))
         }
       }
     }