从另一个合约发送 ERC-20 代币
Posted
技术标签:
【中文标题】从另一个合约发送 ERC-20 代币【英文标题】：Send ERC-20 token from another contract 【发布时间】：2018-12-28 17:43:26 【问题描述】：我正在尝试将存入我的合约地址的 ERC-20 代币发送到另一个地址。这是 ERC-20 合约代码 -
pragma solidity ^0.4.11;
/**
* Math operations with safety checks
*/
library SafeMath
function mul(uint a, uint b) internal returns (uint)
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
function div(uint a, uint b) internal returns (uint)
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
function sub(uint a, uint b) internal returns (uint)
assert(b <= a);
return a - b;
function add(uint a, uint b) internal returns (uint)
uint c = a + b;
assert(c >= a);
return c;
function max64(uint64 a, uint64 b) internal constant returns (uint64)
return a >= b ? a : b;
function min64(uint64 a, uint64 b) internal constant returns (uint64)
return a < b ? a : b;
function max256(uint256 a, uint256 b) internal constant returns (uint256)
return a >= b ? a : b;
function min256(uint256 a, uint256 b) internal constant returns (uint256)
return a < b ? a : b;
function assert(bool assertion) internal
if (!assertion)
throw;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Basic
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic
using SafeMath for uint;
mapping(address => uint) balances;
/**
* @dev Fix for the ERC20 short address attack.
*/
modifier onlyPayloadSize(uint size)
if(msg.data.length < size + 4)
throw;
_;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint balance)
return balances[_owner];
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is BasicToken, ERC20
mapping (address => mapping (address => uint)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32)
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
/**
* @dev Aprove the passed address to spend the specified amount of tokens on beahlf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint _value)
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
/**
* @dev Function to check the amount of tokens than an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint remaining)
return allowed[_owner][_spender];
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable()
owner = msg.sender;
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner()
if (msg.sender != owner)
throw;
_;
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner
if (newOwner != address(0))
owner = newOwner;
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable
event Mint(address indexed to, uint value);
event MintFinished();
bool public mintingFinished = false;
uint public totalSupply = 0;
modifier canMint()
if(mintingFinished) throw;
_;
/**
* @dev Function to mint tokens
* @param _to The address that will recieve the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint _amount) onlyOwner canMint returns (bool)
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner returns (bool)
mintingFinished = true;
MintFinished();
return true;
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev modifier to allow actions only when the contract IS paused
*/
modifier whenNotPaused()
if (paused) throw;
_;
/**
* @dev modifier to allow actions only when the contract IS NOT paused
*/
modifier whenPaused
if (!paused) throw;
_;
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused returns (bool)
paused = true;
Pause();
return true;
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused returns (bool)
paused = false;
Unpause();
return true;
/**
* Pausable token
*
* Simple ERC20 Token example, with pausable token creation
**/
contract PausableToken is StandardToken, Pausable
function transfer(address _to, uint _value) whenNotPaused
super.transfer(_to, _value);
function transferFrom(address _from, address _to, uint _value) whenNotPaused
super.transferFrom(_from, _to, _value);
/**
* @title TokenTimelock
* @dev TokenTimelock is a token holder contract that will allow a
* beneficiary to extract the tokens after a time has passed
*/
contract TokenTimelock
// ERC20 basic token contract being held
ERC20Basic token;
// beneficiary of tokens after they are released
address beneficiary;
// timestamp where token release is enabled
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime)
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
/**
* @dev beneficiary claims tokens held by time lock
*/
function claim()
require(msg.sender == beneficiary);
require(now >= releaseTime);
uint amount = token.balanceOf(this);
require(amount > 0);
token.transfer(beneficiary, amount);
contract TestToken is PausableToken, MintableToken
using SafeMath for uint256;
string public name = "TestToken";
string public symbol = "TT";
uint public decimals = 18;
/**
* @dev mint timelocked tokens
*/
function mintTimelocked(address _to, uint256 _amount, uint256 _releaseTime)
onlyOwner canMint returns (TokenTimelock)
TokenTimelock timelock = new TokenTimelock(this, _to, _releaseTime);
mint(timelock, _amount);
return timelock;
以下是我尝试发送存入代币的合同 -
pragma solidity ^0.4.18;
contract ERC20Interface
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) public returns (bool success);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) public constant returns (uint256 balance);
/**
* Contract that will forward any incoming Ether to the creator of the contract
*/
contract Forwarder
// Address to which any funds sent to this contract will be forwarded
address public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
/**
* Create the contract, and sets the destination address to that of the creator
*/
function Forwarder() public
parentAddress = msg.sender;
/**
* Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent
if (msg.sender != parentAddress)
revert();
_;
/**
* Default function; Gets called when Ether is deposited, and forwards it to the parent address
*/
function() public payable
// throws on failure
parentAddress.transfer(msg.value);
// Fire off the deposited event if we can forward it
ForwarderDeposited(msg.sender, msg.value, msg.data);
/**
* Execute a token transfer of the full balance from the forwarder token to the parent address
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushTokens(address tokenContractAddress) public onlyParent
ERC20Interface instance = ERC20Interface(tokenContractAddress);
var forwarderAddress = address(this);
var forwarderBalance = instance.balanceOf(forwarderAddress);
if (forwarderBalance == 0)
return;
if (!instance.transfer(parentAddress, forwarderBalance))
revert();
当我调用 flushToken 函数时，我收到一个错误 - 错误：所需气体超过限额或交易总是失败。
【问题讨论】：
【参考方案1】：为了将代币从一个地址转移到另一个地址，您首先需要批准交易。
function approve(address spender, uint tokens) public returns (bool success);
那是您批准第二份合同可以从第一份合同中转移资金。 您可以使用此功能检查津贴
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
【讨论】：
要批准我需要有权调用该函数，即我必须是代币合约的所有者。如果我不是怎么办？此外，传递函数没有验证是否有任何设定的限额。以上是关于从另一个合约发送 ERC-20 代币的主要内容，如果未能解决你的问题，请参考以下文章