推荐设备MORE

自助建站有什么优势—小程序

自助建站有什么优势—小程序

公司新闻

怎样在以太坊上发售数据贷币

日期:2021-02-24
我要分享

本文参照 ethereum token ,以发售数据贷币为实例,详细介绍solidity語言和以太坊程序编写。教大伙儿怎样在以太坊上发售数据贷币?

1、数据贷币

在以太坊,Token能够用来表明各种各样能够买卖的产品: 数据贷币、積分、资格证书、IOU、手机游戏虚似物件等。这些Token在完成上有1些共性,能够提炼成通用性插口,这样以太坊钱包和别的的1些运用还可以适配应用这些共性。

1.1 Token的1个极简完成

要完成1个规范的合约,会非常繁杂。大家循序渐进,先完成1个十分简易的合约。

pragma solidity ^0.4.20; 

contract MyToken {

    /* Map目标用来纪录账户的余额, key是账户详细地址,value是余额 */

    mapping (address => uint256) public balanceOf; 

    /* 结构涵数,实行原始化实际操作,给虚币发售人,即默认设置为当今编码的公布人,设定1定的原始虚币数量。 */

    function MyToken(

        uint256 initialSupply

        ) public {

        balanceOf[msg.sender] = initialSupply;              // 原始虚币数据信息所有授于发售者

    } 

    /* 转帐 */

    function transfer(address _to, uint256 _value) public returns (bool success) {

        require(balanceOf[msg.sender] >= _value);           // 查验推送者的账户的余额是不是充足

        require(balanceOf[_to] + _value >= balanceOf[_to]); // 确定接纳者的账户余额不容易外溢。认真细致!

        balanceOf[msg.sender] -= _value;                    // 扣减推送者的余额

        balanceOf[_to] += _value;                           // 提升接纳者的余额

        return true;

    }

}

1.2 阅读文章编码

大家从最简易的合约编码刚开始。

    contract MyToken {

        /* This creates an array with all balances */

        mapping (address => uint256) public balanceOf;

    }

这里界定了1个余额Map,留意的关键点:

address: 是指账户详细地址,16进制文件格式的。

uint256: 2^256 = 10^77 无标记整数金额,指账户余额,基础能考虑各界壕的要求。

public: 全部账户余额全是公布的。 链就任何人都可以以查寻别的人的账户余额。

假如这个合约可以一切正常公布出来,它便可以一切正常的工作中,可是没甚么用。 只是1个可以查寻余额的合约,别的甚么事都做不上,包含获得1个数据贷币。 全部账户余额都回到0。 因此大家必须在起动的情况下,预置1些数据贷币进来。 因而有这么几行编码:

    function MyToken() public {

        balanceOf[msg.sender] = 21000000;

    }

这是1个结构涵数,方式名和类名是1样的。 结构涵数仅仅在这个合约被布署到互联网上的情况下运作1次。它将给msg.sender,即公布这个合约的人,设定余额。 21000000是1个随意设置的数据。 自然,还可以将这个数据做为主要参数来传进来。 

    function MyToken(uint256 initialSupply) public {

        balanceOf[msg.sender] = initialSupply;

    }

这样在布署的情况下,例如应用Ethereum Wallet来布署,就他会让你挑选这个原始主要参数的值。 

如今最少早已有1个账户有着原始数据贷币余额了。接下来就必须加上1个方式,让这些数据贷币可以买卖。

    /* Send coins */

    function transfer(address _to, uint256 _value) public {

        /* Add and subtract new balances */

        balanceOf[msg.sender] -= _value;

        balanceOf[_to] += _value;

    }

这是1个非常直观的方式:

_to: 收付款人的账户详细地址;

_value: 送出的额度。

完成也很简易,便是增减支付款人的账户余额。 但这个完成是有难题的,假如出款人账户余额不够如何办? 也有便是假如收付款人是个土豪,再接受1笔巨款,就把账户打爆了,如何办? 因此大家必须提升1个校检。 校检的编码其实不繁杂,难题是,假如校检发现主要参数的确有难题,那应当如何办? 在以太坊上,停止程序流程实行有两种方式:

立即根据return来回到某个不正确信息内容。 这会节约1点gas,但也是有个头疼的难题, 早已实行的编码造成的任何变动,都会被储存到链上。

