通用模式

作者: gaoer1938 | 来源:发表于2017-08-03 12:23 被阅读64次

通用的MVC模式项目框架MobileProject
通用模式
JavaScript 中几个重要的工具函数
JAVA设计模式
通用模式之
django 学习笔记四
安全
第一章社会工作实务的通用过程模式
通用过程模式
引流的通用模式

date:20170803

从合约中取回钱币

发送钱币的推荐方法是使用取回模式。尽管发送钱币最简单的简单方法是直接调用send。但是它会引入潜在的风险，所以也不推荐使用。你可以阅读安全考虑章节，了解更多信息。
这是一个在合约中使用取回模式的例子，功能是发送最多的钱币到合约中，来成为首富，灵感来自King of the ether。
在下面的合约中，如果你要篡夺成为首富，你要接收去世的人的财产来成为新的首富。

pragma solidity ^0.4.11;

contract WithdrawalContract {
    address public richest;
    uint public mostSent;

    mapping (address => uint) pendingWithdrawals;

    function WithdrawalContract() payable {
        richest = msg.sender;
        mostSent = msg.value;
    }

    function becomeRichest() payable returns (bool) {
        if (msg.value > mostSent) {
            pendingWithdrawals[richest] += msg.value;
            richest = msg.sender;
            mostSent = msg.value;
            return true;
        } else {
            return false;
        }
    }

    function withdraw() {
        uint amount = pendingWithdrawals[msg.sender];
        // 记得在发送之前要把余额设置为0，以防止重入攻击
        pendingWithdrawals[msg.sender] = 0;
        msg.sender.transfer(amount);
    }
}

这和直接发送模式相反：

pragma solidity ^0.4.11;

contract SendContract {
    address public richest;
    uint public mostSent;

    function SendContract() payable {
        richest = msg.sender;
        mostSent = msg.value;
    }

    function becomeRichest() payable returns (bool) {
        if (msg.value > mostSent) {
            // 这一行会出现问题（详情在下文解释）
            richest.transfer(msg.value);
            richest = msg.sender;
            mostSent = msg.value;
            return true;
        } else {
            return false;
        }
    }
}

注意，在这个例子中，攻击者可以困住合约，让合约处于不可使用的状态。通过让richest成为一个合约的地址，该合约有一个回调函数，但是这个回调会执行失败（例如使用revert()或者只是消耗2300 以上的gas），这样，通过transfer调用分发钱币到”有毒“的合约中，它就会失败，因此，becomeRichest就会失败，让合约永远不能正常执行。
相反，如果你使用第一个例子取回模式，那么攻击者只能让他或她的取回函数失败，但是合约的其余代码都没有问题。

限制访问

限制访问时合约的通用模式。注意你不能限制任何人或者计算机读取你的交易内容或者你合约状态。你可以用加密提升难度。但是如果你的合约是可以读取数据的，那么所有人都可以读取数据。
你可以通过其他合约，来限制合约的访问。默认情况下是这样的，除非你把状态变量声明为public。
另外，你可以限制谁可以修改你的合约代码，或者调用你的合约函数，这是这个章节要说的：
使用函数修改器使得限制高度可读。

pragma solidity ^0.4.11;

