以太坊开发(十三)代币示例及讲解

原文:Go-Ethereum 1.7.2 结合 Mist 0.9.2 实现代币智能合约的实例
作者:迦壹

(注:本文是在原文的基础上,根据个人的理解,修改部分内容并添加了一些注释)

基础版的代币合约

下面是一个最简单的代币合约代码,主要介绍可以看注释:

pragma solidity 0.4.20;

/**
 * @title 基础版的代币合约
 */
contract token {
    
    /* 公共变量 */
    string public standard = "https://mshk.top";
    
    /*记录所有余额的映射*/
    mapping (address => uint256) public balanceOf;
    
    /* 初始化合约,并且把初始的所有代币都给这合约的创建者
     * @param initialSupply 代币的总数
     */
    function token (uint256 initialSupply) public {
        balanceOf[msg.sender] = initialSupply;
    }
    
    /**
     * 私有方法从一个帐户发送给另一个帐户代币
     * @param  from address 发送代币的地址
     * @param  to address 接受代币的地址
     * @param  value uint256 接受代币的数量
     */
    function _transfer (address from, address to, uint256 value) internal {
        
        //避免转帐的地址是0x0
        require(to != 0x0);
        
        //检查发送者是否拥有足够余额
        require(balanceOf[from] >= value);
        
        //检查是否溢出
        require(balanceOf[to] + value > balanceOf[to]);
        
        //保存数据用于后面的判断
        uint previousBalances = balanceOf[from] + balanceOf[to];
        
        //从发送者减掉发送额
        balanceOf[from] -= value;
        
        //给接收者加上相同的量
        balanceOf[to] += value;
        
        //判断买、卖双方的数据是否和转换前一致
        assert(balanceOf[from] + balanceOf[to] == previousBalances);
    }
    
    /**
     * 从主帐户合约调用者发送给别人代币
     * @param  to address 接受代币的地址
     * @param  value uint256 接受代币的数量
     */
    function transfer (address to, uint256 value) public {
        _transfer(msg.sender, to, value);
    }
}

接下来我们将上面的合约代码,通过Mist部署到我们的私有链

首先如下图中,点击合约->部署新合约

然后如下面的两张图,选择创建合约的帐户,将上面的代码贴到SOLIDITY合约原始代码处,在右侧选择要部署的合约token,在token的下面Initial Supply处,输入我们要初始化的金额5000用于奖励合约创建者,然后在页面的最下面,点击部署,的弹出的层中,输入创建合约这个帐号的密码,输入正确以后,合约创建成功。

创建一个合约以后,再点击 Mist 右侧的合约,然后在 定制化合约 的下面,可以看到我们刚刚创建的合约 TOKEN,如下图:

注意,在合约下面也有一串0x开头的地址,这个就相当于一个钱包的地址。在以太坊中,合约也相当于一个帐户。

点击 TOKEN ,进入到合约里。在下面的 Balance Of 处,输入刚才创建合约帐户的地址0xa18e688326ab13b6147ce3ca2213db143a4ec2ee,可以看到是有5000个代币在里面,如下图:

在代币创建的时候,初始值我们设置的是5000,所以只有创建帐户的地址有代币,而输入其他帐户的地址,如0xc81896af13449a82f22699311df4ec4b48c07718,是没有值的。

接下来,我们向0xc81896af13449a82f22699311df4ec4b48c07718这个帐户地址,转入一些代币。点击右侧选择函数->选择Transfer,在_to中输入0xc81896af13449a82f22699311df4ec4b48c07718,在_value中输入500,然后点击执行,在弹出的层中输入调用合约帐户的密码,确认操作。

我们能够看到实际调用合约的过程中,会花费一定的gasgas和以太币会根据区块的算力有一个计算公式,gas一般用于奖励给挖矿者。

transfer 方法中,我们设定了,只有合约的调用者msg.sender才能向指定地址转移代币。

