Separate the minting from signature into its own AirdropableToken.sol

Author: SylTi

contracts/token/ERC20/AirdropableToken.sol

@@ -0,0 +1,67 @@
+pragma solidity ^0.4.24;
+
+import "./MintableToken.sol";
+import "../../ECRecovery.sol";
+
+/**
+ * @title AirdropableToken
+ * @author SylTi
+ * @dev Simple ERC20 Token that allow for an airdrop to be realised based on signatures from the owner.
+ * This allow the owners of the token to forward the gas cost to the receiver of the airdrop instead of having to pay for it.
+ */
+
+
+contract AirdropableToken is MintableToken {
+  using ECRecovery for bytes32;
+
+  mapping (address => uint256) public usedNonces;
+
+  /**
+   * @dev Function to mint tokens given a valid signature.
+   * @param _to The address that will receive the minted tokens.
+   * @param _amount The amount of tokens to mint.
+   * @param _nonce Unique value used to prevent multiple usage of the same signature 
+   * @param _signature Signature of the hash
+   * @return A boolean that indicates if the operation was successful.
+   */
+  function claim(
+    address _to,
+    uint256 _amount,
+    uint256 _nonce,
+    bytes _signature
+  )
+    canMint
+    public
+    returns (bool)
+  {
+    require(_nonce == usedNonces[_to], "Invalid nonce");
+    bytes32 proof = getProof(_to, _amount, _nonce);
+    address signer = proof.recover(_signature);
+    require(signer == owner, "Not signed by owner");
+    usedNonces[_to] = _nonce.add(1);
+    return super.doMint(_to, _amount);
+  }
+
+  /**
+   * @dev Function that create the hash proof used to check against the signature.
+   * @param _to The address that will receive the minted tokens.
+   * @param _amount The amount of tokens to mint.
+   * @param _nonce Unique value used to prevent multiple usage of the same signature 
+   * @return A bytes32 hash of the parameters.
+   */
+  function getProof(
+    address _to,
+    uint256 _amount,
+    uint256 _nonce
+  ) public view returns (bytes32) 
+  {
+    return keccak256(
+      abi.encodePacked(
+        address(this), // check if the signature was for this specific contract
+        _to, 
+        _amount, 
+        _nonce
+      )
+    ).toEthSignedMessageHash();
+  }
+}

contracts/token/ERC20/MintableToken.sol

