建造以太坊dapps：白名单和测试一个故事dao-IT业界-PHP中文网

测试

有关构建以太坊 DApp 和白名单的常见问题解答

构建以太坊 DApp 的先决条件是什么？

DApp 中的白名单流程如何运作？

智能合约在 DApp 中的作用是什么？

如何测试我的 DApp？

什么是 DAO，它与 DApp 有何关系？

如何确保我的 DApp 的安全性？

什么是 MetaMask，它在 DApp 开发中为什么很重要？

如何部署我的 DApp？

DApp 开发的挑战是什么？

部署后如何更新我的 DApp？

首页

科技周边

IT业界

建造以太坊dapps：白名单和测试一个故事dao

Lisa Kudrow

Feb 16, 2025 pm 12:24 PM

Building Ethereum DApps: Whitelisting & Testing a Story DAO

关键要点

Story DAO 利用 OpenZeppelin 的 Ownable 合约确保只有所有者才能执行管理功能，从而增强了对 DApp 操作的安全性和控制。
Story DAO 合约具有可调整的费用和持续时间参数，并设有安全措施以防止未经授权的更改，确保只有所有者才能修改关键设置。
Story DAO 中的白名单管理通过需要付费的功能来实现，允许根据发送者的贡献自动和有条件地访问。
综合测试策略，包括 Solidity 和 JavaScript 测试，对于验证 Story DAO 的功能和安全性至关重要，确保在部署之前稳健运行。
Story DAO 的部署过程通过 Truffle 简化，具有特定的迁移脚本和配置，方便从开发环境到生产环境的顺利过渡。

本教程系列的第三部分介绍了使用以太坊构建 DApp，我们构建并将令牌部署到以太坊测试网络 Rinkeby。在本部分中，我们将开始编写 Story DAO 代码。

我们将使用介绍性文章中列出的条件来指导我们。

合约概述

让我们创建一个新的合约 StoryDao.sol，其框架如下：

pragma solidity ^0.4.24;

import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol";

contract StoryDao is Ownable {
    using SafeMath for uint256;

    mapping(address => bool) whitelist;
    uint256 public whitelistedNumber = 0;
    mapping(address => bool) blacklist;
    event Whitelisted(address addr, bool status);
    event Blacklisted(address addr, bool status);

    uint256 public daofee = 100; // 百分之几，即 100 为 1%
    uint256 public whitelistfee = 10000000000000000; // 以 Wei 为单位，这是 0.01 以太币

    event SubmissionCommissionChanged(uint256 newFee);
    event WhitelistFeeChanged(uint256 newFee);

    uint256 public durationDays = 21; // 故事章节持续时间（天）
    uint256 public durationSubmissions = 1000; // 故事章节持续时间（条目）

    function changedaofee(uint256 _fee) onlyOwner external {
        require(_fee <= 1000); // 限制最大费用为 10%
        daofee = _fee;
        emit SubmissionCommissionChanged(_fee);
    }

    function changewhitelistfee(uint256 _fee) onlyOwner external {
        require(_fee > 0); // 确保费用大于 0
        whitelistfee = _fee;
        emit WhitelistFeeChanged(_fee);
    }


    function changeDurationDays(uint256 _days) onlyOwner external {
        require(_days >= 1);
        durationDays = _days;
    }

    function changeDurationSubmissions(uint256 _subs) onlyOwner external {
        require(_subs > 99);
        durationSubmissions = _subs;
    }
}

登录后复制

我们导入 SafeMath 以再次进行安全计算，但这次我们还使用 Zeppelin 的 Ownable 合约，它允许某人“拥有”故事并执行某些仅限管理员的功能。简单地说，我们的 StoryDao 是 Ownable 就足够了；随意检查合约以了解其工作原理。

我们还使用此合约中的 onlyOwner 修饰符。函数修饰符基本上是函数的扩展、插件。onlyOwner 修饰符如下所示：

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

登录后复制

当 onlyOwner 添加到函数时，该函数的主体将粘贴到 _; 部分所在的位置，并且之前的部分将首先执行。因此，通过使用此修饰符，该函数会自动检查消息发送者是否是合约的所有者，然后如果属实则照常继续。如果不是，则会崩溃。

通过在更改 Story DAO 的费用和其他参数的函数上使用 onlyOwner 修饰符，我们确保只有管理员才能进行这些更改。

测试

让我们测试初始函数。

如果不存在，请创建文件夹 test。然后在其中创建文件 TestStoryDao.sol 和 TestStoryDao.js。由于 Truffle 中没有本地方法来测试异常，因此还使用以下内容创建 helpers/expectThrow.js：

