resolve conflicts

Author: pharms-eth

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

@@ -7,22 +7,19 @@
 //
 
 import Foundation
-import PromiseKit
 import BigInt
 
 extension web3.Eth {
-    func feeHistory(blockCount: BigUInt, block: String, percentiles:[Double]) throws -> Web3.Oracle.FeeHistory {
+    func feeHistory(blockCount: BigUInt, block: String, percentiles:[Double]) async 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")
+        let response = try await web3.dispatch(request)
+
+        guard let value: Web3.Oracle.FeeHistory = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
-        }.wait()
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
+        }
+        return value
     }
 }

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

@@ -8,46 +8,33 @@ import Foundation
 
 
 extension web3.Eth {
-    public func sendRawTransactionPromise(_ transaction: Data) -> Promise<TransactionSendingResult> {
+    public func sendRawTransactionPromise(_ transaction: Data) async throws -> 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
+            throw Web3Error.processingError(desc: "Serialized TX is invalid")
         }
         return try await sendRawTransactionPromise(deserializedTX)
     }
 
-    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
+    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)
             }
             throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
         let result = TransactionSendingResult(transaction: transaction, hash: value)
         for hook in self.web3.postSubmissionHooks {
-            Task {
-                hook.function(result)
-            }
+            hook.function(result)
         }
         return result
 
+
     }
 }

Sources/web3swift/Web3/Web3+GasOracle.swift

@@ -83,23 +83,23 @@ extension Web3 {
             }
         }
 
-        private func suggestGasValues() throws -> FeeHistory {
+        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! }
 
-            return try eth.feeHistory(blockCount: blockCount, block: block.hexValue, percentiles: percentiles)
+            return try await eth.feeHistory(blockCount: blockCount, block: block.hexValue, percentiles: percentiles)
         }
 
         /// Suggesting tip values
         /// - Returns: `[percentile_1, percentile_2, percentile_3, ...].count == self.percentile.count`
         /// by default there's 3 percentile.
-        private func suggestTipValue() throws -> [BigUInt] {
+        private func suggestTipValue() async throws -> [BigUInt] {
             var rearrengedArray: [[BigUInt]] = []
 
             /// reaarange `[[min, middle, max]]` to `[[min], [middle], [max]]`
-            try suggestGasValues().reward
+            try await suggestGasValues().reward
                 .forEach { percentiles in
                     percentiles.enumerated().forEach { (index, percentile) in
                         /// if `rearrengedArray` have not that enough items
@@ -116,23 +116,25 @@ extension Web3 {
             return soft(twoDimentsion: rearrengedArray)
         }
 
-        private func suggestBaseFee() throws -> [BigUInt] {
-            self.feeHistory = try suggestGasValues()
+        private func suggestBaseFee() async throws -> [BigUInt] {
+            self.feeHistory = try await suggestGasValues()
             return calculatePercentiles(for: feeHistory!.baseFeePerGas)
         }
 
-        private func suggestGasFeeLegacy() throws -> [BigUInt] {
+        private func suggestGasFeeLegacy() async throws -> [BigUInt] {
             var latestBlockNumber: BigUInt = 0
             switch block {
-            case .latest: latestBlockNumber = try eth.getBlockNumber()
+            case .latest: latestBlockNumber = try await eth.getBlockNumber()
             case let .exact(number): latestBlockNumber = number
             }
 
             guard latestBlockNumber != 0 else { return [] }
 
             // TODO: Make me work with cache
             let lastNthBlockGasPrice = try (latestBlockNumber - blockCount ... latestBlockNumber)
-                .map { try eth.getBlockByNumber($0, fullTransactions: true) }
+                .map {
+                    try eth.getBlockByNumber($0, fullTransactions: true)
+                }
                 .flatMap { b -> [EthereumTransaction] in
                     b.transactions.compactMap { t -> EthereumTransaction? in
                         guard case let .transaction(transaction) = t else { return nil }