chore: merged with develop

Author: JeneaVranceanu

.swiftlint.yml

@@ -0,0 +1,45 @@
+excluded:
+  - Carthage
+  - Pods
+  - .build
+  - Build
+  - DerivedData
+
+disabled_rules:
+  - type_name
+  - identifier_name
+  - line_length
+  - multiple_closures_with_trailing_closure
+  - todo
+
+opt_in_rules:
+ - weak_delegate
+ - unused_import
+ - unneeded_parentheses_in_closure_argument
+ - trailing_closure
+ - static_operator
+ - redundant_nil_coalescing
+ - override_in_extension
+ - legacy_objc_type
+ - implicitly_unwrapped_optional
+ - force_unwrapping
+ - empty_string
+ - closure_body_length
+ - fallthrough
+ - indentation_width
+
+# force warnings
+force_cast: error
+force_try: error 
+
+custom_rules:
+  commented_out_code: 
+    included: ".*\\.swift" # regex that defines paths to include during linting. optional.
+    excluded: ".*Test(s)?\\.swift" # regex that defines paths to exclude during linting. optional
+    name: "Commented out code" # rule name. optional.
+    regex: "^\\/\\/\\s*(@|\\.?([a-z]|(\\})))" # matching pattern
+    capture_group: 0 # number of regex capture group to highlight the rule violation at. optional.
+    match_kinds: # SyntaxKinds to match. optional.
+      - comment
+    message: "No commented code in devel branch allowed." # violation message. optional.
+    severity: warning # violation severity. optional.

Sources/web3swift/Contract/EthereumContract.swift

