feat(EIP712): impl of encodeData, structHash and signHash functions for EIP712TypedData

Author: JeneaVranceanu

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

@@ -84,64 +84,6 @@ public func eip712hash(domainSeparator: EIP712Hashable, message: EIP712Hashable)
     try eip712hash(domainSeparatorHash: domainSeparator.hash(), messageHash: message.hash())
 }
 
-public func eip712hash(_ eip712TypedData: EIP712TypedData) throws -> Data {
-    guard let chainId = eip712TypedData.domain["chainId"] as? Int64,
-          let verifyingContract = eip712TypedData.domain["verifyingContract"] as? String,
-          let verifyingContractAddress = EIP712.Address(verifyingContract)
-    else {
-        throw Web3Error.inputError(desc: "Failed to parse chainId or verifyingContract address. Domain object is \(eip712TypedData.domain).")
-    }
-
-    let domainHash = try EIP712Domain(chainId: EIP712.UInt256(chainId), verifyingContract: verifyingContractAddress).hash()
-    guard let primaryTypeData = eip712TypedData.types[eip712TypedData.primaryType] else {
-        throw Web3Error.inputError(desc: "EIP712 hashing error. Given primary type name is not present amongst types. primaryType - \(eip712TypedData.primaryType); available types - \(eip712TypedData.types.values)")
-    }
-
-    let messageHash = try hashEip712Message(eip712TypedData,
-                                            eip712TypedData.message,
-                                            messageTypeData: primaryTypeData)
-    return eip712hash(domainSeparatorHash: domainHash, messageHash: messageHash)
-}
-
-func hashEip712Message(_ typedData: EIP712TypedData, _ message: [String: AnyObject], messageTypeData: [EIP712TypeProperty]) throws -> Data {
-    var messageData: [Data] = []
-    for field in messageTypeData {
-        guard let fieldValue = message[field.name] else {
-            throw Web3Error.inputError(desc: "EIP712 message doesn't have field with name \(field.name).")
-        }
-
-        if let customType = typedData.types[field.type] {
-            guard let objectAttribute = fieldValue as? [String: AnyObject] else {
-                throw Web3Error.processingError(desc: "Failed to hash EIP712 message. A property from 'message' field with custom type cannot be represented as object and thus encoded & hashed. Property name \(field.name); value \(String(describing: message[field.name])).")
-            }
-            try messageData.append(hashEip712Message(typedData, objectAttribute, messageTypeData: customType))
-        } else {
-            let type = try ABITypeParser.parseTypeString(field.type)
-            var data: Data?
-            switch type {
-            case .dynamicBytes, .bytes:
-                if let bytes = fieldValue as? Data {
-                    data = bytes.sha3(.keccak256)
-                }
-            case .string:
-                if let string = fieldValue as? String {
-                    data = Data(string.bytes).sha3(.keccak256)
-                }
-            default:
-                data = ABIEncoder.encodeSingleType(type: type, value: fieldValue)
-            }
-
-            if let data = data {
-                messageData.append(data)
-            } else {
-                throw Web3Error.processingError(desc: "Failed to encode property of EIP712 message. Property name \(field.name); value \(String(describing: message[field.name]))")
-            }
-        }
-    }
-
-    return Data(messageData.flatMap { $0.bytes }).sha3(.keccak256)
-}
-
 public func eip712hash(domainSeparatorHash: Data, messageHash: Data) -> Data {
     (Data([UInt8(0x19), UInt8(0x01)]) + domainSeparatorHash + messageHash).sha3(.keccak256)
 }

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

@@ -233,4 +233,66 @@ public struct EIP712TypedData {
         }
         return type + "(" + parameters.joined(separator: ",") + ")" + encodedSubtypes.joined(separator: "")
     }
