I assume you are using Web3j and a deployed smart contract implementing ERC20 interface, where transfer method looks like this:
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value && _value > 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
You can use web3j wrapper for your contract to call contract methods on a blockahain. Suppose your Contract filname is MyContract.sol
, then you'll need solc compiler and web3j tool and do the following in your console:
$ solc {contract}.sol --bin --abi --optimize -o {output-dir}/
this will generate .abi
and .bin
files from which you generate a java wrapper class:
$ web3j solidity generate /path/to/<smart-contract>.bin /path/to/<smart-contract>.abi -o /path/to/src/main/java -p com.your.organisation.name
This will produce a java wrapper class for your contract like MyContract.java
on which you can call all the methods available on the smart contract:
import static org.web3j.tx.Contract.GAS_LIMIT;
import static org.web3j.tx.ManagedTransaction.GAS_PRICE;
//web3j initialization code goes here
//Load the deployed contract:
MyContract contract = MyContract.load(contractAddress, web3j, credentials, GAS_PRICE, GAS_LIMIT);
//Call methods on the contract:
Future<> result = contract.transfer(_to, _value);
You can find more info on how to work with smart contracts wrappers here. Hope that helps.
edit.
abi
and bin
for this particular contract can be obtained from etherscan.io
You can transfer tokens even if you are not the owner of the contract. But you are only abe to transfer tokens available to your own account as seen in the contract:
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
Best Answer
tx.origin
vsmsg.sender
:msg.sender
- the address of the direct caller (can be contract or externally owned account)tx.origin
- the address of the caller the transaction originates from (always an externally owned account).It is best practice to not use
tx.origin
unless you really need to know the origin.You should not use
tx.origin
for verification as that would expose you to potential attacks (tx.origin attack). The example in the Solidity docs is outdated and can't be reproduced with.transfer()
anymore but there are ways around it.Transfer ERC20 from A to B:
In order to transfer tokens from account A to account B using Contract C you would need to do the following:
From A call the ERC20 function
approve(address _spender, uint256 _value)
and pass the address of C as spender, plus the amount he is allowed to send. This would tell the Token Contract that your contract C is allowed to transfer the specified amount from your address A.From C call the ERC20 function
transferFrom(address _from, address _to, uint256 _value)
. Passing infrom: A.address
andto: B.address