Go-Ethereum 1.7.2 结合 Mist 0.9.2 实现代币智能合约的实例
目录
[toc]
1、什么是 Mist
Mist
是以太坊官方的在线钱包管理工具。通过 Mist
我们可以很方便的连接上我们的私有网络,从而更好的开发、调试、测试我们的智能合约。既可以连接生产网络、测试网络,更加可以通过设置参数的方式,连接我们自己的私有网络。
Mist
在通过 geth.ipc
文件连接后,就和 Geth
所建立的网络完全契合在一起了,在 Mist
上部署的合约,实际上也就是部署在了 Geth
网络上。Geth
网络上新建账号,也可以在 Mist
这个工具上看到。
通过 Mist
,我们向大家更详细的讲解了以太坊的核心概念,包括:区块、Transaction、Gas、账户、合约、合约中的构造函数,变量以及方法。
2、Mist 在哪里下载?
开发版的 Mist
在这里下载:https://github.com/ethereum/mist
如果要在生产环境上操作,可以直接在以太坊官网下载钱包工具:https://ethereum.org/
3、Mist 有哪些依赖?
需要有以下组件:
- Node.js
v7.x
(use the prefered installation method for your OS) - Meteor javascript app framework
- Yarn package manager
- Electron
v1.7.9
cross platform desktop app framework - Gulp build and automation system
4、如何安装 Mist?
在安装 Mist
前,要先安装依赖的工具包。
4.1、安装 Mist 依赖工具包
➜ /Users/lion >curl https://install.meteor.com/
➜ /Users/lion >brew install yarn
➜ /Users/lion >yarn global add electron@1.7.9
➜ /Users/lion >yarn global add gulp
yarn其他平台的安装方法,可以参考:https://yarnpkg.com/zh-Hans/docs/install
4.2、安装 Mist
➜ /Users/lion/my_project/_eth >git clone https://github.com/ethereum/mist.git
➜ /Users/lion/my_project/_eth >cd mist
➜ /Users/lion/my_project/_eth/mist git:(develop) >git checkout v0.9.2
➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn
4.3、启动 Mist,连接到 Geth
新开一个窗口,用以下命令运行 Mist
的后台程序:
➜ /Users/lion/my_project/_eth/mist git:(369713b) >cd interface
➜ /Users/lion/my_project/_eth/mist/interface git:(369713b) >meteor --no-release-check
[[[[[ ~/my_project/_eth/mist/interface ]]]]]
=> Started proxy.
=> Started MongoDB.
=> Started your app.
=> App running at: http://localhost:3000/
=> Client modified -- refreshing
第一次运行会慢一些,会启动proxy、MongoDB等程序,同时下载一些依赖组件
在启动 Mist
之前,我们要先启动 Geth
,参考:使用 Go-Ethereum 1.7.2搭建以太坊私有链
我们启用以太坊私有链以后,在 ./chain
目录上会创建私有链的一些数据,里面有一个 geth.ipc
文件。
➜ /Users/lion/my_project/_eth/test >ll chain
total 88
drwxr-xr-x 7 lion staff 224 Oct 24 12:21 geth
srw------- 1 lion staff 0 Oct 24 12:24 geth.ipc
-rw------- 1 lion staff 43213 Oct 24 12:08 history
drwx------ 4 lion staff 128 Oct 22 14:57 keystore
在原来的窗口中运行以下命令,用 Mist
连接我们用 Geth
启动的私有链:
➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn dev:electron --rpc /Users/lion/my_project/_eth/test/chain/geth.ipc
如果正常交易以太坊的以太币,可以在官网直接下载以太坊钱包使用:https://ethereum.org/
如果在另一台机器是使用RPC方式运行,也可以使用下面的方法连接到 Geth
:
➜ /Users/lion/my_project/_eth/mist git:(369713b) >yarn dev:electron --rpc http://localhost:8545
运行完以后,会打开一个比较像App的网页,如下图:
在之前的文章中我们创建的帐户,经过
Mist
连接后,也可以在可视化的界面中看到
在 Mist
的界面中,点击发送,可以从一个帐户地址,向另一个帐户地址,转移以太币。
5、使用 Mist 部署一个简单的智能合约
在 Mist
上点击右侧的合约。首先要选择一个帐户来生成合约,用于支付部署合约的费用,以后是谁调用谁来支付费用。(如果在公有链上部署智能合约,需要花费一定的以太币)。
下面是一个最简单的合约代码,主要介绍可以看注释:
pragma solidity 0.4.16;
/**
* @title 基础版的代币合约
*/
contract token {
/* 公共变量 */
string public standard = 'https://mshk.top';
/*记录所有余额的映射*/
mapping (address => uint256) public balanceOf;
/* 初始化合约,并且把初始的所有代币都给这合约的创建者
* @param initialSupply 代币的总数
*/
function token(uint256 initialSupply) {
//给指定帐户初始化代币总量,初始化用于奖励合约创建者
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 接受代币的数量
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
这时,再次进入合约,在Balance Of
处,输入两个帐户的地址,可以看到,余额都发生的变化,如下图:
6、改善代币
通过上面的操作,我们已经可以将合约代码,通过 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
方法,来设置一个允许支出最大金额的列表。
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
方法,用于管理员减去指定帐户的指定金额。进行该方法操作时,通知客户端记录到区块链中。
//减去用户余额事件
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.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
/**
* @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) {
//初始化总量
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) 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;
}
}
6.1、如何部署
如上面的部署中,我们将完整的代码,贴到 Mist
的 solidity合约原始代码
处,在右侧选择 token
, Initial Supply
输入初始金额5000
,Token name
输入我们的代币名称 陌上花开
, Token symbol
代币符号我们输入 $$
,然后点击 部署
,输入部署帐户的密码。
部署合约以后,我们能够在合约页面看到刚才创建的合约。
点击合约名称,可以看到合约的一些基本信息,以及合约和操作函数
我们能够在 Mist
上方的 钱包
中的主帐号这里看到有个小图标,说明主帐户已经有了代币,其他帐户是没有这个图标的
点击进入主帐号以后,我们就可以看到主帐户已经拥有的代币和以太币的数量,因为我们是参考以太币进行设置,最小单位是wei,所以小数点后面有18个0。
接下来,我们向另一个帐户发送一些 陌上花开
币,点击 Mist
上方的发送,输入发送的帐户地址,输入数量 500
,选择发送的是 陌上花开
币,点击发送,如下图
再次回到钱包中,我们可以看到,另一个帐户也有了一个代币的图标,说明代币已经转入成功。
现在你拥有了自己的代币,也可以做转入转出操作。可以被用于价值交换,或者工作时间追踪或者其他项目。
7、高级版的代币功能
一般的代币可以不设置管理者,就是所谓的去中心化。实际使用过程中,可能需要给予挖矿等功能,让别人能够购买你的代币,那么我们就需要设置一个帐户地址做为这个代币合约的管理者。
**
* 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 {
owner = newOwner;
}
}
上面的代码是一个非常简单的合约,我们可以在后面的代码中,使用 继承
来实现后续的功能。
/**
* @title 高级版代币
* 增加冻结用户、挖矿、根据指定汇率购买(售出)代币价格的功能
*/
contract MyAdvancedToken is owned{}
在 MyAdvancedToken
的所有方法中,可以使用 owned
的变量 owner
和 modifier onlyOwner
。
7.1、去中心化的管理者
我们也可以在构造函数中设置是否需要一个去中心化的管理者。
/*初始化合约,并且把初始的所有的令牌都给这合约的创建者
* @param initialSupply 所有币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
* @param centralMinter 是否指定其他帐户为合约所有者,为0是去中心化
*/
function MyAdvancedToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address centralMinter
) {
//设置合约的管理者
if(centralMinter != 0 ) owner = centralMinter;
}
7.2、挖矿
有的时候需要更多的代币流通,可以增加 mintToken
方法,创造更多的代币。
/**
* 合约拥有者,可以为指定帐户创造一些代币
* @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
方法的内容,插入到下划线 _
处调用。
7.3、冻结资产
有的场景中,某些用户违反了规定,需要冻结/解冻帐户,不想让他使用已经拥有的代币.可以增加以下代码来控制:
//是否冻结帐户的列表
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);
}
7.4、自动交易
到了现在,代币的功能很完善,大家也相信你的代币是有价值的,但你想要使用以太币 ether
或者其他代币来购买,让代币市场化,可以真实的交易,我们可以设置一个价格
//卖出的汇率,一个代币,可以卖出多少个以太币,单位是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);
}
7.5、全部代码
把所有的特性加上,完整的代码如下:
pragma solidity 0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
/**
* 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 {
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) {
//初始化总量
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) 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) {
//设置合约的管理者
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 {
//给指定地址增加代币,同时总量也相加
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 {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
/**
* 设置买卖价格
*
* 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格,也可以在这里设置
*
* @param newSellPrice 新的卖出价格
* @param newBuyPrice 新的买入价格
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
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 Token
,Initial Supply
输入初始金额5000,Token name
输入我们的代币名称 陌上花开A
,Token symbol
代币符号我们输入 #
,然后点击部署,输入部署帐户的密码。
创建成功以后,我们在合约列表页,可以看到刚才创建的新合约陌上花开A
。
点击 Mist
上面的发送,我们先给帐户0xd29adaadf3a40fd0b68c83c222c10d3ea637dce0
转入100个以太币。
操作成功以后,我们能够在钱包页面看到Account 4
已经有了100
以太币。
7.6、使用以太币购买代币
接下来,我们进入合约页面,使用以太币购买 陌上花开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
。
7.7、卖出代币
进入合约界面后,我们能够看到代币上的以太币是 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
。
8、常见问题
8.1、在调试Mist
的过程中,创建了很多个合约,如何删除?
In the Ethereum Wallet (Mist) menu, click on Develop -> Toggle Developer Tools -> Wallet UI. Click on the Console tab
CustomContracts.find().fetch().map(
function(m) { CustomContracts.remove(m._id);}
)
博文作者:迦壹
博客地址:Go-Ethereum 1.7.2 结合 Mist 0.9.2 实现代币智能合约的实例
转载声明:可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明,谢谢合作!
5 thoughts on “Go-Ethereum 1.7.2 结合 Mist 0.9.2 实现代币智能合约的实例”
谢谢您的文章,一步一步很详细。
请问全部代码的MyAdvancedToken合约的构造函数中token (initialSupply, tokenName, tokenSymbol)一句如何理解?是给父合约token传入相应参数的意思么?但为部署MyAdvancedToken合约时传入四个相应参数如:5000, TToken, TT, 0 会失败报错”creation of MyAdvancedToken errored: Error encoding arguments: SyntaxError: Unexpected token T in JSON at position 9″,无法成功部署,请问这个应该是什么原因如何解决?谢谢!
还有合约中的最后两行代码:
① _transfer(msg.sender, this, amount);
② msg.sender.transfer(amount * sellPrice);
为什么①转移过去的是代币 ②转移过去的是ether ?
您好,看到您的文章质量非常高,图示讲解也非常清楚。想邀请您成为虫洞社区的首批优质内容签约作者。虫洞社区是中美区块链技术学习社区。我们鼓励内容生产者产生高质量内容,并给予合理的回报,也希望能帮助内容消费者获得高质量的区块链内容。虫洞社区已经积累了200+签约作者以及800+的区块链深度从业者,便于作者建立个人品牌。不知道是否方便加您微信细聊?我的微信是412493137
感谢关注,我只是随着兴趣在更新内容,不是很及时