Merge branch 'develop'

Author: yaroslavyaroslav

CHANGELOG.md

@@ -162,7 +162,7 @@
 - Update libs versions, Cartfile and Pods dependencies  [\#334](https://github.com/skywinder/web3swift/pull/334) ([AnnaYatsun1](https://github.com/AnnaYatsun1))
 - fix crash when 'payable' nil [\#332](https://github.com/skywinder/web3swift/pull/332) ([xdozorx](https://github.com/xdozorx))
 - Update README.md [\#331](https://github.com/skywinder/web3swift/pull/331) ([Iysbaera](https://github.com/Iysbaera))
-- CrytoSwift update  version 1.4.0 [\#327](https://github.com/skywinder/web3swift/pull/327) ([lzttxs](https://github.com/lzttxs))
+- CryptoSwift update  version 1.4.0 [\#327](https://github.com/skywinder/web3swift/pull/327) ([lzttxs](https://github.com/lzttxs))
 - Update carthage libraries [\#325](https://github.com/skywinder/web3swift/pull/325) ([alex78pro](https://github.com/alex78pro))
 - Gas estimate fix [\#324](https://github.com/skywinder/web3swift/pull/324) ([frostiq](https://github.com/frostiq))
 - Update README.md [\#306](https://github.com/skywinder/web3swift/pull/306) ([manuG420](https://github.com/manuG420))
@@ -252,7 +252,7 @@
 - received transaction id from geth node server but not able to see that transaction id at etherscan.io [\#200](https://github.com/skywinder/web3swift/issues/200)
 - How do I fetch information such as balance, decimal,symbol and name of ERC20token ?   [\#199](https://github.com/skywinder/web3swift/issues/199)
 - Starscream 3.1.0 not compatible with Swift 5.0 [\#195](https://github.com/skywinder/web3swift/issues/195)
-- How to Connect infuraWebsocket and subsribe particular event in swift? [\#193](https://github.com/skywinder/web3swift/issues/193)
+- How to Connect infuraWebsocket and subscribe particular event in swift? [\#193](https://github.com/skywinder/web3swift/issues/193)
 - Use of unresolved identifier 'Wallet' [\#192](https://github.com/skywinder/web3swift/issues/192)
 - V in Signed Message Hash not being calculated properly [\#191](https://github.com/skywinder/web3swift/issues/191)
 - Not possible to calculate fast, normal and cheap transaction fee ? [\#190](https://github.com/skywinder/web3swift/issues/190)

Example/myWeb3Wallet/myWeb3Wallet/ViewControllers/WalletController/WalletViewController.swift

@@ -102,7 +102,7 @@ class WalletViewController: UIViewController {
             }
         } catch {
 #if DEBUG
-            print("error creating keyStrore")
+            print("error creating keyStore")
             print("Private key error.")
 #endif
             let alert = UIAlertController(title: "Error", message: "Please enter correct Private key", preferredStyle: .alert)

README.md

@@ -58,7 +58,7 @@
 - [x] ✅**Literally following the standards** (BIP, EIP, etc):
     - [x] **[BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) (HD Wallets), [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) (Seed phrases), [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki) (Key generation prefixes)**
 - [x] **[EIP-20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md)** (Standard interface for tokens - ERC-20), **[EIP-67](https://github.com/ethereum/EIPs/issues/67)** (Standard URI scheme), **[EIP-155](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md)** (Replay attacks protection), **[EIP-2718](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2718.md)** (Typed Transaction Envelope), **[EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md)** (Gas Fee market change)
-    - [x] **And many others** *(For details about this EIP's look at [Documentation page](https://github.com/web3swift-team/web3swift/blob/master/Documentation/))*: EIP-681, EIP-721, EIP-165, EIP-777, EIP-820, EIP-888, EIP-1400, EIP-1410, EIP-1594, EIP-1643, EIP-1644, EIP-1633, EIP-721, EIP-1155, EIP-1376, ST-20
+    - [x] **And many others** *(For details about this EIP's look at [Documentation page](https://github.com/web3swift-team/web3swift/blob/master/Documentation/))*: EIP-165, EIP-681, EIP-721, EIP-777, EIP-820, EIP-888, EIP-1155, EIP-1376, EIP-1400, EIP-1410, EIP-1594, EIP-1633, EIP-1643, EIP-1644, EIP-4361 ([SIWE](https://eips.ethereum.org/EIPS/eip-4361)), ST-20
 - [x] **RLP encoding**
 - [x] Base58 encoding scheme
 - [x] Formatting to and from Ethereum Units

Sources/Web3Core/Contract/ContractProtocol.swift

@@ -210,8 +210,8 @@ extension ContractProtocol {
 
     func decodeInputData(_ data: Data) -> [String: Any]? {
         guard data.count >= 4 else { return nil }
-        let methodId = data[0..<4].toHexString()
-        let data = data[4...]
+        let methodId = data[data.startIndex ..< data.startIndex + 4].toHexString()
+        let data = data[(data.startIndex + 4)...]
         return decodeInputData(methodId, data: data)
     }
 }
@@ -333,14 +333,14 @@ extension DefaultContractProtocol {
 
     public func decodeInputData(_ data: Data) -> [String: Any]? {
         guard data.count % 32 == 4 else { return nil }
-        let methodSignature = data[0..<4].toHexString().addHexPrefix().lowercased()
+        let methodSignature = data[data.startIndex ..< data.startIndex + 4].toHexString().addHexPrefix().lowercased()
 
         guard let function = methods[methodSignature]?.first else { return nil }
-        return function.decodeInputData(Data(data[4 ..< data.count]))
+        return function.decodeInputData(Data(data[data.startIndex + 4 ..< data.startIndex + data.count]))
     }
 
     public func getFunctionCalled(_ data: Data) -> ABI.Element.Function? {
         guard data.count >= 4 else { return nil }
-        return methods[data[0..<4].toHexString().addHexPrefix()]?.first
+        return methods[data[data.startIndex ..< data.startIndex + 4].toHexString().addHexPrefix()]?.first
     }
 }

Sources/Web3Core/EthereumABI/ABIDecoding.swift

@@ -34,27 +34,28 @@ extension ABIDecoder {
         guard let elementItself = elData, let nextElementPointer = nextPtr else {
             return (nil, nil)
         }
+        let startIndex = UInt64(elementItself.startIndex)
         switch type {
         case .uint(let bits):
             guard elementItself.count >= 32 else {break}
             let mod = BigUInt(1) << bits
-            let dataSlice = elementItself[0 ..< 32]
+            let dataSlice = elementItself[startIndex ..< startIndex + 32]
             let v = BigUInt(dataSlice) % mod
             return (v, type.memoryUsage)
         case .int(let bits):
             guard elementItself.count >= 32 else {break}
             let mod = BigInt(1) << bits
-            let dataSlice = elementItself[0 ..< 32]
+            let dataSlice = elementItself[startIndex ..< startIndex + 32]
             let v = BigInt.fromTwosComplement(data: dataSlice) % mod
             return (v, type.memoryUsage)
         case .address:
             guard elementItself.count >= 32 else {break}
-            let dataSlice = elementItself[12 ..< 32]
+            let dataSlice = elementItself[startIndex + 12 ..< startIndex + 32]
             let address = EthereumAddress(dataSlice)
             return (address, type.memoryUsage)
         case .bool:
             guard elementItself.count >= 32 else {break}
-            let dataSlice = elementItself[0 ..< 32]
+            let dataSlice = elementItself[startIndex ..< startIndex + 32]
             let v = BigUInt(dataSlice)
             if v == BigUInt(36) ||
                 v == BigUInt(32) ||
@@ -69,33 +70,33 @@ extension ABIDecoder {
             }
         case .bytes(let length):
             guard elementItself.count >= 32 else {break}
-            let dataSlice = elementItself[0 ..< length]
-            return (dataSlice, type.memoryUsage)
+            let dataSlice = elementItself[startIndex ..< startIndex + length]
+            return (Data(dataSlice), type.memoryUsage)
         case .string:
             guard elementItself.count >= 32 else {break}
-            var dataSlice = elementItself[0 ..< 32]
+            var dataSlice = elementItself[startIndex ..< startIndex + 32]
             let length = UInt64(BigUInt(dataSlice))
-            guard elementItself.count >= 32+length else {break}
+            guard elementItself.count >= 32 + length else {break}
             dataSlice = elementItself[32 ..< 32 + length]
             guard let string = String(data: dataSlice, encoding: .utf8) else {break}
             return (string, type.memoryUsage)
         case .dynamicBytes:
             guard elementItself.count >= 32 else {break}
-            var dataSlice = elementItself[0 ..< 32]
+            var dataSlice = elementItself[startIndex ..< startIndex + 32]
             let length = UInt64(BigUInt(dataSlice))
-            guard elementItself.count >= 32+length else {break}
-            dataSlice = elementItself[32 ..< 32 + length]
-            return (dataSlice, nextElementPointer)
+            guard elementItself.count >= 32 + length else {break}
+            dataSlice = elementItself[startIndex + 32 ..< startIndex + 32 + length]
+            return (Data(dataSlice), nextElementPointer)
         case .array(type: let subType, length: let length):
             switch type.arraySize {
             case .dynamicSize:
                 if subType.isStatic {
                     // uint[] like, expect length and elements
                     guard elementItself.count >= 32 else {break}
-                    var dataSlice = elementItself[0 ..< 32]
+                    var dataSlice = elementItself[startIndex ..< startIndex + 32]
                     let length = UInt64(BigUInt(dataSlice))
                     guard elementItself.count >= 32 + subType.memoryUsage*length else {break}
-                    dataSlice = elementItself[32 ..< 32 + subType.memoryUsage*length]
+                    dataSlice = elementItself[startIndex + 32 ..< startIndex + 32 + subType.memoryUsage*length]
                     var subpointer: UInt64 = 32
                     var toReturn = [Any]()
                     for _ in 0 ..< length {
@@ -108,10 +109,10 @@ extension ABIDecoder {
                 } else {
                     // in principle is true for tuple[], so will work for string[] too
                     guard elementItself.count >= 32 else {break}
-                    var dataSlice = elementItself[0 ..< 32]
+                    var dataSlice = elementItself[startIndex ..< startIndex + 32]
                     let length = UInt64(BigUInt(dataSlice))
                     guard elementItself.count >= 32 else {break}
-                    dataSlice = Data(elementItself[32 ..< elementItself.count])
+                    dataSlice = Data(elementItself[startIndex + 32 ..< UInt64(elementItself.count)])
                     var subpointer: UInt64 = 0
                     var toReturn = [Any]()
                     for _ in 0 ..< length {
@@ -179,21 +180,21 @@ extension ABIDecoder {
             }
         case .function:
             guard elementItself.count >= 32 else {break}
-            let dataSlice = elementItself[8 ..< 32]
-            return (dataSlice, type.memoryUsage)
+            let dataSlice = elementItself[startIndex + 8 ..< startIndex + 32]
+            return (Data(dataSlice), type.memoryUsage)
         }
         return (nil, nil)
     }
 
     fileprivate static func followTheData(type: ABI.Element.ParameterType, data: Data, pointer: UInt64 = 0) -> (elementEncoding: Data?, nextElementPointer: UInt64?) {
         if type.isStatic {
             guard data.count >= pointer + type.memoryUsage else {return (nil, nil)}
-            let elementItself = data[pointer ..< pointer + type.memoryUsage]
+            let elementItself = data[data.startIndex + Int(pointer) ..< data.startIndex + Int(pointer + type.memoryUsage)]
             let nextElement = pointer + type.memoryUsage
             return (Data(elementItself), nextElement)
         } else {
             guard data.count >= pointer + type.memoryUsage else {return (nil, nil)}
-            let dataSlice = data[pointer ..< pointer + type.memoryUsage]
+            let dataSlice = data[data.startIndex + Int(pointer) ..< data.startIndex + Int(pointer + type.memoryUsage)]
             let bn = BigUInt(dataSlice)
             if bn > UInt64.max || bn >= data.count {
                 // there are ERC20 contracts that use bytes32 instead of string. Let's be optimistic and return some data
@@ -209,7 +210,8 @@ extension ABIDecoder {
                 return (nil, nil)
             }
             let elementPointer = UInt64(bn)
-            let elementItself = data[elementPointer ..< UInt64(data.count)]
+            let startIndex = UInt64(data.startIndex)
+            let elementItself = data[startIndex + elementPointer ..< startIndex + UInt64(data.count)]
             let nextElement = pointer + type.memoryUsage
             return (Data(elementItself), nextElement)
         }

Sources/Web3Core/EthereumABI/ABIElements.swift

@@ -397,9 +397,9 @@ extension ABI.Element.Function {
         /// 4) `messageLength` is used to determine where message bytes end to decode string correctly.
         /// 5) The rest of the `data` must be 0 bytes or empty.
         if data.bytes.count >= 100,
-           Data(data[0..<4]) == Data.fromHex("08C379A0"),
-           BigInt(data[4..<36]) == 32,
-           let messageLength = Int(Data(data[36..<68]).toHexString(), radix: 16),
+           Data(data[data.startIndex ..< data.startIndex + 4]) == Data.fromHex("08C379A0"),
+           BigInt(data[data.startIndex + 4 ..< data.startIndex + 36]) == 32,
+           let messageLength = Int(Data(data[data.startIndex + 36 ..< data.startIndex + 68]).toHexString(), radix: 16),
            let message = String(bytes: data.bytes[68..<(68+messageLength)], encoding: .utf8),
            (68+messageLength == data.count || data.bytes[68+messageLength..<data.count].reduce(0) { $0 + $1 } == 0) {
             return ["_success": false,
@@ -410,11 +410,11 @@ extension ABI.Element.Function {
 
         if data.count >= 4,
            let errors = errors,
-           let customError = errors[data[0..<4].toHexString().stripHexPrefix()] {
+           let customError = errors[data[data.startIndex ..< data.startIndex + 4].toHexString().stripHexPrefix()] {
             var errorResponse: [String: Any] = ["_success": false, "_abortedByRevertOrRequire": true, "_error": customError.errorDeclaration]
 
             if (data.count > 32 && !customError.inputs.isEmpty),
-               let decodedInputs = ABIDecoder.decode(types: customError.inputs, data: Data(data[4..<data.count])) {
+               let decodedInputs = ABIDecoder.decode(types: customError.inputs, data: Data(data[data.startIndex + 4 ..< data.startIndex + data.count])) {
                 for idx in decodedInputs.indices {
                     errorResponse["\(idx)"] = decodedInputs[idx]
                     if !customError.inputs[idx].name.isEmpty {

Sources/Web3Core/EthereumNetwork/RequestParameter/RequestParameter+RawRepresentable.swift

@@ -13,7 +13,7 @@ extension RequestParameter: RawRepresentable {
     /// to encode mixed type values array in JSON.
     ///
     /// This protocol is used to implement custom `encode` method for that enum,
-    /// which encodes an array of self-assosiated values.
+    /// which encodes an array of self-associated values.
     ///
     /// You're totally free to use explicit and more convenience member init as `RequestParameter.int(12)` in your code.
     /// - Parameter rawValue: one of the supported types like `Int`, `UInt` etc.

Sources/Web3Core/KeystoreManager/BIP32HDNode.swift

@@ -22,13 +22,31 @@ extension UInt32 {
 }
 
 public class HDNode {
+    private static var maxIterationIndex = UInt32(1) << 31
+
+    /// Contains private and public prefixes for serialization.
+    /// See [BIP-32's serialization format](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format) for more info.
     public struct HDversion {
-        // swiftlint:disable force_unwrapping
-        public var privatePrefix: Data = Data.fromHex("0x0488ADE4")!
-        public var publicPrefix: Data = Data.fromHex("0x0488B21E")!
-        // swiftlint:enable force_unwrapping
-        public init() {}
+        /// Mainnet public key prefix.
+        /// Value `0x0488B21E` is a string `xpub` encoded as Base-58 and later as hexadecimal.
+        public static let publicPrefix: Data! = Data.fromHex("0x0488B21E")
+
+        /// Mainnet private key prefix.
+        /// Value `0x0488ADE4` is a string `xprv` encoded as Base-58 and later as hexadecimal.
+        public static let privatePrefix: Data! = Data.fromHex("0x0488ADE4")
+
+        public let publicPrefix: Data
+        public let privatePrefix: Data
+
+        /// Default values for `publicPrefix` and `privatePrefix` are
+        /// `HDversion.publicPrefix` and `HDversion.privatePrefix` respectively.
+        public init(public publicPrefix: Data = HDversion.publicPrefix,
+                    private privatePrefix: Data = HDversion.privatePrefix) {
+            self.publicPrefix = publicPrefix
+            self.privatePrefix = privatePrefix
+        }
     }
+
     public var path: String? = "m"
     public var privateKey: Data?
     public var publicKey: Data
@@ -37,14 +55,10 @@ public class HDNode {
     public var parentFingerprint: Data = Data(repeating: 0, count: 4)
     public var childNumber: UInt32 = UInt32(0)
     public var isHardened: Bool {
-        childNumber >= (UInt32(1) << 31)
+        childNumber >= Self.maxIterationIndex
     }
     public var index: UInt32 {
-            if self.isHardened {
-                return childNumber - (UInt32(1) << 31)
-            } else {
-                return childNumber
-            }
+        childNumber - (isHardened ? Self.maxIterationIndex : 0)
     }
     public var hasPrivate: Bool {
         privateKey != nil
@@ -65,7 +79,7 @@ public class HDNode {
         guard data.count == 82 else { return nil }
         let header = data[0..<4]
         var serializePrivate = false
-        if header == HDNode.HDversion().privatePrefix {
+        if header == HDversion.privatePrefix {
             serializePrivate = true
         }
         depth = data[4..<5].bytes[0]
@@ -90,30 +104,30 @@ 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 = HMAC(key: hmacKey.bytes, variant: HMAC.Variant.sha2(.sha512))
+
+        guard let hmacKey = "Bitcoin seed".data(using: .ascii) else { return nil }
+        let hmac = HMAC(key: hmacKey.bytes, 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)
         let privKeyCandidate = Data(I_L)
         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 pubKeyCandidate.bytes.first == 0x02 || pubKeyCandidate.bytes.first == 0x03 else { return nil }
         publicKey = pubKeyCandidate
         privateKey = privKeyCandidate
         depth = 0x00
         childNumber = UInt32(0)
     }
 
-    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"
-    public static var defaultPathMetamaskPrefix: String = "m/44'/60'/0'/0"
-    public static var hardenedIndexPrefix: UInt32 = (UInt32(1) << 31)
+    private static let curveOrder = BigUInt("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", radix: 16)!
+    public static let defaultPath = "m/44'/60'/0'/0"
+    public static let defaultPathPrefix = "m/44'/60'/0'"
+    public static let defaultPathMetamask = "m/44'/60'/0'/0/0"
+    public static let defaultPathMetamaskPrefix = "m/44'/60'/0'/0"
+    public static var hardenedIndexPrefix: UInt32 { Self.maxIterationIndex }
 }
 
 extension HDNode {