Merge pull request #202 from argentlabs/tech/remove-0x-executionerror

[CHANGE] Remove workaround returning '0x' when eth_call fails

Author: DarthMike

web3sTests/Client/EthereumClientTests.swift

@@ -34,14 +34,12 @@ struct TransferMatchingSignatureEvent: ABIEvent {
 
 class EthereumClientTests: XCTestCase {
     var client: EthereumClient?
-    var mainnetClient: EthereumClient?
     var account: EthereumAccount?
     let timeout = 10.0
 
     override func setUp() {
         super.setUp()
         self.client = EthereumClient(url: URL(string: TestConfig.clientUrl)!)
-        self.mainnetClient = EthereumClient(url: URL(string: TestConfig.mainnetClientUrl)!)
         self.account = try? EthereumAccount(keyStorage: TestEthereumKeyStorage(privateKey: TestConfig.privateKey))
         print("Public address: \(self.account?.address.value ?? "NONE")")
     }
@@ -325,32 +323,20 @@ extension EthereumClientTests {
         }
     }
 
-    // This is how geth used to work up until a recent version
-    // see https://github.com/ethereum/go-ethereum/pull/21083/
-    // Used to return '0x' in response, and would fail decoding
-    // We'll continue to support this as user of library (and Argent in our case)
-    // works with this assumption.
-    // NOTE: This behaviour will be removed at a later time to fail as expected
-    // NOTE: At the time of writing, this test succeeds as-is in ropsten as nodes behaviour is different. That's why we use a mainnet check here
-    func test_GivenUnimplementedMethod_WhenCallingContract_ThenFailsWith0x_Async() async {
+    func test_GivenUnimplementedMethod_WhenCallingContract_ThenFailsWithExecutionError_Async() async {
         do {
             let function = InvalidMethodA(param: .zero)
-            let _ = try await function.call(withClient: self.mainnetClient!,
-                                            responseType: InvalidMethodA.BoolResponse.self)
+            let _ = try await function.call(
+                withClient: self.client!,
+                responseType: InvalidMethodA.BoolResponse.self)
             XCTFail("Expected to throw while awaiting, but succeeded")
         } catch {
-            XCTAssertEqual(error as? EthereumClientError, .decodeIssue)
-        }
-    }
-
-    func test_GivenFailingCallMethod_WhenCallingContract_ThenFailsWith0x_Async() async {
-        do {
-            let function = InvalidMethodB(param: .zero)
-            let _ = try await function.call(withClient: self.mainnetClient!,
-                                            responseType: InvalidMethodB.BoolResponse.self)
-            XCTFail("Expected to throw while awaiting, but succeeded")
-        } catch {
-            XCTAssertEqual(error as? EthereumClientError, .decodeIssue)
+            XCTAssertEqual(
+                error as? EthereumClientError,
+                .executionError(
+                    .init(code: -32000, message: "execution reverted")
+                )
+            )
         }
     }
 

web3sTests/ERC20/ERC20Tests.swift

@@ -45,16 +45,6 @@ class ERC20Tests: XCTestCase {
         waitForExpectations(timeout: 10)
     }
 
-    func testZeroDecimals() {
-        let expect = expectation(description: "Get token decimals (0)")
-        erc20?.decimals(tokenContract: EthereumAddress("0x40dd3ac2481960cf34d96e647dd0bc52a1f03f52"), completion: { (error, decimals) in
-            XCTAssertNil(error)
-            XCTAssertEqual(decimals, 0)
-            expect.fulfill()
-        })
-        waitForExpectations(timeout: 10)
-    }
-
     func testSymbol() {
         let expect = expectation(description: "Get token symbol")
         erc20?.symbol(tokenContract: self.testContractAddress, completion: { (error, symbol) in
@@ -151,7 +141,7 @@ extension ERC20Tests {
         }
     }
 
-    func testZeroDecimals_Async() async {
+    func testNoDecimals_Async() async {
         do {
             let decimals = try await erc20?.decimals(tokenContract: EthereumAddress("0x40dd3ac2481960cf34d96e647dd0bc52a1f03f52"))
             XCTAssertEqual(decimals, 0)

web3sTests/TestConfig.swift

@@ -12,9 +12,6 @@ struct TestConfig {
     // This is the proxy URL for connecting to the Blockchain. For testing we usually use the Ropsten network on Infura. Using free tier, so might hit rate limits
     static let clientUrl = "https://ropsten.infura.io/v3/b2f4b3f635d8425c96854c3d28ba6bb0"
 
-    // Same for mainnet
-    static let mainnetClientUrl = "https://mainnet.infura.io/v3/b2f4b3f635d8425c96854c3d28ba6bb0"
-    
     // An EOA with some Ether, so that we can test sending transactions (pay for gas)
     static let privateKey = "0xef4e182ae2cf32192d2a62c1159c8c4f7f2d658c303d0dfca5791a205456a132"
 

web3swift/src/Client/EthereumClient.swift

@@ -80,7 +80,7 @@ public protocol EthereumClientProtocol {
 
 public enum EthereumClientError: Error, Equatable {
     case tooManyResults
-    case executionError(description: String)
+    case executionError(JSONRPCErrorDetail)
     case unexpectedReturnValue
     case noResultFound
     case decodeIssue
@@ -266,10 +266,10 @@ public class EthereumClient: EthereumClientProtocol {
         EthereumRPC.execute(session: session, url: url, method: "eth_estimateGas", params: params, receive: String.self) { (error, response) in
             if let gasHex = response as? String, let gas = BigUInt(hex: gasHex) {
                 completion(nil, gas)
-            } else if case let .executionError(errorResult) = error as? JSONRPCError {
-                completion(EthereumClientError.executionError(description: "\(errorResult.error)"), nil)
+            } else if case let .executionError(result) = error as? JSONRPCError {
+                completion(.executionError(result.error), nil)
             } else {
-                completion(EthereumClientError.unexpectedReturnValue, nil)
+                completion(.unexpectedReturnValue, nil)
             }
         }
     }
@@ -380,13 +380,10 @@ public class EthereumClient: EthereumClientProtocol {
         EthereumRPC.execute(session: session, url: url, method: "eth_call", params: params, receive: String.self) { (error, response) in
             if let resDataString = response as? String {
                 completion(nil, resDataString)
-            } else if
-                let error = error,
-                case let JSONRPCError.executionError(result) = error,
-                (result.error.code == JSONRPCErrorCode.invalidInput || result.error.code == JSONRPCErrorCode.contractExecution) {
-                completion(nil, "0x")
+            } else if case let .executionError(result) = error as? JSONRPCError {
+                completion(.executionError(result.error), nil)
             } else {
-                completion(EthereumClientError.unexpectedReturnValue, nil)
+                completion(.unexpectedReturnValue, nil)
             }
         }
     }

web3swift/src/Client/JSONRPC.swift

@@ -20,20 +20,32 @@ struct JSONRPCRequest<T: Encodable>: Encodable {
 }
 
 public struct JSONRPCResult<T: Decodable>: Decodable {
-    var id: Int
-    var jsonrpc: String
-    var result: T
+    public var id: Int
+    public var jsonrpc: String
+    public var result: T
 }
 
-public struct JSONRPCErrorDetail: Decodable {
-    var code: Int
-    var message: String
+public struct JSONRPCErrorDetail: Decodable, Equatable, CustomStringConvertible {
+    public var code: Int
+    public var message: String
+
+    public init(
+        code: Int,
+        message: String
+    ) {
+        self.code = code
+        self.message = message
+    }
+
+    public var description: String {
+        "Code: \(code)\nMessage: \(message)"
+    }
 }
 
 public struct JSONRPCErrorResult: Decodable {
-    var id: Int
-    var jsonrpc: String
-    var error: JSONRPCErrorDetail
+    public var id: Int
+    public var jsonrpc: String
+    public var error: JSONRPCErrorDetail
 }
 
 public enum JSONRPCErrorCode {
@@ -50,7 +62,7 @@ public enum JSONRPCError: Error {
     case unknownError
     case noResult
 
-    var isExecutionError: Bool {
+    public var isExecutionError: Bool {
         switch self {
         case .executionError:
             return true

web3swift/src/Contract/Statically Typed/EthereumClient+Static.swift

@@ -26,22 +26,41 @@ public extension ABIFunction {
 
     }
 
-    func call<T: ABIResponse>(withClient client: EthereumClientProtocol, responseType: T.Type, block: EthereumBlock = .Latest, completion: @escaping((EthereumClientError?, T?) -> Void)) {
+    func call<T: ABIResponse>(
+        withClient client: EthereumClientProtocol,
+        responseType: T.Type,
+        block: EthereumBlock = .Latest,
+        failOnExecutionError: Bool = true,
+        completion: @escaping((EthereumClientError?, T?) -> Void)
+    ) {
 
         guard let tx = try? self.transaction() else {
             return completion(EthereumClientError.encodeIssue, nil)
         }
 
         client.eth_call(tx, block: block) { (error, res) in
-            guard let res = res, error == nil else {
-                return completion(EthereumClientError.unexpectedReturnValue, nil)
-            }
+            let parseOrFail: (String) -> Void = { data in
+                guard let response = (try? T(data: data)) else {
+                    return completion(EthereumClientError.decodeIssue, nil)
+                }
 
-            guard let response = (try? T(data: res)) else {
-                return completion(EthereumClientError.decodeIssue, nil)
+                return completion(nil, response)
             }
 
-            return completion(nil, response)
+            switch (error, res) {
+            case (.executionError, _):
+                if failOnExecutionError {
+                    return completion(error, nil)
+                } else {
+                    return parseOrFail("0x")
+                }
+            case (let error?, _):
+                return completion(error, nil)
+            case (nil, let data?):
+                parseOrFail(data)
+            case (nil, nil):
+                return completion(EthereumClientError.unexpectedReturnValue, nil)
+            }
         }
     }
 }
@@ -62,9 +81,19 @@ public extension ABIFunction {
         }
     }
 
-    func call<T: ABIResponse>(withClient client: EthereumClientProtocol, responseType: T.Type, block: EthereumBlock = .Latest) async throws -> T {
+    func call<T: ABIResponse>(
+        withClient client: EthereumClientProtocol,
+        responseType: T.Type,
+        block: EthereumBlock = .Latest,
+        failOnExecutionError: Bool = true
+    ) async throws -> T {
         return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<T, Error>) in
-            call(withClient: client, responseType: responseType) { error, response in
+            call(
+                withClient: client,
+                responseType: responseType,
+                block: block,
+                failOnExecutionError: failOnExecutionError
+            ) { error, response in
                 if let error = error {
                     continuation.resume(throwing: error)
                 } else if let response = response {

web3swift/src/ENS/EthereumNameService.swift

@@ -58,6 +58,10 @@ public class EthereumNameService: EthereumNameServiceProtocol {
         }
 
         client.eth_call(registryTransaction, block: .Latest, completion: { (error, resolverData) in
+            if case .executionError = error {
+                return completion(.ensUnknown, nil)
+            }
+
             guard let resolverData = resolverData else {
                 return completion(EthereumNameServiceError.noResolver, nil)
             }
@@ -107,6 +111,10 @@ public class EthereumNameService: EthereumNameServiceProtocol {
         }
 
         client.eth_call(registryTransaction, block: .Latest, completion: { (error, resolverData) in
+            if case .executionError = error {
+                return completion(.ensUnknown, nil)
+            }
+            
             guard let resolverData = resolverData else {
                 return completion(EthereumNameServiceError.noResolver, nil)
             }

web3swift/src/ERC20/ERC20.swift

@@ -66,7 +66,11 @@ public class ERC20: ERC20Protocol {
 
     public func decimals(tokenContract: EthereumAddress, completion: @escaping((Error?, UInt8?) -> Void)) {
         let function = ERC20Functions.decimals(contract: tokenContract)
-        function.call(withClient: self.client, responseType: ERC20Responses.decimalsResponse.self) { (error, decimalsResponse) in
+        function.call(
+            withClient: self.client,
+            responseType: ERC20Responses.decimalsResponse.self,
+            failOnExecutionError: false
+        ) { (error, decimalsResponse) in
             return completion(error, decimalsResponse?.value)
         }
     }

web3swift/src/ERC721/ERC721.swift

@@ -347,7 +347,11 @@ public class ERC721Enumerable: ERC721 {
                                     index: BigUInt,
                                     completion: @escaping((Error?, BigUInt?) -> Void)) {
         let function = ERC721EnumerableFunctions.tokenOfOwnerByIndex(contract: contract, address: owner, index: index)
-        function.call(withClient: client, responseType: ERC721EnumerableResponses.numberResponse.self) { error, response in
+        function.call(
+            withClient: client,
+            responseType: ERC721EnumerableResponses.numberResponse.self,
+            failOnExecutionError: false
+        ) { error, response in
             return completion(error, response?.value)
         }
     }