Merge remote-tracking branch 'upstream/master' into erc20-encapsulation

Author: frangio

contracts/math/Math.sol

@@ -13,4 +13,9 @@ library Math {
   function min(uint256 _a, uint256 _b) internal pure returns (uint256) {
     return _a < _b ? _a : _b;
   }
+
+  function average(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    // (_a + _b) / 2 can overflow, so we distribute
+    return (_a / 2) + (_b / 2) + ((_a % 2 + _b % 2) / 2);
+  }
 }

contracts/math/SafeMath.sol

@@ -54,4 +54,13 @@ library SafeMath {
 
     return c;
   }
+
+  /**
+  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
+  * reverts when dividing by zero.
+  */
+  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b != 0);
+    return a % b;
+  }
 }

contracts/mocks/ERC721TokenMock.sol

@@ -21,10 +21,14 @@ contract ERC721TokenMock is ERC721Token {
     super._burn(ownerOf(_tokenId), _tokenId);
   }
 
+  function exists(uint256 _tokenId) public view returns (bool) {
+    return super._exists(_tokenId);
+  }
+
   function setTokenURI(uint256 _tokenId, string _uri) public {
     super._setTokenURI(_tokenId, _uri);
   }
-  
+
   function _removeTokenFrom(address _from, uint256 _tokenId) public {
     super.removeTokenFrom(_from, _tokenId);
   }

contracts/mocks/MathMock.sol

@@ -12,4 +12,8 @@ contract MathMock {
   function min(uint256 _a, uint256 _b) public pure returns (uint256) {
     return Math.min(_a, _b);
   }
+
+  function average(uint256 _a, uint256 _b) public pure returns (uint256) {
+    return Math.average(_a, _b);
+  }
 }

contracts/mocks/SafeMathMock.sol

@@ -21,4 +21,8 @@ contract SafeMathMock {
   function add(uint256 _a, uint256 _b) public pure returns (uint256) {
     return SafeMath.add(_a, _b);
   }
+
+  function mod(uint256 a, uint256 b) public pure returns (uint256) {
+    return SafeMath.mod(a, b);
+  }
 }

contracts/token/ERC721/ERC721Basic.sol

