propagate async changes

Cartfile

@@ -2,4 +2,3 @@ github "attaswift/BigInt" ~> 5.3.0
 github "attaswift/SipHash" ~> 1.2.2
 github "daltoniam/Starscream" ~> 4.0.4
 github "krzyzanowskim/CryptoSwift" ~> 1.4.2
-github "mxcl/PromiseKit" ~> 6.16.2

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

@@ -9,28 +9,18 @@ import Foundation
 
 extension web3.Eth {
 
-    public func callPromise(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions?) -> Promise<Data>{
-        let queue = web3.requestDispatcher.queue
-        do {
-            guard let request = EthereumTransaction.createRequest(method: .call, transaction: transaction, transactionOptions: transactionOptions) else {
-                throw Web3Error.processingError(desc: "Transaction is invalid")
-            }
-            let rp = web3.dispatch(request)
-            return rp.map(on: queue) { response in
-                guard let value: Data = 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
-            }
-        } catch {
-            let returnPromise = Promise<Data>.pending()
-            queue.async {
-                returnPromise.resolver.reject(error)
+    public func callPromise(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions?) async throws -> Data {
+        guard let request = EthereumTransaction.createRequest(method: .call, transaction: transaction, transactionOptions: transactionOptions) else {
+            throw Web3Error.processingError(desc: "Transaction is invalid")
+        }
+        let response = try await web3.dispatch(request)
+
+        guard let value: Data = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return returnPromise.promise
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
     }
 }

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

@@ -10,43 +10,36 @@ import BigInt
 
 extension web3.Eth {
 
-    public func estimateGasPromise(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions?) -> Promise<BigUInt>{
-        let queue = web3.requestDispatcher.queue
-        do {
-            guard let request = EthereumTransaction.createRequest(method: .estimateGas, transaction: transaction, transactionOptions: transactionOptions) else {
-                throw Web3Error.processingError(desc: "Transaction is invalid")
-            }
-            let rp = web3.dispatch(request)
-            return rp.map(on: queue) { response in
-                guard let value: BigUInt = response.getValue() else {
-                    if response.error != nil {
-                        throw Web3Error.nodeError(desc: response.error!.message)
-                    }
-                    throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
-                }
-
-                if let policy = transactionOptions?.gasLimit {
-                    switch policy {
-                    case .automatic:
-                        return value
-                    case .limited(let limitValue):
-                        return limitValue < value ? limitValue: value
-                    case .manual(let exactValue):
-                        return exactValue
-                    case .withMargin:
-                        // MARK: - update value according margin
-                        return value
-                    }
-                } else {
-                    return value
-                }
+    public func estimateGasPromise(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions?) async throws -> BigUInt {
+
+        guard let request = EthereumTransaction.createRequest(method: .estimateGas, transaction: transaction, transactionOptions: transactionOptions) else {
+            throw Web3Error.processingError(desc: "Transaction is invalid")
+        }
+        let response = try await web3.dispatch(request)
+
+        guard let value: BigUInt = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-        } catch {
-            let returnPromise = Promise<BigUInt>.pending()
-            queue.async {
-                returnPromise.resolver.reject(error)
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
+        }
+
+        if let policy = transactionOptions?.gasLimit {
+            switch policy {
+            case .automatic:
+                return value
+            case .limited(let limitValue):
+                return limitValue < value ? limitValue: value
+            case .manual(let exactValue):
+                return exactValue
+            case .withMargin:
+                // MARK: - update value according margin
+                return value
             }
-            return returnPromise.promise
+        } else {
+            return value
         }
+
+
     }
 }

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

@@ -9,22 +9,21 @@ import Foundation
 import BigInt
 
 extension web3.Eth {
-    public func getBalancePromise(address: EthereumAddress, onBlock: String = "latest") -> Promise<BigUInt> {
+    public func getBalancePromise(address: EthereumAddress, onBlock: String = "latest") async throws -> BigUInt {
         let addr = address.address
-        return getBalancePromise(address: addr, onBlock: onBlock)
+        return try await getBalancePromise(address: addr, onBlock: onBlock)
     }
-    public func getBalancePromise(address: String, onBlock: String = "latest") -> Promise<BigUInt> {
+    public func getBalancePromise(address: String, onBlock: String = "latest") async throws -> BigUInt {
         let request = JSONRPCRequestFabric.prepareRequest(.getBalance, parameters: [address.lowercased(), onBlock])
-        let rp = web3.dispatch(request)
-        let queue = web3.requestDispatcher.queue
-        return rp.map(on: queue) { response in
-            guard let value: BigUInt = 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: BigUInt = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
+
     }
 }

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

@@ -9,23 +9,22 @@ import BigInt
 
 
 extension web3.Eth {
-    public func getBlockByHashPromise(_ hash: Data, fullTransactions: Bool = false) -> Promise<Block> {
+    public func getBlockByHashPromise(_ hash: Data, fullTransactions: Bool = false) async throws -> Block {
         let hashString = hash.toHexString().addHexPrefix()
-        return getBlockByHashPromise(hashString, fullTransactions: fullTransactions)
+        return try await getBlockByHashPromise(hashString, fullTransactions: fullTransactions)
     }
 
-    public func getBlockByHashPromise(_ hash: String, fullTransactions: Bool = false) -> Promise<Block> {
+    public func getBlockByHashPromise(_ hash: String, fullTransactions: Bool = false) async throws -> Block {
         let request = JSONRPCRequestFabric.prepareRequest(.getBlockByHash, parameters: [hash, fullTransactions])
-        let rp = web3.dispatch(request)
-        let queue = web3.requestDispatcher.queue
-        return rp.map(on: queue) { response in
-            guard let value: Block = 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: Block = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
+
     }
 }

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

@@ -9,28 +9,27 @@ import BigInt
 
 
 extension web3.Eth {
-    public func getBlockByNumberPromise(_ number: UInt64, fullTransactions: Bool = false) -> Promise<Block> {
+    public func getBlockByNumberPromise(_ number: UInt64, fullTransactions: Bool = false) async throws -> Block {
         let block = String(number, radix: 16).addHexPrefix()
-        return getBlockByNumberPromise(block, fullTransactions: fullTransactions)
+        return try await getBlockByNumberPromise(block, fullTransactions: fullTransactions)
     }
 
-    public func getBlockByNumberPromise(_ number: BigUInt, fullTransactions: Bool = false) -> Promise<Block> {
+    public func getBlockByNumberPromise(_ number: BigUInt, fullTransactions: Bool = false) async throws -> Block {
         let block = String(number, radix: 16).addHexPrefix()
-        return getBlockByNumberPromise(block, fullTransactions: fullTransactions)
+        return try await getBlockByNumberPromise(block, fullTransactions: fullTransactions)
     }
 
-    public func getBlockByNumberPromise(_ number: String, fullTransactions: Bool = false) -> Promise<Block> {
+    public func getBlockByNumberPromise(_ number: String, fullTransactions: Bool = false) async throws -> Block {
         let request = JSONRPCRequestFabric.prepareRequest(.getBlockByNumber, parameters: [number, fullTransactions])
-        let rp = web3.dispatch(request)
-        let queue = web3.requestDispatcher.queue
-        return rp.map(on: queue) { response in
-            guard let value: Block = 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: Block = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
+
     }
 }

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

@@ -10,22 +10,21 @@ import Foundation
 import BigInt
 
 extension web3.Eth {
-    public func getCodePromise(address: EthereumAddress, onBlock: String = "latest") -> Promise<String> {
+    public func getCodePromise(address: EthereumAddress, onBlock: String = "latest") async throws -> String {
         let addr = address.address
-        return getCodePromise(address: addr, onBlock: onBlock)
+        return try await getCodePromise(address: addr, onBlock: onBlock)
     }
-    public func getCodePromise(address: String, onBlock: String = "latest") -> Promise<String> {
+    public func getCodePromise(address: String, onBlock: String = "latest") async throws -> String {
         let request = JSONRPCRequestFabric.prepareRequest(.getCode, parameters: [address.lowercased(), onBlock])
-        let rp = web3.dispatch(request)
-        let queue = web3.requestDispatcher.queue
-        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 response = try await web3.dispatch(request)
+
+        guard let value: String = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
+
     }
 }

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

@@ -9,23 +9,22 @@ import BigInt
 
 
 extension web3.Eth {
-    public func getTransactionCountPromise(address: EthereumAddress, onBlock: String = "latest") -> Promise<BigUInt> {
+    public func getTransactionCountPromise(address: EthereumAddress, onBlock: String = "latest") async throws -> BigUInt {
         let addr = address.address
-        return getTransactionCountPromise(address: addr, onBlock: onBlock)
+        return try await getTransactionCountPromise(address: addr, onBlock: onBlock)
     }
 
-    public func getTransactionCountPromise(address: String, onBlock: String = "latest") -> Promise<BigUInt> {
+    public func getTransactionCountPromise(address: String, onBlock: String = "latest") async throws -> BigUInt {
         let request = JSONRPCRequestFabric.prepareRequest(.getTransactionCount, parameters: [address.lowercased(), onBlock])
-        let rp = web3.dispatch(request)
+        let response = try await web3.dispatch(request)
         let queue = web3.requestDispatcher.queue
-        return rp.map(on: queue) { response in
-            guard let value: BigUInt = response.getValue() else {
-                if response.error != nil {
-                    throw Web3Error.nodeError(desc: response.error!.message)
-                }
-                throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
+
+        guard let value: BigUInt = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
     }
 }

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

@@ -9,23 +9,22 @@ import BigInt
 
 
 extension web3.Eth {
-    public func getTransactionDetailsPromise(_ txhash: Data) -> Promise<TransactionDetails> {
+    public func getTransactionDetailsPromise(_ txhash: Data) async throws -> TransactionDetails {
         let hashString = txhash.toHexString().addHexPrefix()
-        return self.getTransactionDetailsPromise(hashString)
+        return try await self.getTransactionDetailsPromise(hashString)
     }
 
-    public func getTransactionDetailsPromise(_ txhash: String) -> Promise<TransactionDetails> {
+    public func getTransactionDetailsPromise(_ txhash: String) async throws -> TransactionDetails {
         let request = JSONRPCRequestFabric.prepareRequest(.getTransactionByHash, parameters: [txhash])
-        let rp = web3.dispatch(request)
-        let queue = web3.requestDispatcher.queue
-        return rp.map(on: queue) { response in
-            guard let value: TransactionDetails = 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: TransactionDetails = response.getValue() else {
+            if response.error != nil {
+                throw Web3Error.nodeError(desc: response.error!.message)
             }
-            return value
+            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
         }
+        return value
+
     }
 }