hardhat 教程及 hardhat-deploy 插件使用

    sudo apt update      sudo apt install curl git      curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -      sudo apt install nodejs  

    curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.35.2/install.sh | bash      nvm install 12      nvm use 12      nvm alias default 12      npm install npm --global # Upgrade npm to the latest version  

    nvm install 12      nvm use 12      nvm alias default 12      npm install npm --global # Upgrade npm to the latest version  

    npm install -g yarn  

    mkdir hardhat-deploy-tutorial      cd hardhat-deploy-tutorial      yarn init --yes      yarn add -D hardhat  

    import {HardhatUserConfig} from 'hardhat/types';      const config: HardhatUserConfig = {        solidity: {          version: '0.7.6',        }      };      export default config;  

    yarn add -D hardhat-deploy hardhat-deploy-ethers ethers chai chai-ethers mocha @types/chai @types/mocha @types/node typescript ts-node dotenv  

    import {HardhatUserConfig} from 'hardhat/types';      import 'hardhat-deploy';      import 'hardhat-deploy-ethers';      const config: HardhatUserConfig = {        solidity: {          version: '0.7.6',        },        namedAccounts: {          deployer: 0,        },      };      export default config;  

    {        "compilerOptions": {          "target": "es5",          "module": "commonjs",          "strict": true,          "esModuleInterop": true,          "moduleResolution": "node",          "forceConsistentCasingInFileNames": true,          "outDir": "dist"        },        "include": [          "hardhat.config.ts",          "./deploy",          "./test",        ]      }  

    import {HardhatUserConfig} from 'hardhat/types';      import 'hardhat-deploy';      import 'hardhat-deploy-ethers';      const config: HardhatUserConfig = {        solidity: {          version: '0.7.6',        },        namedAccounts: {          deployer: 0,        },        paths: {          sources: 'hide',        },      };      export default config;  

    // SPDX-License-Identifier: MIT      // The line above is recommended and let you define the license of your contract      // Solidity files have to start with this pragma.      // It will be used by the Solidity compiler to validate its version.      pragma solidity ^0.7.0;      // This is the main building block for smart contracts.      contract Token {          // Some string type variables to identify the token.          // The `public` modifier makes a variable readable from outside the contract.          string public name = "My Hardhat Token";          string public symbol = "MBT";          // The fixed amount of tokens stored in an unsigned integer type variable.          uint256 public totalSupply = 1000000;          // An address type variable is used to store ethereum accounts.          address public owner;          // A mapping is a key/value map. Here we store each account balance.          mapping(address => uint256) balances;          /**          * Contract initialization.           *           * The `constructor` is executed only once when the contract is created.           */          constructor(address_owner) {              // The totalSupply is assigned to transaction sender, which is the account              // that is deploying the contract.              balances[_owner] = totalSupply;              owner =_owner;          }          /**          * A function to transfer tokens.           *           * The `external` modifier makes a function *only* callable from outside           * the contract.           */          function transfer(address to, uint256 amount) external {              // Check if the transaction sender has enough tokens.              // If `require`'s first argument evaluates to `false` then the              // transaction will revert.              require(balances[msg.sender] >= amount, "Not enough tokens");              // Transfer the amount.              balances[msg.sender] -= amount;              balances[to] += amount;          }          /**          * Read only function to retrieve the token balance of a given account.           *           * The `view` modifier indicates that it doesn't modify the contract's           * state, which allows us to call it without executing a transaction.           */          function balanceOf(address account) external view returns (uint256) {              return balances[account];          }      }  

    $ yarn hardhat compile      Compiling 1 file with 0.7.3      Compilation finished successfully  

    import {HardhatRuntimeEnvironment} from 'hardhat/types';      import {DeployFunction} from 'hardhat-deploy/types';      const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {        const {deployments, getNamedAccounts} = hre;        const {deploy} = deployments;        const {deployer, tokenOwner} = await getNamedAccounts();        await deploy('Token', {          from: deployer,          args: [tokenOwner],          log: true,        });      };      export default func;      func.tags = ['Token'];  

    import {HardhatUserConfig} from 'hardhat/types';      import 'hardhat-deploy';      import 'hardhat-deploy-ethers';      const config: HardhatUserConfig = {        solidity: {          version: '0.7.6',        },        namedAccounts: {          deployer: 0,          tokenOwner: 1,        },        paths: {          sources: 'hide',        },      };      export default config;  

    Nothing to compile      deploying "Token" (tx: 0x259d19f33819ec8d3bd994f82912aec6af1a18ec5d74303cfb28d793a10ff683)...: deployed at 0x5FbDB2315678afecb367f032d93F642f64180aa3 with 592983 gas      Done in 3.66s.  

    import {HardhatRuntimeEnvironment} from 'hardhat/types'; // this add the type from hardhat runtime environment      import {DeployFunction} from 'hardhat-deploy/types'; // this add the type that a deploy function is expected to fullfil      const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { // 部署函数把 hardhat 运行时作为参数        const {deployments, getNamedAccounts} = hre; // we get the deployments and getNamedAccounts which are provided by hardhat-deploy        const {deploy} = deployments; // the deployments field itself contains the deploy function        const {deployer, tokenOwner} = await getNamedAccounts(); // we fetch the accounts. These can be configured in hardhat.config.ts as explained above        await deploy('Token', { // this will create a deployment called 'Token'. By default it will look for an artifact with the same name. the contract option allows you to use a different artifact          from: deployer, // deployer will be performing the deployment transaction          args: [tokenOwner], // tokenOwner is the address used as the first argument to the Token contract's constructor          log: true, // display the address and gas used in the console (not when run in test though)        });      };      export default func;      func.tags = ['Token']; // this setup a tag so you can execute the script on its own (and its dependencies)  

    import {expect} from "./chai-setup";      import {ethers, deployments, getNamedAccounts} from 'hardhat';      describe("Token contract", function() {        it("Deployment should assign the total supply of tokens to the owner", async function() {          await deployments.fixture(["Token"]);          const {tokenOwner} = await getNamedAccounts();          const Token = await ethers.getContract("Token");          const ownerBalance = await Token.balanceOf(tokenOwner);          const supply = await Token.totalSupply();          expect(ownerBalance).to.equal(supply);        });      });  

    import chaiModule from 'chai';      import {chaiEthers} from 'chai-ethers';      chaiModule.use(chaiEthers);      export = chaiModule;  

    $ npx hardhat test        Token contract          ✓ Deployment should assign the total supply of tokens to the owner (654ms)        1 passing (663ms)  

    await deployments.fixture(["Token"]);  

    const {tokenOwner} = await getNamedAccounts();  

    const Token = await ethers.getContract("Token");  

    const ownerBalance = await Token.balanceOf(tokenOwner);  

    const supply = await Token.totalSupply();  

    expect(ownerBalance).to.equal(supply);  

    import {expect} from "./chai-setup";      import {ethers, deployments, getNamedAccounts, getUnnamedAccounts} from 'hardhat';      describe("Token contract", function() {        it("Deployment should assign the total supply of tokens to the owner", async function() {          await deployments.fixture(["Token"]);          const {tokenOwner} = await getNamedAccounts();          const users = await getUnnamedAccounts();          const TokenAsOwner = await ethers.getContract("Token", tokenOwner);          await TokenAsOwner.transfer(users[0], 50);          expect(await TokenAsOwner.balanceOf(users[0])).to.equal(50);          const TokenAsUser0 = await ethers.getContract("Token", users[0]);          await TokenAsUser0.transfer(users[1], 50);          expect(await TokenAsOwner.balanceOf(users[1])).to.equal(50);        });      });  

    import {Contract} from 'ethers';      import {ethers} from 'hardhat';      export async function setupUsers<T extends {[contractName: string]: Contract}>(        addresses: string[],        contracts: T      ): Promise<({address: string} & T)[]> {        const users: ({address: string} & T)[] = [];        for (const address of addresses) {          users.push(await setupUser(address, contracts));        }        return users;      }      export async function setupUser<T extends {[contractName: string]: Contract}>(        address: string,        contracts: T      ): Promise<{address: string} & T> {        // eslint-disable-next-line @typescript-eslint/no-explicit-any        const user: any = {address};        for (const key of Object.keys(contracts)) {          user[key] = contracts[key].connect(await ethers.getSigner(address));        }        return user as {address: string} & T;      }  

    // We import Chai to use its asserting functions here.      import {expect} from "./chai-setup";      // we import our utilities      import {setupUsers, setupUser} from './utils';      // We import the hardhat environment field we are planning to use      import {ethers, deployments, getNamedAccounts, getUnnamedAccounts} from 'hardhat';      // we create a stup function that can be called by every test and setup variable for easy to read tests      async function setup () {        // it first ensure the deployment is executed and reset (use of evm_snaphost for fast test)        await deployments.fixture(["Token"]);        // we get an instantiated contract in teh form of a ethers.js Contract instance:        const contracts = {          Token: (await ethers.getContract('Token')),        };        // we get the tokenOwner        const {tokenOwner} = await getNamedAccounts();        // get fet unnammedAccounts (which are basically all accounts not named in the config, useful for tests as you can be sure they do not have been given token for example)        // we then use the utilities function to generate user object/        // These object allow you to write things like `users[0].Token.transfer(....)`        const users = await setupUsers(await getUnnamedAccounts(), contracts);        // finally we return the whole object (including the tokenOwner setup as a User object)        return {          ...contracts,          users,          tokenOwner: await setupUser(tokenOwner, contracts),        };      }      // `describe` is a Mocha function that allows you to organize your tests. It's      // not actually needed, but having your tests organized makes debugging them      // easier. All Mocha functions are available in the global scope.      // `describe` receives the name of a section of your test suite, and a callback.      // The callback must define the tests of that section. This callback can't be      // an async function.      describe("Token contract", function() {        // You can nest describe calls to create subsections.        describe("Deployment", function () {          // `it` is another Mocha function. This is the one you use to define your          // tests. It receives the test name, and a callback function.          // If the callback function is async, Mocha will `await` it.          it("Should set the right owner", async function () {            // Expect receives a value, and wraps it in an Assertion object. These            // objects have a lot of utility methods to assert values.            // before the test, we call the fixture function.            // while mocha have hooks to perform these automatically, they force you to declare the variable in greater scope which can introduce subttle errors            // as such we prefers to have the setup called right at the beginning of the test. this also allow yout o name it accordingly for easier to read tests.            const {Token} = await setup();            // This test expects the owner variable stored in the contract to be equal to our configured owner            const {tokenOwner} = await getNamedAccounts();            expect(await Token.owner()).to.equal(tokenOwner);          });          it("Should assign the total supply of tokens to the owner", async function () {            const {Token, tokenOwner} = await setup();            const ownerBalance = await Token.balanceOf(tokenOwner.address);            expect(await Token.totalSupply()).to.equal(ownerBalance);          });        });        describe("Transactions", function () {          it("Should transfer tokens between accounts", async function () {            const {Token, users, tokenOwner} = await setup();            // Transfer 50 tokens from owner to users[0]            await tokenOwner.Token.transfer(users[0].address, 50);            const users0Balance = await Token.balanceOf(users[0].address);            expect(users0Balance).to.equal(50);            // Transfer 50 tokens from users[0] to users[1]            // We use .connect(signer) to send a transaction from another account            await users[0].Token.transfer(users[1].address, 50);            const users1Balance = await Token.balanceOf(users[1].address);            expect(users1Balance).to.equal(50);          });          it("Should fail if sender doesn’t have enough tokens", async function () {            const {Token, users, tokenOwner} = await setup();            const initialOwnerBalance = await Token.balanceOf(tokenOwner.address);            // Try to send 1 token from users[0] (0 tokens) to owner (1000 tokens).            // `require` will evaluate false and revert the transaction.            await expect(users[0].Token.transfer(tokenOwner.address, 1)            ).to.be.revertedWith("Not enough tokens");            // Owner balance shouldn't have changed.            expect(await Token.balanceOf(tokenOwner.address)).to.equal(              initialOwnerBalance            );          });          it("Should update balances after transfers", async function () {            const {Token, users, tokenOwner} = await setup();            const initialOwnerBalance = await Token.balanceOf(tokenOwner.address);            // Transfer 100 tokens from owner to users[0].            await tokenOwner.Token.transfer(users[0].address, 100);            // Transfer another 50 tokens from owner to users[1].            await tokenOwner.Token.transfer(users[1].address, 50);            // Check balances.            const finalOwnerBalance = await Token.balanceOf(tokenOwner.address);            expect(finalOwnerBalance).to.equal(initialOwnerBalance - 150);            const users0Balance = await Token.balanceOf(users[0].address);            expect(users0Balance).to.equal(100);            const users1Balance = await Token.balanceOf(users[1].address);            expect(users1Balance).to.equal(50);          });        });      });  

    $ yarn hardhat test        Token contract          Deployment            ✓ Should set the right owner            ✓ Should assign the total supply of tokens to the owner          Transactions            ✓ Should transfer tokens between accounts (199ms)            ✓ Should fail if sender doesn’t have enough tokens            ✓ Should update balances after transfers (111ms)        5 passing (1s)  

    pragma solidity 0.7.6;      import "hardhat/console.sol";      contract Token {        //...      }  

    function transfer(address to, uint256 amount) external {          console.log("Sender balance is %s tokens", balances[msg.sender]);          console.log("Trying to send %s tokens to %s", amount, to);          require(balances[msg.sender] >= amount, "Not enough tokens");          balances[msg.sender] -= amount;          balances[to] += amount;      }  

    $ yarn hardhat test        Token contract          Deployment            ✓ Should set the right owner            ✓ Should assign the total supply of tokens to the owner          Transactions      Sender balance is 1000 tokens      Trying to send 50 tokens to 0xead9c93b79ae7c1591b1fb5323bd777e86e150d4      Sender balance is 50 tokens      Trying to send 50 tokens to 0xe5904695748fe4a84b40b3fc79de2277660bd1d3            ✓ Should transfer tokens between accounts (373ms)            ✓ Should fail if sender doesn’t have enough tokens      Sender balance is 1000 tokens      Trying to send 100 tokens to 0xead9c93b79ae7c1591b1fb5323bd777e86e150d4      Sender balance is 900 tokens      Trying to send 100 tokens to 0xe5904695748fe4a84b40b3fc79de2277660bd1d3            ✓ Should update balances after transfers (187ms)        5 passing (2s)  

    Nothing to compile      deploying "Token" (tx: 0x259d19f33819ec8d3bd994f82912aec6af1a18ec5d74303cfb28d793a10ff683)...: deployed at 0x5FbDB2315678afecb367f032d93F642f64180aa3 with 592983 gas      Done in 3.79s.  

    yarn hardhat --network  deploy  

    import 'dotenv/config';      export function node_url(networkName: string): string {        if (networkName) {          const uri = process.env['ETH_NODE_URI_' + networkName.toUpperCase()];          if (uri && uri !== '') {            return uri;          }        }        let uri = process.env.ETH_NODE_URI;        if (uri) {          uri = uri.replace('{{networkName}}', networkName);        }        if (!uri || uri === '') {          if (networkName === 'localhost') {            return 'http://localhost:8545';          }          return '';        }        if (uri.indexOf('{{') >= 0) {          throw new Error(            `invalid uri or network not supported by nod eprovider : ${uri}`          );        }        return uri;      }      export function getMnemonic(networkName?: string): string {        if (networkName) {          const mnemonic = process.env['MNEMONIC_' + networkName.toUpperCase()];          if (mnemonic && mnemonic !== '') {            return mnemonic;          }        }        const mnemonic = process.env.MNEMONIC;        if (!mnemonic || mnemonic === '') {          return 'test test test test test test test test test test test junk';        }        return mnemonic;      }      export function accounts(networkName?: string): {mnemonic: string} {        return {mnemonic: getMnemonic(networkName)};      }  

    import {HardhatUserConfig} from 'hardhat/types';      import 'hardhat-deploy';      import 'hardhat-deploy-ethers';      import {node_url, accounts} from './utils/network';      const config: HardhatUserConfig = {        solidity: {          version: '0.7.6',        },        networks: {          rinkeby: {            url: node_url('rinkeby'),            accounts: accounts('rinkeby'),          },        },        namedAccounts: {          deployer: 0,          tokenOwner: 1,        },        paths: {          sources: 'hide',        },      };      export default config;  

    ETH_NODE_URI_RINKEBY=https://eth-rinkeby.alchemyapi.io/v2/      MNEMONIC_RINKEBY=for rinkeby>  

    yarn hardhat --network rinkeby deploy  

    Nothing to compile      deploying "Token" (tx: 0xb40879c3162e6a924cfadfc1027c4629dd57ee4ba08a5f8af575be1c751cd515)...: deployed at 0x8bDFEf5f67685725BC0eD9f54f20A2A4d3FEDA98 with 475842 gas  

    yarn hardhat --network rinkeby sourcify  

    verifying Token (0x8bDFEf5f67685725BC0eD9f54f20A2A4d3FEDA98 on chain 4) ...       => contract Token is now verified  

    yarn hardhat --network rinkeby etherscan-verify --api-key   

    verifying Token (0x8bDFEf5f67685725BC0eD9f54f20A2A4d3FEDA98) ...      waiting for result...       => contract Token is now verified