手把手教你发行属于自己的区块链Token

待我称王封你为后i 2022-05-18 09:55 489阅读 0赞

# 手把手教你发行属于自己的区块链Token #

# 预先准备 #

*  [以太坊钱包][Link 1]
 *  一定数量的eth余额
 *  [MetaMask][]

# Token的参数 #

在发行之前首先要考虑Token的参数，譬如这篇教程准备发行如下Token

*  Token的名称：**Dylan Token**
 *  Token的标识：**DT**
 *  发行量：**19940512**
 *  Token的小数位：**18**

# 编写合约 #

想要基于以太坊拥有自己的**Token**，需要通过智能合约的形式去发行，编写如下基于**ERC20**的**solidity**代码：

pragma solidity ^0.4.18;
    
    library SafeMath {
    
      /**
      * @dev Multiplies two numbers, throws on overflow.
      */
      function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
          return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
      }
    
      /**
      * @dev Integer division of two numbers, truncating the quotient.
      */
      function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
      }
    
      /**
      * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
      */
      function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
      }
    
      /**
      * @dev Adds two numbers, throws on overflow.
      */
      function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
      }
    }
    
    contract ERC20Basic {
      function totalSupply() public view returns (uint256);
      function balanceOf(address who) public view returns (uint256);
      function transfer(address to, uint256 value) public returns (bool);
      event Transfer(address indexed from, address indexed to, uint256 value);
    }
    
    contract BasicToken is ERC20Basic {
      using SafeMath for uint256;
    
      mapping(address => uint256) balances;
    
      uint256 totalSupply_;
    
      /**
      * @dev total number of tokens in existence
      */
      function totalSupply() public view returns (uint256) {
        return totalSupply_;
      }
    
      /**
      * @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, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
    
        // SafeMath.sub will throw if there is not enough balance.
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        Transfer(msg.sender, _to, _value);
        return true;
      }
    
      /**
      * @dev Gets the balance of the specified address.
      * @param _owner The address to query the the balance of.
      * @return An uint256 representing the amount owned by the passed address.
      */
      function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
      }
    
    }
    
    contract ERC20 is ERC20Basic {
      function allowance(address owner, address spender) public view returns (uint256);
      function transferFrom(address from, address to, uint256 value) public returns (bool);
      function approve(address spender, uint256 value) public returns (bool);
      event Approval(address indexed owner, address indexed spender, uint256 value);
    }
    
    contract StandardToken is ERC20, BasicToken {
    
      mapping (address => mapping (address => uint256)) internal 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 uint256 the amount of tokens to be transferred
       */
      function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);
    
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
        Transfer(_from, _to, _value);
        return true;
      }
    
      /**
       * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
       *
       * Beware that changing an allowance with this method brings the risk that someone may use both the old
       * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
       * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       * @param _spender The address which will spend the funds.
       * @param _value The amount of tokens to be spent.
       */
      function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
      }
    
      /**
       * @dev Function to check the amount of tokens that 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 uint256 specifying the amount of tokens still available for the spender.
       */
      function allowance(address _owner, address _spender) public view returns (uint256) {
        return allowed[_owner][_spender];
      }
    
      /**
       * @dev Increase the amount of tokens that an owner allowed to a spender.
       *
       * approve should be called when allowed[_spender] == 0. To increment
       * allowed value is better to use this function to avoid 2 calls (and wait until
       * the first transaction is mined)
       * From MonolithDAO Token.sol
       * @param _spender The address which will spend the funds.
       * @param _addedValue The amount of tokens to increase the allowance by.
       */
      function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
      }
    
      /**
       * @dev Decrease the amount of tokens that an owner allowed to a spender.
       *
       * approve should be called when allowed[_spender] == 0. To decrement
       * allowed value is better to use this function to avoid 2 calls (and wait until
       * the first transaction is mined)
       * From MonolithDAO Token.sol
       * @param _spender The address which will spend the funds.
       * @param _subtractedValue The amount of tokens to decrease the allowance by.
       */
      function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender][_spender];
        if (_subtractedValue > oldValue) {
          allowed[msg.sender][_spender] = 0;
        } else {
          allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
        }
        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
        return true;
      }
    
    }
    
    contract Token is StandardToken {
    
        string public name    = "Dylan Token";
        string public symbol  = "DT";
        uint8 public decimals = 18;
    
        uint256 public constant INITIAL_SUPPLY = 19940512;
    
        function Token() public {
            totalSupply_ = INITIAL_SUPPLY * (10 ** uint256(decimals));
            balances[msg.sender] = totalSupply_;
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136
 *  137
 *  138
 *  139
 *  140
 *  141
 *  142
 *  143
 *  144
 *  145
 *  146
 *  147
 *  148
 *  149
 *  150
 *  151
 *  152
 *  153
 *  154
 *  155
 *  156
 *  157
 *  158
 *  159
 *  160
 *  161
 *  162
 *  163
 *  164
 *  165
 *  166
 *  167
 *  168
 *  169
 *  170
 *  171
 *  172
 *  173
 *  174
 *  175
 *  176
 *  177
 *  178
 *  179
 *  180
 *  181
 *  182
 *  183
 *  184
 *  185
 *  186
 *  187
 *  188
 *  189
 *  190
 *  191
 *  192
 *  193
 *  194
 *  195
 *  196
 *  197
 *  198
 *  199
 *  200

需要修改**Token**的名字`name`、标识`symbol`、发行量`INITIAL_SUPPLY`和小数位`decimals`的，直接在**合约**`Token`中修改相应的变量即可。

# 编译部署合约 #

打开[Remix-Solidity IDE][]，一种在线的Solidity IDE。   
将上述的三个合约代码导入至Remix中，点击**start to compile**进行编译。   
![这里写图片描述][70]  
编译完成后切换到Run，**下拉框选择Token**，点击**Deploy**进行部署   
![这里写图片描述][70 1]  
之后会弹出确认**transaction**的面板，拖到最下面点击**confirm**   
![这里写图片描述][70 2]  
**MetaMask**会弹出，确认交易，点击**submit**   
![这里写图片描述][70 3]   
稍等片刻，交易被确认，会出现下图红框所示的合约地址，**复制到剪贴板**   
教程中**Dylan Token**合约地址为：0x89731a2ddcef82a268d8925327c4080229914f05   
![这里写图片描述][70 4]  
再进入**MetaMask**，点击**Tokens**——**AddToken**，粘贴复制的合约地址，点击**Add**   
![这里写图片描述][70 5]   
就可以在自己的钱包中看到刚刚发行的**Token**了

# 认证合约代码 #

**注意：此步骤需科学上网，不然提交之前的验证码显示出不来。**   
在[以太坊区块浏览器][Link 2]中找到自己的合约地址，点击**Contract code**——**Verify and Publish**，如下图所示   
![这里写图片描述][70 6]  
在**Contract name**:的输入框输入部署的合约名称**Token**, **Compiler** 选择在remix的sttings 中**Solidity version** 显示的版本号。**Optimization** 选择 **No**。 然后在**Enter the Solidity Contract Code below** 下面的输入框中原样填入**Remix**中的代码   
![这里写图片描述][70 7]  
完成后点击提交，如果通过验证，跳转之后会显示如下图红框内所示的**successfully**的字样   
![这里写图片描述][70 8]  
至此Token发行教程完结。

[Link 1]: https://www.myetherwallet.com/
[MetaMask]: https://metamask.io/
[Remix-Solidity IDE]: https://remix.ethereum.org/
[70]: /images/20220518/a2aed734326d41b8b9a919bc3eaf4fcb.png
[70 1]: /images/20220518/83e7b1de39f54ea294eba1ae3efe925c.png
[70 2]: /images/20220518/a3128a4f772e405bb824742505a484a7.png
[70 3]: /images/20220518/5fb51702ea0948b98e80251b4dcf1f42.png
[70 4]: /images/20220518/a309bfd07b1644abbace6b536261fa6e.png
[70 5]: /images/20220518/6fd68a8d40db4af5be6f8e3dc047503b.png
[Link 2]: https://etherscan.io/
[70 6]: /images/20220518/d6b2ed40e76d4df59adc7a5cebd065a2.png
[70 7]: /images/20220518/8147d9801ef240009fd633c32c4aad17.png
[70 8]: /images/20220518/f2609e9f649440899db7a03bc8a5e5d3.png