/**
 * 从主帐户合约调用者发送给别人代币
 * @param  _to address 接受代币的地址
 * @param  _value uint256 接受代币的数量
 */
function transfer(address _to, uint256 _value) public {
    _transfer(msg.sender, _to, _value);
}

这时,再次进入合约,在Balance Of处,输入两个帐户的地址,可以看到,余额都发生的变化,如下图:

改善代币

通过上面的操作,我们已经可以将合约代码,通过 Mist 部署到我们创建的私有链中,同样如果部署到生产环境,只需要连上以太坊的网络,同样的方法也可以将你的合约,部署到生产环境中,不过要根据代码的大小,花费一些以太币。

实际使用过程中,交易的过程,需要通知到客户端,并且记录到区块中,我们可以使用event事件来指定,如下代码进行声明:

//在区块链上创建一个事件,用以通知客户端
event Transfer(address indexed from, address indexed to, uint256 value);

设置一些代币的基本信息

/* 公共变量 */
string public standard = 'https://mshk.top';
string public name; //代币名称
string public symbol; //代币符号比如'$'
uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
uint256 public totalSupply; //代币总量

某些特定的场景中,不允许某个帐户花费超过指定的上限,避免大额支出,我们可以添加一个 approve 方法,来设置一个允许支出最大金额的列表。

注:根据个人的理解,approve是其他合约调用此合约,或者是代理,例如交易所,使用你的账户时,你可以设置一个代币数量。他们只能对你设置的数量的代币进行操作,不知道这样理解是否准确。下面是一个对approve、allowance,以及后面的transferFrom的解释:

注:approve、transferFrom及allowance解释:
账户A有1000个ETH,想允许B账户随意调用100个ETH。A账户按照以下形式调用approve函数approve(B,100)。当B账户想用这100个ETH中的10个ETH给C账户时,则调用transferFrom(A, C, 10)。这时调用allowance[A][B]可以查看B账户还能够调用A账户多少个token。

mapping (address => mapping (address => uint256)) public allowance;

/**
 * 设置帐户允许支付的最大金额
 *
 * 一般在智能合约的时候,避免支付过多,造成风险
 *
 * @param _spender 帐户地址
 * @param _value 金额
 */
function approve(address _spender, uint256 _value) public returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    return true;
}

同样在 solidity 中,合约之间也可以相互调用,我们可以增加一个 approveAndCall 方法,用于在设置帐户最大支出金额后,可以做一些其他操作。

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }

/**
 * 设置帐户允许支付的最大金额
 *
 * 一般在智能合约的时候,避免支付过多,造成风险
 *
 * @param _spender 帐户地址
 * @param _value 金额
 */
function approve(address _spender, uint256 _value) public returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    return true;
}

/**
 * 设置帐户允许支付的最大金额
 *
 * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
 *
 * @param _spender 帐户地址
 * @param _value 金额
 * @param _extraData 操作的时间
 */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
}

我们可以增加一个 burn 方法,用于管理员减去指定帐户的指定金额。进行该方法操作时,通知客户端记录到区块链中。

注:代码并没有判断调用者是否为管理员。

注:代理B在调用burnFrom删除A账户余额时,也需要删除A授权给自己的可调用余额数。

//减去用户余额事件
event Burn(address indexed from, uint256 value);  

/**
 * 减少代币调用者的余额
 *
 * 操作以后是不可逆的
 *
 * @param _value 要删除的数量
 */
function burn(uint256 _value) public returns (bool success) {
    //检查帐户余额是否大于要减去的值
    require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough

    //给指定帐户减去余额
    balanceOf[msg.sender] -= _value;

    //代币问题做相应扣除
    totalSupply -= _value;

    Burn(msg.sender, _value);
    return true;
}

/**
 * 删除帐户的余额(含其他帐户)
 *
 * 删除以后是不可逆的
 *
 * @param _from 要操作的帐户地址
 * @param _value 要减去的数量
 */