@@ -46,37 +46,6 @@ contract MintableToken is StandardToken, Ownable {
   {
     return doMint(_to, _amount);
   }
-
-  /**
-   * @dev Function to mint tokens from an off chain signed message. This can be very usefull during airdrop to make the redeemer pay the gas instead of the owner of the contract.
-   * @param _to The address that will receive the minted tokens.
-   * @param _amount The amount of tokens to mint.
-   * @param _nonce Unique value used to allow multiple minting of the same amount to the same address 
-   * @param _signature Signature of the hash
-   * @return A boolean that indicates if the operation was successful.
-   */
-  function mintWithSignature(
-    address _to,
-    uint256 _amount,
-    uint256 _nonce,
-    bytes _signature
-  )
-    canMint
-    public
-    returns (bool)
-  {
-    require(usedSignatures[_signature] == false, "Signature already used");
-    bytes32 proof = keccak256(
-      address(this), 
-      _to, 
-      _amount, 
-      _nonce
-      ).toEthSignedMessageHash();
-    address signer = proof.recover(_signature);
-    require(signer == owner, "Not signed by owner");
-    usedSignatures[_signature] = true;
-    return doMint(_to, _amount);
-  }
 
   /**
    * @dev Function to stop minting new tokens.
@@ -98,7 +67,7 @@ contract MintableToken is StandardToken, Ownable {
     address _to,
     uint256 _amount
   )
-    private
+    internal
     returns (bool)
   {
     totalSupply_ = totalSupply_.add(_amount);

test/token/ERC20/AirdropableToken.behaviour.js

@@ -0,0 +1,93 @@
+import assertRevert from '../../helpers/assertRevert';
+import { soliditySha3 } from 'web3-utils';
+
+const BigNumber = web3.BigNumber;
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .use(require('chai-bignumber')(BigNumber))
+  .should();
+
+export default function ([owner, anotherAccount, minter]) {
+  describe('as an Airdopable token', function () {
+    describe('mint', function () {
+      const amount = 100;
+
+      describe('when the sender has a valid signature', function () {
+        const from = minter;
+
+        describe('when the token minting is not finished', function () {
+          it('mints the requested amount to the agreed upon address with a signed proof from any address',
+            async function () {
+              const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
+              await this.token.claim(anotherAccount, amount, 0, signature, { from });
+
+              const balance = await this.token.balanceOf(anotherAccount);
+              assert.equal(amount, balance);
+            });
+
+          it('mints the requested amount from the same signed proof should fail', async function () {
+            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
+            await this.token.claim(anotherAccount, amount, 0, signature, { anotherAccount });
+            await assertRevert(this.token.claim(anotherAccount, amount, 0, signature, { anotherAccount }));
+            await assertRevert(this.token.claim(anotherAccount, amount, 0, signature, { owner }));
+            await assertRevert(this.token.claim(anotherAccount, amount, 0, signature, { minter }));
+          });
+
+          it('mints the requested amount twice from the different signed proof', async function () {
+            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
+            const signature2 = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 1));
+
+            await this.token.claim(anotherAccount, amount, 0, signature, { anotherAccount });
+            await this.token.claim(anotherAccount, amount, 1, signature2, { anotherAccount });
+            
+            const balance = await this.token.balanceOf(anotherAccount);
+            assert.equal(amount + amount, balance);
+          });
+
+          it('mints with different parameters than the signed proof should fail', async function () {
+            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
+            await assertRevert(this.token.claim(anotherAccount, amount + 1, 0, signature,
+              { anotherAccount }));
+            await assertRevert(this.token.claim(anotherAccount, amount, 1, signature, { anotherAccount }));
+            await assertRevert(this.token.claim(owner, amount, 0, signature, { anotherAccount }));
+          });
+        });
+
+        describe('when the token minting is finished', function () {
+          beforeEach(async function () {
+            await this.token.finishMinting({ from: owner });
+          });
+
+          it('reverts', async function () {
+            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
+            await assertRevert(this.token.claim(owner, amount, 0, signature, { from }));
+          });
+        });
+      });
+
+      describe('when the sender has not a valid signature', function () {
+        const from = anotherAccount;
+
+        describe('when the token minting is not finished', function () {
+          it('reverts', async function () {
+            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
+            await assertRevert(this.token.claim(owner, amount, 0, signature, { from }));
+            await assertRevert(this.token.claim(owner, amount, 0, signature, { owner }));
+          });
+        });
+
+        describe('when the token minting is already finished', function () {
+          beforeEach(async function () {
+            await this.token.finishMinting({ from: owner });
+          });
+
+          it('reverts', async function () {
+            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
+            await assertRevert(this.token.claim(owner, amount, 0, signature, { from }));
+          });
+        });
+      });
+    });
+  });
+};

test/token/ERC20/AirdropableToken.test.js

@@ -0,0 +1,16 @@
+import shouldBehaveLikeAirdropableToken from './AirdropableToken.behaviour';
+import shouldBehaveLikeMintableToken from './MintableToken.behaviour';
+
+const AirdropableToken = artifacts.require('AirdropableToken');
+
+contract('AirdropableToken', function ([owner, anotherAccount]) {
+  const minter = owner;
+
+  beforeEach(async function () {
+    this.token = await AirdropableToken.new({ from: owner });
+    // await this.token.addMinter(minter, { from: owner });
+  });
+
+  shouldBehaveLikeAirdropableToken([owner, anotherAccount, minter]);
+  shouldBehaveLikeMintableToken([owner, anotherAccount, minter]);
+});

test/token/ERC20/MintableToken.behaviour.js

@@ -1,5 +1,4 @@
 import assertRevert from '../../helpers/assertRevert';
-import { soliditySha3 } from 'web3-utils';
 
 const BigNumber = web3.BigNumber;
 
@@ -103,42 +102,6 @@ export default function ([owner, anotherAccount, minter]) {
             assert.equal(balance, amount);
           });
 
-          it('mints the requested amount to the agreed upon address with a signed proof from any address',
-            async function () {
-              const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
-              await this.token.mintWithSignature(anotherAccount, amount, 0, signature, { from });
-
-              const balance = await this.token.balanceOf(anotherAccount);
-              assert.equal(amount, balance);
-            });
-
-          it('mints the requested amount from the same signed proof should fail', async function () {
-            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
-            await this.token.mintWithSignature(anotherAccount, amount, 0, signature, { anotherAccount });
-            await assertRevert(this.token.mintWithSignature(anotherAccount, amount, 0, signature, { anotherAccount }));
-            await assertRevert(this.token.mintWithSignature(anotherAccount, amount, 0, signature, { owner }));
-            await assertRevert(this.token.mintWithSignature(anotherAccount, amount, 0, signature, { minter }));
-          });
-
-          it('mints the requested amount twice from the different signed proof', async function () {
-            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
-            const signature2 = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 1));
-
-            await this.token.mintWithSignature(anotherAccount, amount, 0, signature, { anotherAccount });
-            await this.token.mintWithSignature(anotherAccount, amount, 1, signature2, { anotherAccount });
-            
-            const balance = await this.token.balanceOf(anotherAccount);
-            assert.equal(amount + amount, balance);
-          });
-
-          it('mints with different parameters than the signed proof should fail', async function () {
-            const signature = web3.eth.sign(owner, soliditySha3(this.token.address, anotherAccount, amount, 0));
-            await assertRevert(this.token.mintWithSignature(anotherAccount, amount + 1, 0, signature,
-              { anotherAccount }));
-            await assertRevert(this.token.mintWithSignature(anotherAccount, amount, 1, signature, { anotherAccount }));
-            await assertRevert(this.token.mintWithSignature(owner, amount, 0, signature, { anotherAccount }));
-          });
-
           it('emits a mint and a transfer event', async function () {
             const { logs } = await this.token.mint(owner, amount, { from });
 
@@ -158,11 +121,6 @@ export default function ([owner, anotherAccount, minter]) {
           it('reverts', async function () {
             await assertRevert(this.token.mint(owner, amount, { from }));
           });
-
-          it('reverts', async function () {
-            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
-            await assertRevert(this.token.mintWithSignature(owner, amount, 0, signature, { from }));
-          });
         });
       });
 
@@ -173,11 +131,6 @@ export default function ([owner, anotherAccount, minter]) {
           it('reverts', async function () {
             await assertRevert(this.token.mint(owner, amount, { from }));
           });
-          it('reverts', async function () {
-            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
-            await assertRevert(this.token.mintWithSignature(owner, amount, 0, signature, { from }));
-            await assertRevert(this.token.mintWithSignature(owner, amount, 0, signature, { owner }));
-          });
         });
 
         describe('when the token minting is already finished', function () {
@@ -188,11 +141,6 @@ export default function ([owner, anotherAccount, minter]) {
           it('reverts', async function () {
             await assertRevert(this.token.mint(owner, amount, { from }));
           });
-
-          it('reverts', async function () {
-            const signature = web3.eth.sign(from, soliditySha3(this.token.address, owner, amount, 0));
-            await assertRevert(this.token.mintWithSignature(owner, amount, 0, signature, { from }));
-          });
         });
       });
     });