binded synchronous functions to promises fixed tests

Alex Vlasov · Alex Vlasov · commit 953785aea941 · 2018-06-18T21:51:20.000+03:00
diff --git a/web3swift/HookedFunctions/Classes/Web3+BrowserFunctions.swift b/web3swift/HookedFunctions/Classes/Web3+BrowserFunctions.swift
@@ -91,7 +91,7 @@ extension web3.BrowserFunctions {
         case .failure(_):
             return nil
         case .success(let res):
-            return res
+            return ["txhash": res.hash]
         }
     }
     
diff --git a/web3swift/KeystoreManager/Classes/EthereumKeystoreV3.swift b/web3swift/KeystoreManager/Classes/EthereumKeystoreV3.swift
@@ -84,8 +84,8 @@ public class EthereumKeystoreV3: AbstractKeystore {
         let saltLen = 32;
         guard let saltData = Data.randomBytes(length: saltLen) else {throw AbstractKeystoreError.noEntropyError}
         guard let derivedKey = scrypt(password: password, salt: saltData, length: dkLen, N: N, R: R, P: P) else {throw AbstractKeystoreError.keyDerivationError}
-        let last16bytes = derivedKey[(derivedKey.count - 16)...(derivedKey.count-1)]
-        let encryptionKey = derivedKey[0...15]
+        let last16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count-1)])
+        let encryptionKey = Data(derivedKey[0...15])
         guard let IV = Data.randomBytes(length: 16) else {throw AbstractKeystoreError.noEntropyError}
         var aesCipher : AES?
         switch aesMode {
@@ -148,7 +148,7 @@ public class EthereumKeystoreV3: AbstractKeystore {
                 default:
                     hashVariant = nil
             }
-            guard (hashVariant != nil) else {return nil}
+            guard hashVariant != nil else {return nil}
             guard let c = keystoreParams.crypto.kdfparams.c else {return nil}
             guard let passData = password.data(using: .utf8) else {return nil}
             guard let derivedArray = try? PKCS5.PBKDF2(password: passData.bytes, salt: saltData.bytes, iterations: c, keyLength: derivedLen, variant: hashVariant!).calculate() else {return nil}
@@ -158,7 +158,7 @@ public class EthereumKeystoreV3: AbstractKeystore {
         }
         guard let derivedKey = passwordDerivedKey else {return nil}
         var dataForMAC = Data()
-        let derivedKeyLast16bytes = derivedKey[(derivedKey.count - 16)...(derivedKey.count - 1)]
+        let derivedKeyLast16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count - 1)])
         dataForMAC.append(derivedKeyLast16bytes)
         guard let cipherText = Data.fromHex(keystoreParams.crypto.ciphertext) else {return nil}
         if (cipherText.count != 32) {return nil}
diff --git a/web3swift/Promises/Classes/Promise+HttpProvider.swift b/web3swift/Promises/Classes/Promise+HttpProvider.swift
@@ -87,8 +87,8 @@ extension Web3HttpProvider {
         return rp.promise.ensure(on: queue) {
             task = nil
             }.map(on: queue){ (data: Data) throws -> JSONRPCresponseBatch in
-//                let debugValue = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions(rawValue: 0))
-//                print(debugValue)
+                let debugValue = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions(rawValue: 0))
+                print(debugValue)
                 let parsedResponse = try JSONDecoder().decode(JSONRPCresponseBatch.self, from: data)
                 return parsedResponse
         }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Contract+GetIndexedEvents.swift b/web3swift/Promises/Classes/Promise+Web3+Contract+GetIndexedEvents.swift
@@ -29,6 +29,9 @@ extension web3.web3contract {
             let request = JSONRPCRequestFabric.prepareRequest(.getLogs, parameters: [preEncoding])
             let fetchLogsPromise = self.web3.dispatch(request).map(on: queue) {response throws -> [EventParserResult] in
                 guard let value: [EventLog] = response.getValue() else {
+                    if response.error != nil {
+                        throw Web3Error.nodeError(response.error!.message)
+                    }
                     throw Web3Error.nodeError("Empty or malformed response")
                 }
                 let allLogs = value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+Call.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+Call.swift
@@ -20,6 +20,9 @@ extension web3.Eth {
             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(response.error!.message)
+                    }
                     throw Web3Error.nodeError("Invalid value from Ethereum node")
                 }
                 return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+EstimateGas.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+EstimateGas.swift
@@ -21,6 +21,9 @@ extension web3.Eth {
             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(response.error!.message)
+                    }
                     throw Web3Error.nodeError("Invalid value from Ethereum node")
                 }
                 return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetAccounts.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetAccounts.swift