+
+    /// Convenience function for ``encodeData(_:data:)`` that uses ``primaryType`` and ``message`` as values.
+    /// - Returns: encoded data based on ``primaryType`` and ``message``.
+    public func encodeData() throws -> Data {
+        try encodeData(primaryType, data: message)
+    }
+
+    public func encodeData(_ type: String, data: [String : AnyObject]) throws -> Data {
+        // Adding typehash
+        var encTypes: [ABI.Element.ParameterType] = [.bytes(length: 32)]
+        var encValues: [Any] = [try typeHash(type)]
+
+        guard let typeData = types[type] else {
+            throw Web3Error.processingError(desc: "EIP712. Attempting to encode data for type that doesn't exist in this payload. Given type: \(type). Available types: \(types.values).")
+        }
+
+        // Add field contents
+        for field in typeData {
+            let value = data[field.name]
+            if field.type == "string" {
+                guard let value = value as? String else {
+                    throw Web3Error.processingError(desc: "EIP712. Type metadata '\(field)' and actual value '\(String(describing: value))' type doesn't match. Cannot cast value to String.")
+                }
+                encTypes.append(.bytes(length: 32))
+                encValues.append(value.sha3(.keccak256).addHexPrefix())
+            } else if field.type == "bytes"{
+                guard let value = value as? Data else {
+                    throw Web3Error.processingError(desc: "EIP712. Type metadata '\(field)' and actual value '\(String(describing: value))' type doesn't match. Cannot cast value to Data.")
+                }
+                encTypes.append(.bytes(length: 32))
+                encValues.append(value.sha3(.keccak256))
+            } else if types[field.type] != nil {
+                guard let value = value as? [String : AnyObject] else {
+                    throw Web3Error.processingError(desc: "EIP712. Custom type metadata '\(field)' and actual value '\(String(describing: value))' type doesn't match. Cannot cast value to [String : AnyObject].")
+                }
+                encTypes.append(.bytes(length: 32))
+                encValues.append(try encodeData(field.type, data: value).sha3(.keccak256))
+            } else {
+                encTypes.append(try ABITypeParser.parseTypeString(field.type))
+                encValues.append(value as Any)
+            }
+        }
+
+        guard let encodedData = ABIEncoder.encode(types: encTypes, values: encValues) else {
+            throw Web3Error.processingError(desc: "EIP712. ABIEncoder.encode failed with the following types and values: \(encTypes); \(encValues)")
+        }
+        return encodedData
+    }
+
+    /// Convenience function for ``structHash(_:data:)`` that uses ``primaryType`` and ``message`` as values.
+    /// - Returns: SH# keccak256 hash of encoded data based on ``primaryType`` and ``message``.
+    public func structHash() throws -> Data {
+        try structHash(primaryType, data: message)
+    }
+
+    public func structHash(_ type: String, data: [String : AnyObject]) throws -> Data {
+        try encodeData(type, data: data).sha3(.keccak256)
+    }
+
+    public func signHash() throws -> Data {
+        try (Data.fromHex("0x1901")! + structHash("EIP712Domain", data: domain) + structHash()).sha3(.keccak256)
+    }
 }

Sources/web3swift/Web3/Web3+Signing.swift

@@ -44,11 +44,12 @@ public struct Web3Signer {
                                   keystore: BIP32Keystore,
                                   account: EthereumAddress,
                                   password: String? = nil) throws -> Data {
-        let hash = try eip712hash(eip712TypedDataPayload)
+        let hash = try eip712TypedDataPayload.signHash()
         guard let signature = try Web3Signer.signPersonalMessage(hash,
                                                                  keystore: keystore,
                                                                  account: account,
-                                                                 password: password ?? "")
+                                                                 password: password ?? "",
+                                                                 useHash: false)
         else {
             throw Web3Error.dataError
         }
@@ -67,7 +68,8 @@ public struct Web3Signer {
         guard let signature = try Web3Signer.signPersonalMessage(hash,
                                                                  keystore: keystore,
                                                                  account: account,
-                                                                 password: password ?? "")
+                                                                 password: password ?? "",
+                                                                 useHash: false)
         else {
             throw Web3Error.dataError
         }

Tests/web3swiftTests/localTests/EIP712TypedDataPayloadTests.swift

@@ -7,8 +7,9 @@
 import Foundation
 import XCTest
 import web3swift
-import Web3Core
+@testable import Web3Core
 
