Fixin FIXME memos

- Mostly of them are about making appropriate error thrown.
- Change data method to return `HTTPURLResponse` instead of `URLResponse`.
- Adding cache for GasOracle struct (were disabled, because it used method that available only from iOS 13).
- Some comment formatting.
- Delete `Package@5.0.swift` package config file.

Author: yaroslavyaroslav

Package@5.0.swift

@@ -13,7 +13,6 @@ public typealias Receipt = Hash
 public typealias Address = Hash // 20 bytes (40 chars length without 0x)
 public typealias TransactionHash = Hash // 64 chars length without 0x
 
-// FIXME: Add documentation to each method.
 /// Ethereum JSON RPC API Calls
 ///
 /// ## How to
@@ -74,7 +73,7 @@ public typealias TransactionHash = Hash // 64 chars length without 0x
 /// - `protocol APIRequestParameterType: Encodable` — this type is part of the ``RequestParameter`` enum mechanism which purpose is to restrict types that can be passed as associated types within `RequestParameter` cases.
 /// - `protocol APIRequestParameterElementType: Encodable` — this type purpose is the same as ``APIRequestParameterType` one except this one is made for `Element`s of an `Array` s when the latter is an associated type of a given `RequestParameter` case.
 public enum APIRequest {
-    // MARK: - Official API
+    // MARK: - Official Ethereum API
 
     /// Gas price request
     case gasPrice
@@ -189,7 +188,7 @@ public enum APIRequest {
     ///         by effective tip per gas and the coresponding effective tip for the percentile will be determined, accounting for gas consumed."
     case feeHistory(BigUInt, BlockNumber, [Double])
 
-    // MARK: - Additional API
+    // MARK: - Additional Ethereum API
 
     /// Creates new account.
     ///
@@ -339,23 +338,16 @@ extension APIRequest {
     static func send<Result>(uRLRequest: URLRequest, with session: URLSession) async throws -> APIResponse<Result> {
         let (data, response) = try await session.data(for: uRLRequest)
 
-        // FIXME: Add appropriate error thrown
-        guard let httpResponse = response as? HTTPURLResponse,
-               200 ..< 400 ~= httpResponse.statusCode else { throw Web3Error.connectionError }
+        guard 200 ..< 400 ~= response.statusCode else { throw Web3Error.serverError(code: response.statusCode) }
 
-        // FIXME: Add throwing an error from is server fails.
         /// This bit of code is purposed to work with literal types that comes in Response in hexString type.
         /// Currently it's just `Data` and any kind of Integers `(U)Int`, `Big(U)Int`.
         if Result.self == Data.self || Result.self == UInt.self || Result.self == Int.self || Result.self == BigInt.self || Result.self == BigUInt.self {
-            // FIXME: Make appropriate error
-            guard let Literal = Result.self as? LiteralInitiableFromString.Type else { throw Web3Error.unknownError }
-            // FIXME: Add appropriate error thrown.
-            guard let responseAsString = try? JSONDecoder().decode(APIResponse<String>.self, from: data) else { throw Web3Error.unknownError }
-            // FIXME: Add appropriate error thrown.
-            guard let literalValue = Literal.init(from: responseAsString.result) else { throw Web3Error.unknownError }
+            guard let Literal = Result.self as? LiteralInitiableFromString.Type else { throw Web3Error.typeError }
+            guard let responseAsString = try? JSONDecoder().decode(APIResponse<String>.self, from: data) else { throw Web3Error.dataError }
+            guard let literalValue = Literal.init(from: responseAsString.result) else { throw Web3Error.dataError }
             /// `Literal` conforming `LiteralInitiableFromString`, that conforming to an `APIResponseType` type, so it's never fails.
-            // FIXME: Make appropriate error
-            guard let result = literalValue as? Result else { throw Web3Error.unknownError }
+            guard let result = literalValue as? Result else { throw Web3Error.typeError }
             return APIResponse(id: responseAsString.id, jsonrpc: responseAsString.jsonrpc, result: result)
         }
         return try JSONDecoder().decode(APIResponse<Result>.self, from: data)

Sources/web3swift/API/APIMethod.swift

@@ -10,18 +10,16 @@ import Foundation
 @available(iOS, obsoleted: 15.0, message: "Use the built-in API instead")
 @available(macOS, obsoleted: 12.0, message: "Use the built-in API instead")
 extension URLSession {
-    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
-        var dataTask: URLSessionDataTask?
-
-        return try await withCheckedThrowingContinuation { continuation in
-            dataTask = self.dataTask(with: request) { data, response, error in
-                guard let data = data, let response = response else {
+    func data(for request: URLRequest) async throws -> (Data, HTTPURLResponse) {
+        try await withCheckedThrowingContinuation { continuation in
+            let dataTask = self.dataTask(with: request) { data, response, error in
+                guard let data = data, let response = response as? HTTPURLResponse else {
                     let error = error ?? URLError(.badServerResponse)
                     return continuation.resume(throwing: error)
                 }
                 continuation.resume(returning: (data, response))
             }
-            dataTask?.resume()
+            dataTask.resume()
         }
     }
 }

Sources/web3swift/API/Async+BackwardCapability.swift

@@ -9,10 +9,8 @@ import Foundation
 
 extension web3.Eth {
 
-    // FIXME: Possible this not working at all.
     public func callTransaction(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions?) async throws -> Data {
-        // FIXME: Add appropriate error
-        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.unknownError}
+        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.dataError}
         let request: APIRequest = .call(transactionParameters, transactionOptions?.callOnBlock ?? .latest)
         let response: APIResponse<Data> = try await APIRequest.sendRequest(with: self.provider, for: request)
         return response.result

Sources/web3swift/EthereumAPICalls/Ethereum/Eth+Call.swift

@@ -11,8 +11,7 @@ import BigInt
 extension web3.Eth {
 
     public func estimateGas(for transaction: EthereumTransaction, transactionOptions: TransactionOptions?) async throws -> BigUInt {
-        // FIXME: Add appropriate error
-        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.unknownError }
+        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.dataError }
 
         let request: APIRequest = .estimateGas(transactionParameters, transactionOptions?.callOnBlock ?? .latest)
         let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)

Sources/web3swift/EthereumAPICalls/Ethereum/Eth+EstimateGas.swift

@@ -16,8 +16,7 @@ extension web3.Eth {
     }
 
     public func send(raw transaction: EthereumTransaction) async throws -> TransactionSendingResult {
-        // FIXME: Add appropriate error
-        guard let transactionHexData = transaction.encode()?.toHexString().addHexPrefix() else { throw Web3Error.unknownError }
+        guard let transactionHexData = transaction.encode()?.toHexString().addHexPrefix() else { throw Web3Error.dataError }
         let request: APIRequest = .sendRawTransaction(transactionHexData)
         let response: APIResponse<Hash> = try await APIRequest.sendRequest(with: self.provider, for: request)
 

Sources/web3swift/EthereumAPICalls/Ethereum/Eth+SendRawTransaction.swift

@@ -46,8 +46,7 @@ extension web3.Eth {
             return try await self.web3.eth.send(raw: assembledTransaction)
         }
 
-        // FIXME: Add appropriate error
-        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.unknownError }
+        guard let transactionParameters = transaction.encodeAsDictionary(from: transactionOptions?.from) else { throw Web3Error.dataError }
 
         let request: APIRequest = .sendTransaction(transactionParameters)
         let response: APIResponse<Hash> = try await APIRequest.sendRequest(with: self.provider, for: request)

Sources/web3swift/EthereumAPICalls/Ethereum/Eth+SendTransaction.swift

@@ -10,7 +10,6 @@ import BigInt
 
 extension web3.Personal {
 
-    // FIXME: Possible this not working at all.
     public func signPersonal(message: Data, from: EthereumAddress, password: String = "web3swift") async throws -> Data {
 
         guard let attachedKeystoreManager = self.web3.provider.attachedKeystoreManager else {

Sources/web3swift/EthereumAPICalls/Personal/Personal+Sign.swift

@@ -200,7 +200,6 @@ extension web3.web3contract {
             }
         }
 
-        // FIXME: This could not worked at all.
         let request: APIRequest = .getLogs(preEncoding)
         let response: APIResponse<[EventLog]> = try await APIRequest.sendRequest(with: self.web3.provider, for: request)
 

Sources/web3swift/Web3/Web3+EventParser.swift

@@ -39,20 +39,22 @@ extension Web3 {
         /// Another example: If you set it [100.0] you'll get the very highest value of a dataset e.g. max Tip amount.
         var percentiles: [Double]
 
-        // TODO: Disabled until 3.0 version, coz will be enabled from 3.0.0.
-//        var forceDropCache = false
+        var forceDropCache = false
+
+        var cacheTimeout: Double
 
         /// Oracle initializer
         /// - Parameters:
         ///   - provider: Web3 Ethereum provider
         ///   - block: Number of block from which counts starts backward
         ///   - blockCount: Count of block to calculate statistics
         ///   - percentiles: Percentiles of fees to which result of predictions will be split in
-        public init(_ provider: web3, block: BlockNumber = .latest, blockCount: BigUInt = 20, percentiles: [Double] = [25, 50, 75]) {
+        public init(_ provider: web3, block: BlockNumber = .latest, blockCount: BigUInt = 20, percentiles: [Double] = [25, 50, 75], cacheTimeout: Double = 10) {
             self.web3Provider = provider
             self.block = block
             self.blockCount = blockCount
             self.percentiles = percentiles
+            self.cacheTimeout = cacheTimeout
         }
 
 
@@ -84,12 +86,18 @@ extension Web3 {
         }
 
         private func suggestGasValues() async throws -> FeeHistory {
-            // This is some kind of cache.
-            // It stores about 9 seconds, than it rewrites it with newer data.
-            // TODO: Disabled until 3.0 version, coz `distance` available from iOS 13.
-//            guard feeHistory == nil, forceDropCache, feeHistory!.timestamp.distance(to: Date()) > cacheTimeout else { return feeHistory! }
+            /// This is some kind of cache.
+            /// It stores about 10 seconds, than it rewrites it with newer data.
+
+            /// We're explicitly checking that feeHistory is not nil before force unwrapping it.
+            // swiftlint: disable force_unwrapping
+            guard feeHistory == nil, forceDropCache, feeHistory!.timestamp.distance(to: Date()) > cacheTimeout else { return feeHistory! }
+
+            feeHistory = try await eth.feeHistory(blockCount: blockCount, block: block, percentiles: percentiles)
 
-            return try await eth.feeHistory(blockCount: blockCount, block: block, percentiles: percentiles)
+            /// We're assigning this value the line very above, so it's free to force unwrapping here
+            return feeHistory!
+            // swiftlint: enable force_unwrapping
         }
 
         /// Suggesting tip values
@@ -126,9 +134,8 @@ extension Web3 {
             switch block {
             case .latest: latestBlockNumber = try await eth.blockNumber()
             case let .exact(number): latestBlockNumber = number
-            // FIXME: Make real error here
-                // Error throws since pending and erliest are unable to be used in this method.
-            default: throw Web3Error.unknownError
+            // Error throws since pending and erliest are unable to be used in this method.
+            default: throw Web3Error.valueError
             }
 
             /// checking if latest block number is greather than number of blocks to take in account