finish cleanup

pharms-eth · pharms-eth · commit c8869dc8510a · 2022-04-15T23:55:23.000-07:00
diff --git a/Sources/web3swift/Web3/Web3+MutatingTransaction.swift b/Sources/web3swift/Web3/Web3+MutatingTransaction.swift
@@ -10,163 +10,121 @@ import BigInt
 public class WriteTransaction: ReadTransaction {
 
     public func assemblePromise(transactionOptions: TransactionOptions? = nil) async throws -> EthereumTransaction {
-            var assembledTransaction: EthereumTransaction = self.transaction
-            let queue = self.web3.requestDispatcher.queue
-            let returnPromise = Promise<EthereumTransaction> { seal in
-                if self.method != "fallback" {
-                    let m = self.contract.methods[self.method]
-                    if m == nil {
-                        seal.reject(Web3Error.inputError(desc: "Contract's ABI does not have such method"))
-                        return
-                    }
-                    switch m! {
-                    case .function(let function):
-                        if function.constant {
-                            seal.reject(Web3Error.inputError(desc: "Trying to transact to the constant function"))
-                            return
-                        }
-                    case .constructor(_):
-                        break
-                    default:
-                        seal.reject(Web3Error.inputError(desc: "Contract's ABI does not have such method"))
-                        return
-                    }
-                }
+        var assembledTransaction: EthereumTransaction = self.transaction
 
-                var mergedOptions = self.transactionOptions.merge(transactionOptions)
-                if mergedOptions.value != nil {
-                    assembledTransaction.value = mergedOptions.value!
-                }
-                var forAssemblyPipeline: (EthereumTransaction, EthereumContract, TransactionOptions) = (assembledTransaction, self.contract, mergedOptions)
-
-                for hook in self.web3.preAssemblyHooks {
-                    let prom: Promise<Bool> = Promise<Bool> {seal in
-                        hook.queue.async {
-                            let hookResult = hook.function(forAssemblyPipeline)
-                            if hookResult.3 {
-                                forAssemblyPipeline = (hookResult.0, hookResult.1, hookResult.2)
-                            }
-                            seal.fulfill(hookResult.3)
-                        }
-                    }
-                    let shouldContinue = try prom.wait()
-                    if !shouldContinue {
-                        seal.reject(Web3Error.processingError(desc: "Transaction is canceled by middleware"))
-                        return
-                    }
+        if self.method != "fallback" {
+            let m = self.contract.methods[self.method]
+            if m == nil {
+                throw Web3Error.inputError(desc: "Contract's ABI does not have such method")
+            }
+            switch m! {
+            case .function(let function):
+                if function.constant {
+                    throw Web3Error.inputError(desc: "Trying to transact to the constant function")
                 }
+            case .constructor(_):
+                break
+            default:
+                throw Web3Error.inputError(desc: "Contract's ABI does not have such method")
+            }
+        }
 
-                assembledTransaction = forAssemblyPipeline.0
-                mergedOptions = forAssemblyPipeline.2
+        var mergedOptions = self.transactionOptions.merge(transactionOptions)
+        if mergedOptions.value != nil {
+            assembledTransaction.value = mergedOptions.value!
+        }
+        var forAssemblyPipeline: (EthereumTransaction, EthereumContract, TransactionOptions) = (assembledTransaction, self.contract, mergedOptions)
 
-                guard let from = mergedOptions.from else {
-                    seal.reject(Web3Error.inputError(desc: "No 'from' field provided"))
-                    return
-                }
+        for hook in self.web3.preAssemblyHooks {
+            let hookResult = hook.function(forAssemblyPipeline)
+            if hookResult.3 {
+                forAssemblyPipeline = (hookResult.0, hookResult.1, hookResult.2)
+            }
 
-                // assemble promise for gas estimation
-                var optionsForGasEstimation = TransactionOptions()
-                optionsForGasEstimation.from = mergedOptions.from
-                optionsForGasEstimation.to = mergedOptions.to
-                optionsForGasEstimation.value = mergedOptions.value
-                optionsForGasEstimation.gasLimit = mergedOptions.gasLimit
-                optionsForGasEstimation.callOnBlock = mergedOptions.callOnBlock
-
-                // assemble promise for gasLimit
-                var gasEstimatePromise: Promise<BigUInt>? = nil
-                guard let gasLimitPolicy = mergedOptions.gasLimit else {
-                    seal.reject(Web3Error.inputError(desc: "No gasLimit policy provided"))
-                    return
-                }
-                switch gasLimitPolicy {
-                case .automatic, .withMargin, .limited:
-                    gasEstimatePromise = self.web3.eth.estimateGasPromise(assembledTransaction, transactionOptions: optionsForGasEstimation)
-                case .manual(let gasLimit):
-                    gasEstimatePromise = Promise<BigUInt>.value(gasLimit)
-                }
+            let shouldContinue = hookResult.3
+            if !shouldContinue {
+                throw Web3Error.processingError(desc: "Transaction is canceled by middleware")
+            }
+        }
 
-                // assemble promise for nonce
-                var getNoncePromise: Promise<BigUInt>?
-                guard let noncePolicy = mergedOptions.nonce else {
-                    seal.reject(Web3Error.inputError(desc: "No nonce policy provided"))
-                    return
-                }
-                switch noncePolicy {
-                case .latest:
-                    getNoncePromise = self.web3.eth.getTransactionCountPromise(address: from, onBlock: "latest")
-                case .pending:
-                    getNoncePromise = self.web3.eth.getTransactionCountPromise(address: from, onBlock: "pending")
-                case .manual(let nonce):
-                    getNoncePromise = Promise<BigUInt>.value(nonce)
-                }
+        assembledTransaction = forAssemblyPipeline.0
+        mergedOptions = forAssemblyPipeline.2
 
-                // assemble promise for gasPrice
-                var gasPricePromise: Promise<BigUInt>? = nil
-                guard let gasPricePolicy = mergedOptions.gasPrice else {
-                    seal.reject(Web3Error.inputError(desc: "No gasPrice policy provided"))
-                    return
-                }
-                switch gasPricePolicy {
-                case .automatic, .withMargin:
-                    gasPricePromise = self.web3.eth.getGasPricePromise()
-                case .manual(let gasPrice):
-                    gasPricePromise = Promise<BigUInt>.value(gasPrice)
-                }
-                var promisesToFulfill: [Promise<BigUInt>] = [getNoncePromise!, gasPricePromise!, gasEstimatePromise!]
-                when(resolved: getNoncePromise!, gasEstimatePromise!, gasPricePromise!).map(on: queue, { (results: [PromiseResult<BigUInt>]) throws -> EthereumTransaction in
-
-                    promisesToFulfill.removeAll()
-                    guard case .fulfilled(let nonce) = results[0] else {
-                        throw Web3Error.processingError(desc: "Failed to fetch nonce")
-                    }
-                    guard case .fulfilled(let gasEstimate) = results[1] else {
-                        throw Web3Error.processingError(desc: "Failed to fetch gas estimate")
-                    }
-                    guard case .fulfilled(let gasPrice) = results[2] else {
-                        throw Web3Error.processingError(desc: "Failed to fetch gas price")
-                    }
-
-                    let estimate = mergedOptions.resolveGasLimit(gasEstimate)
-                    let finalGasPrice = mergedOptions.resolveGasPrice(gasPrice)
-
-                    var finalOptions = TransactionOptions()
-                    finalOptions.nonce = .manual(nonce)
-                    finalOptions.gasLimit = .manual(estimate)
-                    finalOptions.gasPrice = .manual(finalGasPrice)
-
-                    assembledTransaction.applyOptions(finalOptions)
-
-                    forAssemblyPipeline = (assembledTransaction, self.contract, mergedOptions)
-
-                    for hook in self.web3.postAssemblyHooks {
-                        let prom: Promise<Bool> = Promise<Bool> {seal in
-                            hook.queue.async {
-                                let hookResult = hook.function(forAssemblyPipeline)
-                                if hookResult.3 {
-                                    forAssemblyPipeline = (hookResult.0, hookResult.1, hookResult.2)
-                                }
-                                seal.fulfill(hookResult.3)
-                            }
-                        }
-                        let shouldContinue = try prom.wait()
-                        if !shouldContinue {
-                            throw Web3Error.processingError(desc: "Transaction is canceled by middleware")
-                        }
-                    }
-
-                    assembledTransaction = forAssemblyPipeline.0
-                    mergedOptions = forAssemblyPipeline.2
-
-                    return assembledTransaction
-                }).done(on: queue) {tx in
-                    seal.fulfill(tx)
-                    }.catch(on: queue) {err in
-                        seal.reject(err)
-                }
+        guard let from = mergedOptions.from else {
+            throw Web3Error.inputError(desc: "No 'from' field provided")
+        }
+
+        // assemble promise for gas estimation
+        var optionsForGasEstimation = TransactionOptions()
+        optionsForGasEstimation.from = mergedOptions.from
+        optionsForGasEstimation.to = mergedOptions.to
+        optionsForGasEstimation.value = mergedOptions.value
+        optionsForGasEstimation.gasLimit = mergedOptions.gasLimit
+        optionsForGasEstimation.callOnBlock = mergedOptions.callOnBlock
+
+            // assemble promise for gasLimit
+
+        guard let gasLimitPolicy = mergedOptions.gasLimit else {
+            throw Web3Error.inputError(desc: "No gasLimit policy provided")
+        }
+
+        guard let gasPricePolicy = mergedOptions.gasPrice else {
+            throw Web3Error.inputError(desc: "No gasPrice policy provided")
+        }
+
+        guard let noncePolicy = mergedOptions.nonce else {
+            throw Web3Error.inputError(desc: "No nonce policy provided")
+        }
+
+
+        let assembledTransactionPostHood = assembledTransaction
+        let optionsForGasEstimationPostHood = optionsForGasEstimation
+
+        async let gasEstimatePromise = gasEstimate(for: gasLimitPolicy, assembledTransaction: assembledTransactionPostHood, optionsForGasEstimation: optionsForGasEstimationPostHood)
+
+        // assemble promise for nonce
+        async let getNoncePromise = nonce(for: noncePolicy, from: from)
+
+
+        // assemble promise for gasPrice
+        async let gasPricePromise = gasPrice(for: gasPricePolicy)
+
+
+        let results = try await [getNoncePromise, gasPricePromise, gasEstimatePromise]
+
+        let nonce = results[0]
+        let gasEstimate = results[1]
+        let gasPrice = results[2]
+
+
+        let estimate = mergedOptions.resolveGasLimit(gasEstimate)
+        let finalGasPrice = mergedOptions.resolveGasPrice(gasPrice)
+
+        var finalOptions = TransactionOptions()
+        finalOptions.nonce = .manual(nonce)
+        finalOptions.gasLimit = .manual(estimate)
+        finalOptions.gasPrice = .manual(finalGasPrice)
+
+        assembledTransaction.applyOptions(finalOptions)
+
+        forAssemblyPipeline = (assembledTransaction, self.contract, mergedOptions)
+
+        for hook in self.web3.postAssemblyHooks {
+            let hookResult = hook.function(forAssemblyPipeline)
+            if hookResult.3 {
+                forAssemblyPipeline = (hookResult.0, hookResult.1, hookResult.2)
+            }
+            let shouldContinue = hookResult.3
+            if !shouldContinue {
+                throw Web3Error.processingError(desc: "Transaction is canceled by middleware")
             }
-            return returnPromise
         }
 
+
+        return assembledTransaction
+
+    }
+
     public func sendPromise(password: String = "web3swift", transactionOptions: TransactionOptions? = nil) async throws -> TransactionSendingResult{
         let transaction = try await self.assemblePromise(transactionOptions: transactionOptions)
         let mergedOptions = self.transactionOptions.merge(transactionOptions)
diff --git a/Tests/web3swiftTests/localTests/web3swiftTransactionsTests.swift b/Tests/web3swiftTests/localTests/web3swiftTransactionsTests.swift
@@ -641,7 +641,7 @@ class web3swiftTransactionsTests: XCTestCase {
 
             Thread.sleep(forTimeInterval: 1.0)
 
-            let receipt = try web3.eth.getTransactionReceipt(txHash)
+            let receipt = try await web3.eth.getTransactionReceipt(txHash)
             print(receipt)
             XCTAssert(receipt.status == .ok)
 
@@ -652,7 +652,7 @@ class web3swiftTransactionsTests: XCTestCase {
                 break
             }
 
-            let details = try web3.eth.getTransactionDetails(txHash)
+            let details = try await web3.eth.getTransactionDetails(txHash)
             print(details)
             let txnGasLimit = details.transaction.parameters.gasLimit
             XCTAssert(txnGasLimit == BigUInt(78423))
diff --git a/Tests/web3swiftTests/localTests/web3swiftUserCases.swift b/Tests/web3swiftTests/localTests/web3swiftUserCases.swift
@@ -54,19 +54,18 @@ class web3swiftUserCases: XCTestCase {
         let web3 = try await Web3.new(URL.init(string: "http://127.0.0.1:8545")!)
         let allAddresses = try await web3.eth.getAccounts()
         let gasPrice = try await web3.eth.getGasPrice()
-        let assembled = try writeTX.assemblePromise().wait()
-        let txnGasLimit = assembled.parameters.gasLimit
-        XCTAssert(txnGasLimit == gasEstimate + 1234)
         let sendToAddress = EthereumAddress("0xe22b8979739D724343bd002F9f432F5990879901")!
-        guard let writeTX = web3.eth.sendETH(to: sendToAddress, amount: "0.001") else {return XCTFail()}
+        guard let writeTX = web3.eth.sendETH(to: sendToAddress, amount: "0.001") else {
+            return XCTFail()
+        }
         writeTX.transactionOptions.from = allAddresses[0]
         writeTX.transactionOptions.gasPrice = .manual(gasPrice * 2)
         let gasEstimate = try await writeTX.estimateGasPromise()
         writeTX.transactionOptions.gasLimit = .manual(gasEstimate + 1234)
         let assembled = try await writeTX.assemblePromise()
         let txnGasLimit = assembled.parameters.gasLimit
         let txnGasPrice = assembled.parameters.gasPrice
-      
+        
         XCTAssert(txnGasLimit == gasEstimate + 1234)
         XCTAssert(txnGasPrice == gasPrice * 2)
     }
diff --git a/Tests/web3swiftTests/remoteTests/GasOracleTests.swift b/Tests/web3swiftTests/remoteTests/GasOracleTests.swift
@@ -13,37 +13,43 @@ import BigInt
 // MARK: Works only with network connection
 class OracleTests: XCTestCase {
 
-    let web3 = Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+
 
     let blockNumber: BigUInt = 14571792
 
-    lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
 
-    func testPretictBaseFee() throws {
+
+    func testPretictBaseFee() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
         let etalonPercentiles: [BigUInt] = [
             71456911562,    // 10 percentile
             92735433497,    // 40 percentile
             105739785122,   // 60 percentile
             118929912191    // 90 percentile
         ]
 
-        let baseFeePercentiles = oracle.baseFeePercentiles
+        let baseFeePercentiles = await oracle.baseFeePercentiles()
         XCTAssertEqual(baseFeePercentiles, etalonPercentiles, "Arrays should be equal")
     }
 
-    func testPredictTip() throws {
+    func testPredictTip() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
         let etalonPercentiles: [BigUInt] = [
             1251559157,     // 10 percentile
             1594062500,     // 40 percentile
             2268157275,     // 60 percentile
             11394017894     // 90 percentile
         ]
 
-        let tipFeePercentiles = oracle.tipFeePercentiles
+        let tipFeePercentiles = await oracle.tipFeePercentiles()
         XCTAssertEqual(tipFeePercentiles, etalonPercentiles, "Arrays should be equal")
     }
 
-    func testPredictBothFee() throws {
+    func testPredictBothFee() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
         let etalonPercentiles: ([BigUInt], [BigUInt]) = (
             baseFee: [
                 71456911562,    // 10 percentile
@@ -59,25 +65,29 @@ class OracleTests: XCTestCase {
             ]
         )
 
-        let bothFeesPercentiles = oracle.bothFeesPercentiles
+        let bothFeesPercentiles = await oracle.bothFeesPercentiles()
         XCTAssertEqual(bothFeesPercentiles?.baseFee, etalonPercentiles.0, "Arrays should be equal")
         XCTAssertEqual(bothFeesPercentiles?.tip, etalonPercentiles.1, "Arrays should be equal")
     }
 
-    func testPredictLegacyGasPrice() throws {
+    func testPredictLegacyGasPrice() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
         let etalonPercentiles: [BigUInt] = [
             93253857566,     // 10 percentile
             106634912620,    // 40 percentile
             111000000000,    // 60 percentile
             127210686305     // 90 percentile
         ]
         
-        let gasPriceLegacyPercentiles = oracle.gasPriceLegacyPercentiles
+        let gasPriceLegacyPercentiles = await oracle.gasPriceLegacyPercentiles()
         XCTAssertEqual(gasPriceLegacyPercentiles, etalonPercentiles, "Arrays should be equal")
     }
 
-    func testAllTransactionInBlockDecodesWell() throws {
-        let blockWithTransaction = try web3.eth.getBlockByNumber(blockNumber, fullTransactions: true)
+    func testAllTransactionInBlockDecodesWell() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        lazy var oracle: Web3.Oracle = .init(web3, block: .exact(blockNumber), blockCount: 20, percentiles: [10, 40, 60, 90])
+        let blockWithTransaction = try await web3.eth.getBlockByNumber(blockNumber, fullTransactions: true)
 
         let nullTransactions = blockWithTransaction.transactions.filter {
             guard case .null = $0 else { return false }