function burnFrom(address _from, uint256 _value) public returns (bool success) {

    //检查帐户余额是否大于要减去的值
    require(balanceOf[_from] >= _value);

    //检查 其他帐户 的余额是否够使用
    require(_value <= allowance[_from][msg.sender]);

    //减掉代币
    balanceOf[_from] -= _value;
    allowance[_from][msg.sender] -= _value;

    //更新总量
    totalSupply -= _value;
    Burn(_from, _value);
    return true;
}

完整的代码如下:

pragma solidity 0.4.20;

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }


/**
 * @title 基础版的代币合约
 */
contract token {
    /* 公共变量 */
    string public standard = 'https://mshk.top';
    string public name; //代币名称
    string public symbol; //代币符号比如'$'
    uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
    uint256 public totalSupply; //代币总量

    /*记录所有余额的映射*/
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* 在区块链上创建一个事件,用以通知客户端*/
    event Transfer(address indexed from, address indexed to, uint256 value);  //转帐通知事件
    event Burn(address indexed from, uint256 value);  //减去用户余额事件

    /* 初始化合约,并且把初始的所有代币都给这合约的创建者
     * @param initialSupply 代币的总数
     * @param tokenName 代币名称
     * @param tokenSymbol 代币符号
     */
    function token(uint256 initialSupply, string tokenName, string tokenSymbol) public {

        //初始化总量
        totalSupply = initialSupply * 10 ** uint256(decimals);    //以太币是10^18,后面18个0,所以默认decimals是18

        //给指定帐户初始化代币总量,初始化用于奖励合约创建者
        balanceOf[msg.sender] = totalSupply;

        name = tokenName;
        symbol = tokenSymbol;

    }


    /**
     * 私有方法从一个帐户发送给另一个帐户代币
     * @param  _from address 发送代币的地址
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function _transfer(address _from, address _to, uint256 _value) internal {

      //避免转帐的地址是0x0
      require(_to != 0x0);

      //检查发送者是否拥有足够余额
      require(balanceOf[_from] >= _value);

      //检查是否溢出
      require(balanceOf[_to] + _value > balanceOf[_to]);

      //保存数据用于后面的判断
      uint previousBalances = balanceOf[_from] + balanceOf[_to];

      //从发送者减掉发送额
      balanceOf[_from] -= _value;

      //给接收者加上相同的量
      balanceOf[_to] += _value;

      //通知任何监听该交易的客户端
      Transfer(_from, _to, _value);

      //判断买、卖双方的数据是否和转换前一致
      assert(balanceOf[_from] + balanceOf[_to] == previousBalances);

    }

    /**
     * 从主帐户合约调用者发送给别人代币
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value);
    }

    /**
     * 从某个指定的帐户中,向另一个帐户发送代币
     *
     * 调用过程,会检查设置的允许最大交易额
     *
     * @param  _from address 发送者地址
     * @param  _to address 接受者地址
     * @param  _value uint256 要转移的代币数量
     * @return success        是否交易成功
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
        //检查发送者是否拥有足够余额
        require(_value <= allowance[_from][msg.sender]);   // Check allowance

        allowance[_from][msg.sender] -= _value;

        _transfer(_from, _to, _value);

        return true;
    }

    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险
     *
     * @param _spender 帐户地址
     * @param _value 金额
     */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
     *
     * @param _spender 帐户地址
     * @param _value 金额
     * @param _extraData 操作的时间
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

    /**
     * 减少代币调用者的余额
     *
     * 操作以后是不可逆的
     *
     * @param _value 要删除的数量
     */
    function burn(uint256 _value) public returns (bool success) {
        //检查帐户余额是否大于要减去的值
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough

        //给指定帐户减去余额
        balanceOf[msg.sender] -= _value;

        //代币问题做相应扣除
        totalSupply -= _value;

        Burn(msg.sender, _value);
        return true;
    }

    /**
     * 删除帐户的余额(含其他帐户)
     *
     * 删除以后是不可逆的
     *
     * @param _from 要操作的帐户地址
     * @param _value 要减去的数量
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {

        //检查帐户余额是否大于要减去的值
        require(balanceOf[_from] >= _value);

        //检查 其他帐户 的余额是否够使用
        require(_value <= allowance[_from][msg.sender]);

        //减掉代币
        balanceOf[_from] -= _value;
        allowance[_from][msg.sender] -= _value;

        //更新总量
        totalSupply -= _value;
        Burn(_from, _value);
        return true;
    }
}

如上面的部署中,我们将完整的代码,贴到 Mistsolidity合约原始代码处,在右侧选择 tokenInitial Supply 输入初始金额5000Token name 输入我们的代币名称 陌上花开Token symbol代币符号我们输入 $$ ,然后点击 部署 ,输入部署帐户的密码。

部署合约以后,我们能够在合约页面看到刚才创建的合约。

点击合约名称,可以看到合约的一些基本信息,以及合约和操作函数

我们能够在 Mist 上方的 钱包 中的主帐号这里看到有个小图标,说明主帐户已经有了代币,其他帐户是没有这个图标的

点击进入主帐号以后,我们就可以看到主帐户已经拥有的代币和以太币的数量,因为我们是参考以太币进行设置,最小单位是wei,所以小数点后面有18个0。

接下来,我们向另一个帐户发送一些 陌上花开 币,点击 Mist 上方的发送,输入发送的帐户地址,输入数量 500 ,选择发送的是 陌上花开 币,点击发送,如下图

再次回到钱包中,我们可以看到,另一个帐户也有了一个代币的图标,说明代币已经转入成功。

现在你拥有了自己的代币,也可以做转入转出操作。可以被用于价值交换,或者工作时间追踪或者其他项目。

高级版的代币功能

虽然区块链是去中心化的,但是实现对代币(合约)的管理,也在许多应用中有需求,为了对代币进行管理,首先需要给合约添加一个管理者。

**
 * owned 是一个管理者
 */
contract owned {
    address public owner;

    /**
     * 初台化构造函数
     */
    function owned() {
        owner = msg.sender;
    }

    /**
     * 判断当前合约调用者是否是管理员
     */
    modifier onlyOwner {
        require (msg.sender == owner);
        _;
    }

    /**
     * 指派一个新的管理员
     * @param  newOwner address 新的管理员帐户地址
     */
    function transferOwnership(address newOwner) onlyOwner {
       if (newOwner != address(0)) {
        owner = newOwner;
      }
    }
}

上面的代码是一个非常简单的合约,我们可以在后面的代码中,使用 继承 来实现后续的功能。

/**
 * @title 高级版代币
 * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
 */
contract MyAdvancedToken is owned{}

MyAdvancedToken 的所有方法中,可以使用 owned 的变量 ownermodifier onlyOwner

去中心化的管理者

我们也可以在构造函数中设置是否需要一个去中心化的管理者。

/*初始化合约,并且把初始的所有的令牌都给这合约的创建者
 * @param initialSupply 所有币的总数
 * @param tokenName 代币名称
 * @param tokenSymbol 代币符号
 * @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
 */
function MyAdvancedToken(
  uint256 initialSupply,
  string tokenName,
  string tokenSymbol,
  address centralMinter
)  {
    //设置合约的管理者
    if(centralMinter != 0 ) owner = centralMinter;
}

代币增发

实现代币增发,代币增发就如同央行印钞票一样,想必很多人都需要这样的功能。

/**
 * 合约拥有者,可以为指定帐户创造一些代币
 * @param  target address 帐户地址
 * @param  mintedAmount uint256 增加的金额(单位是wei)
 */
function mintToken(address target, uint256 mintedAmount) onlyOwner {

    //给指定地址增加代币,同时总量也相加
    balanceOf[target] += mintedAmount;
    totalSupply += mintedAmount;
}

在方法的最后有一个 onlyOwner,说明 mintToken 是继承了 onlyOwner方法,会先调用 modifier onlyOwner 方法,然后将 mintToken 方法的内容,插入到下划线 _ 处调用。

冻结资产

有的场景中,某些用户违反了规定,需要冻结/解冻帐户,不想让他使用已经拥有的代币.可以增加以下代码来控制:

//是否冻结帐户的列表
mapping (address => bool) public frozenAccount;

//定义一个事件,当有资产被冻结的时候,通知正在监听事件的客户端
event FrozenFunds(address target, bool frozen);

/**
 * 增加冻结帐户名称
 *
 * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
 *
 * @param  target address 帐户地址
 * @param  freeze bool    是否冻结
 */
function freezeAccount(address target, bool freeze) onlyOwner {
    frozenAccount[target] = freeze;
    FrozenFunds(target, freeze);
}

代币买卖(兑换)

可以自己的货币中实现代币与其他数字货币(ether 或其他tokens)的兑换机制。有了这个功能,我们的合约就可以在一买一卖中赚利润了。

//卖出的汇率,一个代币,可以卖出多少个以太币,单位是wei
uint256 public sellPrice;

//买入的汇率,1个以太币,可以买几个代币
uint256 public buyPrice;

/**
 * 设置买卖价格
 *
 * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格,也可以在这里设置
 *
 * @param newSellPrice 新的卖出价格
 * @param newBuyPrice 新的买入价格
 */
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
    sellPrice = newSellPrice;
    buyPrice = newBuyPrice;
}

