feat(EIP712): type encoding, type hashing, circular dependency checks, tests;

Author: JeneaVranceanu

Sources/web3swift/Utils/EIP/EIP712/EIP712Parser.swift

@@ -98,7 +98,7 @@ public class EIP712Parser {
             throw Web3Error.inputError(desc: "EIP712Parser: cannot decode EIP712TypedData object. Failed to parse one of primaryType, domain or message fields. Is any field missing?")
         }
 
-        return EIP712TypedData(types: types, primaryType: primaryType, domain: domain, message: message)
+        return try EIP712TypedData(types: types, primaryType: primaryType, domain: domain, message: message)
     }
 }
 
@@ -130,11 +130,107 @@ public struct EIP712TypedData {
     public init(types: [String : [EIP712TypeProperty]],
                 primaryType: String,
                 domain: [String : AnyObject],
-                message: [String : AnyObject]) {
+                message: [String : AnyObject]) throws {
         self.types = types
         self.primaryType = primaryType
         self.domain = domain
         self.message = message
+        if let problematicType = hasCircularDependency() {
+            throw Web3Error.inputError(desc: "Created EIP712TypedData has a circular dependency amongst it's types. Cycle was first identified in '\(problematicType)'. Review it's uses in 'types'.")
+        }
     }
 
+    /// Checks for a circular dependency among the given types.
+    ///
+    /// If a circular dependency is detected, it returns the name of the type where the cycle was first identified.
+    /// Otherwise, it returns `nil`.
+    ///
+    /// - Returns: The type name where a circular dependency is detected, or `nil` if no circular dependency exists.
+    /// - Note: The function utilizes depth-first search to identify the circular dependencies.
+    func hasCircularDependency() -> String? {
+
+        /// Generates an adjacency list for the given types, representing their dependencies.
+        ///
+        /// - Parameter types: A dictionary mapping type names to their property definitions.
+        /// - Returns: An adjacency list representing type dependencies.
+        func createAdjacencyList(types: [String: [EIP712TypeProperty]]) -> [String: [String]] {
+            var adjList: [String: [String]] = [:]
+
+            for (typeName, fields) in types {
+                adjList[typeName] = []
+                for field in fields {
+                    if types.keys.contains(field.type) {
+                        adjList[typeName]?.append(field.type)
+                    }
+                }
+            }
+
+            return adjList
+        }
+
+        let adjList = createAdjacencyList(types: types)
+
+        /// Depth-first search to check for circular dependencies.
+        ///
+        /// - Parameters:
+        ///   - node: The current type being checked.
+        ///   - visited: A dictionary keeping track of the visited types.
+        ///   - stack: A dictionary used for checking the current path for cycles.
+        ///
+        /// - Returns: `true` if a cycle is detected from the current node, `false` otherwise.
+        func depthFirstSearch(node: String, visited: inout [String: Bool], stack: inout [String: Bool]) -> Bool {
+            visited[node] = true
+            stack[node] = true
+
+            for neighbor in adjList[node] ?? [] {
+                if visited[neighbor] == nil {
+                    if depthFirstSearch(node: neighbor, visited: &visited, stack: &stack) {
+                        return true
+                    }
+                } else if stack[neighbor] == true {
+                    return true
+                }
+            }
+
+            stack[node] = false
+            return false
+        }
+
+        var visited: [String: Bool] = [:]
+        var stack: [String: Bool] = [:]
+
+        for typeName in adjList.keys {
+            if visited[typeName] == nil {
+                if depthFirstSearch(node: typeName, visited: &visited, stack: &stack) {
+                    return typeName
+                }
+            }
+        }
+
+        return nil
+    }
+
+    public func encodeType(_ type: String) throws -> String {
+        guard let typeData = types[type] else {
+            throw Web3Error.processingError(desc: "EIP712. Attempting to encode type that doesn't exist in this payload. Given type: \(type). Available types: \(types.values).")
+        }
+        return try encodeType(type, typeData)
+    }
+
+    public func typeHash(_ type: String) throws -> String {
+        try encodeType(type).sha3(.keccak256).addHexPrefix()
+    }
+
+    internal func encodeType(_ type: String, _ typeData: [EIP712TypeProperty], typesCovered: [String] = []) throws -> String {
+        var typesCovered = typesCovered
+        var encodedSubtypes: [String] = []
+        let parameters = try typeData.map { attributeType in
+            if let innerTypes = types[attributeType.type], !typesCovered.contains(attributeType.type) {
+                encodedSubtypes.append(try encodeType(attributeType.type, innerTypes))
+                typesCovered.append(attributeType.type)
+            }
+            return "\(attributeType.type) \(attributeType.name)"
+        }
+        return type + "(" + parameters.joined(separator: ",") + ")" + encodedSubtypes.joined(separator: "")
+    }
 }

