本文小編為大家詳細介紹“以太坊DAO時間鎖定Multisig怎么運用”，內(nèi)容詳細，步驟清晰，細節(jié)處理妥當(dāng)，希望這篇“以太坊DAO時間鎖定Multisig怎么運用”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學(xué)習(xí)新知識吧。

創(chuàng)新互聯(lián)建站專注于錫林郭勒盟網(wǎng)站建設(shè)服務(wù)及定制，我們擁有豐富的企業(yè)做網(wǎng)站經(jīng)驗。 熱誠為您提供錫林郭勒盟營銷型網(wǎng)站建設(shè)，錫林郭勒盟網(wǎng)站制作、錫林郭勒盟網(wǎng)頁設(shè)計、錫林郭勒盟網(wǎng)站官網(wǎng)定制、小程序開發(fā)服務(wù)，打造錫林郭勒盟網(wǎng)絡(luò)公司原創(chuàng)品牌,更為您提供錫林郭勒盟網(wǎng)站排名全網(wǎng)營銷落地服務(wù)。

Decentralized Autonomous Organization，簡稱DAO，以太坊中重要的概念。一般翻譯為去中心化的自治組織。

有時候，時間也可以用作一種很好的安全機制。以下代碼基于DAO區(qū)塊鏈大會，但有不同的變化。不是每個操作需要X個成員批準，而是任何交易都可以由單個成員發(fā)起，但它們在執(zhí)行之前都需要最少的延遲，這取決于交易的支持。提案的批準越多，就越早執(zhí)行。會員可以對交易進行投票，這意味著它將取消其他一個已批準的簽名。

時間鎖定Multisig

這意味著如果你沒有緊急程度，則執(zhí)行任何交易可能只需要一個或兩個簽名。但是，如果單個密鑰被泄露，其他密鑰可以將該交易延遲數(shù)月或數(shù)年，甚至可以阻止其執(zhí)行。

這個怎么運作

所有密鑰都已批準的交易可以在十分鐘后執(zhí)行（此金額是可配置的），并且每5％未投票的成員每次需要的時間加倍（如果他們主動投票，則為四倍）反對）。如果它是一個簡單的ether交易，只要支持投票將其置于所需的時間內(nèi)，就會執(zhí)行交易，但更復(fù)雜的交易將要求使用正確的字節(jié)碼手動執(zhí)行交易。這些是默認值，但在創(chuàng)建合約時可以設(shè)置不同的值：

批準交易的成員數(shù)量：近似時間延遲

• 100％批準：10分鐘（最低默認值）

• 90％批準：40分鐘

• 80％：2小時40分鐘

• 50％：大約一周

• 40％：1個月

• 30％：4個月

• 20％：超過一年

• 10％或更少：5年或從不 一旦最短的時間過去，任何人都可以執(zhí)行交易（參見“國會”以獲得更完整的步行）。這是故意的，因為它允許某人安排交易或雇用其他人來執(zhí)行交易。

代碼：

pragma solidity >=0.4.22 <0.6.0;

contract owned {
    address public owner;

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) onlyOwner public {
        owner = newOwner;
    }
}

contract tokenRecipient {
    event receivedEther(address sender, uint amount);
    event receivedTokens(address _from, uint256 _value, address _token, bytes _extraData);

    function receiveApproval(address _from, uint256 _value, address _token, bytes memory _extraData) public {
        Token t = Token(_token);
        require(t.transferFrom(_from, address(this), _value));
        emit receivedTokens(_from, _value, _token, _extraData);
    }

    function () payable external {
        emit receivedEther(msg.sender, msg.value);
    }
}

interface Token {
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}

