fix: EthError uses InOut as type for inputs; produces error declaration using errorDeclaration computed variable; tests added

Author: JeneaVranceanu

Sources/Core/EthereumABI/ABIElements.swift

@@ -156,16 +156,16 @@ public extension ABI {
         /// Custom structured error type available since solidity 0.8.4
         public struct EthError {
             public let name: String
-            public let inputs: [Input]
+            public let inputs: [InOut]
 
-            public struct Input {
-                public let name: String
-                public let type: ParameterType
+            /// e.g. `CustomError(uint32, address sender)`
+            public var errorDeclaration: String {
+                "\(name)(\(inputs.map { "\($0.type.abiRepresentation) \($0.name)".trim() }.joined(separator: ",")))"
+            }
 
-                public init(name: String, type: ParameterType) {
-                    self.name = name
-                    self.type = type
-                }
+            public init(name: String, inputs: [InOut]) {
+                self.name = name.trim()
+                self.inputs = inputs
             }
         }
     }

Sources/Core/EthereumABI/ABIParsing.swift

@@ -129,11 +129,9 @@ private func parseReceive(abiRecord: ABI.Record) throws -> ABI.Element.Receive {
 }
 
 private func parseError(abiRecord: ABI.Record) throws -> ABI.Element.EthError {
-    let inputs = try abiRecord.inputs?.map({ (input: ABI.Input) throws -> ABI.Element.EthError.Input in
-        let nativeInput = try input.parseForError()
-        return nativeInput
-    })
-    let abiInputs = inputs ?? []
+    let abiInputs = try abiRecord.inputs?.map({ input throws -> ABI.Element.InOut in
+        try input.parse()
+    }) ?? []
     let name = abiRecord.name ?? ""
     return ABI.Element.EthError(name: name, inputs: abiInputs)
 }
@@ -172,12 +170,6 @@ extension ABI.Input {
         let indexed = self.indexed == true
         return ABI.Element.Event.Input(name: name, type: parameterType, indexed: indexed)
     }
-
-    func parseForError() throws -> ABI.Element.EthError.Input {
-        let name = self.name ?? ""
-        let parameterType = try ABITypeParser.parseTypeString(self.type)
-        return ABI.Element.EthError.Input(name: name, type: parameterType)
-    }
 }
 
 extension ABI.Output {

Tests/web3swiftTests/localTests/ABIElementsTests.swift

@@ -0,0 +1,54 @@
+//
+//  ABIElementsTest.swift
+//
+//  Created by JeneaVranceanu on 28.11.2022.
+//
+
+import Foundation
+import XCTest
+import Core
+
+class ABIElementsTest: XCTestCase {
+    typealias EthError = ABI.Element.EthError
+
+    /// Function with any parameters should be able to decode `require` and `revert` calls in soliditiy.
+    /// Note: `require(expression)` and `revert()` without a message return 0 bytes thus we cannot guarantee
+    /// that 0 bytes response will be interpreted correctly.
+    private let emptyFunction = ABI.Element.Function(name: "any",
+                                                     inputs: [],
+                                                     outputs: [],
+                                                     constant: false,
+                                                     payable: false)
+
+    func testErrorRepresentation() {
+        XCTAssertEqual(EthError(name: "Error", inputs: []).errorDeclaration, "Error()")
+        XCTAssertEqual(EthError(name: "Error", inputs: [.init(name: "", type: .address)]).errorDeclaration, "Error(address)")
+        XCTAssertEqual(EthError(name: "Error", inputs: [.init(name: "           ", type: .address)]).errorDeclaration, "Error(address)")
+        XCTAssertEqual(EthError(name: "Error", inputs: [.init(name: "           ", type: .address), .init(name: "", type: .uint(bits: 256))]).errorDeclaration, "Error(address,uint256)")
+        XCTAssertEqual(EthError(name: "Error", inputs: [.init(name: "sender", type: .address), .init(name: "    ", type: .uint(bits: 256))]).errorDeclaration, "Error(address sender,uint256)")
+        let allTypesNamedAndNot: [ABI.Element.InOut] = [
+            .init(name: "sender", type: .address),
+            .init(name: "", type: .address),
+            .init(name: "", type: .uint(bits: 8)),
+            .init(name: "", type: .uint(bits: 16)),
+            .init(name: "", type: .uint(bits: 32)),
+            .init(name: "", type: .uint(bits: 64)),
+            .init(name: "", type: .uint(bits: 128)),
+            .init(name: "", type: .uint(bits: 256)),
+            .init(name: "my_int_8", type: .int(bits: 8)),
+            .init(name: "my_int_16", type: .int(bits: 16)),
+            .init(name: "my_int_32", type: .int(bits: 32)),
+            .init(name: "my_int_64", type: .int(bits: 64)),
+            .init(name: "my_int_128", type: .int(bits: 128)),
+            .init(name: "my_int_256", type: .int(bits: 256)),
+            .init(name: "someFlag", type: .bool),
+            .init(name: "rand_bytes", type: .bytes(length: 123)),
+            .init(name: "", type: .dynamicBytes),
+            .init(name: "error_message_maybe", type: .string),
+        ]
+        XCTAssertEqual(EthError(name: "VeryCustomErrorName",
+                                inputs: allTypesNamedAndNot).errorDeclaration,
+                       "VeryCustomErrorName(address sender,address,uint8,uint16,uint32,uint64,uint128,uint256,int8 my_int_8,int16 my_int_16,int32 my_int_32,int64 my_int_64,int128 my_int_128,int256 my_int_256,bool someFlag,bytes123 rand_bytes,bytes,string error_message_maybe)")
+    }
+
+}