然后增加买、卖的方法,每一次的交易,都会消耗掉一定的 ether。在 Solidity 0.4.0 之后,要接收 ether 的函数都要加一个 payable 属性,如果你开放的合约,需要别人转钱给你,就需要加 payable

下面的方法,不会增加代币,只是改变调用合约者的代币数量,买、卖的价格单位不是 ether,而是 wei,这是以太币中最小的单位(就像美元里的美分,比特币里的聪)。1 ether = 1000000000000000000 wei。因此使用 ether 设置价格的时候,在最后加18个0

当创建合约的时候,发送足够多的 ether 作为代币的背书,否则你的合约就是破产的,你的用户就不能够卖掉他们的代币。

/**
 * 使用以太币购买代币
 */
function buy() payable public {
  uint amount = msg.value / buyPrice;

  _transfer(this, msg.sender, amount);
}

/**
 * @dev 卖出代币
 * @return 要卖出的数量(单位是wei)
 */
function sell(uint256 amount) public {

    //检查合约的余额是否充足
    require(this.balance >= amount * sellPrice);

    _transfer(msg.sender, this, amount);

    msg.sender.transfer(amount * sellPrice);
}

实现Gas的自动补充

以太坊中的交易时需要gas(支付给矿工的费用,费用以ether来支付)。而如果用户没有以太币,只有代币的情况(或者我们想向用户隐藏以太坊的细节),就需要自动补充gas的功能。这个功能将使我们代币更加好用。