export default async promise => {
    try {
      await promise;
    } catch (error) {
      const invalidOpcode = error.message.search('invalid opcode') >= 0;
      const outOfGas = error.message.search('out of gas') >= 0;
      const revert = error.message.search('revert') >= 0;
      assert(
        invalidOpcode || outOfGas || revert,
        'Expected throw, got \'' + error + '\' instead',
      );
      return;
    }
    assert.fail('Expected throw not received');
  };

登录后复制

注意：Solidity 测试通常用于测试低级、基于合约的函数，即智能合约的内部结构。JS 测试通常用于测试合约是否可以从外部正确交互，这是我们的最终用户将要执行的操作。

在 TestStoryDao.sol 中，放入以下内容：

pragma solidity ^0.4.24;

import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol";

contract StoryDao is Ownable {
    using SafeMath for uint256;

    mapping(address => bool) whitelist;
    uint256 public whitelistedNumber = 0;
    mapping(address => bool) blacklist;
    event Whitelisted(address addr, bool status);
    event Blacklisted(address addr, bool status);

    uint256 public daofee = 100; // 百分之几，即 100 为 1%
    uint256 public whitelistfee = 10000000000000000; // 以 Wei 为单位，这是 0.01 以太币

    event SubmissionCommissionChanged(uint256 newFee);
    event WhitelistFeeChanged(uint256 newFee);

    uint256 public durationDays = 21; // 故事章节持续时间（天）
    uint256 public durationSubmissions = 1000; // 故事章节持续时间（条目）

    function changedaofee(uint256 _fee) onlyOwner external {
        require(_fee <= 1000); // 限制最大费用为 10%
        daofee = _fee;
        emit SubmissionCommissionChanged(_fee);
    }

    function changewhitelistfee(uint256 _fee) onlyOwner external {
        require(_fee > 0); // 确保费用大于 0
        whitelistfee = _fee;
        emit WhitelistFeeChanged(_fee);
    }


    function changeDurationDays(uint256 _days) onlyOwner external {
        require(_days >= 1);
        durationDays = _days;
    }

    function changeDurationSubmissions(uint256 _subs) onlyOwner external {
        require(_subs > 99);
        durationSubmissions = _subs;
    }
}

登录后复制

这将检查 StoryDao 合约是否以正确的费用和持续时间数字正确部署。第一行确保它通过从已部署地址列表中读取它来部署，并且最后一节进行一些断言——检查声明是真还是假。在我们的例子中，我们将数字与已部署合约的初始值进行比较。每当它是“真”时，Assert.equals 部分都会发出一个事件，说明“真”，这就是 Truffle 在测试时正在监听的。

在 TestStoryDao.js 中，放入以下内容：

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

登录后复制

为了使我们的测试能够成功运行，我们还需要告诉 Truffle 我们希望部署 StoryDao——因为它不会为我们这样做。因此，让我们在迁移中使用几乎与我们之前编写的迁移相同的 content 创建 3_deploy_storydao.js：

export default async promise => {
    try {
      await promise;
    } catch (error) {
      const invalidOpcode = error.message.search('invalid opcode') >= 0;
      const outOfGas = error.message.search('out of gas') >= 0;
      const revert = error.message.search('revert') >= 0;
      assert(
        invalidOpcode || outOfGas || revert,
        'Expected throw, got \'' + error + '\' instead',
      );
      return;
    }
    assert.fail('Expected throw not received');
  };

登录后复制

此时，我们还应该更新（或创建，如果不存在）项目文件夹根目录中的 package.json 文件，其中包含我们到目前为止需要的依赖项，以及将来可能需要的依赖项：

pragma solidity ^0.4.24;

import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/StoryDao.sol";

contract TestStoryDao {
    function testDeploymentIsFine() public {
        StoryDao sd = StoryDao(DeployedAddresses.StoryDao());

        uint256 daofee = 100; // 百分之几，即 100 为 1%
        uint256 whitelistfee = 10000000000000000; // 以 Wei 为单位，这是 0.01 以太币

        uint256 durationDays = 21; // 故事章节持续时间（天）
        uint256 durationSubmissions = 1000; // 故事章节持续时间（条目）

        Assert.equal(sd.daofee(), daofee, "初始 DAO 费用应为 100");
        Assert.equal(sd.whitelistfee(), whitelistfee, "初始白名单费用应为 0.01 以太币");
        Assert.equal(sd.durationDays(), durationDays, "初始天数持续时间应设置为 3 周");
        Assert.equal(sd.durationSubmissions(), durationSubmissions, "初始提交持续时间应设置为 1000 个条目");
    }
}

