Merge branch 'master' into less-helpers

Author: nventuro

contracts/bounties/BreakInvariantBounty.sol

@@ -8,12 +8,16 @@ import "../ownership/Ownable.sol";
  * @dev This bounty will pay out to a researcher if they break invariant logic of the contract.
  */
 contract BreakInvariantBounty is PullPayment, Ownable {
-  bool private _claimable = true;
+  bool private _claimable;
   mapping(address => address) private _researchers;
 
   event TargetCreated(address createdAddress);
   event BountyCanceled();
 
+  constructor() public {
+    _claimable = true;
+  }
+
   /**
    * @dev Fallback function allowing the contract to receive funds, if they haven't already been claimed.
    */

contracts/ownership/Ownable.sol

@@ -8,7 +8,6 @@ pragma solidity ^0.4.24;
 contract Ownable {
   address private _owner;
 
-  event OwnershipRenounced(address indexed previousOwner);
   event OwnershipTransferred(
     address indexed previousOwner,
     address indexed newOwner
@@ -20,6 +19,7 @@ contract Ownable {
    */
   constructor() public {
     _owner = msg.sender;
+    emit OwnershipTransferred(address(0), _owner);
   }
 
   /**
@@ -51,7 +51,7 @@ contract Ownable {
    * modifier anymore.
    */
   function renounceOwnership() public onlyOwner {
-    emit OwnershipRenounced(_owner);
+    emit OwnershipTransferred(_owner, address(0));
     _owner = address(0);
   }
 

test/access/Roles.test.js

@@ -1,13 +1,12 @@
 const shouldFail = require('../helpers/shouldFail');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const RolesMock = artifacts.require('RolesMock');
 
 require('chai')
   .should();
 
 contract('Roles', function ([_, authorized, otherAuthorized, anyone]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   beforeEach(async function () {
     this.roles = await RolesMock.new();
   });

test/access/roles/PublicRole.behavior.js

@@ -1,4 +1,5 @@
 const shouldFail = require('../../helpers/shouldFail');
+const { ZERO_ADDRESS } = require('../../helpers/constants');
 const expectEvent = require('../../helpers/expectEvent');
 
 require('chai')
@@ -10,7 +11,6 @@ function capitalize (str) {
 
 function shouldBehaveLikePublicRole (authorized, otherAuthorized, [anyone], rolename) {
   rolename = capitalize(rolename);
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   describe('should behave like public role', function () {
     beforeEach('check preconditions', async function () {

test/crowdsale/AllowanceCrowdsale.test.js

@@ -2,6 +2,7 @@ const expectEvent = require('../helpers/expectEvent');
 const { ether } = require('../helpers/ether');
 const shouldFail = require('../helpers/shouldFail');
 const { ethGetBalance } = require('../helpers/web3');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -17,7 +18,6 @@ contract('AllowanceCrowdsale', function ([_, investor, wallet, purchaser, tokenW
   const value = ether(0.42);
   const expectedTokenAmount = rate.mul(value);
   const tokenAllowance = new BigNumber('1e22');
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   beforeEach(async function () {
     this.token = await SimpleToken.new({ from: tokenWallet });

test/crowdsale/Crowdsale.test.js

@@ -2,6 +2,7 @@ const expectEvent = require('../helpers/expectEvent');
 const shouldFail = require('../helpers/shouldFail');
 const { ether } = require('../helpers/ether');
 const { ethGetBalance } = require('../helpers/web3');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -17,7 +18,6 @@ contract('Crowdsale', function ([_, investor, wallet, purchaser]) {
   const value = ether(42);
   const tokenSupply = new BigNumber('1e22');
   const expectedTokenAmount = rate.mul(value);
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   it('requires a non-null token', async function () {
     await shouldFail.reverting(

test/drafts/ERC20Migrator.test.js

@@ -1,4 +1,5 @@
 const shouldFail = require('../helpers/shouldFail');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const ERC20Mock = artifacts.require('ERC20Mock');
 const ERC20Mintable = artifacts.require('ERC20Mintable');
@@ -11,8 +12,6 @@ require('chai')
   .should();
 
 contract('ERC20Migrator', function ([_, owner, recipient, anotherAccount]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   const totalSupply = 200;
 
   it('reverts with a null legacy token address', async function () {

test/examples/SimpleToken.test.js

@@ -1,4 +1,5 @@
 const { decodeLogs } = require('../helpers/decodeLogs');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 const SimpleToken = artifacts.require('SimpleToken');
 
 const BigNumber = web3.BigNumber;
@@ -8,8 +9,6 @@ require('chai')
   .should();
 
 contract('SimpleToken', function ([_, creator]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   beforeEach(async function () {
     this.token = await SimpleToken.new({ from: creator });
   });

test/helpers/constants.js

@@ -0,0 +1,6 @@
+const BigNumber = web3.BigNumber;
+
+module.exports = {
+  ZERO_ADDRESS: '0x0000000000000000000000000000000000000000',
+  MAX_UINT256: new BigNumber(2).pow(256).minus(1),
+};

test/math/SafeMath.test.js

@@ -1,4 +1,5 @@
 const shouldFail = require('../helpers/shouldFail');
+const { MAX_UINT256 } = require('../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 const SafeMathMock = artifacts.require('SafeMathMock');
@@ -8,8 +9,6 @@ require('chai')
   .should();
 
 contract('SafeMath', function () {
-  const MAX_UINT = new BigNumber(2).pow(256).minus(1);
-
   beforeEach(async function () {
     this.safeMath = await SafeMathMock.new();
   });
@@ -23,7 +22,7 @@ contract('SafeMath', function () {
     });
 
     it('throws a revert error on addition overflow', async function () {
-      const a = MAX_UINT;
+      const a = MAX_UINT256;
       const b = new BigNumber(1);
 
       await shouldFail.reverting(this.safeMath.add(a, b));
@@ -62,7 +61,7 @@ contract('SafeMath', function () {
     });
 
     it('throws a revert error on multiplication overflow', async function () {
-      const a = MAX_UINT;
+      const a = MAX_UINT256;
       const b = new BigNumber(2);
 
       await shouldFail.reverting(this.safeMath.mul(a, b));

test/ownership/Ownable.behavior.js

@@ -1,6 +1,6 @@
 const shouldFail = require('../helpers/shouldFail');
-
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const expectEvent = require('../helpers/expectEvent');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 require('chai')
   .should();
@@ -13,7 +13,8 @@ function shouldBehaveLikeOwnable (owner, [anyone]) {
 
     it('changes owner after transfer', async function () {
       (await this.ownable.isOwner({ from: anyone })).should.be.equal(false);
-      await this.ownable.transferOwnership(anyone, { from: owner });
+      const { logs } = await this.ownable.transferOwnership(anyone, { from: owner });
+      expectEvent.inLogs(logs, 'OwnershipTransferred');
 
       (await this.ownable.owner()).should.equal(anyone);
       (await this.ownable.isOwner({ from: anyone })).should.be.equal(true);
@@ -28,7 +29,9 @@ function shouldBehaveLikeOwnable (owner, [anyone]) {
     });
 
     it('loses owner after renouncement', async function () {
-      await this.ownable.renounceOwnership({ from: owner });
+      const { logs } = await this.ownable.renounceOwnership({ from: owner });
+      expectEvent.inLogs(logs, 'OwnershipTransferred');
+
       (await this.ownable.owner()).should.equal(ZERO_ADDRESS);
     });
 

test/ownership/Secondary.test.js

@@ -1,13 +1,12 @@
 const shouldFail = require('../helpers/shouldFail');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const SecondaryMock = artifacts.require('SecondaryMock');
 
 require('chai')
   .should();
 
 contract('Secondary', function ([_, primary, newPrimary, anyone]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   beforeEach(async function () {
     this.secondary = await SecondaryMock.new({ from: primary });
   });

test/payment/ConditionalEscrow.test.js

@@ -1,5 +1,7 @@
 const { shouldBehaveLikeEscrow } = require('./Escrow.behavior');
+
 const shouldFail = require('../helpers/shouldFail');
+const { ether } = require('../helpers/ether');
 
 const BigNumber = web3.BigNumber;
 
@@ -23,7 +25,7 @@ contract('ConditionalEscrow', function ([_, owner, payee, ...otherAccounts]) {
   });
 
   context('when withdrawal is disallowed', function () {
-    const amount = web3.toWei(23.0, 'ether');
+    const amount = ether(23.0);
 
     beforeEach(async function () {
       await this.escrow.setAllowed(payee, false);

test/payment/Escrow.behavior.js

@@ -1,6 +1,7 @@
 const expectEvent = require('../helpers/expectEvent');
 const shouldFail = require('../helpers/shouldFail');
 const { ethGetBalance } = require('../helpers/web3');
+const { ether } = require('../helpers/ether');
 
 const BigNumber = web3.BigNumber;
 
@@ -9,7 +10,7 @@ require('chai')
   .should();
 
 function shouldBehaveLikeEscrow (primary, [payee1, payee2]) {
-  const amount = web3.toWei(42.0, 'ether');
+  const amount = ether(42.0);
 
   describe('as an escrow', function () {
     describe('deposits', function () {

test/payment/PullPayment.test.js

@@ -1,4 +1,5 @@
 const { ethGetBalance } = require('../helpers/web3');
+const { ether } = require('../helpers/ether');
 
 const BigNumber = web3.BigNumber;
 
@@ -9,7 +10,7 @@ require('chai')
 const PullPaymentMock = artifacts.require('PullPaymentMock');
 
 contract('PullPayment', function ([_, payer, payee1, payee2]) {
-  const amount = web3.toWei(17.0, 'ether');
+  const amount = ether(17.0);
 
   beforeEach(async function () {
     this.contract = await PullPaymentMock.new({ value: amount });

test/payment/RefundEscrow.test.js

@@ -1,6 +1,8 @@
 const shouldFail = require('../helpers/shouldFail');
 const expectEvent = require('../helpers/expectEvent');
 const { ethGetBalance } = require('../helpers/web3');
+const { ether } = require('../helpers/ether');
+const { ZERO_ADDRESS } = require('../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -11,9 +13,8 @@ require('chai')
 const RefundEscrow = artifacts.require('RefundEscrow');
 
 contract('RefundEscrow', function ([_, primary, beneficiary, refundee1, refundee2]) {
-  const amount = web3.toWei(54.0, 'ether');
+  const amount = ether(54.0);
   const refundees = [refundee1, refundee2];
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   it('requires a non-null beneficiary', async function () {
     await shouldFail.reverting(

test/payment/SplitPayment.test.js

@@ -1,5 +1,7 @@
 const { ethGetBalance } = require('../helpers/web3');
 const { sendEther } = require('./../helpers/sendTransaction');
+const { ether } = require('../helpers/ether');
+const { ZERO_ADDRESS } = require('./../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -11,8 +13,7 @@ const shouldFail = require('../helpers/shouldFail');
 const SplitPayment = artifacts.require('SplitPayment');
 
 contract('SplitPayment', function ([_, owner, payee1, payee2, payee3, nonpayee1, payer1]) {
-  const amount = web3.toWei(1.0, 'ether');
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+  const amount = ether(1.0);
 
   it('rejects an empty set of payees', async function () {
     await shouldFail.reverting(SplitPayment.new([], []));

test/token/ERC20/ERC20.test.js

@@ -1,5 +1,6 @@
 const shouldFail = require('../../helpers/shouldFail');
 const expectEvent = require('../../helpers/expectEvent');
+const { ZERO_ADDRESS } = require('../../helpers/constants');
 
 const ERC20Mock = artifacts.require('ERC20Mock');
 
@@ -10,8 +11,6 @@ require('chai')
   .should();
 
 contract('ERC20', function ([_, owner, recipient, anotherAccount]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   beforeEach(async function () {
     this.token = await ERC20Mock.new(owner, 100);
   });

test/token/ERC20/TokenVesting.test.js

@@ -1,6 +1,7 @@
 const shouldFail = require('../../helpers/shouldFail');
 const time = require('../../helpers/time');
 const { ethGetBlock } = require('../../helpers/web3');
+const { ZERO_ADDRESS } = require('../../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -13,7 +14,6 @@ const TokenVesting = artifacts.require('TokenVesting');
 
 contract('TokenVesting', function ([_, owner, beneficiary]) {
   const amount = new BigNumber(1000);
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   beforeEach(async function () {
     // +1 minute so it starts after contract instantiation

test/token/ERC20/behaviors/ERC20Burnable.behavior.js

@@ -1,8 +1,8 @@
 const shouldFail = require('../../../helpers/shouldFail');
 const expectEvent = require('../../../helpers/expectEvent');
+const { ZERO_ADDRESS } = require('../../../helpers/constants');
 
 const BigNumber = web3.BigNumber;
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
 require('chai')
   .use(require('chai-bignumber')(BigNumber))

test/token/ERC20/behaviors/ERC20Mintable.behavior.js

@@ -1,5 +1,6 @@
 const shouldFail = require('../../../helpers/shouldFail');
 const expectEvent = require('../../../helpers/expectEvent');
+const { ZERO_ADDRESS } = require('../../../helpers/constants');
 
 const BigNumber = web3.BigNumber;
 
@@ -8,8 +9,6 @@ require('chai')
   .should();
 
 function shouldBehaveLikeERC20Mintable (minter, [anyone]) {
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
   describe('as a mintable token', function () {
     describe('mint', function () {
       const amount = 100;

test/token/ERC721/ERC721.behavior.js

@@ -1,6 +1,7 @@
 const expectEvent = require('../../helpers/expectEvent');
 const { shouldSupportInterfaces } = require('../../introspection/SupportsInterface.behavior');
 const shouldFail = require('../../helpers/shouldFail');
+const { ZERO_ADDRESS } = require('../../helpers/constants');
 const { decodeLogs } = require('../../helpers/decodeLogs');
 const { sendTransaction } = require('../../helpers/sendTransaction');
 
@@ -19,7 +20,6 @@ function shouldBehaveLikeERC721 (
   const firstTokenId = 1;
   const secondTokenId = 2;
   const unknownTokenId = 3;
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
   const RECEIVER_MAGIC_VALUE = '0x150b7a02';
 
   describe('like an ERC721', function () {

test/token/ERC721/ERC721MintBurn.behavior.js

@@ -1,5 +1,6 @@
 const shouldFail = require('../../helpers/shouldFail');
 const expectEvent = require('../../helpers/expectEvent');
+const { ZERO_ADDRESS } = require('../../helpers/constants');
 const BigNumber = web3.BigNumber;
 
 require('chai')
@@ -15,7 +16,6 @@ function shouldBehaveLikeMintAndBurnERC721 (
   const secondTokenId = 2;
   const thirdTokenId = 3;
   const unknownTokenId = 4;
-  const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
   const MOCK_URI = 'https://example.com';
 
   describe('like a mintable and burnable ERC721', function () {