自动补充的逻辑是这样了,在执行交易之前,我们判断用户的余额(用来支付矿工的费用),如果用户的余额非常少(低于某个阈值时)可能影响到交易进行,合约自动售出一部分代币来补充余额,以帮助用户顺利完成交易。

先来设定余额阈值:

uint minBalanceForAccounts;

    function setMinBalance(uint minimumBalanceInFinney) onlyOwner {
         minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
    }

finney 是货币单位 1 finney = 0.001eth
然后交易中加入对用户的余额的判断。

function transfer(address _to, uint256 _value) {
    ...
    if(msg.sender.balance < minBalanceForAccounts)
        sell((minBalanceForAccounts - msg.sender.balance) / sellPrice);
    if(_to.balance<minBalanceForAccounts)   // 可选,让接受者也补充余额,以便接受者使用代币。
        _to.send(sell((minBalanceForAccounts - _to.balance) / sellPrice));
}

全部代码

pragma solidity 0.4.20;

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }

/**
 * owned 是一个管理者
 */
contract owned {
    address public owner;

    /**
     * 初台化构造函数
     */
    function owned () public {
        owner = msg.sender;
    }

    /**
     * 判断当前合约调用者是否是管理员
     */
    modifier onlyOwner {
        require (msg.sender == owner);
        _;
    }

    /**
     * 指派一个新的管理员
     * @param  newOwner address 新的管理员帐户地址
     */
    function transferOwnership(address newOwner) onlyOwner public {
        if (newOwner != address(0)) {
        owner = newOwner;
      }
    }
}

