Membina Ethereum Dapps: Whitelisting & Testing A Story Dao

mata utama

Kisah DAO menggunakan kontrak yang boleh dimiliki oleh Openzeppelin untuk memastikan bahawa hanya pemilik yang dapat melaksanakan fungsi pengurusan, dengan itu meningkatkan keselamatan dan mengawal operasi DAPP.
Kontrak DAO Kisah mempunyai parameter yuran dan tempoh laras dan dilengkapi dengan langkah -langkah keselamatan untuk mencegah perubahan yang tidak dibenarkan, memastikan bahawa hanya pemilik yang dapat mengubah suai tetapan kritikal.
Pengurusan Whitelist dalam cerita DAO dilaksanakan melalui ciri -ciri berbayar yang membolehkan akses automatik dan bersyarat berdasarkan sumbangan penghantar.
Strategi ujian bersepadu, termasuk ujian solidity dan JavaScript, adalah penting untuk mengesahkan fungsi dan keselamatan cerita DAO, memastikan operasi yang mantap sebelum penggunaan.
Proses penempatan cerita DAO dipermudahkan oleh truffle, dengan skrip dan konfigurasi penghijrahan tertentu, yang memudahkan peralihan yang lancar dari persekitaran pembangunan ke persekitaran pengeluaran.

Bahagian ketiga siri tutorial ini menerangkan membina DAPP menggunakan Ethereum, di mana kita membina dan menggunakan token ke Rinkeby Rangkaian Ujian Ethereum. Dalam bahagian ini, kita akan mula menulis cerita DAO Story.

kami akan membimbing kami menggunakan kriteria yang disenaraikan dalam artikel pengenalan.

Gambaran Keseluruhan Kontrak

mari kita buat kontrak baru Storydao.sol, yang kerangka kerja seperti berikut:

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;
    }
}

Kami mengimport SafeMath untuk melakukan pengiraan yang selamat sekali lagi, tetapi kali ini kami juga menggunakan kontrak yang dimiliki oleh Zeppelin, yang membolehkan seseorang untuk "memiliki" cerita dan melaksanakan fungsi pentadbir tertentu. Ringkasnya, sudah cukup untuk Storydao kami untuk dimiliki;

Kami juga menggunakan pengubahsuaian sahaja dalam kontrak ini. Pengubah fungsi pada dasarnya adalah sambungan dan pemalam untuk fungsi. Pengubahsuaian Onlyowner kelihatan seperti ini:

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

Apabila hanya pemilik ditambah ke fungsi, badan fungsi akan disisipkan ke mana _; Oleh itu, dengan menggunakan pengubah ini, fungsi secara automatik memeriksa sama ada pengirim mesej adalah pemilik kontrak dan kemudian terus seperti biasa jika ia benar. Jika tidak, ia akan terhempas.

Dengan menggunakan pengubahsuaian Onlyowner pada fungsi yang mengubah yuran dan parameter lain cerita DAO, kami memastikan bahawa hanya pentadbir dapat membuat perubahan ini.

ujian

mari kita menguji fungsi awal.

Jika tidak wujud, buat ujian folder. Kemudian buat fail teststorydao.sol dan teststorydao.js di dalamnya. Oleh kerana tidak ada kaedah asli dalam truffle untuk menguji pengecualian, pembantu/expectthrow.js juga dibuat menggunakan yang berikut:

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');
  };

NOTA: Ujian solidity biasanya digunakan untuk menguji fungsi berasaskan kontrak rendah, iaitu, struktur dalaman kontrak pintar. Ujian JS sering digunakan untuk menguji sama ada kontrak boleh berinteraksi dengan betul dari luar, yang mana pengguna akhir kami akan lakukan.

dalam teststorydao.sol, letakkan kandungan berikut:

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;
    }
}

Ini akan memeriksa bahawa kontrak Storydao betul digunakan dengan angka yuran dan tempoh yang betul. Baris pertama memastikan bahawa ia digunakan dengan membacanya dari senarai alamat yang digunakan, dan bahagian terakhir membuat beberapa pernyataan - semak jika perisytiharan itu benar atau palsu. Dalam contoh kami, kami membandingkan nombor dengan nilai awal kontrak yang digunakan. Setiap kali ia "benar", bahagian Assert.Equals akan mengeluarkan peristiwa yang menyatakan "benar", yang mana Truffle sedang mendengar semasa ujian.

dalam teststorydao.js, letakkan kandungan berikut:

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

Agar ujian kami berjalan dengan jayanya, kami juga perlu memberitahu Truffle bahawa kami ingin menggunakan Storydao - kerana ia tidak akan melakukannya untuk kami. Oleh itu, mari kita buat 3_deploy_storydao.js dalam penghijrahan menggunakan kandungan hampir sama seperti penghijrahan yang kami tulis sebelum ini:

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');
  };

