8.7.2 Ledger for DApps Browser & Bugfixes

novawallet/Common/Services/ExtrinsicService/Substrate/ExtrinsicSenderResolution/Proxy/ProxyResolutionPathFinder.swift

@@ -27,9 +27,18 @@ extension ProxyResolution {
         }
 
         let accounts: [AccountId: [MetaChainAccountResponse]]
+        let proxieds: [AccountId: MetaChainAccountResponse]
 
         init(accounts: [AccountId: [MetaChainAccountResponse]]) {
             self.accounts = accounts
+
+            proxieds = accounts.reduce(into: [AccountId: MetaChainAccountResponse]()) { accum, keyValue in
+                guard let account = keyValue.value.first(where: { $0.chainAccount.type == .proxied }) else {
+                    return
+                }
+
+                accum[keyValue.key] = account
+            }
         }
 
         private func buildResult(
@@ -79,8 +88,10 @@ extension ProxyResolution {
                 }
 
                 let components = try solution.components.map { oldComponent in
+                    let optAccount = accounts[oldComponent.proxyAccountId] ?? proxieds[oldComponent.proxyAccountId]
+
                     guard
-                        let account = accounts[oldComponent.proxyAccountId],
+                        let account = optAccount,
                         let proxyType = oldComponent.applicableTypes.first else {
                         throw PathFinderError.noAccount
                     }

novawallet/Common/Services/Proxy/ChainProxySyncService.swift

@@ -178,25 +178,34 @@ final class ChainProxySyncService: ObservableSyncService, ChainProxySyncServiceP
             let proxyList = try proxyListWrapper.targetOperation.extractNoCancellableResultData()
             let chainMetaAccounts = try metaAccountsWrapper.targetOperation.extractNoCancellableResultData()
 
-            let notProxiedAccountIdList: [AccountId] = chainMetaAccounts.compactMap { wallet in
+            let possibleProxiesList: [AccountId] = chainMetaAccounts.compactMap { wallet in
                 guard wallet.info.type != .proxied else {
                     return nil
                 }
 
                 return wallet.info.fetch(for: chainModel.accountRequest())?.accountId
             }
 
-            let notProxiedAccountIds = Set(notProxiedAccountIdList)
+            var possibleProxiesIds = Set(possibleProxiesList)
+            var prevProxiesIds = possibleProxiesIds
+            var proxies: [ProxiedAccountId: [ProxyAccount]] = [:]
 
-            // We only need remote proxieds for proxies we have locally and we don't support delaed proxies
-            let proxies = proxyList.compactMapValues { accounts in
-                accounts.filter {
-                    !$0.hasDelay && notProxiedAccountIds.contains($0.accountId)
-                }
-            }.filter { !$0.value.isEmpty }
+            repeat {
+                // We only need remote proxieds for current proxies and we don't support delayed proxies
+                proxies = proxyList.compactMapValues { accounts in
+                    accounts.filter {
+                        !$0.hasDelay && possibleProxiesIds.contains($0.accountId)
+                    }
+                }.filter { !$0.value.isEmpty }
+
+                prevProxiesIds = possibleProxiesIds
+                possibleProxiesIds = possibleProxiesIds.union(Set(proxies.keys))
+
+            } while possibleProxiesIds != prevProxiesIds
 
             return proxies
         }
+
         proxyListOperation.addDependency(proxyListWrapper.targetOperation)
         proxyListOperation.addDependency(metaAccountsWrapper.targetOperation)
 

novawallet/Common/Storage/WalletsUpdateMediator.swift

@@ -34,6 +34,44 @@ final class WalletUpdateMediator {
         self.operationQueue = operationQueue
     }
 
+    private static func nonProxiedWalletReachable(
+        from proxiedWallet: ManagedMetaAccountModel,
+        wallets: [ManagedMetaAccountModel],
+        removeIds: Set<MetaAccountModel.Id>
+    ) -> Bool {
+        var currentProxieds: Set<MetaAccountModel.Id> = [proxiedWallet.info.metaId]
+        var prevProxieds = currentProxieds
+        var foundWallets: [MetaAccountModel.Id: ManagedMetaAccountModel] = [proxiedWallet.info.metaId: proxiedWallet]
+
+        repeat {
+            let newReachableWallets: [ManagedMetaAccountModel] = currentProxieds.flatMap { proxiedId in
+                guard
+                    let proxied = foundWallets[proxiedId],
+                    let chainAccount = proxied.info.chainAccounts.first(where: { $0.proxy != nil }),
+                    let proxy = chainAccount.proxy else {
+                    return [ManagedMetaAccountModel]()
+                }
+
+                return wallets.filter { $0.info.has(accountId: proxy.accountId, chainId: chainAccount.chainId) }
+            }
+
+            if newReachableWallets.contains(
+                where: { $0.info.type != .proxied && !removeIds.contains($0.info.metaId) }
+            ) {
+                return true
+            }
+
+            foundWallets = newReachableWallets.reduce(into: foundWallets) {
+                $0[$1.info.metaId] = $1
+            }
+
+            prevProxieds = currentProxieds
+            currentProxieds = Set(foundWallets.keys)
+        } while prevProxieds != currentProxieds
+
+        return false
+    }
+
     private static func includeProxiedsToRemoveSet(
         starting removeIds: Set<MetaAccountModel.Id>,
         wallets: [ManagedMetaAccountModel]
@@ -46,20 +84,12 @@ final class WalletUpdateMediator {
         // we can have nested proxieds so we make sure to remove them all
 
         repeat {
-            let newProxiedIdsToRemove = allProxieds.filter { proxiedWallet in
-                guard
-                    let chainAccount = proxiedWallet.info.chainAccounts.first(where: { $0.proxy != nil }),
-                    let proxy = chainAccount.proxy else {
-                    return false
-                }
-
-                return wallets.allSatisfy { wallet in
-                    guard !newRemovedIds.contains(wallet.identifier) else {
-                        return true
-                    }
-
-                    return !wallet.info.has(accountId: proxy.accountId, chainId: chainAccount.chainId)
-                }
+            let newProxiedIdsToRemove = allProxieds.filter { proxied in
+                !nonProxiedWalletReachable(
+                    from: proxied,
+                    wallets: wallets,
+                    removeIds: newRemovedIds
+                )
             }.map(\.identifier)
 
             oldRemovedIds = newRemovedIds

novawallet/Common/ViewModel/RemoteImageViewModel.swift

@@ -76,7 +76,7 @@ final class RemoteImageSerializer: CacheSerializer {
             return uiImage
         } else {
             let imsvg = SVGKImage(data: data)
-            return imsvg?.uiImage ?? UIImage()
+            return imsvg?.uiImage
         }
     }
 }

novawallet/Modules/DApp/DAppBrowser/StateMachine/PolkadotExtensionStates/DAppBrowserSigningState.swift

@@ -9,15 +9,20 @@ final class DAppBrowserSigningState: DAppBrowserBaseState {
         super.init(stateMachine: stateMachine)
     }
 
-    private func provideOperationResponse(with signature: Data, nextState: DAppBrowserStateProtocol) throws {
+    private func provideOperationResponse(
+        with signature: Data,
+        modifiedTransaction: Data?,
+        nextState: DAppBrowserStateProtocol
+    ) throws {
         guard let msgType = signingType.msgType else {
             return
         }
 
         let identifier = (0 ... UInt32.max).randomElement() ?? 0
         let result = PolkadotExtensionSignerResult(
             identifier: UInt(identifier),
-            signature: signature.toHex(includePrefix: true)
+            signature: signature.toHex(includePrefix: true),
+            signedTransaction: modifiedTransaction?.toHex(includePrefix: true)
         )
 
         try provideResponse(for: msgType, result: result, nextState: nextState)
@@ -54,7 +59,11 @@ extension DAppBrowserSigningState: DAppBrowserStateProtocol {
 
         if let signature = response.signature {
             do {
-                try provideOperationResponse(with: signature, nextState: nextState)
+                try provideOperationResponse(
+                    with: signature,
+                    modifiedTransaction: response.modifiedTransaction,
+                    nextState: nextState
+                )
             } catch {
                 stateMachine?.emit(error: error, nextState: nextState)
             }

novawallet/Modules/DApp/DAppOperationConfirm/DAppEthereumConfirmInteractor.swift

@@ -202,7 +202,7 @@ final class DAppEthereumConfirmInteractor: DAppOperationBaseInteractor {
                 switch result {
                 case let .success(txHash):
                     let txHashData = try Data(hexString: txHash)
-                    let response = DAppOperationResponse(signature: txHashData)
+                    let response = DAppOperationResponse(signature: txHashData, modifiedTransaction: nil)
                     let result: Result<DAppOperationResponse, Error> = .success(response)
                     self.presenter?.didReceive(responseResult: result, for: self.request)
                 case let .failure(error):
@@ -234,7 +234,7 @@ final class DAppEthereumConfirmInteractor: DAppOperationBaseInteractor {
             do {
                 switch result {
                 case let .success(signedTransaction):
-                    let response = DAppOperationResponse(signature: signedTransaction)
+                    let response = DAppOperationResponse(signature: signedTransaction, modifiedTransaction: nil)
                     let result: Result<DAppOperationResponse, Error> = .success(response)
                     self.presenter?.didReceive(responseResult: result, for: self.request)
                 case let .failure(error):
@@ -304,7 +304,7 @@ extension DAppEthereumConfirmInteractor: DAppOperationConfirmInteractorInputProt
     }
 
     func reject() {
-        let response = DAppOperationResponse(signature: nil)
+        let response = DAppOperationResponse(signature: nil, modifiedTransaction: nil)
         presenter?.didReceive(responseResult: .success(response), for: request)
     }
 

novawallet/Modules/DApp/DAppOperationConfirm/DAppEthereumSignBytesInteractor.swift

@@ -103,7 +103,7 @@ extension DAppEthereumSignBytesInteractor: DAppOperationConfirmInteractorInputPr
 
                     do {
                         let signature = try signingOperation.extractNoCancellableResultData()
-                        let response = DAppOperationResponse(signature: signature)
+                        let response = DAppOperationResponse(signature: signature, modifiedTransaction: nil)
 
                         self.presenter?.didReceive(responseResult: .success(response), for: self.request)
                     } catch {
@@ -119,7 +119,7 @@ extension DAppEthereumSignBytesInteractor: DAppOperationConfirmInteractorInputPr
     }
 
     func reject() {
-        let response = DAppOperationResponse(signature: nil)
+        let response = DAppOperationResponse(signature: nil, modifiedTransaction: nil)
         presenter?.didReceive(responseResult: .success(response), for: request)
     }
 

novawallet/Modules/DApp/DAppOperationConfirm/DAppOperationConfirmInteractor+Proccessing.swift

@@ -79,19 +79,13 @@ extension DAppOperationConfirmInteractor {
                 )
             }
 
-            // TODO: Find out whether to return this validation
-
             guard
-                let specVersion = BigUInt.fromHexString(extrinsic.specVersion) /* ,
-                 codingFactory.specVersion == specVersion */ else {
+                let specVersion = BigUInt.fromHexString(extrinsic.specVersion) else {
                 throw DAppOperationConfirmInteractorError.extrinsicBadField(name: "specVersion")
             }
 
-            // TODO: Find out whether to return this validation
-
             guard
-                let transactionVersion = BigUInt.fromHexString(extrinsic.transactionVersion) /* ,
-                 codingFactory.txVersion == transactionVersion */ else {
+                let transactionVersion = BigUInt.fromHexString(extrinsic.transactionVersion) else {
                 throw DAppOperationConfirmInteractorError.extrinsicBadField(name: "transactionVersion")
             }
 
@@ -135,6 +129,8 @@ extension DAppOperationConfirmInteractor {
                 specVersion: UInt32(specVersion),
                 tip: tip,
                 transactionVersion: UInt32(transactionVersion),
+                metadataHash: extrinsic.metadataHash,
+                withSignedTransaction: extrinsic.withSignedTransaction ?? false,
                 signedExtensions: expectedSignedExtensions,
                 version: extrinsic.version
             )