/**
 * @title 基础版的代币合约
 */
contract token {
    /* 公共变量 */
    string public standard = 'https://mshk.top';
    string public name; //代币名称
    string public symbol; //代币符号比如'$'
    uint8 public decimals = 18;  //代币单位,展示的小数点后面多少个0,和以太币一样后面是是18个0
    uint256 public totalSupply; //代币总量

    /*记录所有余额的映射*/
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* 在区块链上创建一个事件,用以通知客户端*/
    event Transfer(address indexed from, address indexed to, uint256 value);  //转帐通知事件
    event Burn(address indexed from, uint256 value);  //减去用户余额事件

    /* 初始化合约,并且把初始的所有代币都给这合约的创建者
     * @param initialSupply 代币的总数
     * @param tokenName 代币名称
     * @param tokenSymbol 代币符号
     */
    function token(uint256 initialSupply, string tokenName, string tokenSymbol) public {

        //初始化总量
        totalSupply = initialSupply * 10 ** uint256(decimals);    //以太币是10^18,后面18个0,所以默认decimals是18

        //给指定帐户初始化代币总量,初始化用于奖励合约创建者
        //balanceOf[msg.sender] = totalSupply;
        balanceOf[this] = totalSupply;

        name = tokenName;
        symbol = tokenSymbol;

    }


    /**
     * 私有方法从一个帐户发送给另一个帐户代币
     * @param  _from address 发送代币的地址
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function _transfer(address _from, address _to, uint256 _value) internal {

      //避免转帐的地址是0x0
      require(_to != 0x0);

      //检查发送者是否拥有足够余额
      require(balanceOf[_from] >= _value);

      //检查是否溢出
      require(balanceOf[_to] + _value > balanceOf[_to]);

      //保存数据用于后面的判断
      uint previousBalances = balanceOf[_from] + balanceOf[_to];

      //从发送者减掉发送额
      balanceOf[_from] -= _value;

      //给接收者加上相同的量
      balanceOf[_to] += _value;

      //通知任何监听该交易的客户端
      Transfer(_from, _to, _value);

      //判断买、卖双方的数据是否和转换前一致
      assert(balanceOf[_from] + balanceOf[_to] == previousBalances);

    }

    /**
     * 从主帐户合约调用者发送给别人代币
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value);
    }

    /**
     * 从某个指定的帐户中,向另一个帐户发送代币
     *
     * 调用过程,会检查设置的允许最大交易额
     *
     * @param  _from address 发送者地址
     * @param  _to address 接受者地址
     * @param  _value uint256 要转移的代币数量
     * @return success        是否交易成功
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        //检查发送者是否拥有足够余额
        require(_value <= allowance[_from][msg.sender]);   // Check allowance

        allowance[_from][msg.sender] -= _value;

        _transfer(_from, _to, _value);

        return true;
    }

    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险
     *
     * @param _spender 帐户地址
     * @param _value 金额
     */
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    /**
     * 设置帐户允许支付的最大金额
     *
     * 一般在智能合约的时候,避免支付过多,造成风险,加入时间参数,可以在 tokenRecipient 中做其他操作
     *
     * @param _spender 帐户地址
     * @param _value 金额
     * @param _extraData 操作的时间
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

    /**
     * 减少代币调用者的余额
     *
     * 操作以后是不可逆的
     *
     * @param _value 要删除的数量
     */
    function burn(uint256 _value) public returns (bool success) {
        //检查帐户余额是否大于要减去的值
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough

        //给指定帐户减去余额
        balanceOf[msg.sender] -= _value;

        //代币问题做相应扣除
        totalSupply -= _value;

        Burn(msg.sender, _value);
        return true;
    }

    /**
     * 删除帐户的余额(含其他帐户)
     *
     * 删除以后是不可逆的
     *
     * @param _from 要操作的帐户地址
     * @param _value 要减去的数量
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {

        //检查帐户余额是否大于要减去的值
        require(balanceOf[_from] >= _value);

        //检查 其他帐户 的余额是否够使用
        require(_value <= allowance[_from][msg.sender]);

        //减掉代币
        balanceOf[_from] -= _value;
        allowance[_from][msg.sender] -= _value;

        //更新总量
        totalSupply -= _value;
        Burn(_from, _value);
        return true;
    }



    /**
     * 匿名方法,预防有人向这合约发送以太币
     */
    /*function() {
        //return;     // Prevents accidental sending of ether
    }*/
}