@@ -23,12 +23,6 @@ contract ERC721Basic is ERC165 {
    *   bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
    */
 
-  bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
-  /*
-   * 0x4f558e79 ===
-   *   bytes4(keccak256('exists(uint256)'))
-   */
-
   bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
   /**
    * 0x780e9d63 ===
@@ -63,7 +57,6 @@ contract ERC721Basic is ERC165 {
 
   function balanceOf(address _owner) public view returns (uint256 _balance);
   function ownerOf(uint256 _tokenId) public view returns (address _owner);
-  function exists(uint256 _tokenId) public view returns (bool _exists);
 
   function approve(address _to, uint256 _tokenId) public;
   function getApproved(uint256 _tokenId)

contracts/token/ERC721/ERC721BasicToken.sol

@@ -37,7 +37,6 @@ contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
   {
     // register the supported interfaces to conform to ERC721 via ERC165
     _registerInterface(InterfaceId_ERC721);
-    _registerInterface(InterfaceId_ERC721Exists);
   }
 
   /**
@@ -61,16 +60,6 @@ contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
     return owner;
   }
 
-  /**
-   * @dev Returns whether the specified token exists
-   * @param _tokenId uint256 ID of the token to query the existence of
-   * @return whether the token exists
-   */
-  function exists(uint256 _tokenId) public view returns (bool) {
-    address owner = tokenOwner[_tokenId];
-    return owner != address(0);
-  }
-
   /**
    * @dev Approves another address to transfer the given token ID
    * The zero address indicates there is no approved address.
@@ -200,6 +189,16 @@ contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
     require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
   }
 
+  /**
+   * @dev Returns whether the specified token exists
+   * @param _tokenId uint256 ID of the token to query the existence of
+   * @return whether the token exists
+   */
+  function _exists(uint256 _tokenId) internal view returns (bool) {
+    address owner = tokenOwner[_tokenId];
+    return owner != address(0);
+  }
+
   /**
    * @dev Returns whether the given spender can transfer a given token ID
    * @param _spender address of the spender to query

contracts/token/ERC721/ERC721Token.sol

@@ -68,7 +68,7 @@ contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
    * @param _tokenId uint256 ID of the token to query
    */
   function tokenURI(uint256 _tokenId) public view returns (string) {
-    require(exists(_tokenId));
+    require(_exists(_tokenId));
     return tokenURIs[_tokenId];
   }
 
@@ -116,7 +116,7 @@ contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
    * @param _uri string URI to assign
    */
   function _setTokenURI(uint256 _tokenId, string _uri) internal {
-    require(exists(_tokenId));
+    require(_exists(_tokenId));
     tokenURIs[_tokenId] = _uri;
   }
 

ethpm.json

@@ -1,6 +1,6 @@
 {
   "package_name": "zeppelin",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Secure Smart Contract library for Solidity",
   "authors": [
     "OpenZeppelin Community <[email protected]>"

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openzeppelin-solidity",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Secure Smart Contract library for Solidity",
   "files": [
     "contracts",

package.json

@@ -37,4 +37,28 @@ contract('Math', function () {
       result.should.be.bignumber.equal(min);
     });
   });
+
+  describe('average', function () {
+    function bnAverage (a, b) {
+      return a.plus(b).div(2).truncated();
+    }
+
+    it('is correctly calculated with two odd numbers', async function () {
+      const a = new BigNumber(57417);
+      const b = new BigNumber(95431);
+      (await this.math.average(a, b)).should.be.bignumber.equal(bnAverage(a, b));
+    });
+
+    it('is correctly calculated with two even numbers', async function () {
+      const a = new BigNumber(42304);
+      const b = new BigNumber(84346);
+      (await this.math.average(a, b)).should.be.bignumber.equal(bnAverage(a, b));
+    });
+
+    it('is correctly calculated with one even and one odd number', async function () {
+      const a = new BigNumber(57417);
+      const b = new BigNumber(84346);
+      (await this.math.average(a, b)).should.be.bignumber.equal(bnAverage(a, b));
+    });
+  });
 });

test/library/Math.test.js

@@ -1,4 +1,5 @@
 const { assertRevert } = require('../helpers/assertRevert');
+
 const BigNumber = web3.BigNumber;
 const SafeMathMock = artifacts.require('SafeMathMock');
 
@@ -88,4 +89,43 @@ contract('SafeMath', () => {
       await assertRevert(this.safeMath.div(a, b));
     });
   });
+
+  describe('mod', function () {
+    describe('modulos correctly', async function () {
+      it('when the dividend is smaller than the divisor', async function () {
+        const a = new BigNumber(284);
+        const b = new BigNumber(5678);
+
+        (await this.safeMath.mod(a, b)).should.be.bignumber.equal(a.mod(b));
+      });
+
+      it('when the dividend is equal to the divisor', async function () {
+        const a = new BigNumber(5678);
+        const b = new BigNumber(5678);
+
+        (await this.safeMath.mod(a, b)).should.be.bignumber.equal(a.mod(b));
+      });
+
+      it('when the dividend is larger than the divisor', async function () {
+        const a = new BigNumber(7000);
+        const b = new BigNumber(5678);
+
+        (await this.safeMath.mod(a, b)).should.be.bignumber.equal(a.mod(b));
+      });
+
+      it('when the dividend is a multiple of the divisor', async function () {
+        const a = new BigNumber(17034); // 17034 == 5678 * 3
+        const b = new BigNumber(5678);
+
+        (await this.safeMath.mod(a, b)).should.be.bignumber.equal(a.mod(b));
+      });
+    });
+
+    it('reverts with a 0 divisor', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(0);
+
+      await assertRevert(this.safeMath.mod(a, b));
+    });
+  });
 });