Tests/web3swiftTests/localTests/EIP712TypedDataPayloadTests.swift

@@ -120,4 +120,103 @@ class EIP712TypedDataPayloadTests: XCTestCase {
                         "wallet" : "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"])
         XCTAssertEqual(parsedEip712TypedData.message["contents"] as? String, "Hello, Bob!")
     }
+
+    func testEIP712CircularDependency() throws {
+        let problematicTypeExample = """
+        {
+        "types":{
+          "EIP712Domain":[
+             {
+                "name":"name",
+                "type":"string"
+             },
+             {
+                "name":"version",
+                "type":"string"
+             },
+             {
+                "name":"chainId",
+                "type":"uint256"
+             },
+             {
+                "name":"verifyingContract",
+                "type":"address"
+             }
+          ],
+          "Person":[
+             {
+                "name":"name",
+                "type":"string"
+             },
+             {
+                "name":"wallet",
+                "type":"address"
+             },
+             {
+                "name":"mail",
+                "type":"Mail"
+             }
+          ],
+          "Mail":[
+             {
+                "name":"from",
+                "type":"Person"
+             },
+             {
+                "name":"to",
+                "type":"Person"
+             },
+             {
+                "name":"contents",
+                "type":"string"
+             }
+          ]
+        },
+        "primaryType":"Mail",
+        "domain":{
+          "name":"Ether Mail",
+          "version":"1",
+          "chainId":1,
+          "verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
+        },
+        "message":{
+          "from":{
+             "name":"Cow",
+             "wallet":"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
+          },
+          "to":{
+             "name":"Bob",
+             "wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
+          },
+          "contents":"Hello, Bob!"
+        }
+        }
+        """
+        XCTAssertThrowsError(try EIP712Parser.parse(problematicTypeExample)) { error in
+            guard let error = error as? Web3Error else {
+                XCTFail("Thrown error is not Web3Error.")
+                return
+            }
+
+            if case let .inputError(desc) = error {
+                XCTAssertTrue(desc.hasPrefix("Created EIP712TypedData has a circular dependency amongst it's types."))
+            } else {
+                XCTFail("A different Web3Error is thrown. Something changed?")
+            }
+        }
+    }
+
+    func testEIP712EncodeType() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        try XCTAssertEqual(parsedEip712TypedData.encodeType("EIP712Domain"), "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+        try XCTAssertEqual(parsedEip712TypedData.encodeType("Person"), "Person(string name,address wallet)")
+        try XCTAssertEqual(parsedEip712TypedData.encodeType("Mail"), "Mail(Person from,Person to,string contents)Person(string name,address wallet)")
+    }
+
+    func testEIP712TypeHash() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        try XCTAssertEqual(parsedEip712TypedData.typeHash("EIP712Domain"), "0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f")
+        try XCTAssertEqual(parsedEip712TypedData.typeHash("Person"), "0xb9d8c78acf9b987311de6c7b45bb6a9c8e1bf361fa7fd3467a2163f994c79500")
+        try XCTAssertEqual(parsedEip712TypedData.typeHash("Mail"), "0xa0cedeb2dc280ba39b857546d74f5549c3a1d7bdc2dd96bf881f76108e23dac2")
+    }
 }