chore: minor reordering of the structures in EIP712.swift file; removed EIP712DomainHashable as it is redundant;

chore: removed multiple `private func keccak256` defined in EIP712.swift file. These were redundant.

chore: `EIP712Domain` is now public as it's a required model for Gnosis Safe transaction. May be reused by other developers;

Author: JeneaVranceanu

Sources/web3swift/Utils/EIP/EIP712.swift

@@ -1,44 +1,8 @@
-import BigInt
 import CryptoSwift
 import Foundation
+import BigInt
 import Core
 
-// TODO: Refactor me
-
-struct EIP712Domain: EIP712DomainHashable {
-    let chainId:            EIP712.UInt256?
-    let verifyingContract:  EIP712.Address
-}
-
-protocol EIP712DomainHashable: EIP712Hashable {}
-
-public struct SafeTx: EIP712Hashable {
-    let to:             EIP712.Address
-    let value:          EIP712.UInt256
-    let data:           EIP712.Bytes
-    let operation:      EIP712.UInt8
-    let safeTxGas:      EIP712.UInt256
-    let baseGas:        EIP712.UInt256
-    let gasPrice:       EIP712.UInt256
-    let gasToken:       EIP712.Address
-    let refundReceiver: EIP712.Address
-    let nonce:          EIP712.UInt256
-
-    public init(to: EIP712.Address, value: EIP712.UInt256, data: EIP712.Bytes, operation: EIP712.UInt8, safeTxGas: EIP712.UInt256, baseGas: EIP712.UInt256, gasPrice: EIP712.UInt256, gasToken: EIP712.Address, refundReceiver: EIP712.Address, nonce: EIP712.UInt256) {
-        self.to = to
-        self.value = value
-        self.data = data
-        self.operation = operation
-        self.safeTxGas = safeTxGas
-        self.baseGas = baseGas
-        self.gasPrice = gasPrice
-        self.gasToken = gasToken
-        self.refundReceiver = refundReceiver
-        self.nonce = nonce
-    }
-
-}
-
 /// Protocol defines EIP712 struct encoding
 public protocol EIP712Hashable {
     var typehash: Data { get }
@@ -52,6 +16,15 @@ public class EIP712 {
     public typealias Bytes = Data
 }
 
+public struct EIP712Domain: EIP712Hashable {
+    public let chainId:            EIP712.UInt256?
+    public let verifyingContract:  EIP712.Address
+    public init(chainId: EIP712.UInt256?, verifyingContract: EIP712.Address) {
+        self.chainId = chainId
+        self.verifyingContract = verifyingContract
+    }
+}
+
 public extension EIP712.Address {
     static var zero: Self {
         EthereumAddress(Data(count: 20))!
@@ -114,19 +87,19 @@ public extension EIP712Hashable {
     // MARK: - Default implementation
 
     var typehash: Data {
-        keccak256(encodeType())
+        Data(encodeType().bytes).sha3(.keccak256)
     }
 
     func hash() throws -> Data {
         typealias SolidityValue = (value: Any, type: ABI.Element.ParameterType)
-        var parametrs: [Data] = [self.typehash]
+        var parameters: [Data] = [typehash]
         for case let (_, field) in Mirror(reflecting: self).children {
             let result: Data
             switch field {
             case let string as String:
-                result = keccak256(string)
+                result = Data(string.bytes).sha3(.keccak256)
             case let data as EIP712.Bytes:
-                result = keccak256(data)
+                result = data.sha3(.keccak256)
             case is EIP712.UInt8:
                 result = ABIEncoder.encodeSingleType(type: .uint(bits: 8), value: field as AnyObject)!
             case is EIP712.UInt256:
@@ -143,28 +116,54 @@ public extension EIP712Hashable {
                 }
             }
             guard result.count == 32 else { preconditionFailure("ABI encode error") }
-            parametrs.append(result)
+            parameters.append(result)
         }
-        let encoded = parametrs.flatMap { $0.bytes }
-        return keccak256(encoded)
+        return Data(parameters.flatMap { $0.bytes }).sha3(.keccak256)
     }
 }
 
-// Encode functions
-func eip712encode(domainSeparator: EIP712Hashable, message: EIP712Hashable) throws -> Data {
+public func eip712encode(domainSeparator: EIP712Hashable, message: EIP712Hashable) throws -> Data {
     let data = try Data([UInt8(0x19), UInt8(0x01)]) + domainSeparator.hash() + message.hash()
-    return keccak256(data)
+    return data.sha3(.keccak256)
 }
 
-// MARK: - keccak256
-private func keccak256(_ data: [UInt8]) -> Data {
-    Data(SHA3(variant: .keccak256).calculate(for: data))
-}
+// MARK: - Gnosis Safe Transaction model
 
-private func keccak256(_ string: String) -> Data {
-    keccak256(Array(string.utf8))
-}
+/// Gnosis Safe Transaction.
+/// https://docs.gnosis-safe.io/tutorials/tutorial_tx_service_initiate_sign
+public struct SafeTx: EIP712Hashable {
+    /// Checksummed address
+    let to:             EIP712.Address
+    /// Value in wei
+    let value:          EIP712.UInt256
+    /// 0x prefixed hex string
+    let data:           EIP712.Bytes
+    /// `0` CALL, `1` DELEGATE_CALL
+    let operation:      EIP712.UInt8
+    /// Token address, **must be checksummed**, (held by the Safe) to be used as a refund to the sender, if `null` is Ether
+    let gasToken:       EIP712.Address
+    /// Max gas to use in the transaction
+    let safeTxGas:      EIP712.UInt256
+    /// Gast costs not related to the transaction execution (signature check, refund payment...)
+    let baseGas:        EIP712.UInt256
+    /// Gas price used for the refund calculation
+    let gasPrice:       EIP712.UInt256
+    /// Checksummed address of receiver of gas payment (or `null` if tx.origin)
+    let refundReceiver: EIP712.Address
+    /// Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
+    let nonce:          EIP712.UInt256
+
+    public init(to: EIP712.Address, value: EIP712.UInt256, data: EIP712.Bytes, operation: EIP712.UInt8, safeTxGas: EIP712.UInt256, baseGas: EIP712.UInt256, gasPrice: EIP712.UInt256, gasToken: EIP712.Address, refundReceiver: EIP712.Address, nonce: EIP712.UInt256) {
+        self.to = to
+        self.value = value
+        self.data = data
+        self.operation = operation
+        self.safeTxGas = safeTxGas
+        self.baseGas = baseGas
+        self.gasPrice = gasPrice
+        self.gasToken = gasToken
+        self.refundReceiver = refundReceiver
+        self.nonce = nonce
+    }
 
-private func keccak256(_ data: Data) -> Data {
-    keccak256(data.bytes)
 }