根据throw 来抛出出现异常, 这会将本次造成的全部变动都回退,但也会致使推送者的gas都被耗费。 但是Wallet可以检验出来将会抛的出现异常,他会显示信息1个警示,防止以太币被消耗掉。

    function transfer(address _to, uint256 _value) public {

        /* Check if sender has balance and for overflows */

        require(balanceOf[msg.sender] >= _value && balanceOf[_to] + _value >= balanceOf[_to]); 

        /* Add and subtract new balances */

        balanceOf[msg.sender] -= _value;

        balanceOf[_to] += _value;

    }

这个合约自身还必须1些基础信息内容。 之后大家会根据Token申请注册表来解决这些合约,如今大家先立即上编码吧。 

    string public name;

    string public symbol;

    uint8 public decimals;

调整下结构涵数,加上上述合约信息内容。

/* Initializes contract with initial supply tokens to the creator of the contract */

function MyToken(uint256 initialSupply, string tokenName, string tokenSymbol, uint8 decimalUnits) public {

balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens

name = tokenName;                                   // Set the name for display purposes

symbol = tokenSymbol;                               // Set the symbol for display purposes

decimals = decimalUnits;                            // Amount of decimals for display purposes

    }

最终,大家必须设定1些“恶性事件”。 这是以太坊独有的,它可让以太坊钱包这样的运用来追踪合约上产生的主题活动。 全部恶性事件的第1个标识符务必是大写的,而且放在合约编码的起止一部分。

    event Transfer(address indexed from, address indexed to, uint256 value);

这里大家设定了1个转帐的恶性事件。随后在转帐编码完成的最终,传出这个恶性事件。

And then you just need to add these two lines inside the “transfer” function: 

        /* Notify anyone listening that this transfer took place */

        emit Transfer(msg.sender, _to, _value);

这样,1个合约就开发设计进行了。

1.3 有关注解

和java1样,solidity也适用注解标识,例如@notice和@param。这些注解可让以太坊钱包等运用能够将注解的內容显示信息给客户。 这里相关于注解的详尽表明。

2、改善1下

如今这个数据加密贷币能够上线了。可大家总要折腾,把这个贷币做的更成心思1点。

2.1 健全基本作用

在基本作用上,大家也有许多事儿要做,例如approve, sendFrom等作用。

考虑到这么1个情景: 把数据贷币卖给买卖所,不能能就把数据贷币推送到买卖所给的账户就完事了, 她们还获知道是谁发的数据贷币,也不容易去定阅这些恶性事件。 因此,大家必须提升以下适用:

提升准许approve作用,准许买卖所从你的账户里边扣款。

或更进1步,出示approveAndCall作用,在approve以后,通告买卖所做后续的事儿。

在这些待完成的作用里边, 转帐是最基础的公共作用。 大家把它改动为內部涵数,供别的方式完成时启用。

    /* Internal transfer, can only be called by this contract */

    function _transfer(address _from, address _to, uint _value) internal {

        require (_to != 0x0);                               // Prevent transfer to 0x0 address. Use burn() instead

        require (balanceOf[_from] >= _value);                // Check if the sender has enough

        require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows

        require(!frozenAccount[_from]);                     // Check if sender is frozen

        require(!frozenAccount[_to]);                       // Check if recipient is frozen

        balanceOf[_from] -= _value;                         // Subtract from the sender

        balanceOf[_to] += _value;                           // Add the same to the recipient

        emit Transfer(_from, _to, _value);

    }

这是1个十分风险的方式,1一不小心钱就没了。 因此启用这个transfer方式必须十分慎重,保证要历经批准才能够。

2.2 集中化管理方法

全部的Dapps默认设置是是非非集中化式管理方法。 这并不是代表着不可以做集中化管理方法。 假如必须操纵可以获得数据贷币的人, 操纵数据贷币的应用,这就得必须集中化式的管理方法。 大家能够用1个账户,或1个合约来操纵, 应用的对策,能够是民主化的网络投票,还可以选用限定数据贷币全部者的权利的方法。 对于这些情景,大家必须应用到合约的1个十分有效的特性: inheritance。 合约的承继特性使得它能够获得父合约的全部特点,并且不必须再次界定。

    contract owned {

        address public owner;

 

        function owned() {

            owner = msg.sender;

        }

 

        modifier onlyOwner {

            require(msg.sender == owner);

            _;

        }

 

        function transferOwnership(address newOwner) onlyOwner {

            owner = newOwner;

        }

    }