@@ -33,7 +33,7 @@ public struct EthereumContract: ContractProtocol {
         var toReturn = [String: ABI.Element]()
         for m in self._abi {
             switch m {
-            case .function(let function): 
+            case .function(let function):
                 guard let name = function.name else {continue}
                 toReturn[name] = m
             default:
@@ -50,7 +50,7 @@ public struct EthereumContract: ContractProtocol {
                 break
             }
             switch m {
-            case .constructor(_): 
+            case .constructor(_):
                 toReturn = m
                 break
             default:
@@ -68,10 +68,10 @@ public struct EthereumContract: ContractProtocol {
         var toReturn = [String: ABI.Element.Event]()
         for m in self._abi {
             switch m {
-            case .event(let event): 
+            case .event(let event):
                 let name = event.name
                 toReturn[name] = event
-            default: 
+            default:
                 continue
             }
         }

Sources/web3swift/Convenience/Base58.swift

@@ -56,7 +56,6 @@ struct Base58 {
         }
 
         for b in base58 {
-            // str = "\(str)\(base58Alphabet[String.Index(encodedOffset: Int(b))])"
             str = "\(str)\(base58Alphabet[String.Index(utf16Offset: Int(b), in: base58Alphabet)])"
         }
 
@@ -67,23 +66,27 @@ struct Base58 {
     static func bytesFromBase58(_ base58: String) -> [UInt8] {
         // remove leading and trailing whitespaces
         let string = base58.trimmingCharacters(in: CharacterSet.whitespaces)
-
         guard !string.isEmpty else { return [] }
 
-        var zerosCount = 0
-        var length = 0
+        // count leading ASCII "1"'s [decodes directly to binary zero bytes]
+        var leadingZeros = 0
         for c in string {
             if c != "1" { break }
-            zerosCount += 1
+            leadingZeros += 1
         }
 
-        let size = string.lengthOfBytes(using: String.Encoding.utf8) * 733 / 1000 + 1 - zerosCount
-        var base58: [UInt8] = Array(repeating: 0, count: size)
+        // calculate the size of the decoded output, rounded up
+        let size = (string.lengthOfBytes(using: String.Encoding.utf8) - leadingZeros) * 733 / 1000 + 1
+
+        // allocate a buffer large enough for the decoded output
+        var base58: [UInt8] = Array(repeating: 0, count: size + leadingZeros)
+
+        // decode what remains of the data
+        var length = 0
         for c in string where c != " " {
             // search for base58 character
-            guard let base58Index = base58Alphabet.index(of: c) else { return [] }
+            guard let base58Index = base58Alphabet.firstIndex(of: c) else { return [] }
 
-            // var carry = base58Index.encodedOffset
             var carry = base58Index.utf16Offset(in: base58Alphabet)
             var i = 0
             for j in 0...base58.count where carry != 0 || i < length {
@@ -97,20 +100,16 @@ struct Base58 {
             length = i
         }
 
-        // skip leading zeros
-        var zerosToRemove = 0
-
+        // calculate how many leading zero bytes we have
+        var totalZeros = 0
         for b in base58 {
             if b != 0 { break }
-            zerosToRemove += 1
+            totalZeros += 1
         }
-        base58.removeFirst(zerosToRemove)
+        // remove the excess zero bytes
+        base58.removeFirst(totalZeros - leadingZeros)
 
-        var result: [UInt8] = Array(repeating: 0, count: zerosCount)
-        for b in base58 {
-            result.append(b)
-        }
-        return result
+        return base58
     }
 }
 
@@ -158,11 +157,4 @@ extension String {
         return bytes
     }
 
-//    public var littleEndianHexToUInt: UInt {
-//        let data = Data.fromHex(self)!
-//        let revensed =
-//        return UInt(sel)
-//        return UInt(self.dataWithHexString().bytes.reversed().fullHexString, radix: 16)!
-//    }
-
 }

Sources/web3swift/Convenience/Decodable+Extensions.swift

@@ -5,6 +5,7 @@
 //  Created by levantAJ on 1/18/19.
 //  Copyright © 2019 levantAJ. All rights reserved.
 //
+import BigInt
 import Foundation
 
 struct AnyCodingKey: CodingKey {
@@ -93,6 +94,50 @@ extension KeyedDecodingContainer {
             try decodeNil(forKey: key) == false else { return nil }
         return try decode(type, forKey: key)
     }
+
+    /// Decodes a value of the given key from Hex to BigUInt
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`
+    ///
+    /// - Parameter type: Generic type `T` wich conforms to `DecodableFromHex` protocol
+    /// - Parameter key: The key that the decoded value is associated with.
+    /// - Returns: A decoded value of type `BigUInt`
+    /// - throws: `Web3Error.dataError` if value associated with key are unable
+    ///   to be initialized as `BigUInt`.
+    public func decodeHex<T: DecodableFromHex>(to type: T.Type, key: KeyedDecodingContainer<K>.Key) throws -> T {
+        let string = try self.decode(String.self, forKey: key)
+        guard let number = T(from: string) else { throw Web3Error.dataError }
+        return number
+    }
+}
+
+public protocol DecodableFromHex: Decodable {
+    init?(from hexString: String)
+}
+
+extension Data: DecodableFromHex {
+    public init?(from hexString: String) {
+        self.init()
+        guard let tmp = Self.fromHex(hexString) else { return nil }
+        self = tmp
+    }
+}
+
+extension BigUInt: DecodableFromHex {
+    public init?(from hexString: String) {
+        self.init()
+        guard let tmp = BigUInt(hexString.stripHexPrefix(), radix: 16) else { return nil }
+        self = tmp
+    }
+}
+
+extension Date: DecodableFromHex {
+    public init?(from hexString: String) {
+        self.init()
+        let stripedHexString = hexString.stripHexPrefix()
+        guard let timestampInt = UInt64(stripedHexString, radix: 16) else { return nil }
+        self = Date(timeIntervalSince1970: TimeInterval(timestampInt))
+    }
 }
 
 private extension KeyedDecodingContainer {

Sources/web3swift/EthereumABI/ABIElements.swift

@@ -1,7 +1,7 @@
-// 
+//
 //  Created by Alex Vlasov on 25/10/2018.
 //  Copyright © 2018 Alex Vlasov. All rights reserved.
-// 
+//
 
 import Foundation
 import BigInt

Sources/web3swift/EthereumABI/ABIEncoding.swift

@@ -1,7 +1,7 @@
-// 
+//
 //  Created by Alex Vlasov on 25/10/2018.
 //  Copyright © 2018 Alex Vlasov. All rights reserved.
-// 
+//
 
 import Foundation
 import BigInt
@@ -383,3 +383,75 @@ extension ABIEncoder {
         return nil
     }
 }
+
+// MARK: - SoliditySHA3 implementation based on web3js
+
+public extension ABIEncoder {
+    /**
+     A convenience implementation of web3js [soliditySha3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html?highlight=soliditySha3#soliditysha3)
+     that is based on web3swift [`ABIEncoder`](https://github.com/skywinder/web3swift/blob/develop/Sources/web3swift/EthereumABI/ABIEncoding.swift ).
+     */
+    static func soliditySha3(_ values: [Any]) throws -> Data {
+        try abiEncode(values).sha3(.keccak256)
+    }
+
+    static func soliditySha3(_ value: Any) throws -> Data {
+        if let values = value as? [Any] {
+            return try abiEncode(values).sha3(.keccak256)
+        } else {
+            return try abiEncode(value).sha3(.keccak256)
+        }
+    }
+
+    /// Using AnyObject any number can be represented as Bool and Bool can be represented as number.
+    /// That will lead to invalid hash output. DO NOT USE THIS FUNCTION.
+    /// This function will exist to intentionally throw an error that will raise awareness that the hash output can be potentially,
+    /// and most likely will be, wrong.
+    /// - Parameter values: to hash
+    /// - Returns: solidity sha3 hash
+    static func soliditySha3(_ values: [AnyObject]) throws -> Data {
+        throw Web3Error.inputError(desc: "AnyObject creates ambiguity and does not guarantee that the output will be correct. Please, use `soliditySha3(Any) or soliditySha3([Any]) instead.`")
+    }
+
+    /// See docs for ``soliditySha3(_ values: [AnyObject])``
+    static func soliditySha3(_ value: AnyObject) throws -> Data {
+        throw Web3Error.inputError(desc: "AnyObject creates ambiguity and does not guarantee that the output will be correct. Please, use `soliditySha3(Any) or soliditySha3([Any]) instead.`")
+    }
+
+    static func abiEncode(_ values: [Any]) throws -> Data {
+        return try values.map {
+            try abiEncode($0)
+        }.reduce(into: Data()) { partialResult, nextElement in
+            partialResult.append(nextElement)
+        }
+    }
+
+    static func abiEncode(_ value: Any) throws -> Data {
+        if let v = value as? Bool {
+            return Data(v ? [0b1] : [0b0])
+        } else if let v = value as? Int {
+            return ABIEncoder.convertToData(BigInt(exactly: v)?.abiEncode(bits: 256)! as AnyObject)!
+        } else if let v = value as? Int8 {
+            return ABIEncoder.convertToData(BigInt(exactly: v)?.abiEncode(bits: 8) as AnyObject)!
+        } else if let v = value as? Int16 {
+            return ABIEncoder.convertToData(BigInt(exactly: v)?.abiEncode(bits: 16)! as AnyObject)!
+        } else if let v = value as? Int32 {
+            return ABIEncoder.convertToData(BigInt(exactly: v)?.abiEncode(bits: 32)! as AnyObject)!
+        } else if let v = value as? Int64 {
+            return ABIEncoder.convertToData(BigInt(exactly: v)?.abiEncode(bits: 64)! as AnyObject)!
+        } else if let v = value as? UInt {
+            return ABIEncoder.convertToData(BigUInt(exactly: v)?.abiEncode(bits: 256)! as AnyObject)!
+        } else if let v = value as? UInt8 {
+            return ABIEncoder.convertToData(BigUInt(exactly: v)?.abiEncode(bits: 8)! as AnyObject)!
+        } else if let v = value as? UInt16 {
+            return ABIEncoder.convertToData(BigUInt(exactly: v)?.abiEncode(bits: 16)! as AnyObject)!
+        } else if let v = value as? UInt32 {
+            return ABIEncoder.convertToData(BigUInt(exactly: v)?.abiEncode(bits: 32)! as AnyObject)!
+        } else if let v = value as? UInt64 {
+            return ABIEncoder.convertToData(BigUInt(exactly: v)?.abiEncode(bits: 64)! as AnyObject)!
+        } else if let data = ABIEncoder.convertToData(value as AnyObject) {
+            return data
+        }
+        throw Web3Error.inputError(desc: "SoliditySha3: `abiEncode` accepts an Int/UInt (any of 8, 16, 32, 64 bits long), HEX string, Bool, Data, BigInt or BigUInt instance. Given value is of type \(type(of: value)).")
+    }
+}

Sources/web3swift/EthereumAddress/EthereumAddress.swift

@@ -72,7 +72,15 @@ public struct EthereumAddress: Equatable {
         return ret
     }
 
-    public init?(_ addressString: String, type: AddressType = .normal, ignoreChecksum: Bool = false) {
+    public static func contractDeploymentAddress() -> EthereumAddress {
+        return EthereumAddress("0x", type: .contractDeployment)!
+    }
+}
+
+/// In swift structs it's better to implement initializers in extension
+/// Since it's make available syntetized initializer then for free.
+extension EthereumAddress {
+    public init?(_ addressString:String, type: AddressType = .normal, ignoreChecksum: Bool = false) {
         switch type {
         case .normal:
             guard let data = Data.fromHex(addressString) else {return nil}
@@ -108,16 +116,12 @@ public struct EthereumAddress: Equatable {
         }
     }
 
-    public init?(_ addressData: Data, type: AddressType = .normal) {
+    public init?(_ addressData:Data, type: AddressType = .normal) {
         guard addressData.count == 20 else {return nil}
         self._address = addressData.toHexString().addHexPrefix()
         self.type = type
     }
 
-    public static func contractDeploymentAddress() -> EthereumAddress {
-        return EthereumAddress("0x", type: .contractDeployment)!
-    }
-
 }
 
 extension EthereumAddress: Hashable { }