SDU项目实训——区块链上实现积分机制

本篇博客是讲解关于如何实现积分机制，需要用到的工具及链接如下：

创建token实现积分机制 目录使用工具小狐狸安装Remix编译器介绍以及合约的部署创造自己的代币部署

目录 使用工具

编译器：

 https://remix.ethereum.org/

MetaMask钱包插件

https://metamask.io/

小狐狸安装

MetaMask除了是一个简单的钱包，它主要卖点是让使用者可以很容易跟以太坊的智能合约互动；MetaMask也不会存钱包资料，所有钱包的私钥和密码都由使用者本身持有，就算是 MetaMask 停止更新，大家也可以用手上的私钥到其他钱包拿回自己的币。

1、使用 Chrome或者火狐浏览器到 MetaMask官网按照向导安装:

只有以下四种浏览器可以下载，推荐使用火狐或者谷歌。按照导航一步步安装就可以，然后后面的私密备份密语要记得备份，最后这样就是安装好了。

Remix编译器介绍以及合约的部署

https://remix.ethereum.org/进入编辑器

打开remix编译器 default_workspace,默认有三个文件夹
1.contracts ——智能合约的文件夹，放智能合约，以.sol结尾；
2.scripts ——脚本文件夹，存放运行智能合约的脚本；
3.tests ——测试文件夹，用于运行智能合约单元测试；

换成测试网，并测试：

获取测试币方式：

https://ropsten.oregonctf.org/eth

创造自己的代币

ERC20 Token
ERC20是一个代币标准。要求我们在实现代币的时候必须要遵守的协议，如指定代币名称、总量、实现代币交易函数等，只有支持了协议才能被钱包支持。
其接口如下：

contract ERC20Interface {

    string public constant name = "Token Name";    //代币名字
    string public constant symbol = "SYM";     //代币符号
    uint8 public constant decimals = 18;  // 18 is the most common number of decimal places  //精确度

//内置功能函数，不用管
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

name ： 代币名称
symbol： 代币符号
decimals： 代币小数点位数，代币的最小单位， 18表示我们可以拥有 .0000000000000000001单位个代币。
totalSupply() : 发行代币总量。
balanceOf(): 查看对应账号的代币余额。
transfer(): 实现代币转账交易，用于给用户发送代币（从我们的账户里）。
transferFrom(): 给被授权的用户使用，他可以从我们（参数 from）的账户里发送代币给其他用户（参数 to）。
allowance(): 返回授权花费的代币数。
approve(): 授权用户可代表我们花费的代币数。

编写代币合约代码

pragma solidity ^0.4.16;

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

contract TokenERC20 {
    string public name;
    string public symbol;
    uint8 public decimals = 18;  // 18 是建议的默认值
    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);


    function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
        name = tokenName;
        symbol = tokenSymbol;
    }


    function _transfer(address _from, address _to, uint _value) internal {
        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);
    }

    function transfer(address _to, uint256 _value) public returns (bool) {
        _transfer(msg.sender, _to, _value);
        return true;
    }

    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;
    }

    function approve(address _spender, uint256 _value) public
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    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;
        }
    }

    function burn(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] -= _value;
        totalSupply -= _value;
        Burn(msg.sender, _value);
        return true;
    }

    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;
    }
}

把上面两部分代码粘贴到remix编辑器中

部署

编译部署合约：
（1）找适合的编译器版本。要不然会报错
（2）部署合约：先链接你的钱包，然后有个Deploy按钮，在部署前你需要填入参数：你的代币发行量，代币名称，代币符号；会消耗Gas费用，也就是消耗你的以太（可能慢），余额减少，右边已部署合约一栏有合约的一些函数功能出现说明就可以了。
（3）在钱包中添加代币：在小狐狸资产选项下有个 导入代币 ，点击。代币合约地址就是在 已部署合约 栏中你的合约名紧跟在后面的地址，直接复制。复制后，代币信息自动填充。此时，你就看到你的资产下面有你自己的代币了

（4）通过钱包向其他用户转账自己的代币：
可以自己创建另一个账户，现在以我的地址为例，注意：别的用户必须导入你的 代币合约地址 才能显示你的代币。你的代币数量减少，说明转账成功。