Add ERC20 token with snapshoting mechanism (#1209)

contracts/mocks/ERC20SnapshotMock.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.4.24;
+
+import "../token/ERC20/ERC20Snapshot.sol";
+
+
+contract ERC20SnapshotMock is ERC20Snapshot {
+
+  constructor(address initialAccount, uint256 initialBalance) public {
+    _mint(initialAccount, initialBalance);
+  }
+
+  function mint(address account, uint256 amount) public {
+    _mint(account, amount);
+  }
+
+  function burn(address account, uint256 amount) public {
+    _burn(account, amount);
+  }
+}

contracts/token/ERC20/ERC20Snapshot.sol

@@ -0,0 +1,130 @@
+pragma solidity ^0.4.24;
+
+import "./ERC20.sol";
+import "../../utils/Arrays.sol";
+
+
+/**
+ * @title ERC20Snapshot token
+ * @dev An ERC20 token which enables taking snapshots of account balances.
+ * This can be useful to safely implement voting weighed by balance.
+ */
+contract ERC20Snapshot is ERC20 {
+
+  using Arrays for uint256[];
+
+  // The 0 id represents no snapshot was taken yet.
+  uint256 private currentSnapshotId;
+
+  mapping (address => uint256[]) private snapshotIds;
+  mapping (address => uint256[]) private snapshotBalances;
+
+  event Snapshot(uint256 id);
+
+  /**
+   * @dev Increments current snapshot. Emites Snapshot event.
+   * @return An uint256 representing current snapshot id.
+   */
+  function snapshot() external returns (uint256) {
+    currentSnapshotId += 1;
+    emit Snapshot(currentSnapshotId);
+    return currentSnapshotId;
+  }
+
+  /**
+   * @dev Returns account balance for specific snapshot.
+   * @param account address The address to query the balance of.
+   * @param snapshotId uint256 The snapshot id for which to query the balance of.
+   * @return An uint256 representing the amount owned by the passed address for specific snapshot.
+   */
+  function balanceOfAt(
+    address account,
+    uint256 snapshotId
+  )
+    public
+    view
+    returns (uint256)
+  {
+    require(snapshotId > 0 && snapshotId <= currentSnapshotId);
+
+    uint256 idx = snapshotIds[account].findUpperBound(snapshotId);
+
+    if (idx == snapshotIds[account].length) {
+      return balanceOf(account);
+    } else {
+      return snapshotBalances[account][idx];
+    }
+  }
+
+  /**
+  * @dev Transfer token for a specified address. It takes balance snapshot for the sender and recipient account
+  * before transfer is done.
+  * @param to The address to transfer to.
+  * @param value The amount to be transferred.
+  */
+  function transfer(address to, uint256 value) public returns (bool) {
+    updateSnapshot(msg.sender);
+    updateSnapshot(to);
+    return super.transfer(to, value);
+  }
+
+  /**
+   * @dev Transfer tokens from one address to another. It takes balance snapshot of both accounts before
+   * the transfer is done.
+   * @param from address The address which you want to send tokens from
+   * @param to address The address which you want to transfer to
+   * @param value uint256 the amount of tokens to be transferred
+   */
+  function transferFrom(
+    address from,
+    address to,
+    uint256 value
+  ) 
+    public
+    returns (bool)
+  {
+    updateSnapshot(from);
+    updateSnapshot(to);
+    return super.transferFrom(from, to, value);
+  }
+
+  /**
+   * @dev Internal function that mints an amount of the token and assigns it to
+   * an account. This encapsulates the modification of balances such that the
+   * proper events are emitted. Takes snapshot before tokens are minted.
+   * @param account The account that will receive the created tokens.
+   * @param amount The amount that will be created.
+   */
+  function _mint(address account, uint256 amount) internal {
+    updateSnapshot(account);
+    super._mint(account, amount);
+  }
+
+  /**
+   * @dev Internal function that burns an amount of the token of a given
+   * account. Takes snapshot before tokens are burned.
+   * @param account The account whose tokens will be burnt.
+   * @param amount The amount that will be burnt.
+   */
+  function _burn(address account, uint256 amount) internal {
+    updateSnapshot(account);
+    super._burn(account, amount);
+  }
+
+  function updateSnapshot(address account) private {
+    if (lastSnapshotId(account) < currentSnapshotId) {
+      snapshotIds[account].push(currentSnapshotId);
+      snapshotBalances[account].push(balanceOf(account));
+    }
+  }
+
+  function lastSnapshotId(address account) private view returns (uint256) {
+    uint256[] storage snapshots = snapshotIds[account];
+    if (snapshots.length == 0) {
+      return 0;
+    } else {
+      return snapshots[snapshots.length - 1];
+    }
+  }
+
+}

contracts/utils/Arrays.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.4.23;
+
+import "../math/Math.sol";
+
+
+/**
+ * @title Arrays
+ * @dev Utility library of inline array functions
+ */
+library Arrays {
+
+  /**
+   * @dev Find upper bound for searching element. Utilize binary search function with O(log(n)) cost.
+   */
+  function findUpperBound(
+    uint256[] storage array,
+    uint256 element
+  ) 
+    internal
+    view
+    returns (uint256)
+  {
+    uint256 low = 0;
+    uint256 high = array.length;
+
+    while (low < high) {
+      uint256 mid = Math.average(low, high);
+
+      if (array[mid] > element) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+
+    // At this point at `low` is the exclusive upper bound. We will return the inclusive upper bound.
+    if (low > 0 && array[low - 1] == element) {
+      return low - 1;
+    } else {
+      return low;
+    }
+  }
+}

test/token/ERC20/ERC20Snapshot.test.js

@@ -0,0 +1,136 @@
+const ERC20Snapshot = artifacts.require('ERC20SnapshotMock');
+const { expectThrow } = require('../../helpers/expectThrow');
+const { EVMRevert } = require('../../helpers/EVMRevert');
+const BigNumber = web3.BigNumber;
+
+require('chai')
+  .use(require('chai-bignumber')(BigNumber))
+  .should();
+
+contract('ERC20Snapshot', function ([_, owner, recipient, spender]) {
+  beforeEach(async function () {
+    this.token = await ERC20Snapshot.new(owner, 100);
+  });
+
+  context('there is no snapshots yet', function () {
+    describe('balanceOfAt', function () {
+      it('rejected for snapshotId parameter equals to 0', async function () {
+        await expectThrow(
+          this.token.balanceOfAt(owner, 0),
+          EVMRevert,
+        );
+      });
+
+      it('rejected for snapshotId parameter greather than currentSnapshotId', async function () {
+        await expectThrow(
+          this.token.balanceOfAt(owner, 1),
+          EVMRevert,
+        );
+      });
+    });
+
+    describe('after transfer', function () {
+      beforeEach(async function () {
+        await this.token.transfer(recipient, 10, { from: owner });
+      });
+
+      it('balanceOf returns correct value', async function () {
+        (await this.token.balanceOf(owner)).should.be.bignumber.equal(90);
+        (await this.token.balanceOf(recipient)).should.be.bignumber.equal(10);
+      });
+    });
+  });
+
+  context('snapshots exist', function () {
+    beforeEach(async function () {
+      await this.token.snapshot();
+    });
+
+    describe('accounts do not have snapshots yet', function () {
+      it('snapshot value of the owner account equals to his balance', async function () {
+        const balanceOfAt = (await this.token.balanceOfAt(owner, 1));
+        const balanceOf = (await this.token.balanceOf(owner));
+        balanceOfAt.should.be.bignumber.equal(balanceOf);
+      });
+
+      it('snapshot value of the recipient account equals to balance', async function () {
+        const balanceOfAt = (await this.token.balanceOfAt(recipient, 1));
+        const balanceOf = (await this.token.balanceOf(recipient));
+        balanceOfAt.should.be.bignumber.equal(balanceOf);
+      });
+    });
+
+    describe('accounts have already one snapshot', function () {
+      beforeEach(async function () {
+        await this.token.transfer(recipient, 10, { from: owner });
+      });
+
+      it('snapshot keeps previous balance', async function () {
+        (await this.token.balanceOfAt(owner, 1)).should.be.bignumber.equal(100);
+        (await this.token.balanceOfAt(recipient, 1)).should.be.bignumber.equal(0);
+      });
+
+      it('account has correct balance', async function () {
+        (await this.token.balanceOf(owner)).should.be.bignumber.equal(90);
+        (await this.token.balanceOf(recipient)).should.be.bignumber.equal(10);
+      });
+    });
+
+    describe('snapshot keeps previous balance even for multiple transfers', async function () {
+      beforeEach(async function () {
+        await this.token.transfer(recipient, 10, { from: owner });
+        await this.token.transfer(recipient, 10, { from: owner });
+      });
+
+      it('snapshot has previous balance', async function () {
+        (await this.token.balanceOfAt(owner, 1)).should.be.bignumber.equal(100);
+        (await this.token.balanceOfAt(recipient, 1)).should.be.bignumber.equal(0);
+      });
+
+      it('account has correct balance', async function () {
+        (await this.token.balanceOf(owner)).should.be.bignumber.equal(80);
+        (await this.token.balanceOf(recipient)).should.be.bignumber.equal(20);
+      });
+    });
+
+    describe('snapshot keeps correct values for transfer from action', async function () {
+      beforeEach(async function () {
+        await this.token.approve(spender, 20, { from: owner });
+        await this.token.transferFrom(owner, recipient, 20, { from: spender });
+      });
+
+      it('spender and recipient snapshot is stored', async function () {
+        (await this.token.balanceOfAt(owner, 1)).should.be.bignumber.equal(100);
+        (await this.token.balanceOfAt(recipient, 1)).should.be.bignumber.equal(0);
+      });
+    });
+
+    describe('new tokens are minted', function () {
+      beforeEach(async function () {
+        await this.token.mint(owner, 50);
+      });
+
+      it('snapshot keeps balance before mint', async function () {
+        (await this.token.balanceOfAt(owner, 1)).should.be.bignumber.equal(100);
+      });
+
+      it('current balance is greater after mint', async function () {
+        (await this.token.balanceOf(owner)).should.be.bignumber.equal(150);
+      });
+    });
+
+    describe('chunk tokens are burned', function () {
+      beforeEach(async function () {
+        await this.token.burn(owner, 30);
+      });
+
+      it('snapshot keeps balance before burn', async function () {
+        (await this.token.balanceOfAt(owner, 1)).should.be.bignumber.equal(100);
+      });
+
+      it('crrent balance is lower after burn', async function () {
+        (await this.token.balanceOf(owner)).should.be.bignumber.equal(70);
+      });
+    });
+  });
+});