named return variables in libraries...

...are now consistent with how we do it in contracts

moved downcast helpers to Math

clearer error names

contracts/libraries/Math.sol

@@ -6,16 +6,30 @@ library Math {
         return a < b ? a : b;
     }
 
-    // https://github.com/ethereum/dapp-bin/blob/11f05fc9e3f31a00d57982bc2f65ef2654f1b569/library/math.sol#L28
     // https://github.com/ethereum/dapp-bin/pull/50
+    // https://github.com/ethereum/dapp-bin/blob/11f05fc9e3f31a00d57982bc2f65ef2654f1b569/library/math.sol#L28
     function sqrt(uint256 x) internal pure returns (uint256 y) {
-        if (x == 0) return 0;
-        else if (x <= 3) return 1;
-        uint256 z = (x + 1) / 2;
-        y = x;
-        while (z < y) {
-            y = z;
-            z = (x / z + z) / 2;
+        if (x == 0) {
+            y = 0;
+        } else if (x <= 3) {
+            y = 1;
+        } else {
+            y = x;
+            uint256 z = (x + 1) / 2;
+            while (z < y) {
+                y = z;
+                z = (x / z + z) / 2;
+            }
         }
     }
+
+    function downcastTo64(uint256 a) internal pure returns (uint64) {
+        require(a <= uint64(-1), "Math: downcast overflow (uint256 to uint64)");
+        return uint64(a);
+    }
+
+    function downcastTo128(uint256 a) internal pure returns (uint128) {
+        require(a <= uint128(-1), "Math: downcast overflow (uint256 to uint128)");
+        return uint128(a);
+    }
 }

contracts/libraries/SafeMath128.sol

@@ -2,28 +2,24 @@
 pragma solidity 0.5.12;
 
 library SafeMath128 {
-    function add(uint128 a, uint128 b) internal pure returns (uint128) {
-        uint128 c = a + b;
-        require(c >= a, "SafeMath: addition overflow");
-        return c;
+    function add(uint128 a, uint128 b) internal pure returns (uint128 c) {
+        c = a + b;
+        require(c >= a, "SafeMath128: addition overflow");
     }
 
     function sub(uint128 a, uint128 b) internal pure returns (uint128) {
-        require(b <= a, "SafeMath: subtraction overflow");
-        uint128 c = a - b;
-        return c;
+        require(b <= a, "SafeMath128: subtraction overflow");
+        return a - b;
     }
 
-    function mul(uint128 a, uint128 b) internal pure returns (uint128) {
+    function mul(uint128 a, uint128 b) internal pure returns (uint128 c) {
         if (a == 0) return 0;
-        uint128 c = a * b;
-        require(c / a == b, "SafeMath: multiplication overflow");
-        return c;
+        c = a * b;
+        require(c / a == b, "SafeMath128: multiplication overflow");
     }
 
     function div(uint128 a, uint128 b) internal pure returns (uint128) {
-        require(b > 0, "SafeMath: division by zero");
-        uint128 c = a / b;
-        return c;
+        require(b > 0, "SafeMath128: division by zero");
+        return a / b;
     }
 }

contracts/libraries/SafeMath256.sol

@@ -2,38 +2,24 @@
 pragma solidity 0.5.12;
 
 library SafeMath256 {
-    function add(uint256 a, uint256 b) internal pure returns (uint256) {
-        uint256 c = a + b;
-        require(c >= a, "SafeMath: addition overflow");
-        return c;
+    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        c = a + b;
+        require(c >= a, "SafeMath256: addition overflow");
     }
 
     function sub(uint256 a, uint256 b) internal pure returns (uint256) {
-        require(b <= a, "SafeMath: subtraction overflow");
-        uint256 c = a - b;
-        return c;
+        require(b <= a, "SafeMath256: subtraction overflow");
+        return a - b;
     }
 
-    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
         if (a == 0) return 0;
-        uint256 c = a * b;
-        require(c / a == b, "SafeMath: multiplication overflow");
-        return c;
+        c = a * b;
+        require(c / a == b, "SafeMath256: multiplication overflow");
     }
 
     function div(uint256 a, uint256 b) internal pure returns (uint256) {
-        require(b > 0, "SafeMath: division by zero");
-        uint256 c = a / b;
-        return c;
-    }
-
-    function downcastTo64(uint256 a) internal pure returns (uint64) {
-        require(a <= uint64(-1), "SafeMath: downcast overflow");
-        return uint64(a);
-    }
-
-    function downcastTo128(uint256 a) internal pure returns (uint128) {
-        require(a <= uint128(-1), "SafeMath: downcast overflow");
-        return uint128(a);
+        require(b > 0, "SafeMath256: division by zero");
+        return a / b;
     }
 }