API preferred rep based on weight (#1)

* update api to determine preferred rep based on the highest weight

* improve client send overload functions

* improve api to return updated reps

* skip reps that can't issue temporary vote

Author: davidscheutz

Sources/KeetaClient/Client/KeetaClient.swift

@@ -56,9 +56,8 @@ public final class KeetaClient {
     }
 
     @discardableResult
-    public func send(amount: BigInt, from fromPubKeyAccount: String, to toPubKeyAccount: String, memo: String? = nil) async throws -> String {
+    public func send(amount: BigInt, from fromAccount: Account, to toPubKeyAccount: String, memo: String? = nil) async throws -> String {
         let toAccount = try AccountBuilder.create(fromPublicKey: toPubKeyAccount)
-        let fromAccount = try AccountBuilder.create(fromPublicKey: fromPubKeyAccount)
         return try await send(amount: amount, from: fromAccount, to: toAccount, memo: memo)
     }
 
@@ -68,9 +67,8 @@ public final class KeetaClient {
     }
 
     @discardableResult
-    public func send(amount: BigInt, from fromPubKeyAccount: String, to toPubKeyAccount: String, token tokenPubKey: String, memo: String? = nil) async throws -> String {
+    public func send(amount: BigInt, from fromAccount: Account, to toPubKeyAccount: String, token tokenPubKey: String, memo: String? = nil) async throws -> String {
         let toAccount = try AccountBuilder.create(fromPublicKey: toPubKeyAccount)
-        let fromAccount = try AccountBuilder.create(fromPublicKey: fromPubKeyAccount)
         let token = try AccountBuilder.create(fromPublicKey: tokenPubKey)
         return try await send(amount: amount, from: fromAccount, to: toAccount, token: token, memo: memo)
     }

Sources/KeetaClient/Networking/ClientRepresentative.swift

@@ -13,3 +13,9 @@ public struct ClientRepresentative {
         self.weight = weight
     }
 }
+
+extension [ClientRepresentative] {
+    var preferred: Element? {
+        self.max { ($0.weight ?? 0) < ($1.weight ?? 0) }
+    }
+}

Sources/KeetaClient/Networking/KeetaApi.swift

@@ -5,6 +5,7 @@ public enum KeetaApiError: Error {
     case invalidBalanceValue(_ value: String)
     case invalidSupplyValue(_ value: String)
     case clientRepresentativeNotFound(_ address: String)
+    case noVotes(errors: [Error])
     case missingAtLeastOneRep
     case blockMismatch
     case notPublished
@@ -13,9 +14,9 @@ public enum KeetaApiError: Error {
 public final class KeetaApi: HTTPClient {
 
     public var preferredRep: ClientRepresentative
+    public var reps: [ClientRepresentative]
 
     private let publishAidUrl: String
-    private let reps: [ClientRepresentative]
     private let decoder: Decoder = JSONDecoder()
 
     public convenience init(config: NetworkConfig) throws {
@@ -27,7 +28,7 @@ public final class KeetaApi: HTTPClient {
 
         self.publishAidUrl = publishAidUrl
         self.reps = reps
-        self.preferredRep = preferredRep ?? reps[0]
+        self.preferredRep = reps.preferred ?? reps[0]
     }
 
     public func votes(for blocks: [Block], temporaryVotes: [Vote]? = nil) async throws -> [Vote] {
@@ -47,17 +48,38 @@ public final class KeetaApi: HTTPClient {
 
         // Request votes
         let requests = try KeetaEndpoint.votes(for: blocks, temporaryVotes: temporaryVotes, from: repUrls)
+        var errors = [Error]()
 
-        return try await withThrowingTaskGroup(of: VoteResponse.self) { group in
+        return try await withThrowingTaskGroup(of: VoteResponse?.self) { group in
             for request in requests {
-                group.addTask { try await self.sendRequest(to: request) }
+                group.addTask {
+                    do {
+                        return try await self.sendRequest(to: request)
+                    } catch {
+                        if temporaryVotes?.isEmpty == false {
+                            // a permanent vote is required for each temporary vote
+                            throw error
+                        } else {
+                            // silently skip reps that can't provide a temporary vote
+                            errors.append(error)
+                            return nil
+                        }
+                    }
+                }
             }
 
             var results: [Vote] = []
             for try await result in group {
-                let vote = try Vote.create(from: result.vote.binary)
-                results.append(vote)
+                if let result {
+                    let vote = try Vote.create(from: result.vote.binary)
+                    results.append(vote)
+                }
+            }
+            
+            guard !results.isEmpty else {
+                throw KeetaApiError.noVotes(errors: errors)
             }
+            
             return results
         }
     }
@@ -131,7 +153,9 @@ public final class KeetaApi: HTTPClient {
         }
     }
 
-    public func balance(for account: Account) async throws -> AccountBalance {
+    public func balance(for account: Account, replaceReps: Bool = false) async throws -> AccountBalance {
+        try await updateRepresentatives(replace: replaceReps)
+        
         let repUrl = preferredRep.apiUrl
         let result: AccountStateResponse = try await sendRequest(to: KeetaEndpoint.accountInfo(of: account, baseUrl: repUrl))
 
@@ -146,6 +170,39 @@ public final class KeetaApi: HTTPClient {
         return .init(account: result.account, balances: balances, currentHeadBlock: result.currentHeadBlock)
     }
 
+    @discardableResult
+    public func updateRepresentatives(replace: Bool = true) async throws -> [ClientRepresentative] {
+        let endpoint = KeetaEndpoint.representatives(baseUrl: preferredRep.apiUrl)
+        let response: RepresentativesResponse = try await sendRequest(to: endpoint)
+        
+        func rep(from rep: RepresentativeResponse) -> ClientRepresentative {
+            .init(
+                address: rep.representative,
+                apiUrl: rep.endpoints.api,
+                socketUrl: rep.endpoints.p2p,
+                weight: BigInt(hex: rep.weight)
+            )
+        }
+        
+        if reps.isEmpty || replace {
+            reps = response.representatives.map { rep(from: $0) }
+        } else {
+            // only update known reps
+            for (index, knownRep) in reps.enumerated() {
+                if let update = response.representatives
+                    .first(where: { $0.representative.lowercased() == knownRep.address.lowercased() }) {
+                    reps[index] = rep(from: update)
+                }
+            }
+        }
+        
+        if let preferredRep = reps.preferred {
+            self.preferredRep = preferredRep
+        }
+        
+        return reps
+    }
+    
     public func accountInfo(for account: Account) async throws -> AccountInfo {
         let repUrl = preferredRep.apiUrl
         let result: AccountStateResponse = try await sendRequest(to: KeetaEndpoint.accountInfo(of: account, baseUrl: repUrl))

Sources/KeetaClient/Networking/KeetaEndpoint.swift

@@ -49,6 +49,10 @@ struct KeetaEndpoint: Endpoint {
         return repBaseUrls.map { .init(url: $0 + "/node/publish", method: .post, body: body) }
     }
 
+    static func representatives(baseUrl: String) -> Self {
+        .init(url: baseUrl + "/node/ledger/representatives", method: .get)
+    }
+    
     static func accountInfo(of account: Account, baseUrl: String) -> Self {
         .init(url: baseUrl + "/node/ledger/account/\(account.publicKeyString)", method: .get)
     }

Sources/KeetaClient/Networking/Responses/ClientResponse.swift

@@ -0,0 +1,15 @@
+struct RepresentativesResponse: Decodable {
+    let representatives: [RepresentativeResponse]
+    
+}
+
+struct RepresentativeResponse: Decodable {
+    let representative: String
+    let weight: String
+    let endpoints: Endpoints
+}
+
+struct Endpoints: Decodable {
+    let api: String
+    let p2p: String
+}

Tests/KeetaClientTests/ApiTests.swift

@@ -141,6 +141,21 @@ class ApiTests: XCTestCase {
         try await api.verify(account: newRecipient, head: nil, balance: .init(2))
     }
 
+    func test_updateReps() async throws {
+        let api = try createAPI()
+        try await api.updateRepresentatives()
+        
+        api.reps.forEach {
+            XCTAssertNotNil($0.weight, "Expected rep \($0.address) to have weight")
+        }
+        
+        let preferredRep = try XCTUnwrap(api.preferredRep)
+        let otherReps = api.reps.filter { $0.address != preferredRep.address }
+        
+        let highestWeight = try XCTUnwrap(preferredRep.weight)
+        XCTAssertTrue(otherReps.allSatisfy { ($0.weight ?? 0) <= highestWeight })
+    }
+    
     func test_history() async throws {
         let api = try createAPI()
         let history = try await api.history(of: wellFundedAccount)