chore: fixed conflicts with develop

Author: JeneaVranceanu

Sources/web3swift/Convenience/Data+Extension.swift

@@ -66,7 +66,7 @@ public extension Data {
             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, 32, pointer)
+                    return SecRandomCopyBytes(kSecRandomDefault, length, pointer)
                 } else {
                     return nil
                 }

Sources/web3swift/Convenience/SECP256k1.swift

@@ -343,7 +343,7 @@ extension SECP256K1 {
             let result = data.withUnsafeMutableBytes { (mutableRBBytes) -> Int32? in
                 if let mutableRBytes = mutableRBBytes.baseAddress, mutableRBBytes.count > 0 {
                     let mutableBytes = mutableRBytes.assumingMemoryBound(to: UInt8.self)
-                    return SecRandomCopyBytes(kSecRandomDefault, 32, mutableBytes)
+                    return SecRandomCopyBytes(kSecRandomDefault, length, mutableBytes)
                 } else {
                     return nil
                 }

Sources/web3swift/HookedFunctions/Web3+BrowserFunctions.swift

@@ -74,15 +74,18 @@ extension web3.BrowserFunctions {
 
 
     public func sendTransaction(_ transactionJSON: [String: Any], password: String = "web3swift") -> [String:Any]? {
-        guard let transaction = EthereumTransaction.fromJSON(transactionJSON) else {return nil}
-        guard let options = TransactionOptions.fromJSON(transactionJSON) else {return nil}
-        var transactionOptions = TransactionOptions()
-        transactionOptions.from = options.from
-        transactionOptions.to = options.to
-        transactionOptions.value = options.value ?? BigUInt(0)
-        transactionOptions.gasLimit = options.gasLimit ?? .automatic
-        transactionOptions.gasPrice = options.gasPrice ?? .automatic
-        return self.sendTransaction(transaction, transactionOptions: transactionOptions, password: password)
+        do {
+          let jsonData: Data = try JSONSerialization.data(withJSONObject: transactionJSON, options: [])
+          let transaction: EthereumTransaction = try JSONDecoder().decode(EthereumTransaction.self, from: jsonData)
+          let options: TransactionOptions = try JSONDecoder().decode(TransactionOptions.self, from: jsonData)
+          var transactionOptions = TransactionOptions()
+          transactionOptions.from = options.from
+          transactionOptions.to = options.to
+          transactionOptions.value = options.value ?? 0
+          transactionOptions.gasLimit = options.gasLimit ?? .automatic
+          transactionOptions.gasPrice = options.gasPrice ?? .automatic
+          return self.sendTransaction(transaction, transactionOptions: transactionOptions, password: password)
+        } catch { return nil }
     }
 
     public func sendTransaction(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions, password: String = "web3swift") -> [String:Any]? {
@@ -95,15 +98,18 @@ extension web3.BrowserFunctions {
     }
 
     public func estimateGas(_ transactionJSON: [String: Any]) -> BigUInt? {
-        guard let transaction = EthereumTransaction.fromJSON(transactionJSON) else {return nil}
-        guard let options = TransactionOptions.fromJSON(transactionJSON) else {return nil}
-        var transactionOptions = TransactionOptions()
-        transactionOptions.from = options.from
-        transactionOptions.to = options.to
-        transactionOptions.value = options.value ?? BigUInt(0)
-        transactionOptions.gasLimit = .automatic
-        transactionOptions.gasPrice = options.gasPrice ?? .automatic
-        return self.estimateGas(transaction, transactionOptions: transactionOptions)
+        do {
+            let jsonData: Data = try JSONSerialization.data(withJSONObject: transactionJSON, options: [])
+            let transaction: EthereumTransaction = try JSONDecoder().decode(EthereumTransaction.self, from: jsonData)
+            let options: TransactionOptions = try JSONDecoder().decode(TransactionOptions.self, from: jsonData)
+            var transactionOptions = TransactionOptions()
+            transactionOptions.from = options.from
+            transactionOptions.to = options.to
+            transactionOptions.value = options.value ?? 0
+            transactionOptions.gasLimit = .automatic
+            transactionOptions.gasPrice = options.gasPrice ?? .automatic
+            return self.estimateGas(transaction, transactionOptions: transactionOptions)
+        } catch { return nil }
     }
 
     public func estimateGas(_ transaction: EthereumTransaction, transactionOptions: TransactionOptions) -> BigUInt? {
@@ -116,9 +122,10 @@ extension web3.BrowserFunctions {
     }
 
     public func prepareTxForApproval(_ transactionJSON: [String: Any]) -> (transaction: EthereumTransaction?, options: TransactionOptions?) {
-        guard let transaction = EthereumTransaction.fromJSON(transactionJSON) else {return (nil, nil)}
-        guard let options = TransactionOptions.fromJSON(transactionJSON) else {return (nil, nil)}
         do {
+            let jsonData: Data = try JSONSerialization.data(withJSONObject: transactionJSON, options: [])
+            let transaction: EthereumTransaction = try JSONDecoder().decode(EthereumTransaction.self, from: jsonData)
+            let options: TransactionOptions = try JSONDecoder().decode(TransactionOptions.self, from: jsonData)
             return try self.prepareTxForApproval(transaction, options: options)
         } catch {
             return (nil, nil)
@@ -144,20 +151,23 @@ extension web3.BrowserFunctions {
     }
 
     public func signTransaction(_ transactionJSON: [String: Any], password: String = "web3swift") -> String? {
-        guard let transaction = EthereumTransaction.fromJSON(transactionJSON) else {return nil}
-        guard let options = TransactionOptions.fromJSON(transactionJSON) else {return nil}
-        var transactionOptions = TransactionOptions()
-        transactionOptions.from = options.from
-        transactionOptions.to = options.to
-        transactionOptions.value = options.value ?? BigUInt(0)
-        transactionOptions.gasLimit = options.gasLimit ?? .automatic
-        transactionOptions.gasPrice = options.gasPrice ?? .automatic
-        if let nonceString = transactionJSON["nonce"] as? String, let nonce = BigUInt(nonceString.stripHexPrefix(), radix: 16) {
-            transactionOptions.nonce = .manual(nonce)
-        } else {
-            transactionOptions.nonce = .pending
-        }
-        return self.signTransaction(transaction, transactionOptions: transactionOptions, password: password)
+        do {
+            let jsonData: Data = try JSONSerialization.data(withJSONObject: transactionJSON, options: [])
+            let transaction: EthereumTransaction = try JSONDecoder().decode(EthereumTransaction.self, from: jsonData)
+            let options: TransactionOptions = try JSONDecoder().decode(TransactionOptions.self, from: jsonData)
+            var transactionOptions = TransactionOptions()
+            transactionOptions.from = options.from
+            transactionOptions.to = options.to
+            transactionOptions.value = options.value ?? 0
+            transactionOptions.gasLimit = options.gasLimit ?? .automatic
+            transactionOptions.gasPrice = options.gasPrice ?? .automatic
+            if let nonceString = transactionJSON["nonce"] as? String, let nonce = BigUInt(nonceString.stripHexPrefix(), radix: 16) {
+                transactionOptions.nonce = .manual(nonce)
+            } else {
+                transactionOptions.nonce = .pending
+            }
+            return self.signTransaction(transaction, transactionOptions: transactionOptions, password: password)
+        } catch { return nil }
     }
 
     public func signTransaction(_ trans: EthereumTransaction, transactionOptions: TransactionOptions, password: String = "web3swift") -> String? {

Sources/web3swift/KeystoreManager/EthereumKeystoreV3.swift

@@ -96,7 +96,7 @@ public class EthereumKeystoreV3: AbstractKeystore {
         if (keyData == nil) {
             throw AbstractKeystoreError.encryptionError("Encryption without key data")
         }
-        let saltLen = 32;
+        let saltLen = 32
         guard let saltData = Data.randomBytes(length: saltLen) else {
             throw AbstractKeystoreError.noEntropyError
         }

Sources/web3swift/Promises/Promise+Web3+Contract+GetIndexedEvents.swift

@@ -272,7 +272,7 @@ extension ERC721: IERC721Metadata {
         let contract = self.contract
         var transactionOptions = TransactionOptions()
         transactionOptions.callOnBlock = .latest
-        let result = try contract.read("tokenId", parameters: [tokenId] as [AnyObject], extraData: Data(), transactionOptions: self.transactionOptions)!.call(transactionOptions: transactionOptions)
+        let result = try contract.read("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data(), transactionOptions: self.transactionOptions)!.call(transactionOptions: transactionOptions)
         guard let res = result["0"] as? String else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res
     }

Sources/web3swift/Tokens/ERC721/Web3+ERC721.swift

@@ -248,7 +248,7 @@ public class ERC721x: IERC721x {
         let contract = self.contract
         var transactionOptions = TransactionOptions()
         transactionOptions.callOnBlock = .latest
-        let result = try contract.read("tokenId", parameters: [tokenId] as [AnyObject], extraData: Data(), transactionOptions: self.transactionOptions)!.call(transactionOptions: transactionOptions)
+        let result = try contract.read("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data(), transactionOptions: self.transactionOptions)!.call(transactionOptions: transactionOptions)
         guard let res = result["0"] as? String else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res
     }

Sources/web3swift/Tokens/ERC721x/Web3+ERC721x.swift

@@ -29,7 +29,7 @@ public struct EthereumTransaction: CustomStringConvertible {
         get{
             if (self.r == BigUInt(0) && self.s == BigUInt(0)) {
                 return self.v
-            } else if (self.v == BigUInt(27) || self.v == BigUInt(28)) {
+            } else if (self.v == BigUInt(27) || self.v == BigUInt(28) || self.v < BigUInt(35)) {
                 return nil
             } else {
                 return ((self.v - BigUInt(1)) / BigUInt(2)) - BigUInt(17)
@@ -125,11 +125,12 @@ public struct EthereumTransaction: CustomStringConvertible {
         } else if self.v >= 27 && self.v <= 30 {
             d = BigUInt(27)
         }
-        if (self.chainID != nil && self.chainID != BigUInt(0)) {
-            normalizedV = self.v - d - self.chainID! - self.chainID!
-        } else if (inferedChainID != nil) {
-            normalizedV = self.v - d - inferedChainID! - inferedChainID!
+        if let testID = self.chainID, testID != BigUInt(0) && self.v >= (d + testID + testID) {
+            normalizedV = self.v - d - testID - testID
+        } else if let testID = inferedChainID, self.v >= (d + testID + testID) {
+            normalizedV = self.v - d - testID - testID
         } else {
+            if(d > v) { d = 0 }
             normalizedV = self.v - d
         }
         guard let vData = normalizedV.serialize().setLengthLeft(1) else {return nil}
@@ -353,51 +354,5 @@ public extension EthereumTransaction {
         }
         return tx
     }
-    
-    static func fromJSON(_ json: [String: Any]) -> EthereumTransaction? {
-        guard let options = TransactionOptions.fromJSON(json) else {return nil}
-        guard let toString = json["to"] as? String else {return nil}
-        var to: EthereumAddress
-        if toString == "0x" || toString == "0x0" {
-            to = EthereumAddress.contractDeploymentAddress()
-        } else {
-            guard let ethAddr = EthereumAddress(toString) else {return nil}
-            to = ethAddr
-        }
-        //        if (!to.isValid) {
-        //            return nil
-        //        }
-        var dataString = json["data"] as? String
-        if (dataString == nil) {
-            dataString = json["input"] as? String
-        }
-        guard dataString != nil, let data = Data.fromHex(dataString!) else {return nil}
-        var transaction = EthereumTransaction(to: to, data: data, options: options)
-        if let nonceString = json["nonce"] as? String {
-            guard let nonce = BigUInt(nonceString.stripHexPrefix(), radix: 16) else {return nil}
-            transaction.nonce = nonce
-        }
-        if let vString = json["v"] as? String {
-            guard let v = BigUInt(vString.stripHexPrefix(), radix: 16) else {return nil}
-            transaction.v = v
-        }
-        if let rString = json["r"] as? String {
-            guard let r = BigUInt(rString.stripHexPrefix(), radix: 16) else {return nil}
-            transaction.r = r
-        }
-        if let sString = json["s"] as? String {
-            guard let s = BigUInt(sString.stripHexPrefix(), radix: 16) else {return nil}
-            transaction.s = s
-        }
-        if let valueString = json["value"] as? String {
-            guard let value = BigUInt(valueString.stripHexPrefix(), radix: 16) else {return nil}
-            transaction.value = value
-        }
-        let inferedChainID = transaction.inferedChainID
-        if (transaction.inferedChainID != nil && transaction.v >= BigUInt(37)) {
-            transaction.chainID = inferedChainID
-        }
-        return transaction
-    }
-    
+
 }

Sources/web3swift/Transaction/EthereumTransaction.swift

@@ -108,7 +108,7 @@ public struct TransactionOptions {
             return nil
         }
     }
-    
+
     public func merge(_ otherOptions: TransactionOptions?) -> TransactionOptions {
         guard let other = otherOptions else {return self}
         var opts = TransactionOptions()
@@ -121,45 +121,7 @@ public struct TransactionOptions {
         opts.callOnBlock = mergeIfNotNil(first: self.callOnBlock, second: other.callOnBlock)
         return opts
     }
-    
-    public static func fromJSON(_ json: [String: Any]) -> TransactionOptions? {
-        var options = TransactionOptions()
-        if let gas = json["gas"] as? String, let gasBiguint = BigUInt(gas.stripHexPrefix().lowercased(), radix: 16) {
-            options.gasLimit = .manual(gasBiguint)
-        } else if let gasLimit = json["gasLimit"] as? String, let gasgasLimitBiguint = BigUInt(gasLimit.stripHexPrefix().lowercased(), radix: 16) {
-            options.gasLimit = .limited(gasgasLimitBiguint)
-        } else {
-            options.gasLimit = .automatic
-        }
-        if let gasPrice = json["gasPrice"] as? String, let gasPriceBiguint = BigUInt(gasPrice.stripHexPrefix().lowercased(), radix: 16) {
-            options.gasPrice = .manual(gasPriceBiguint)
-        } else {
-            options.gasPrice = .automatic
-        }
-        if let value = json["value"] as? String, let valueBiguint = BigUInt(value.stripHexPrefix().lowercased(), radix: 16) {
-            options.value = valueBiguint
-        }
-        if let toString = json["to"] as? String {
-            guard let addressTo = EthereumAddress(toString) else {return nil}
-            options.to = addressTo
-        }
-        if let fromString = json["from"] as? String {
-            guard let addressFrom = EthereumAddress(fromString) else {return nil}
-            options.from = addressFrom
-        }
-        if let nonceString = json["nonce"] as? String, let nonce = BigUInt(nonceString.stripHexPrefix(), radix: 16) {
-            options.nonce = .manual(nonce)
-        } else {
-            options.nonce = .pending
-        }
-        if let callOnBlockString = json["callOnBlock"] as? String, let callOnBlock = BigUInt(callOnBlockString.stripHexPrefix(), radix: 16) {
-            options.callOnBlock = .exactBlockNumber(callOnBlock)
-        } else {
-            options.callOnBlock = .pending
-        }
-        return options
-    }
-    
+
     /// Merges two sets of topions by overriding the parameters from the first set by parameters from the second
     /// set if those are not nil.
     ///

Sources/web3swift/Web3/Web3+Options.swift

@@ -110,12 +110,19 @@ extension EthereumTransaction:Decodable {
         case r
         case s
         case value
+        case type  // present in EIP-1559 transaction objects
     }
 
     public init(from decoder: Decoder) throws {
         let options = try TransactionOptions(from: decoder)
         let container = try decoder.container(keyedBy: CodingKeys.self)
 
+        // test to see if it is a EIP-1559 wrapper
+        if let envelope = try decodeHexToBigUInt(container, key: .type, allowOptional: true) {
+            // if present and non-sero we are a new wrapper we can't decode
+            if(envelope != BigInt(0)) { throw Web3Error.dataError }
+        }
+        
         var data = try decodeHexToData(container, key: .data, allowOptional: true)
         if data != nil {
             self.data = data!
@@ -198,25 +205,6 @@ public struct TransactionDetails: Decodable {
         let transaction = try EthereumTransaction(from: decoder)
         self.transaction = transaction
     }
-    
-    public init? (_ json: [String: AnyObject]) {
-        let bh = json["blockHash"] as? String
-        if (bh != nil) {
-            guard let blockHash = Data.fromHex(bh!) else {return nil}
-            self.blockHash = blockHash
-        }
-        let bn = json["blockNumber"] as? String
-        let ti = json["transactionIndex"] as? String
-        
-        guard let transaction = EthereumTransaction.fromJSON(json) else {return nil}
-        self.transaction = transaction
-        if bn != nil {
-            blockNumber = BigUInt(bn!.stripHexPrefix(), radix: 16)
-        }
-        if ti != nil {
-            transactionIndex = BigUInt(ti!.stripHexPrefix(), radix: 16)
-        }
-    }
 }
 
 public struct TransactionReceipt: Decodable {
@@ -418,27 +406,12 @@ public enum TransactionInBlock:Decodable {
         if let string = try? value.decode(String.self) {
             guard let d = Data.fromHex(string) else {throw Web3Error.dataError}
             self = .hash(d)
-        } else if let dict = try? value.decode([String:String].self) {
-//            guard let t = try? EthereumTransaction(from: decoder) else {throw Web3Error.dataError}
-            guard let t = EthereumTransaction.fromJSON(dict) else {throw Web3Error.dataError}
-            self = .transaction(t)
+        } else if let transaction = try? value.decode(EthereumTransaction.self) {
+            self = .transaction(transaction)
         } else {
             self = .null
         }
     }
-    
-    
-    public init?(_ data: AnyObject) {
-        if let string = data as? String {
-            guard let d = Data.fromHex(string) else {return nil}
-            self = .hash(d)
-        } else if let dict = data as? [String:AnyObject] {
-            guard let t = EthereumTransaction.fromJSON(dict) else {return nil}
-            self = .transaction(t)
-        } else {
-            return nil
-        }
-    }
 }
 
 public struct Block:Decodable {