[trello.com/c/XEj672SB] code improvements

Author: StanislavDevIOS

Adamant/Modules/Wallets/Lisk/LskApiCore.swift

@@ -33,6 +33,19 @@ class LskApiCore: BlockchainHealthCheckableService {
         }
     }
 
+    func request<Output>(
+        node: CommonKit.Node,
+        _ body: @Sendable @escaping (APIClient) async throws -> Output
+    ) async -> WalletServiceResult<Output> {
+        let client = makeClient(node: node)
+        
+        do {
+            return .success(try await body(client))
+        } catch {
+            return .failure(mapError(error))
+        }
+    }
+    
     func getStatusInfo(node: CommonKit.Node) async -> WalletServiceResult<NodeStatusInfo> {
         let startTimestamp = Date.now.timeIntervalSince1970
 
@@ -69,3 +82,11 @@ private func mapError(_ error: APIError) -> WalletServiceError {
         return .remoteServiceError(message: error.message, error: error)
     }
 }
+
+private func mapError(_ error: Error) -> WalletServiceError {
+    if let error = error as? APIError {
+        return mapError(error)
+    }
+    
+    return .remoteServiceError(message: error.localizedDescription, error: error)
+}

Adamant/Modules/Wallets/Lisk/LskNodeApiService.swift

@@ -36,24 +36,18 @@ final class LskNodeApiService: WalletApiService {
     }
 
     func requestTransactionsApi<Output>(
-        body: @escaping @Sendable (
-            _ api: Transactions,
-            _ completion: @escaping @Sendable (LiskKit.Result<Output>) -> Void
-        ) -> Void
+        _ request: @Sendable @escaping (Transactions) async throws -> Output
     ) async -> WalletServiceResult<Output> {
-        await requestClient { client, completion in
-            body(.init(client: client), completion)
+        await requestClient { client in
+            try await request(Transactions(client: client))
         }
     }
 
     func requestAccountsApi<Output>(
-        body: @escaping @Sendable (
-            _ api: Accounts,
-            _ completion: @escaping @Sendable (LiskKit.Result<Output>) -> Void
-        ) -> Void
+        _ request: @Sendable @escaping (Accounts) async throws -> Output
     ) async -> WalletServiceResult<Output> {
-        await requestClient { client, completion in
-            body(.init(client: client), completion)
+        await requestClient { client in
+            try await request(Accounts(client: client))
         }
     }
 
@@ -75,4 +69,12 @@ private extension LskNodeApiService {
             await core.request(node: node, body: body)
         }
     }
+    
+    func requestClient<Output>(
+        _ body: @Sendable @escaping (APIClient) async throws -> Output
+    ) async -> WalletServiceResult<Output> {
+        await api.request { core, node in
+            await core.request(node: node, body)
+        }
+    }
 }

Adamant/Modules/Wallets/Lisk/LskServiceApiService.swift

@@ -55,6 +55,14 @@ final class LskServiceApiService: WalletApiService {
             body(.init(client: client, version: .v3), completion)
         }
     }
+    
+    func requestServiceApi<Output>(
+        _ request: @Sendable @escaping (LiskKit.Service) async throws -> Output
+    ) async -> WalletServiceResult<Output> {
+        await requestClient { client in
+            try await request(LiskKit.Service(client: client, version: .v3))
+        }
+    }
 }
 
 private extension LskServiceApiService {
@@ -68,4 +76,12 @@ private extension LskServiceApiService {
             await core.request(node: node, body: body)
         }
     }
+    
+    func requestClient<Output>(
+        _ body: @Sendable @escaping (APIClient) async throws -> Output
+    ) async -> WalletServiceResult<Output> {
+        await api.request { core, node in
+            await core.request(node: node, body)
+        }
+    }
 }

Adamant/Modules/Wallets/Lisk/LskWalletService+Send.swift

@@ -53,17 +53,8 @@ extension LskWalletService: WalletServiceTwoStepSend {
     }
 
     func sendTransaction(_ transaction: TransactionEntity) async throws {
-        _ = try await lskNodeApiService.requestTransactionsApi { api, completion in
-            Task {
-                do {
-                    let id = try await api.submit(transaction: transaction)
-                    completion(.success(response: id))
-                } catch let error as APIError {
-                    completion(.error(response: error))
-                } catch {
-                    completion(.error(response: APIError.unknown(code: nil)))
-                }
-            }
+        _ = try await lskNodeApiService.requestTransactionsApi { api in
+            try await api.submit(transaction: transaction)
         }.get()
     }
 }

