cleanups use async calls with opaque batching for most of the calls

Author: Alex Vlasov

web3swift/Concurrency/Classes/Web3+Concurrency.swift

@@ -24,7 +24,7 @@ public class OperationDispatcher {
         self.provider = provider
         self.queue = queue
         self.policy = policy
-        self.lockQueue = DispatchQueue(label: "batchingQueue")
+        self.lockQueue = DispatchQueue(label: "batchingQueue", qos: .userInitiated)
     }
 
     struct Request {

web3swift/Concurrency/Classes/Web3+TransactionOperations.swift

@@ -11,19 +11,16 @@ import Result
 import BigInt
 
 final class ContractCallOperation: Web3Operation {
-    var intermediate: TransactionIntermediate?
     var method: String?
 
-    convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, intermediate: TransactionIntermediate, onBlock: String = "latest") {
-        self.init(web3Instance, queue: queue, inputData: [intermediate.transaction, intermediate.options as Any, onBlock] as AnyObject)
-        self.intermediate = intermediate
+    convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, intermediate: TransactionIntermediate, onBlock: String = "latest", options: Web3Options? = nil) {
+        self.init(web3Instance, queue: queue, inputData: [intermediate, options as Any, onBlock] as AnyObject)
         self.method = intermediate.method
     }
 
-    convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, contract: web3.web3contract, method: String = "fallback", parameters: [AnyObject] = [], extraData: Data = Data(), options: Web3Options?, onBlock: String = "latest") {
+    convenience init?(_ web3Instance: web3, queue: OperationQueue? = nil, contract: web3.web3contract, method: String = "fallback", parameters: [AnyObject] = [], extraData: Data = Data(), options: Web3Options? = nil, onBlock: String = "latest") {
         guard let intermediate = contract.method(method, parameters: parameters, extraData: extraData, options: options) else {return nil}
-        self.init(web3Instance, queue: queue, inputData: [intermediate.transaction, intermediate.options as Any, onBlock] as AnyObject)
-        self.intermediate = intermediate
+        self.init(web3Instance, queue: queue, inputData: [intermediate, options as Any, onBlock] as AnyObject)
         self.method = method
     }
 
@@ -34,17 +31,20 @@ final class ContractCallOperation: Web3Operation {
         guard let _ = self.next else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard inputData != nil else {return processError(Web3Error.inputError("Invalid input supplied"))}
         guard let input = inputData! as? [AnyObject] else {return processError(Web3Error.inputError("Invalid input supplied"))}
+        
         guard input.count == 3 else {return processError(Web3Error.inputError("Invalid input supplied"))}
-        guard let transaction = input[0] as? EthereumTransaction else {return processError(Web3Error.inputError("Invalid input supplied"))}
+        guard let intermediate = input[0] as? TransactionIntermediate else {return processError(Web3Error.inputError("Invalid input supplied"))}
         let options = input[1] as? Web3Options
         guard let onBlock = input[2] as? String else {return processError(Web3Error.inputError("Invalid input supplied"))}
-        let mergedOptions = Web3Options.merge(Web3Options.defaultOptions(), with: options)
-        guard let request = EthereumTransaction.createRequest(method: JSONRPCmethod.call, transaction: transaction, onBlock: onBlock, options: mergedOptions) else {return processError(Web3Error.inputError("Invalid input supplied"))}
-        let dataOp = DataFetchOperation(self.web3, queue: self.expectedQueue)
-        dataOp.inputData = request as AnyObject
-        let parsingOp = DataConversionOperation(self.web3, queue: self.expectedQueue)
-        dataOp.next = OperationChainingType.operation(parsingOp)
-        let callback = { (res: Result<AnyObject, Web3Error>) -> () in
+        guard var mergedOptions = Web3Options.merge(intermediate.options, with: options) else {return processError(Web3Error.inputError("Invalid input supplied"))}
+        mergedOptions.gasLimit = nil
+        if (options?.gasLimit != nil) {
+            mergedOptions.gasLimit = options?.gasLimit
+        }
+        guard let _ = mergedOptions.from else {return processError(Web3Error.inputError("Invalid input supplied"))}
+        let transaction = intermediate.transaction
+
+        let parsingCallback = { (res: Result<AnyObject, Web3Error>) -> () in
             switch res {
             case .success(let result):
                 guard let resultData = result as? Data else {
@@ -57,9 +57,6 @@ final class ContractCallOperation: Web3Operation {
                 guard let method = self.method else {
                     return self.processError(Web3Error.dataError)
                 }
-                guard let intermediate = self.intermediate else {
-                    return self.processError(Web3Error.dataError)
-                }
                 guard let decodedData = intermediate.contract.decodeReturnData(method, data: resultData) else
                 {
                     return self.processError(Web3Error.dataError)
@@ -69,8 +66,49 @@ final class ContractCallOperation: Web3Operation {
                 return self.processError(error)
             }
         }
-        parsingOp.next = OperationChainingType.callback(callback, self.expectedQueue)
+        
+        guard let request = EthereumTransaction.createRequest(method: JSONRPCmethod.call, transaction: transaction, onBlock: onBlock, options: mergedOptions) else {return self.processError(Web3Error.inputError("Invalid input supplied"))}
+        let dataOp = DataFetchOperation(self.web3, queue: self.expectedQueue)
+        dataOp.inputData = request as AnyObject
+        let parsingOp = DataConversionOperation(self.web3, queue: self.expectedQueue)
+        dataOp.next = OperationChainingType.operation(parsingOp)
+        parsingOp.next = OperationChainingType.callback(parsingCallback, self.expectedQueue)
         self.expectedQueue.addOperation(dataOp)
+        
+//        let gasEstimationCallback = { (res: Result<AnyObject, Web3Error>) -> () in
+//            switch res {
+//            case .success(let result):
+//                guard let gasEstimate = result as? BigUInt else {
+//                    return self.processError(Web3Error.dataError)
+//                }
+////                if mergedOptions.gasLimit == nil {
+////                    mergedOptions.gasLimit = gasEstimate
+////                } else {
+////                    if (mergedOptions.gasLimit! < gasEstimate) {
+////                        if (options?.gasLimit != nil && options!.gasLimit != nil && options!.gasLimit! >=  gasEstimate) {
+////                            mergedOptions.gasLimit = options!.gasLimit!
+////                        } else {
+////                            return self.processError(Web3Error.inputError("Estimated gas is larger than the gas limit"))
+////                        }
+////                    }
+////                }
+//                guard let request = EthereumTransaction.createRequest(method: JSONRPCmethod.call, transaction: transaction, onBlock: onBlock, options: mergedOptions) else {return self.processError(Web3Error.inputError("Invalid input supplied"))}
+//                let dataOp = DataFetchOperation(self.web3, queue: self.expectedQueue)
+//                dataOp.inputData = request as AnyObject
+//                let parsingOp = DataConversionOperation(self.web3, queue: self.expectedQueue)
+//                dataOp.next = OperationChainingType.operation(parsingOp)
+//                parsingOp.next = OperationChainingType.callback(parsingCallback, self.expectedQueue)
+//                self.expectedQueue.addOperation(dataOp)
+//                return
+//            case .failure(let error):
+//                return self.processError(error)
+//            }
+//        }
+//
+//        guard let gasEstimateOperation = ContractEstimateGasOperation.init(self.web3, queue: self.expectedQueue, intermediate: intermediate, onBlock: onBlock) else {return self.processError(Web3Error.dataError)}
+//        gasEstimateOperation.next = OperationChainingType.callback(gasEstimationCallback, self.expectedQueue)
+//        self.expectedQueue.addOperation(gasEstimateOperation)
+
     }
 }
 
@@ -140,7 +178,7 @@ final class ContractSendOperation: Web3Operation {
                 } else {
                     if (mergedOptions.gasLimit! < gasEstimate) {
                         if (options?.gasLimit != nil && options!.gasLimit != nil && options!.gasLimit! >=  gasEstimate) {
-                            mergedOptions.gasLimit = gasEstimate
+                            mergedOptions.gasLimit = options!.gasLimit!
                         } else {
                             return self.processError(Web3Error.inputError("Estimated gas is larger than the gas limit"))
                         }

web3swift/KeystoreManager/Classes/EthereumAddress.swift

@@ -79,7 +79,7 @@ public struct EthereumAddress: Equatable {
         case .normal:
             guard let data = Data.fromHex(addressString) else {return nil}
             guard data.count == 20 else {return nil}
-            if (!ignoreChecksum && data.toHexString().addHexPrefix() != addressString.lowercased()) {
+            if (!ignoreChecksum && data.toHexString().addHexPrefix() != addressString) {
                 let checksummedAddress = EthereumAddress.toChecksumAddress(data.toHexString().addHexPrefix())
                 guard checksummedAddress == addressString else {return nil}
             }

web3swift/Web3/Classes/Web3+HttpProvider.swift

@@ -61,6 +61,7 @@ public class Web3HttpProvider: Web3Provider {
         }
         guard let response = self.syncPost(requests) else {return nil}
         guard let res = response as? [[String: AnyObject]?] else {return nil}
+//        print(res)
         return res
     }