test: add erc20 tests (#37)

integration-tests/contracts/ERC20.sol

+// SPDX-License-Identifier: MIT
+pragma solidity >=0.7.0 <0.8.0;
+
+contract ERC20 {
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+    uint256 constant private MAX_UINT256 = 2**256 - 1;
+    mapping (address => uint256) public balances;
+    mapping (address => mapping (address => uint256)) public allowed;
+    /*
+    NOTE:
+    The following variables are OPTIONAL vanities. One does not have to include them.
+    They allow one to customise the token contract & in no way influences the core functionality.
+    Some wallets/interfaces might not even bother to look at this information.
+    */
+    string public name;                   //fancy name: eg OVM Coin
+    uint8 public decimals;                //How many decimals to show.
+    string public symbol;                 //An identifier: eg OVM
+    uint256 public totalSupply;
+
+    constructor(
+        uint256 _initialAmount,
+        string memory _tokenName,
+        uint8 _decimalUnits,
+        string memory _tokenSymbol
+    ) public {
+        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
+        totalSupply = _initialAmount;                        // Update total supply
+        name = _tokenName;                                   // Set the name for display purposes
+        decimals = _decimalUnits;                            // Amount of decimals for display purposes
+        symbol = _tokenSymbol;                               // Set the symbol for display purposes
+    }
+
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        require(balances[msg.sender] >= _value);
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        uint256 allowance = allowed[_from][msg.sender];
+        require(balances[_from] >= _value && allowance >= _value);
+        balances[_to] += _value;
+        balances[_from] -= _value;
+        if (allowance < MAX_UINT256) {
+            allowed[_from][msg.sender] -= _value;
+        }
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function balanceOf(address _owner) public view returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) public returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+}

integration-tests/test/erc20.spec.ts

+import { Contract, ContractFactory, Wallet } from 'ethers'
+import { ethers } from 'hardhat'
+import { expect } from 'chai'
+
+describe('Basic ERC20 interactions', async () => {
+  const initialAmount = 1000
+  const tokenName = 'OVM Test'
+  const tokenDecimals = 8
+  const TokenSymbol = 'OVM'
+
+  let wallet: Wallet
+  let other: Wallet
+  let Factory__ERC20: ContractFactory
+  let ERC20: Contract
+
+  before(async () => {
+    wallet = Wallet.createRandom().connect(ethers.provider)
+    other = Wallet.createRandom().connect(ethers.provider)
+    Factory__ERC20 = await ethers.getContractFactory('ERC20', wallet)
+  })
+
+  beforeEach(async () => {
+    ERC20 = await Factory__ERC20.deploy(
+      initialAmount,
+      tokenName,
+      tokenDecimals,
+      TokenSymbol
+    )
+  })
+
+  it('should set the total supply', async () => {
+    const totalSupply = await ERC20.totalSupply()
+    expect(totalSupply.toNumber()).to.equal(initialAmount)
+  })
+
+  it('should get the token name', async () => {
+    const name = await ERC20.name()
+    expect(name).to.equal(tokenName)
+  })
+
+  it('should get the token decimals', async () => {
+    const decimals = await ERC20.decimals()
+    expect(decimals).to.equal(tokenDecimals)
+  })
+
+  it('should get the token symbol', async () => {
+    const symbol = await ERC20.symbol()
+    expect(symbol).to.equal(TokenSymbol)
+  })
+
+  it('should assign initial balance', async () => {
+    const balance = await ERC20.balanceOf(wallet.address)
+    expect(balance.toNumber()).to.equal(initialAmount)
+  })
+
+  it('should transfer amount to destination account', async () => {
+    const transfer = await ERC20.transfer(other.address, 100)
+    const receipt = await transfer.wait()
+
+    // There are two events from the transfer with the first being
+    // the fee of value 0 and the second of the value transfered (100)
+    expect(receipt.events.length).to.equal(2)
+    expect(receipt.events[0].args._value.toNumber()).to.equal(0)
+    expect(receipt.events[1].args._from).to.equal(wallet.address)
+    expect(receipt.events[1].args._value.toNumber()).to.equal(100)
+
+    const receiverBalance = await ERC20.balanceOf(other.address)
+    const senderBalance = await ERC20.balanceOf(wallet.address)
+
+    expect(receiverBalance.toNumber()).to.equal(100)
+    expect(senderBalance.toNumber()).to.equal(900)
+  })
+})