Pada ketika ini, kita juga harus mengemas kini (atau membuat, jika tidak) fail pakej.json dalam akar folder projek, yang mengandungi kebergantungan yang kita perlukan setakat ini, dan apa yang kita perlukan pada masa depan:

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 个条目");
    }
}

dan .babelrc fail yang mengandungi perkara berikut:

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]}));
    })
});

kita juga perlu memerlukan Babel dalam konfigurasi truffle supaya ia tahu bahawa ia harus digunakan semasa menyusun ujian.

Nota: Babel adalah tambahan kepada NodeJS yang membolehkan kita menggunakan JavaScript generasi akan datang dalam generasi NodeJS semasa, jadi kita boleh menulis import dan kandungan lain. Sekiranya anda tidak faham ini, abaikannya dan tampalkannya. Selepas pemasangan, anda mungkin tidak perlu menangani masalah ini lagi.

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);
  }
};

Sekarang, akhirnya menjalankan ujian truffle. Output harus sama dengan ini:

Untuk maklumat lanjut mengenai ujian, lihat tutorial ini, yang telah kami sediakan khusus untuk menampung ujian kontrak pintar.

Di bahagian berikutnya kursus ini, kami akan melangkau ujian kerana menaip mereka verbatim akan membuat tutorial terlalu lama, tetapi sila rujuk kod sumber akhir projek untuk menyemak semua ujian. Proses yang kami tamat mempunyai persekitaran yang ditubuhkan untuk ujian, jadi anda boleh menulis ujian tanpa persediaan lanjut.

Whitelist

mari kita membina mekanisme putih yang membolehkan pengguna mengambil bahagian dalam membina cerita. Tambahkan kerangka fungsi berikut ke 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"
  }
}

Fungsi fungsi yang tidak dinamakan () dipanggil fungsi sandaran, yang dipanggil apabila dana dihantar ke kontrak ini tetapi tiada arahan khusus (iaitu tiada fungsi lain yang dipanggil secara khusus). Ini membolehkan orang ramai untuk menyertai Storydao dengan menghantar Ether ke DAO sahaja dan untuk memainkan putih atau membeli token dengan serta -merta berdasarkan sama ada mereka disenaraikan atau tidak.

Fungsi Whitelistsender digunakan untuk putih dan boleh dipanggil secara langsung, tetapi kami akan memastikan bahawa fungsi sandaran secara automatik memanggilnya selepas menerima beberapa eter, dengan syarat pengirim belum disenaraikan. Fungsi whitelistaddress diisytiharkan awam kerana ia juga harus dipanggil dari kontrak lain, sementara fungsi sandaran adalah luaran kerana dana hanya dihantar dari alamat luaran ke alamat ini. Kontrak yang memanggil kontrak ini dengan mudah boleh memanggil fungsi yang diperlukan secara langsung.

mari kita berurusan dengan fungsi sandaran terlebih dahulu.

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;
    }
}

Kami periksa sama ada pengirim belum disenaraikan putih dan mewakilkan panggilan ke fungsi WhitelistAddress. Perhatikan bahawa kami mengulas fungsi BuyTokens kerana kami belum memilikinya.

Seterusnya, mari kita berurusan dengan senarai putih.

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

Perhatikan bahawa fungsi ini menerima alamat sebagai hujah, dan bukannya mengeluarkannya dari mesej (dari transaksi). Ini mempunyai manfaat tambahan untuk dapat memainkan peranan lain jika seseorang tidak mampu menyertai DAO, sebagai contoh.

kita mulakan dengan beberapa fungsi pemeriksaan kewarasan: Pengirim harus disenaraikan putih atau disenarai hitam (dilarang) dan mesti menghantar yuran yang cukup untuk membayar. Sekiranya syarat -syarat ini memuaskan, alamat itu ditambah kepada senarai putih, peristiwa Whiteled dikeluarkan, dan akhirnya, jika bilangan eters yang dihantar adalah lebih besar daripada bilangan ether yang diperlukan untuk membayar yuran putih, selebihnya akan digunakan untuk membeli token.

Nota: Kami menggunakan sub bukan - untuk menolak, kerana ini adalah fungsi SafeMath untuk pengiraan yang selamat.

Selagi pengguna menghantar 0.01 eter atau lebih eter ke kontrak Storydao, mereka kini boleh memainkan peranannya sendiri atau orang lain.

Kesimpulan

Dalam tutorial ini, kami membina bahagian awal DAO, tetapi masih banyak kerja yang perlu dilakukan. Tinggal: Di bahagian seterusnya, kami akan berurusan dengan menambah kandungan kepada cerita!

Soalan Lazim Membangun Ethereum Dapps and Whitelists

Apakah prasyarat untuk membina Ethereum Dapp?

