diff --git a/contracts/MoatAsset.sol b/contracts/MoatAsset.sol index 3a3e0c0..ec24517 100644 --- a/contracts/MoatAsset.sol +++ b/contracts/MoatAsset.sol @@ -22,14 +22,6 @@ contract Registry { address public registryAddress; AddressRegistry aRegistry = AddressRegistry(registryAddress); - modifier onlyAdmin() { - require( - msg.sender == getAddress("admin"), - "Permission Denied" - ); - _; - } - modifier onlyAllowedResolver(address user) { require( aRegistry.isApprovedResolver(user), diff --git a/contracts/MoatResolver.sol b/contracts/MoatResolver.sol index 7e1f461..94aae95 100644 --- a/contracts/MoatResolver.sol +++ b/contracts/MoatResolver.sol @@ -1,17 +1,32 @@ // Global Freeze Variable // withdraw store the 0.5% on the contract itself and can be withdrawn by admin addresses // after sometime of inactivity, admin have power to change the ownership of the wealth. What say? +// still didn't factor 18 decimal thing on Kyber pragma solidity ^0.4.24; interface AddressRegistry { - function getAddr(string AddrName) external returns(address); + function getAddr(string addrName) external returns(address); +} + +interface token { + function transfer(address receiver, uint amount) external returns(bool); } interface MoatAsset { function getBalance(address assetHolder, address tokenAddr) external view returns (uint256 balance); - function transferAssets(address tokenAddress, uint amount, address sendTo, address target) external; - function updateBalance(address tokenAddress, uint amount, bool credit, address user) external; + function transferAssets( + address tokenAddress, + uint amount, + address sendTo, + address target + ) external; + function updateBalance( + address tokenAddress, + uint amount, + bool credit, + address user + ) external; } interface MoatKyber { @@ -25,9 +40,18 @@ interface MoatKyber { ) external returns (uint); } +interface MoatMaker { + function getLoan( + address borrower, + uint lockETH, + uint loanDAI + ) external returns (uint, address); +} + contract Registry { - address public RegistryAddress; + + address public registryAddress; modifier onlyAdmin() { require( msg.sender == getAddress("admin"), @@ -35,50 +59,71 @@ contract Registry { ); _; } - function getAddress(string AddressName) internal view returns(address) { - AddressRegistry aRegistry = AddressRegistry(RegistryAddress); - address realAddress = aRegistry.getAddr(AddressName); - require(realAddress != address(0), "Invalid Address"); - return realAddress; + + function getAddress(string name) internal view returns(address addr) { + AddressRegistry aRegistry = AddressRegistry(registryAddress); + addr = aRegistry.getAddr(name); + require(addr != address(0), "Invalid Address"); } + } contract Protocols is Registry { + event KyberExecute( + address trader, + address src, + address dest, + uint srcAmt, + uint destAmt, + uint slipRate, + uint fees + ); + + event MakerLoan( + address borrower, + uint lockETH, + uint loanDAI, + uint feeDeduct + ); + address eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; uint public fees; bool public feesBool; - - - event KyberExecute(address src, address dest, uint srcAmt, uint destAmt, uint slipRate, uint fees); + function getFees() public view returns(uint, bool) { + return (fees, feesBool); + } function kyberTrade( - uint weiAmt, address src, address dest, uint srcAmt, uint slipRate - ) public payable { - - MoatAsset MAFunctions = MoatAsset(getAddress("asset")); + ) public payable + { + MoatAsset initMA = MoatAsset(getAddress("asset")); + uint ethVal; - - if (msg.value > 0) { - ethVal = msg.value; - getAddress("moatkyber").transfer(msg.value); - } else { - ethVal = weiAmt; - MAFunctions.transferAssets(src, srcAmt, getAddress("moatkyber"), msg.sender); + if (src == eth) { + ethVal = srcAmt; } - // get assets from MoatAsset or user individual wallet - // send that asset to MoatKyber + if (msg.value > 0 && msg.value == srcAmt) { + getAddress("moatkyber").transfer(srcAmt); + } else { + initMA.transferAssets( + src, + srcAmt, + getAddress("moatkyber"), + msg.sender + ); + } // initiate kyber trade - MoatKyber kmoat = MoatKyber(getAddress("moatkyber")); - uint destAmt = kmoat.executeTrade( + MoatKyber kybermoat = MoatKyber(getAddress("moatkyber")); + uint destAmt = kybermoat.executeTrade( ethVal, src, dest, @@ -87,22 +132,98 @@ contract Protocols is Registry { getAddress("admin") ); - MAFunctions.updateBalance(dest, destAmt, true, msg.sender); - - // fees deduction only if the user have ETH balance - uint assetBal = MAFunctions.getBalance(msg.sender, eth); - if (assetBal > 0 && feesBool) { - if (src == eth) { // if selling ETH - MAFunctions.transferAssets(eth, ethVal/200, address(this), msg.sender); - emit KyberExecute(src, dest, srcAmt, destAmt, slipRate, ethVal/200); - } else { // if buying ETH - MAFunctions.transferAssets(eth, destAmt/200, address(this), msg.sender); - emit KyberExecute(src, dest, srcAmt, destAmt, slipRate, destAmt/200); - } - } else { - emit KyberExecute(src, dest, srcAmt, destAmt, slipRate, 0); + uint feeCut; + uint modifiedDestAmt = destAmt; + if (feesBool) { + feeCut = destAmt/fees; + modifiedDestAmt = destAmt - feeCut; } + if (dest == eth) { + getAddress("asset").transfer(modifiedDestAmt); + } else { + token tokenFunctions = token(dest); + tokenFunctions.transfer(getAddress("asset"), destAmt); + } + + initMA.updateBalance( + src, + srcAmt, + false, + msg.sender + ); + + initMA.updateBalance( + dest, + modifiedDestAmt, + true, + msg.sender + ); + + emit KyberExecute( + msg.sender, + src, + dest, + srcAmt, + destAmt, + slipRate, + feeCut + ); + } + + function makerBorrow( + uint lockETH, + uint loanDAI + ) public payable + { + + MoatAsset initMA = MoatAsset(getAddress("asset")); + + if (msg.value > 0) { + require(lockETH == msg.value, "Possibility of glitch in the Tx"); + getAddress("moatmaker").transfer(msg.value); + } else { + initMA.transferAssets( + eth, + lockETH, + getAddress("moatmaker"), + msg.sender + ); + initMA.updateBalance( + eth, + lockETH, + false, + msg.sender + ); + } + + MoatMaker makermoat = MoatMaker(getAddress("moatmaker")); + uint daiMinted; + address daiAddr; + (daiMinted, daiAddr) = makermoat.getLoan( + msg.sender, + lockETH, + loanDAI + ); + + uint modifiedLoanDAI; + uint feeDeduct; + if (loanDAI > 0) { + if (feesBool) { + feeDeduct = loanDAI/fees; + modifiedLoanDAI = loanDAI - feeDeduct; + } + token tokenFunctions = token(daiAddr); + tokenFunctions.transfer(getAddress("asset"), modifiedLoanDAI); + initMA.updateBalance( + daiAddr, + modifiedLoanDAI, + true, + msg.sender + ); + } + + emit MakerLoan(msg.sender, lockETH, loanDAI, feeDeduct); } } @@ -113,8 +234,25 @@ contract MoatResolver is Protocols { function () public payable {} constructor(address rAddr, uint cut) public { // 200 means 0.5% - RegistryAddress = rAddr; + registryAddress = rAddr; fees = cut; } + function collectFees(address tokenAddress, uint amount) public onlyAdmin { + if (tokenAddress == eth) { + msg.sender.transfer(amount); + } else { + token tokenFunctions = token(tokenAddress); + tokenFunctions.transfer(msg.sender, amount); + } + } + + function enableFees() public onlyAdmin { + feesBool = true; + } + + function disableFees() public onlyAdmin { + feesBool = false; + } + } \ No newline at end of file diff --git a/contracts/protocols/MoatKyber.sol b/contracts/protocols/MoatKyber.sol index 03681d1..41f52ca 100644 --- a/contracts/protocols/MoatKyber.sol +++ b/contracts/protocols/MoatKyber.sol @@ -29,6 +29,7 @@ interface Kyber { contract Registry { address public registryAddress; + modifier onlyResolver() { require( msg.sender == getAddress("resolver"), @@ -37,6 +38,14 @@ contract Registry { _; } + modifier onlyAdmin() { + require( + msg.sender == getAddress("admin"), + "Permission Denied" + ); + _; + } + function getAddress(string name) internal view returns(address addr) { AddressRegistry aRegistry = AddressRegistry(registryAddress); addr = aRegistry.getAddr(name); @@ -48,7 +57,7 @@ contract Registry { contract Trade is Registry { - event Swapped(address src, uint srcAmt, address dest, uint destAmt); + address eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; function executeTrade( uint weiAmt, @@ -64,17 +73,11 @@ contract Trade is Registry { src, srcAmt, dest, - getAddress("asset"), + getAddress("resolver"), 2**256 - 1, slipRate, walletId ); - emit Swapped( - src, - srcAmt, - dest, - destAmt - ); } function allowKyber(address[] tokenArr) public { @@ -95,4 +98,13 @@ contract MoatKyber is Trade { function () public payable {} + function collectFees(address tokenAddress, uint amount) public onlyAdmin { + if (tokenAddress == eth) { + msg.sender.transfer(amount); + } else { + token tokenFunctions = token(tokenAddress); + tokenFunctions.transfer(msg.sender, amount); + } + } + } \ No newline at end of file diff --git a/contracts/protocols/MoatMaker.sol b/contracts/protocols/MoatMaker.sol index 8848f05..e3c8e94 100644 --- a/contracts/protocols/MoatMaker.sol +++ b/contracts/protocols/MoatMaker.sol @@ -114,7 +114,7 @@ contract Borrow is BorrowTasks { if (borrower != msg.sender) { require( msg.sender == getAddress("resolver"), - "Message Sender is not MoatResolver." + "Message sender is not MoatResolver." ); require( aRegistry.isApprovedResolver(borrower), @@ -128,25 +128,25 @@ contract Borrow is BorrowTasks { address borrower, uint lockETH, uint loanDAI - ) public securedResolver(borrower) + ) public securedResolver(borrower) returns (uint daiMinted, address daiAddr) { if (borrowerCDPs[borrower] == 0x0000000000000000000000000000000000000000000000000000000000000000) { borrowerCDPs[borrower] = openCDP(); } - if (lockETH != 0) { convertToWETH(lockETH); convertToPETH(lockETH - lockETH/1000); lockPETH(borrower, lockETH - lockETH/1000); // event for locking ETH } - if (loanDAI != 0) { loanMaster.draw(borrowerCDPs[borrower], loanDAI); token tokenFunctions = token(dai); - tokenFunctions.transfer(getAddress("asset"), loanDAI); + tokenFunctions.transfer(getAddress("resolver"), loanDAI); + daiMinted = loanDAI; // event for drawing DAI } + return (daiMinted, daiAddr); } }