feat: improve decode error

Sources/Web3Core/Contract/ContractProtocol.swift

@@ -144,7 +144,8 @@ public protocol ContractProtocol {
     ///     - method signature (with or without `0x` prefix, case insensitive): `0xFFffFFff`;
     ///   - data: non empty bytes to decode;
     /// - Returns: dictionary with decoded values. `nil` if decoding failed.
-    func decodeReturnData(_ method: String, data: Data) -> [String: Any]?
+    @discardableResult
+    func decodeReturnData(_ method: String, data: Data) throws -> [String: Any]
 
     /// Decode input arguments of a function.
     /// - Parameters:
@@ -313,13 +314,40 @@ extension DefaultContractProtocol {
         return bloom.test(topic: event.topic)
     }
 
-    public func decodeReturnData(_ method: String, data: Data) -> [String: Any]? {
+    @discardableResult
+    public func decodeReturnData(_ method: String, data: Data) throws -> [String: Any] {
         if method == "fallback" {
-            return [String: Any]()
+            return [:]
+        }
+
+        guard let function = methods[method]?.first else {
+            throw Web3Error.inputError(desc: "Function method does not exist.")
+        }
+
+        switch data.count % 32 {
+        case 0:
+            return try function.decodeReturnData(data)
+        case 4:
+            let selector = data[0..<4]
+            if selector.toHexString() == "08c379a0", let reason = ABI.Element.EthError.decodeStringError(data[4...]) {
+                throw Web3Error.revert("revert(string)` or `require(expression, string)` was executed. reason: \(reason)", reason: reason)
+            }
+            else if selector.toHexString() == "4e487b71", let reason = ABI.Element.EthError.decodePanicError(data[4...]) {
+                let panicCode = String(format: "%02X", Int(reason)).addHexPrefix()
+                throw Web3Error.revert("Error: call revert exception; VM Exception while processing transaction: reverted with panic code \(panicCode)", reason: panicCode)
+            }
+            else if let customError = errors[selector.toHexString().addHexPrefix().lowercased()] {
+                if let errorArgs = customError.decodeEthError(data[4...]) {
+                    throw Web3Error.revertCustom(customError.signature, errorArgs)
+                } else {
+                    throw Web3Error.inputError(desc: "Signature matches \(customError.errorDeclaration) but failed to be decoded.")
+                }
+            } else {
+                throw Web3Error.inputError(desc: "Found no matched error")
+            }
+        default:
+            throw Web3Error.inputError(desc: "Invalid data count")
         }
-        return methods[method]?.compactMap({ function in
-            return function.decodeReturnData(data)
-        }).first
     }
 
     public func decodeInputData(_ method: String, data: Data) -> [String: Any]? {
@@ -339,8 +367,32 @@ extension DefaultContractProtocol {
         return function.decodeInputData(Data(data[data.startIndex + 4 ..< data.startIndex + data.count]))
     }
 
+    public func decodeEthError(_ data: Data) -> [String: Any]? {
+        guard data.count >= 4,
+              let err = errors.first(where: { $0.value.methodEncoding == data[0..<4] })?.value else {
+            return nil
+        }
+        return err.decodeEthError(data[4...])
+    }
+
     public func getFunctionCalled(_ data: Data) -> ABI.Element.Function? {
         guard data.count >= 4 else { return nil }
         return methods[data[data.startIndex ..< data.startIndex + 4].toHexString().addHexPrefix()]?.first
     }
 }
+
+extension DefaultContractProtocol {
+    @discardableResult
+    public func callStatic(_ method: String, parameters: [Any], provider: Web3Provider) async throws -> [String: Any] {
+        guard let address = address else {
+            throw Web3Error.inputError(desc: "address field is missing")
+        }
+        guard let data = self.method(method, parameters: parameters, extraData: nil) else {
+            throw Web3Error.dataError
+        }
+        let transaction = CodableTransaction(to: address, data: data)
+
+        let result: Data = try await APIRequest.sendRequest(with: provider, for: .call(transaction, .latest)).result
+        return try decodeReturnData(method, data: result)
+    }
+}

Sources/Web3Core/EthereumABI/ABIElements.swift

@@ -220,6 +220,40 @@ extension ABI.Element.Event {
     }
 }
 
+// MARK: - Decode custom error
+
+extension ABI.Element.EthError {
+    public func decodeEthError(_ data: Data) -> [String: Any]? {
+        guard inputs.count * 32 <= data.count,
+              let decoded = ABIDecoder.decode(types: inputs, data: data) else {
+            return nil
+        }
+
+        var result = [String: Any]()
+        for (index, out) in inputs.enumerated() {
+            result["\(index)"] = decoded[index]
+            if !out.name.isEmpty {
+                result[out.name] = decoded[index]
+            }
+        }
+        return result
+    }
+
+    /// Decodes `revert(string)` and `require(expression, string)` calls.
+    /// These calls are decomposed as `Error(string` error.
+    public static func decodeStringError(_ data: Data) -> String? {
+        let decoded = ABIDecoder.decode(types: [.init(name: "", type: .string)], data: data)
+        return decoded?.first as? String
+    }
+
+    /// Decodes `Panic(uint256)` errors.
+    /// See more about panic code explain at:  https://docs.soliditylang.org/en/v0.8.21/control-structures.html#panic-via-assert-and-error-via-require
+    public static func decodePanicError(_ data: Data) -> BigUInt? {
+        let decoded = ABIDecoder.decode(types: [.init(name: "", type: .uint(bits: 256))], data: data)
+        return decoded?.first as? BigUInt
+    }
+}
+
 // MARK: - Function input/output decoding
 
 extension ABI.Element {
@@ -232,7 +266,7 @@ extension ABI.Element {
         case .fallback:
             return nil
         case .function(let function):
-            return function.decodeReturnData(data)
+            return try? function.decodeReturnData(data)
         case .receive:
             return nil
         case .error:
@@ -314,25 +348,21 @@ extension ABI.Element.Function {
     ///  - next 32 bytes are the error message length;
     ///  - the next N bytes, where N >= 32, are the message bytes
     ///  - the rest are 0 bytes padding.
-    public func decodeReturnData(_ data: Data, errors: [String: ABI.Element.EthError]? = nil) -> [String: Any] {
-        if let decodedError = decodeErrorResponse(data, errors: errors) {
-            return decodedError
-        }
-
+    public func decodeReturnData(_ data: Data) throws -> [String: Any] {
         guard !outputs.isEmpty else {
             NSLog("Function doesn't have any output types to decode given data.")
-            return ["_success": true]
+            return [:]
         }
 
         guard outputs.count * 32 <= data.count else {
-            return ["_success": false, "_failureReason": "Bytes count must be at least \(outputs.count * 32). Given \(data.count). Decoding will fail."]
+            throw Web3Error.revert("Bytes count must be at least \(outputs.count * 32). Given \(data.count). Decoding will fail.", reason: nil)
         }
 
         // TODO: need improvement - we should be able to tell which value failed to be decoded
         guard let values = ABIDecoder.decode(types: outputs, data: data) else {
-            return ["_success": false, "_failureReason": "Failed to decode at least one value."]
+            throw Web3Error.revert("Failed to decode at least one value.", reason: nil)
         }
-        var returnArray: [String: Any] = ["_success": true]
+        var returnArray: [String: Any] = [:]
         for i in outputs.indices {
             returnArray["\(i)"] = values[i]
             if !outputs[i].name.isEmpty {
@@ -412,6 +442,7 @@ extension ABI.Element.Function {
            let errors = errors,
            let customError = errors[data[data.startIndex ..< data.startIndex + 4].toHexString().stripHexPrefix()] {
             var errorResponse: [String: Any] = ["_success": false, "_abortedByRevertOrRequire": true, "_error": customError.errorDeclaration]
+//            customError.decodeEthError(data[4...])
 
             if (data.count > 32 && !customError.inputs.isEmpty),
                let decodedInputs = ABIDecoder.decode(types: customError.inputs, data: Data(data[data.startIndex + 4 ..< data.startIndex + data.count])) {

Sources/Web3Core/EthereumABI/ABIParameterTypes.swift

@@ -192,6 +192,20 @@ extension ABI.Element.Event {
     }
 }
 
+extension ABI.Element.EthError {
+    public var signature: String {
+        return "\(name)(\(inputs.map { $0.type.abiRepresentation }.joined(separator: ",")))"
+    }
+
+    public var methodString: String {
+        return String(signature.sha3(.keccak256).prefix(8))
+    }
+
+    public var methodEncoding: Data {
+        return signature.data(using: .ascii)!.sha3(.keccak256)[0...3]
+    }
+}
+
 extension ABI.Element.ParameterType: ABIEncoding {
     public var abiRepresentation: String {
         switch self {

Sources/Web3Core/EthereumABI/Sequence+ABIExtension.swift

@@ -56,6 +56,8 @@ public extension Sequence where Element == ABI.Element {
         var errors = [String: ABI.Element.EthError]()
         for case let .error(error) in self {
             errors[error.name] = error
+            errors[error.signature] = error
+            errors[error.methodString.addHexPrefix().lowercased()] = error
         }
         return errors
     }

Sources/Web3Core/EthereumNetwork/Request/APIRequest+ComputedProperties.swift

@@ -8,15 +8,12 @@
 import Foundation
 
 extension APIRequest {
-    var method: REST {
+    public var method: REST {
          .POST
     }
 
-   public var encodedBody: Data {
-        let request = RequestBody(method: call, params: parameters)
-        // this is safe to force try this here
-        // Because request must failed to compile if it not conformable with `Encodable` protocol
-        return try! JSONEncoder().encode(request)
+    public var encodedBody: Data {
+       RequestBody(method: call, params: parameters).encodedBody
     }
 
     var parameters: [RequestParameter] {