@@ -30,6 +30,9 @@ extension web3.Eth {
         let rp = web3.dispatch(request)
         return rp.map(on: queue ) { response in
             guard let value: [EthereumAddress] = response.getValue() else {
+                if response.error != nil {
+                    throw Web3Error.nodeError(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetBalance.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetBalance.swift
@@ -21,6 +21,9 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockByHash.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockByHash.swift
@@ -22,12 +22,12 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
-//            let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))
-//            let details = try JSONDecoder().decode(Block.self, from: reencoded)
-//            return details
         }
     }
 }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockByNumber.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockByNumber.swift
@@ -27,12 +27,12 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
-//            let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))
-//            let details = try JSONDecoder().decode(Block.self, from: reencoded)
-//            return details
         }
     }
 }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockNumber.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetBlockNumber.swift
@@ -17,6 +17,9 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetGasPrice.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetGasPrice.swift
@@ -17,6 +17,9 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionCount.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionCount.swift
@@ -9,17 +9,22 @@
 import Foundation
 import BigInt
 import PromiseKit
+
 extension web3.Eth {
     public func getTransactionCountPromise(address: EthereumAddress, onBlock: String = "latest") -> Promise<BigUInt> {
         let addr = address.address
         return getTransactionCountPromise(address: addr, onBlock: onBlock)
     }
+    
     public func getTransactionCountPromise(address: String, onBlock: String = "latest") -> Promise<BigUInt> {
         let request = JSONRPCRequestFabric.prepareRequest(.getTransactionCount, 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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionDetails.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionDetails.swift
@@ -22,16 +22,12 @@ extension web3.Eth {
         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(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
-//            guard let details = TransactionDetails(value) else {
-//                throw Web3Error.processingError("Can not deserialize transaction details")
-//            }
-//            return details
-//            let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))
-//            let details = try JSONDecoder().decode(TransactionDetails.self, from: reencoded)
-//            return details
         }
     }
 }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionReceipt.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+GetTransactionReceipt.swift
@@ -22,16 +22,12 @@ extension web3.Eth {
         let queue = web3.requestDispatcher.queue
         return rp.map(on: queue ) { response in
             guard let value: TransactionReceipt = response.getValue() else {
+                if response.error != nil {
+                    throw Web3Error.nodeError(response.error!.message)
+                }
                 throw Web3Error.nodeError("Invalid value from Ethereum node")
             }
             return value
-//            guard let details = TransactionReceipt(value) else {
-//                throw Web3Error.processingError("Can not deserialize transaction details")
-//            }
-//            return details
-//            let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))
-//            let details = try JSONDecoder().decode(TransactionReceipt.self, from: reencoded)
-//            return details
         }
     }
 }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+SendRawTransaction.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+SendRawTransaction.swift
@@ -29,6 +29,9 @@ extension web3.Eth {
             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(response.error!.message)
+                    }
                     throw Web3Error.nodeError("Invalid value from Ethereum node")
                 }
                 let result = TransactionSendingResult(transaction: transaction, hash: value)
