Now we are using CommonCrypto instead of CryptoSwift (up to 1000 times faster now)

Optimized mnemonics generation (10 times faster)

Added Transaction class (Work in progress)
Added SignedTransaction class (Work in progress)

Author: v57

Cartfile

@@ -2,3 +2,4 @@ github "mxcl/PromiseKit" ~> 6.0
 github "attaswift/BigInt" ~> 3.1
 github "krzyzanowskim/CryptoSwift"
 github "Boilertalk/secp256k1.swift"
+github "v57/BlueCryptor" ~> 1.0

Cartfile.resolved

@@ -1,5 +1,6 @@
 github "Boilertalk/secp256k1.swift" "0.1.4"
 github "attaswift/BigInt" "v3.1.0"
 github "attaswift/SipHash" "v1.2.2"
-github "krzyzanowskim/CryptoSwift" "0.13.0"
-github "mxcl/PromiseKit" "6.5.2"
+github "krzyzanowskim/CryptoSwift" "0.13.1"
+github "mxcl/PromiseKit" "6.6.1"
+github "v57/BlueCryptor" "1.0.22"

Package.swift

@@ -14,6 +14,7 @@ let package = Package(
     .package(url: "https://github.com/krzyzanowskim/CryptoSwift.git", from: "0.12.0"),
     .package(url: "https://github.com/Boilertalk/secp256k1.swift.git", from: "0.1.1"),
     .package(url: "https://github.com/mxcl/PromiseKit.git", from: "6.4.0"),
+    .package(url: "https://github.com/v57/BlueCryptor.git", from: "1.0.0"),
     ],
   targets: [
     // Targets are the basic building blocks of a package. A target can define a module or a test suite.

README.md

@@ -1,5 +1,5 @@
-# We just released web3swift 2.0 [check it out](https://github.com/BANKEX/web3swift/releases/tag/2.0.0)
-### also check our [Discord Channel](https://discord.gg/3ETv2ST)
+
+### You can ask for help in our [Discord Channel](https://discord.gg/3ETv2ST)
 <p align="right">
 <a href="https://brianmacdonald.github.io/Ethonate/address#0x47FC2e245b983A92EB3359F06E31F34B107B6EF6" target="_blank">
 <img src="https://brianmacdonald.github.io/Ethonate/svg/eth-support-blue.svg" alt="Support">
@@ -57,7 +57,7 @@ Don't forget to set the iOS version in a Podfile, otherwise you get an error if
   Add this to the dependency section of your `Package.swift` manifest:
 
     ```Swift
-    .package(url: "https://github.com/BANKEX/web3swift.git", from: "2.0.0")
+    .package(url: "https://github.com/BANKEX/web3swift.git", from: "2.1.0")
     ```
 
 - **CocoaPods:** Put this in your `Podfile`:
@@ -69,7 +69,7 @@ Don't forget to set the iOS version in a Podfile, otherwise you get an error if
 - **Carthage:** Put this in your `Cartfile`:
 
     ```
-    github "BANKEX/web3swift" ~> 2.0
+    github "BANKEX/web3swift" ~> 2.1
     ```
 
 

Sources/ABIv2/ABIv2Decoding.swift

@@ -31,7 +31,7 @@ public struct ABIv2Decoder {
     ///   - data: Data to decode
     /// - Returns: Array of decoded types
     public static func decode(types: [ABIv2.Element.ParameterType], data: Data) -> [AnyObject]? {
-//        print("Full data: \n" + data.toHexString())
+//        print("Full data: \n" + data.hex)
         var toReturn = [AnyObject]()
         var consumed: UInt64 = 0
         for i in 0 ..< types.count {
@@ -59,30 +59,30 @@ public struct ABIv2Decoder {
         }
         switch type {
         case let .uint(bits):
-//            print("Uint256 element itself: \n" + elementItself.toHexString())
+//            print("Uint256 element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let mod = BigUInt(1) << bits
             let dataSlice = elementItself[0 ..< 32]
             let v = BigUInt(dataSlice) % mod
 //            print("Uint256 element is: \n" + String(v))
             return (v as AnyObject, type.memoryUsage)
         case let .int(bits):
-//            print("Int256 element itself: \n" + elementItself.toHexString())
+//            print("Int256 element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let mod = BigInt(1) << bits
             let dataSlice = elementItself[0 ..< 32]
             let v = BigInt.fromTwosComplement(data: dataSlice) % mod
 //            print("Int256 element is: \n" + String(v))
             return (v as AnyObject, type.memoryUsage)
         case .address:
-//            print("Address element itself: \n" + elementItself.toHexString())
+//            print("Address element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let dataSlice = elementItself[12 ..< 32]
             let address = Address(dataSlice)
 //            print("Address element is: \n" + String(address.address))
             return (address as AnyObject, type.memoryUsage)
         case .bool:
-//            print("Bool element itself: \n" + elementItself.toHexString())
+//            print("Bool element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let dataSlice = elementItself[0 ..< 32]
             let v = BigUInt(dataSlice)
@@ -93,13 +93,13 @@ public struct ABIv2Decoder {
                 return (false as AnyObject, type.memoryUsage)
             }
         case let .bytes(length):
-//            print("Bytes32 element itself: \n" + elementItself.toHexString())
+//            print("Bytes32 element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let dataSlice = elementItself[0 ..< length]
-//            print("Bytes32 element is: \n" + String(dataSlice.toHexString()))
+//            print("Bytes32 element is: \n" + String(dataSlice.hex))
             return (dataSlice as AnyObject, type.memoryUsage)
         case .string:
-//            print("String element itself: \n" + elementItself.toHexString())
+//            print("String element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             var dataSlice = elementItself[0 ..< 32]
             let length = UInt64(BigUInt(dataSlice))
@@ -109,18 +109,18 @@ public struct ABIv2Decoder {
 //            print("String element is: \n" + String(string))
             return (string as AnyObject, type.memoryUsage)
         case .dynamicBytes:
-//            print("Bytes element itself: \n" + elementItself.toHexString())
+//            print("Bytes element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             var dataSlice = elementItself[0 ..< 32]
             let length = UInt64(BigUInt(dataSlice))
             guard elementItself.count >= 32 + length else { break }
             dataSlice = elementItself[32 ..< 32 + length]
-//            print("Bytes element is: \n" + String(dataSlice.toHexString()))
+//            print("Bytes element is: \n" + String(dataSlice.hex))
             return (dataSlice as AnyObject, type.memoryUsage)
         case let .array(type: subType, length: length):
             switch type.arraySize {
             case .dynamicSize:
-//                print("Dynamic array element itself: \n" + elementItself.toHexString())
+//                print("Dynamic array element itself: \n" + elementItself.hex)
                 if subType.isStatic {
                     // uint[] like, expect length and elements
                     guard elementItself.count >= 32 else { break }
@@ -146,7 +146,7 @@ public struct ABIv2Decoder {
                     dataSlice = Data(elementItself[32 ..< elementItself.count])
                     var subpointer: UInt64 = 0
                     var toReturn = [AnyObject]()
-//                    print("Dynamic array sub element itself: \n" + dataSlice.toHexString())
+//                    print("Dynamic array sub element itself: \n" + dataSlice.hex)
                     for _ in 0 ..< length {
                         let (v, c) = decodeSignleType(type: subType, data: dataSlice, pointer: subpointer)
                         guard let valueUnwrapped = v, let consumedUnwrapped = c else { break }
@@ -156,7 +156,7 @@ public struct ABIv2Decoder {
                     return (toReturn as AnyObject, nextElementPointer)
                 }
             case let .staticSize(staticLength):
-//                print("Static array element itself: \n" + elementItself.toHexString())
+//                print("Static array element itself: \n" + elementItself.hex)
                 guard length == staticLength else { break }
                 var toReturn = [AnyObject]()
                 var consumed: UInt64 = 0
@@ -175,7 +175,7 @@ public struct ABIv2Decoder {
                 break
             }
         case let .tuple(types: subTypes):
-//            print("Tuple element itself: \n" + elementItself.toHexString())
+//            print("Tuple element itself: \n" + elementItself.hex)
             var toReturn = [AnyObject]()
             var consumed: UInt64 = 0
             for i in 0 ..< subTypes.count {
@@ -191,23 +191,23 @@ public struct ABIv2Decoder {
                 return (toReturn as AnyObject, nextElementPointer)
             }
         case .function:
-//            print("Function element itself: \n" + elementItself.toHexString())
+//            print("Function element itself: \n" + elementItself.hex)
             guard elementItself.count >= 32 else { break }
             let dataSlice = elementItself[8 ..< 32]
-//            print("Function element is: \n" + String(dataSlice.toHexString()))
+//            print("Function element is: \n" + String(dataSlice.hex))
             return (dataSlice as AnyObject, type.memoryUsage)
         }
         return (nil, nil)
     }
 
     fileprivate static func followTheData(type: ABIv2.Element.ParameterType, data: Data, pointer: UInt64 = 0) -> (elementEncoding: Data?, nextElementPointer: UInt64?) {
-//        print("Follow the data: \n" + data.toHexString())
+//        print("Follow the data: \n" + data.hex)
 //        print("At pointer: \n" + String(pointer))
         if type.isStatic {
             guard data.count >= pointer + type.memoryUsage else { return (nil, nil) }
             let elementItself = data[pointer ..< pointer + type.memoryUsage]
             let nextElement = pointer + type.memoryUsage
-//            print("Got element itself: \n" + elementItself.toHexString())
+//            print("Got element itself: \n" + elementItself.hex)
 //            print("Next element pointer: \n" + String(nextElement))
             return (Data(elementItself), nextElement)
         } else {
@@ -230,7 +230,7 @@ public struct ABIv2Decoder {
             let elementPointer = UInt64(bn)
             let elementItself = data[elementPointer ..< UInt64(data.count)]
             let nextElement = pointer + type.memoryUsage
-//            print("Got element itself: \n" + elementItself.toHexString())
+//            print("Got element itself: \n" + elementItself.hex)
 //            print("Next element pointer: \n" + String(nextElement))
             return (Data(elementItself), nextElement)
         }

Sources/ABIv2/ABIv2Encoding.swift

@@ -259,7 +259,7 @@ public struct ABIv2Encoder {
                         toReturn.append(encoding)
                     }
                     let total = lengthEncoding + toReturn
-//                    print("Dynamic array of static types encoding :\n" + String(total.toHexString()))
+//                    print("Dynamic array of static types encoding :\n" + String(total.hex))
                     return total
                 } else {
                     // create new context
@@ -292,7 +292,7 @@ public struct ABIv2Encoder {
                         }
                     }
                     let total = lengthEncoding + headsConcatenated + tailsConcatenated
-//                    print("Dynamic array of dynamic types encoding :\n" + String(total.toHexString()))
+//                    print("Dynamic array of dynamic types encoding :\n" + String(total.hex))
                     return total
                 }
             case let .staticSize(staticLength):
@@ -307,7 +307,7 @@ public struct ABIv2Encoder {
                         guard let encoding = enc else { break }
                         toReturn.append(encoding)
                     }
-//                    print("Static array of static types encoding :\n" + String(toReturn.toHexString()))
+//                    print("Static array of static types encoding :\n" + String(toReturn.hex))
                     let total = toReturn
                     return total
                 } else {
@@ -335,7 +335,7 @@ public struct ABIv2Encoder {
                         tailsPointer = tailsPointer + BigUInt(tail.count)
                     }
                     let total = headsConcatenated + tailsConcatenated
-//                    print("Static array of dynamic types encoding :\n" + String(total.toHexString()))
+//                    print("Static array of dynamic types encoding :\n" + String(total.hex))
                     return total
                 }
             case .notArray:

Sources/ABIv2/ABIv2ParameterTypes.swift

@@ -179,12 +179,12 @@ extension ABIv2.Element.Function {
 
     /// Function hash in hex
     public var methodString: String {
-        return String(signature.sha3(.keccak256).prefix(8))
+        return signature.keccak256().hex
     }
 
     /// Function hash
     public var methodEncoding: Data {
-        return signature.data(using: .ascii)!.sha3(.keccak256)[0..<4]
+        return signature.data(using: .ascii)!.keccak256()[0..<4]
     }
 }
 
@@ -198,7 +198,7 @@ extension ABIv2.Element.Event {
 
     /// Event hash
     public var topic: Data {
-        return signature.data(using: .ascii)!.sha3(.keccak256)
+        return signature.data(using: .ascii)!.keccak256()
     }
 }
 

Sources/Contract/ComparisonExtensions.swift

@@ -39,9 +39,9 @@ extension String: EventFilterComparable {
     public func isEqualTo(_ other: AnyObject) -> Bool {
         switch other {
         case let oth as String:
-            return data.sha3(.keccak256) == oth.data.sha3(.keccak256)
+            return data.keccak256() == oth.data.keccak256()
         case let oth as Data:
-            return data.sha3(.keccak256) == oth.sha3(.keccak256)
+            return data.keccak256() == oth.keccak256()
         default:
             return false
         }
@@ -56,13 +56,13 @@ extension Data: EventFilterComparable {
             if self == data {
                 return true
             }
-            let hash = data.sha3(.keccak256)
+            let hash = data.keccak256()
             return self == hash
         case let oth as Data:
             if self == oth {
                 return true
             }
-            let hash = oth.sha3(.keccak256)
+            let hash = oth.keccak256()
             return self == hash
         default:
             return false

Sources/Contract/EthereumFilterEncodingExtensions.swift

@@ -11,32 +11,32 @@ import Foundation
 
 extension BigUInt: EventFilterEncodable {
     public func eventFilterEncoded() -> String? {
-        return abiEncode(bits: 256)?.toHexString().withHex
+        return abiEncode(bits: 256)?.hex.withHex
     }
 }
 
 extension BigInt: EventFilterEncodable {
     public func eventFilterEncoded() -> String? {
-        return abiEncode(bits: 256)?.toHexString().withHex
+        return abiEncode(bits: 256)?.hex.withHex
     }
 }
 
 extension Data: EventFilterEncodable {
     public func eventFilterEncoded() -> String? {
         guard let padded = self.setLengthLeft(32) else { return nil }
-        return padded.toHexString().withHex
+        return padded.hex.withHex
     }
 }
 
 extension Address: EventFilterEncodable {
     public func eventFilterEncoded() -> String? {
         guard let padded = self.addressData.setLengthLeft(32) else { return nil }
-        return padded.toHexString().withHex
+        return padded.hex.withHex
     }
 }
 
 extension String: EventFilterEncodable {
     public func eventFilterEncoded() -> String? {
-        return data.sha3(.keccak256).toHexString().withHex
+        return data.keccak256().hex.withHex
     }
 }

Sources/Contract/EventFiltering.swift

@@ -68,7 +68,7 @@ internal func encodeTopicToGetLogs(contract: ContractV2, eventName: String?, fil
     }
     var topics = [[String?]?]()
     if eventTopic != nil {
-        topics.append([eventTopic!.toHexString().withHex])
+        topics.append([eventTopic!.hex.withHex])
     } else {
         topics.append(nil as [String?]?)
     }