vws unstoppable support

Author: justinvforvendetta

Sources/Components/Inputs/CurrencyInput.swift

@@ -58,7 +58,9 @@ class CurrencyInput: UITextField {
     }
 
     public func setAmount(_ amount: NSNumber) {
-        text = amount.toBlankCurrency(fractDigits: Constants.maximumFractionDigits)
+        let safeAmount = amount.doubleValue.isFinite ? amount : NSNumber(value: 0.0)
+
+        text = safeAmount.toBlankCurrency(fractDigits: Constants.maximumFractionDigits)
         text = text?.replacingOccurrences(of: " ", with: "")
 
         format()

Sources/Extensions/NSNumber+Currency.swift

@@ -17,6 +17,10 @@ extension NSNumber {
     }
 
     func toCurrency(currency: String? = nil, fractDigits: Int = 2, floating: Bool = true) -> String {
+        guard doubleValue.isFinite else {
+            return currency == "XVG" ? "0 XVG" : "0"
+        }
+
         let formatter = NumberFormatter()
         formatter.numberStyle = .currency
         if floating == false {
@@ -33,7 +37,7 @@ extension NSNumber {
         }
 
         // Remove extra symbol space
-        return "\(formatter.string(from: self)!)\(suffix)"
+        return "\(formatter.string(from: self) ?? "0")\(suffix)"
     }
 
     func toPairCurrency(fractDigits: Int = 2) -> String {
@@ -63,6 +67,10 @@ extension NSNumber {
     }
 
     func toBlankCurrency(fractDigits: Int = 2, floating: Bool = true) -> String {
+        guard doubleValue.isFinite else {
+            return "0"
+        }
+
         let formatter = NumberFormatter()
         formatter.numberStyle = .currency
         if floating == false { // Freeze fractDigits number
@@ -73,6 +81,6 @@ extension NSNumber {
         formatter.currencySymbol = ""
 
         // Remove extra symbol space
-        return "\(formatter.string(from: self)!)"
+        return formatter.string(from: self) ?? "0"
     }
 }

Sources/Providers/WalletServiceProvider.swift

@@ -21,6 +21,7 @@ class WalletServiceProvider: ServiceProvider {
         registerWalletClient()         // Depends on Credentials & HttpSession
         registerTransactionRepository()
         registerTransactionFactory()   // Depends on RatesClient & ApplicationRepository
+        registerTxTransponder()
         registerTransactionManager()
         registerWalletTicker()         // Depends on WalletClient & TransactionManager
         registerFiatRateTicker()       // Depends on RatesClient & ApplicationRepository
@@ -52,6 +53,12 @@ class WalletServiceProvider: ServiceProvider {
         }
     }
 
+    func registerTxTransponder() {
+        container.register(TxTransponderProtocol.self) { r in
+            TxTransponder(walletClient: r.resolve(WalletClientProtocol.self)!)
+        }
+    }
+
     // MARK: - Transaction Manager
     func registerTransactionManager() {
         container.register(TransactionManager.self) { r in

Sources/Wallet/AddressValidator.swift

@@ -20,8 +20,44 @@ class AddressValidator {
         _ currency: String?
     ) -> Void
 
-   
+    enum ResolutionError: Error {
+        case missingApiToken
+        case httpStatus(Int)
+        case emptyResponse
+        case noRecords
+        case recordNotFound
+        case invalidJson
+        case invalidResolvedAddress
+    }
+
+    private enum UnstoppableDomains {
+        static let apiBaseUrl = "https://api.unstoppabledomains.com/resolve/domains/"
+        static let recordKey = "crypto.XVG.address"
+
+        static var apiToken: String? {
+            return Bundle.main.object(forInfoDictionaryKey: "UNSTOPPABLE_DOMAINS_API_TOKEN") as? String
+        }
+
+        static func looksLikeDomain(_ value: String) -> Bool {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+
+            return trimmed.firstIndex(of: ".") != nil
+                && trimmed.firstIndex(of: ".") != trimmed.startIndex
+                && !trimmed.contains(" ")
+                && !trimmed.contains("://")
+                && !trimmed.contains("/")
+        }
+    }
+
+    private struct UnstoppableDomainsResponse: Decodable {
+        let records: [String: String]?
+    }
+
     static func validate(address: String) -> Bool {
+        if validateVergeLegacy(address: address) {
+            return true
+        }
+
         // Try legacy first
         if let _ = try? BitcoinAddress(legacy: address) {
             return true
@@ -35,6 +71,17 @@ class AddressValidator {
         return false
     }
 
+    private static func validateVergeLegacy(address: String) -> Bool {
+        guard let payload = Base58Check.decode(address), payload.count == 21 else {
+            return false
+        }
+
+        let versionByte = payload[0]
+
+        return versionByte == Network.mainnetXVG.pubkeyhash
+            || versionByte == Network.mainnetXVG.scripthash
+    }
+
 
 
     func validate(
@@ -45,21 +92,56 @@ class AddressValidator {
     }
 
     func validate(string: String, completion: @escaping ValidationCompletion) {
+        validate(string: string, resolveDomains: false) { valid, address, amount, label, currency, _ in
+            completion(valid, address, amount, label, currency)
+        }
+    }
+
+    func validateOrResolve(string: String, completion: @escaping ValidationCompletion) {
+        validateOrResolve(string: string) { valid, address, amount, label, currency, _ in
+            completion(valid, address, amount, label, currency)
+        }
+    }
+
+    func validateOrResolve(
+        string: String,
+        completion: @escaping (
+            _ valid: Bool,
+            _ address: String?,
+            _ amount: NSNumber?,
+            _ label: String?,
+            _ currency: String?,
+            _ error: ResolutionError?
+        ) -> Void
+    ) {
+        validate(string: string, resolveDomains: true, completion: completion)
+    }
+
+    private func validate(
+        string: String,
+        resolveDomains: Bool,
+        completion: @escaping (
+            _ valid: Bool,
+            _ address: String?,
+            _ amount: NSNumber?,
+            _ label: String?,
+            _ currency: String?,
+            _ error: ResolutionError?
+        ) -> Void
+    ) {
         var valid = false
         var address: String?
         var amount: NSNumber?
         var label: String?
         var currency: String?
 
         let parameters = self.normalizeUrl(url: string)
+        let addressParam = parameters["address"] ?? nil
 
-        guard let addressParam = parameters["address"], AddressValidator.validate(address: addressParam ?? "") else {
-            return completion(valid, address, amount, label, currency)
+        guard let recipient = addressParam else {
+            return completion(valid, address, amount, label, currency, nil)
         }
 
-        address = addressParam
-        valid = true
-
         if let amountParam = parameters["amount"], amountParam != nil {
             amount = self.amountToNumber(stringAmount: amountParam!)
         }
@@ -72,7 +154,29 @@ class AddressValidator {
             currency = currencyParam?.uppercased() == "XVG" ? nil : currencyParam
         }
 
-        completion(valid, address, amount, label, currency)
+        if AddressValidator.validate(address: recipient) {
+            valid = true
+            address = recipient
+
+            return completion(valid, address, amount, label, currency, nil)
+        }
+
+        guard resolveDomains, UnstoppableDomains.looksLikeDomain(recipient) else {
+            return completion(valid, address, amount, label, currency, nil)
+        }
+
+        resolveUnstoppableDomain(recipient) { result in
+            switch result {
+            case .success(let resolvedAddress):
+                guard AddressValidator.validate(address: resolvedAddress) else {
+                    return completion(false, nil, amount, label, currency, .invalidResolvedAddress)
+                }
+
+                completion(true, resolvedAddress, amount, label, currency, nil)
+            case .failure(let error):
+                completion(false, nil, amount, label, currency, error)
+            }
+        }
     }
 
     fileprivate func amountToNumber(stringAmount: String) -> NSNumber? {
@@ -104,4 +208,55 @@ class AddressValidator {
 
         return parameters
     }
+
+    private func resolveUnstoppableDomain(_ domain: String, completion: @escaping (Result<String, ResolutionError>) -> Void) {
+        guard let token = UnstoppableDomains.apiToken, !token.isEmpty else {
+            return completion(.failure(.missingApiToken))
+        }
+
+        let trimmedDomain = domain.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard let encodedDomain = trimmedDomain.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed),
+            let url = URL(string: UnstoppableDomains.apiBaseUrl + encodedDomain)
+        else {
+            return completion(.failure(.recordNotFound))
+        }
+
+        var request = URLRequest(url: url)
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+
+        URLSession.shared.dataTask(with: request) { data, response, _ in
+            guard let httpResponse = response as? HTTPURLResponse else {
+                return completion(.failure(.emptyResponse))
+            }
+
+            guard httpResponse.statusCode == 200 else {
+                return completion(.failure(.httpStatus(httpResponse.statusCode)))
+            }
+
+            guard let data = data, !data.isEmpty else {
+                return completion(.failure(.emptyResponse))
+            }
+
+            guard let decoded = try? JSONDecoder().decode(UnstoppableDomainsResponse.self, from: data) else {
+                return completion(.failure(.invalidJson))
+            }
+
+            guard let records = decoded.records else {
+                return completion(.failure(.noRecords))
+            }
+
+            guard let address = records[UnstoppableDomains.recordKey], !address.isEmpty else {
+                return completion(.failure(.recordNotFound))
+            }
+
+            completion(.success(self.normalizedResolvedAddress(address)))
+        }.resume()
+    }
+
+    private func normalizedResolvedAddress(_ address: String) -> String {
+        return address
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .replacingOccurrences(of: "verge://", with: "")
+            .replacingOccurrences(of: "verge:", with: "")
+    }
 }

Sources/Wallet/Credentials.swift

@@ -4,6 +4,7 @@ import BitcoinKit
 
 class Credentials {
     static let vergeCoinType: UInt32 = 77
+    static let legacyVwsCoinType: UInt32 = 0
     static let defaultAccount: UInt32 = 0
 
     enum CredentialsError: Error {
@@ -136,6 +137,19 @@ class Credentials {
             return privateKey1
         }
     }
+
+    // MARK: - Legacy VWS BIP44 account-level key (m/44'/0'/0')
+    var legacyVwsBip44PrivateKey: HDPrivateKey1 {
+        do {
+            return try privateKey1
+                .derived(at: 44, hardened: true)
+                .derived(at: Self.legacyVwsCoinType, hardened: true)
+                .derived(at: Self.defaultAccount, hardened: true)
+        } catch {
+            print("Failed to derive legacy VWS BIP44 private key: \(error)")
+            return privateKey1
+        }
+    }
 
     var publicKey: HDPublicKey {
         return bip44PrivateKey.extendedPublicKey()

Sources/Wallet/ElectrumXWalletClient.swift

@@ -548,6 +548,17 @@ final class ElectrumXWalletClient: WalletClientProtocol {
     }
 }
 
+extension ElectrumXWalletClient.ElectrumXWalletClientError: LocalizedError {
+    var errorDescription: String? {
+        switch self {
+        case .unsupportedOperation:
+            return "Sending from 18-word ElectrumX wallets is not implemented yet."
+        case .addressDerivationFailed:
+            return "Could not derive an ElectrumX wallet address."
+        }
+    }
+}
+
 final class RoutingWalletClient: WalletClientProtocol {
     private let applicationRepository: ApplicationRepository
     private let vwsClient: WalletClientProtocol

Sources/Wallet/NFCWalletTransactionFactory.swift

@@ -124,7 +124,7 @@ class NFCWalletTransactionFactory: NSObject, NFCNDEFReaderSessionDelegate {
             return
         }
 
-        self.addressValidator.validate(string: url) { isValid, address, amount, label, currency in
+        self.addressValidator.validateOrResolve(string: url) { isValid, address, amount, label, currency in
             let txFactory = self.sendTransactionDelegate.getSendTransaction()
 
             if let address = address, isValid {
@@ -153,7 +153,9 @@ class NFCWalletTransactionFactory: NSObject, NFCNDEFReaderSessionDelegate {
             txFactory.fiatRate = nil
             txFactory.fiatRateFetchedAt = nil
 
-            self.sendTransactionDelegate.didChangeSendTransaction(txFactory)
+            DispatchQueue.main.async {
+                self.sendTransactionDelegate.didChangeSendTransaction(txFactory)
+            }
         }
     }
 }