implement checksum verification in address generation if address has various capitalization

Author: Alex Vlasov

web3swift/Concurrency/Classes/Web3+TransactionOperations.swift

@@ -106,11 +106,11 @@ final class ContractSendOperation: Web3Operation {
 
     convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, contract: web3.web3contract, method: String = "fallback", parameters: [AnyObject] = [], extraData: Data = Data(), options: Web3Options?, onBlock: String = "pending", password: String = "BANKEXFOUNDATION") {
         guard let intermediate = contract.method(method, parameters: parameters, extraData: extraData, options: options) else {return nil}
-        self.init(web3Instance, queue: queue, inputData: [intermediate, password, onBlock, options] as AnyObject)
+        self.init(web3Instance, queue: queue, inputData: [intermediate, password, onBlock, options as Any] as AnyObject)
     }
 
     convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, intermediate: TransactionIntermediate, options: Web3Options? = nil, onBlock: String = "pending", password: String = "BANKEXFOUNDATION") {
-        self.init(web3Instance, queue: queue, inputData: [intermediate, password, onBlock, options] as AnyObject)
+        self.init(web3Instance, queue: queue, inputData: [intermediate, password, onBlock, options as Any] as AnyObject)
     }
 
     override func main() {
@@ -120,7 +120,7 @@ final class ContractSendOperation: Web3Operation {
         guard let completion = self.next else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard inputData != nil else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard let input = inputData! as? [AnyObject] else {return processError(Web3Error.inputError("Invalid input supplied"))}
-        guard input.count == 3 else {return processError(Web3Error.inputError("Invalid input supplied"))}
+        guard input.count == 4 else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard let intermediate = input[0] as? TransactionIntermediate else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard let password = input[1] as? String else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard let onBlock = input[2] as? String else {return processError(Web3Error.inputError("Invalid input supplied"))}

web3swift/KeystoreManager/Classes/BIP32HDNode.swift

@@ -119,6 +119,8 @@ public class HDNode {
     private static var curveOrder = BigUInt("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", radix: 16)!
     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"
+    public static var defaultPathMetamaskPrefix: String = "m/44'/60'/0'/0"
     public static var hardenedIndexPrefix: UInt32 = (UInt32(1) << 31)
 }
 

web3swift/KeystoreManager/Classes/BIP32Keystore.swift

@@ -33,7 +33,8 @@ public class BIP32Keystore: AbstractKeystore {
         if let key = self.paths.keyForValue(value: account) {
             guard let decryptedRootNode = try? self.getPrefixNodeData(password), decryptedRootNode != nil else {throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")}
             guard let rootNode = HDNode(decryptedRootNode!) else {throw AbstractKeystoreError.encryptionError("Failed to deserialize a root node")}
-            guard rootNode.depth == HDNode.defaultPathPrefix.components(separatedBy: "/").count - 1 else {throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")}
+            guard rootNode.depth == (self.rootPrefix.components(separatedBy: "/").count - 1) else {throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")}
+//            guard rootNode.depth == HDNode.defaultPathPrefix.components(separatedBy: "/").count - 1 else {throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")}
             guard let index = UInt32(key.components(separatedBy: "/").last!) else {throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")}
             guard let keyNode = rootNode.derive(index: index, derivePrivateKey: true) else {throw AbstractKeystoreError.encryptionError("Derivation failed")}
             guard let privateKey = keyNode.privateKey else {throw AbstractKeystoreError.invalidAccountError}
@@ -69,13 +70,13 @@ public class BIP32Keystore: AbstractKeystore {
         rootPrefix = keystoreParams!.rootPath!
     }
 
-    public convenience init? (mnemonics: String, password: String = "BANKEXFOUNDATION", mnemonicsPassword: String = "", language: BIP39Language = BIP39Language.english, prefixPath: String = HDNode.defaultPathPrefix) throws {
+    public convenience init? (mnemonics: String, password: String = "BANKEXFOUNDATION", mnemonicsPassword: String = "", language: BIP39Language = BIP39Language.english, prefixPath: String = HDNode.defaultPathMetamaskPrefix) throws {
         guard var seed = BIP39.seedFromMmemonics(mnemonics, password: mnemonicsPassword, language: language) else {throw AbstractKeystoreError.noEntropyError}
         defer{ Data.zero(&seed) }
         try self.init(seed: seed, password: password, prefixPath: prefixPath)
     }
 
-    public init? (seed: Data, password: String = "BANKEXFOUNDATION", prefixPath: String = HDNode.defaultPathPrefix) throws {
+    public init? (seed: Data, password: String = "BANKEXFOUNDATION", prefixPath: String = HDNode.defaultPathMetamaskPrefix) throws {
         guard let prefixNode = HDNode(seed: seed)?.derive(path: prefixPath, derivePrivateKey: true) else {return nil}
         self.rootPrefix = prefixPath
         try createNewAccount(parentNode: prefixNode, password: password)
@@ -255,4 +256,11 @@ public class BIP32Keystore: AbstractKeystore {
         let data = try JSONEncoder().encode(params)
         return data
     }
+    
+    public func serializeRootNodeToString(password: String = "BANKEXFOUNDATION") throws -> String {
+        guard let decryptedRootNode = try? self.getPrefixNodeData(password), decryptedRootNode != nil else {throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")}
+        guard let rootNode = HDNode(decryptedRootNode!) else {throw AbstractKeystoreError.encryptionError("Failed to deserialize a root node")}
+        guard let string = rootNode.serializeToString(serializePublic: false) else {throw AbstractKeystoreError.encryptionError("Failed to deserialize a root node")}
+        return string
+    }
 }

web3swift/KeystoreManager/Classes/EthereumAddress.swift

@@ -74,11 +74,15 @@ public struct EthereumAddress: Equatable {
         return ret
     }
 
-    public init?(_ addressString:String, type: AddressType = .normal) {
+    public init?(_ addressString:String, type: AddressType = .normal, ignoreChecksum: Bool = false) {
         switch type {
         case .normal:
             guard let data = Data.fromHex(addressString) else {return nil}
             guard data.count == 20 else {return nil}
+            if (!ignoreChecksum && data.toHexString().addHexPrefix() != addressString.lowercased()) {
+                let checksummedAddress = EthereumAddress.toChecksumAddress(data.toHexString().addHexPrefix())
+                guard checksummedAddress == addressString else {return nil}
+            }
             self._address = data.toHexString().addHexPrefix()
             self.type = .normal
         case .contractDeployment:

web3swift/Web3/Classes/Web3+Structures.swift

@@ -289,8 +289,8 @@ public struct Block:Decodable {
         let minerAddress = try? container.decode(String.self, forKey: .miner)
         var miner:EthereumAddress?
         if minerAddress != nil {
-            miner = EthereumAddress(minerAddress!)
-            guard miner!.isValid else {throw Web3Error.dataError}
+            guard let minr = EthereumAddress(minerAddress!) else {throw Web3Error.dataError}
+            miner = minr
         }
         self.miner = miner
 

web3swift/Web3/Classes/Web3+Utils.swift

@@ -152,9 +152,9 @@ extension Web3.Utils {
         }
     }
 
-    public static func formatToPrecision(_ bigNumber: BigInt, numberDecimals: Int = 18, formattingDecimals: Int = 4, decimalSeparator: String = ".") -> String? {
+    public static func formatToPrecision(_ bigNumber: BigInt, numberDecimals: Int = 18, formattingDecimals: Int = 4, decimalSeparator: String = ".", fallbackToScientific: Bool = false) -> String? {
         let magnitude = bigNumber.magnitude
-        guard let formatted = formatToPrecision(magnitude, numberDecimals: numberDecimals, formattingDecimals: formattingDecimals, decimalSeparator: decimalSeparator) else {return nil}
+        guard let formatted = formatToPrecision(magnitude, numberDecimals: numberDecimals, formattingDecimals: formattingDecimals, decimalSeparator: decimalSeparator, fallbackToScientific: fallbackToScientific) else {return nil}
         switch bigNumber.sign {
         case .plus:
             return formatted

web3swiftTests/web3swiftTests.swift

@@ -142,6 +142,34 @@ class web3swiftTests: XCTestCase {
         XCTAssertNotNil(key)
     }
 
+    func testBIP32keystoreMatching() {
+        let mnemonic = "fruit wave dwarf banana earth journey tattoo true farm silk olive fence"
+        let keystore = try! BIP32Keystore(mnemonics: mnemonic, password: "", mnemonicsPassword: "banana")
+        XCTAssertNotNil(keystore)
+        let account = keystore!.addresses![0]
+        let key = try! keystore!.UNSAFE_getPrivateKeyData(password: "", account: account)
+        let pubKey = Web3.Utils.privateToPublic(key, compressed: true);
+        XCTAssert(pubKey?.toHexString() == "027160bd3a4d938cac609ff3a11fe9233de7b76c22a80d2b575e202cbf26631659")
+    }
+    
+    func testBIP32keystoreMatchingRootNode() {
+        let mnemonic = "fruit wave dwarf banana earth journey tattoo true farm silk olive fence"
+        let keystore = try! BIP32Keystore(mnemonics: mnemonic, password: "", mnemonicsPassword: "banana")
+        XCTAssertNotNil(keystore)
+        let rootNode = try! keystore!.serializeRootNodeToString(password: "")
+        XCTAssert(rootNode == "xprvA2KM71v838kPwE8Lfr12m9DL939TZmPStMnhoFcZkr1nBwDXSG7c3pjYbMM9SaqcofK154zNSCp7W7b4boEVstZu1J3pniLQJJq7uvodfCV")
+    }
+    
+    func testBIP32keystoreCustomPathMatching() {
+        let mnemonic = "fruit wave dwarf banana earth journey tattoo true farm silk olive fence"
+        let keystore = try! BIP32Keystore(mnemonics: mnemonic, password: "", mnemonicsPassword: "banana", prefixPath:"m/44'/60'/0'/0")
+        XCTAssertNotNil(keystore)
+        let account = keystore!.addresses![0]
+        let key = try! keystore!.UNSAFE_getPrivateKeyData(password: "", account: account)
+        let pubKey = Web3.Utils.privateToPublic(key, compressed: true);
+        XCTAssert(pubKey?.toHexString() == "027160bd3a4d938cac609ff3a11fe9233de7b76c22a80d2b575e202cbf26631659")
+    }
+    
     func testByBIP32keystoreCreateChildAccount() {
         let mnemonic = "normal dune pole key case cradle unfold require tornado mercy hospital buyer"
         let keystore = try! BIP32Keystore(mnemonics: mnemonic, password: "", mnemonicsPassword: "")
@@ -458,6 +486,15 @@ class web3swiftTests: XCTestCase {
         let output = EthereumAddress.toChecksumAddress(input);
         XCTAssert(output == "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359", "Failed to checksum address")
     }
+    
+    func testChecksumAddressParsing() {
+        let input = "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"
+        let addr = EthereumAddress(input);
+        XCTAssert(addr != nil);
+        let invalidInput = "0xfb6916095ca1df60bB79Ce92cE3Ea74c37c5d359"
+        let invalidAddr = EthereumAddress(invalidInput);
+        XCTAssert(invalidAddr == nil);
+    }
 
     func testTransaction() {
         do {
@@ -1924,7 +1961,7 @@ class web3swiftTests: XCTestCase {
                 case .failure(let error):
                     print(error)
                     XCTFail()
-                    fatalError()
+//                    fatalError()
                 }
                 OperationQueue.current?.underlyingQueue?.async {
                     expected = expected - 1
@@ -2013,8 +2050,9 @@ class web3swiftTests: XCTestCase {
                 print(error)
                 if case .nodeError(_) = error {
                     fail = false
+                    break
                 }
-//                XCTFail()
+                XCTFail()
 //                fatalError()
             }
             semaphore.signal()
@@ -2233,7 +2271,9 @@ class web3swiftTests: XCTestCase {
             print(error)
             XCTFail()
         }
-        let bkxBalanceSend = intermediate!.call(options: nil)
+        var options = Web3Options();
+        options.gasLimit = gasEstimate.value!
+        let bkxBalanceSend = intermediate!.call(options: options)
         switch bkxBalanceSend {
         case .success(let result):
             print(result)
@@ -2260,7 +2300,7 @@ class web3swiftTests: XCTestCase {
     func testNumberFormattingUtil() {
         let balance = BigInt("-1000000000000000000")!
         let formatted = Web3.Utils.formatToPrecision(balance, numberDecimals: 18, formattingDecimals: 4, decimalSeparator: ",")
-        XCTAssert(formatted == "-1,0000")
+        XCTAssert(formatted == "-1")
     }
 
     func testNumberFormattingUtil2() {
@@ -2283,7 +2323,7 @@ class web3swiftTests: XCTestCase {
 
     func testNumberFormattingUtil5() {
         let balance = BigInt("-1")!
-        let formatted = Web3.Utils.formatToPrecision(balance, numberDecimals: 18, formattingDecimals: 9, decimalSeparator: ",")
+        let formatted = Web3.Utils.formatToPrecision(balance, numberDecimals: 18, formattingDecimals: 9, decimalSeparator: ",", fallbackToScientific: true)
         XCTAssert(formatted == "-1e-18")
     }
 
@@ -2293,6 +2333,12 @@ class web3swiftTests: XCTestCase {
         XCTAssert(formatted == "0")
     }
 
+    func testNumberFormattingUtil7() {
+        let balance = BigInt("-1100000000000000000")!
+        let formatted = Web3.Utils.formatToPrecision(balance, numberDecimals: 18, formattingDecimals: 4, decimalSeparator: ",")
+        XCTAssert(formatted == "-1,1000")
+    }
+    
     func testPerformanceExample() {
         // This is an example of a performance test case.
         self.measure {

web3swiftTests/web3swift_remote_Tests.swift

@@ -131,7 +131,7 @@ class web3swift_remote_Tests: XCTestCase {
         let blockNumber = web3.eth.getBlockNumber()
         guard case .success(let currentBlock) = blockNumber else {return XCTFail()}
         let currentBlockAsInt = UInt64(currentBlock)
-        for i in currentBlockAsInt-3 ... currentBlockAsInt {
+        for i in currentBlockAsInt-1 ... currentBlockAsInt {
             let present = eventParser.parseBlockByNumber(i)
             guard case .success(let pres) = present else {return XCTFail()}
             for p in pres {