diff --git a/web3swift/Promises/Classes/Promise+Web3+Eth+SendTransaction.swift b/web3swift/Promises/Classes/Promise+Web3+Eth+SendTransaction.swift
@@ -24,6 +24,9 @@ extension web3.Eth {
                 }
                 return self.web3.dispatch(request).map(on: queue) {response in
                     guard let value: String = response.getValue() else {
+                        if response.error != nil {
+                            throw Web3Error.nodeError(response.error!.message)
+                        }
                         throw Web3Error.nodeError("Invalid value from Ethereum node")
                     }
                     let result = TransactionSendingResult(transaction: assembledTransaction, hash: value)
@@ -33,7 +36,8 @@ extension web3.Eth {
             guard let from = options.from else {
                 throw Web3Error.inputError("No 'from' field provided")
             }
-            do {try Web3Signer.signTX(transaction: &assembledTransaction, keystore: self.web3.provider.attachedKeystoreManager!, account: from, password: password)
+            do {
+                try Web3Signer.signTX(transaction: &assembledTransaction, keystore: self.web3.provider.attachedKeystoreManager!, account: from, password: password)
             } catch {
                 throw Web3Error.inputError("Failed to locally sign a transaction")
             }
diff --git a/web3swift/Promises/Classes/Promise+Web3+Personal+Sign.swift b/web3swift/Promises/Classes/Promise+Web3+Personal+Sign.swift
@@ -12,14 +12,17 @@ import PromiseKit
 
 extension web3.Personal {
     
-    func sendPersonalMessagePromise(message: Data, from: EthereumAddress, password:String = "BANKEXFOUNDATION") -> Promise<Data> {
+    func signPersonalMessagePromise(message: Data, from: EthereumAddress, password:String = "BANKEXFOUNDATION") -> Promise<Data> {
         let queue = web3.requestDispatcher.queue
         do {
             if self.web3.provider.attachedKeystoreManager == nil {
                 let hexData = message.toHexString().addHexPrefix()
                 let request = JSONRPCRequestFabric.prepareRequest(.personalSign, parameters: [from.address.lowercased(), hexData])
                 return self.web3.dispatch(request).map(on: queue) {response in
                     guard let value: Data = response.getValue() else {
+                        if response.error != nil {
+                            throw Web3Error.nodeError(response.error!.message)
+                        }
                         throw Web3Error.nodeError("Invalid value from Ethereum node")
                     }
                     return value
diff --git a/web3swift/Promises/Classes/Promise+Web3+Personal+UnlockAccount.swift b/web3swift/Promises/Classes/Promise+Web3+Personal+UnlockAccount.swift
@@ -24,6 +24,9 @@ extension web3.Personal {
                 let request = JSONRPCRequestFabric.prepareRequest(.unlockAccount, parameters: [account.lowercased(), password, seconds])
                 return self.web3.dispatch(request).map(on: queue) {response in
                     guard let value: Bool = response.getValue() else {
+                        if response.error != nil {
+                            throw Web3Error.nodeError(response.error!.message)
+                        }
                         throw Web3Error.nodeError("Invalid value from Ethereum node")
                     }
                     return value
diff --git a/web3swift/Web3/Classes/Web3+Eth.swift b/web3swift/Web3/Classes/Web3+Eth.swift
diff --git a/web3swift/Web3/Classes/Web3+EventParser.swift b/web3swift/Web3/Classes/Web3+EventParser.swift
diff --git a/web3swift/Web3/Classes/Web3+JSONRPC.swift b/web3swift/Web3/Classes/Web3+JSONRPC.swift
diff --git a/web3swift/Web3/Classes/Web3+Personal.swift b/web3swift/Web3/Classes/Web3+Personal.swift
diff --git a/web3swift/Web3/Classes/Web3+Structures.swift b/web3swift/Web3/Classes/Web3+Structures.swift
diff --git a/web3swift/Web3/Classes/Web3+TransactionIntermediate.swift b/web3swift/Web3/Classes/Web3+TransactionIntermediate.swift
diff --git a/web3swiftTests/web3swiftTests.swift b/web3swiftTests/web3swiftTests.swift
diff --git a/web3swiftTests/web3swift_local_node_Tests.swift b/web3swiftTests/web3swift_local_node_Tests.swift

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ extension web3.BrowserFunctions {`
`91`	`91`	`case .failure(_):`
`92`	`92`	`return nil`
`93`	`93`	`case .success(let res):`
`94`		`- return res`
	`94`	`+ return ["txhash": res.hash]`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,12 @@ extension web3.Eth {`
`22`	`22`	`let queue = web3.requestDispatcher.queue`
`23`	`23`	`return rp.map(on: queue ) { response in`
`24`	`24`	`guard let value: Block = response.getValue() else {`
	`25`	`+ if response.error != nil {`
	`26`	`+ throw Web3Error.nodeError(response.error!.message)`
	`27`	`+ }`
`25`	`28`	`throw Web3Error.nodeError("Invalid value from Ethereum node")`
`26`	`29`	`}`
`27`	`30`	`return value`
`28`		`-// let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))`
`29`		`-// let details = try JSONDecoder().decode(Block.self, from: reencoded)`
`30`		`-// return details`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,12 @@ extension web3.Eth {`
`27`	`27`	`let queue = web3.requestDispatcher.queue`
`28`	`28`	`return rp.map(on: queue ) { response in`
`29`	`29`	`guard let value: Block = response.getValue() else {`
	`30`	`+ if response.error != nil {`
	`31`	`+ throw Web3Error.nodeError(response.error!.message)`
	`32`	`+ }`
`30`	`33`	`throw Web3Error.nodeError("Invalid value from Ethereum node")`
`31`	`34`	`}`
`32`	`35`	`return value`
`33`		`-// let reencoded = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions(rawValue: 0))`
`34`		`-// let details = try JSONDecoder().decode(Block.self, from: reencoded)`
`35`		`-// return details`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`