contract AccessRestriction {
    // 这些变量在构造期间执行，
    // `msg.sender`是创建该合约的账号
    address public owner = msg.sender;
    uint public creationTime = now;

    // 修改器可以用来修改函数体。
    // 如果使用了这个修改器，它会先检测，并且只有函数从特定地址调用才会放行
    modifier onlyBy(address _account)
    {
        require(msg.sender == _account);
        // 不要忘了"_;"!
        // 它代表了使用该修改器的函数的函数体
        _;
    }

    /// 让 `_newOwner` 成为该合约的拥有者
    function changeOwner(address _newOwner)
        onlyBy(owner)
    {
        owner = _newOwner;
    }

    modifier onlyAfter(uint _time) {
        require(now >= _time);
        _;
    }

    /// 擦除拥有者信息。
    /// 只能在合约创建6个星期之后被调用。
    function disown()
        onlyBy(owner)
        onlyAfter(creationTime + 6 weeks)
    {
        delete owner;
    }

    // 这个修改器要求函数调用要有一定数量的钱币
    // 如果调用者发送了太多钱币，会被退还，但是会在函数体执行之后，再退还
    // Solidity v0.4.0之前这么做是很危险的,因为可能会忽略`_;`之后的版本。
    modifier costs(uint _amount) {
        require(msg.value >= _amount);
        _;
        if (msg.value > _amount)
            msg.sender.send(msg.value - _amount);
    }

    function forceOwnerChange(address _newOwner)
        costs(200 ether)
    {
        owner = _newOwner;
        // 一些示例条件
        if (uint(owner) & 0 == 1)
            // Solidity  v0.4.0之前不会退还.
            return;
        // 返回多余的钱币
    }
}

访问控制更加特殊的方法会在下个例子中讨论。

状态机

合约通常像一个状态机，这意味着他们有特定的阶段，不同的阶段表现不同或者会调用不同的函数。一个函数调用可以结束一个阶段，让合约进入到另一个阶段（尤其是合约模型是可交互的）。有些阶段在某个时间点会自动达到，也是很普遍的。

一个例子是秘密竞价合约，在”接收秘密竞价“的时候开始，然后转换到”披露竞价“阶段，然后在确定竞价结果的阶段结束。

函数修改器可以用在这种场合中，来改变状态，以及保护合约的不正当使用。

例子

在下面的例子中，修改器atStage保证了函数只能在特定的时候被调用。

自动计时交易通过timeTransitions修改器来处理，可以用在任意函数中。

注意：修改器顺序很重要。如果atStage和timedTransitions结合起来，你要保证atStage在最后面，然后合约会进入新的阶段。

最后，当函数结束的时候，transitionNext修改器会自动的用来进入下个阶段。

注意：修改器可能会被忽略。在Solidity v0.4.0之前可能会发生：因为修改器只是简单的替换代码，而不是使用函数调用，所以如果函数return掉的时候，transitionNext修改器中的代码可能会被忽略。如果你要这么做，那么你应该在这些函数中手动调用nextStage。从版本0.4.0开始，修改器代码即使函数return了，也能够执行。

pragma solidity ^0.4.11;

contract StateMachine {
    enum Stages {
        AcceptingBlindedBids,
        RevealBids,
        AnotherStage,
        AreWeDoneYet,
        Finished
    }

    // 这是当前状态。
    Stages public stage = Stages.AcceptingBlindedBids;

    uint public creationTime = now;

    modifier atStage(Stages _stage) {
        require(stage == _stage);
        _;
    }

    function nextStage() internal {
        stage = Stages(uint(stage) + 1);
    }

    // 实现阶段过渡。要确保这个修改器放在最前面
    // 否则不会进入下个阶段
    modifier timedTransitions() {
        if (stage == Stages.AcceptingBlindedBids &&
                    now >= creationTime + 10 days)
            nextStage();
        if (stage == Stages.RevealBids &&
                now >= creationTime + 12 days)
            nextStage();
        // 通过交易进入下一个阶段
        _;
    }

    // 修改器的顺序在这里是非常重要的
    function bid()
        payable
        timedTransitions
        atStage(Stages.AcceptingBlindedBids)
    {
        // 这里我们不会先实现。
    }

    function reveal()
        timedTransitions
        atStage(Stages.RevealBids)
    {
    }

    // 这个修改器会使得函数结束的时候进入下一个阶段
    modifier transitionNext()
    {
        _;
        nextStage();
    }

    function g()
        timedTransitions
        atStage(Stages.AnotherStage)
        transitionNext
    {
    }

    function h()
        timedTransitions
        atStage(Stages.AreWeDoneYet)
        transitionNext
    {
    }

    function i()
        timedTransitions
        atStage(Stages.Finished)
    {
    }
}