Sebelum mula membina Ethereum Dapp, anda perlu mempunyai pemahaman asas mengenai teknologi blockchain, Ethereum dan kontrak pintar. Anda juga harus biasa dengan bahasa pengaturcaraan seperti JavaScript dan Solidity, yang digunakan untuk menulis kontrak pintar di Ethereum. Di samping itu, anda perlu memasang alat seperti node.js, truffle, ganache, dan metamask yang penting untuk membangun dan menguji DAPP.

Bagaimanakah proses Whitelisting berfungsi di DAPP?

Whitelists adalah langkah keselamatan dalam DAPPS yang menyekat akses kepada ciri -ciri tertentu atau bidang permohonan. Ia melibatkan membuat senarai alamat yang diluluskan yang membolehkan interaksi dengan DAPPS. Hanya transaksi yang dimulakan dari alamat ini akan diterima, sementara yang lain akan ditolak. Ini membantu mencegah akses yang tidak dibenarkan dan aktiviti berniat jahat.

Apakah peranan kontrak pintar di Dapps?

Kontrak pintar adalah kontrak yang dilaksanakan sendiri, dan terma perjanjian mereka ditulis terus ke dalam kod. Mereka memainkan peranan penting dalam Dapps kerana mereka mengautomasikan pelaksanaan logik perniagaan di blok block. Mereka memastikan ketelusan, keselamatan, dan kebolehubahan kerana sekali digunakan, mereka tidak boleh diubah atau diganggu.

Bagaimana untuk menguji Dapp saya?

Ujian adalah bahagian penting dalam pembangunan DAPP untuk memastikan fungsi dan keselamatannya. Anda boleh menggunakan alat seperti truffle dan ganache untuk menguji. Truffle menyediakan Ethereum dengan persekitaran pembangunan, rangka kerja ujian, dan saluran paip aset, sementara ganache membolehkan anda membuat blok blok Ethereum swasta untuk ujian.

Apa itu DAO dan bagaimana ia berkaitan dengan DAPP?

DAO mewakili organisasi autonomi yang terdesentralisasi. Ia adalah jenis organisasi yang diwakili oleh peraturan yang dikodkan sebagai program komputer yang telus, dikawal oleh ahli organisasi dan tidak terjejas oleh kerajaan pusat. Urus niaga dan peraturan kewangan Dao disimpan di blok block, yang menjadikannya DAPP.

Bagaimana untuk memastikan keselamatan Dapp saya?

Pastikan keselamatan DAPP melibatkan pelbagai amalan. Ini termasuk menulis kontrak pintar yang selamat, ujian menyeluruh, melakukan audit keselamatan, dan menjaga perisian dan kebergantungan sehingga kini. Ia juga penting untuk mengikuti amalan terbaik untuk pengekodan yang selamat dan terus mengikuti kelemahan keselamatan terkini dan ancaman di ruang blockchain.

Apa itu metamask dan mengapa penting dalam pembangunan Dapp?

Metamask adalah lanjutan penyemak imbas yang membolehkan anda berinteraksi dengan blockchain Ethereum dan Dapps secara langsung dari penyemak imbas anda. Ia juga boleh berfungsi sebagai dompet Ethereum untuk menguruskan token Ethereum dan ERC-20 anda. Adalah penting dalam pembangunan DAPP kerana ia menyediakan pengguna dengan antara muka mesra pengguna supaya pengguna dapat berinteraksi dengan DAPP anda tanpa menjalankan nod Ethereum penuh.

Bagaimana cara menggunakan Dapp saya?

Sebaik sahaja anda telah membangun dan menguji DAPP anda, anda boleh menggunakannya ke Mainnet Ethereum atau TestNet. Ini melibatkan menyusun kontrak pintar anda, menggunakannya ke blok block, dan menghubungkan DAPP anda ke kontrak tersebut. Anda boleh menyelesaikan proses ini menggunakan alat seperti truffle dan infura.

Apakah cabaran pembangunan Dapp?

Pembangunan Dapp menghadapi beberapa cabaran. Ini termasuk menangani isu skalabiliti rangkaian Ethereum, memastikan keselamatan DAPP, menguruskan harga gas yang tidak menentu untuk urus niaga, dan menyediakan antara muka mesra pengguna. Ia juga memerlukan mengawasi teknologi dan peraturan blockchain yang berkembang pesat.

Bagaimana untuk mengemas kini DAPP saya selepas digunakan?

Mengemas kini DAPPS selepas penempatan boleh mencabar kerana kontrak pintar di blok block tidak berubah. Walau bagaimanapun, anda boleh merancang kontrak yang boleh ditingkatkan dengan memisahkan data dan logik ke dalam kontrak yang berlainan atau menaik taraf kontrak menggunakan panggilan yang diwakilkan. Perancangan untuk peningkatan dan perubahan semasa fasa reka bentuk DAPP sangat penting.

Atas ialah kandungan terperinci Membina Ethereum Dapps: Whitelisting & Testing A Story Dao. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!