登录后复制

以及包含以下内容的 .babelrc 文件：

import expectThrow from './helpers/expectThrow';

const StoryDao = artifacts.require("StoryDao");

contract('StoryDao Test', async (accounts) => {
    it("should make sure environment is OK by checking that the first 3 accounts have over 20 eth", async () =>{
        assert.equal(web3.eth.getBalance(accounts[0]).toNumber() > 2e+19, true, "Account 0 has more than 20 eth");
        assert.equal(web3.eth.getBalance(accounts[1]).toNumber() > 2e+19, true, "Account 1 has more than 20 eth");
        assert.equal(web3.eth.getBalance(accounts[2]).toNumber() > 2e+19, true, "Account 2 has more than 20 eth");
    });

    it("should make the deployer the owner", async () => {
        let instance = await StoryDao.deployed();
        assert.equal(await instance.owner(), accounts[0]);
    });

    it("should let owner change fee and duration", async () => {
        let instance = await StoryDao.deployed();

        let newDaoFee = 50;
        let newWhitelistFee = 1e+10; // 1 ether
        let newDayDuration = 42;
        let newSubsDuration = 1500;

        instance.changedaofee(newDaoFee, {from: accounts[0]});
        instance.changewhitelistfee(newWhitelistFee, {from: accounts[0]});
        instance.changeDurationDays(newDayDuration, {from: accounts[0]});
        instance.changeDurationSubmissions(newSubsDuration, {from: accounts[0]});

        assert.equal(await instance.daofee(), newDaoFee);
        assert.equal(await instance.whitelistfee(), newWhitelistFee);
        assert.equal(await instance.durationDays(), newDayDuration);
        assert.equal(await instance.durationSubmissions(), newSubsDuration);
    });

    it("should forbid non-owners from changing fee and duration", async () => {
        let instance = await StoryDao.deployed();

        let newDaoFee = 50;
        let newWhitelistFee = 1e+10; // 1 ether
        let newDayDuration = 42;
        let newSubsDuration = 1500;

        await expectThrow(instance.changedaofee(newDaoFee, {from: accounts[1]}));
        await expectThrow(instance.changewhitelistfee(newWhitelistFee, {from: accounts[1]}));
        await expectThrow(instance.changeDurationDays(newDayDuration, {from: accounts[1]}));
        await expectThrow(instance.changeDurationSubmissions(newSubsDuration, {from: accounts[1]}));
    });

    it("should make sure the owner can only change fees and duration to valid values", async () =>{
        let instance = await StoryDao.deployed();

        let invalidDaoFee = 20000;
        let invalidDayDuration = 0;
        let invalidSubsDuration = 98;

        await expectThrow(instance.changedaofee(invalidDaoFee, {from: accounts[0]}));
        await expectThrow(instance.changeDurationDays(invalidDayDuration, {from: accounts[0]}));
        await expectThrow(instance.changeDurationSubmissions(invalidSubsDuration, {from: accounts[0]}));
    })
});

登录后复制

我们还需要在 Truffle 配置中要求 Babel，以便它知道在编译测试时应该使用它。

注意：Babel 是 NodeJS 的一个附加组件，它允许我们在当前一代 NodeJS 中使用下一代 JavaScript，因此我们可以编写 import 等内容。如果您不理解这一点，只需忽略它并逐字粘贴即可。安装后，您可能再也不用处理这个问题了。

var Migrations = artifacts.require("./Migrations.sol");
var StoryDao = artifacts.require("./StoryDao.sol");

module.exports = function(deployer, network, accounts) {
  if (network == "development") {
    deployer.deploy(StoryDao, {from: accounts[0]});
  } else {
    deployer.deploy(StoryDao);
  }
};

登录后复制

现在，最后运行 truffle test。输出应该类似于此：

Building Ethereum DApps: Whitelisting & Testing a Story DAO

有关测试的更多信息，请参阅本教程，我们专门准备了本教程来涵盖智能合约的测试。

在本课程的后续部分中，我们将跳过测试，因为逐字输入它们会使教程过长，但请参考项目的最终源代码以检查所有测试。我们刚刚完成的过程已经为测试设置了环境，因此您可以编写测试而无需进一步设置。

白名单

现在让我们构建白名单机制，它允许用户参与构建故事。将以下函数框架添加到 StoryDao.sol：