/**
 * @title 高级版代币
 * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
 */
contract MyAdvancedToken is owned, token {

    //卖出的汇率,一个代币,可以卖出多少个以太币,单位是wei
    uint256 public sellPrice;

    //买入的汇率,1个以太币,可以买几个代币
    uint256 public buyPrice;

    //是否冻结帐户的列表
    mapping (address => bool) public frozenAccount;

    //定义一个事件,当有资产被冻结的时候,通知正在监听事件的客户端
    event FrozenFunds(address target, bool frozen);


    /*初始化合约,并且把初始的所有的令牌都给这合约的创建者
     * @param initialSupply 所有币的总数
     * @param tokenName 代币名称
     * @param tokenSymbol 代币符号
     * @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
     */
    function MyAdvancedToken (
      uint256 initialSupply,
      string tokenName,
      string tokenSymbol,
      address centralMinter
    ) token (initialSupply, tokenName, tokenSymbol) public {

        //设置合约的管理者
        if(centralMinter != 0 ) owner = centralMinter;

        sellPrice = 2;     //设置1个单位的代币(单位是wei),能够卖出2个以太币
        buyPrice = 4;      //设置1个以太币,可以买0.25个代币
    }


    /**
     * 私有方法,从指定帐户转出余额
     * @param  _from address 发送代币的地址
     * @param  _to address 接受代币的地址
     * @param  _value uint256 接受代币的数量
     */
    function _transfer(address _from, address _to, uint _value) internal {

        //避免转帐的地址是0x0
        require (_to != 0x0);

        //检查发送者是否拥有足够余额
        require (balanceOf[_from] > _value);

        //检查是否溢出
        require (balanceOf[_to] + _value > balanceOf[_to]);

        //检查 冻结帐户
        require(!frozenAccount[_from]);
        require(!frozenAccount[_to]);



        //从发送者减掉发送额
        balanceOf[_from] -= _value;

        //给接收者加上相同的量
        balanceOf[_to] += _value;

        //通知任何监听该交易的客户端
        Transfer(_from, _to, _value);

    }

    /**
     * 合约拥有者,可以为指定帐户创造一些代币
     * @param  target address 帐户地址
     * @param  mintedAmount uint256 增加的金额(单位是wei)
     */
    function mintToken(address target, uint256 mintedAmount) onlyOwner public {

        //给指定地址增加代币,同时总量也相加
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;


        Transfer(0, this, mintedAmount);
        Transfer(this, target, mintedAmount);
    }

    /**
     * 增加冻结帐户名称
     *
     * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
     *
     * @param  target address 帐户地址
     * @param  freeze bool    是否冻结
     */
    function freezeAccount(address target, bool freeze) onlyOwner public {
        frozenAccount[target] = freeze;
        FrozenFunds(target, freeze);
    }

    /**
     * 设置买卖价格
     *
     * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格,也可以在这里设置
     *
     * @param newSellPrice 新的卖出价格
     * @param newBuyPrice 新的买入价格
     */
    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }

    /**
     * 使用以太币购买代币
     */
    function buy() payable public {
      uint amount = msg.value / buyPrice;

      _transfer(this, msg.sender, amount);
    }

    /**
     * @dev 卖出代币
     * @return 要卖出的数量(单位是wei)
     */
    function sell(uint256 amount) public {

        //检查合约的余额是否充足
        require(this.balance >= amount * sellPrice);

        _transfer(msg.sender, this, amount);

        msg.sender.transfer(amount * sellPrice);
    }
}

