スマートコントラクトの開発環境「waffle」を使用してみた

yarn add --dev ethereum-waffle
yarn add @openzeppelin/contracts@^4.6.0 -D

# ファイル構成
.
├── package.json
├── src
│   └── BasicToken.sol
├── waffle.json

# package.json
{
  "scripts": {
    "build": "waffle"
  },
  "devDependencies": {
    "@openzeppelin/contracts": "^4.6.0",
    "ethereum-waffle": "^3.4.4"
  }
}

# waffle.json
{
  "compilerType": "solcjs",
  "compilerVersion": "0.8.13",
  "sourceDirectory": "./src",
  "outputDirectory": "./build"
}

// src/BasicToken.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// Example class - a mock class using delivering from ERC20
contract BasicToken is ERC20 {
  constructor(uint256 initialBalance) ERC20("Basic", "BSC") {
      _mint(msg.sender, initialBalance);
  }
}

# ビルドコマンド
yarn build

# ERC20ビルドファイル
.
├── build
│   ├── BasicToken.json
│   ├── Context.json
│   ├── ERC20.json
│   ├── IERC20.json
│   └── IERC20Metadata.json

# 出力の一部（build/BasicToken.json）
{
  "abi": [
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "initialBalance",
          "type": "uint256"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {...

# 出力ファイルの構成（Contract JSON ABI）
- abi: []
- evm:
  - bytecode
    - functionDebugData
    - generatedSources
    - linkReferences
    - object
    - opcodes
    - sourceMap
  - deployedBytecode
- bytecode: str

# bytecodeの一部
  "bytecode": "60806040523480156200001157600080fd5b506040516200179438038062001794833981810160405281019062000037919062000357565b604051806

# objectの一部
      "object": "608060405234801561001057600080fd5b50600436106100a95760003560e01c80633950935111610071578063395093511461016857806370a082311

# opcodesの一部
      "opcodes": "PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0x10 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x4 CALLDATASIZE LT PUSH2 0xA9 JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 

# sourceMapの一部
      "sourceMap": "175:139:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2154:98:0;;;:::i;::

# functionDebugDataの一部
      "functionDebugData": {
        "@_44": {
          "entryPoint": null,
          "id": 44,
          "parameterSlots": 2,
          "returnSlots": 0
        },

# generatedSourcesの一部
      "generatedSources": [
        {
          "ast": {
            "nodeType": "YulBlock",
            "src": "0:3568:5",
            "statements": [
              {

# MoachaとChaiのインストールコマンド
yarn add --dev mocha chai @types/mocha
# Typescriptのインストールコマンド
yarn add --dev typescript ts-node

# package.json
{
  "scripts": {
    "build": "waffle"
  },
  "devDependencies": {
    "@openzeppelin/contracts": "^4.6.0",
    "chai": "^4.3.7",
    "ethereum-waffle": "^3.4.4",
    "mocha": "^10.1.0"
  }
}

# test/BasicToken.test.ts

import {expect, use} from 'chai';
import {Contract} from 'ethers';
import {deployContract, MockProvider, solidity} from 'ethereum-waffle';
import BasicToken from '../build/BasicToken.json';

use(solidity);

describe('BasicToken', () => {
  const [wallet, walletTo] = new MockProvider().getWallets();
  let token: Contract;

  beforeEach(async () => {
    token = await deployContract(wallet, BasicToken, [1000]);
  });

  it('Assigns initial balance', async () => {
    expect(await token.balanceOf(wallet.address)).to.equal(1000);
  });

  it('Transfer adds amount to destination account', async () => {
    await token.transfer(walletTo.address, 7);
    expect(await token.balanceOf(walletTo.address)).to.equal(7);
  });

  it('Transfer emits event', async () => {
    await expect(token.transfer(walletTo.address, 7))
      .to.emit(token, 'Transfer')
      .withArgs(wallet.address, walletTo.address, 7);
  });

  it('Can not transfer above the amount', async () => {
    await expect(token.transfer(walletTo.address, 1007)).to.be.reverted;
  });

  it('Can not transfer from empty account', async () => {
    const tokenFromOtherWallet = token.connect(walletTo);
    await expect(tokenFromOtherWallet.transfer(wallet.address, 1))
      .to.be.reverted;
  });

  it('Calls totalSupply on BasicToken contract', async () => {
    await token.totalSupply();
    expect('totalSupply').to.be.calledOnContract(token);
  });

  it('Calls balanceOf with sender address on BasicToken contract', async () => {
    await token.balanceOf(wallet.address);
    expect('balanceOf').to.be.calledOnContractWith(token, [wallet.address]);
  });
});

# .mocharc.json
{
  "require": "ts-node/register/transpile-only",
  "spec": "test/**/*.test.{js,ts}"
}

# package.json
{
  "scripts": {
    "build": "waffle",
    "test": "NODE_ENV=test mocha --openssl-legacy-provider"
  },
  "devDependencies": {
    "@openzeppelin/contracts": "^4.6.0",
    "@types/mocha": "^10.0.0",
    "chai": "^4.3.7",
    "ethereum-waffle": "^3.4.4",
    "mocha": "^10.1.0"
  },
  "dependencies": {
    "ts-node": "^10.9.1",
    "typescript": "^4.9.3"
  }
}

# テスト結果
yarn test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  BasicToken
    ✔ Assigns initial balance
    ✔ Transfer adds amount to destination account (59ms)
    ✔ Transfer emits event (49ms)
    ✔ Can not transfer above the amount
    ✔ Can not transfer from empty account
    ✔ Calls totalSupply on BasicToken contract
    ✔ Calls balanceOf with sender address on BasicToken contract


  7 passing (773ms)

# Mochaによる単純テスト

describe('tests', () => {

  let v = 1

  it('is equal to 5', async () => {
    if (v===5) {
      return
    }
    throw '5ではありません'
  });

  it('is bigger than 4', async () => {
    if (v>4) {
      return
    }
    throw '5以下です'
  });

  it('is smaller than 6', async () => {
    if (v<6) {
      return
    }
    throw '6以上です'
  });

});

# Mochaによる単純テストの出力結果

yarn test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  tests
    1) is equal to 5
    2) is bigger than 4
    ✔ is smaller than 6


  1 passing (5ms)
  2 failing

  1) tests
       is equal to 5:
     Error: the string "5ではありません" was thrown, throw an Error :)


  2) tests
       is bigger than 4:
     Error: the string "5以下です" was thrown, throw an Error :)

# Mochaによる単純テストの出力結果(全てパス)
yarn test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  tests
    ✔ is equal to 5
    ✔ is bigger than 4
    ✔ is smaller than 6


  3 passing (2ms)

// Mochaでテスト毎の前処理を追加

describe('tests', () => {

  let v = 6

  beforeEach(async () => {
    v = 5
  });

  it('is equal to 5', async () => {
    if (v===5) {
      return
    }
    throw '5ではありません'
  });

});

# 実行結果
yarn run test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  tests
    ✔ is equal to 5


  1 passing (2ms)

// Chaiを加えた単純テストコード

import {expect} from 'chai';

describe('tests', () => {

  let v = 1

  it('is equal to 5', async () => {
    expect(v).to.equal(5);
  });

  it('is bigger than 4', async () => {
    expect(v).to.be.above(4);
  });

  it('is smaller than 6', async () => {
    expect(v).to.be.below(6)
  });
});

# Chaiを加えた単純テストコードの出力結果

yarn test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  tests
    1) is equal to 5
    2) is bigger than 4
    ✔ is smaller than 6


  1 passing (6ms)
  2 failing

  1) tests
       is equal to 5:

      AssertionError: expected 1 to equal 5
      + expected - actual

      -1
      +5

      at Context.<anonymous> (test/BasicToken.test.ts:13:18)
      at processImmediate (node:internal/timers:471:21)

  2) tests
       is bigger than 4:

      AssertionError: expected 1 to be above 4
      + expected - actual

      -1
      +4

      at Context.<anonymous> (test/BasicToken.test.ts:17:21)
      at processImmediate (node:internal/timers:471:21)

