Merge branch 'develop' into chore/more-sign-tests

Author: JeneaVranceanu

README.md

@@ -58,7 +58,7 @@
 - [x] ✅**Literally following the standards** (BIP, EIP, etc):
     - [x] **[BIP32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) (HD Wallets), [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) (Seed phrases), [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki) (Key generation prefixes)**
 - [x] **[EIP-20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md)** (Standard interface for tokens - ERC-20), **[EIP-67](https://github.com/ethereum/EIPs/issues/67)** (Standard URI scheme), **[EIP-155](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md)** (Replay attacks protection), **[EIP-2718](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2718.md)** (Typed Transaction Envelope), **[EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md)** (Gas Fee market change)
-    - [x] **And many others** *(For details about this EIP's look at [Documentation page](https://github.com/web3swift-team/web3swift/blob/master/Documentation/))*: EIP-681, EIP-721, EIP-165, EIP-777, EIP-820, EIP-888, EIP-1400, EIP-1410, EIP-1594, EIP-1643, EIP-1644, EIP-1633, EIP-721, EIP-1155, EIP-1376, ST-20
+    - [x] **And many others** *(For details about this EIP's look at [Documentation page](https://github.com/web3swift-team/web3swift/blob/master/Documentation/))*: EIP-165, EIP-681, EIP-721, EIP-777, EIP-820, EIP-888, EIP-1155, EIP-1376, EIP-1400, EIP-1410, EIP-1594, EIP-1633, EIP-1643, EIP-1644, EIP-4361 ([SIWE](https://eips.ethereum.org/EIPS/eip-4361)), ST-20
 - [x] **RLP encoding**
 - [x] Base58 encoding scheme
 - [x] Formatting to and from Ethereum Units

Sources/Web3Core/Contract/ContractProtocol.swift

@@ -280,6 +280,13 @@ extension DefaultContractProtocol {
         return encodedData
     }
 
+    public func event(_ event: String, parameters: [Any]) -> [EventFilterParameters.Topic?] {
+        guard let event = events[event] else {
+            return []
+        }
+        return event.encodeParameters(parameters)
+    }
+
     public func parseEvent(_ eventLog: EventLog) -> (eventName: String?, eventData: [String: Any]?) {
         for (eName, ev) in self.events {
             if !ev.anonymous {

Sources/Web3Core/EthereumABI/ABIElements.swift

@@ -211,13 +211,85 @@ extension ABI.Element.Function {
     }
 }
 
-// MARK: - Event logs decoding
+// MARK: - Event logs decoding & encoding
 
 extension ABI.Element.Event {
     public func decodeReturnedLogs(eventLogTopics: [Data], eventLogData: Data) -> [String: Any]? {
         guard let eventContent = ABIDecoder.decodeLog(event: self, eventLogTopics: eventLogTopics, eventLogData: eventLogData) else { return nil }
         return eventContent
     }
+
+    public static func encodeTopic(input: ABI.Element.Event.Input, value: Any) -> EventFilterParameters.Topic? {
+        switch input.type {
+        case .string:
+            guard let string = value as? String else {
+                return nil
+            }
+            return .string(string.sha3(.keccak256).addHexPrefix())
+        case .dynamicBytes:
+            guard let data = ABIEncoder.convertToData(value) else {
+                return nil
+            }
+            return .string(data.sha3(.keccak256).toHexString().addHexPrefix())
+        case .bytes(length: _):
+            guard let data = ABIEncoder.convertToData(value), let data = data.setLengthLeft(32) else {
+                return nil
+            }
+            return .string(data.toHexString().addHexPrefix())
+        case .address, .uint(bits: _), .int(bits: _), .bool:
+            guard let encoded = ABIEncoder.encodeSingleType(type: input.type, value: value) else {
+                return nil
+            }
+            return .string(encoded.toHexString().addHexPrefix())
+        default:
+            guard let data = try? ABIEncoder.abiEncode(value).setLengthLeft(32) else {
+                return nil
+            }
+            return .string(data.toHexString().addHexPrefix())
+        }
+    }
+
+    public func encodeParameters(_ parameters: [Any?]) -> [EventFilterParameters.Topic?] {
+        guard parameters.count <= inputs.count else {
+            // too many arguments for fragment
+            return []
+        }
+        var topics: [EventFilterParameters.Topic?] = []
+
+        if !anonymous {
+            topics.append(.string(topic.toHexString().addHexPrefix()))
+        }
+
+        for (i, p) in parameters.enumerated() {
+            let input = inputs[i]
+            if !input.indexed {
+                // cannot filter non-indexed parameters; must be null
+                return []
+            }
+            if p == nil {
+                topics.append(nil)
+            } else if input.type.isArray || input.type.isTuple {
+                // filtering with tuples or arrays not supported
+                return []
+            } else if let p = p as? Array<Any> {
+                topics.append(.strings(p.map { Self.encodeTopic(input: input, value: $0) }))
+            } else {
+                topics.append(Self.encodeTopic(input: input, value: p!))
+            }
+        }
+
+        // Trim off trailing nulls
+        while let last = topics.last {
+            if last == nil {
+                topics.removeLast()
+            } else if case .string(let string) = last, string == nil {
+                topics.removeLast()
+            } else {
+                break
+            }
+        }
+        return topics
+    }
 }
 
 // MARK: - Function input/output decoding

Sources/Web3Core/EthereumNetwork/Utility/HexDecodable+Extensions.swift

@@ -17,16 +17,17 @@ extension BigInt: LiteralInitiableFromString { }
 extension BigUInt: LiteralInitiableFromString { }
 
 extension Data: LiteralInitiableFromString {
+    /// Converts hexadecimal string representation of some bytes into actual bytes.
+    /// Notes:
+    ///  - empty string will return `nil`;
+    ///  - empty hex string, meaning it's equal to `"0x"`, will return empty `Data` object.
+    /// - Parameter hex: bytes represented as string.
+    /// - Returns: optional raw bytes.
     public static func fromHex(_ hex: String) -> Data? {
-        let string = hex.lowercased().stripHexPrefix()
-        let array = [UInt8](hex: string)
-        if array.count == 0 {
-            if hex == "0x" || hex == "" {
-                return Data()
-            } else {
-                return nil
-            }
-        }
-        return Data(array)
+        let hex = hex.lowercased().trim()
+        guard !hex.isEmpty else { return nil }
+        guard hex != "0x" else { return Data() }
+        let bytes = [UInt8](hex: hex.stripHexPrefix())
+        return bytes.isEmpty ? nil : Data(bytes)
     }
 }

Sources/Web3Core/KeystoreManager/BIP32Keystore.swift

@@ -149,71 +149,76 @@ public class BIP32Keystore: AbstractKeystore {
         } else {
             newIndex = UInt32.zero
         }
+
         guard let newNode = parentNode.derive(index: newIndex, derivePrivateKey: true, hardened: false) else {
             throw AbstractKeystoreError.keyDerivationError
         }
         guard let newAddress = Utilities.publicToAddress(newNode.publicKey) else {
             throw AbstractKeystoreError.keyDerivationError
         }
-        let prefixPath = self.rootPrefix
-        var newPath: String
-        if newNode.isHardened {
-            newPath = prefixPath + "/" + String(newNode.index % HDNode.hardenedIndexPrefix) + "'"
-        } else {
-            newPath = prefixPath + "/" + String(newNode.index)
-        }
+        let newPath = rootPrefix + "/" + String(newNode.index)
         addressStorage.add(address: newAddress, for: newPath)
     }
 
     public func createNewCustomChildAccount(password: String, path: String) throws {
-        guard let decryptedRootNode = try getPrefixNodeData(password) else {
+        guard let decryptedRootNode = try getPrefixNodeData(password),
+              let keystoreParams else {
             throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")
         }
         guard let rootNode = HDNode(decryptedRootNode) else {
             throw AbstractKeystoreError.encryptionError("Failed to deserialize a root node")
         }
-        let prefixPath = self.rootPrefix
-        var pathAppendix: String?
+
+        let prefixPath = rootPrefix
+        var pathAppendix = path
+
         if path.hasPrefix(prefixPath) {
-            let upperIndex = (path.range(of: prefixPath)?.upperBound)!
-            if upperIndex < path.endIndex {
-                pathAppendix = String(path[path.index(after: upperIndex)])
+            if let upperIndex = (path.range(of: prefixPath)?.upperBound), upperIndex < path.endIndex {
+                pathAppendix = String(path[path.index(after: upperIndex)..<path.endIndex])
             } else {
                 throw AbstractKeystoreError.encryptionError("out of bounds")
             }
-
-            guard pathAppendix != nil else {
-                throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")
-            }
-            if pathAppendix!.hasPrefix("/") {
-                pathAppendix = pathAppendix?.trimmingCharacters(in: CharacterSet.init(charactersIn: "/"))
-            }
-        } else {
-            if path.hasPrefix("/") {
-                pathAppendix = path.trimmingCharacters(in: CharacterSet.init(charactersIn: "/"))
-            }
         }
-        guard pathAppendix != nil else {
-            throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")
+        if pathAppendix.hasPrefix("/") {
+            pathAppendix = pathAppendix.trimmingCharacters(in: .init(charactersIn: "/"))
         }
         guard rootNode.depth == prefixPath.components(separatedBy: "/").count - 1 else {
             throw AbstractKeystoreError.encryptionError("Derivation depth mismatch")
         }
-        guard let newNode = rootNode.derive(path: pathAppendix!, derivePrivateKey: true) else {
+        guard let newNode = rootNode.derive(path: pathAppendix, derivePrivateKey: true) else {
             throw AbstractKeystoreError.keyDerivationError
         }
         guard let newAddress = Utilities.publicToAddress(newNode.publicKey) else {
             throw AbstractKeystoreError.keyDerivationError
         }
-        var newPath: String
-        if newNode.isHardened {
-            newPath = prefixPath + "/" + pathAppendix!.trimmingCharacters(in: CharacterSet.init(charactersIn: "'")) + "'"
-        } else {
-            newPath = prefixPath + "/" + pathAppendix!
-        }
+
+        let newPath = prefixPath + "/" + pathAppendix
+
         addressStorage.add(address: newAddress, for: newPath)
-        guard let serializedRootNode = rootNode.serialize(serializePublic: false) else {throw AbstractKeystoreError.keyDerivationError}
-        try encryptDataToStorage(password, data: serializedRootNode, aesMode: self.keystoreParams!.crypto.cipher)
+        guard let serializedRootNode = rootNode.serialize(serializePublic: false) else {
+            throw AbstractKeystoreError.keyDerivationError
+        }
+        try encryptDataToStorage(password, data: serializedRootNode, aesMode: keystoreParams.crypto.cipher)
+    }
+
+    /// Fast generation addresses for current account
+    /// used to show which addresses the user can get for indices from `0` to `number-1`
+    /// - Parameters:
+    ///   - password: password of seed storage
+    ///   - number: number of wallets addresses needed to generate from  `0` to `number-1`
+    /// - Returns: Array of addresses generated from `0` to number bound
+    public func getAddressForAccount(password: String, number: UInt) throws -> [EthereumAddress] {
+        guard let decryptedRootNode = try? getPrefixNodeData(password),
+              let rootNode = HDNode(decryptedRootNode) else {
+            throw AbstractKeystoreError.encryptionError("Failed to decrypt a keystore")
+        }
+        return try [UInt](0..<number).compactMap { number in
+            guard rootNode.depth == rootPrefix.components(separatedBy: "/").count - 1,
+                  let newNode = rootNode.derive(path: "\(number)", derivePrivateKey: true) else {
+                throw AbstractKeystoreError.keyDerivationError
+            }
+            return Utilities.publicToAddress(newNode.publicKey)
+        }
     }
 
     fileprivate func encryptDataToStorage(_ password: String, data: Data, dkLen: Int = 32, N: Int = 4096, R: Int = 6, P: Int = 1, aesMode: String = "aes-128-cbc") throws {

Sources/Web3Core/Transaction/EventfilterParameters.swift

@@ -50,8 +50,8 @@ extension EventFilterParameters {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(fromBlock.description, forKey: .fromBlock)
         try container.encode(toBlock.description, forKey: .toBlock)
-        try container.encode(address.description, forKey: .address)
-        try container.encode(topics.textRepresentation, forKey: .topics)
+        try container.encode(address, forKey: .address)
+        try container.encode(topics, forKey: .topics)
     }
 }
 
@@ -96,6 +96,17 @@ extension EventFilterParameters {
         case string(String?)
         case strings([Topic?]?)
 
+        public func encode(to encoder: Encoder) throws {
+            switch self {
+            case let .string(s):
+                var container = encoder.singleValueContainer()
+                try container.encode(s)
+            case let .strings(ss):
+                var container = encoder.unkeyedContainer()
+                try container.encode(contentsOf: ss ?? [])
+            }
+        }
+
         var rawValue: String {
             switch self {
             case let .string(string):

Sources/Web3Core/Utility/Data+Extension.swift

@@ -5,7 +5,8 @@
 
 import Foundation
 
-extension Data {
+public extension Data {
+
     init<T>(fromArray values: [T]) {
         let values = values
         let ptrUB = values.withUnsafeBufferPointer { (ptr: UnsafeBufferPointer) in return ptr }
@@ -33,32 +34,34 @@ extension Data {
         return difference == UInt8(0x00)
     }
 
-    public static func zero(_ data: inout Data) {
+    static func zero(_ data: inout Data) {
         let count = data.count
         data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in
             body.baseAddress?.assumingMemoryBound(to: UInt8.self).initialize(repeating: 0, count: count)
         }
     }
 
-    public static func randomBytes(length: Int) -> Data? {
-        for _ in 0...1024 {
-            var data = Data(repeating: 0, count: length)
-            let result = data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) -> Int32? in
-                if let bodyAddress = body.baseAddress, body.count > 0 {
-                    let pointer = bodyAddress.assumingMemoryBound(to: UInt8.self)
-                    return SecRandomCopyBytes(kSecRandomDefault, length, pointer)
-                } else {
-                    return nil
-                }
-            }
-            if let notNilResult = result, notNilResult == errSecSuccess {
-                return data
-            }
+    /**
+     Generates an array of random bytes of the specified length.
+     This function uses `SecRandomCopyBytes` to generate random bytes returning it as a `Data` object.
+     If an error occurs during random bytes generation, the function returns `nil`.
+     Error occurs only if `SecRandomCopyBytes` returns status that is not `errSecSuccess`.
+     See [all status codes](https://developer.apple.com/documentation/security/1542001-security_framework_result_codes) for possible error reasons.
+     Note: in v4 of web3swift this function will be deprecated and a new implementation will be provided that will throw occurred error.
+     - Parameter length: The number of random bytes to generate.
+
+     - Returns: optional `Data` object containing the generated random bytes, or `nil` if an error occurred during generation.
+     */
+    static func randomBytes(length: Int) -> Data? {
+        var entropyBytes = [UInt8](repeating: 0, count: length)
+        let status = SecRandomCopyBytes(kSecRandomDefault, entropyBytes.count, &entropyBytes)
+        guard status == errSecSuccess else {
+            return nil
         }
-        return nil
+        return Data(entropyBytes)
     }
 
-    public func bitsInRange(_ startingBit: Int, _ length: Int) -> UInt64? { // return max of 8 bytes for simplicity, non-public
+    func bitsInRange(_ startingBit: Int, _ length: Int) -> UInt64? { // return max of 8 bytes for simplicity, non-public
         if startingBit + length / 8 > self.count, length > 64, startingBit > 0, length >= 1 { return nil }
         let bytes = self[(startingBit/8) ..< (startingBit+length+7)/8]
         let padding = Data(repeating: 0, count: 8 - bytes.count)

Sources/Web3Core/Utility/String+Extension.swift

@@ -135,6 +135,26 @@ extension String {
     func trim() -> String {
         trimmingCharacters(in: .whitespacesAndNewlines)
     }
+
+   /// Splits a string into groups of `every` n characters, grouping from left-to-right by default. If `backwards` is true, right-to-left.
+   public func split(every: Int, backwards: Bool = false) -> [String] {
+       var result = [String]()
+
+       for i in stride(from: 0, to: self.count, by: every) {
+           switch backwards {
+           case true:
+               let endIndex = self.index(self.endIndex, offsetBy: -i)
+               let startIndex = self.index(endIndex, offsetBy: -every, limitedBy: self.startIndex) ?? self.startIndex
+               result.insert(String(self[startIndex..<endIndex]), at: 0)
+           case false:
+               let startIndex = self.index(self.startIndex, offsetBy: i)
+               let endIndex = self.index(startIndex, offsetBy: every, limitedBy: self.endIndex) ?? self.endIndex
+               result.append(String(self[startIndex..<endIndex]))
+           }
+       }
+
+       return result
+   }
 }
 
 extension Character {

Sources/web3swift/EthereumAPICalls/Ethereum/IEth+Defaults.swift

@@ -130,6 +130,12 @@ public extension IEth {
     }
 }
 
+public extension IEth {
+    func getLogs(eventFilter: EventFilterParameters) async throws -> [EventLog] {
+        try await APIRequest.sendRequest(with: self.provider, for: .getLogs(eventFilter)).result
+    }
+}
+
 public extension IEth {
     func send(_ transaction: CodableTransaction) async throws -> TransactionSendingResult {
         let request = APIRequest.sendTransaction(transaction)

Sources/web3swift/EthereumAPICalls/Ethereum/IEth.swift

@@ -25,6 +25,8 @@ public protocol IEth {
 
     func code(for address: EthereumAddress, onBlock: BlockNumber) async throws -> Hash
 
+    func getLogs(eventFilter: EventFilterParameters) async throws -> [EventLog]
+
     func gasPrice() async throws -> BigUInt
 
     func getTransactionCount(for address: EthereumAddress, onBlock: BlockNumber) async throws -> BigUInt