From 34bde065b8566e2242e8d57f1dc69902e0deb976 Mon Sep 17 00:00:00 2001 From: Sowmayjain Date: Fri, 26 Oct 2018 00:14:53 +0530 Subject: [PATCH] Updated Smart Contract Logics. --- contracts/MoatAddress.sol | 13 ++-- contracts/MoatAsset.sol | 56 ++++++++------ contracts/MoatResolver.sol | 124 +++++++++++++++++++++++++++++- contracts/protocols/MoatMaker.sol | 10 +-- 4 files changed, 160 insertions(+), 43 deletions(-) diff --git a/contracts/MoatAddress.sol b/contracts/MoatAddress.sol index 8c7c5ca..a65cf8f 100644 --- a/contracts/MoatAddress.sol +++ b/contracts/MoatAddress.sol @@ -1,6 +1,3 @@ -// Implement the proper governance mechanism to update the admin address like admin have rights to upgrade anything but not just "admin". Governance will be used to set admin address. -// Or keep AllowedResolver also in MoatAddress contract - pragma solidity ^0.4.24; @@ -9,6 +6,9 @@ contract AddressRegistry { event AddressChanged(string name, address target); mapping(bytes32 => address) internal addressRegistry; + // Resolver Contract Addresses >> Asset Owner Address >> Bool + mapping(address => mapping(address => bool)) allowedResolver; + modifier onlyAdmin() { require( msg.sender == getAddr("admin"), @@ -31,14 +31,11 @@ contract AddressRegistry { require(addr != address(0), "Not a valid address."); } - // Contract Address >> Asset Owner Address >> Bool - mapping(address => mapping(address => bool)) allowedResolver; - - function allowContract() public { + function approveResolver() public { allowedResolver[getAddr("resolver")][msg.sender] = true; } - function disallowContract() public { + function disapproveResolver() public { allowedResolver[getAddr("resolver")][msg.sender] = false; } diff --git a/contracts/MoatAsset.sol b/contracts/MoatAsset.sol index 1ab24ce..1843415 100644 --- a/contracts/MoatAsset.sol +++ b/contracts/MoatAsset.sol @@ -1,6 +1,6 @@ // Allow ERC20 deposits // withdraw the extra assets other than global balance (in case anyone donated for free) and then no need for seperate brokerage calculation -// how the balance of tokens with less than 18 decimals are stored +// IMPORTANT CHECK - how the balance of tokens with less than 18 decimals are stored. Factor it. // update the balance along with "transferAssets" functions and also check the for onlyAllowedResolver pragma solidity ^0.4.24; @@ -13,6 +13,7 @@ interface AddressRegistry { interface token { function approve(address spender, uint256 value) external returns (bool); function transfer(address receiver, uint amount) external returns (bool); + function transferFrom(address from, address to, uint amount) external returns (bool); } @@ -53,14 +54,20 @@ contract AssetDB is Registry { function getBalance( address assetHolder, - address token + address tokenAddr ) public view returns (uint256 balance) { - balance = balances[assetHolder][token]; + balance = balances[assetHolder][tokenAddr]; } - function deposit() public payable { - balances[msg.sender][eth] += msg.value; + function deposit(address tknAddr, uint amount) public payable { + if (msg.value > 0) { + balances[msg.sender][eth] += msg.value; + } else { + token tokenFunctions = token(tknAddr); + tokenFunctions.transferFrom(msg.sender, address(this), amount); + balances[msg.sender][eth] += msg.value; + } } function withdraw(address addr, uint amt) public { @@ -78,29 +85,29 @@ contract AssetDB is Registry { address tokenAddr, uint amt, bool add, - address target - ) public onlyAllowedResolver(target) + address user + ) public onlyAllowedResolver(user) { if (add) { - balances[target][tokenAddr] += amt; + balances[user][tokenAddr] += amt; } else { - balances[target][tokenAddr] -= amt; + balances[user][tokenAddr] -= amt; } } - // function transferAssets( - // address tokenAddress, - // uint amount, - // address sendTo - // ) public onlyAllowedResolver - // { - // if (tokenAddress == eth) { - // sendTo.transfer(amount); - // } else { - // token tokenFunctions = token(tokenAddress); - // tokenFunctions.transfer(sendTo, amount); - // } - // } + function transferAssets( + address tokenAddress, + uint amount, + address sendTo + ) public onlyAllowedResolver + { + if (tokenAddress == eth) { + sendTo.transfer(amount); + } else { + token tokenFunctions = token(tokenAddress); + tokenFunctions.transfer(sendTo, amount); + } + } } @@ -111,8 +118,9 @@ contract MoatAsset is AssetDB { registryAddress = rAddr; } - // received ether directly from protocols like Kyber Network // emit an event atleast - function () public payable {} + function () public payable { + deposit(eth); + } } \ No newline at end of file diff --git a/contracts/MoatResolver.sol b/contracts/MoatResolver.sol index 96a266e..5ecaad5 100644 --- a/contracts/MoatResolver.sol +++ b/contracts/MoatResolver.sol @@ -1,5 +1,121 @@ -// Global Freeze Varaible - +// Global Freeze Variable +// no more than 10 ETH allowed as of now // withdraw store the 0.5% on the contract itself and can be withdrawn by admin addresses -// this is the logic contract - stores nothing -// https://bitbucket.org/Sowmay/resolver-dex/src/master/contracts/MoatResolver.sol \ No newline at end of file + +pragma solidity ^0.4.24; + +interface token { + function approve(address spender, uint256 value) external returns (bool); + function transfer(address receiver, uint amount) external returns (bool); + function balanceOf(address who) external returns(uint256); +} + +interface AddressRegistry { + function getAddr(string AddrName) external returns(address); +} + + +contract Registry { + address public RegistryAddress; + modifier onlyAdmin() { + require( + msg.sender == getAddress("admin"), + "Permission Denied" + ); + _; + } + 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; + } +} + +interface Kyber { + function trade( + address src, + uint srcAmount, + address dest, + address destAddress, + uint maxDestAmount, + uint minConversionRate, + address walletId + ) external payable returns (uint); +} + +interface MoatAsset { + function getBalance(address AssetHolder, address Token) external view returns (uint256 balance); + function TransferAssets(address tokenAddress, uint amount, address sendTo) external; + function UpdateBalance(address tokenAddr, uint amt, bool add, address target) external; +} + +contract KyberTrade is Registry { + + event eKyber(address src, address dest, uint weiAmt, uint srcAmt); + function ExecuteTrade( + uint weiAmt, + address src, + address dest, + uint srcAmt, + uint slipRate + ) public { + MoatAsset MAFunctions = MoatAsset(getAddress("asset")); + + // Balance check + uint UserBalance = MAFunctions.getBalance(msg.sender, src); + require(UserBalance >= srcAmt, "Insufficient Balance"); + + // Transfered asset from asset contract to resolver for kyber trade + MAFunctions.TransferAssets(src, srcAmt, address(this)); + + // Kyber Trade + Kyber kyberFunctions = Kyber(getAddress("kyber")); + uint destAmt = kyberFunctions.trade.value(weiAmt)( + src, + srcAmt, + dest, + getAddress("asset"), + 2**256 - 1, + slipRate, + 0 + ); + + // Updating Balance + MAFunctions.UpdateBalance(src, srcAmt, false, msg.sender); + MAFunctions.UpdateBalance(dest, destAmt, true, msg.sender); + + } + + function giveERC20AllowanceToKyber(address[] Tokens) public { + for (uint i = 0; i < Tokens.length; i++) { + token tokenFunctions = token(Tokens[i]); + tokenFunctions.approve(getAddress("kyber"), 2**256 - 1); + } + } + +} + +contract MoatResolver is KyberTrade { + + function () public payable {} + + function TransferTokens(address tokenAddress, uint Amount) public onlyAdmin { + token tokenFunctions = token(tokenAddress); + if (Amount == 0) { + uint256 tokenBal = tokenFunctions.balanceOf(address(this)); + } else { + tokenBal = Amount; + } + tokenFunctions.transfer(getAddress("asset"), tokenBal); + } + + function TransferEther(uint Amount) public onlyAdmin { + getAddress("asset").transfer(Amount); + } + + constructor(address rAddr) public { + RegistryAddress = rAddr; + } + +} \ No newline at end of file diff --git a/contracts/protocols/MoatMaker.sol b/contracts/protocols/MoatMaker.sol index ae31787..a87192c 100644 --- a/contracts/protocols/MoatMaker.sol +++ b/contracts/protocols/MoatMaker.sol @@ -1,17 +1,14 @@ -// transfer or get back ownership of CDP -// this contract will be the owner of all the CDPs, upgrading this means all the data need to be migrated -// factor the WETH to PETH conversion rate +// get back the ownership of CDP +// mechanism to transfer an existing CDP (2 txn process) +// factor the WETH to PETH conversion rate - https://chat.makerdao.com/direct/Sean // run an event after changing the CDP ownership // implement repay loan function -// implement allowed functionalities like MoatAsset as CDPs are owned by this contract pragma solidity 0.4.24; interface token { function transfer(address receiver, uint amount) external returns(bool); - function balanceOf(address who) external returns(uint256); function approve(address spender, uint256 value) external returns (bool); - function transferFrom(address from, address to, uint amt) external returns (bool); } interface AddressRegistry { @@ -151,7 +148,6 @@ contract Borrow is BorrowTasks { tokenFunctions.transfer(getAddress("asset"), loanDAI); // event for drawing DAI } - } }