Merge branch 'develop' into remove-Promises

Author: pharms-eth

Sources/web3swift/Contract/EthereumContract.swift

@@ -114,15 +114,18 @@ public struct EthereumContract: ContractProtocol {
         } else if extraData != Data() {
             fullData.append(extraData)
         }
-        let transaction = EthereumTransaction(gasPrice: BigUInt(0), gasLimit: BigUInt(0), to: to, value: BigUInt(0), data: fullData)
+        let params = EthereumParameters(gasLimit: BigUInt(0), gasPrice: BigUInt(0))
+        let transaction = EthereumTransaction(to: to, value: BigUInt(0), data: fullData, parameters: params)
         return transaction
     }
 
     public func method(_ method: String = "fallback", parameters: [AnyObject] = [AnyObject](), extraData: Data = Data()) -> EthereumTransaction? {
         guard let to = self.address else {return nil}
 
         if (method == "fallback") {
-            let transaction = EthereumTransaction(gasPrice: BigUInt(0), gasLimit: BigUInt(0), to: to, value: BigUInt(0), data: extraData)
+            let params = EthereumParameters(gasLimit: BigUInt(0), gasPrice: BigUInt(0))
+            let transaction = EthereumTransaction(to: to, value: BigUInt(0), data: extraData, parameters: params)
+
             return transaction
         }
         let foundMethod = self.methods.filter { (key, value) -> Bool in
@@ -131,7 +134,8 @@ public struct EthereumContract: ContractProtocol {
         guard foundMethod.count == 1 else {return nil}
         let abiMethod = foundMethod[method]
         guard let encodedData = abiMethod?.encodeParameters(parameters) else {return nil}
-        let transaction = EthereumTransaction(gasPrice: BigUInt(0), gasLimit: BigUInt(0), to: to, value: BigUInt(0), data: encodedData)
+        let params = EthereumParameters(gasLimit: BigUInt(0), gasPrice: BigUInt(0))
+        let transaction = EthereumTransaction(to: to, value: BigUInt(0), data: encodedData, parameters: params)
         return transaction
     }
 

Sources/web3swift/Convenience/Array+Extension.swift

@@ -5,6 +5,7 @@
 //
 
 import Foundation
+import BigInt
 
 extension Array {
     public func split(intoChunksOf chunkSize: Int) -> [[Element]] {
@@ -14,3 +15,41 @@ extension Array {
         }
     }
 }
+
+extension Array where Element: Comparable {
+    /// Sorts array and drops most and least values.
+    /// - Returns: Sorted array without most and least values, nil if `array.count` <= 2
+    func cropAnomalyValues() -> Self? {
+        var sortedArray = self.sorted()
+        // Array should at least counts two to pass that formations.
+        guard sortedArray.count > 1 else { return nil }
+        sortedArray.removeLast()
+        sortedArray.removeFirst()
+        return sortedArray
+    }
+}
+
+extension Array where Element: BinaryInteger {
+    // TODO: Make me generic
+    /// Calculates mean value of a dataset
+    /// - Returns: Mean value of a dataset, nil if dataset is empty
+    func mean() -> BigUInt? {
+        guard !self.isEmpty else { return nil }
+        return BigUInt(self.reduce(0, +)) / BigUInt(self.count)
+    }
+
+
+    /// Calculates percentile of dataset on which get called.
+    /// - Parameter value: Percentile value.
+    /// - Returns: Item from dataset that is belongs to given percentile, nil if dataset is empty.
+    func percentile(of value: Double) -> Element? {
+        guard !self.isEmpty else { return nil }
+
+        let normalizedValue = value / 100 * Double(self.count)
+        let index = Int(ceil(normalizedValue))
+
+        let sorted_data = self.sorted()
+        guard index < self.count else { return sorted_data[sorted_data.count - 1] }
+        return sorted_data[index]
+    }
+}

Sources/web3swift/Convenience/Decodable+Extensions.swift

@@ -35,6 +35,7 @@ extension KeyedDecodingContainer {
     ///   for the given key.
     /// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
     ///   the given key.
+    @available(*, deprecated, message: "Use decodeHex insetad")
     public func decode(_ type: [Any].Type, forKey key: KeyedDecodingContainer<K>.Key) throws -> [Any] {
         var values = try nestedUnkeyedContainer(forKey: key)
         return try values.decode(type)
@@ -52,6 +53,7 @@ extension KeyedDecodingContainer {
     ///   for the given key.
     /// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
     ///   the given key.
+    @available(*, deprecated, message: "Use decodeHex() insetad")
     public func decode(_ type: [String: Any].Type, forKey key: KeyedDecodingContainer<K>.Key) throws -> [String: Any] {
         let values = try nestedContainer(keyedBy: AnyCodingKey.self, forKey: key)
         return try values.decode(type)
@@ -70,6 +72,7 @@ extension KeyedDecodingContainer {
     ///   the value is a null value.
     /// - throws: `DecodingError.typeMismatch` if the encountered encoded value
     ///   is not convertible to the requested type.
+    @available(*, deprecated, message: "In next version Will be replaced by decodeHexIfPresent() insetad")
     public func decodeIfPresent(_ type: [Any].Type, forKey key: KeyedDecodingContainer<K>.Key) throws -> [Any]? {
         guard contains(key),
             try decodeNil(forKey: key) == false else { return nil }
@@ -89,26 +92,107 @@ extension KeyedDecodingContainer {
     ///   the value is a null value.
     /// - throws: `DecodingError.typeMismatch` if the encountered encoded value
     ///   is not convertible to the requested type.
+    @available(*, deprecated, message: "In next version Will be replaced by decodeHexIfPresent() insetad")
     public func decodeIfPresent(_ type: [String: Any].Type, forKey key: KeyedDecodingContainer<K>.Key) throws -> [String: Any]? {
         guard contains(key),
             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
+    /// Decodes a value of the given key from Hex to `DecodableFromHex`
     ///
-    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `UInt.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(fromHex: string) else { throw Web3Error.dataError }
+    /// - Returns: A decoded value of type `T`
+    /// - throws: `Web3Error.dataError` if value associated with key are unable to be initialized as `DecodableFromHex`.
+    public func decodeHex<T: DecodableFromHex>(_ type: T.Type, forKey: KeyedDecodingContainer<K>.Key) throws -> T {
+        let hexString = try self.decode(String.self, forKey: forKey)
+        guard let number = T(fromHex: hexString) else { throw Web3Error.dataError }
         return number
     }
+
+    /// Decodes a value of the given key from Hex to `[DecodableFromHex]`
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `UInt.Type`
+    ///
+    /// - Parameter type: Array of a 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 `T`
+    /// - throws: `Web3Error.dataError` if value associated with key are unable to be initialized as `[[DecodableFromHex]]`.
+    public func decodeHex<T: DecodableFromHex>(_ type: [T].Type, forKey: KeyedDecodingContainer<K>.Key) throws -> [T] {
+        var container = try nestedUnkeyedContainer(forKey: forKey)
+        guard let array = try? container.decodeHex(type) else { throw Web3Error.dataError }
+        return array
+    }
+
+    /// Decodes a value of the given key from Hex to `[DecodableFromHex]`
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `EthereumAddress`, `UInt.Type`
+    ///
+    /// - Parameter type: Array of a 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 `T`
+    /// - throws: `Web3Error.dataError` if value associated with key are unable to be initialized as `[[DecodableFromHex]]`.
+    public func decodeHex<T: DecodableFromHex>(_ type: [[T]].Type, forKey: KeyedDecodingContainer<K>.Key) throws -> [[T]] {
+        var container = try nestedUnkeyedContainer(forKey: forKey)
+        guard let array = try? container.decodeHex(type) else { throw Web3Error.dataError }
+        return array
+    }
+
+    /// Decodes a value of the given key from Hex to `DecodableFromHex`
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `UInt.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 `T`, or nil if key is not present
+    /// - throws: `Web3Error.dataError` if value associated with key are unable to be initialized as `DecodableFromHex`.
+    public func decodeHexIfPresent<T: DecodableFromHex>(_ type: T.Type, forKey: KeyedDecodingContainer<K>.Key) throws -> T? {
+        guard contains(forKey) else { return nil }
+        return try decodeHex(type, forKey: forKey)
+    }
+
+}
+
+public extension UnkeyedDecodingContainer {
+    /// Decodes a unkeyed value from hex to `[DecodableFromHex]`
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `EthereumAddress`
+    ///
+    /// - 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 `[DecodableFromHex]`.
+    mutating func decodeHex<T: DecodableFromHex>(_ type: [T].Type) throws -> [T] {
+        var array: [T] = []
+        while !isAtEnd {
+            let hexString = try decode(String.self)
+            guard let item = T(fromHex: hexString) else { continue }
+            array.append(item)
+        }
+        return array
+    }
+
+
+    /// Decodes a unkeyed value from Hex to `DecodableFromHex`
+    ///
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `EthereumAddress`
+    ///
+    /// - 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 `[[DecodableFromHex]]`.
+    mutating func decodeHex<T: DecodableFromHex>(_ type: [[T]].Type) throws -> [[T]] {
+        var array: [[T]] = []
+        while !isAtEnd {
+            var container = try nestedUnkeyedContainer()
+            let intArr = try container.decodeHex([T].self)
+            array.append(intArr)
+        }
+        return array
+    }
 }
 
 public protocol DecodableFromHex: Decodable {
@@ -123,6 +207,12 @@ extension Data: DecodableFromHex {
     }
 }
 
+extension UInt: DecodableFromHex {
+    public init?(fromHex hexString: String) {
+        self.init(hexString.stripHexPrefix(), radix: 16)
+    }
+}
+
 extension BigUInt: DecodableFromHex {
     public init?(fromHex hexString: String) {
         self.init(hexString.stripHexPrefix(), radix: 16)
@@ -144,6 +234,7 @@ extension EthereumAddress: DecodableFromHex {
     }
 }
 
+// deprecated, should be removed in 3.0.0
 private extension KeyedDecodingContainer {
     func decode(_ type: [String: Any].Type) throws -> [String: Any] {
         var dictionary: [String: Any] = [:]
@@ -168,6 +259,7 @@ private extension KeyedDecodingContainer {
     }
 }
 
+// deprecated, should be removed in 3.0.0
 private extension UnkeyedDecodingContainer {
     mutating func decode(_ type: [Any].Type) throws -> [Any] {
         var elements: [Any] = []

Sources/web3swift/HookedFunctions/Web3+BrowserFunctions.swift

@@ -134,10 +134,11 @@ extension web3.BrowserFunctions {
             var options = opts
             guard let _ = options.from else {return (nil, nil)}
             let gasPrice = try await self.web3.eth.getGasPrice()
-            transaction.gasPrice = gasPrice
+            transaction.parameters.gasPrice = gasPrice
             options.gasPrice = .manual(gasPrice)
             guard let gasEstimate = await self.estimateGas(transaction, transactionOptions: options) else {return (nil, nil)}
-            transaction.gasLimit = gasEstimate
+            transaction.parameters.gasLimit = gasEstimate
+
             options.gasLimit = .limited(gasEstimate)
             print(transaction)
             return (transaction, options)
@@ -176,18 +177,18 @@ extension web3.BrowserFunctions {
             guard let noncePolicy = transactionOptions.nonce else {return nil}
             switch gasPricePolicy {
             case .manual(let gasPrice):
-                transaction.gasPrice = gasPrice
+                transaction.parameters.gasPrice = gasPrice
             default:
                 let gasPrice = try await self.web3.eth.getGasPrice()
-                transaction.gasPrice = gasPrice
+                transaction.parameters.gasPrice = gasPrice
             }
 
             switch gasLimitPolicy {
             case .manual(let gasLimit):
-                transaction.gasLimit = gasLimit
+                transaction.parameters.gasLimit = gasLimit
             default:
                 let gasLimit = try await self.web3.eth.estimateGas(transaction, transactionOptions: transactionOptions)
-                transaction.gasLimit = gasLimit
+                transaction.parameters.gasLimit = gasLimit
             }
 
             switch noncePolicy {
@@ -205,7 +206,7 @@ extension web3.BrowserFunctions {
             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()
+            let signedData = transaction.encode()?.toHexString().addHexPrefix()
             return signedData
         } catch {
             return nil

Sources/web3swift/Promises/Promise+Web3+Eth+FeeHistory.swift

@@ -0,0 +1,28 @@
+//
+//  Promise+Web3+Eth+FeeHistory.swift
+//  web3swift
+//
+//  Created by Yaroslav on 11.04.2022.
+//  Copyright © 2022 web3swift. All rights reserved.
+//
+
+import Foundation
+import PromiseKit
+import BigInt
+
+extension web3.Eth {
+    func feeHistory(blockCount: BigUInt, block: String, percentiles:[Double]) throws -> Web3.Oracle.FeeHistory {
+        let request = JSONRPCRequestFabric.prepareRequest(.feeHistory, parameters: [blockCount.description.addHexPrefix(), block, percentiles])
+        let rp = web3.dispatch(request)
+        let queue = web3.requestDispatcher.queue
+        return try rp.map(on: queue) { response in
+            guard let value: Web3.Oracle.FeeHistory = response.getValue() else {
+                if response.error != nil {
+                    throw Web3Error.nodeError(desc: response.error!.message)
+                }
+                throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
+            }
+            return value
+        }.wait()
+    }
+}

Sources/web3swift/Promises/Promise+Web3+Eth+SendRawTransaction.swift

@@ -8,23 +8,36 @@ import Foundation
 
 
 extension web3.Eth {
-    public func sendRawTransactionPromise(_ transaction: Data) async throws -> TransactionSendingResult {
-        guard let deserializedTX = EthereumTransaction.fromRaw(transaction) else {
-            throw Web3Error.processingError(desc: "Serialized TX is invalid")
+    public func sendRawTransactionPromise(_ transaction: Data) -> Promise<TransactionSendingResult> {
+        guard let deserializedTX = EthereumTransaction(rawValue: transaction) else {
+            let promise = Promise<TransactionSendingResult>.pending()
+            promise.resolver.reject(Web3Error.processingError(desc: "Serialized TX is invalid"))
+            return promise.promise
         }
         return try await sendRawTransactionPromise(deserializedTX)
     }
 
-    public func sendRawTransactionPromise(_ transaction: EthereumTransaction) async throws -> TransactionSendingResult {
-
-        guard let request = EthereumTransaction.createRawTransaction(transaction: transaction) else {
-            throw Web3Error.processingError(desc: "Transaction is invalid")
-        }
-        let response = try await web3.dispatch(request)
-
-        guard let value: String = response.getValue() else {
-            if response.error != nil {
-                throw Web3Error.nodeError(desc: response.error!.message)
+    public func sendRawTransactionPromise(_ transaction: EthereumTransaction) -> Promise<TransactionSendingResult>{
+        let queue = web3.requestDispatcher.queue
+        do {
+            guard let request = EthereumTransaction.createRawTransaction(transaction: transaction) else {
+                throw Web3Error.processingError(desc: "Transaction is invalid")
+            }
+            let rp = web3.dispatch(request)
+            return rp.map(on: queue) { response in
+                guard let value: String = response.getValue() else {
+                    if response.error != nil {
+                        throw Web3Error.nodeError(desc: response.error!.message)
+                    }
+                    throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
+                }
+                let result = TransactionSendingResult(transaction: transaction, hash: value)
+                for hook in self.web3.postSubmissionHooks {
+                    hook.queue.async {
+                        hook.function(result)
+                    }
+                }
+                return result
             }
             throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }

Sources/web3swift/SwiftRLP/RLP.swift

@@ -113,6 +113,7 @@ public struct RLP {
         return encoded.bytes[0]
     }
 
+    // FIXME: Make encode generic to avoid casting it's argument to [AnyObject]
     public static func encode(_ elements: Array<AnyObject>) -> Data? {
         var encodedData = Data()
         for e in elements {