added TransactionChecker protocol and implement logic to verify that previous accounts have transactions

Author: albertopeam

Sources/Web3Core/KeystoreManager/BIP44.swift

@@ -14,25 +14,53 @@ public protocol BIP44 {
     - Throws: `BIP44Error.warning` if the child key shouldn't be used according to BIP44 standard.
     - Returns: an HDNode child key for the provided `path` if it can be created, otherwise nil
      */
-    func derive(path: String, warns: Bool) async throws -> HDNode?
+    func derive(path: String, warns: Bool, transactionChecker: TransactionChecker) async throws -> HDNode?
 }
 
-public enum BIP44Error: Equatable {
+public enum BIP44Error: Error, Equatable {
     /// The selected path doesn't fulfill BIP44 standard, you can derive the root key anyway
     case warning
 }
 
+public protocol TransactionChecker {
+    /**
+    It verifies if the provided `address` has at least one transaction
+     
+     - Parameter address: to be queried
+     - Throws: any error related to query the blockchain provider
+     - Returns: true if the `address` has at least one transaction, false otherwise
+     */
+    func hasTransactions(address: String) async throws -> Bool
+}
+
 extension HDNode: BIP44 {
-    public func derive(path: String, warns: Bool = true) async throws -> HDNode? {
+    public func derive(path: String, warns: Bool = true, transactionChecker: TransactionChecker) async throws -> HDNode? {
         if warns {
             guard let account = path.accountFromPath else {
                 return nil
             }
             if account == 0 {
                 return derive(path: path, derivePrivateKey: true)
+            } else {
+                for searchAccount in 0..<account {
+                    let maxUnusedAddressIndexes = 20
+                    var hasTransactions = false
+                    for searchAddressIndex in 0..<maxUnusedAddressIndexes {
+                        if let searchPath = path.newPath(account: searchAccount, addressIndex: searchAddressIndex),
+                           let childNode = derive(path: searchPath, derivePrivateKey: true),
+                           let ethAddress = Utilities.publicToAddress(childNode.publicKey) {
+                            hasTransactions = try await transactionChecker.hasTransactions(address: ethAddress.address)
+                            if hasTransactions {
+                                break
+                            }
+                        }
+                    }
+                    if !hasTransactions {
+                        throw BIP44Error.warning
+                    }
+                }
+                return derive(path: path, derivePrivateKey: true)
             }
-            var accountIndex = 0
-            return nil
         } else {
             return derive(path: path, derivePrivateKey: true)
         }
@@ -70,7 +98,7 @@ extension String {
      Transforms a bip44 path into a new one changing `account` & `index`. The resulting one will have the change value equal to `0` to represent external chain. Format `m/44'/coin_type'/account'/change/address_index`
      - Parameter account: the new `account` to use
      - Parameter addressIndex: the new `addressIndex` to use
-     - Returns: a valid bip44 path or nil otherwise
+     - Returns: a valid bip44 path with the provided `account`, `addressIndex`and external `change` or nil otherwise
     */
     func newPath(account: Int, addressIndex: Int) -> String? {
         guard isBip44Path else {
@@ -83,8 +111,6 @@ extension String {
         components[changePosition] = "0"
         let addressIndexPosition = 5
         components[addressIndexPosition] = "\(addressIndex)"
-        let result = components.joined(separator: "/")
-        return result
+        return components.joined(separator: "/")
     }
 }
-

Tests/web3swiftTests/localTests/BIP44Tests.swift

@@ -8,23 +8,93 @@ import Web3Core
 @testable import web3swift
 
 final class BIP44Tests: LocalTestCase {
+    private var mockTransactionChecker: MockTransactionChecker!
+    
+    override func setUpWithError() throws {
+        try super.setUpWithError()
+        mockTransactionChecker = MockTransactionChecker()
+    }
+    
+    override func tearDownWithError() throws {
+        try super.tearDownWithError()
+        mockTransactionChecker = nil
+    }
 
+    //MARK: - warns false
+    
     func testDeriveNoWarn() async throws {
         let rootNode = try rootNode()
 
-        let childNode = try await rootNode.derive(path: "m/44'/60'/8096'/0/1", warns: false)
+        let childNode = try await rootNode.derive(path: "m/44'/60'/8096'/0/1", warns: false, transactionChecker: mockTransactionChecker)
 
         XCTAssertEqual(try XCTUnwrap(childNode).publicKey.toHexString(), "035785d4918449c87892371c0f9ccf6e4eda40a7fb0f773f1254c064d3bba64026")
     }
-   
-    func testAccountZeroCanBeDerived() async throws {
+
+    //MARK: - warns true
+    
+    func testDeriveInvalidPath() async throws {
         let rootNode = try rootNode()
 
-        let childNode = try await rootNode.derive(path: "m/44'/60'/0'/0/255", warns: true)
+        let childNode = try? await rootNode.derive(path: "", warns: true, transactionChecker: mockTransactionChecker)
+        
+        XCTAssertNil(childNode)
+    }
+    
+    func testAccountZeroCanBeDerivedAlways() async throws {
+        let rootNode = try rootNode()
+        
+        let childNode = try await rootNode.derive(path: "m/44'/60'/0'/0/255", warns: true, transactionChecker: mockTransactionChecker)
 
         XCTAssertEqual(try XCTUnwrap(childNode).publicKey.toHexString(), "0262fba1af8f149258123265318114066decf50d16c1222a9d657b7de2296c2734")
     }
 
+    func testAccountOneWithoutTransactionsInAccountZeroWarns() async throws {
+        do {
+            let rootNode = try rootNode()
+            let path = "m/44'/60'/1'/0/0"
+            mockTransactionChecker.results = false.times(n: 20)
+            
+            let _ = try await rootNode.derive(path: path, warns: true, transactionChecker: mockTransactionChecker)
+            
+            XCTFail("Child must not be created usign warns true for the path: \(path)")
+        } catch BIP44Error.warning {
+            XCTAssertTrue(true)
+        }
+    }
+    
+    func testAccountOneWithTransactionsInAccountZeroNotWarns() async throws {
+        do {
+            let rootNode = try rootNode()
+            let path = "m/44'/60'/1'/0/0"
+            var results = false.times(n: 19)
+            results.append(true)
+            mockTransactionChecker.results = results
+            
+            let childNode = try await rootNode.derive(path: path, warns: true, transactionChecker: mockTransactionChecker)
+            
+            XCTAssertEqual(try XCTUnwrap(childNode).publicKey.toHexString(), "036cd8f1bad46fa7caf7a80d48528b90db2a3b7a5c9a18d74d61b286e03850abf4")
+        } catch BIP44Error.warning {
+            XCTFail("BIP44Error.warning must not be thrown")
+        }
+    }
+    
+    func testAccountTwoWithTransactionsInAccountZeroButNotInOneWarns() async throws {
+        do {
+            let rootNode = try rootNode()
+            let path = "m/44'/60'/2'/0/0"
+            var results: Array<Bool> = .init()
+            results.append(true)
+            results.append(contentsOf: false.times(n: 20))
+            mockTransactionChecker.results = results
+            
+            let _ = try await rootNode.derive(path: path, warns: true, transactionChecker: mockTransactionChecker)
+            
+            XCTFail("Child must not be created usign warns true for the path: \(path)")
+        } catch BIP44Error.warning {
+            XCTAssertTrue(true)
+        }
+    }
+    
     // MARK: - private
 
     private func rootNode() throws -> HDNode {
@@ -33,3 +103,23 @@ final class BIP44Tests: LocalTestCase {
         return try XCTUnwrap(HDNode(seed: seed))
     }
 }
+
+extension Bool {
+    func times(n: Int) -> Array<Bool> {
+        var array: Array<Bool> = .init()
+        (0..<n).forEach { _ in
+            array.append(self)
+        }
+        return array
+    }
+}
+
+private final class MockTransactionChecker: TransactionChecker {
+    var addresses: [String] = .init()
+    var results: [Bool] = .init()
+    
+    func hasTransactions(address: String) async throws -> Bool {
+        addresses.append(address)
+        return results.removeFirst()
+    }
+}