Rewrite GasOracle

- Implement generic decodeHex methods for T: DecodableFromHex, [T], [[T]].
- Make RPC API `feeHistory` call internal.
- Reimplement `tipFeePercentiles` to return array of percentiles of last tips.
- Reimplement `baseFeePercentiles` to return array of percentiles of last baseFee.
- Rename `bothFeesPercentiles` to return tuple of arrays of percentiles of last both tips and baseFee.
- `JSONRPCresponse` now can decode `Web3.Oracle.FeeHistory`
- `JSONRPCparams` now can encode `[Double]`
- Add `OracleTests`
   - `testPretictBaseFee`
   - `testPredictTip`

Author: yaroslavyaroslav

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,38 @@ 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
+    // FIXME: Add doc comment
+    func mean() -> BigUInt? {
+        guard !self.isEmpty else { return nil }
+        return BigUInt(self.reduce(0, +)) / BigUInt(self.count)
+    }
+
+    // FIXME: Add doc comment
+    func percentile(of value: Double) -> Element? {
+        guard !self.isEmpty else { return nil }
+
+        let normalizedValue = value / 100 * Double(self.count)
+        let index = Int(ceil(normalizedValue))
+        guard index < self.count else { return nil }
+
+        let sorted_data = self.sorted()
+        return sorted_data[index]
+    }
+}

Sources/web3swift/Convenience/Decodable+Extensions.swift

@@ -18,8 +18,8 @@ extension KeyedDecodingContainer {
     /// - Returns: A decoded value of type `BigUInt`
     /// - 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 string = try self.decode(String.self, forKey: forKey)
-        guard let number = T(fromHex: string) else { throw Web3Error.dataError }
+        let hexString = try self.decode(String.self, forKey: forKey)
+        guard let number = T(fromHex: hexString) else { throw Web3Error.dataError }
         return number
     }
 