// 今回使用した3つの機能
expect(v).to.equal(5);
expect(v).to.be.above(4);
expect(v).to.be.below(6)

// 数値が想定通りに得られるかを計算する自作アサーション

import {expect, use} from 'chai';

const f = (chai, _)=>{
  var Assertion = chai.Assertion;

  Assertion.addMethod("myequal", function(val, msg) {
    if (msg) {
      _.flag(this, "message", msg)
    }
    var obj = _.flag(this, "object")

    this.assert(
      val === obj,
      "expected #{this} to equal #{exp}",
      "expected #{this} to not equal #{exp}",
      val
    );
  });
}

use(f)

describe('tests', () => {

  let v = 6

  it('is my equal to 5', async () => {
    expect(v).to.myequal(5)
  });

  it('is my not equal to 5', async () => {
    expect(v).to.not.myequal(5)
  });

  it('is my equal to 6', async () => {
    expect(v).to.not.myequal(6)
  });

# 出力結果

yarn run test
yarn run v1.22.19
warning package.json: No license field
$ NODE_ENV=test mocha --openssl-legacy-provider


  tests
    1) is my equal to 5
    ✔ is my not equal to 5
    2) is my equal to 6


  1 passing (7ms)
  2 failing

  1) tests
       is my equal to 5:

      AssertionError: expected 6 to equal 5
      + expected - actual

      -6
      +5

      at Context.<anonymous> (test/BasicToken.test.ts:33:18)
      at processImmediate (node:internal/timers:471:21)

  2) tests
       is my equal to 6:

      AssertionError: expected 6 to not equal 6
      + expected - actual


      at Context.<anonymous> (test/BasicToken.test.ts:41:22)
      at processImmediate (node:internal/timers:471:21)

// Chaiで使用可能なEthereum用アサーション

import {solidity} from 'ethereum-waffle';

use(solidity);

// コントラクトをデプロイして発行したトークン量が正しい値かを検証する

import {expect, use} from 'chai';
import {Contract} from 'ethers';
import {deployContract, MockProvider, solidity} from 'ethereum-waffle';
import BasicToken from '../build/BasicToken.json';

use(solidity);

describe('BasicToken', () => {
  const [wallet] = new MockProvider().getWallets();
  let token: Contract;

  beforeEach(async () => {
    token = await deployContract(wallet, BasicToken, [1000]);
  });

  it('Assigns initial balance', async () => {
    expect(await token.balanceOf(wallet.address)).to.equal(1000);
  });

});