Adamant/Modules/Wallets/Lisk/LskWalletService.swift

@@ -273,15 +273,8 @@ final class LskWalletService: WalletService {
             throw WalletServiceError.notLogged
         }
 
-        let minFeePerByte = try await lskNodeApiService.requestAccountsApi { api, completion in
-            Task {
-                do {
-                    let fee = try await api.getFees()
-                    completion(.success(response: fee.minFeePerByte))
-                } catch {
-                    completion(.error(response: mapError(error)))
-                }
-            }
+        let minFeePerByte = try await lskNodeApiService.requestAccountsApi { api in
+            try await api.getFees().minFeePerByte
         }.get()
 
         let tempTransaction = TransactionEntity().createTx(
@@ -298,15 +291,8 @@ final class LskWalletService: WalletService {
         let feeValue = tempTransaction.getFee(with: minFeePerByte)
         let fee = BigUInt(feeValue)
 
-        let lastBlock = try await lskNodeApiService.requestAccountsApi { api, completion in
-            Task {
-                do {
-                    let lastBlock = try await api.lastBlock()
-                    completion(.success(response: lastBlock))
-                } catch {
-                    completion(.error(response: mapError(error)))
-                }
-            }
+        let lastBlock = try await lskNodeApiService.requestAccountsApi { api in
+            try await api.lastBlock()
         }.get()
 
         let height = UInt64(lastBlock.header.height)
@@ -315,18 +301,18 @@ final class LskWalletService: WalletService {
     }
 
     func isExist(address: String) async throws -> Bool {
-        let result = try await lskServiceApiService.requestServiceApi { api, completion in
-            api.exist(address: address) { result in
-                switch result {
-                case .success(let response):
-                    completion(.success(response: response.data.isExists))
-                case .error(let error):
-                    completion(.error(response: mapError(error)))
+        try await lskServiceApiService.requestServiceApi { api in
+            try await withUnsafeThrowingContinuation { continuation in
+                api.exist(address: address) { result in
+                    switch result {
+                    case .success(let response):
+                        continuation.resume(returning: response.data.isExists)
+                    case .error(let error):
+                        continuation.resume(throwing: error)
+                    }
                 }
             }
         }.get()
-        
-        return result
     }
 }
 
@@ -486,16 +472,10 @@ extension LskWalletService {
     }
 
     func getBalance(address: String) async throws -> Decimal {
-        let result = await lskNodeApiService.requestAccountsApi { api, completion in
-            Task {
-                do {
-                    let balanceRaw = try await api.balance(address: address)
-                    let balance = BigUInt(balanceRaw?.availableBalance ?? "0") ?? .zero
-                    completion(.success(response: balance))
-                } catch {
-                    completion(.error(response: mapError(error)))
-                }
-            }
+        let result = await lskNodeApiService.requestAccountsApi { api in
+            let balanceRaw = try await api.balance(address: address)
+            let balance = BigUInt(balanceRaw?.availableBalance ?? "0") ?? .zero
+            return balance
         }
 
         switch result {
@@ -507,23 +487,11 @@ extension LskWalletService {
     }
 
     func getNonce(address: String) async throws -> UInt64 {
-        let result = await lskNodeApiService.requestAccountsApi { api, completion in
-            Task {
-                do {
-                    let nonce = try await api.nonce(address: address)
-                    completion(.success(response: UInt64(nonce) ?? .zero))
-                } catch {
-                    completion(.error(response: mapError(error)))
-                }
-            }
-        }
+        let nonce = try await lskNodeApiService.requestAccountsApi { api in
+            try await api.nonce(address: address)
+        }.get()
 
-        switch result {
-        case let .success(nonce):
-            return nonce
-        case let .failure(error):
-            throw error
-        }
+        return UInt64(nonce) ?? .zero
     }
 
     func handleAccountSuccess(with balance: String?, completion: @escaping (WalletServiceResult<Decimal>) -> Void) {
@@ -684,14 +652,3 @@ extension LskWalletService: PrivateKeyGenerator {
         return keypair.privateKeyString
     }
 }
-
-
-private func mapError(_ error: Error) -> APIError {
-    if let error = error as? APIError {
-        return error
-    } else if let _ = error as? URLError {
-        return APIError.noNetwork
-    } else {
-        return APIError.unknown(code: nil)
-    }
-}