🛠 refactoring, generics, remove redudant class etc

Author: skywinder

Example/web3swiftBrowser/web3swiftBrowser/PrefferedModels.swift

@@ -20,31 +20,33 @@ struct Wallet {
     var password = "web3swift" // We recommend here and everywhere to use the password set by the user.
 
     var address: String
-    var keystore: AbstractKeystore
+
     var data: Data
     var isHD: Bool
 
     init(type: walletType) {
         switch type {
         case .EthereumKeystoreV3:
-            keystore = try! EthereumKeystoreV3(password: password)!
+            let keystore = try! EthereumKeystoreV3(password: password)!
             self.address = keystore.addresses!.first!.address
-            self.data = try! JSONEncoder().encode(keystore.giveKeystoreParams())
+            self.data = try! JSONEncoder().encode(keystore.keystoreParams)
             self.isHD = false
+            self.address = keystore.addresses!.first!.address
 
         case .BIP39:
             let mnemonics = try! BIP39.generateMnemonics(bitsOfEntropy: bitsOfEntropy)!
-            keystore = try! BIP32Keystore(
+            let keystore = try! BIP32Keystore(
                     mnemonics: mnemonics,
                     password: password,
                     mnemonicsPassword: "",
                     language: .english)!
             self.name = "HD Wallet"
-            self.data = try! JSONEncoder().encode(keystore.giveKeystoreParams())
+            self.data = try! JSONEncoder().encode(keystore.keystoreParams)
             self.isHD = true
+            self.address = keystore.addresses!.first!.address
         }
 
-        self.address = keystore.addresses!.first!.address
+        
     }
 }
 

Sources/web3swift/HookedFunctions/Web3+BrowserFunctions.swift

@@ -196,7 +196,7 @@ extension web3.BrowserFunctions {
                 transaction.chainID = self.web3.provider.network?.chainID
             }
 
-            guard let keystore: AbstractKeystore = keystoreManager.walletForAddress(from)  else {return nil}
+            guard let keystore = keystoreManager.walletForAddress(from) else {return nil}
             try Web3Signer.signTX(transaction: &transaction, keystore: keystore, account: from, password: password)
             print(transaction)
             let signedData = transaction.encode(forSignature: false, chainID: nil)?.toHexString().addHexPrefix()

Sources/web3swift/KeystoreManager/AbstractKeystore.swift

@@ -9,8 +9,6 @@ import Foundation
 //import EthereumAddress
 
 public protocol AbstractKeystore {
-    associatedtype Params: AbstractKeystoreParams
-    func giveKeystoreParams() -> Params
     var addresses: [EthereumAddress]? { get }
     var isHDKeystore: Bool { get }
     func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data

Sources/web3swift/KeystoreManager/BIP32Keystore.swift

@@ -12,12 +12,14 @@ import Foundation
 
 public class BIP32Keystore: AbstractKeystore {
 
-    public typealias Params = KeystoreParamsBIP32
-    public func giveKeystoreParams() -> Params {
-        self.keystoreParams!
-    }
 
     // Protocol
+    public var isHDKeystore: Bool = true
+
+    public var keystoreParams: KeystoreParamsBIP32?
+    public var paths: [String: EthereumAddress] = [String: EthereumAddress]()
+
+    public var rootPrefix: String
 
     public var addresses: [EthereumAddress]? {
         get {
@@ -32,8 +34,6 @@ public class BIP32Keystore: AbstractKeystore {
         }
     }
 
-    public var isHDKeystore: Bool = true
-
     public func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data {
         if let key = self.paths.keyForValue(value: account) {
             guard let decryptedRootNode = try? self.getPrefixNodeData(password) else {
@@ -62,9 +62,6 @@ public class BIP32Keystore: AbstractKeystore {
 
     // --------------
 
-    public var keystoreParams: KeystoreParamsBIP32?
-    public var paths: [String: EthereumAddress] = [String: EthereumAddress]()
-    public var rootPrefix: String
 
     public convenience init?(_ jsonString: String) {
         let lowercaseJSON = jsonString.lowercased()

Sources/web3swift/KeystoreManager/EthereumKeystoreV3.swift

@@ -9,17 +9,11 @@ import CryptoSwift
 import Foundation
 
 public class EthereumKeystoreV3: AbstractKeystore {
-    public typealias Params = KeystoreParamsV3
-    public var keystoreParams: Params?
-
-    public func giveKeystoreParams() -> Params {
-        keystoreParams!
-    }
-
-
     // Protocol
-    private var address: EthereumAddress?
     public var isHDKeystore: Bool = false
+    private var address: EthereumAddress?
+    public var keystoreParams: KeystoreParamsV3?
+
 
     public var addresses: [EthereumAddress]? {
         get {
@@ -32,7 +26,9 @@ public class EthereumKeystoreV3: AbstractKeystore {
 
     public func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data {
         if self.addresses?.count == 1 && account == self.addresses?.last {
-            guard let privateKey = try? self.getKeyData(password) else {throw AbstractKeystoreError.invalidPasswordError}
+            guard let privateKey = try? self.getKeyData(password) else {
+                throw AbstractKeystoreError.invalidPasswordError
+            }
             return privateKey
         }
         throw AbstractKeystoreError.invalidAccountError
@@ -48,18 +44,26 @@ public class EthereumKeystoreV3: AbstractKeystore {
 
     public convenience init?(_ jsonString: String) {
         let lowercaseJSON = jsonString.lowercased()
-        guard let jsonData = lowercaseJSON.data(using: .utf8) else {return nil}
+        guard let jsonData = lowercaseJSON.data(using: .utf8) else {
+            return nil
+        }
         self.init(jsonData)
     }
 
     public convenience init?(_ jsonData: Data) {
-        guard let keystoreParams = try? JSONDecoder().decode(KeystoreParamsV3.self, from: jsonData) else {return nil}
+        guard let keystoreParams = try? JSONDecoder().decode(KeystoreParamsV3.self, from: jsonData) else {
+            return nil
+        }
         self.init(keystoreParams)
     }
 
     public init?(_ keystoreParams: KeystoreParamsV3) {
-        if (keystoreParams.version != 3) {return nil}
-        if (keystoreParams.crypto.version != nil && keystoreParams.crypto.version != "1") {return nil}
+        if (keystoreParams.version != 3) {
+            return nil
+        }
+        if (keystoreParams.crypto.version != nil && keystoreParams.crypto.version != "1") {
+            return nil
+        }
         self.keystoreParams = keystoreParams
         if keystoreParams.address != nil {
             self.address = EthereumAddress(keystoreParams.address!.addHexPrefix())
@@ -68,29 +72,43 @@ public class EthereumKeystoreV3: AbstractKeystore {
         }
     }
 
-    public init? (password: String = "web3swift", aesMode: String = "aes-128-cbc") throws {
-        guard var newPrivateKey = SECP256K1.generatePrivateKey() else {return nil}
-        defer {Data.zero(&newPrivateKey)}
+    public init?(password: String = "web3swift", aesMode: String = "aes-128-cbc") throws {
+        guard var newPrivateKey = SECP256K1.generatePrivateKey() else {
+            return nil
+        }
+        defer {
+            Data.zero(&newPrivateKey)
+        }
         try encryptDataToStorage(password, keyData: newPrivateKey, aesMode: aesMode)
     }
 
-    public init? (privateKey: Data, password: String = "web3swift", aesMode: String = "aes-128-cbc") throws {
-        guard privateKey.count == 32 else {return nil}
-        guard SECP256K1.verifyPrivateKey(privateKey: privateKey) else {return nil}
+    public init?(privateKey: Data, password: String = "web3swift", aesMode: String = "aes-128-cbc") throws {
+        guard privateKey.count == 32 else {
+            return nil
+        }
+        guard SECP256K1.verifyPrivateKey(privateKey: privateKey) else {
+            return nil
+        }
         try encryptDataToStorage(password, keyData: privateKey, aesMode: aesMode)
     }
 
-    fileprivate func encryptDataToStorage(_ password: String, keyData: Data?, dkLen: Int=32, N: Int = 4096, R: Int = 6, P: Int = 1, aesMode: String = "aes-128-cbc") throws {
+    fileprivate func encryptDataToStorage(_ password: String, keyData: Data?, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1, aesMode: String = "aes-128-cbc") throws {
         if (keyData == nil) {
             throw AbstractKeystoreError.encryptionError("Encryption without key data")
         }
         let saltLen = 32;
-        guard let saltData = Data.randomBytes(length: saltLen) else {throw AbstractKeystoreError.noEntropyError}
-        guard let derivedKey = scrypt(password: password, salt: saltData, length: dkLen, N: N, R: R, P: P) else {throw AbstractKeystoreError.keyDerivationError}
-        let last16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count-1)])
+        guard let saltData = Data.randomBytes(length: saltLen) else {
+            throw AbstractKeystoreError.noEntropyError
+        }
+        guard let derivedKey = scrypt(password: password, salt: saltData, length: dkLen, N: N, R: R, P: P) else {
+            throw AbstractKeystoreError.keyDerivationError
+        }
+        let last16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count - 1)])
         let encryptionKey = Data(derivedKey[0...15])
-        guard let IV = Data.randomBytes(length: 16) else {throw AbstractKeystoreError.noEntropyError}
-        var aesCipher : AES?
+        guard let IV = Data.randomBytes(length: 16) else {
+            throw AbstractKeystoreError.noEntropyError
+        }
+        var aesCipher: AES?
         switch aesMode {
         case "aes-128-cbc":
             aesCipher = try? AES(key: encryptionKey.bytes, blockMode: CBC(iv: IV.bytes), padding: .noPadding)
@@ -102,7 +120,9 @@ public class EthereumKeystoreV3: AbstractKeystore {
         if aesCipher == nil {
             throw AbstractKeystoreError.aesError
         }
-        guard let encryptedKey = try aesCipher?.encrypt(keyData!.bytes) else {throw AbstractKeystoreError.aesError}
+        guard let encryptedKey = try aesCipher?.encrypt(keyData!.bytes) else {
+            throw AbstractKeystoreError.aesError
+        }
 //        let encryptedKeyData = Data(bytes:encryptedKey)
         let encryptedKeyData = Data(encryptedKey)
         var dataForMAC = Data()
@@ -112,85 +132,129 @@ public class EthereumKeystoreV3: AbstractKeystore {
         let kdfparams = KdfParamsV3(salt: saltData.toHexString(), dklen: dkLen, n: N, p: P, r: R, c: nil, prf: nil)
         let cipherparams = CipherParamsV3(iv: IV.toHexString())
         let crypto = CryptoParamsV3(ciphertext: encryptedKeyData.toHexString(), cipher: aesMode, cipherparams: cipherparams, kdf: "scrypt", kdfparams: kdfparams, mac: mac.toHexString(), version: nil)
-        guard let pubKey = Web3.Utils.privateToPublic(keyData!) else {throw AbstractKeystoreError.keyDerivationError}
-        guard let addr = Web3.Utils.publicToAddress(pubKey) else {throw AbstractKeystoreError.keyDerivationError}
+        guard let pubKey = Web3.Utils.privateToPublic(keyData!) else {
+            throw AbstractKeystoreError.keyDerivationError
+        }
+        guard let addr = Web3.Utils.publicToAddress(pubKey) else {
+            throw AbstractKeystoreError.keyDerivationError
+        }
         self.address = addr
         let keystoreparams = KeystoreParamsV3(address: addr.address.lowercased(), crypto: crypto, id: UUID().uuidString.lowercased(), version: 3)
         self.keystoreParams = keystoreparams
     }
 
-    public func regenerate(oldPassword: String, newPassword: String, dkLen: Int=32, N: Int = 4096, R: Int = 6, P: Int = 1) throws {
+    public func regenerate(oldPassword: String, newPassword: String, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1) throws {
         var keyData = try self.getKeyData(oldPassword)
         if keyData == nil {
             throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")
         }
-        defer {Data.zero(&keyData!)}
+        defer {
+            Data.zero(&keyData!)
+        }
         try self.encryptDataToStorage(newPassword, keyData: keyData!, aesMode: self.keystoreParams!.crypto.cipher)
     }
 
     fileprivate func getKeyData(_ password: String) throws -> Data? {
-        guard let keystoreParams = self.keystoreParams else {return nil}
-        guard let saltData = Data.fromHex(keystoreParams.crypto.kdfparams.salt) else {return nil}
+        guard let keystoreParams = self.keystoreParams else {
+            return nil
+        }
+        guard let saltData = Data.fromHex(keystoreParams.crypto.kdfparams.salt) else {
+            return nil
+        }
         let derivedLen = keystoreParams.crypto.kdfparams.dklen
-        var passwordDerivedKey:Data?
+        var passwordDerivedKey: Data?
         switch keystoreParams.crypto.kdf {
         case "scrypt":
-            guard let N = keystoreParams.crypto.kdfparams.n else {return nil}
-            guard let P = keystoreParams.crypto.kdfparams.p else {return nil}
-            guard let R = keystoreParams.crypto.kdfparams.r else {return nil}
+            guard let N = keystoreParams.crypto.kdfparams.n else {
+                return nil
+            }
+            guard let P = keystoreParams.crypto.kdfparams.p else {
+                return nil
+            }
+            guard let R = keystoreParams.crypto.kdfparams.r else {
+                return nil
+            }
             passwordDerivedKey = scrypt(password: password, salt: saltData, length: derivedLen, N: N, R: R, P: P)
         case "pbkdf2":
-            guard let algo = keystoreParams.crypto.kdfparams.prf else {return nil}
-            var hashVariant:HMAC.Variant?;
+            guard let algo = keystoreParams.crypto.kdfparams.prf else {
+                return nil
+            }
+            var hashVariant: HMAC.Variant?;
             switch algo {
-                case "hmac-sha256" :
-                    hashVariant = HMAC.Variant.sha256
-                case "hmac-sha384" :
-                    hashVariant = HMAC.Variant.sha384
-                case "hmac-sha512" :
-                    hashVariant = HMAC.Variant.sha512
-                default:
-                    hashVariant = nil
+            case "hmac-sha256":
+                hashVariant = HMAC.Variant.sha256
+            case "hmac-sha384":
+                hashVariant = HMAC.Variant.sha384
+            case "hmac-sha512":
+                hashVariant = HMAC.Variant.sha512
+            default:
+                hashVariant = nil
+            }
+            guard hashVariant != nil else {
+                return nil
+            }
+            guard let c = keystoreParams.crypto.kdfparams.c else {
+                return nil
+            }
+            guard let passData = password.data(using: .utf8) else {
+                return nil
+            }
+            guard let derivedArray = try? PKCS5.PBKDF2(password: passData.bytes, salt: saltData.bytes, iterations: c, keyLength: derivedLen, variant: hashVariant!).calculate() else {
+                return nil
             }
-            guard hashVariant != nil else {return nil}
-            guard let c = keystoreParams.crypto.kdfparams.c else {return nil}
-            guard let passData = password.data(using: .utf8) else {return nil}
-            guard let derivedArray = try? PKCS5.PBKDF2(password: passData.bytes, salt: saltData.bytes, iterations: c, keyLength: derivedLen, variant: hashVariant!).calculate() else {return nil}
 //            passwordDerivedKey = Data(bytes:derivedArray)
             passwordDerivedKey = Data(derivedArray)
         default:
             return nil
         }
-        guard let derivedKey = passwordDerivedKey else {return nil}
+        guard let derivedKey = passwordDerivedKey else {
+            return nil
+        }
         var dataForMAC = Data()
         let derivedKeyLast16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count - 1)])
         dataForMAC.append(derivedKeyLast16bytes)
-        guard let cipherText = Data.fromHex(keystoreParams.crypto.ciphertext) else {return nil}
-        if (cipherText.count != 32) {return nil}
+        guard let cipherText = Data.fromHex(keystoreParams.crypto.ciphertext) else {
+            return nil
+        }
+        if (cipherText.count != 32) {
+            return nil
+        }
         dataForMAC.append(cipherText)
         let mac = dataForMAC.sha3(.keccak256)
-        guard let calculatedMac = Data.fromHex(keystoreParams.crypto.mac), mac.constantTimeComparisonTo(calculatedMac) else {return nil}
+        guard let calculatedMac = Data.fromHex(keystoreParams.crypto.mac), mac.constantTimeComparisonTo(calculatedMac) else {
+            return nil
+        }
         let cipher = keystoreParams.crypto.cipher
         let decryptionKey = derivedKey[0...15]
-        guard let IV = Data.fromHex(keystoreParams.crypto.cipherparams.iv) else {return nil}
-        var decryptedPK:Array<UInt8>?
+        guard let IV = Data.fromHex(keystoreParams.crypto.cipherparams.iv) else {
+            return nil
+        }
+        var decryptedPK: Array<UInt8>?
         switch cipher {
         case "aes-128-ctr":
-            guard let aesCipher = try? AES(key: decryptionKey.bytes, blockMode: CTR(iv: IV.bytes), padding: .noPadding) else {return nil}
+            guard let aesCipher = try? AES(key: decryptionKey.bytes, blockMode: CTR(iv: IV.bytes), padding: .noPadding) else {
+                return nil
+            }
             decryptedPK = try aesCipher.decrypt(cipherText.bytes)
         case "aes-128-cbc":
-            guard let aesCipher = try? AES(key: decryptionKey.bytes, blockMode: CBC(iv: IV.bytes), padding: .noPadding) else {return nil}
+            guard let aesCipher = try? AES(key: decryptionKey.bytes, blockMode: CBC(iv: IV.bytes), padding: .noPadding) else {
+                return nil
+            }
             decryptedPK = try? aesCipher.decrypt(cipherText.bytes)
         default:
             return nil
         }
-        guard decryptedPK != nil else {return nil}
+        guard decryptedPK != nil else {
+            return nil
+        }
 //        return Data(bytes:decryptedPK!)
         return Data(decryptedPK!)
     }
 
     public func serialize() throws -> Data? {
-        guard let params = self.keystoreParams else {return nil}
+        guard let params = self.keystoreParams else {
+            return nil
+        }
         let data = try JSONEncoder().encode(params)
         return data
     }