+// TODO: take more tests from https://github.com/Mrtenz/eip-712/blob/master/src/eip-712.test.ts
 
 /// Tests based primarily on the following example https://eips.ethereum.org/assets/eip-712/Example.js
 class EIP712TypedDataPayloadTests: XCTestCase {
@@ -221,4 +222,55 @@ class EIP712TypedDataPayloadTests: XCTestCase {
         try XCTAssertEqual(parsedEip712TypedData.typeHash("Person"), "0xb9d8c78acf9b987311de6c7b45bb6a9c8e1bf361fa7fd3467a2163f994c79500")
         try XCTAssertEqual(parsedEip712TypedData.typeHash("Mail"), "0xa0cedeb2dc280ba39b857546d74f5549c3a1d7bdc2dd96bf881f76108e23dac2")
     }
+
+    func testEIP712EncodeData() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        let encodedMessage = "a0cedeb2dc280ba39b857546d74f5549c3a1d7bdc2dd96bf881f76108e23dac2fc71e5fa27ff56c350aa531bc129ebdf613b772b6604664f5d8dbe21b85eb0c8cd54f074a4af31b4411ff6a60c9719dbd559c221c8ac3492d9d872b041d703d1b5aadf3154a261abdd9086fc627b61efca26ae5702701d05cd2305f7c52a2fc8"
+        XCTAssertEqual(try parsedEip712TypedData.encodeData().toHexString(), encodedMessage)
+        XCTAssertEqual(try parsedEip712TypedData.encodeData(parsedEip712TypedData.primaryType, data: parsedEip712TypedData.message).toHexString(), encodedMessage)
+
+        XCTAssertEqual(try parsedEip712TypedData.encodeData("EIP712Domain", data: parsedEip712TypedData.domain).toHexString(),
+                       "8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400fc70ef06638535b4881fafcac8287e210e3769ff1a8e91f1b95d6246e61e4d3c6c89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc60000000000000000000000000000000000000000000000000000000000000001000000000000000000000000cccccccccccccccccccccccccccccccccccccccc")
+
+        XCTAssertEqual(try parsedEip712TypedData.encodeData("Person", data: parsedEip712TypedData.message["from"] as! [String : AnyObject]).toHexString(),
+                       "b9d8c78acf9b987311de6c7b45bb6a9c8e1bf361fa7fd3467a2163f994c795008c1d2bd5348394761719da11ec67eedae9502d137e8940fee8ecd6f641ee1648000000000000000000000000cd2a3d9f938e13cd947ec05abc7fe734df8dd826")
+
+        XCTAssertEqual(try parsedEip712TypedData.encodeData("Person",
+                                                            data: ["wallet" : "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
+                                                                   "name" : "Cow"] as [String : AnyObject]).toHexString(),
+                       "b9d8c78acf9b987311de6c7b45bb6a9c8e1bf361fa7fd3467a2163f994c795008c1d2bd5348394761719da11ec67eedae9502d137e8940fee8ecd6f641ee1648000000000000000000000000cd2a3d9f938e13cd947ec05abc7fe734df8dd826")
+    }
+
+    func testEIP712StructHash() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        XCTAssertEqual(try parsedEip712TypedData.structHash().toHexString(), "c52c0ee5d84264471806290a3f2c4cecfc5490626bf912d01f240d7a274b371e")
+        XCTAssertEqual(try parsedEip712TypedData.structHash("EIP712Domain", data: parsedEip712TypedData.domain).toHexString(),
+                       "f2cee375fa42b42143804025fc449deafd50cc031ca257e0b194a650a912090f")
+    }
+
+    func testEIP712SignHash() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        XCTAssertEqual(try parsedEip712TypedData.signHash().toHexString(), "be609aee343fb3c4b28e1df9e632fca64fcfaede20f02e86244efddf30957bd2")
+    }
+
+    func testEIP712Signing() throws {
+        let parsedEip712TypedData = try EIP712Parser.parse(testTypedDataPayload)
+        let privateKey = Data.fromHex("cow".sha3(.keccak256).addHexPrefix())!
+        let publicKey = Utilities.privateToPublic(privateKey)!
+        let address = Utilities.publicToAddress(publicKey)!
+        XCTAssertEqual(address, EthereumAddress("0xcd2a3d9f938e13cd947ec05abc7fe734df8dd826"));
+
+        /// This signing doesn't use `"\u{19}Ethereum Signed Message:\n"`. As per EIP712 standard
+        /// the following format is used instead:
+        /// ```
+        ///     encode(domainSeparator : 𝔹²⁵⁶, message : 𝕊) = "\x19\x01" ‖ domainSeparator ‖ hashStruct(message)
+        /// ```
+        ///
+        /// The output of ``EIP712TypedData.signHash`` is exactly that.
+        let (compressedSignature, _) = try SECP256K1.signForRecovery(hash: parsedEip712TypedData.signHash(), privateKey: privateKey)
+        let unmarshalledSignature = Utilities.unmarshalSignature(signatureData: compressedSignature!)!
+        XCTAssertEqual(unmarshalledSignature.v, 28)
+        XCTAssertEqual(unmarshalledSignature.r.toHexString(), "4355c47d63924e8a72e509b65029052eb6c299d53a04e167c5775fd466751c9d")
+        XCTAssertEqual(unmarshalledSignature.s.toHexString(), "07299936d304c153f6443dfa05f40ff007d72911b6f72307f996231605b91562")
+    }
 }