Merge pull request #2 from InstaDApp/dev

Merging Dev Commits.

contracts/protocols/InstaKyber.sol

@@ -1,8 +1,31 @@
 pragma solidity ^0.4.24;
 
-import "openzeppelin-solidity/contracts/math/SafeMath.sol";
-import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
 
+library SafeMath {
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "Assertion Failed");
+        return c;
+    }
+    
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b > 0, "Assertion Failed");
+        uint256 c = a / b;
+        return c;
+    }
+
+}
+
+interface IERC20 {
+    function balanceOf(address who) external view returns (uint256);
+    function transfer(address to, uint256 value) external returns (bool);
+    function approve(address spender, uint256 value) external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}
 
 interface AddressRegistry {
     function getAddr(string name) external view returns(address);
@@ -59,48 +82,6 @@ contract Trade is Registry {
         address affiliate
     );
 
-    function executeTrade(
-        address src,
-        address dest,
-        uint srcAmt,
-        uint minConversionRate
-    ) public payable returns (uint destAmt)
-    {
-        address protocolAdmin = getAddress("admin");
-        uint ethQty;
-
-        // fetch token & deduct fees
-        IERC20 tokenFunctions = IERC20(src);
-        if (src == getAddress("eth")) {
-            require(msg.value == srcAmt, "Invalid Operation");
-            ethQty = srcAmt;
-        } else {
-            tokenFunctions.transferFrom(msg.sender, address(this), srcAmt);
-        }
-
-        Kyber kyberFunctions = Kyber(getAddress("kyber"));
-        destAmt = kyberFunctions.trade.value(ethQty)(
-            src,
-            srcAmt,
-            dest,
-            msg.sender,
-            2**256 - 1,
-            minConversionRate,
-            protocolAdmin
-        );
-
-        emit KyberTrade(
-            src,
-            srcAmt,
-            dest,
-            destAmt,
-            msg.sender,
-            minConversionRate,
-            protocolAdmin
-        );
-
-    }
-
     function getExpectedPrice(
         address src,
         address dest,
@@ -109,25 +90,82 @@ contract Trade is Registry {
     {
         Kyber kyberFunctions = Kyber(getAddress("kyber"));
         return kyberFunctions.getExpectedRate(
-            src,
+            src, dest, srcAmt
-            dest,
-            srcAmt
         );
     }
 
     function approveKyber(address[] tokenArr) public {
+        address kyberProxy = getAddress("kyber");
         for (uint i = 0; i < tokenArr.length; i++) {
             IERC20 tokenFunctions = IERC20(tokenArr[i]);
-            tokenFunctions.approve(getAddress("kyber"), 2**256 - 1);
+            tokenFunctions.approve(kyberProxy, 2**256 - 1);
+        }
+    }
+
+    function executeTrade(
+        address src, // token to sell
+        address dest, // token to buy
+        uint srcAmt, // amount of token for sell
+        uint minConversionRate, // minimum slippage rate
+        uint maxDestAmt // max amount of dest token
+    ) public payable returns (uint destAmt)
+    {
+
+        address eth = getAddress("eth");
+        uint ethQty = getToken(
+            msg.sender, src, srcAmt, eth
+        );
+        
+        // Interacting with Kyber Proxy Contract
+        Kyber kyberFunctions = Kyber(getAddress("kyber"));
+        destAmt = kyberFunctions.trade.value(ethQty)(
+            src,
+            srcAmt,
+            dest,
+            msg.sender,
+            maxDestAmt,
+            minConversionRate,
+            getAddress("admin")
+        );
+
+        // maxDestAmt usecase implementated
+        if (src == eth && address(this).balance > 0) {
+            msg.sender.transfer(address(this).balance);
+        } else if (src != eth) { // as there is no balanceOf of eth
+            IERC20 srcTkn = IERC20(src);
+            uint srcBal = srcTkn.balanceOf(address(this));
+            if (srcBal > 0) {
+                srcTkn.transfer(msg.sender, srcBal);
+            }
+        }
+
+        emit KyberTrade(
+            src, srcAmt, dest, destAmt, msg.sender, minConversionRate, getAddress("admin")
+        );
+
+    }
+
+    function getToken(
+        address trader,
+        address src,
+        uint srcAmt,
+        address eth
+    ) internal returns (uint ethQty)
+    {
+        if (src == eth) {
+            require(msg.value == srcAmt, "Invalid Operation");
+            ethQty = srcAmt;
+        } else {
+            IERC20 tokenFunctions = IERC20(src);
+            tokenFunctions.transferFrom(trader, address(this), srcAmt);
+            ethQty = 0;
         }
     }
 
 }
 
 
-contract MoatKyber is Trade {
+contract InstaKyber is Trade {
-
-    event AssetsCollected(address name, uint addr);
 
     constructor(address rAddr) public {
         addressRegistry = rAddr;
@@ -135,14 +173,4 @@ contract MoatKyber is Trade {
 
     function () public payable {}
 
-    function collectAsset(address tokenAddress, uint amount) public onlyAdmin {
-        if (tokenAddress == getAddress("eth")) {
-            msg.sender.transfer(amount);
-        } else {
-            IERC20 tokenFunctions = IERC20(tokenAddress);
-            tokenFunctions.transfer(msg.sender, amount);
-        }
-        emit AssetsCollected(tokenAddress, amount);
-    }
-
 }

contracts/protocols/InstaMaker.sol

@@ -1,8 +1,31 @@
 pragma solidity 0.4.24;
 
-import "openzeppelin-solidity/contracts/math/SafeMath.sol";
-import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
 
+library SafeMath {
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "Assertion Failed");
+        return c;
+    }
+    
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        require(b > 0, "Assertion Failed");
+        uint256 c = a / b;
+        return c;
+    }
+
+}
+
+interface IERC20 {
+    function balanceOf(address who) external view returns (uint256);
+    function transfer(address to, uint256 value) external returns (bool);
+    function approve(address spender, uint256 value) external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}
 
 interface AddressRegistry {
     function getAddr(string name) external view returns(address);
@@ -29,13 +52,20 @@ interface WETHFace {
     function withdraw(uint wad) external;
 }
 
-interface MoatKyber {
+interface InstaKyber {
     function executeTrade(
         address src,
         address dest,
         uint srcAmt,
-        uint minConversionRate
+        uint minConversionRate,
+        uint maxDestAmt
     ) external payable returns (uint destAmt);
+
+    function getExpectedPrice(
+        address src,
+        address dest,
+        uint srcAmt
+    ) external view returns (uint, uint);
 }
 
 
@@ -63,55 +93,50 @@ contract GlobalVar is Registry {
     using SafeMath for uint;
     using SafeMath for uint256;
 
-    // kovan network
+    bytes32 blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000;
-    // address public weth = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
+    address cdpAddr; // cups
-    // address public peth = 0xf4d791139cE033Ad35DB2B2201435fAd668B1b64;
+    mapping (address => bytes32) cdps; // borrower >>> CDP Bytes
-    // address public mkr = 0xAaF64BFCC32d0F15873a02163e7E500671a4ffcD;
-    // address public dai = 0xC4375B7De8af5a38a93548eb8453a498222C4fF2;
-    // address public eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
-    // address public cdpAddr = 0xa71937147b55Deb8a530C7229C442Fd3F31b7db2;
-
-    // address public ethfeed = 0x729D19f657BD0614b4985Cf1D82531c67569197B // pip
-    // address public mkrfeed = 0x99041F808D598B782D5a3e498681C2452A31da08 // pep
-
-    MakerCDP loanMaster = MakerCDP(getAddress("cdp"));
-
-    bytes32 public blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000;
-    mapping (address => bytes32) public cdps; // borrower >>> CDP Bytes
     bool public freezed;
+
 }
 
 
 contract IssueLoan is GlobalVar {
 
-    event LockedETH(address borrower, uint lockETH, uint lockPETH);
+    event LockedETH(address borrower, uint lockETH, uint lockPETH, address lockedBy);
     event LoanedDAI(address borrower, uint loanDAI);
-    event OpenedNewCDP(address borrower, bytes32 cdpBytes);
+    event NewCDP(address borrower, bytes32 cdpBytes);
 
     function pethPEReth(uint ethNum) public view returns (uint rPETH) {
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
         rPETH = (ethNum.mul(10 ** 27)).div(loanMaster.per());
     }
 
     function borrow(uint daiDraw) public payable {
-        if (cdps[msg.sender] == blankCDP) {
+        if (msg.value > 0) {lockETH(msg.sender);}
-            cdps[msg.sender] = loanMaster.open();
-            emit OpenedNewCDP(msg.sender, cdps[msg.sender]);
-        }
-        if (msg.value > 0) {lockETH();}
         if (daiDraw > 0) {drawDAI(daiDraw);}
     }
 
-    function lockETH() public payable {
+    function lockETH(address borrower) public payable {
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
+        if (cdps[borrower] == blankCDP) {
+            require(msg.sender == borrower, "Creating CDP for others is not permitted at the moment.");
+            cdps[msg.sender] = loanMaster.open();
+            emit NewCDP(msg.sender, cdps[msg.sender]);
+        }
         WETHFace wethTkn = WETHFace(getAddress("weth"));
         wethTkn.deposit.value(msg.value)(); // ETH to WETH
         uint pethToLock = pethPEReth(msg.value);
         loanMaster.join(pethToLock); // WETH to PETH
-        loanMaster.lock(cdps[msg.sender], pethToLock); // PETH to CDP
+        loanMaster.lock(cdps[borrower], pethToLock); // PETH to CDP
-        emit LockedETH(msg.sender, msg.value, pethToLock);
+        emit LockedETH(
+            borrower, msg.value, pethToLock, msg.sender
+        );
     }
 
     function drawDAI(uint daiDraw) public {
         require(!freezed, "Operation Disabled");
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
         loanMaster.draw(cdps[msg.sender], daiDraw);
         IERC20 daiTkn = IERC20(getAddress("dai"));
         daiTkn.transfer(msg.sender, daiDraw);
@@ -123,58 +148,46 @@ contract IssueLoan is GlobalVar {
 
 contract RepayLoan is IssueLoan {
 
-    event WipedDAI(address borrower, uint daiWipe, uint mkrCharged);
+    event WipedDAI(address borrower, uint daiWipe, uint mkrCharged, address wipedBy);
     event UnlockedETH(address borrower, uint ethFree);
 
-    function repay(
+    function repay(uint daiWipe, uint ethFree) public payable {
-        uint daiWipe,
+        if (daiWipe > 0) {wipeDAI(daiWipe, msg.sender);}
-        uint ethFree,
-        uint mkrFees, // either this...
-        uint feeMinConRate // or this is 0
-    ) public payable
-    {
-        if (daiWipe > 0) {wipeDAI(daiWipe, mkrFees, feeMinConRate);}
         if (ethFree > 0) {unlockETH(ethFree);}
     }
 
-    function wipeDAI(uint daiWipe, uint mkrFees, uint feeMinConRate) public payable {
+    function wipeDAI(uint daiWipe, address borrower) public payable {
-        IERC20 daiTkn = IERC20(getAddress("dai"));
+        address dai = getAddress("dai");
-        IERC20 mkrTkn = IERC20(getAddress("mkr"));
+        address mkr = getAddress("mkr");
+        address eth = getAddress("eth");
 
-        // MKR now balance
+        IERC20 daiTkn = IERC20(dai);
-        uint nowBal = mkrTkn.balanceOf(address(this));
+        IERC20 mkrTkn = IERC20(mkr);
 
-        // fetch DAI
+        uint contractMKR = mkrTkn.balanceOf(address(this)); // contract MKR balance before wiping
-        daiTkn.transferFrom(msg.sender, address(this), daiWipe); // DAI to pay the debt
+        daiTkn.transferFrom(msg.sender, address(this), daiWipe); // get DAI to pay the debt
-        // wipe DAI
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
-        loanMaster.wipe(cdps[msg.sender], daiWipe);
+        loanMaster.wipe(cdps[borrower], daiWipe); // wipe DAI
+        uint mkrCharged = contractMKR - mkrTkn.balanceOf(address(this)); // MKR fee = before wiping bal - after wiping bal
 
-        // MKR after wiping
+        // claiming paid MKR back
-        uint mkrCharged = nowBal - mkrTkn.balanceOf(address(this));
+        if (msg.value > 0) { // Interacting with Kyber to swap ETH with MKR
-
+            swapETHMKR(
-        // if fees paid in MKR
+                eth, mkr, mkrCharged, msg.value
-        if (mkrFees > 0) {
-            mkrTkn.transferFrom(msg.sender, address(this), mkrCharged); // user paying MKR fees
-        } else { // otherwise swap ETH via MoatKyber
-            MoatKyber mtky = MoatKyber(getAddress("moatkyber"));
-            uint mkrBought = mtky.executeTrade.value(msg.value)(
-                getAddress("eth"),
-                getAddress("mkr"),
-                msg.value,
-                feeMinConRate
             );
-            if (mkrBought > mkrCharged) {
+        } else { // take MKR directly from address
-                mkrTkn.transfer(msg.sender, mkrBought - mkrCharged); // pay back balanced MKR tokens
+            mkrTkn.transferFrom(msg.sender, address(this), mkrCharged); // user paying MKR fees
-            }
         }
 
-        require(mkrTkn.balanceOf(address(this)) == nowBal, "MKR balance not reimbursed");
+        emit WipedDAI(
-        emit WipedDAI(msg.sender, daiWipe, mkrCharged);
+            borrower, daiWipe, mkrCharged, msg.sender
+        );
     }
 
     function unlockETH(uint ethFree) public {
         require(!freezed, "Operation Disabled");
         uint pethToUnlock = pethPEReth(ethFree);
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
         loanMaster.free(cdps[msg.sender], pethToUnlock); // CDP to PETH
         loanMaster.exit(pethToUnlock); // PETH to WETH
         WETHFace wethTkn = WETHFace(getAddress("weth"));
@@ -183,6 +196,25 @@ contract RepayLoan is IssueLoan {
         emit UnlockedETH(msg.sender, ethFree);
     }
 
+    function swapETHMKR(
+        address eth,
+        address mkr,
+        uint mkrCharged,
+        uint ethQty
+    ) internal 
+    {
+        InstaKyber instak = InstaKyber(getAddress("InstaKyber"));
+        uint minRate;
+        (, minRate) = instak.getExpectedPrice(eth, mkr, ethQty);
+        uint mkrBought = instak.executeTrade.value(ethQty)(
+            eth, mkr, ethQty, minRate, mkrCharged
+        );
+        require(mkrCharged == mkrBought, "ETH not sufficient to cover the MKR fees.");
+        if (address(this).balance > 0) {
+            msg.sender.transfer(address(this).balance);
+        }
+    }
+
 }
 
 
@@ -192,24 +224,24 @@ contract BorrowTasks is RepayLoan {
 
     function transferCDP(address nextOwner) public {
         require(nextOwner != 0, "Invalid Address.");
+        MakerCDP loanMaster = MakerCDP(cdpAddr);
         loanMaster.give(cdps[msg.sender], nextOwner);
-        emit TranferCDP(cdps[msg.sender], msg.sender, nextOwner);
         cdps[msg.sender] = blankCDP;
+        emit TranferCDP(cdps[msg.sender], msg.sender, nextOwner);
     }
 
     function getETHRate() public view returns (uint) {
         PriceInterface ethRate = PriceInterface(getAddress("ethfeed"));
         bytes32 ethrate;
         (ethrate, ) = ethRate.peek();
-        return uint(ethrate).div(10**18);
+        return uint(ethrate);
     }
 
-    function getCDPID(address borrower) public view returns (uint) {
+    function getCDP(address borrower) public view returns (uint, bytes32) {
-        return uint(cdps[borrower]);
+        return (uint(cdps[borrower]), cdps[borrower]);
     }
 
     function approveERC20() public {
-        address cdpAddr = getAddress("cdp");
         IERC20 wethTkn = IERC20(getAddress("weth"));
         wethTkn.approve(cdpAddr, 2**256 - 1);
         IERC20 pethTkn = IERC20(getAddress("peth"));
@@ -223,26 +255,27 @@ contract BorrowTasks is RepayLoan {
 }
 
 
-contract MoatMaker is BorrowTasks {
+contract InstaMaker is BorrowTasks {
+
+    event MKRCollected(uint amount);
 
     constructor(address rAddr) public {
         addressRegistry = rAddr;
+        cdpAddr = getAddress("cdp");
         approveERC20();
     }
 
     function () public payable {}
 
-    function collectAsset(address tokenAddress, uint amount) public onlyAdmin {
-        if (tokenAddress == getAddress("eth")) {
-            msg.sender.transfer(amount);
-        } else {
-            IERC20 tokenFunctions = IERC20(tokenAddress);
-            tokenFunctions.transfer(msg.sender, amount);
-        }
-    }
-
     function freeze(bool stop) public onlyAdmin {
         freezed = stop;
     }
 
+    // collecting MKR token kept as balance to pay fees
+    function collectMKR(uint amount) public onlyAdmin {
+        IERC20 mkrTkn = IERC20(getAddress("mkr"));
+        mkrTkn.transfer(msg.sender, amount);
+        emit MKRCollected(amount);
+    }
+
 }