site improvements and smart contracts

smart_contracts/uniTestToken.sol

+pragma solidity ^0.4.18;
+
+contract ERC20Token {
+    uint256 public totalSupply;
+    function balanceOf(address who) public constant returns (uint256);
+    function transfer(address to, uint256 value) public returns (bool);
+    function allowance(address owner, address spender) public constant returns (uint256);
+    function transferFrom(address from, address to, uint256 value) public returns (bool);
+    function approve(address spender, uint256 value) public returns (bool);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+library SafeMath {
+    function mul(uint256 a, uint256 b) internal constant returns (uint256) {
+        uint256 c = a * b;
+        assert(a == 0 || c / a == b);
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal constant 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 constant returns (uint256) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    function add(uint256 a, uint256 b) internal constant returns (uint256) {
+        uint256 c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+contract StandardToken is ERC20Token {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) balances;
+    mapping (address => mapping (address => uint256)) internal allowed;
+
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        require(_to != address(0));
+        require(_value <= balances[msg.sender]);
+
+        // SafeMath.sub will throw if there is not enough balance.
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+        require(_to != address(0));
+        require(_value <= balances[_from]);
+        require(_value <= allowed[_from][msg.sender]);
+
+        balances[_from] = balances[_from].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+        Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function approve(address _spender, uint256 _value) public returns (bool) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
+        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+          allowed[msg.sender][_spender] = 0;
+        } else {
+          allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function balanceOf(address _owner) public constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+}
+
+contract Ownable {
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    address public owner;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function Ownable() {
+        owner = msg.sender;
+    }
+
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        require(newOwner != address(0));
+        OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+}
+
+contract MintableToken is StandardToken, Ownable {
+    event Mint(address indexed to, uint256 amount);
+    event MintFinished();
+
+    bool public mintingFinished = false;
+
+    modifier canMint() {
+        require(!mintingFinished);
+        _;
+    }
+
+    /**
+    * @dev Function to mint tokens
+    * @param _to The address that will receive the minted tokens.
+    * @param _amount The amount of tokens to mint.
+    * @return A boolean that indicates if the operation was successful.
+    */
+    function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
+        totalSupply = totalSupply.add(_amount);
+        balances[_to] = balances[_to].add(_amount);
+        Mint(_to, _amount);
+        Transfer(0x0, _to, _amount);
+        return true;
+    }
+
+    /**
+    * @dev Function to stop minting new tokens.
+    * @return True if the operation was successful.
+    */
+    function finishMinting() onlyOwner public returns (bool) {
+        mintingFinished = true;
+        MintFinished();
+        return true;
+    }
+}
+
+contract uniTestToken is MintableToken {
+    string public constant name = "UNI Test Token";
+    string public constant symbol = "UNT";
+    uint8 public constant decimals = 6;
+}

smart_contracts/uniswap.sol

+pragma solidity ^0.4.18;
+
+/// @title SafeMath
+/// @dev Math operations with safety checks that throw on error
+library SafeMath {
+    /// @dev Multiplies a times b
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a * b;
+        assert(a == 0 || c / a == b);
+        return c;
+    }
+
+    /// @dev Divides a by b
+    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;
+    }
+
+    /// @dev Subtracts a from b
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    /// @dev Adds a to b
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+
+contract Ownable {
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    address public owner;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function Ownable() public {
+        owner = msg.sender;
+    }
+
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        require(newOwner != address(0));
+        OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+}
+
+
+contract ERC20Token {
+    uint256 public totalSupply;
+    function balanceOf(address who) public constant returns (uint256);
+    function transfer(address to, uint256 value) public returns (bool);
+    function allowance(address owner, address spender) public constant returns (uint256);
+    function transferFrom(address from, address to, uint256 value) public returns (bool);
+    function approve(address spender, uint256 value) public returns (bool);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+contract uniswap is Ownable{
+    using SafeMath for uint256;
+
+    event TokenPurchase(address indexed buyer, uint256 tokensPurchased, uint256 ethSpent);
+    event EthPurchase(address indexed buyer, uint256 ethPurchased, uint256 tokensSpent);
+
+    uint256 public totalEthQuantity;
+    uint256 public totalTokenQuantity;
+    uint256 public invariant = 0;
+    address public tokenAddress;
+    ERC20Token token;
+
+    function uniswap(address _tokenAddress) public payable {
+        tokenAddress = _tokenAddress;
+        token = ERC20Token(tokenAddress);
+        totalEthQuantity = msg.value;
+    }
+
+
+    function initiateUniswap(uint256 initialTokenQuantity) public onlyOwner {
+        require(invariant == 0);
+        token.transferFrom(msg.sender, address(this), initialTokenQuantity);
+        totalTokenQuantity = initialTokenQuantity;
+        invariant = initialTokenQuantity.mul(totalEthQuantity);
+        require(invariant > 0);
+    }
+
+
+
+    function ethToTokens(uint256 minimumTokens, uint256 timeout) public payable {
+        uint256 fee = msg.value/500;
+        uint256 ethInPurchase = msg.value.sub(fee);
+        uint256 newTotalEth = totalEthQuantity.add(ethInPurchase);
+        uint256 newTotalTokens = invariant/newTotalEth;
+        uint256 purchasedTokens = totalTokenQuantity.sub(newTotalTokens);
+        require(purchasedTokens >= minimumTokens);
+        require(now < timeout);                             
+        token.transfer(msg.sender, purchasedTokens);
+        totalEthQuantity = newTotalEth;
+        totalTokenQuantity = newTotalTokens;
+        TokenPurchase(msg.sender, purchasedTokens, ethInPurchase);
+    }
+
+
+    function tokenToEth(uint256 sellQuantity, uint256 minimumEth, uint256 timeout) public {
+        uint256 fee = sellQuantity/500;
+        uint256 tokensInPurchase = sellQuantity - fee;
+        uint256 newTotalTokens = totalTokenQuantity.sub(fee);
+        uint256 newTotalEth = invariant/newTotalTokens;
+        uint256 purchasedEth = totalEthQuantity.sub(newTotalEth);
+        require(purchasedEth >= minimumEth);
+        require(now < timeout);
+        msg.sender.transfer(purchasedEth);
+        totalTokenQuantity = newTotalTokens;
+        totalEthQuantity = newTotalEth;
+        EthPurchase(msg.sender, purchasedEth, tokensInPurchase);
+    }
+
+
+    function ownerTokenWithdraw(uint256 tokenAmount) public onlyOwner {
+        token.transfer(msg.sender, tokenAmount);
+        totalTokenQuantity = totalTokenQuantity.sub(tokenAmount);
+        invariant = totalTokenQuantity.mul(totalEthQuantity);
+    }
+
+
+    function ownerEthWithdraw(uint256 ethAmount) public onlyOwner {
+        msg.sender.transfer(ethAmount);
+        totalEthQuantity = totalEthQuantity.sub(ethAmount);
+        invariant = totalEthQuantity.mul(totalTokenQuantity);
+    }
+}

src/App.js

@@ -3,8 +3,6 @@ import unicorn from './images/unicornNoBackground.png';
 import ethLogo from './images/ethLogo.png';
 import './App.css';
 
-//window.web3.eth.defaultAccount = window.web3.eth.accounts[0]
-
 var uniswapABI = [{"constant":false,"inputs":[{"name":"tokenAmount","type":"uint256"}],"name":"ownerTokenWithdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"ethAmount","type":"uint256"}],"name":"ownerEthWithdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"sellQuantity","type":"uint256"},{"name":"minimumEth","type":"uint256"},{"name":"timeout","type":"uint256"}],"name":"tokenToEth","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalTokenQuantity","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"minimumTokens","type":"uint256"},{"name":"timeout","type":"uint256"}],"name":"ethToTokens","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"initialTokenQuantity","type":"uint256"}],"name":"initiateUniswap","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalEthQuantity","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"tokenAddress","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"invariant","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_tokenAddress","type":"address"}],"payable":true,"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"buyer","type":"address"},{"indexed":false,"name":"tokensPurchased","type":"uint256"},{"indexed":false,"name":"ethSpent","type":"uint256"}],"name":"TokenPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"buyer","type":"address"},{"indexed":false,"name":"ethPurchased","type":"uint256"},{"indexed":false,"name":"tokensSpent","type":"uint256"}],"name":"EthPurchase","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]
 var uniswapAddress = '0xe52dd7e4c3652600bc6daf601e5a0eea2b072597';
 var uniswapContract = window.web3.eth.contract(uniswapABI).at(uniswapAddress);