{
  "name": "storydao",
  "devDependencies": {
    "babel-preset-es2015": "^6.18.0",
    "babel-preset-stage-2": "^6.24.1",
    "babel-preset-stage-3": "^6.17.0",
    "babel-polyfill": "^6.26.0",
    "babel-register": "^6.23.0",
    "dotenv": "^6.0.0",
    "truffle": "^4.1.12",
    "openzeppelin-solidity": "^1.10.0",
    "openzeppelin-solidity-metadata": "^1.2.0",
    "openzeppelin-zos": "",
    "truffle-wallet-provider": "^0.0.5",
    "ethereumjs-wallet": "^0.6.0",
    "web3": "^1.0.0-beta.34",
    "truffle-assertions": "^0.3.1"
  }
}

登录后复制

未命名的函数 function() 被称为回退函数，当向此合约发送资金但没有特定指令（即没有专门调用另一个函数）时，就会调用此函数。这允许人们通过仅向 DAO 发送以太币来加入 StoryDao，并根据他们是否已列入白名单来立即列入白名单或购买代币。

whitelistSender 函数用于列入白名单，可以直接调用，但我们将确保回退函数在收到一些以太币后自动调用它，前提是发送者尚未列入白名单。whitelistAddress 函数被声明为 public，因为它也应该可以从其他合约调用，而回退函数是 external，因为资金只会从外部地址发送到此地址。调用此合约的合约可以轻松直接调用所需函数。

让我们首先处理回退函数。

pragma solidity ^0.4.24;

import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol";

contract StoryDao is Ownable {
    using SafeMath for uint256;

    mapping(address => bool) whitelist;
    uint256 public whitelistedNumber = 0;
    mapping(address => bool) blacklist;
    event Whitelisted(address addr, bool status);
    event Blacklisted(address addr, bool status);

    uint256 public daofee = 100; // 百分之几，即 100 为 1%
    uint256 public whitelistfee = 10000000000000000; // 以 Wei 为单位，这是 0.01 以太币

    event SubmissionCommissionChanged(uint256 newFee);
    event WhitelistFeeChanged(uint256 newFee);

    uint256 public durationDays = 21; // 故事章节持续时间（天）
    uint256 public durationSubmissions = 1000; // 故事章节持续时间（条目）

    function changedaofee(uint256 _fee) onlyOwner external {
        require(_fee <= 1000); // 限制最大费用为 10%
        daofee = _fee;
        emit SubmissionCommissionChanged(_fee);
    }

    function changewhitelistfee(uint256 _fee) onlyOwner external {
        require(_fee > 0); // 确保费用大于 0
        whitelistfee = _fee;
        emit WhitelistFeeChanged(_fee);
    }


    function changeDurationDays(uint256 _days) onlyOwner external {
        require(_days >= 1);
        durationDays = _days;
    }

    function changeDurationSubmissions(uint256 _subs) onlyOwner external {
        require(_subs > 99);
        durationSubmissions = _subs;
    }
}

登录后复制

我们检查发送者是否尚未列入白名单，并将调用委托给 whitelistAddress 函数。请注意，我们注释掉了 buyTokens 函数，因为我们还没有它。

接下来，让我们处理白名单。

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

登录后复制

请注意，此函数接受地址作为参数，而不是从消息（从事务）中提取它。这还有一个额外的好处，即如果有人负担不起加入 DAO 的费用，例如，人们可以将其他人列入白名单。

我们从一些健全性检查开始函数：发送者不得已列入白名单或列入黑名单（被禁止），并且必须已发送足够的费用来支付费用。如果这些条件令人满意，则将地址添加到白名单，发出 Whitelisted 事件，最后，如果发送的以太币数量大于支付白名单费用所需的以太币数量，则剩余部分将用于购买代币。

注意：我们使用 sub 而不是 - 来减去，因为这是用于安全计算的 SafeMath 函数。

只要用户向 StoryDao 合约发送 0.01 以太币或更多以太币，他们现在就可以将自己或其他人列入白名单。

结论

在本教程中，我们构建了 DAO 的初始部分，但还有很多工作要做。敬请期待：在下一部分中，我们将处理向故事中添加内容！

有关构建以太坊 DApp 和白名单的常见问题解答

构建以太坊 DApp 的先决条件是什么？

在开始构建以太坊 DApp 之前，您需要对区块链技术、以太坊和智能合约有基本的了解。您还应该熟悉 JavaScript 和 Solidity 等编程语言，Solidity 用于编写以太坊上的智能合约。此外，您需要安装 Node.js、Truffle、Ganache 和 MetaMask 等工具，这些工具对于开发和测试 DApp 至关重要。