参考之前的方法,在 Mist 中重新部署合约,贴完代码后,在右侧选择 My Advanced TokenInitial Supply 输入初始金额5000Token name 输入我们的代币名称 陌上花开AToken symbol 代币符号我们输入 #,然后点击部署,输入部署帐户的密码。

创建成功以后,我们在合约列表页,可以看到刚才创建的新合约陌上花开A。

点击 Mist 上面的发送,我们先给帐户0xd29adaadf3a40fd0b68c83c222c10d3ea637dce0转入100个以太币。

操作成功以后,我们能够在钱包页面看到Account 4已经有了100以太币。

使用以太币购买代币

接下来,我们进入合约页面,使用以太币购买 陌上花开A 代币,进入合约界面后,我们能够看到代币上的以太币是 0 ether,在右侧选择 Buy 方法,Execut from 选择 Account 4,在 Send ether 输入 10 个以太币,点击 执行。

执行成功以后,能够看到当前页面自动刷新,合约中已经有了10 ether,代币的总量不变

再次回到 钱包 页面,可以看到 Account 4 已经从 100 ether 变成了 90 ether,并且多了一个代币图标。

点击 Account 4 帐号进去,可以看到一些详细信息,ether的总量是 89,999081514 而不是 90,是因为执行合约的时候,我们会消费一定的 gas。我们设置的费率是1:4,所以 10 ether,只可以购买 2.5陌上花开A 代币,最小单位也是wei,所以是 2,500000000000000000

卖出代币

进入合约界面后,我们能够看到代币上的以太币是 10 ether,在右侧选择 Sell 方法,在 Amount 处输入 2000000000000000000(因为我们刚才购买了2.5个代币,现在卖出2个,卖出的最小单位是wei),Execut from 选择 Account 4,点击 执行。

执行以后,在代币的详情页面,能够看到从 10 ether 变成了 6 ether ,因为刚才 Account 4 卖出了 2 个 陌上花开A 代币,而我们设置的卖价是 1个代币 能卖出 2个以太币。

再次回到 Account 4 的详情页面,能够看到以太币变成了 93,998273026,而 陌上花开A 代币的数量,变成了 0,500000000000000000。

注:Account4使用10个以太币购买了2.5个代币,如果交易机制没有手续费,Account4卖出2.5个代币仍然会获得10个以太币。而这里通过设置买价4和卖价2,Account4卖出2.5个代币只会获得5个以太币。代币合约利用手续费赚取了5个以太币。

扩展阅读

以太坊官方代币说明

参考:实现一个可管理、增发、兑换、冻结等高级功能的代币
作者:Tiny熊

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,511评论 1 330
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,495评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,595评论 0 225
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,558评论 0 190
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,715评论 3 270
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,672评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,112评论 2 291
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,837评论 0 181
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,417评论 0 228
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,928评论 2 232
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,316评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,773评论 2 234
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,253评论 3 220
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,827评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,440评论 0 180
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,523评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,583评论 2 249

推荐阅读更多精彩内容