contract TimeLockMultisig is owned, tokenRecipient {

    Proposal[] public proposals;
    uint public numProposals;
    mapping (address => uint) public memberId;
    Member[] public members;
    uint minimumTime = 10;

    event ProposalAdded(uint proposalID, address recipient, uint amount, string description);
    event Voted(uint proposalID, bool position, address voter, string justification);
    event ProposalExecuted(uint proposalID, int result, uint deadline);
    event MembershipChanged(address member, bool isMember);

    struct Proposal {
        address recipient;
        uint amount;
        string description;
        bool executed;
        int currentResult;
        bytes32 proposalHash;
        uint creationDate;
        Vote[] votes;
        mapping (address => bool) voted;
    }

    struct Member {
        address member;
        string name;
        uint memberSince;
    }

    struct Vote {
        bool inSupport;
        address voter;
        string justification;
    }

    // Modifier that allows only shareholders to vote and create new proposals
    modifier onlyMembers {
        require(memberId[msg.sender] != 0);
        _;
    }

    /**
     * Constructor
     *
     * First time setup
     */
    constructor(
        address founder, 
        address[] memory initialMembers, 
        uint minimumAmountOfMinutes
    ) payable public {
        if (founder != address(0)) owner = founder;
        if (minimumAmountOfMinutes !=0) minimumTime = minimumAmountOfMinutes;
        // It’s necessary to add an empty first member
        addMember(address(0), '');
        // and let's add the founder, to save a step later
        addMember(owner, 'founder');
        changeMembers(initialMembers, true);
    }

    /**
     * Add member
     *
     * @param targetMember address to add as a member
     * @param memberName label to give this member address
     */
    function addMember(address targetMember, string memory memberName) onlyOwner public
    {
        uint id;
        if (memberId[targetMember] == 0) {
            memberId[targetMember] = members.length;
            id = members.length++;
        } else {
            id = memberId[targetMember];
        }

        members[id] = Member({member: targetMember, memberSince: now, name: memberName});
        emit MembershipChanged(targetMember, true);
    }

    /**
     * Remove member
     *
     * @param targetMember the member to remove
     */
    function removeMember(address targetMember) onlyOwner public {
        require(memberId[targetMember] != 0);

        for (uint i = memberId[targetMember]; i proposalDeadline(proposalNumber)
            && p.currentResult > 0
            && p.proposalHash == keccak256(abi.encodePacked(p.recipient, p.amount, ''))
            && supportsProposal) {
            executeProposal(proposalNumber, '');
        }
    }

    function proposalDeadline(uint proposalNumber) public view returns(uint deadline) {
        Proposal storage p = proposals[proposalNumber];
        uint factor = calculateFactor(uint(p.currentResult), (members.length - 1));
        return p.creationDate + uint(factor * minimumTime *  1 minutes);
    }

    function calculateFactor(uint a, uint b) public pure returns (uint factor) {
        return 2**(20 - (20 * a)/b);
    }

    /**
     * Finish vote
     *
     * Count the votes proposal #`proposalNumber` and execute it if approved
     *
     * @param proposalNumber proposal number
     * @param transactionBytecode optional: if the transaction contained a bytecode, you need to send it
     */
    function executeProposal(uint proposalNumber, bytes memory transactionBytecode) public {
        Proposal storage p = proposals[proposalNumber];

        require(now >= proposalDeadline(proposalNumber)                                         // If it is past the voting deadline
            && p.currentResult > 0                                                              // and a minimum quorum has been reached
            && !p.executed                                                                      // and it is not currently being executed
            && checkProposalCode(proposalNumber, p.recipient, p.amount, transactionBytecode));  // and the supplied code matches the proposal...


        p.executed = true;
        (bool success, ) = p.recipient.call.value(p.amount)(transactionBytecode);
        require(success);

        // Fire Events
        emit ProposalExecuted(proposalNumber, p.currentResult, proposalDeadline(proposalNumber));
    }
}

部署和使用

像以前一樣在這些教程上部署該代碼。在部署參數(shù)上，將最小時間留空將默認為30分鐘，如果你想要更快的鎖定時間，則放1分鐘。上傳后，執(zhí)行“添加成員”功能以添加組的新成員，他們可以是你認識的其他人，也可以是不同計算機上的帳戶或離線存儲。

設(shè)置為所有者owner的帳戶非常強大，因為它可以隨意添加或刪除成員。因此，在添加主成員后，我們建議你通過執(zhí)行Transfer Membership功能將owner設(shè)置為另一個帳戶。如果你希望對所有成員的添加或刪除進行投票，則將其設(shè)置為multisig本身，就像任何其他交易一樣。另一種方法是將其設(shè)置為另一個受信任的multisig錢包，如果你希望永久修復(fù)成員數(shù)，則可以設(shè)置為0x000。請記住，此合約上的資金僅與“所有者”帳戶一樣安全。

與上述任何DAO一樣，此合約可以持有以太幣，任何基于以太坊的代幣并執(zhí)行任何合約。為此，請檢查如何在國會DAO上執(zhí)行復(fù)雜的提案。

警告和改進

為簡單起見，對提案的投票僅僅算得少一點支持。如果你愿意，你可以玩弄負面投票更重要的想法，但這意味著少數(shù)成員可以對任何提議的交易擁有有效的否決權(quán)！

讀到這里，這篇“以太坊DAO時間鎖定Multisig怎么運用”文章已經(jīng)介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領(lǐng)會，如果想了解更多相關(guān)內(nèi)容的文章，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道。