convert to big number

Author: felix2feng

contracts/SetToken.sol

@@ -5,6 +5,7 @@ import "zeppelin-solidity/contracts/token/ERC20/StandardToken.sol";
 import "zeppelin-solidity/contracts/token/ERC20/ERC20.sol";
 import "zeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol";
 import "zeppelin-solidity/contracts/math/SafeMath.sol";
+import "./external/SafeMathUint256.sol";
 import "./lib/Set.sol";
 
 
@@ -68,14 +69,17 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
    */
   function issue(uint quantity) public returns (bool success) {
     // Transfers the sender's components to the contract
+    // Since the component length is defined ahead of time, this is not 
+    // an unbounded loop
     for (uint i = 0; i < components.length; i++) {
       address currentComponent = components[i];
       uint currentUnits = units[i];
 
       // Transfer value is defined as the currentUnits (in GWei)
       // multiplied by quantity in Wei divided by the units of gWei.
       // We do this to allow fractional units to be defined
-      uint transferValue = currentUnits.mul(quantity).div(10**9);
+      // uint transferValue = currentUnits.mul(quantity).div(10**9);
+      uint transferValue = SafeMathUint256.fxpMul(currentUnits, quantity, 10**9);
 
       // Protect against the case that the gWei divisor results in a value that is
       // 0 and the user is able to generate Sets without sending a balance
@@ -104,6 +108,8 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
    */
   function redeem(uint quantity) public returns (bool success) {
     // Check that the sender has sufficient components
+    // Since the component length is defined ahead of time, this is not 
+    // an unbounded loop
     require(balances[msg.sender] >= quantity);
 
     // To prevent re-entrancy attacks, decrement the user's Set balance
@@ -117,7 +123,8 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
       uint currentUnits = units[i];
 
       // The transaction will fail if any of the components fail to transfer
-      uint transferValue = currentUnits.mul(quantity).div(10**9);
+      // uint transferValue = currentUnits.mul(quantity).div(10**9);
+      uint transferValue = SafeMathUint256.fxpMul(currentUnits, quantity, 10**9);
 
       // Protect against the case that the gWei divisor results in a value that is
       // 0 and the user is able to generate Sets without sending a balance

contracts/external/SafeMathUint256.sol

@@ -0,0 +1,72 @@
+pragma solidity 0.4.21;
+
+
+/**
+ * @title SafeMathUint256
+ * @dev Uint256 math operations with safety checks that throw on error
+ */
+library SafeMathUint256 {
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        // assert(b > 0); // Solidity automatically throws when dividing by 0
+        uint256 c = a / b;
+        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b <= a);
+        return a - b;
+    }
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a);
+        return c;
+    }
+
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a <= b) {
+            return a;
+        } else {
+            return b;
+        }
+    }
+
+    function max(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a >= b) {
+            return a;
+        } else {
+            return b;
+        }
+    }
+
+    function getUint256Min() internal pure returns (uint256) {
+        return 0;
+    }
+
+    function getUint256Max() internal pure returns (uint256) {
+        return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+    }
+
+    function isMultipleOf(uint256 a, uint256 b) internal pure returns (bool) {
+        return a % b == 0;
+    }
+
+    // Float [fixed point] Operations
+    function fxpMul(uint256 a, uint256 b, uint256 base) internal pure returns (uint256) {
+        return div(mul(a, b), base);
+    }
+
+    function fxpDiv(uint256 a, uint256 b, uint256 base) internal pure returns (uint256) {
+        return div(mul(a, base), b);
+    }
+}