(注：本文是在原文的基础上，根据个人的理解，修改部分内容并添加了一些注释)
买卖部分代码未调试通过
基础版的代币合约
下面是一个最简单的代币合约代码，主要介绍可以看注释：
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，然后点击执行，在弹出的层中输入调用合约帐户的密码，确认操作。
我们能够看到实际调用合约的过程中，会花费一定的gas，gas和以太币会根据区块的算力有一个计算公式，gas一般用于奖励给挖矿者。
在transfer方法中，我们设定了，只有合约的调用者msg.sender才能向指定地址转移代币。
/** * 从主帐户合约调用者发送给别人代币 *@param_to address 接受代币的地址 *@param_value uint256 接受代币的数量 */functiontransfer(address _to, uint256 _value)public{ _transfer(msg.sender, _to, _value);}
这时，再次进入合约，在Balance Of处，输入两个帐户的地址，可以看到，余额都发生的变化，如下图：
改善代币
通过上面的操作，我们已经可以将合约代码，通过 Mist 部署到我们创建的私有链中，同样如果部署到生产环境，只需要连上以太坊的网络，同样的方法也可以将你的合约，部署到生产环境中，不过要根据代码的大小，花费一些以太币。
实际使用过程中，交易的过程，需要通知到客户端，并且记录到区块中，我们可以使用event事件来指定，如下代码进行声明：
//在区块链上创建一个事件，用以通知客户端eventTransfer(address indexed from, address indexed to, uint256 value);
设置一些代币的基本信息
/* 公共变量 */stringpublicstandard ='https://mshk.top';stringpublicname;//代币名称stringpublicsymbol;//代币符号比如'$'uint8publicdecimals =18;//代币单位，展示的小数点后面多少个0,和以太币一样后面是是18个0uint256publictotalSupply;//代币总量
某些特定的场景中，不允许某个帐户花费超过指定的上限，避免大额支出，我们可以添加一个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))publicallowance;/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险 * *@param_spender 帐户地址 *@param_value 金额 */functionapprove(address _spender, uint256 _value)publicreturns(bool success){ allowance[msg.sender][_spender] = _value;returntrue;}
同样在solidity中，合约之间也可以相互调用，我们可以增加一个approveAndCall方法，用于在设置帐户最大支出金额后，可以做一些其他操作。
interfacetokenRecipient{functionreceiveApproval(address _from, uint256 _value, address _token, bytes _extraData)public; }/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险 * *@param_spender 帐户地址 *@param_value 金额 */functionapprove(address _spender, uint256 _value)publicreturns(bool success){ allowance[msg.sender][_spender] = _value;returntrue;}/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作 * *@param_spender 帐户地址 *@param_value 金额 *@param_extraData 操作的时间 */functionapproveAndCall(address _spender, uint256 _value, bytes _extraData)publicreturns(bool success){ tokenRecipient spender = tokenRecipient(_spender);if(approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData);returntrue; }}
我们可以增加一个burn方法，用于管理员减去指定帐户的指定金额。进行该方法操作时，通知客户端记录到区块链中。
注：代码并没有判断调用者是否为管理员。
注：代理B在调用burnFrom删除A账户余额时，也需要删除A授权给自己的可调用余额数。
//减去用户余额事件event Burn(address indexed from, uint256 value);/** * 减少代币调用者的余额 * * 操作以后是不可逆的 * *@param_value 要删除的数量 */functionburn(uint256 _value)publicreturns(bool success){//检查帐户余额是否大于要减去的值require(balanceOf[msg.sender] >= _value);// Check if the sender has enough//给指定帐户减去余额balanceOf[msg.sender] -= _value;//代币问题做相应扣除totalSupply -= _value; Burn(msg.sender, _value);returntrue;}/** * 删除帐户的余额（含其他帐户） * * 删除以后是不可逆的 * *@param_from 要操作的帐户地址 *@param_value 要减去的数量 */functionburnFrom(address _from, uint256 _value)publicreturns(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);returntrue;}
完整的代码如下：
pragma solidity0.4.20;interfacetokenRecipient{functionreceiveApproval(address _from, uint256 _value, address _token, bytes _extraData)external; }/** *@title基础版的代币合约 */contract token {/* 公共变量 */stringpublicstandard ='https://mshk.top'; stringpublicname;//代币名称stringpublicsymbol;//代币符号比如'$'uint8publicdecimals =18;//代币单位，展示的小数点后面多少个0,和以太币一样后面是是18个0uint256publictotalSupply;//代币总量/*记录所有余额的映射*/mapping (address => uint256)publicbalanceOf; mapping (address => mapping (address => uint256))publicallowance;/* 在区块链上创建一个事件，用以通知客户端*/event Transfer(address indexed from, address indexed to, uint256 value);//转帐通知事件event Burn(address indexed from, uint256 value);//减去用户余额事件/* 初始化合约，并且把初始的所有代币都给这合约的创建者 *@paraminitialSupply 代币的总数 *@paramtokenName 代币名称 *@paramtokenSymbol 代币符号 */functiontoken(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{//避免转帐的地址是0x0require(_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 接受代币的数量 */functiontransfer(address _to, uint256 _value)public{ _transfer(msg.sender, _to, _value); }/** * 从某个指定的帐户中，向另一个帐户发送代币 * * 调用过程，会检查设置的允许最大交易额 * *@param_from address 发送者地址 *@param_to address 接受者地址 *@param_value uint256 要转移的代币数量 *@returnsuccess 是否交易成功 */functiontransferFrom(address _from, address _to, uint256 _value)publicreturns(bool success){//检查发送者是否拥有足够余额require(_value <= allowance[_from][msg.sender]);// Check allowanceallowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value);returntrue; }/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险 * *@param_spender 帐户地址 *@param_value 金额 */functionapprove(address _spender, uint256 _value)publicreturns(bool success){ allowance[msg.sender][_spender] = _value;returntrue; }/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作 * *@param_spender 帐户地址 *@param_value 金额 *@param_extraData 操作的时间 */functionapproveAndCall(address _spender, uint256 _value, bytes _extraData)publicreturns(bool success){ tokenRecipient spender = tokenRecipient(_spender);if(approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData);returntrue; } }/** * 减少代币调用者的余额 * * 操作以后是不可逆的 * *@param_value 要删除的数量 */functionburn(uint256 _value)publicreturns(bool success){//检查帐户余额是否大于要减去的值require(balanceOf[msg.sender] >= _value);// Check if the sender has enough//给指定帐户减去余额balanceOf[msg.sender] -= _value;//代币问题做相应扣除totalSupply -= _value; Burn(msg.sender, _value);returntrue; }/** * 删除帐户的余额（含其他帐户） * * 删除以后是不可逆的 * *@param_from 要操作的帐户地址 *@param_value 要减去的数量 */functionburnFrom(address _from, uint256 _value)publicreturns(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);returntrue; }}
如上面的部署中，我们将完整的代码，贴到Mist的solidity合约原始代码处，在右侧选择token，Initial Supply输入初始金额5000，Token name输入我们的代币名称陌上花开，Token symbol代币符号我们输入$$,然后点击部署，输入部署帐户的密码。
部署合约以后，我们能够在合约页面看到刚才创建的合约。
点击合约名称，可以看到合约的一些基本信息，以及合约和操作函数
我们能够在Mist上方的钱包中的主帐号这里看到有个小图标，说明主帐户已经有了代币，其他帐户是没有这个图标的
点击进入主帐号以后，我们就可以看到主帐户已经拥有的代币和以太币的数量，因为我们是参考以太币进行设置，最小单位是wei，所以小数点后面有18个0。
接下来，我们向另一个帐户发送一些陌上花开币，点击Mist上方的发送，输入发送的帐户地址，输入数量500，选择发送的是陌上花开币，点击发送，如下图
再次回到钱包中，我们可以看到，另一个帐户也有了一个代币的图标，说明代币已经转入成功。
现在你拥有了自己的代币，也可以做转入转出操作。可以被用于价值交换,或者工作时间追踪或者其他项目。
高级版的代币功能
虽然区块链是去中心化的，但是实现对代币（合约）的管理，也在许多应用中有需求，为了对代币进行管理，首先需要给合约添加一个管理者。
** * owned 是一个管理者 */contract owned { addresspublicowner;/**
* 初台化构造函数
*/functionowned(){ owner = msg.sender; }/**
* 判断当前合约调用者是否是管理员
*/modifier onlyOwner {require(msg.sender == owner); _; }/** * 指派一个新的管理员 *@paramnewOwner address 新的管理员帐户地址 */functiontransferOwnership(address newOwner)onlyOwner{if(newOwner != address(0)) { owner = newOwner; } }}
上面的代码是一个非常简单的合约，我们可以在后面的代码中，使用继承来实现后续的功能。
/** *@title高级版代币 * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能 */contract MyAdvancedToken is owned{}
在MyAdvancedToken的所有方法中，可以使用owned的变量owner和modifier onlyOwner。
去中心化的管理者
我们也可以在构造函数中设置是否需要一个去中心化的管理者。
/*初始化合约，并且把初始的所有的令牌都给这合约的创建者 *@paraminitialSupply 所有币的总数 *@paramtokenName 代币名称 *@paramtokenSymbol 代币符号 *@paramcentralMinter 是否指定其他帐户为合约所有者,为0是去中心化 */functionMyAdvancedToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address centralMinter
){//设置合约的管理者if(centralMinter !=0) owner = centralMinter;}
代币增发
实现代币增发，代币增发就如同央行印钞票一样，想必很多人都需要这样的功能。
/** * 合约拥有者，可以为指定帐户创造一些代币 *@paramtarget address 帐户地址 *@parammintedAmount uint256 增加的金额(单位是wei) */functionmintToken(address target, uint256 mintedAmount)onlyOwner{//给指定地址增加代币，同时总量也相加balanceOf[target] += mintedAmount; totalSupply += mintedAmount;}
在方法的最后有一个onlyOwner，说明mintToken是继承了onlyOwner方法，会先调用modifier onlyOwner方法，然后将mintToken方法的内容，插入到下划线 _ 处调用。
冻结资产
有的场景中，某些用户违反了规定，需要冻结/解冻帐户，不想让他使用已经拥有的代币.可以增加以下代码来控制：
//是否冻结帐户的列表mapping (address => bool)publicfrozenAccount;//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端event FrozenFunds(address target, bool frozen);/** * 增加冻结帐户名称 * * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约 * *@paramtarget address 帐户地址 *@paramfreeze bool 是否冻结 */functionfreezeAccount(address target, bool freeze)onlyOwner{ frozenAccount[target] = freeze; FrozenFunds(target, freeze);}
代币买卖（兑换）
可以自己的货币中实现代币与其他数字货币（ether 或其他tokens）的兑换机制。有了这个功能，我们的合约就可以在一买一卖中赚利润了。
//卖出的汇率,一个代币，可以卖出多少个以太币，单位是weiuint256publicsellPrice;//买入的汇率,1个以太币，可以买几个代币uint256publicbuyPrice;/** * 设置买卖价格 * * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置 * *@paramnewSellPrice 新的卖出价格 *@paramnewBuyPrice 新的买入价格 */functionsetPrices(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作为代币的背书,否则你的合约就是破产的,你的用户就不能够卖掉他们的代币。
/**
* 使用以太币购买代币
*/functionbuy()payablepublic{ uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount);}/**
* @dev 卖出代币
* @return 要卖出的数量(单位是wei)
*/functionsell(uint256 amount)public{//检查合约的余额是否充足require(this.balance >= amount * sellPrice); _transfer(msg.sender,this, amount); msg.sender.transfer(amount * sellPrice);}
实现Gas的自动补充
以太坊中的交易时需要gas（支付给矿工的费用，费用以ether来支付）。而如果用户没有以太币，只有代币的情况（或者我们想向用户隐藏以太坊的细节），就需要自动补充gas的功能。这个功能将使我们代币更加好用。
自动补充的逻辑是这样了，在执行交易之前，我们判断用户的余额（用来支付矿工的费用），如果用户的余额非常少（低于某个阈值时）可能影响到交易进行，合约自动售出一部分代币来补充余额，以帮助用户顺利完成交易。
先来设定余额阈值：
uint minBalanceForAccounts;functionsetMinBalance(uint minimumBalanceInFinney)onlyOwner{ minBalanceForAccounts = minimumBalanceInFinney *1finney; }
finney 是货币单位 1 finney = 0.001eth
然后交易中加入对用户的余额的判断。
functiontransfer(address _to, uint256 _value){ ...if(msg.sender.balance < minBalanceForAccounts) sell((minBalanceForAccounts - msg.sender.balance) / sellPrice);if(_to.balance
全部代码
pragma solidity0.4.20;interfacetokenRecipient{functionreceiveApproval(address _from, uint256 _value, address _token, bytes _extraData)external; }/**
* owned 是一个管理者
*/contract owned { addresspublicowner;/**
* 初台化构造函数
*/functionowned()public{ owner = msg.sender; }/**
* 判断当前合约调用者是否是管理员
*/modifier onlyOwner {require(msg.sender == owner); _; }/** * 指派一个新的管理员 *@paramnewOwner address 新的管理员帐户地址 */functiontransferOwnership(address newOwner)onlyOwnerpublic{if(newOwner != address(0)) { owner = newOwner; } }}/** *@title基础版的代币合约 */contract token {/* 公共变量 */stringpublicstandard ='https://mshk.top'; stringpublicname;//代币名称stringpublicsymbol;//代币符号比如'$'uint8publicdecimals =18;//代币单位，展示的小数点后面多少个0,和以太币一样后面是是18个0uint256publictotalSupply;//代币总量/*记录所有余额的映射*/mapping (address => uint256)publicbalanceOf; mapping (address => mapping (address => uint256))publicallowance;/* 在区块链上创建一个事件，用以通知客户端*/event Transfer(address indexed from, address indexed to, uint256 value);//转帐通知事件event Burn(address indexed from, uint256 value);//减去用户余额事件/* 初始化合约，并且把初始的所有代币都给这合约的创建者 *@paraminitialSupply 代币的总数 *@paramtokenName 代币名称 *@paramtokenSymbol 代币符号 */functiontoken(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{//避免转帐的地址是0x0require(_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 接受代币的数量 */functiontransfer(address _to, uint256 _value)public{ _transfer(msg.sender, _to, _value); }/** * 从某个指定的帐户中，向另一个帐户发送代币 * * 调用过程，会检查设置的允许最大交易额 * *@param_from address 发送者地址 *@param_to address 接受者地址 *@param_value uint256 要转移的代币数量 *@returnsuccess 是否交易成功 */functiontransferFrom(address _from, address _to, uint256 _value)publicreturns(bool success){//检查发送者是否拥有足够余额require(_value <= allowance[_from][msg.sender]);// Check allowanceallowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value);returntrue; }/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险 * *@param_spender 帐户地址 *@param_value 金额 */functionapprove(address _spender, uint256 _value)publicreturns(bool success){ allowance[msg.sender][_spender] = _value;returntrue; }/** * 设置帐户允许支付的最大金额 * * 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作 * *@param_spender 帐户地址 *@param_value 金额 *@param_extraData 操作的时间 */functionapproveAndCall(address _spender, uint256 _value, bytes _extraData)publicreturns(bool success){ tokenRecipient spender = tokenRecipient(_spender);if(approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData);returntrue; } }/** * 减少代币调用者的余额 * * 操作以后是不可逆的 * *@param_value 要删除的数量 */functionburn(uint256 _value)publicreturns(bool success){//检查帐户余额是否大于要减去的值require(balanceOf[msg.sender] >= _value);// Check if the sender has enough//给指定帐户减去余额balanceOf[msg.sender] -= _value;//代币问题做相应扣除totalSupply -= _value; Burn(msg.sender, _value);returntrue; }/** * 删除帐户的余额（含其他帐户） * * 删除以后是不可逆的 * *@param_from 要操作的帐户地址 *@param_value 要减去的数量 */functionburnFrom(address _from, uint256 _value)publicreturns(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);returntrue; }/**
* 匿名方法，预防有人向这合约发送以太币
*//*function() {
//return; // Prevents accidental sending of ether
}*/}/** *@title高级版代币 * 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能 */contract MyAdvancedToken is owned, token {//卖出的汇率,一个代币，可以卖出多少个以太币，单位是weiuint256publicsellPrice;//买入的汇率,1个以太币，可以买几个代币uint256publicbuyPrice;//是否冻结帐户的列表mapping (address => bool)publicfrozenAccount;//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端event FrozenFunds(address target, bool frozen);/*初始化合约，并且把初始的所有的令牌都给这合约的创建者 *@paraminitialSupply 所有币的总数 *@paramtokenName 代币名称 *@paramtokenSymbol 代币符号 *@paramcentralMinter 是否指定其他帐户为合约所有者,为0是去中心化 */functionMyAdvancedToken(
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{//避免转帐的地址是0x0require(_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); }/** * 合约拥有者，可以为指定帐户创造一些代币 *@paramtarget address 帐户地址 *@parammintedAmount uint256 增加的金额(单位是wei) */functionmintToken(address target, uint256 mintedAmount)onlyOwnerpublic{//给指定地址增加代币，同时总量也相加balanceOf[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0, this, mintedAmount); Transfer(this, target, mintedAmount); }/** * 增加冻结帐户名称 * * 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约 * *@paramtarget address 帐户地址 *@paramfreeze bool 是否冻结 */functionfreezeAccount(address target, bool freeze)onlyOwnerpublic{ frozenAccount[target] = freeze; FrozenFunds(target, freeze); }/** * 设置买卖价格 * * 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置 * *@paramnewSellPrice 新的卖出价格 *@paramnewBuyPrice 新的买入价格 */functionsetPrices(uint256 newSellPrice, uint256 newBuyPrice)onlyOwnerpublic{ sellPrice = newSellPrice; buyPrice = newBuyPrice; }/**
* 使用以太币购买代币
*/functionbuy()payablepublic{ uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); }/** *@dev卖出代币 *@return要卖出的数量(单位是wei) */functionsell(uint256 amount)public{//检查合约的余额是否充足require(this.balance >= amount * sellPrice); _transfer(msg.sender, this, amount); msg.sender.transfer(amount * sellPrice); }}
参考之前的方法，在Mist中重新部署合约，贴完代码后，在右侧选择My Advanced Token，Initial Supply输入初始金额5000，Token name输入我们的代币名称陌上花开A，Token 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个以太币。
pragma solidity 0.4.24;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
/**
* owned 是一个管理者
*/
contract owned {
address public owner;
/**
* 初台化构造函数
*/
constructor () 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 代币符号
*/
constructor (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;
//通知任何监听该交易的客户端
emit 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;
emit 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;
emit 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是去中心化
*/
constructor (
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;
//通知任何监听该交易的客户端
emit Transfer(_from, _to, _value);
}
/**
* 合约拥有者，可以为指定帐户创造一些代币
* @param target address 帐户地址
* @param mintedAmount uint256 增加的金额(单位是wei)
*/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
//给指定地址增加代币，同时总量也相加
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/**
* 增加冻结帐户名称
*
* 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
*
* @param target address 帐户地址
* @param freeze bool 是否冻结
*/
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit 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(address(this).balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
}.
以上买卖未调试通过
