Merge pull request #759 from JeneaVranceanu/chore/bip32hdnode/swift-lint-cleanup

chore: BIP32HDNode - SwiftLint clean up

Author: JeneaVranceanu

Sources/Web3Core/KeystoreManager/BIP32HDNode.swift

@@ -9,8 +9,7 @@ import CryptoSwift
 
 extension UInt32 {
     public func serialize32() -> Data {
-        let uint32 = UInt32(self)
-        var bigEndian = uint32.bigEndian
+        var bigEndian = self.bigEndian
         let count = MemoryLayout<UInt32>.size
         let bytePtr = withUnsafePointer(to: &bigEndian) {
             $0.withMemoryRebound(to: UInt8.self, capacity: count) {
@@ -24,11 +23,11 @@ extension UInt32 {
 
 public class HDNode {
     public struct HDversion {
+        // swiftlint:disable force_unwrapping
         public var privatePrefix: Data = Data.fromHex("0x0488ADE4")!
         public var publicPrefix: Data = Data.fromHex("0x0488B21E")!
-        public init() {
-
-        }
+        // swiftlint:enable force_unwrapping
+        public init() {}
     }
     public var path: String? = "m"
     public var privateKey: Data?
@@ -38,23 +37,17 @@ public class HDNode {
     public var parentFingerprint: Data = Data(repeating: 0, count: 4)
     public var childNumber: UInt32 = UInt32(0)
     public var isHardened: Bool {
-        get {
-            return self.childNumber >= (UInt32(1) << 31)
-        }
+        childNumber >= (UInt32(1) << 31)
     }
     public var index: UInt32 {
-        get {
             if self.isHardened {
-                return self.childNumber - (UInt32(1) << 31)
+                return childNumber - (UInt32(1) << 31)
             } else {
-                return self.childNumber
+                return childNumber
             }
-        }
     }
     public var hasPrivate: Bool {
-        get {
-            return privateKey != nil
-        }
+        privateKey != nil
     }
 
     init() {
@@ -81,8 +74,11 @@ public class HDNode {
         chaincode = data[13..<45]
         if serializePrivate {
             privateKey = data[46..<78]
-            guard let pubKey = Utilities.privateToPublic(privateKey!, compressed: true) else { return nil }
-            if pubKey[0] != 0x02 && pubKey[0] != 0x03 { return nil }
+            guard
+                let privateKey = privateKey,
+                let pubKey = Utilities.privateToPublic(privateKey, compressed: true),
+                (pubKey[0] == 0x02 || pubKey[0] == 0x03)
+            else { return nil }
             publicKey = pubKey
         } else {
             publicKey = data[45..<78]
@@ -94,10 +90,10 @@ public class HDNode {
 
     public init?(seed: Data) {
         guard seed.count >= 16 else { return nil }
+        // swiftlint:disable force_unwrapping
         let hmacKey = "Bitcoin seed".data(using: .ascii)!
-        let hmac: Authenticator = HMAC(key: hmacKey.bytes, variant: HMAC.Variant.sha2(.sha512))
-        guard let entropy = try? hmac.authenticate(seed.bytes) else { return nil }
-        guard entropy.count == 64 else { return nil }
+        let hmac = HMAC(key: hmacKey.bytes, variant: HMAC.Variant.sha2(.sha512))
+        guard let entropy = try? hmac.authenticate(seed.bytes), entropy.count == 64 else { return nil }
         let I_L = entropy[0..<32]
         let I_R = entropy[32..<64]
         chaincode = Data(I_R)
@@ -112,6 +108,7 @@ public class HDNode {
     }
 
     private static var curveOrder = BigUInt("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", radix: 16)!
+    // swiftlint:enable force_unwrapping
     public static var defaultPath: String = "m/44'/60'/0'/0"
     public static var defaultPathPrefix: String = "m/44'/60'/0'"
     public static var defaultPathMetamask: String = "m/44'/60'/0'/0/0"
@@ -120,130 +117,15 @@ public class HDNode {
 }
 
 extension HDNode {
-    public func derive (index: UInt32, derivePrivateKey: Bool, hardened: Bool = false) -> HDNode? {
+    public func derive(index: UInt32, derivePrivateKey: Bool, hardened: Bool = false) -> HDNode? {
         if derivePrivateKey {
-            if self.hasPrivate { // derive private key when is itself extended private key
-                var entropy: [UInt8]
-                var trueIndex: UInt32
-                if index >= (UInt32(1) << 31) || hardened {
-                    trueIndex = index
-                    if trueIndex < (UInt32(1) << 31) {
-                        trueIndex = trueIndex + (UInt32(1) << 31)
-                    }
-                    let hmac: Authenticator = HMAC(key: self.chaincode.bytes, variant: .sha2(.sha512))
-                    var inputForHMAC = Data()
-                    inputForHMAC.append(Data([UInt8(0x00)]))
-                    inputForHMAC.append(self.privateKey!)
-                    inputForHMAC.append(trueIndex.serialize32())
-                    guard let ent = try? hmac.authenticate(inputForHMAC.bytes) else { return nil }
-                    guard ent.count == 64 else { return nil }
-                    entropy = ent
-                } else {
-                    trueIndex = index
-                    let hmac: Authenticator = HMAC(key: self.chaincode.bytes, variant: .sha2(.sha512))
-                    var inputForHMAC = Data()
-                    inputForHMAC.append(self.publicKey)
-                    inputForHMAC.append(trueIndex.serialize32())
-                    guard let ent = try? hmac.authenticate(inputForHMAC.bytes) else { return nil }
-                    guard ent.count == 64 else { return nil }
-                    entropy = ent
-                }
-                let I_L = entropy[0..<32]
-                let I_R = entropy[32..<64]
-                let cc = Data(I_R)
-                let bn = BigUInt(Data(I_L))
-                if bn > HDNode.curveOrder {
-                    if trueIndex < UInt32.max {
-                        return self.derive(index: index+1, derivePrivateKey: derivePrivateKey, hardened: hardened)
-                    }
-                    return nil
-                }
-                let newPK = (bn + BigUInt(self.privateKey!)) % HDNode.curveOrder
-                if newPK == BigUInt(0) {
-                    if trueIndex < UInt32.max {
-                        return self.derive(index: index+1, derivePrivateKey: derivePrivateKey, hardened: hardened)
-                    }
-                    return nil
-                }
-                guard let privKeyCandidate = newPK.serialize().setLengthLeft(32) else { return nil }
-                guard SECP256K1.verifyPrivateKey(privateKey: privKeyCandidate) else { return nil }
-                guard let pubKeyCandidate = SECP256K1.privateToPublic(privateKey: privKeyCandidate, compressed: true) else { return nil }
-                guard pubKeyCandidate.bytes[0] == 0x02 || pubKeyCandidate.bytes[0] == 0x03 else { return nil }
-                guard self.depth < UInt8.max else { return nil }
-                let newNode = HDNode()
-                newNode.chaincode = cc
-                newNode.depth = self.depth + 1
-                newNode.publicKey = pubKeyCandidate
-                newNode.privateKey = privKeyCandidate
-                newNode.childNumber = trueIndex
-                guard let fprint = try? RIPEMD160.hash(message: self.publicKey.sha256())[0..<4] else {
-                    return nil
-                }
-                newNode.parentFingerprint = fprint
-                var newPath = String()
-                if newNode.isHardened {
-                    newPath = self.path! + "/"
-                    newPath += String(newNode.index % HDNode.hardenedIndexPrefix) + "'"
-                } else {
-                    newPath = self.path! + "/" + String(newNode.index)
-                }
-                newNode.path = newPath
-                return newNode
-            } else {
-                return nil // derive private key when is itself extended public key (impossible)
-            }
-        } else { // deriving only the public key
-            var entropy: [UInt8] // derive public key when is itself public key
-            if index >= (UInt32(1) << 31) || hardened {
-                return nil // no derivation of hardened public key from extended public key
-            } else {
-                let hmac: Authenticator = HMAC(key: self.chaincode.bytes, variant: .sha2(.sha512))
-                var inputForHMAC = Data()
-                inputForHMAC.append(self.publicKey)
-                inputForHMAC.append(index.serialize32())
-                guard let ent = try? hmac.authenticate(inputForHMAC.bytes) else { return nil }
-                guard ent.count == 64 else { return nil }
-                entropy = ent
-            }
-            let I_L = entropy[0..<32]
-            let I_R = entropy[32..<64]
-            let cc = Data(I_R)
-            let bn = BigUInt(Data(I_L))
-            if bn > HDNode.curveOrder {
-                if index < UInt32.max {
-                    return self.derive(index: index+1, derivePrivateKey: derivePrivateKey, hardened: hardened)
-                }
-                return nil
-            }
-            guard let tempKey = bn.serialize().setLengthLeft(32) else { return nil }
-            guard SECP256K1.verifyPrivateKey(privateKey: tempKey) else { return nil }
-            guard let pubKeyCandidate = SECP256K1.privateToPublic(privateKey: tempKey, compressed: true) else { return nil }
-            guard pubKeyCandidate.bytes[0] == 0x02 || pubKeyCandidate.bytes[0] == 0x03 else { return nil }
-            guard let newPublicKey = SECP256K1.combineSerializedPublicKeys(keys: [self.publicKey, pubKeyCandidate], outputCompressed: true) else { return nil }
-            guard newPublicKey.bytes[0] == 0x02 || newPublicKey.bytes[0] == 0x03 else { return nil }
-            guard self.depth < UInt8.max else { return nil }
-            let newNode = HDNode()
-            newNode.chaincode = cc
-            newNode.depth = self.depth + 1
-            newNode.publicKey = newPublicKey
-            newNode.childNumber = index
-            guard let fprint = try? RIPEMD160.hash(message: self.publicKey.sha256())[0..<4] else {
-                return nil
-            }
-            newNode.parentFingerprint = fprint
-            var newPath = String()
-            if newNode.isHardened {
-                newPath = self.path! + "/"
-                newPath += String(newNode.index % HDNode.hardenedIndexPrefix) + "'"
-            } else {
-                newPath = self.path! + "/" + String(newNode.index)
-            }
-            newNode.path = newPath
-            return newNode
+            return self.derivePrivateKey(index: index, hardened: hardened)
+        } else {
+            return derivePublicKey(index: index, hardened: hardened)
         }
     }
 
-    public func derive (path: String, derivePrivateKey: Bool = true) -> HDNode? {
+    public func derive(path: String, derivePrivateKey: Bool = true) -> HDNode? {
         let components = path.components(separatedBy: "/")
         var currentNode: HDNode = self
         var firstComponent = 0
@@ -262,30 +144,158 @@ extension HDNode {
         return currentNode
     }
 
+    /// Derive public key when is itself private key.
+    /// Derivation of private key when is itself extended public key is impossible and will return `nil`.
+    private func derivePrivateKey(index: UInt32, hardened: Bool) -> HDNode? {
+        guard let privateKey = privateKey else {
+            // derive private key when is itself extended public key (impossible)
+            return nil
+        }
+
+        var trueIndex = index
+        if trueIndex < (UInt32(1) << 31) && hardened {
+            trueIndex += (UInt32(1) << 31)
+        }
+
+        guard let entropy = calculateEntropy(index: trueIndex, privateKey: privateKey, hardened: hardened) else { return nil }
+
+        let I_L = entropy[0..<32]
+        let I_R = entropy[32..<64]
+        let chainCode = Data(I_R)
+        let bn = BigUInt(Data(I_L))
+        if bn > HDNode.curveOrder {
+            if trueIndex < UInt32.max {
+                return self.derive(index: index + 1, derivePrivateKey: true, hardened: hardened)
+            }
+            return nil
+        }
+        let newPK = (bn + BigUInt(privateKey)) % HDNode.curveOrder
+        if newPK == BigUInt(0) {
+            if trueIndex < UInt32.max {
+                return self.derive(index: index + 1, derivePrivateKey: true, hardened: hardened)
+            }
+            return nil
+        }
+
+        guard
+            let newPrivateKey = newPK.serialize().setLengthLeft(32),
+            SECP256K1.verifyPrivateKey(privateKey: newPrivateKey),
+            let newPublicKey = SECP256K1.privateToPublic(privateKey: newPrivateKey, compressed: true),
+            (newPublicKey.bytes[0] == 0x02 || newPublicKey.bytes[0] == 0x03),
+            self.depth < UInt8.max
+        else { return nil }
+        return createNode(chainCode: chainCode, depth: depth + 1, publicKey: newPublicKey, privateKey: newPrivateKey, childNumber: trueIndex)
+    }
+
+    /// Derive public key when is itself public key.
+    /// No derivation of hardened public key from extended public key is allowed.
+    private func derivePublicKey(index: UInt32, hardened: Bool) -> HDNode? {
+        if index >= (UInt32(1) << 31) || hardened {
+            // no derivation of hardened public key from extended public key
+            return nil
+        }
+
+        guard let entropy = calculateEntropy(index: index, hardened: hardened) else { return nil }
+
+        let I_L = entropy[0..<32]
+        let I_R = entropy[32..<64]
+        let chainCode = Data(I_R)
+        let bn = BigUInt(Data(I_L))
+        if bn > HDNode.curveOrder {
+            if index < UInt32.max {
+                return self.derive(index: index+1, derivePrivateKey: false, hardened: hardened)
+            }
+            return nil
+        }
+
+        guard
+            let tempKey = bn.serialize().setLengthLeft(32),
+            SECP256K1.verifyPrivateKey(privateKey: tempKey),
+            let pubKeyCandidate = SECP256K1.privateToPublic(privateKey: tempKey, compressed: true),
+            (pubKeyCandidate.bytes[0] == 0x02 || pubKeyCandidate.bytes[0] == 0x03),
+            let newPublicKey = SECP256K1.combineSerializedPublicKeys(keys: [self.publicKey, pubKeyCandidate], outputCompressed: true),
+            (newPublicKey.bytes[0] == 0x02 || newPublicKey.bytes[0] == 0x03),
+            self.depth < UInt8.max
+        else { return nil }
+
+        return createNode(chainCode: chainCode, depth: depth + 1, publicKey: newPublicKey, childNumber: index)
+    }
+
+    private func createNode(chainCode: Data, depth: UInt8, publicKey: Data, privateKey: Data? = nil, childNumber: UInt32) -> HDNode? {
+        let newNode = HDNode()
+        newNode.chaincode = chainCode
+        newNode.depth = depth
+        newNode.publicKey = publicKey
+        newNode.privateKey = privateKey
+        newNode.childNumber = childNumber
+        guard
+            let fprint = try? RIPEMD160.hash(message: self.publicKey.sha256())[0..<4],
+            let path = path
+        else { return nil }
+        newNode.parentFingerprint = fprint
+        var newPath = String()
+        if newNode.isHardened {
+            newPath = path + "/"
+            newPath += String(newNode.index % HDNode.hardenedIndexPrefix) + "'"
+        } else {
+            newPath = path + "/" + String(newNode.index)
+        }
+        newNode.path = newPath
+        return newNode
+    }
+
+    private func calculateHMACInput(_ index: UInt32, privateKey: Data? = nil, hardened: Bool) -> Data {
+        var inputForHMAC = Data()
+
+        if let privateKey = privateKey, (index >= (UInt32(1) << 31) || hardened) {
+            inputForHMAC.append(Data([UInt8(0x00)]))
+            inputForHMAC.append(privateKey)
+        } else {
+            inputForHMAC.append(self.publicKey)
+        }
+
+        inputForHMAC.append(index.serialize32())
+        return inputForHMAC
+    }
+
+    /// Calculates entropy used for private or public key derivation.
+    /// - Parameters:
+    ///   - index: index
+    ///   - privateKey: private key data or `nil` if entropy is calculated for a public key;
+    ///   - hardened: is hardened key
+    /// - Returns: 64 bytes entropy or `nil`.
+    private func calculateEntropy(index: UInt32, privateKey: Data? = nil, hardened: Bool) -> [UInt8]? {
+        let inputForHMAC = calculateHMACInput(index, privateKey: privateKey, hardened: hardened)
+        let hmac = HMAC(key: self.chaincode.bytes, variant: .sha2(.sha512))
+        guard let entropy = try? hmac.authenticate(inputForHMAC.bytes), entropy.count == 64 else { return nil }
+        return entropy
+    }
+
     public func serializeToString(serializePublic: Bool = true, version: HDversion = HDversion()) -> String? {
         guard let data = self.serialize(serializePublic: serializePublic, version: version) else { return nil }
-        let encoded = Base58.base58FromBytes(data.bytes)
-        return encoded
+        return Base58.base58FromBytes(data.bytes)
     }
 
     public func serialize(serializePublic: Bool = true, version: HDversion = HDversion()) -> Data? {
         var data = Data()
-        if !serializePublic && !self.hasPrivate { return nil }
+        /// Public or private key
+        let keyData: Data
         if serializePublic {
+            keyData = publicKey
             data.append(version.publicPrefix)
         } else {
+            guard let privateKey = privateKey else { return nil }
+            keyData = privateKey
             data.append(version.privatePrefix)
         }
-        data.append(contentsOf: [self.depth])
-        data.append(self.parentFingerprint)
-        data.append(self.childNumber.serialize32())
-        data.append(self.chaincode)
-        if serializePublic {
-            data.append(self.publicKey)
-        } else {
+        data.append(contentsOf: [depth])
+        data.append(parentFingerprint)
+        data.append(childNumber.serialize32())
+        data.append(chaincode)
+        if !serializePublic {
             data.append(contentsOf: [0x00])
-            data.append(self.privateKey!)
         }
+        data.append(keyData)
         let hashedData = data.sha256().sha256()
         let checksum = hashedData[0..<4]
         data.append(checksum)