Make SafeMath a library

contracts/SafeMath.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.4.8;
 /**
  * Math operations with safety checks
  */
-contract SafeMath {
+library SafeMath {
   function safeMul(uint a, uint b) internal returns (uint) {
     uint c = a * b;
     assert(a == 0 || c / a == b);

contracts/payment/PullPayment.sol

@@ -9,14 +9,16 @@ import '../SafeMath.sol';
  * Base contract supporting async send for pull payments.
  * Inherit from this contract and use asyncSend instead of send.
  */
-contract PullPayment is SafeMath {
+contract PullPayment {
+  using SafeMath for uint;
+
   mapping(address => uint) public payments;
   uint public totalPayments;
 
   // store sent amount as credit to be pulled, called by payer
   function asyncSend(address dest, uint amount) internal {
-    payments[dest] = safeAdd(payments[dest], amount);
-    totalPayments = safeAdd(totalPayments, amount);
+    payments[dest] = payments[dest].safeAdd(amount);
+    totalPayments = totalPayments.safeAdd(amount);
   }
 
   // withdraw accumulated balance, called by payee
@@ -32,7 +34,7 @@ contract PullPayment is SafeMath {
       throw;
     }
 
-    totalPayments = safeSub(totalPayments, payment);
+    totalPayments = totalPayments.safeSub(payment);
     payments[payee] = 0;
 
     if (!payee.send(payment)) {

contracts/token/BasicToken.sol

@@ -9,7 +9,8 @@ import '../SafeMath.sol';
  * Basic token
  * Basic version of StandardToken, with no allowances
  */
-contract BasicToken is ERC20Basic, SafeMath {
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint;
 
   mapping(address => uint) balances;
 
@@ -22,8 +23,8 @@ contract BasicToken is ERC20Basic, SafeMath {
   }
 
   function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
-    balances[msg.sender] = safeSub(balances[msg.sender], _value);
-    balances[_to] = safeAdd(balances[_to], _value);
+    balances[msg.sender] = balances[msg.sender].safeSub(_value);
+    balances[_to] = balances[_to].safeAdd(_value);
     Transfer(msg.sender, _to, _value);
   }
 

contracts/token/CrowdsaleToken.sol

@@ -32,10 +32,10 @@ contract CrowdsaleToken is StandardToken {
       throw;
     }
 
-    uint tokens = safeMul(msg.value, getPrice());
-    totalSupply = safeAdd(totalSupply, tokens);
+    uint tokens = msg.value.safeMul(getPrice());
+    totalSupply = totalSupply.safeAdd(tokens);
 
-    balances[recipient] = safeAdd(balances[recipient], tokens);
+    balances[recipient] = balances[recipient].safeAdd(tokens);
 
     if (!multisig.send(msg.value)) {
       throw;

contracts/token/StandardToken.sol

@@ -22,9 +22,9 @@ contract StandardToken is BasicToken, ERC20 {
     // Check is not needed because safeSub(_allowance, _value) will already throw if this condition is not met
     // if (_value > _allowance) throw;
 
-    balances[_to] = safeAdd(balances[_to], _value);
-    balances[_from] = safeSub(balances[_from], _value);
-    allowed[_from][msg.sender] = safeSub(_allowance, _value);
+    balances[_to] = balances[_to].safeAdd(_value);
+    balances[_from] = balances[_from].safeSub(_value);
+    allowed[_from][msg.sender] = _allowance.safeSub(_value);
     Transfer(_from, _to, _value);
   }
 

contracts/token/VestedToken.sol

@@ -52,8 +52,8 @@ contract VestedToken is StandardToken, LimitedTransferToken {
     grants[_holder][_grantId] = grants[_holder][grants[_holder].length - 1];
     grants[_holder].length -= 1;
 
-    balances[msg.sender] = safeAdd(balances[msg.sender], nonVested);
-    balances[_holder] = safeSub(balances[_holder], nonVested);
+    balances[msg.sender] = balances[msg.sender].safeAdd(nonVested);
+    balances[_holder] = balances[_holder].safeSub(nonVested);
     Transfer(_holder, msg.sender, nonVested);
   }
 
@@ -98,32 +98,33 @@ contract VestedToken is StandardToken, LimitedTransferToken {
       return tokens;
     }
 
-    uint256 cliffTokens = safeDiv(safeMul(tokens, safeSub(cliff, start)), safeSub(vesting, start));
+    uint256 cliffTokens = tokens.safeMul(cliff.safeSub(start)).safeDiv(vesting.safeSub(start));
     vestedTokens = cliffTokens;
 
-    uint256 vestingTokens = safeSub(tokens, cliffTokens);
+    uint256 vestingTokens = tokens.safeSub(cliffTokens);
 
-    vestedTokens = safeAdd(vestedTokens, safeDiv(safeMul(vestingTokens, safeSub(time, cliff)), safeSub(vesting, cliff)));
+    vestedTokens = vestedTokens.safeAdd(vestingTokens.safeMul(time.safeSub(cliff)).safeDiv(vesting.safeSub(cliff)));
   }
 
   function nonVestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
-    return safeSub(grant.value, vestedTokens(grant, time));
+    return grant.value.safeSub(vestedTokens(grant, time));
   }
 
   function lastTokenIsTransferableDate(address holder) constant public returns (uint64 date) {
     date = uint64(now);
     uint256 grantIndex = grants[holder].length;
     for (uint256 i = 0; i < grantIndex; i++) {
-      date = max64(grants[holder][i].vesting, date);
+      date = SafeMath.max64(grants[holder][i].vesting, date);
     }
   }
 
   function transferableTokens(address holder, uint64 time) constant public returns (uint256 nonVested) {
     uint256 grantIndex = grants[holder].length;
     for (uint256 i = 0; i < grantIndex; i++) {
-      nonVested = safeAdd(nonVested, nonVestedTokens(grants[holder][i], time));
+      uint256 current = nonVestedTokens(grants[holder][i], time);
+      nonVested = nonVested.safeAdd(current);
     }
 
-    return min256(safeSub(balances[holder], nonVested), super.transferableTokens(holder, time));
+    return SafeMath.min256(balances[holder].safeSub(nonVested), super.transferableTokens(holder, time));
   }
 }

test/helpers/SafeMathMock.sol

@@ -4,18 +4,18 @@ pragma solidity ^0.4.8;
 import '../../contracts/SafeMath.sol';
 
 
-contract SafeMathMock is SafeMath {
+contract SafeMathMock {
   uint public result;
 
   function multiply(uint a, uint b) {
-    result = safeMul(a, b);
+    result = SafeMath.safeMul(a, b);
   }
 
   function subtract(uint a, uint b) {
-    result = safeSub(a, b);
+    result = SafeMath.safeSub(a, b);
   }
 
   function add(uint a, uint b) {
-    result = safeAdd(a, b);
+    result = SafeMath.safeAdd(a, b);
   }
 }