diff --git a/Sources/web3swift/Tokens/ERC1155/Web3+ERC1155.swift b/Sources/web3swift/Tokens/ERC1155/Web3+ERC1155.swift index 2ddb502a3..3cc91263e 100644 --- a/Sources/web3swift/Tokens/ERC1155/Web3+ERC1155.swift +++ b/Sources/web3swift/Tokens/ERC1155/Web3+ERC1155.swift @@ -67,9 +67,7 @@ public class ERC1155: IERC1155 { if self._hasReadProperties { return } - let contract = self.contract guard contract.contract.address != nil else {return} - self.transaction.callOnBlock = .latest guard let tokenIdPromise = try await contract.createReadOperation("id", parameters: [] as [AnyObject], extraData: Data())?.callContractMethod() else {return} @@ -80,34 +78,25 @@ public class ERC1155: IERC1155 { } public func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, id: BigUInt, value: BigUInt, data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, id, value, data] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, id, value, data] as [AnyObject])! return tx } public func safeBatchTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, ids: [BigUInt], values: [BigUInt], data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - + updateTransactionAndContract(from: from) let tx = contract - .createWriteOperation("safeBatchTransferFrom", parameters: [originalOwner, to, ids, values, data] as [AnyObject] )! + .createWriteOperation("safeBatchTransferFrom", parameters: [originalOwner, to, ids, values, data] as [AnyObject])! return tx } public func balanceOf(account: EthereumAddress, id: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest let result = try await contract - .createReadOperation("balanceOf", parameters: [account, id] as [AnyObject], extraData: Data() )! + .createReadOperation("balanceOf", parameters: [account, id] as [AnyObject], extraData: Data())! .callContractMethod() - /* let result = try await contract - .prepareToRead("balanceOf", parameters: [account, id] as [AnyObject], extraData: Data() )! + .prepareToRead("balanceOf", parameters: [account, id] as [AnyObject], extraData: Data())! .execute() .decodeData() @@ -117,27 +106,32 @@ public class ERC1155: IERC1155 { } public func setApprovalForAll(from: EthereumAddress, operator user: EthereumAddress, approved: Bool, scope: Data) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved, scope] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved, scope] as [AnyObject])! return tx } public func isApprovedForAll(owner: EthereumAddress, operator user: EthereumAddress, scope: Data) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user, scope] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user, scope] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC1155 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC1376/Web3+ERC1376.swift b/Sources/web3swift/Tokens/ERC1376/Web3+ERC1376.swift index f3570578b..8b5a7b34d 100644 --- a/Sources/web3swift/Tokens/ERC1376/Web3+ERC1376.swift +++ b/Sources/web3swift/Tokens/ERC1376/Web3+ERC1376.swift @@ -89,27 +89,20 @@ public class ERC1376: IERC1376, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -121,16 +114,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -143,16 +133,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -165,16 +152,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -187,24 +171,19 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func approve(from: EthereumAddress, spender: EthereumAddress, expectedValue: String, newValue: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -220,16 +199,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, eValue, nValue] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, eValue, nValue] as [AnyObject])! return tx } func increaseAllowance(from: EthereumAddress, spender: EthereumAddress, value: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -242,16 +218,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("increaseAllowance", parameters: [spender, amount] as [AnyObject] )! + let tx = contract.createWriteOperation("increaseAllowance", parameters: [spender, amount] as [AnyObject])! return tx } func decreaseAllowance(from: EthereumAddress, spender: EthereumAddress, value: String, strict: Bool) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -264,33 +237,26 @@ public class ERC1376: IERC1376, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("decreaseAllowance", parameters: [spender, amount, strict] as [AnyObject] )! + let tx = contract.createWriteOperation("decreaseAllowance", parameters: [spender, amount, strict] as [AnyObject])! return tx } func setERC20ApproveChecking(from: EthereumAddress, approveChecking: Bool) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setERC20ApproveChecking", parameters: [approveChecking] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setERC20ApproveChecking", parameters: [approveChecking] as [AnyObject])! return tx } func spendableAllowance(owner: EthereumAddress, spender: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("spendableAllowance", parameters: [owner, spender] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("spendableAllowance", parameters: [owner, spender] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func transfer(from: EthereumAddress, data: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -302,16 +268,13 @@ public class ERC1376: IERC1376, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(data, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [value] as [AnyObject])! return tx } func transferAndCall(from: EthereumAddress, to: EthereumAddress, value: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -323,34 +286,26 @@ public class ERC1376: IERC1376, ERC20BaseProperties { guard let amount = Utilities.parseToBigUInt(value, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferAndCall", parameters: [to, amount, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferAndCall", parameters: [to, amount, data] as [AnyObject])! return tx } func nonceOf(owner: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("nonceOf", parameters: [owner] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("nonceOf", parameters: [owner] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func increaseNonce(from: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("increaseNonce", parameters: [] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("increaseNonce", parameters: [] as [AnyObject])! return tx } func delegateTransferAndCall(from: EthereumAddress, nonce: BigUInt, fee: BigUInt, gasAmount: BigUInt, to: EthereumAddress, value: String, data: [UInt8], mode: IERC1376DelegateMode, v: UInt8, r: Data, s: Data) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -365,51 +320,50 @@ public class ERC1376: IERC1376, ERC20BaseProperties { let modeValue = mode.rawValue - let tx = contract.createWriteOperation("delegateTransferAndCall", parameters: [nonce, fee, gasAmount, to, amount, data, modeValue, v, r, s] as [AnyObject] )! + let tx = contract.createWriteOperation("delegateTransferAndCall", parameters: [nonce, fee, gasAmount, to, amount, data, modeValue, v, r, s] as [AnyObject])! return tx } func directDebit(debtor: EthereumAddress, receiver: EthereumAddress) async throws -> DirectDebit { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("directDebit", parameters: [debtor, receiver] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("directDebit", parameters: [debtor, receiver] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? DirectDebit else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func setupDirectDebit(from: EthereumAddress, receiver: EthereumAddress, info: DirectDebitInfo) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setupDirectDebit", parameters: [receiver, info] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setupDirectDebit", parameters: [receiver, info] as [AnyObject])! return tx } func terminateDirectDebit(from: EthereumAddress, receiver: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("terminateDirectDebit", parameters: [receiver] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("terminateDirectDebit", parameters: [receiver] as [AnyObject])! return tx } func withdrawDirectDebit(from: EthereumAddress, debtor: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("withdrawDirectDebit", parameters: [debtor] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("withdrawDirectDebit", parameters: [debtor] as [AnyObject])! return tx } func withdrawDirectDebit(from: EthereumAddress, debtors: [EthereumAddress], strict: Bool) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("withdrawDirectDebit", parameters: [debtors, strict] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("withdrawDirectDebit", parameters: [debtors, strict] as [AnyObject])! return tx } } + +// MARK: - Private + +extension ERC1376 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} + diff --git a/Sources/web3swift/Tokens/ERC1400/Web3+ERC1400.swift b/Sources/web3swift/Tokens/ERC1400/Web3+ERC1400.swift index 98d98360f..fbdbb48bb 100644 --- a/Sources/web3swift/Tokens/ERC1400/Web3+ERC1400.swift +++ b/Sources/web3swift/Tokens/ERC1400/Web3+ERC1400.swift @@ -86,27 +86,20 @@ public class ERC1400: IERC1400, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -118,16 +111,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -140,16 +130,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -162,23 +149,19 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -191,50 +174,38 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } // ERC1400 methods public func getDocument(name: Data) async throws -> (String, Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getDocument", parameters: [name] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getDocument", parameters: [name] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? (String, Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func setDocument(from: EthereumAddress, name: Data, uri: String, documentHash: Data) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setDocument", parameters: [name, uri, documentHash] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setDocument", parameters: [name, uri, documentHash] as [AnyObject])! return tx } public func balanceOfByPartition(partition: Data, tokenHolder: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOfByPartition", parameters: [partition, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOfByPartition", parameters: [partition, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func partitionsOf(tokenHolder: EthereumAddress) async throws -> [Data] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("partitionsOf", parameters: [tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("partitionsOf", parameters: [tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [Data] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transferWithData(from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -247,16 +218,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferWithData", parameters: [to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferWithData", parameters: [to, value, data] as [AnyObject])! return tx } public func transferFromWithData(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -269,16 +237,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFromWithData", parameters: [originalOwner, to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFromWithData", parameters: [originalOwner, to, value, data] as [AnyObject])! return tx } public func transferByPartition(partition: Data, from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -291,16 +256,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferByPartition", parameters: [partition, to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferByPartition", parameters: [partition, to, value, data] as [AnyObject])! return tx } public func operatorTransferByPartition(partition: Data, from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -313,24 +275,19 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorTransferByPartition", parameters: [partition, originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorTransferByPartition", parameters: [partition, originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func isControllable() async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isControllable", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isControllable", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func controllerTransfer(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -343,16 +300,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("controllerTransfer", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("controllerTransfer", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func controllerRedeem(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -365,76 +319,55 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("controllerRedeem", parameters: [tokenHolder, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("controllerRedeem", parameters: [tokenHolder, value, data, operatorData] as [AnyObject])! return tx } public func authorizeOperator(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject])! return tx } public func revokeOperator(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject])! return tx } public func authorizeOperatorByPartition(from: EthereumAddress, partition: Data, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("authorizeOperatorByPartition", parameters: [partition, user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperatorByPartition", parameters: [partition, user] as [AnyObject])! return tx } public func revokeOperatorByPartition(from: EthereumAddress, partition: Data, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("revokeOperatorByPartition", parameters: [partition, user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperatorByPartition", parameters: [partition, user] as [AnyObject])! return tx } public func isOperator(operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperator", parameters: [user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperator", parameters: [user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func isOperatorForPartition(partition: Data, operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperatorForPartition", parameters: [partition, user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperatorForPartition", parameters: [partition, user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func isIssuable() async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isIssuable", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isIssuable", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func issue(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -447,16 +380,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("issue", parameters: [tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("issue", parameters: [tokenHolder, value, data] as [AnyObject])! return tx } public func issueByPartition(from: EthereumAddress, partition: Data, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -469,16 +399,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("issueByPartition", parameters: [partition, tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("issueByPartition", parameters: [partition, tokenHolder, value, data] as [AnyObject])! return tx } public func redeem(from: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -491,16 +418,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeem", parameters: [value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeem", parameters: [value, data] as [AnyObject])! return tx } public func redeemFrom(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -513,16 +437,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeemFrom", parameters: [tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeemFrom", parameters: [tokenHolder, value, data] as [AnyObject])! return tx } public func redeemByPartition(from: EthereumAddress, partition: Data, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -535,16 +456,13 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeemByPartition", parameters: [partition, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeemByPartition", parameters: [partition, value, data] as [AnyObject])! return tx } public func operatorRedeemByPartition(from: EthereumAddress, partition: Data, tokenHolder: EthereumAddress, amount: String, operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -557,14 +475,11 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorRedeemByPartition", parameters: [partition, tokenHolder, value, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorRedeemByPartition", parameters: [partition, tokenHolder, value, operatorData] as [AnyObject])! return tx } public func canTransfer(to: EthereumAddress, amount: String, data: [UInt8]) async throws -> ([UInt8], Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -577,15 +492,12 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [to, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [to, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func canTransferFrom(originalOwner: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> ([UInt8], Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -598,15 +510,12 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func canTransferByPartition(originalOwner: EthereumAddress, to: EthereumAddress, partition: Data, amount: String, data: [UInt8]) async throws -> ([UInt8], Data, Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -619,7 +528,7 @@ public class ERC1400: IERC1400, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, partition, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, partition, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data, Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } @@ -627,114 +536,82 @@ public class ERC1400: IERC1400, ERC20BaseProperties { extension ERC1400: IERC777 { public func canImplementInterfaceForAddress(interfaceHash: Data, addr: EthereumAddress) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getInterfaceImplementer(addr: EthereumAddress, interfaceHash: Data) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func setInterfaceImplementer(from: EthereumAddress, addr: EthereumAddress, interfaceHash: Data, implementer: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject])! return tx } public func setManager(from: EthereumAddress, addr: EthereumAddress, newManager: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject])! return tx } public func interfaceHash(interfaceName: String) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func updateERC165Cache(from: EthereumAddress, contract: EthereumAddress, interfaceId: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = self.contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject])! return tx } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getGranularity() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getDefaultOperators() async throws -> [EthereumAddress] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [EthereumAddress] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func authorize(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject])! return tx } public func revoke(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject])! return tx } public func isOperatorFor(operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func send(from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -746,16 +623,13 @@ extension ERC1400: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject])! return tx } public func operatorSend(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -767,16 +641,13 @@ extension ERC1400: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func burn(from: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -788,16 +659,13 @@ extension ERC1400: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject])! return tx } public func operatorBurn(from: EthereumAddress, amount: String, originalOwner: EthereumAddress, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -809,7 +677,19 @@ extension ERC1400: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject])! return tx } } + +// MARK: - Private + +extension ERC1400 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC1410/Web3+ERC1410.swift b/Sources/web3swift/Tokens/ERC1410/Web3+ERC1410.swift index 4551cd793..5cc788487 100644 --- a/Sources/web3swift/Tokens/ERC1410/Web3+ERC1410.swift +++ b/Sources/web3swift/Tokens/ERC1410/Web3+ERC1410.swift @@ -64,28 +64,20 @@ public class ERC1410: IERC1410, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -97,17 +89,13 @@ public class ERC1410: IERC1410, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -120,17 +108,13 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -143,26 +127,19 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -175,35 +152,26 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } // ERC1410 methods public func balanceOfByPartition(partition: Data, tokenHolder: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOfByPartition", parameters: [partition, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOfByPartition", parameters: [partition, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func partitionsOf(tokenHolder: EthereumAddress) async throws -> [Data] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("partitionsOf", parameters: [tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("partitionsOf", parameters: [tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [Data] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transferByPartition(partition: Data, from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -216,17 +184,13 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferByPartition", parameters: [partition, to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferByPartition", parameters: [partition, to, value, data] as [AnyObject])! return tx } public func operatorTransferByPartition(partition: Data, from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -239,14 +203,11 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorTransferByPartition", parameters: [partition, originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorTransferByPartition", parameters: [partition, originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func canTransferByPartition(originalOwner: EthereumAddress, to: EthereumAddress, partition: Data, amount: String, data: [UInt8]) async throws -> ([UInt8], Data, Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -259,74 +220,50 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, partition, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, partition, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data, Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func isOperator(operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperator", parameters: [user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperator", parameters: [user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func isOperatorForPartition(partition: Data, operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperatorForPartition", parameters: [partition, user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperatorForPartition", parameters: [partition, user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func authorizeOperator(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject])! return tx } public func revokeOperator(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject])! return tx } public func authorizeOperatorByPartition(from: EthereumAddress, partition: Data, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("authorizeOperatorByPartition", parameters: [partition, user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperatorByPartition", parameters: [partition, user] as [AnyObject])! return tx } public func revokeOperatorByPartition(from: EthereumAddress, partition: Data, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("revokeOperatorByPartition", parameters: [partition, user] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperatorByPartition", parameters: [partition, user] as [AnyObject])! return tx } public func issueByPartition(from: EthereumAddress, partition: Data, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -339,17 +276,13 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("issueByPartition", parameters: [partition, tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("issueByPartition", parameters: [partition, tokenHolder, value, data] as [AnyObject])! return tx } public func redeemByPartition(from: EthereumAddress, partition: Data, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -362,17 +295,13 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeemByPartition", parameters: [partition, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeemByPartition", parameters: [partition, value, data] as [AnyObject])! return tx } public func operatorRedeemByPartition(from: EthereumAddress, partition: Data, tokenHolder: EthereumAddress, amount: String, operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -385,106 +314,78 @@ public class ERC1410: IERC1410, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorRedeemByPartition", parameters: [partition, tokenHolder, value, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorRedeemByPartition", parameters: [partition, tokenHolder, value, operatorData] as [AnyObject])! return tx } } extension ERC1410: IERC777 { public func canImplementInterfaceForAddress(interfaceHash: Data, addr: EthereumAddress) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getInterfaceImplementer(addr: EthereumAddress, interfaceHash: Data) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func setInterfaceImplementer(from: EthereumAddress, addr: EthereumAddress, interfaceHash: Data, implementer: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - - let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject])! return tx } public func setManager(from: EthereumAddress, addr: EthereumAddress, newManager: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - - let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject])! return tx } public func interfaceHash(interfaceName: String) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func updateERC165Cache(from: EthereumAddress, contract: EthereumAddress, interfaceId: [UInt8]) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - - let tx = contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = self.contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject])! return tx } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func authorize(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject])! return tx } public func revoke(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject])! return tx } public func isOperatorFor(operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func send(from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -496,17 +397,13 @@ extension ERC1410: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject])! return tx } public func operatorSend(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -518,17 +415,13 @@ extension ERC1410: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func burn(from: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -540,17 +433,13 @@ extension ERC1410: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject])! return tx } public func operatorBurn(from: EthereumAddress, amount: String, originalOwner: EthereumAddress, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -562,23 +451,31 @@ extension ERC1410: IERC777 { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject])! return tx } public func getGranularity() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getDefaultOperators() async throws -> [EthereumAddress] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [EthereumAddress] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC1410 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC1594/Web3+ERC1594.swift b/Sources/web3swift/Tokens/ERC1594/Web3+ERC1594.swift index de3bb5b41..0bba895bf 100644 --- a/Sources/web3swift/Tokens/ERC1594/Web3+ERC1594.swift +++ b/Sources/web3swift/Tokens/ERC1594/Web3+ERC1594.swift @@ -54,28 +54,19 @@ public class ERC1594: IERC1594, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -87,17 +78,13 @@ public class ERC1594: IERC1594, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -110,17 +97,13 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -133,26 +116,19 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -165,18 +141,14 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } // ERC1594 public func transferWithData(from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -189,17 +161,13 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferWithData", parameters: [to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferWithData", parameters: [to, value, data] as [AnyObject])! return tx } public func transferFromWithData(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -212,25 +180,19 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFromWithData", parameters: [originalOwner, to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFromWithData", parameters: [originalOwner, to, value, data] as [AnyObject])! return tx } public func isIssuable() async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isIssuable", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isIssuable", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func issue(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -243,17 +205,13 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("issue", parameters: [tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("issue", parameters: [tokenHolder, value, data] as [AnyObject])! return tx } public func redeem(from: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -266,17 +224,13 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeem", parameters: [value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeem", parameters: [value, data] as [AnyObject])! return tx } public func redeemFrom(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -289,14 +243,11 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("redeemFrom", parameters: [tokenHolder, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("redeemFrom", parameters: [tokenHolder, value, data] as [AnyObject])! return tx } public func canTransfer(to: EthereumAddress, amount: String, data: [UInt8]) async throws -> ([UInt8], Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -309,15 +260,12 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [to, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [to, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func canTransferFrom(originalOwner: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> ([UInt8], Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -330,8 +278,20 @@ public class ERC1594: IERC1594, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, value, data] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canTransfer", parameters: [originalOwner, to, value, data] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([UInt8], Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC1594 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC1633/Web3+ERC1633.swift b/Sources/web3swift/Tokens/ERC1633/Web3+ERC1633.swift index 7aae7e727..79f8219a9 100644 --- a/Sources/web3swift/Tokens/ERC1633/Web3+ERC1633.swift +++ b/Sources/web3swift/Tokens/ERC1633/Web3+ERC1633.swift @@ -41,28 +41,20 @@ public class ERC1633: IERC1633, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -74,17 +66,13 @@ public class ERC1633: IERC1633, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -97,17 +85,13 @@ public class ERC1633: IERC1633, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -120,25 +104,19 @@ public class ERC1633: IERC1633, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -151,32 +129,38 @@ public class ERC1633: IERC1633, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } func parentToken() async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("parentToken", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("parentToken", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func parentTokenId() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("parentTokenId", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("parentTokenId", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC1633 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC1643/Web3+ERC1643.swift b/Sources/web3swift/Tokens/ERC1643/Web3+ERC1643.swift index be5cce528..3885a1cf4 100644 --- a/Sources/web3swift/Tokens/ERC1643/Web3+ERC1643.swift +++ b/Sources/web3swift/Tokens/ERC1643/Web3+ERC1643.swift @@ -44,28 +44,20 @@ public class ERC1643: IERC1643, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -77,17 +69,13 @@ public class ERC1643: IERC1643, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -100,17 +88,13 @@ public class ERC1643: IERC1643, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -123,25 +107,19 @@ public class ERC1643: IERC1643, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -154,44 +132,45 @@ public class ERC1643: IERC1643, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } // ERC1643 methods public func getDocument(name: Data) async throws -> (String, Data) { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getDocument", parameters: [name] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getDocument", parameters: [name] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? (String, Data) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func setDocument(from: EthereumAddress, name: Data, uri: String, documentHash: Data) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setDocument", parameters: [name, uri, documentHash] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setDocument", parameters: [name, uri, documentHash] as [AnyObject])! return tx } public func removeDocument(from: EthereumAddress, name: Data) throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("removeDocument", parameters: [name] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("removeDocument", parameters: [name] as [AnyObject])! return tx } public func getAllDocuments() async throws -> [Data] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getAllDocuments", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getAllDocuments", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [Data] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC1643 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} + diff --git a/Sources/web3swift/Tokens/ERC1644/Web3+ERC1644.swift b/Sources/web3swift/Tokens/ERC1644/Web3+ERC1644.swift index 98d3f60f4..b1921794d 100644 --- a/Sources/web3swift/Tokens/ERC1644/Web3+ERC1644.swift +++ b/Sources/web3swift/Tokens/ERC1644/Web3+ERC1644.swift @@ -43,28 +43,20 @@ public class ERC1644: IERC1644, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -76,17 +68,13 @@ public class ERC1644: IERC1644, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -99,17 +87,13 @@ public class ERC1644: IERC1644, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -122,25 +106,19 @@ public class ERC1644: IERC1644, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -153,26 +131,20 @@ public class ERC1644: IERC1644, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } // ERC1644 public func isControllable() async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isControllable", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isControllable", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func controllerTransfer(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -185,17 +157,13 @@ public class ERC1644: IERC1644, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("controllerTransfer", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("controllerTransfer", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func controllerRedeem(from: EthereumAddress, tokenHolder: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -208,7 +176,19 @@ public class ERC1644: IERC1644, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("controllerRedeem", parameters: [tokenHolder, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("controllerRedeem", parameters: [tokenHolder, value, data, operatorData] as [AnyObject])! return tx } } + +// MARK: - Private + +extension ERC1644 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC20/Web3+ERC20.swift b/Sources/web3swift/Tokens/ERC20/Web3+ERC20.swift index d1aeba7ea..36ea8c26f 100644 --- a/Sources/web3swift/Tokens/ERC20/Web3+ERC20.swift +++ b/Sources/web3swift/Tokens/ERC20/Web3+ERC20.swift @@ -42,30 +42,25 @@ public class ERC20: IERC20, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest let result = try await contract - .createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )! + .createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())! .callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest let result = try await contract - .createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )! + .createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())! .callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract self.transaction.from = from self.transaction.to = self.address - self.transaction.callOnBlock = .latest + transaction.callOnBlock = .latest // get the decimals manually let callResult = try await contract @@ -80,15 +75,15 @@ public class ERC20: IERC20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + contract.transaction = transaction + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract self.transaction.from = from self.transaction.to = self.address - self.transaction.callOnBlock = .latest + transaction.callOnBlock = .latest // get the decimals manually let callResult = try await contract @@ -103,16 +98,15 @@ public class ERC20: IERC20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + contract.transaction = transaction + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract self.transaction.from = from self.transaction.to = self.address - self.transaction.callOnBlock = .latest + transaction.callOnBlock = .latest // get the decimals manually let callResult = try await contract @@ -127,16 +121,15 @@ public class ERC20: IERC20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(newAmount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + contract.transaction = transaction + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract self.transaction.from = from self.transaction.to = self.address - self.transaction.callOnBlock = .latest + transaction.callOnBlock = .latest // get the decimals manually let callResult = try await contract @@ -151,16 +144,14 @@ public class ERC20: IERC20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + contract.transaction = transaction + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest let result = try await contract - .createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )! + .createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())! .callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res diff --git a/Sources/web3swift/Tokens/ERC721/Web3+ERC721.swift b/Sources/web3swift/Tokens/ERC721/Web3+ERC721.swift index 9a5887eab..a946b2deb 100644 --- a/Sources/web3swift/Tokens/ERC721/Web3+ERC721.swift +++ b/Sources/web3swift/Tokens/ERC721/Web3+ERC721.swift @@ -85,13 +85,10 @@ public class ERC721: IERC721 { } public func readProperties() async throws { - if self._hasReadProperties { return } - let contract = self.contract guard contract.contract.address != nil else {return} - self.transaction.callOnBlock = .latest async let tokenIdPromise = contract.createReadOperation("tokenId", parameters: [AnyObject](), extraData: Data())?.callContractMethod() @@ -104,152 +101,128 @@ public class ERC721: IERC721 { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getOwner(tokenId: BigUInt) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("ownerOf", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("ownerOf", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getApproved(tokenId: BigUInt) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getApproved", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getApproved", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject])! return tx } public func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject])! return tx } public func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt, data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, data] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, data] as [AnyObject])! return tx } public func approve(from: EthereumAddress, approved: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("approve", parameters: [approved, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("approve", parameters: [approved, tokenId] as [AnyObject])! return tx } public func setApprovalForAll(from: EthereumAddress, operator user: EthereumAddress, approved: Bool) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved] as [AnyObject])! return tx } public func isApprovedForAll(owner: EthereumAddress, operator user: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } +// MARK: - Private + +extension ERC721 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} + +// MARK: - IERC721Enumerable + extension ERC721: IERC721Enumerable { public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func tokenByIndex(index: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenByIndex", parameters: [index] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("tokenByIndex", parameters: [index] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func tokenOfOwnerByIndex(owner: EthereumAddress, index: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenOfOwnerByIndex", parameters: [owner, index] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("tokenOfOwnerByIndex", parameters: [owner, index] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } +// MARK: - IERC721Metadata + // FIXME: Rewrite this to CodableTransaction extension ERC721: IERC721Metadata { public func name() async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("name", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("name", parameters: [AnyObject](), extraData: Data())!.callContractMethod() 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 } public func symbol() async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("symbol", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("symbol", parameters: [AnyObject](), extraData: Data())!.callContractMethod() 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 } public func tokenURI(tokenId: BigUInt) async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() 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 } diff --git a/Sources/web3swift/Tokens/ERC721x/Web3+ERC721x.swift b/Sources/web3swift/Tokens/ERC721x/Web3+ERC721x.swift index 7285b48c9..b7f839287 100644 --- a/Sources/web3swift/Tokens/ERC721x/Web3+ERC721x.swift +++ b/Sources/web3swift/Tokens/ERC721x/Web3+ERC721x.swift @@ -73,9 +73,8 @@ public class ERC721x: IERC721x { if self._hasReadProperties { return } - let contract = self.contract guard contract.contract.address != nil else {return} - self.transaction.callOnBlock = .latest + transaction.callOnBlock = .latest guard let tokenIdPromise = try await contract.createReadOperation("tokenId", parameters: [] as [AnyObject], extraData: Data())?.callContractMethod() else {return} @@ -86,213 +85,178 @@ public class ERC721x: IERC721x { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getOwner(tokenId: BigUInt) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("ownerOf", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("ownerOf", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getApproved(tokenId: BigUInt) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getApproved", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("getApproved", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject])! return tx } public func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId] as [AnyObject])! return tx } public func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt, data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, data] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, data] as [AnyObject])! return tx } public func approve(from: EthereumAddress, approved: EthereumAddress, tokenId: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("approve", parameters: [approved, tokenId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("approve", parameters: [approved, tokenId] as [AnyObject])! return tx } public func setApprovalForAll(from: EthereumAddress, operator user: EthereumAddress, approved: Bool) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setApprovalForAll", parameters: [user, approved] as [AnyObject])! return tx } public func isApprovedForAll(owner: EthereumAddress, operator user: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("isApprovedForAll", parameters: [owner, user] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func tokenByIndex(index: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenByIndex", parameters: [index] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("tokenByIndex", parameters: [index] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func tokenOfOwnerByIndex(owner: EthereumAddress, index: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenOfOwnerByIndex", parameters: [owner, index] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("tokenOfOwnerByIndex", parameters: [owner, index] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func name() async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("name", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("name", parameters: [AnyObject](), extraData: Data())!.callContractMethod() 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 } public func symbol() async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("symbol", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("symbol", parameters: [AnyObject](), extraData: Data())!.callContractMethod() 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 } public func tokenURI(tokenId: BigUInt) async throws -> String { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("tokenURI", parameters: [tokenId] as [AnyObject], extraData: Data())!.callContractMethod() 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 } func implementsERC721X() async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("implementsERC721X", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("implementsERC721X", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func getBalance(account: EthereumAddress, tokenId: BigUInt) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account, tokenId] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("balanceOf", parameters: [account, tokenId] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func tokensOwned(account: EthereumAddress) async throws -> ([BigUInt], [BigUInt]) { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokensOwned", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + transaction.callOnBlock = .latest + let result = try await contract.createReadOperation("tokensOwned", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? ([BigUInt], [BigUInt]) else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func transfer(from: EthereumAddress, to: EthereumAddress, tokenId: BigUInt, quantity: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId, quantity] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transfer", parameters: [to, tokenId, quantity] as [AnyObject])! return tx } func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt, quantity: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId, quantity] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, tokenId, quantity] as [AnyObject])! return tx } func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt, amount: BigUInt) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, amount] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, amount] as [AnyObject])! return tx } func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenId: BigUInt, amount: BigUInt, data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, amount, data] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenId, amount, data] as [AnyObject])! return tx } func safeTransferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, tokenIds: [BigUInt], amounts: [BigUInt], data: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenIds, amounts, data] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("safeTransferFrom", parameters: [originalOwner, to, tokenIds, amounts, data] as [AnyObject])! return tx } } + +// MARK: - Private + +extension ERC721x { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ERC777/Web3+ERC777.swift b/Sources/web3swift/Tokens/ERC777/Web3+ERC777.swift index 4ef3be52f..3af0acdef 100644 --- a/Sources/web3swift/Tokens/ERC777/Web3+ERC777.swift +++ b/Sources/web3swift/Tokens/ERC777/Web3+ERC777.swift @@ -57,43 +57,32 @@ public class ERC777: IERC777, ERC20BaseProperties { } public func getGranularity() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("granularity", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getDefaultOperators() async throws -> [EthereumAddress] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("defaultOperators", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [EthereumAddress] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -105,16 +94,13 @@ public class ERC777: IERC777, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -127,16 +113,13 @@ public class ERC777: IERC777, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -149,53 +132,40 @@ public class ERC777: IERC777, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } // ERC777 methods public func authorize(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("authorizeOperator", parameters: [user] as [AnyObject])! return tx } public func revoke(from: EthereumAddress, operator user: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - - let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject] )! + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("revokeOperator", parameters: [user] as [AnyObject])! return tx } public func isOperatorFor(operator user: EthereumAddress, tokenHolder: EthereumAddress) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("isOperatorFor", parameters: [user, tokenHolder] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func send(from: EthereumAddress, to: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -207,16 +177,13 @@ public class ERC777: IERC777, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("send", parameters: [to, value, data] as [AnyObject])! return tx } public func operatorSend(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -228,16 +195,13 @@ public class ERC777: IERC777, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("operatorSend", parameters: [originalOwner, to, value, data, operatorData] as [AnyObject])! return tx } public func burn(from: EthereumAddress, amount: String, data: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -249,16 +213,13 @@ public class ERC777: IERC777, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [value, data] as [AnyObject])! return tx } public func operatorBurn(from: EthereumAddress, amount: String, originalOwner: EthereumAddress, data: [UInt8], operatorData: [UInt8]) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -270,67 +231,50 @@ public class ERC777: IERC777, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [originalOwner, value, data, operatorData] as [AnyObject])! return tx } public func canImplementInterfaceForAddress(interfaceHash: Data, addr: EthereumAddress) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("canImplementInterfaceForAddress", parameters: [interfaceHash, addr] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getInterfaceImplementer(addr: EthereumAddress, interfaceHash: Data) async throws -> EthereumAddress { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("getInterfaceImplementer", parameters: [addr, interfaceHash] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func setInterfaceImplementer(from: EthereumAddress, addr: EthereumAddress, interfaceHash: Data, implementer: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setInterfaceImplementer", parameters: [addr, interfaceHash, implementer] as [AnyObject])! return tx } public func setManager(from: EthereumAddress, addr: EthereumAddress, newManager: EthereumAddress) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = contract.createWriteOperation("setManager", parameters: [addr, newManager] as [AnyObject])! return tx } public func interfaceHash(interfaceName: String) async throws -> Data { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("interfaceHash", parameters: [interfaceName] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Data else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } + // FIXME: might want to rename contract param here public func updateERC165Cache(from: EthereumAddress, contract: EthereumAddress, interfaceId: [UInt8]) throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - - let tx = contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject] )! + updateTransactionAndContract(from: from) + let tx = self.contract.createWriteOperation("updateERC165Cache", parameters: [contract, interfaceId] as [AnyObject])! return tx } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -343,16 +287,27 @@ public class ERC777: IERC777, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } public func supportsInterface(interfaceID: String) async throws -> Bool { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ERC777 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} + diff --git a/Sources/web3swift/Tokens/ERC888/Web3+ERC888.swift b/Sources/web3swift/Tokens/ERC888/Web3+ERC888.swift index 46a0dc8f0..65d472e54 100644 --- a/Sources/web3swift/Tokens/ERC888/Web3+ERC888.swift +++ b/Sources/web3swift/Tokens/ERC888/Web3+ERC888.swift @@ -39,31 +39,27 @@ public class ERC888: IERC888, ERC20BaseProperties { } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.from = from + transaction.to = address + transaction.callOnBlock = .latest + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) guard let dec = callResult["0"], let decTyped = dec as? BigUInt else { throw Web3Error.inputError(desc: "Contract may be not ERC20 compatible, can not get decimals")} decimals = decTyped - let intDecimals = Int(decimals) guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } diff --git a/Sources/web3swift/Tokens/ST20/Web3+ST20.swift b/Sources/web3swift/Tokens/ST20/Web3+ST20.swift index 71097eb27..c6da4b9c6 100644 --- a/Sources/web3swift/Tokens/ST20/Web3+ST20.swift +++ b/Sources/web3swift/Tokens/ST20/Web3+ST20.swift @@ -50,20 +50,14 @@ public class ST20: IST20, ERC20BaseProperties { } func tokenDetails() async throws -> [UInt32] { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("tokenDetails", parameters: [] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("tokenDetails", parameters: [] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? [UInt32] else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } func verifyTransfer(from: EthereumAddress, originalOwner: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -76,17 +70,13 @@ public class ST20: IST20, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("verifyTransfer", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("verifyTransfer", parameters: [originalOwner, to, value] as [AnyObject])! return tx } func mint(from: EthereumAddress, investor: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -99,17 +89,13 @@ public class ST20: IST20, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("mint", parameters: [investor, value] as [AnyObject] )! + let tx = contract.createWriteOperation("mint", parameters: [investor, value] as [AnyObject])! return tx } public func burn(from: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -121,33 +107,25 @@ public class ST20: IST20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("burn", parameters: [value] as [AnyObject] )! + let tx = contract.createWriteOperation("burn", parameters: [value] as [AnyObject])! return tx } public func getBalance(account: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("balanceOf", parameters: [account] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func getAllowance(originalOwner: EthereumAddress, delegate: EthereumAddress) async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("allowance", parameters: [originalOwner, delegate] as [AnyObject], extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } public func transfer(from: EthereumAddress, to: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -159,17 +137,13 @@ public class ST20: IST20, ERC20BaseProperties { guard let value = Utilities.parseToBigUInt(amount, decimals: intDecimals) else { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transfer", parameters: [to, value] as [AnyObject])! return tx } public func transferFrom(from: EthereumAddress, to: EthereumAddress, originalOwner: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -182,17 +156,13 @@ public class ST20: IST20, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("transferFrom", parameters: [originalOwner, to, value] as [AnyObject])! return tx } public func setAllowance(from: EthereumAddress, to: EthereumAddress, newAmount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -205,17 +175,13 @@ public class ST20: IST20, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject] )! + let tx = contract.createWriteOperation("setAllowance", parameters: [to, value] as [AnyObject])! return tx } public func approve(from: EthereumAddress, spender: EthereumAddress, amount: String) async throws -> WriteOperation { - let contract = self.contract - - self.transaction.from = from - self.transaction.to = self.address - self.transaction.callOnBlock = .latest - + transaction.callOnBlock = .latest + updateTransactionAndContract(from: from) // get the decimals manually let callResult = try await contract.createReadOperation("decimals" )!.callContractMethod() var decimals = BigUInt(0) @@ -228,16 +194,26 @@ public class ST20: IST20, ERC20BaseProperties { throw Web3Error.inputError(desc: "Can not parse inputted amount") } - let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject] )! + let tx = contract.createWriteOperation("approve", parameters: [spender, value] as [AnyObject])! return tx } public func totalSupply() async throws -> BigUInt { - let contract = self.contract - self.transaction.callOnBlock = .latest - let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data() )!.callContractMethod() + let result = try await contract.createReadOperation("totalSupply", parameters: [AnyObject](), extraData: Data())!.callContractMethod() guard let res = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")} return res } } + +// MARK: - Private + +extension ST20 { + + private func updateTransactionAndContract(from: EthereumAddress) { + transaction.from = from + transaction.to = address + contract.transaction = transaction + } + +} diff --git a/Sources/web3swift/Tokens/ST20/Web3+SecurityToken.swift b/Sources/web3swift/Tokens/ST20/Web3+SecurityToken.swift index a7670f124..087e42768 100644 --- a/Sources/web3swift/Tokens/ST20/Web3+SecurityToken.swift +++ b/Sources/web3swift/Tokens/ST20/Web3+SecurityToken.swift @@ -100,7 +100,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -119,7 +119,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -138,7 +138,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -171,7 +171,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -190,7 +190,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -209,7 +209,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -228,7 +228,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest - + contract.transaction = transaction // get the decimals manually let callResult = try await contract.createReadOperation("decimals")!.callContractMethod() var decimals = BigUInt(0) @@ -254,6 +254,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest + contract.transaction = transaction return contract.createWriteOperation("renounceOwnership", parameters: [AnyObject]() )! } @@ -261,6 +262,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest + contract.transaction = transaction return contract.createWriteOperation("transferOwnership", parameters: [newOwner] as [AnyObject])! } @@ -333,6 +335,7 @@ public class SecurityToken: ISecurityToken, ERC20BaseProperties { transaction.from = from transaction.to = self.address transaction.callOnBlock = .latest + contract.transaction = transaction return contract.createWriteOperation("createCheckpoint", parameters: [AnyObject]() )! } diff --git a/Sources/web3swift/Utils/ENS/ENSBaseRegistrar.swift b/Sources/web3swift/Utils/ENS/ENSBaseRegistrar.swift index 744ffa61b..6158b941e 100644 --- a/Sources/web3swift/Utils/ENS/ENSBaseRegistrar.swift +++ b/Sources/web3swift/Utils/ENS/ENSBaseRegistrar.swift @@ -36,7 +36,7 @@ public extension ENS { public func addController(from: EthereumAddress, controllerAddress: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("addController", parameters: [controllerAddress as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("addController", parameters: [controllerAddress as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } @@ -44,7 +44,7 @@ public extension ENS { public func removeController(from: EthereumAddress, controllerAddress: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("removeController", parameters: [controllerAddress as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("removeController", parameters: [controllerAddress as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } @@ -52,12 +52,12 @@ public extension ENS { public func setResolver(from: EthereumAddress, resolverAddress: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("setResolver", parameters: [resolverAddress as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("setResolver", parameters: [resolverAddress as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } public func getNameExpirity(name: BigUInt) async throws -> BigUInt { - guard let transaction = self.contract.createReadOperation("nameExpires", parameters: [name as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("nameExpires", parameters: [name as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let expirity = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Can't get answer")} return expirity @@ -65,7 +65,7 @@ public extension ENS { @available(*, message: "This function should not be used to check if a name can be registered by a user. To check if a name can be registered by a user, check name availablility via the controller") public func isNameAvailable(name: BigUInt) async throws -> Bool { - guard let transaction = self.contract.createReadOperation("available", parameters: [name as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("available", parameters: [name as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let available = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Can't get answer")} return available @@ -74,7 +74,7 @@ public extension ENS { public func reclaim(from: EthereumAddress, record: BigUInt) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("reclaim", parameters: [record as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("reclaim", parameters: [record as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } diff --git a/Sources/web3swift/Utils/ENS/ENSRegistry.swift b/Sources/web3swift/Utils/ENS/ENSRegistry.swift index 587684eb8..a75f09389 100644 --- a/Sources/web3swift/Utils/ENS/ENSRegistry.swift +++ b/Sources/web3swift/Utils/ENS/ENSRegistry.swift @@ -48,7 +48,7 @@ public extension ENS { public func getOwner(node: String) async throws -> EthereumAddress { guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createReadOperation("owner", parameters: [nameHash as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createReadOperation("owner", parameters: [nameHash as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let address = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "No address in result")} return address @@ -56,7 +56,7 @@ public extension ENS { public func getResolver(forDomain domain: String) async throws -> Resolver { guard let nameHash = NameHash.nameHash(domain) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createReadOperation("resolver", parameters: [nameHash as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createReadOperation("resolver", parameters: [nameHash as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let resolverAddress = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "No address in result")} return Resolver(web3: self.web3, resolverContractAddress: resolverAddress) @@ -64,7 +64,7 @@ public extension ENS { public func getTTL(node: String) async throws -> BigUInt { guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createReadOperation("ttl", parameters: [nameHash as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createReadOperation("ttl", parameters: [nameHash as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let ans = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "No answer in result")} return ans @@ -77,7 +77,7 @@ public extension ENS { options.to = contractAddress } guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createWriteOperation("setOwner", parameters: [nameHash, owner] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createWriteOperation("setOwner", parameters: [nameHash, owner] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.writeToChain(password: password) else {throw Web3Error.processingError(desc: "Can't send transaction")} return result } @@ -90,7 +90,7 @@ public extension ENS { } guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} guard let labelHash = NameHash.nameHash(label) else {throw Web3Error.processingError(desc: "Failed to get label hash")} - guard let transaction = self.registryContract.createWriteOperation("setSubnodeOwner", parameters: [nameHash, labelHash, owner] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createWriteOperation("setSubnodeOwner", parameters: [nameHash, labelHash, owner] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.writeToChain(password: password) else {throw Web3Error.processingError(desc: "Can't send transaction")} return result } @@ -102,7 +102,7 @@ public extension ENS { options.to = contractAddress } guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createWriteOperation("setResolver", parameters: [nameHash, resolver] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createWriteOperation("setResolver", parameters: [nameHash, resolver] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.writeToChain(password: password) else {throw Web3Error.processingError(desc: "Can't send transaction")} return result } @@ -114,7 +114,7 @@ public extension ENS { options.to = contractAddress } guard let nameHash = NameHash.nameHash(node) else {throw Web3Error.processingError(desc: "Failed to get name hash")} - guard let transaction = self.registryContract.createWriteOperation("setTTL", parameters: [nameHash, ttl] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.registryContract.createWriteOperation("setTTL", parameters: [nameHash, ttl] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.writeToChain(password: password) else {throw Web3Error.processingError(desc: "Can't send transaction")} return result } diff --git a/Sources/web3swift/Utils/ENS/ENSReverseRegistrar.swift b/Sources/web3swift/Utils/ENS/ENSReverseRegistrar.swift index 1ba0baa24..c65b4f667 100644 --- a/Sources/web3swift/Utils/ENS/ENSReverseRegistrar.swift +++ b/Sources/web3swift/Utils/ENS/ENSReverseRegistrar.swift @@ -33,33 +33,33 @@ public extension ENS { public func claimAddress(from: EthereumAddress, owner: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("claim", parameters: [owner as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("claim", parameters: [owner as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } public func claimAddressWithResolver(from: EthereumAddress, owner: EthereumAddress, resolver: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("claimWithResolver", parameters: [owner, resolver] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("claimWithResolver", parameters: [owner, resolver] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } public func setName(from: EthereumAddress, name: String) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("setName", parameters: [name] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("setName", parameters: [name] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } public func getReverseRecordName(address: EthereumAddress) async throws -> Data { - guard let transaction = self.contract.createReadOperation("node", parameters: [address] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("node", parameters: [address] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let name = result["0"] as? Data else {throw Web3Error.processingError(desc: "Can't get answer")} return name } public func getDefaultResolver() async throws -> EthereumAddress { - guard let transaction = self.contract.createReadOperation("defaultResolver", parameters: [] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("defaultResolver", parameters: [] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let address = result["0"] as? EthereumAddress else {throw Web3Error.processingError(desc: "Can't get answer")} return address diff --git a/Sources/web3swift/Utils/ENS/ETHRegistrarController.swift b/Sources/web3swift/Utils/ENS/ETHRegistrarController.swift index f684e3692..1003c4f66 100644 --- a/Sources/web3swift/Utils/ENS/ETHRegistrarController.swift +++ b/Sources/web3swift/Utils/ENS/ETHRegistrarController.swift @@ -31,28 +31,28 @@ public extension ENS { } public func getRentPrice(name: String, duration: UInt) async throws -> BigUInt { - guard let transaction = self.contract.createReadOperation("rentPrice", parameters: [name, duration] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("rentPrice", parameters: [name, duration] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let price = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Can't get answer")} return price } public func checkNameValidity(name: String) async throws -> Bool { - guard let transaction = self.contract.createReadOperation("valid", parameters: [name] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("valid", parameters: [name] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let valid = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Can't get answer")} return valid } public func isNameAvailable(name: String) async throws -> Bool { - guard let transaction = self.contract.createReadOperation("available", parameters: [name as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("available", parameters: [name as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let available = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Can't get answer")} return available } public func calculateCommitmentHash(name: String, owner: EthereumAddress, secret: String) async throws -> Data { - guard let transaction = self.contract.createReadOperation("makeCommitment", parameters: [name, owner.address, secret] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createReadOperation("makeCommitment", parameters: [name, owner.address, secret] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} guard let result = try? await transaction.callContractMethod() else {throw Web3Error.processingError(desc: "Can't call transaction")} guard let hash = result["0"] as? Data else {throw Web3Error.processingError(desc: "Can't get answer")} return hash @@ -61,7 +61,7 @@ public extension ENS { public func sumbitCommitment(from: EthereumAddress, commitment: Data) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("commit", parameters: [commitment as AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("commit", parameters: [commitment as AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } @@ -70,7 +70,7 @@ public extension ENS { defaultOptions.value = amount defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("register", parameters: [name, owner.address, duration, secret] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("register", parameters: [name, owner.address, duration, secret] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } @@ -79,7 +79,7 @@ public extension ENS { defaultOptions.value = amount defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("renew", parameters: [name, duration] as [AnyObject], extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("renew", parameters: [name, duration] as [AnyObject], extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } @@ -87,7 +87,7 @@ public extension ENS { public func withdraw(from: EthereumAddress) throws -> WriteOperation { defaultOptions.from = from defaultOptions.to = self.address - guard let transaction = self.contract.createWriteOperation("withdraw", parameters: [AnyObject](), extraData: Data() ) else {throw Web3Error.transactionSerializationError} + guard let transaction = self.contract.createWriteOperation("withdraw", parameters: [AnyObject](), extraData: Data()) else {throw Web3Error.transactionSerializationError} return transaction } } diff --git a/Tests/web3swiftTests/localTests/AdvancedABIv2Tests.swift b/Tests/web3swiftTests/localTests/AdvancedABIv2Tests.swift index 1be8abb35..f9bc88ef2 100755 --- a/Tests/web3swiftTests/localTests/AdvancedABIv2Tests.swift +++ b/Tests/web3swiftTests/localTests/AdvancedABIv2Tests.swift @@ -44,8 +44,7 @@ class AdvancedABIv2Tests: LocalTestCase { // MARK: Read data from ABI flow // MARK: - Encoding ABI Data flow let tx = contract.createReadOperation("testSingle") - let testSingle = try await tx!.callContractMethod() - + let _ = try await tx!.callContractMethod() } func testAdvancedABIv2staticArray() async throws { @@ -80,8 +79,7 @@ class AdvancedABIv2Tests: LocalTestCase { // MARK: Read data from ABI flow // MARK: - Encoding ABI Data flow let tx = contract.createReadOperation("testStaticArray") - let testStaticArray = try await tx!.callContractMethod() - + let _ = try await tx!.callContractMethod() } func testAdvancedABIv2dynamicArray() async throws { @@ -115,8 +113,7 @@ class AdvancedABIv2Tests: LocalTestCase { contract = web3.contract(abiString, at: receipt.contractAddress, abiVersion: 2)! let tx = contract.createReadOperation("testDynArray") - let testDynArray = try await tx!.callContractMethod() - + let _ = try await tx!.callContractMethod() } func testAdvancedABIv2dynamicArrayOfStrings() async throws { @@ -151,8 +148,7 @@ class AdvancedABIv2Tests: LocalTestCase { // MARK: Read data from ABI flow // MARK: - Encoding ABI Data flow let tx = contract.createReadOperation("testDynOfDyn") - let testDynOfDyn = try await tx!.callContractMethod() - + let _ = try await tx!.callContractMethod() } func testAdvancedABIv2staticArrayOfStrings() async throws { @@ -187,8 +183,7 @@ class AdvancedABIv2Tests: LocalTestCase { // MARK: Read data from ABI flow // MARK: - Encoding ABI Data flow let tx = contract.createReadOperation("testStOfDyn") - let testStOfDyn = try await tx!.callContractMethod() - + let _ = try await tx!.callContractMethod() } func testEmptyArrayDecoding() async throws { diff --git a/Tests/web3swiftTests/localTests/PersonalSignatureTests.swift b/Tests/web3swiftTests/localTests/PersonalSignatureTests.swift index 141b23b0d..852137efd 100755 --- a/Tests/web3swiftTests/localTests/PersonalSignatureTests.swift +++ b/Tests/web3swiftTests/localTests/PersonalSignatureTests.swift @@ -44,8 +44,7 @@ class PersonalSignatureTests: XCTestCase { Thread.sleep(forTimeInterval: 1.0) let receipt = try await web3.eth.transactionReceipt(txHash) - - + switch receipt.status { case .notYetProcessed: return