这里建立1个十分简易的,声明数据贷币owner的合约。 随后就把自身发售的数据贷币关系过来:

 

    contract MyToken is owned {

        /* the rest of the contract as usual */

这代表着在MyToken里边全部的方式都可以以应用owner这个特性和能够承继的方式onlyOwner。 而且能够启用transferOwnership这个方式来改动全部者。 留意1下onlyOwner的完成,有1个“-”标志,子类必须遮盖完成这个方式时,子类的涵数体将放在这里。 能够在MyToken的结构涵数里边提升这个主要参数来设定owner:

 

    function MyToken(

        uint256 initialSupply,

        string tokenName,

        uint8 decimalUnits,

        string tokenSymbol,

        address centralMinter

        ) {

        if(centralMinter != 0 ) owner = centralMinter;

    }

2.3 印钞造币

在实际中,贷币的总量并不是稳定的,常常会伴随着经济发展的发展趋势而持续地提升。 央行会持续引入流动性性, 印钞厂开足马力包装印刷钞票… 就数据贷币而言,大家也期待可以像央行那样开展监管,依据价钱的增减而操纵贷币总量。 大家看来看这个如何做。

最先,大家必须有1个字段来储存总供货链:totalSupply, 而且在结构涵数中原始化:

    contract MyToken {

        uint256 public totalSupply;

 

        function MyToken(...) {

            totalSupply = initialSupply;

            ...

        }

        ...

    }

加上1个方式来印钞造币:

     function mintToken(address target, uint256 mintedAmount) onlyOwner {

        balanceOf[target] += mintedAmount;

        totalSupply += mintedAmount;

        emit Transfer(0, owner, mintedAmount);

        emit Transfer(owner, target, mintedAmount);

    }

留意,这个方式后边的onlyOwner, 表明它将遮盖完成父类中的 modifier onlyOwner 这个方式。 这是和别的語言不1样的地区,能够对遮盖的方式再次取名,乃至改动键入輸出主要参数。 在编译程序时,这个方式的完成会更换到onlyOwner的”_“部位。

2.4 冻洁财产

在实践活动中,有时必须对数据贷币做1些监管,冻洁或解除冻结账户便是普遍的实际操作。

    mapping (address => bool) public frozenAccount;

    event FrozenFunds(address target, bool frozen);

 

    function freezeAccount(address target, bool freeze) onlyOwner {

        frozenAccount[target] = freeze;

        emit FrozenFunds(target, freeze);

    }

在这个完成中,大家假设全部账户一开始全是未冻洁情况。 以后,能够根据freezeAccount命令来冻洁账户,或解除冻结账户。 另外,大家还必须改动下transfer方式,转帐以前,必须确定账户是不是沒有冻洁。 

    function transfer(address _to, uint256 _value) {

        require(!frozenAccount[msg.sender]);

这样,冻洁后, 账户的余额是不会改变的,但没法实行转帐实际操作。 这类方法是默认设置账户全是未冻洁情况,能够转帐。 也有1个情景是默认设置账户全是冻洁的,仅有白名单中的账户才能够转帐。这类状况下,大家要是把frozenAccount方式更换成approvedAccount,并将上述完成更换成认证账户:

        require(approvedAccount[msg.sender]);

2.5 交易贷币

到现阶段为止,大家这个新币种還是自身內部循环系统应用,反映不出使用价值来。 最简易的给数据贷币标价的方式,便是和以太币挂钩起来。 出示1个方式,能够在销售市场上以销售市场价全自动交易,就和本外币互换1样。

最先,大家必须定1个交易的牌价:

    uint256 public sellPrice;

    uint256 public buyPrice;

 

    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {

        sellPrice = newSellPrice;

        buyPrice = newBuyPrice;

    }

针对币值起伏不大的贷币,这类做法是能够接纳的。终究每次调剂币值都必须消耗1定的以太币。 假如要设定固定不动的币值, 能够考虑到科学研究下 standard data feeds 随后完成下贷币交易的作用:

 

    function buy() payable returns (uint amount){

        amount = msg.value / buyPrice;                    // calculates the amount

        _transfer(this, msg.sender, amount);

        return amount;

    }

 

    function sell(uint amount) returns (uint revenue){

        require(balanceOf[msg.sender] >= amount);         // checks if the sender has enough to sell

        balanceOf[this] += amount;                        // adds the amount to owners balance

        balanceOf[msg.sender] -= amount;                  // subtracts the amount from sellers balance

        revenue = amount * sellPrice;

        msg.sender.transfer(revenue);                     // sends ether to the seller: its important to do this last to prevent recursion attacks

        Transfer(msg.sender, this, amount);               // executes an event reflecting on the change

        return revenue;                                   // ends function and returns

    }

留意,这类方法其实不会建立新的数据贷币, 只是在初始账户和数据贷币owner之间做了转帐。 合约既能够持有自身的token,还可以持有以太币。 但无论是设定币值,還是投放新币,都没法触碰真实的金融机构发售的贷币,或以太币。 合约能做的事儿便是在自身的贷币管理体系中迁移贷币。

留意, 币值并不是以Ether为企业来设定,1般是应用wei企业,即以太币的最少企业来设定。 1个ether等于10^18个wei,因此假如贷币是以ether来标价,那必须加18个0转成wei标价。 在建立合约的情况下,留意要凑集充足的以太币做为提前准备金来解决将会的兑换,不然这个贷币会因为没法兑换而没人买了。 这个事例叙述了1个简易的管理中心化的买卖管理中心来交易数据贷币。1个更成心思的销售市场应当是任何人都可以以出不一样的价钱来交易贷币。

2.6 Gas全自动付款

在以太坊管理体系中,每次买卖或合约都必须付款1定的花费(Gas), 之后有将会会调剂这个对策。 到现阶段为止,挖币花费还只能根据以太币来付款,这样全部的数据贷币客户就必须应用以太币来进行合约或买卖。 这样的话,客户体验就不太好了。大家期待数据贷币客户在买卖时,也可以立即应用数据贷币,不必须去考虑到以太币、区块链和怎样获得以太币。 1个可行的方式是必须全自动监测账户余额,假如余额不够,就严禁买卖。

这样,必须最先建立1个阀值自变量,并出示1个方式来改动这个自变量。 这个自变量原始值设定为5 finney (0.005 Ether),即约等于1笔买卖用的Gas。

    uint public minBalanceForAccounts;

 

    function setMinBalance(uint minimumBalanceInFinney) onlyOwner {

         minBalanceForAccounts = minimumBalanceInFinney * 1 finney;

    }

以后,改动transfer方式, 对售币客户做充值。

 

    /* Send coins */

    function transfer(address _to, uint256 _value) {

        ...

        if(msg.sender.balance < minBalanceForAccounts)

            sell((minBalanceForAccounts - msg.sender.balance) / sellPrice);

    }

或立即把花费付款给sender。

    /* Send coins */

    function transfer(address _to, uint256 _value) {

        ...

        if(_to.balance<minBalanceForAccounts)

            _to.send(sell((minBalanceForAccounts - _to.balance) / sellPrice));

    }

这就保证了这些账户不容易因为余额不够而致使买卖不成功。

2.7 Proof of Work

在工作中量证实管理体系中(POW, Proof of Work), 1个简易的方式是完成和以太币1起“合拼挖币”,即挖矿不但得到以太币简历,也会另外获得新数据贷币的奖赏。 参照这里special keyword coinbase 来掌握怎样获得某个入链区块的挖矿账户。 

    function giveBlockReward() {

        balanceOf[block.coinbase] += 1;

    }

自然,还可以尝试去设定1些数据信息困难,任何人处理这个难题便可以获得数据贷币奖赏。 在下1个事例中,你必须测算1个挑戰数据信息的立方根, 测算取得成功后,获得奖赏,并设定下1个挑戰数据信息。

    uint public currentChallenge = 1; // 必须测算出这个数据信息的立方根?

    function rewardMathGeniuses(uint answerToCurrentReward, uint nextChallenge) {

        require(answerToCurrentReward**3 == currentChallenge); // If answer is wrong do not continue

        balanceOf[msg.sender] += 1;         // Reward the player

        currentChallenge = nextChallenge;   // Set the next challenge

    }

自然,测算立方根,对人来讲将会较为难,但对测算机来讲是很非常容易的事儿。 因为最终1个赢家能够挑选下1个挑戰数据信息,她们能够挑选1个对自身有益的数据信息,这样对别的挖矿来讲是不公平公正的。 这类POW的测算公式,最好是是挑选对测算机来讲,有测算难度,可是很非常容易认证测算結果的公式。 比特币和以太坊应用的测算哈希值的方法能够说是现阶段最好是的数据信息困难了。 假如大家要在新的币种中应用哈希测算做为数据信息困难, 能够参照以下编码:

 

    bytes32 public currentChallenge;                         // The coin starts with a challenge

    uint public timeOfLastProof;                             // Variable to keep track of when rewards were given

    uint public difficulty = 10**32;                         // Difficulty starts reasonably low

 

    function proofOfWork(uint nonce){

        bytes8 n = bytes8(sha3(nonce, currentChallenge));    // Generate a random hash based on input

        require(n >= bytes8(difficulty));                   // Check if its under the difficulty

 

        uint timeSinceLastProof = (now - timeOfLastProof);  // Calculate time since last reward was given

        require(timeSinceLastProof >=  5 seconds);         // Rewards cannot be given too quickly

        balanceOf[msg.sender] += timeSinceLastProof / 60 seconds;  // The reward to the winner grows by the minute

 

        difficulty = difficulty * 10 minutes / timeSinceLastProof + 1;  // Adjusts the difficulty

 

        timeOfLastProof = now;                              // Reset the counter

        currentChallenge = sha3(nonce, currentChallenge, block.blockhash(block.number - 1));  // Save a hash that will be used as the next proof

    }

必须改动下结构涵数, 加上原始值: 

        timeOfLastProof = now;

1旦这个合约刚开始上线运作, 必须挑选1个工作中量证实公式, 并设定适合的 nonce 值。 假如收到 “Data cant be execute” , 则表明 nounce设定不符合理,再次调剂下。 直至账户可以每分钟收到1个数据贷币为止,以后测算难度会每10分钟全自动调剂1次。 这便是挖币的全过程。

2.8 改善发售体制

最后版本号的编码以下:

pragma solidity ^0.4.16;

 

contract owned {

    address public owner;

 

    function owned() public {

        owner = msg.sender;

    }

 

    modifier onlyOwner {

        require(msg.sender == owner);

        _;

    }

 

    function transferOwnership(address newOwner) onlyOwner public {

        owner = newOwner;

    }

}

 

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

 

/******************************************/

/*       ERC20规范的虚币       */

/******************************************/

 

contract TokenERC20 {

    string public name;    // public特性,数据贷币名字

    string public symbol;// 数据贷币的标记

    uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it

    uint256 public totalSupply; //贷币总供货量

 

    mapping (address => uint256) public balanceOf;  // 账户-余额 投射关联

    mapping (address => mapping (address => uint256)) public allowance; // 2维数据信息[a][b]=amount,指账户a受权给b可动用的额度为amount。

/**

*

* 转帐的区块链恶性事件。

*

**/

    event Transfer(address indexed from, address indexed to, uint256 value);

    

    /**

     *

* 准许转帐申请办理的区块链恶性事件

*

**/

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

 

    /**

     *

* 发售更多贷币的区块链恶性事件

*

**/

    event Burn(address indexed from, uint256 value);

 

    /**

     * 结构涵数,用来实行原始化实际操作。

     *

     * 原始化合约,并给合约的建立者出示1定数额的数据贷币

     */

    function TokenERC20(

        uint256 initialSupply,

        string tokenName,

        string tokenSymbol

    ) public {

        totalSupply = initialSupply * 10 ** uint256(decimals);  // Update total supply with the decimal amount

        balanceOf[msg.sender] = totalSupply;                // 给建立者全部原始贷币;

        name = tokenName;                                   // 设定本数据贷币的显示信息名字。

        symbol = tokenSymbol;                               // 设定本数据信息贷币的显示信息标记。 

    }

 

    /**

     * Internal transfer, only can be called by this contract

     */

    function _transfer(address _from, address _to, uint _value) internal {

        // 防止转帐到0x0的空闲地址。

        require(_to != 0x0);

        // 查验出款账户余额是不是充足

        require(balanceOf[_from] >= _value);

        // 查验收付款账户是不是会外溢。

        require(balanceOf[_to] + _value > balanceOf[_to]);

        // 纪录下转帐前的两个账户总额,必须保证和转帐后是1致的。  

        uint previousBalances = balanceOf[_from] + balanceOf[_to];

        // 出款账户扣款

        balanceOf[_from] -= _value;

        // 收付款账户收付款

        balanceOf[_to] += _value;

// 推送转帐恶性事件

        emit Transfer(_from, _to, _value);

        // 保证转帐前后左右两个账户总和是1样的。 

        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);

    }

 

    /**

     * 转帐

     *

     * 从当今账户转出给定额度到收付款人账户上

     *

     * @param _to 收付款人账户详细地址

     * @param _value 额度,指当今贷币企业

     */

    function transfer(address _to, uint256 _value) public returns (bool success) {

        _transfer(msg.sender, _to, _value);

        return true;

    }

 

    /**

     * 转帐

     *

     * 从出款人账户转出给定额度到收付款人账户

     *

     * @param _from 出款人账户详细地址

     * @param _to 收付款人账户详细地址

     * @param _value 转帐额度

     */

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {

        require(_value <= allowance[_from][msg.sender]);     // 查验_from账户中能够由进行人动用的额度。 

        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;

        emit Approval(msg.sender, _spender, _value);

        return true;

    }

 

    /**

     * 准许并实行从收付款账户进行的、从本账户扣款并转帐的申请办理。 

     * 容许 收付款账户能够获得比预订额度更多以的币值, 并通告对方。 

     *

     * @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;

        }

    }

 

    /**

     * 消毁贷币

     *

     * 从当今账户中消毁 `_value` 额度的贷币,本实际操作不能大逆转。 

     *

     * @param _value 待消毁的贷币额

     */

    function burn(uint256 _value) public returns (bool success) {

        require(balanceOf[msg.sender] >= _value);   // 查验当今账户的余额是不是充足。 

        balanceOf[msg.sender] -= _value;            // 扣减当今账户余额

        totalSupply -= _value;                      // 升级贷币总供货量

        emit Burn(msg.sender, _value);

        return true;

    }

 

    /**

     * 从特殊账户中消毁1定额度的贷币

     *

     * 从特殊账户_from中消毁 `_value` 额度的贷币,本实际操作不能大逆转。 

     *

     * @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;

    }

}

 

/******************************************/

/*       高級特点的虚币                   */

/******************************************/

 

contract MyAdvancedToken is owned, TokenERC20 {

 

    uint256 public sellPrice;

    uint256 public buyPrice;

 

    mapping (address => bool) public frozenAccount;

 

    /* 账户冻洁的恶性事件   */

    event FrozenFunds(address target, bool frozen);

 

    /* 原始化账户余额和虚币信息内容 */

    function MyAdvancedToken(

        uint256 initialSupply,

        string tokenName,

        string tokenSymbol

    ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}

 

    /* 內部的转帐插口,只容许內部启用 */

    function _transfer(address _from, address _to, uint _value) internal {

        require (_to != 0x0);                               // 严禁向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);

    }

 

    /// @notice 给总体目标账户推送 挖币补贴。 

    /// @param target 总体目标账户

    /// @param mintedAmount 挖币补贴

    function mintToken(address target, uint256 mintedAmount) onlyOwner public {

        balanceOf[target] += mintedAmount;

        totalSupply += mintedAmount;

        emit Transfer(0, this, mintedAmount);

        emit Transfer(this, target, mintedAmount);

    }

 

    /// @notice 冻洁/解除冻结账户,冻洁后,账户就没法收发虚币了。 

    /// @param target 待冻洁的账户

    /// @param freeze 冻洁/解除冻结

    function freezeAccount(address target, bool freeze) onlyOwner public {

        frozenAccount[target] = freeze;

        emit FrozenFunds(target, freeze);

    }

 

    /// @notice 设定虚币对以太币的交易汇率

    /// @param newSellPrice 卖出价

    /// @param newBuyPrice 买入价

    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {

        sellPrice = newSellPrice;

        buyPrice = newBuyPrice;

    }

 

    /// @notice 买入。留意这里应用的是payable插口,启用情况下,必须键入买入额度(以太币wei为企业),买入取得成功后,当今账户提升了amount个虚币,所应用的以太币存入到当今合约所属的详细地址中(并不是owner账户)。

    function buy() payable public {

        uint amount = msg.value / buyPrice;               // calculates the amount

        _transfer(owner, msg.sender, amount);              // makes the transfers

    }

 

    /// @notice 卖出。

    /// @param amount 卖出的数量

    function sell(uint256 amount) public {

        address myAddress = this;

        require(myAddress.balance >= amount * sellPrice);      //  查验是不是有充足的卖出余额

        _transfer(msg.sender, owner, amount);              // 转帐

        msg.sender.transfer(amount * sellPrice); // 务必在最终1步实行以太币的转帐实际操作,避免recursion attacks。留意,这里是从当今合约所属的详细地址上转注资金给卖出者。 

    }

天地数据信息IDC出示中国香港服务器美国服务器等全世界国外服务器租赁代管,是地区链、数据贷币、数据加密贷币、直销、流新闻媒体、出口外贸、手机游戏等服务器处理计划方案首选品牌。天地数据信息已为多家公司出示区块链服务器租赁代管处理计划方案,为她们的区块链安全性出示适用!实际详询线上客服!