Merge pull request #833 from JeneaVranceanu/feat/eip712-dynamic-parsing

feat(EIP712): parsing of TypedData payload; encoding + hashing;

Sources/Web3Core/EthereumABI/ABIParsing.swift

@@ -7,16 +7,41 @@ import Foundation
 
 extension ABI {
 
- public enum ParsingError: Swift.Error {
+ public enum ParsingError: LocalizedError {
  case invalidJsonFile
- case elementTypeInvalid
+ case elementTypeInvalid(_ desc: String? = nil)
  case elementNameInvalid
  case functionInputInvalid
  case functionOutputInvalid
  case eventInputInvalid
  case parameterTypeInvalid
  case parameterTypeNotFound
  case abiInvalid
+
+ public var errorDescription: String? {
+ var errorMessage: [String?]
+ switch self {
+ case .invalidJsonFile:
+ errorMessage = ["invalidJsonFile"]
+ case .elementTypeInvalid(let desc):
+ errorMessage = ["elementTypeInvalid", desc]
+ case .elementNameInvalid:
+ errorMessage = ["elementNameInvalid"]
+ case .functionInputInvalid:
+ errorMessage = ["functionInputInvalid"]
+ case .functionOutputInvalid:
+ errorMessage = ["functionOutputInvalid"]
+ case .eventInputInvalid:
+ errorMessage = ["eventInputInvalid"]
+ case .parameterTypeInvalid:
+ errorMessage = ["parameterTypeInvalid"]
+ case .parameterTypeNotFound:
+ errorMessage = ["parameterTypeNotFound"]
+ case .abiInvalid:
+ errorMessage = ["abiInvalid"]
+ }
+ return errorMessage.compactMap { $0 }.joined(separator: " ")
+ }
  }
 
  enum TypeParsingExpressions {
@@ -39,7 +64,7 @@ extension ABI.Record {
  public func parse() throws -> ABI.Element {
  let typeString = self.type ?? "function"
  guard let type = ABI.ElementType(rawValue: typeString) else {
- throw ABI.ParsingError.elementTypeInvalid
+ throw ABI.ParsingError.elementTypeInvalid("Invalid ABI type \(typeString).")
  }
  return try parseToElement(from: self, type: type)
  }

Sources/Web3Core/EthereumABI/ABITypeParser.swift

@@ -46,7 +46,7 @@ public struct ABITypeParser {
 
  public static func parseTypeString(_ string: String) throws -> ABI.Element.ParameterType {
  let (type, tail) = recursiveParseType(string)
- guard let t = type, tail == nil else {throw ABI.ParsingError.elementTypeInvalid}
+ guard let t = type, tail == nil else { throw ABI.ParsingError.elementTypeInvalid("Invalid ABI type \(string).") }
  return t
  }
 

Sources/Web3Core/KeystoreManager/AbstractKeystore.swift

@@ -11,11 +11,30 @@ public protocol AbstractKeystore {
  func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data
 }
 
-public enum AbstractKeystoreError: Error {
- case noEntropyError
- case keyDerivationError
- case aesError
- case invalidAccountError
+public enum AbstractKeystoreError: LocalizedError {
+ case noEntropyError(_ additionalDescription: String? = nil)
+ case keyDerivationError(_ additionalDescription: String? = nil)
+ case aesError(_ additionalDescription: String? = nil)
+ case invalidAccountError(_ additionalDescription: String? = nil)
  case invalidPasswordError
- case encryptionError(String)
+ case encryptionError(_ additionalDescription: String? = nil)
+
+ public var errorDescription: String? {
+ var errorMessage: [String?]
+ switch self {
+ case .noEntropyError(let additionalDescription):
+ errorMessage = ["Entropy error (e.g. failed to generate a random array of bytes).", additionalDescription]
+ case .keyDerivationError(let additionalDescription):
+ errorMessage = ["Key derivation error.", additionalDescription]
+ case .aesError(let additionalDescription):
+ errorMessage = ["AES error.", additionalDescription]
+ case .invalidAccountError(let additionalDescription):
+ errorMessage = ["Invalid account error.", additionalDescription]
+ case .invalidPasswordError:
+ errorMessage = ["Invalid password error."]
+ case .encryptionError(let additionalDescription):
+ errorMessage = ["Encryption error.", additionalDescription]
+ }
+ return errorMessage.compactMap { $0 }.joined(separator: " ")
+ }
 }

Sources/Web3Core/KeystoreManager/BIP39.swift

@@ -95,11 +95,13 @@ public class BIP39 {
  }
 
  private static func entropyOf(size: Int) throws -> Data {
+ let isCorrectSize = size >= 128 && size <= 256 && size.isMultiple(of: 32)
+ let randomBytesCount = size / 8
  guard
- size >= 128 && size <= 256 && size.isMultiple(of: 32),
- let entropy = Data.randomBytes(length: size/8)
+ isCorrectSize,
+ let entropy = Data.randomBytes(length: randomBytesCount)
  else {
- throw AbstractKeystoreError.noEntropyError
+ throw AbstractKeystoreError.noEntropyError("BIP39. \(!isCorrectSize ? "Requested entropy of wrong bits size: \(size). Expected: 128 <= size <= 256, size % 32 == 0." : "Failed to generate \(randomBytesCount) of random bytes.")")
  }
  return entropy
  }

Sources/Web3Core/KeystoreManager/EthereumKeystoreV3.swift

@@ -23,13 +23,13 @@ public class EthereumKeystoreV3: AbstractKeystore {
  }
 
  public func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data {
- if self.addresses?.count == 1 && account == self.addresses?.last {
- guard let privateKey = try? self.getKeyData(password) else {
+ if account == addresses?.last {
+ guard let privateKey = try? getKeyData(password) else {
  throw AbstractKeystoreError.invalidPasswordError
  }
  return privateKey
  }
- throw AbstractKeystoreError.invalidAccountError
+ throw AbstractKeystoreError.invalidAccountError("EthereumKeystoreV3. Cannot get private key: keystore doesn't contain information about given address \(account.address).")
  }
 
  // Class
@@ -77,7 +77,7 @@ public class EthereumKeystoreV3: AbstractKeystore {
  defer {
  Data.zero(&newPrivateKey)
  }
- try encryptDataToStorage(password, keyData: newPrivateKey, aesMode: aesMode)
+ try encryptDataToStorage(password, privateKey: newPrivateKey, aesMode: aesMode)
  }
 
  public init?(privateKey: Data, password: String, aesMode: String = "aes-128-cbc") throws {
@@ -87,68 +87,60 @@ public class EthereumKeystoreV3: AbstractKeystore {
  guard SECP256K1.verifyPrivateKey(privateKey: privateKey) else {
  return nil
  }
- try encryptDataToStorage(password, keyData: privateKey, aesMode: aesMode)
+ try encryptDataToStorage(password, privateKey: privateKey, aesMode: aesMode)
  }
 
- fileprivate func encryptDataToStorage(_ password: String, keyData: Data?, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1, aesMode: String = "aes-128-cbc") throws {
- if keyData == nil {
- throw AbstractKeystoreError.encryptionError("Encryption without key data")
+ fileprivate func encryptDataToStorage(_ password: String, privateKey: Data, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1, aesMode: String = "aes-128-cbc") throws {
+ if privateKey.count != 32 {
+ throw AbstractKeystoreError.encryptionError("EthereumKeystoreV3. Attempted encryption with private key of length != 32. Given private key length is \(privateKey.count).")
  }
  let saltLen = 32
  guard let saltData = Data.randomBytes(length: saltLen) else {
- throw AbstractKeystoreError.noEntropyError
+ throw AbstractKeystoreError.noEntropyError("EthereumKeystoreV3. Failed to generate random bytes: `Data.randomBytes(length: \(saltLen))`.")
  }
  guard let derivedKey = scrypt(password: password, salt: saltData, length: dkLen, N: N, R: R, P: P) else {
- throw AbstractKeystoreError.keyDerivationError
+ throw AbstractKeystoreError.keyDerivationError("EthereumKeystoreV3. Scrypt function failed.")
  }
  let last16bytes = Data(derivedKey[(derivedKey.count - 16)...(derivedKey.count - 1)])
  let encryptionKey = Data(derivedKey[0...15])
  guard let IV = Data.randomBytes(length: 16) else {
- throw AbstractKeystoreError.noEntropyError
+ throw AbstractKeystoreError.noEntropyError("EthereumKeystoreV3. Failed to generate random bytes: `Data.randomBytes(length: 16)`.")
  }
- var aesCipher: AES?
- switch aesMode {
+ var aesCipher: AES
+ switch aesMode.lowercased() {
  case "aes-128-cbc":
- aesCipher = try? AES(key: encryptionKey.bytes, blockMode: CBC(iv: IV.bytes), padding: .noPadding)
+ aesCipher = try AES(key: encryptionKey.bytes, blockMode: CBC(iv: IV.bytes), padding: .noPadding)
  case "aes-128-ctr":
- aesCipher = try? AES(key: encryptionKey.bytes, blockMode: CTR(iv: IV.bytes), padding: .noPadding)
+ aesCipher = try AES(key: encryptionKey.bytes, blockMode: CTR(iv: IV.bytes), padding: .noPadding)
  default:
- aesCipher = nil
+ throw AbstractKeystoreError.aesError("EthereumKeystoreV3. AES error: given AES mode can be one of 'aes-128-cbc' or 'aes-128-ctr'. Instead '\(aesMode)' was given.")
  }
- if aesCipher == nil {
- throw AbstractKeystoreError.aesError
- }
- guard let encryptedKey = try aesCipher?.encrypt(keyData!.bytes) else {
- throw AbstractKeystoreError.aesError
- }
- let encryptedKeyData = Data(encryptedKey)
- var dataForMAC = Data()
- dataForMAC.append(last16bytes)
- dataForMAC.append(encryptedKeyData)
+
+ let encryptedKeyData = Data(try aesCipher.encrypt(privateKey.bytes))
+ let dataForMAC = last16bytes + encryptedKeyData
  let mac = dataForMAC.sha3(.keccak256)
  let kdfparams = KdfParamsV3(salt: saltData.toHexString(), dklen: dkLen, n: N, p: P, r: R, c: nil, prf: nil)
  let cipherparams = CipherParamsV3(iv: IV.toHexString())
  let crypto = CryptoParamsV3(ciphertext: encryptedKeyData.toHexString(), cipher: aesMode, cipherparams: cipherparams, kdf: "scrypt", kdfparams: kdfparams, mac: mac.toHexString(), version: nil)
- guard let pubKey = Utilities.privateToPublic(keyData!) else {
- throw AbstractKeystoreError.keyDerivationError
+ guard let publicKey = Utilities.privateToPublic(privateKey) else {
+ throw AbstractKeystoreError.keyDerivationError("EthereumKeystoreV3. Failed to derive public key from given private key. `Utilities.privateToPublic(privateKey)` returned `nil`.")
  }
- guard let addr = Utilities.publicToAddress(pubKey) else {
- throw AbstractKeystoreError.keyDerivationError
+ guard let addr = Utilities.publicToAddress(publicKey) else {
+ throw AbstractKeystoreError.keyDerivationError("EthereumKeystoreV3. Failed to derive address from derived public key. `Utilities.publicToAddress(publicKey)` returned `nil`.")
  }
  self.address = addr
  let keystoreparams = KeystoreParamsV3(address: addr.address.lowercased(), crypto: crypto, id: UUID().uuidString.lowercased(), version: 3)
  self.keystoreParams = keystoreparams
  }
 
  public func regenerate(oldPassword: String, newPassword: String, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1) throws {
- var keyData = try self.getKeyData(oldPassword)
- if keyData == nil {
- throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")
+ guard var privateKey = try getKeyData(oldPassword) else {
+ throw AbstractKeystoreError.encryptionError("EthereumKeystoreV3. Failed to decrypt a keystore")
  }
  defer {
- Data.zero(&keyData!)
+ Data.zero(&privateKey)
  }
- try self.encryptDataToStorage(newPassword, keyData: keyData!, aesMode: self.keystoreParams!.crypto.cipher)
+ try self.encryptDataToStorage(newPassword, privateKey: privateKey, aesMode: self.keystoreParams!.crypto.cipher)
  }
 
  fileprivate func getKeyData(_ password: String) throws -> Data? {

Sources/Web3Core/KeystoreManager/KeystoreManager.swift

@@ -43,7 +43,7 @@ public class KeystoreManager: AbstractKeystore {
 
  public func UNSAFE_getPrivateKeyData(password: String, account: EthereumAddress) throws -> Data {
  guard let keystore = walletForAddress(account) else {
- throw AbstractKeystoreError.invalidAccountError
+ throw AbstractKeystoreError.invalidAccountError("KeystoreManager: no keystore/wallet found for given address. Address `\(account.address)`.")
  }
  return try keystore.UNSAFE_getPrivateKeyData(password: password, account: account)
  }

Sources/Web3Core/Transaction/CodableTransaction.swift

@@ -156,7 +156,7 @@ public struct CodableTransaction {
  let result = self.attemptSignature(privateKey: privateKey, useExtraEntropy: useExtraEntropy)
  if result { return }
  }
- throw AbstractKeystoreError.invalidAccountError
+ throw AbstractKeystoreError.invalidAccountError("Failed to sign transaction with given private key.")
  }
 
  // actual signing algorithm implementation

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

@@ -16,6 +16,12 @@ public class EIP712 {
  public typealias Bytes = Data
 }
 
+// FIXME: this type is wrong - The minimum number of optional fields is 5, and those are
+// string name the user readable name of signing domain, i.e. the name of the DApp or the protocol.
+// string version the current major version of the signing domain. Signatures from different versions are not compatible.
+// uint256 chainId the EIP-155 chain id. The user-agent should refuse signing if it does not match the currently active chain.
+// address verifyingContract the address of the contract that will verify the signature. The user-agent may do contract specific phishing prevention.
+// bytes32 salt an disambiguating salt for the protocol. This can be used as a domain separator of last resort.
 public struct EIP712Domain: EIP712Hashable {
  public let chainId: EIP712.UInt256?
  public let verifyingContract: EIP712.Address
@@ -54,6 +60,8 @@ public extension EIP712Hashable {
  result = ABIEncoder.encodeSingleType(type: .uint(bits: 256), value: field)!
  case is EIP712.Address:
  result = ABIEncoder.encodeSingleType(type: .address, value: field)!
+ case let boolean as Bool:
+ result = ABIEncoder.encodeSingleType(type: .uint(bits: 8), value: boolean ? 1 : 0)!
  case let hashable as EIP712Hashable:
  result = try hashable.hash()
  default:
@@ -64,16 +72,19 @@ public extension EIP712Hashable {
  preconditionFailure("Not solidity type")
  }
  }
- guard result.count == 32 else { preconditionFailure("ABI encode error") }
+ guard result.count % 32 == 0 else { preconditionFailure("ABI encode error") }
  parameters.append(result)
  }
  return Data(parameters.flatMap { $0.bytes }).sha3(.keccak256)
  }
 }
 
-public func eip712encode(domainSeparator: EIP712Hashable, message: EIP712Hashable) throws -> Data {
- let data = try Data([UInt8(0x19), UInt8(0x01)]) + domainSeparator.hash() + message.hash()
- return data.sha3(.keccak256)
+public func eip712hash(domainSeparator: EIP712Hashable, message: EIP712Hashable) throws -> Data {
+ try eip712hash(domainSeparatorHash: domainSeparator.hash(), messageHash: message.hash())
+}
+
+public func eip712hash(domainSeparatorHash: Data, messageHash: Data) -> Data {
+ (Data([UInt8(0x19), UInt8(0x01)]) + domainSeparatorHash + messageHash).sha3(.keccak256)
 }
 
 // MARK: - Additional private and public extensions with support members