@@ -30,24 +30,63 @@ extension KeyedDecodingContainer {
     /// - 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 `BigUInt`
-    /// - throws: `Web3Error.dataError` if value associated with key are unable to be initialized as `[DecodableFromHex]`.
-    public func decodeHex<T: DecodableFromHex>(_ type: Array<T>.Type, forKey: KeyedDecodingContainer<K>.Key) throws -> Array<T> {
-        var container = try self.nestedUnkeyedContainer(forKey: forKey)
-        guard let array = try? container.decode(type) else { throw Web3Error.dataError }
+    /// - 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`
+    /// Currently this method supports only `Data.Type`, `BigUInt.Type`, `Date.Type`, `EthereumAddress`
     ///
     /// - 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 `BigUInt`
+    /// - 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
+    }
+}
+
+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]`.
-    public func decodeHex<T: DecodableFromHex>(_ type: Array<Array<T>>.Type, forKey: KeyedDecodingContainer<K>.Key) throws -> Array<Array<T>> {
-        var container = try self.nestedUnkeyedContainer(forKey: forKey)
-        guard let array = try? container.decode(type) else { throw Web3Error.dataError }
+    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
     }
 }

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

@@ -15,12 +15,12 @@ extension web3.Eth {
 //        return feeHistory(address: addr, onBlock: onBlock)
 //    }
 
-    public func feeHistory(blockCount: BigUInt, block: String, percentiles:[Double]) throws -> Oracle.FeeHistory {
+    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: Oracle.FeeHistory = response.getValue() else {
+            guard let value: Web3.Oracle.FeeHistory = response.getValue() else {
                 if response.error != nil {
                     throw Web3Error.nodeError(desc: response.error!.message)
                 }

Sources/web3swift/Web3/Web3+GasOracle.swift

@@ -9,7 +9,7 @@
 import Foundation
 import BigInt
 
-extension web3.Eth {
+extension Web3 {
     /// Oracle is the class to do a transaction fee suggestion
     final public class Oracle {
 
@@ -33,10 +33,10 @@ extension web3.Eth {
         /// Oracle initializer
         /// - Parameters:
         ///   - provider: Web3 Ethereum provider
-        ///   - block: Number of block from which counts starts
+        ///   - block: Number of block from which counts starts backward
         ///   - blockCount: Count of block to calculate statistics
         ///   - percentiles: Percentiles of fees which will split in fees history
-        public init(_ provider: web3, block: String = "latest", blockCount: BigUInt = 20, percentiles: [Double] = [10, 50, 90]) {
+        public init(_ provider: web3, block: String = "latest", blockCount: BigUInt = 20, percentiles: [Double] = [25, 50, 75]) {
             self.web3Provider = provider
             self.block = block
             self.blockCount = blockCount
@@ -72,7 +72,7 @@ extension web3.Eth {
         private func soft(twoDimentsion array: [[BigUInt]]) -> [BigUInt] {
             /// We've got `[[min],[middle],[max]]` 2 dimensional array
             /// we're getting `[min, middle, max].count == self.percentiles.count`,
-            /// where each value are mean from the input percentile array
+            /// where each value are mean from the input percentile arrays
             array.compactMap { percentileArray -> [BigUInt]? in
                 guard !percentileArray.isEmpty else { return nil }
                 // swiftlint:disable force_unwrapping
@@ -98,28 +98,37 @@ extension web3.Eth {
         }
 
         /// Suggesting tip values
-        /// - Returns: `[percentile 1, percentile 2, percentile 3].count == self.percentile.count`
+        /// - Returns: `[percentile_1, percentile_2, percentile_3, ...].count == self.percentile.count`
         /// by default there's 3 percentile.
         private func suggestTipValue() throws -> [BigUInt] {
+            var rearrengedArray: [[BigUInt]] = []
+
             /// reaarange `[[min, middle, max]]` to `[[min], [middle], [max]]`
-            let rearrengedArray = try suggestGasValues().reward
-                .map { internalArray -> [BigUInt] in
-                    var newArray = [BigUInt]()
-                    internalArray.enumerated().forEach { newArray[$0] = $1 }
-                    return newArray
+            try suggestGasValues().reward
+                .forEach { percentiles in
+                    percentiles.enumerated().forEach { (index, percentile) in
+                        /// if `rearrengedArray` have not that enough items
+                        /// as `percentiles` current item index
+                        if rearrengedArray.endIndex <= index {
+                            /// append its as an array
+                            rearrengedArray.append([percentile])
+                        } else {
+                            /// append `percentile` value to appropriate `percentiles` array.
+                            rearrengedArray[index].append(percentile)
+                        }
+                    }
                 }
             return soft(twoDimentsion: rearrengedArray)
         }
 
         private func suggestBaseFee() throws -> [BigUInt] {
-            calculatePercentiles(for: try suggestGasValues().baseFeePerGas)
+            self.feeHistory = try suggestGasValues()
+            return calculatePercentiles(for: feeHistory!.baseFeePerGas)
         }
 
         private func suggestGasFeeLegacy(_ statistic: Statistic) throws -> BigUInt {
             let latestBlockNumber = try eth.getBlockNumber()
 
-            // Assigning last block to object var to predict baseFee of the next block
-//            latestBlock = try eth.getBlockByNumber(latestBlockNumber)
             // TODO: Make me work with cache
             let lastNthBlockGasPrice = try (latestBlockNumber - blockCount ... latestBlockNumber)
                 .map { try eth.getBlockByNumber($0, fullTransactions: true) }
@@ -136,17 +145,14 @@ extension web3.Eth {
     }
 }
 
-public extension web3.Eth.Oracle {
+public extension Web3.Oracle {
     // MARK: - Base Fee
-    /// Base fee amount based on last Nth blocks
+    /// Softed baseFee amount
     ///
     /// Normalized means that most high and most low value were droped from calculation.
     ///
-    /// Nth block may include empty ones.
-    ///
-    /// - Parameter statistic: Statistic to apply for base fee calculation
     /// - Returns: Suggested base fee amount according to statistic, nil if failed to perdict
-    func predictBaseFee() -> [BigUInt] {
+    var baseFeePercentiles: [BigUInt] {
         guard let value = try? suggestBaseFee() else { return [] }
         return value
     }
@@ -160,7 +166,7 @@ public extension web3.Eth.Oracle {
     ///
     /// - Parameter statistic: Statistic to apply for tip calculation
     /// - Returns: Suggested tip amount according to statistic, nil if failed to perdict
-    func predictTip() -> [BigUInt] {
+    var tipFeePercentiles: [BigUInt] {
         guard let value = try? suggestTipValue() else { return [] }
         return value
     }
@@ -171,7 +177,7 @@ public extension web3.Eth.Oracle {
     ///   - baseFee: Statistic to apply for baseFee
     ///   - tip: Statistic to apply for tip
     /// - Returns: Tuple where `baseFee` — base fee, `tip` — tip, nil if failed to predict
-    func predictBothFees() -> (baseFee: [BigUInt], tip: [BigUInt])? {
+    var bothFeesPercentiles: (baseFee: [BigUInt], tip: [BigUInt])? {
         guard let baseFee = try? suggestBaseFee() else { return nil }
         guard let tip = try? suggestTipValue() else { return nil }
 
@@ -188,7 +194,7 @@ public extension web3.Eth.Oracle {
 //    }
 }
 
-public extension web3.Eth.Oracle {
+public extension Web3.Oracle {
     // TODO: Make me struct and encapsulate math within to make me extendable
     enum Statistic {
         /// Mininum statistic
@@ -202,7 +208,7 @@ public extension web3.Eth.Oracle {
     }
 }
 
-public extension web3.Eth.Oracle {
+extension Web3.Oracle {
     struct FeeHistory {
         let timestamp = Date()
         let baseFeePerGas: [BigUInt]
@@ -212,7 +218,7 @@ public extension web3.Eth.Oracle {
     }
 }
 
-extension web3.Eth.Oracle.FeeHistory: Decodable {
+extension Web3.Oracle.FeeHistory: Decodable {
     enum CodingKeys: String, CodingKey {
         case baseFeePerGas
         case gasUsedRatio
@@ -229,35 +235,3 @@ extension web3.Eth.Oracle.FeeHistory: Decodable {
         self.reward = try values.decodeHex([[BigUInt]].self, forKey: .reward)
     }
 }
-
-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 {
-    func mean() -> BigUInt? {
-        guard !self.isEmpty else { return nil }
-        return BigUInt(self.reduce(0, +)) / BigUInt(self.count)
-    }
-
-    func percentile(of value: Double) -> BigUInt? {
-        guard !self.isEmpty else { return nil }
-
-        let sorted_data = self.sorted()
-//        if self.count % 2 == 1 {
-            return BigUInt(sorted_data[Int(floor(Double(self.count) / value / 10))])
-//        } else {
-//            return BigUInt(sorted_data[self.count / Int(value) / 10] + sorted_data[(self.count / Int(value) / 10) - 1] /( value) / 10)
-//        }
-    }
-}

Sources/web3swift/Web3/Web3+JSONRPC.swift

@@ -91,23 +91,26 @@ public struct JSONRPCresponse: Decodable{
         public var message: String
     }
 
-    internal var decodableTypes: [Decodable.Type] = [[EventLog].self,
-                                  [TransactionDetails].self,
-                                  [TransactionReceipt].self,
-                                  [Block].self,
-                                  [String].self,
-                                  [Int].self,
-                                  [Bool].self,
-                                  EventLog.self,
-                                  TransactionDetails.self,
-                                  TransactionReceipt.self,
-                                  Block.self,
-                                  String.self,
-                                  Int.self,
-                                  Bool.self,
-                                  [String: String].self,
-                                  [String: Int].self,
-                                  [String: [String: [String: [String]]]].self]
+    internal var decodableTypes: [Decodable.Type] = [
+        [EventLog].self,
+        [TransactionDetails].self,
+        [TransactionReceipt].self,
+        [Block].self,
+        [String].self,
+        [Int].self,
+        [Bool].self,
+        EventLog.self,
+        TransactionDetails.self,
+        TransactionReceipt.self,
+        Block.self,
+        String.self,
+        Int.self,
+        Bool.self,
+        [String: String].self,
+        [String: Int].self,
+        [String: [String: [String: [String]]]].self,
+        Web3.Oracle.FeeHistory.self
+    ]
 
     // FIXME: Make me a real generic
     public init(from decoder: Decoder) throws {
@@ -160,6 +163,8 @@ public struct JSONRPCresponse: Decodable{
             result = rawValue
         } else if let rawValue = try? container.decodeIfPresent([String: [String: [String: [String: String?]]]].self, forKey: .result) {
             result = rawValue
+        } else if let rawValue = try? container.decodeIfPresent(Web3.Oracle.FeeHistory.self, forKey: .result) {
+            result = rawValue
         }
         self.init(id: id, jsonrpc: jsonrpc, result: result, error: nil)
     }
@@ -261,6 +266,7 @@ public struct EventFilterParameters: Codable {
 
 /// Raw JSON RCP 2.0 internal flattening wrapper.
 public struct JSONRPCparams: Encodable{
+    // TODO: Rewrite me to generic
     public var params = [Any]()
 
     public func encode(to encoder: Encoder) throws {
@@ -274,6 +280,8 @@ public struct JSONRPCparams: Encodable{
                 try container.encode(p)
             } else if let p = par as? EventFilterParameters {
                 try container.encode(p)
+            } else if let p = par as? [Double] {
+                try container.encode(p)
             }
         }
     }