@@ -13,8 +11,6 @@ var tokenABI = [{"constant":true,"inputs":[],"name":"mintingFinished","outputs":
 var tokenAddress = '0x8e2183e0Ac73e6FBd1F9E0fAb24368728f978092';
 var tokenContract = window.web3.eth.contract(tokenABI).at(tokenAddress);
 
-//console.log(tokenContract);
-
 /*
 tokenContract.Transfer().watch((err, response) => {
     console.log(response.args.from);
@@ -39,7 +35,10 @@ class App extends Component {
                   tokenBalance: null,
                   tokenAllowance: null,
                   currentMaskAddress: window.web3.eth.accounts[0],
-                  minimumTokensPurchased: null
+                  minimumTokensPurchased: null,
+                  invariant: null,
+                  marketEth: null,
+                  marketTokens: null
     }
 
     this.buyTokens = this.buyTokens.bind(this);
@@ -47,17 +46,33 @@ class App extends Component {
   }
 
   componentWillMount(){
-  //  self.setState(currentMaskAddress: window.web3.eth.defaultAccount)
-  /*  window.web3.eth.getAccounts(function(error, accounts) {
-      var defaultAccount = accounts[0];
-      alert(defaultAccount);
-      self.setState(currentMaskAddress: defaultAccount);
-    }); */
   }
 
 
   componentDidMount(){
+    this.getInvarient();
+    this.getMarketEth();
+    this.getMarketTokens();
+    this.getEthBalance();
+    this.getTokenBalance();
+    this.getAllowance();
+
+
+  }
 
+  approveAllowance(value) {
+    console.log('oh shit waddup');
+    tokenContract.approve(uniswapAddress, value, function(error, balance) {
+      console.log(balance);
+    });
+  }
+
+  getMaskAddress() {
+    var address = window.web3.eth.accounts[0];
+    this.setState({currentMaskAddress: address})
+  }
+
+  getEthBalance() {
     var self = this;
 
     window.web3.eth.getBalance(this.state.currentMaskAddress, function(error, balance) {
@@ -65,36 +80,63 @@ class App extends Component {
       var roundedValue=Math.round(ethValue*10000)/10000;
       self.setState({ethBalance: roundedValue});
     });
+  }
+
+  getTokenBalance() {
+    var self = this;
 
     tokenContract.balanceOf(this.state.currentMaskAddress, function(error, balance) {
       var tokenAmount = (balance.toNumber())/1000000;
       self.setState({tokenBalance: tokenAmount});
     });
+  }
+
+  getAllowance() {
+    var self = this;
 
     tokenContract.allowance(this.state.currentMaskAddress, uniswapAddress, function(error, balance) {
       var tokensAllowed = (balance.toNumber())/1000000;
       self.setState({tokenAllowance: tokensAllowed});
     });
+  }
 
-    //window.web3.eth.getAccounts(accounts => console.log(accounts[0]))
+  getInvarient() {
+    var self = this;
+
+    uniswapContract.invariant.call(function(err, value){
+      var number = value.toNumber();
+      console.log("invariant: " + number/(10**24));
+      self.setState({invariant: number});
+    });
   }
 
-  approveAllowance(value) {
-    console.log('oh shit waddup');
-    tokenContract.approve(uniswapAddress, value, function(error, balance) {
-      console.log(balance);
+  getMarketEth() {
+    var self = this
+
+    uniswapContract.totalEthQuantity.call(function(err, value){
+      var number = value.toNumber();
+      console.log("marketEthQuantity: " + number/(10**18));
+      self.setState({marketEth: number});
+    });
+  }
+
+  getMarketTokens() {
+    var self = this
+
+    uniswapContract.totalTokenQuantity.call(function(err, value){
+      var number = value.toNumber();
+      console.log("marketTokenQuantity: " + number/(10**6));
+      self.setState({marketTokens: number});
     });
   }
 
+
   buyTokens() {
-    console.log(this.state.minimumTokensPurchased);
 
     var minTokens = this.state.minimumTokensPurchased
 
     window.web3.eth.getBlock('latest', function(error, blockInfo) {
-        console.log(blockInfo);
         var time = blockInfo.timestamp;
-        console.log(time)
         var maxTime = time + 300; //current block time + 5mins
 
         uniswapContract.ethToTokens.sendTransaction(minTokens, maxTime, {