以太坊智能合约部署代币

pragma solidity ^0.4.0;
//创建一个基础合约，用于指定某些操作只能由合约拥有者-执行
contract owned{
    //声明一个用于接收合约的状态变量
    address public owner;
    //构造函数，把当前交易的发送者设置为合约拥有者
    function owned() public {
        owner = msg.sender;
    }
    //声明一个修改器，证明只有合约拥有者才能执行某些操作
    modifier onlyOwner{
        if(msg.sender != owner){
            revert();
        }else{
            _;
        }
    }
    //此函数的功能是把合约转让给指定用户
    function transferOwner(address newOwner) public onlyOwner{
        owner = newOwner;
    }
}
//创建代币合约
contract Ztoken is owned {
    //代币所拥有的各种参数
    string public name;//代币的名称
    string public symbol;//代币的符号
    uint8 public decimals = 0;//代币的小数位
    uint public totalSupply;//代币的总量
    
    uint public sellPrice;//代币卖出的价格
    uint public buyPrice;//代币买入的价格
    
    //映射所有账户对应的代币余额
    mapping(address => uint) public balanceof;
    //映射已经被冻结的账户
    mapping(address => bool) public frozenAccount;
    //构造函数，初始化代币的变量和代币的初始总量
    function Ztoken(uint initalSupply,string _name,string _symbol,uint8 _decimals,address centerMinter){
        //指定当前合约的拥有者，如果不指定，则为交易的发送者
        if(centerMinter != 0){
            owner = centerMinter;
        }
        balanceof[owner] = initalSupply;
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        totalSupply = initalSupply;
    }
    //发行货币的机制，本次代币的机制为向指定地址发送代币
    function mintToken(address target,uint mintedAmount) onlyOwner{
        if(target != 0){
            balanceof[target] += mintedAmount;
            totalSupply += mintedAmount;
        }else{
            revert();
        }
        
    }
    //实现账户的冻结与解冻
    function freezeAmount(address target,bool _bool) onlyOwner{
        if(target != 0){
            frozenAccount[target] = _bool;
        }
    }
    //实现账户之间代币的转移
    function transfer(address _to,uint _value){
        //检测发起者和接收者账户是否被冻结
        if(frozenAccount[msg.sender] || frozenAccount[_to])
        revert();
        //检测交易余额是否足够
        if(balanceof[msg.sender] < _value){
            revert();
        }
        //检测接收者的账户余额是否溢出
        if(balanceof[_to] + _value < balanceof[_to]){
            revert();
        }
        //转账
        balanceof[_to] += _value;
        balanceof[msg.sender] -= _value;
    }
    //设置代币的买卖价格
    function setPrice(uint newSellPrice,uint newBuyPrice) onlyOwner{
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }
    //实现卖操作
    function sell(uint amount) returns(uint revenue){
        //检测账户是否被冻结 
        if(frozenAccount[msg.sender]){
            revert();
        }
        //检测余额是否足够 
        if(balanceof[msg.sender] < amount){
            revert();
        }
        //实现卖操作
        balanceof[owner] += amount;
        balanceof[msg.sender] -= amount;
        //通过当前价格计算卖家得到的以太币数量
        revenue = amount * sellPrice;
        //转账以太币给卖家
        if(msg.sender.send(revenue)){
            return revenue;
        }else{
            revert();
        }
    }
    //实现买的操作
    function buy() payable returns(uint amount){
        //检测买家是否有误
        if(buyPrice <= 0){
            revert();
        }
        //根据用户发送的以太币计算出要买的代币的数量
        amount = msg.value /buyPrice;
        //检测合约拥有者的代币是否足够
        if(balanceof[owner] < amount){
            revert();
        }
        //向合约拥有者发送代币
        if(!owner.send(msg.value)){
            revert();
        }
        //代币变化
        balanceof[owner] -= amount;
        balanceof[msg.sender] += amount;
        return amount;
    }
    
}

        在以太坊上部署一个代币，通常都要首先创建一个基础合约，基础合约的作用是在代币合约中某些操作只能由代币合约拥有者才能进行。在代币合约中首先使用构造函数来初始化代币的相关参数，然后分别设计了发币机制函数、账户冻结与解冻函数、账户之间代币的相互转移函数、代币的买卖操作函数。如果要赋予代币更多的功能特点，可以在这些函数的基础上去添加扩展，特别是发币机制能体现代币的价值所在。