test/math/SafeMath.test.js

@@ -1,37 +1,37 @@
-const { expectThrow } = require('../../helpers/expectThrow');
-const expectEvent = require('../../helpers/expectEvent');
-
-const BigNumber = web3.BigNumber;
-
-require('chai')
-  .use(require('chai-bignumber')(BigNumber))
-  .should();
-
-function shouldBehaveLikeCappedToken (minter, [anyone], cap) {
-  describe('capped token', function () {
-    const from = minter;
-
-    it('should start with the correct cap', async function () {
-      (await this.token.cap()).should.be.bignumber.equal(cap);
-    });
-
-    it('should mint when amount is less than cap', async function () {
-      const { logs } = await this.token.mint(anyone, cap.sub(1), { from });
-      expectEvent.inLogs(logs, 'Mint');
-    });
-
-    it('should fail to mint if the ammount exceeds the cap', async function () {
-      await this.token.mint(anyone, cap.sub(1), { from });
-      await expectThrow(this.token.mint(anyone, 100, { from }));
-    });
-
-    it('should fail to mint after cap is reached', async function () {
-      await this.token.mint(anyone, cap, { from });
-      await expectThrow(this.token.mint(anyone, 1, { from }));
-    });
-  });
-}
-
-module.exports = {
-  shouldBehaveLikeCappedToken,
-};
+const { expectThrow } = require('../../helpers/expectThrow');
+const expectEvent = require('../../helpers/expectEvent');
+
+const BigNumber = web3.BigNumber;
+
+require('chai')
+  .use(require('chai-bignumber')(BigNumber))
+  .should();
+
+function shouldBehaveLikeCappedToken (minter, [anyone], cap) {
+  describe('capped token', function () {
+    const from = minter;
+
+    it('should start with the correct cap', async function () {
+      (await this.token.cap()).should.be.bignumber.equal(cap);
+    });
+
+    it('should mint when amount is less than cap', async function () {
+      const { logs } = await this.token.mint(anyone, cap.sub(1), { from });
+      expectEvent.inLogs(logs, 'Mint');
+    });
+
+    it('should fail to mint if the ammount exceeds the cap', async function () {
+      await this.token.mint(anyone, cap.sub(1), { from });
+      await expectThrow(this.token.mint(anyone, 100, { from }));
+    });
+
+    it('should fail to mint after cap is reached', async function () {
+      await this.token.mint(anyone, cap, { from });
+      await expectThrow(this.token.mint(anyone, 1, { from }));
+    });
+  });
+}
+
+module.exports = {
+  shouldBehaveLikeCappedToken,
+};

test/token/ERC20/CappedToken.behavior.js

@@ -47,26 +47,6 @@ function shouldBehaveLikeERC721BasicToken (accounts) {
       });
     });
 
-    describe('exists', function () {
-      context('when the token exists', function () {
-        const tokenId = firstTokenId;
-
-        it('should return true', async function () {
-          const result = await this.token.exists(tokenId);
-          result.should.be.true;
-        });
-      });
-
-      context('when the token does not exist', function () {
-        const tokenId = unknownTokenId;
-
-        it('should return false', async function () {
-          const result = await this.token.exists(tokenId);
-          result.should.be.false;
-        });
-      });
-    });
-
     describe('ownerOf', function () {
       context('when the given token ID was tracked by this token', function () {
         const tokenId = firstTokenId;
@@ -554,7 +534,6 @@ function shouldBehaveLikeERC721BasicToken (accounts) {
     shouldSupportInterfaces([
       'ERC165',
       'ERC721',
-      'ERC721Exists',
     ]);
   });
 }

test/token/ERC721/ERC721BasicToken.behavior.js

@@ -225,7 +225,6 @@ contract('ERC721Token', function (accounts) {
   shouldSupportInterfaces([
     'ERC165',
     'ERC721',
-    'ERC721Exists',
     'ERC721Enumerable',
     'ERC721Metadata',
   ]);