diff --git a/contracts/logics/exchangeRate/daiLogic.sol b/contracts/logics/exchangeRate/daiLogic.sol new file mode 100644 index 0000000..cdb4fd4 --- /dev/null +++ b/contracts/logics/exchangeRate/daiLogic.sol @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; + +import { DSMath } from "../../libs/safeMath.sol"; + +interface CTokenInterface { + function borrowBalanceCurrent(address account) external returns (uint256); + function exchangeRateCurrent() external returns (uint256); + + function balanceOf(address owner) external view returns (uint256); + + function underlying() external view returns (address); +} + +interface TokenInterface { + function balanceOf(address owner) external view returns (uint256); +} + +interface CompTroller { + function getAllMarkets() external view returns (address[] memory); +} + +interface ICurve { + function get_virtual_price() external view returns (uint256 out); +} + + +interface PriceFeedInterface { + function getPrices(address[] memory tokens) external view returns (uint256[] memory pricesInETH); + function getPrice(address token) external view returns (uint256 priceInETH); + function getEthPrice() external view returns (uint256 ethPriceUSD); +} + +contract DaiRateLogic is DSMath { + address public immutable poolToken; + address public immutable dsa; + + address public constant ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public constant daiAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + address public constant PriceFeedAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant compTrollerAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant cethAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant curve3poolAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant curve3poolTokenAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + function getCompoundNetAssetsInEth(address _dsa) private returns (uint256 _netBal) { + uint totalSupplyInETH; + uint totalBorrowInETH; + address[] memory allMarkets = CompTroller(compTrollerAddr).getAllMarkets(); + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + + for (uint i = 0; i < allMarkets.length; i++) { + CTokenInterface ctoken = CTokenInterface(allMarkets[i]); + uint tokenPriceInETH = address(ctoken) == cethAddr ? 10 ** 18 : priceFeedContract.getPrice(ctoken.underlying()); + uint supply = wmul(ctoken.balanceOf(_dsa), ctoken.exchangeRateCurrent()); + uint supplyInETH = wmul(supply, tokenPriceInETH); + + uint borrow = ctoken.borrowBalanceCurrent(_dsa); + uint borrowInETH = wmul(borrow, tokenPriceInETH); + + totalSupplyInETH += add(totalSupplyInETH, supplyInETH); + totalBorrowInETH = add(totalBorrowInETH, borrowInETH); + } + _netBal = sub(totalSupplyInETH, totalBorrowInETH); + } + + function getCurveNetAssetsInEth(address _dsa) private view returns (uint256 _netBal) { + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + uint ethPriceUSD = priceFeedContract.getEthPrice(); + uint virtualPrice = ICurve(curve3poolAddr).get_virtual_price(); + uint curveTokenBal = TokenInterface(curve3poolTokenAddr).balanceOf(_dsa); + uint amtInUSD = wmul(curveTokenBal, virtualPrice); + uint amtInETH = wdiv(amtInUSD, ethPriceUSD); + _netBal = add(_netBal, amtInETH); + } + + function getNetDsaAssetsInEth(address _dsa) private returns (uint256 _netBal) { + _netBal += getCompoundNetAssetsInEth(_dsa); + _netBal += getCurveNetAssetsInEth(_dsa); + } + + function getTotalToken() public returns (uint256 _daiBal) { + address _dsa = 0x0000000000000000000000000000000000000000; + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + uint daiPriceInETH = priceFeedContract.getPrice(daiAddr); + + TokenInterface daiToken = TokenInterface(daiAddr); + _daiBal = daiToken.balanceOf(poolToken); + _daiBal += daiToken.balanceOf(_dsa); + + uint balInEth = getNetDsaAssetsInEth(_dsa); + _daiBal = wdiv(balInEth, daiPriceInETH); + } + + constructor (address daiPool, address _dsa) public { + poolToken = address(daiPool); + dsa = _dsa; + } +} \ No newline at end of file diff --git a/contracts/logics/exchangeRate/ethLogic.sol b/contracts/logics/exchangeRate/ethLogic.sol new file mode 100644 index 0000000..2750401 --- /dev/null +++ b/contracts/logics/exchangeRate/ethLogic.sol @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; + +import { DSMath } from "../../libs/safeMath.sol"; + +interface CTokenInterface { + function borrowBalanceCurrent(address account) external returns (uint256); + function exchangeRateCurrent() external returns (uint256); + + function balanceOf(address owner) external view returns (uint256); + + function underlying() external view returns (address); +} + +interface CompTroller { + function getAllMarkets() external view returns (address[] memory); +} + +interface ICurve { + function get_virtual_price() external view returns (uint256 out); +} + +interface TokenInterface { + function balanceOf(address owner) external view returns (uint256); +} + +interface PriceFeedInterface { + function getPrices(address[] memory tokens) external view returns (uint256[] memory pricesInETH); + function getPrice(address token) external view returns (uint256 priceInETH); + function getEthPrice() external view returns (uint256 ethPriceUSD); +} + +interface ManagerLike { + function ilks(uint) external view returns (bytes32); + function owns(uint) external view returns (address); + function urns(uint) external view returns (address); + function vat() external view returns (address); +} + +interface VatLike { + function ilks(bytes32) external view returns (uint, uint, uint, uint, uint); + function dai(address) external view returns (uint); + function urns(bytes32, address) external view returns (uint, uint); + function gem(bytes32, address) external view returns (uint); +} + + +contract EthRateLogic is DSMath { + address public immutable poolToken; + address public immutable dsa; + + uint public immutable vaultId; + address public immutable vaultUrn; + + address public constant ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public constant daiAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + address public constant PriceFeedAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant compTrollerAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant cethAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant curve3poolAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant curve3poolTokenAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant managerAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + bytes32 public constant ethIlk = bytes32(0); + + + function getMakerNetAssetsInEth() private view returns (uint256 _netBal) { + ManagerLike managerContract = ManagerLike(managerAddr); + VatLike vatContract = VatLike(managerContract.vat()); + uint daiPriceInETH = PriceFeedInterface(PriceFeedAddr).getPrice(daiAddr); + + (uint coll, uint art) = vatContract.urns(ethIlk, vaultUrn); + (,uint rate,,,) = vatContract.ilks(ethIlk); + uint debt = rmul(art,rate); + uint debtInEth = wmul(debt, daiPriceInETH); + return sub(coll, debtInEth); + + } + + function getCompoundNetAssetsInEth(address _dsa) private returns (uint256 _netBal) { + uint totalSupplyInETH; + uint totalBorrowInETH; + address[] memory allMarkets = CompTroller(compTrollerAddr).getAllMarkets(); + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + + for (uint i = 0; i < allMarkets.length; i++) { + CTokenInterface ctoken = CTokenInterface(allMarkets[i]); + uint tokenPriceInETH = address(ctoken) == cethAddr ? 10 ** 18 : priceFeedContract.getPrice(ctoken.underlying()); + uint supply = wmul(ctoken.balanceOf(_dsa), ctoken.exchangeRateCurrent()); + uint supplyInETH = wmul(supply, tokenPriceInETH); + + uint borrow = ctoken.borrowBalanceCurrent(_dsa); + uint borrowInETH = wmul(borrow, tokenPriceInETH); + + totalSupplyInETH += add(totalSupplyInETH, supplyInETH); + totalBorrowInETH = add(totalBorrowInETH, borrowInETH); + } + _netBal = sub(totalSupplyInETH, totalBorrowInETH); + } + + function getCurveNetAssetsInEth(address _dsa) private view returns (uint256 _netBal) { + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + uint ethPriceUSD = priceFeedContract.getEthPrice(); + uint virtualPrice = ICurve(curve3poolAddr).get_virtual_price(); + uint curveTokenBal = TokenInterface(curve3poolTokenAddr).balanceOf(_dsa); + uint amtInUSD = wmul(curveTokenBal, virtualPrice); + uint amtInETH = wdiv(amtInUSD, ethPriceUSD); + _netBal = add(_netBal, amtInETH); + } + + function getNetDsaAssets(address _dsa) private returns (uint256 _netBal) { + _netBal = _dsa.balance; + _netBal += getCompoundNetAssetsInEth(_dsa); + _netBal += getMakerNetAssetsInEth(); + _netBal += getCurveNetAssetsInEth(_dsa); + } + + function getTotalToken() public returns (uint256) { + address _dsa = 0x0000000000000000000000000000000000000000; + uint256 bal = poolToken.balance; + bal += getNetDsaAssets(_dsa); + return bal; + } + + constructor (address ethPool, address _dsa, uint _vaultId) public { + poolToken = address(ethPool); + vaultId = _vaultId; + dsa = _dsa; + vaultUrn = ManagerLike(managerAddr).urns(_vaultId); + + } +} \ No newline at end of file diff --git a/contracts/logics/exchangeRate/priceFeed.sol b/contracts/logics/exchangeRate/priceFeed.sol new file mode 100644 index 0000000..8b132b3 --- /dev/null +++ b/contracts/logics/exchangeRate/priceFeed.sol @@ -0,0 +1,147 @@ +pragma solidity ^0.6.0; +pragma experimental ABIEncoderV2; + +interface ChainLinkInterface { + function latestAnswer() external view returns (int256); + function decimals() external view returns (uint256); +} + +interface IndexInterface { + function master() external view returns (address); +} + +interface TokenInterface { + function decimals() external view returns (uint); +} + +import { DSMath } from "../../libs/safeMath.sol"; + + +contract Basic is DSMath { + address public constant instaIndex = 0x2971AdFa57b20E5a416aE5a708A8655A9c74f723; + address public constant ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + modifier isChief { + require( + IndexInterface(instaIndex).master() == msg.sender, "not-Chief"); + _; + } + + event LogAddChainLinkMapping( + address tokenSymbol, + address chainlinkFeed + ); + + event LogRemoveChainLinkMapping( + address tokenSymbol, + address chainlinkFeed + ); + + struct FeedData { + address feedAddress; + uint multiplier; + } + + mapping (address => FeedData) public chainLinkMapping; + + + function convertPrice(uint price, uint multiplier) internal pure returns (uint) { + return price * (10 ** multiplier); + } + + function _addChainLinkMapping( + address token, + address chainlinkFeed + ) internal { + require(token != address(0), "token-not-vaild"); + require(chainlinkFeed != address(0), "chainlinkFeed-not-vaild"); + require(chainLinkMapping[token].feedAddress == address(0), "chainlinkFeed-already-added"); + uint tokenDec = token == ethAddr ? 18 : TokenInterface(token).decimals(); + uint feedDec = ChainLinkInterface(chainlinkFeed).decimals(); + + chainLinkMapping[token].feedAddress = chainlinkFeed; + chainLinkMapping[token].multiplier = sub(36, add(tokenDec, feedDec)); + emit LogAddChainLinkMapping(token, chainlinkFeed); + } + + function _removeChainLinkMapping(address token) internal { + require(token != address(0), "token-not-vaild"); + require(chainLinkMapping[token].feedAddress != address(0), "chainlinkFeed-not-added-yet"); + + emit LogRemoveChainLinkMapping(token, chainLinkMapping[token].feedAddress); + delete chainLinkMapping[token]; + } + + function addChainLinkMapping( + address[] memory tokens, + address[] memory chainlinkFeeds + ) public isChief { + require(tokens.length == chainlinkFeeds.length, "lenght-not-same"); + for (uint i = 0; i < tokens.length; i++) { + _addChainLinkMapping(tokens[i], chainlinkFeeds[i]); + } + } + + function removeChainLinkMapping(address[] memory tokens) public isChief { + for (uint i = 0; i < tokens.length; i++) { + _removeChainLinkMapping(tokens[i]); + } + } +} + +contract Resolver is Basic { + function getPrices(address[] memory tokens) + public + view + returns ( + uint[] memory tokensPriceInETH + ) { + tokensPriceInETH = new uint[](tokens.length); + for (uint i = 0; i < tokens.length; i++) { + if (tokens[i] != ethAddr) { + FeedData memory feedData = chainLinkMapping[tokens[i]]; + ChainLinkInterface feedContract = ChainLinkInterface(feedData.feedAddress); + require(address(feedContract) != address(0), "price-not-found"); + tokensPriceInETH[i] = convertPrice(uint(feedContract.latestAnswer()), feedData.multiplier); + } else { + tokensPriceInETH[i] = 10 ** 18; + } + } + } + + function getPrice(address token) + public + view + returns ( + uint tokenPriceInETH + ) { + if (token != ethAddr) { + FeedData memory tokenFeedData = chainLinkMapping[token]; + ChainLinkInterface tokenFeed = ChainLinkInterface(tokenFeedData.feedAddress); + require(address(tokenFeed) != address(0), "price-not-found"); + tokenPriceInETH = convertPrice(uint(tokenFeed.latestAnswer()), tokenFeedData.multiplier); + } else { + tokenPriceInETH = 10 ** 18; + } + } + + function getEthPrice() + public + view + returns ( + uint ethPriceInUsd + ) { + FeedData memory ethFeedData = chainLinkMapping[ethAddr]; + ChainLinkInterface ethFeed = ChainLinkInterface(ethFeedData.feedAddress); + ethPriceInUsd = convertPrice(uint(ethFeed.latestAnswer()), ethFeedData.multiplier); + } +} + +contract ChainLinkPriceFeed is Resolver { + constructor (address[] memory tokens, address[] memory chainlinkFeeds) public { + require(tokens.length == chainlinkFeeds.length, "Lenght-not-same"); + for (uint i = 0; i < tokens.length; i++) { + _addChainLinkMapping(tokens[i], chainlinkFeeds[i]); + } + } +} \ No newline at end of file diff --git a/contracts/logics/exchangeRate/usdcLogic.sol b/contracts/logics/exchangeRate/usdcLogic.sol new file mode 100644 index 0000000..6c69792 --- /dev/null +++ b/contracts/logics/exchangeRate/usdcLogic.sol @@ -0,0 +1,144 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; + +import { DSMath } from "../../libs/safeMath.sol"; + +interface CTokenInterface { + function borrowBalanceCurrent(address account) external returns (uint256); + function exchangeRateCurrent() external returns (uint256); + + function balanceOf(address owner) external view returns (uint256); + + function underlying() external view returns (address); +} + +interface CompTroller { + function getAllMarkets() external view returns (address[] memory); +} + +interface ICurve { + function get_virtual_price() external view returns (uint256 out); +} + +interface TokenInterface { + function balanceOf(address owner) external view returns (uint256); +} + +interface PriceFeedInterface { + function getPrices(address[] memory tokens) external view returns (uint256[] memory pricesInETH); + function getPrice(address token) external view returns (uint256 priceInETH); + function getEthPrice() external view returns (uint256 ethPriceUSD); +} + +interface ManagerLike { + function ilks(uint) external view returns (bytes32); + function owns(uint) external view returns (address); + function urns(uint) external view returns (address); + function vat() external view returns (address); +} + +interface VatLike { + function ilks(bytes32) external view returns (uint, uint, uint, uint, uint); + function dai(address) external view returns (uint); + function urns(bytes32, address) external view returns (uint, uint); + function gem(bytes32, address) external view returns (uint); +} + + +contract UsdcRateLogic is DSMath { + address public immutable poolToken; + address public immutable dsa; + + uint public immutable vaultId; + address public immutable vaultUrn; + + address public constant ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public constant daiAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public constant usdcAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + address public constant PriceFeedAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant compTrollerAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant cethAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant curve3poolAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + address public constant curve3poolTokenAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + + address public constant managerAddr = address(0xe81F70Cc7C0D46e12d70efc60607F16bbD617E88); + bytes32 public constant usdcAIlk = bytes32(0); + + + function getMakerNetAssetsInEth() private view returns (uint256 _netBal) { + ManagerLike managerContract = ManagerLike(managerAddr); + VatLike vatContract = VatLike(managerContract.vat()); + uint daiPriceInETH = PriceFeedInterface(PriceFeedAddr).getPrice(daiAddr); + uint usdcPriceInETH = PriceFeedInterface(PriceFeedAddr).getPrice(usdcAddr); + + (uint coll, uint art) = vatContract.urns(usdcAIlk, vaultUrn); + (,uint rate,,,) = vatContract.ilks(usdcAIlk); + uint debt = rmul(art, rate); + + uint debtInEth = wmul(debt, daiPriceInETH); + uint collInEth = wmul(coll, usdcPriceInETH); + return sub(collInEth, debtInEth); + + } + + function getCompoundNetAssetsInEth(address _dsa) private returns (uint256 _netBalInEth) { + uint totalSupplyInETH; + uint totalBorrowInETH; + address[] memory allMarkets = CompTroller(compTrollerAddr).getAllMarkets(); + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + + for (uint i = 0; i < allMarkets.length; i++) { + CTokenInterface ctoken = CTokenInterface(allMarkets[i]); + uint tokenPriceInETH = address(ctoken) == cethAddr ? 10 ** 18 : priceFeedContract.getPrice(ctoken.underlying()); + uint supply = wmul(ctoken.balanceOf(_dsa), ctoken.exchangeRateCurrent()); + uint supplyInETH = wmul(supply, tokenPriceInETH); + + uint borrow = ctoken.borrowBalanceCurrent(_dsa); + uint borrowInETH = wmul(borrow, tokenPriceInETH); + + totalSupplyInETH += add(totalSupplyInETH, supplyInETH); + totalBorrowInETH = add(totalBorrowInETH, borrowInETH); + } + _netBalInEth = sub(totalSupplyInETH, totalBorrowInETH); + } + + function getCurveNetAssetsInEth(address _dsa) private view returns (uint256 _netBalInEth) { + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + uint ethPriceUSD = priceFeedContract.getEthPrice(); + uint virtualPrice = ICurve(curve3poolAddr).get_virtual_price(); + uint curveTokenBal = TokenInterface(curve3poolTokenAddr).balanceOf(_dsa); + uint amtInUSD = wmul(curveTokenBal, virtualPrice); + uint amtInETH = wdiv(amtInUSD, ethPriceUSD); + _netBalInEth = add(_netBalInEth, amtInETH); + } + + function getNetDsaAssetsInEth(address _dsa) private returns (uint256 _netBalInEth) { + _netBalInEth += getCompoundNetAssetsInEth(_dsa); + _netBalInEth += getMakerNetAssetsInEth(); + _netBalInEth += getCurveNetAssetsInEth(_dsa); + } + + function getTotalToken() public returns (uint256 usdcBal) { + address _dsa = 0x0000000000000000000000000000000000000000; + PriceFeedInterface priceFeedContract = PriceFeedInterface(PriceFeedAddr); + uint usdcPriceInETH = priceFeedContract.getPrice(usdcAddr); + + TokenInterface usdcToken = TokenInterface(usdcAddr); + usdcBal = usdcToken.balanceOf(_dsa); + usdcBal += TokenInterface(usdcAddr).balanceOf(poolToken); + + uint balInEth = getNetDsaAssetsInEth(_dsa); + usdcBal += wdiv(balInEth, usdcPriceInETH); + } + + + constructor (address usdcPool, address _dsa, uint _vaultId) public { + poolToken = address(usdcPool); + vaultId = _vaultId; + dsa = _dsa; + vaultUrn = ManagerLike(managerAddr).urns(_vaultId); + } +} \ No newline at end of file diff --git a/contracts/logics/settle/eth/basic.sol b/contracts/logics/settle/eth/basic.sol new file mode 100644 index 0000000..cd02417 --- /dev/null +++ b/contracts/logics/settle/eth/basic.sol @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; +pragma experimental ABIEncoderV2; + +import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; +import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +import { DSMath } from "../../../libs/safeMath.sol"; + +interface DSAInterface { + function cast(address[] calldata _targets, bytes[] calldata _data, address _origin) external payable; + function isAuth(address) external returns(bool); +} + +contract LogicOne { + + using SafeERC20 for IERC20; + + /** + * @dev Return ethereum address + */ + function getEthAddr() internal pure returns (address) { + return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; // ETH Address + } + + function getOriginAddress() private pure returns(address) { + return 0xB7fA44c2E964B6EB24893f7082Ecc08c8d0c0F87; // DSA address + } + + function deploy(address _dsa, address _token, uint amt) public { + require(DSAInterface(_dsa).isAuth(address(this)), "pool-not-auth-in-dsa"); + if (_token == getEthAddr()) { + uint _bal = address(this).balance; + amt = amt > _bal ? _bal : amt; + payable(_dsa).transfer(amt); + } else { + IERC20 token = IERC20(_token); + uint _bal = token.balanceOf(address(this)); + amt = amt > _bal ? _bal : amt; + token.safeTransfer(_dsa, amt); + } + // emit event? + } + + // withdraw assets from DSA + function redeem(address _dsa, address _token, uint amt) public { + uint _bal = IERC20(_token).balanceOf(_dsa); + amt = amt > _bal ? _bal : amt; + address[] memory _targets = new address[](1); + _targets[0] = address(0); // Check9898 - address of basic connector + bytes[] memory _data = new bytes[](1); + _data[0] = abi.encodeWithSignature("withdraw(address,uint256,address,uint256,uint256)", _token, amt, address(this), uint(0), uint(0)); + DSAInterface(_dsa).cast(_targets, _data, getOriginAddress()); + } +} diff --git a/contracts/logics/settle/eth/crvMining.sol b/contracts/logics/settle/eth/crvMining.sol new file mode 100644 index 0000000..632a188 --- /dev/null +++ b/contracts/logics/settle/eth/crvMining.sol @@ -0,0 +1,97 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; +pragma experimental ABIEncoderV2; + +import { DSMath } from "../../../libs/safeMath.sol"; + +interface DSAInterface { + function cast(address[] calldata _targets, bytes[] calldata _data, address _origin) external payable; +} + +contract LogicOne { + + function getEthAddress() private pure returns(address) { + return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + } + + function getCrvAddress() private pure returns(address) { + return 0xD533a949740bb3306d119CC777fa900bA034cd52; + } + + function getOriginAddress() private pure returns(address) { + return 0xB7fA44c2E964B6EB24893f7082Ecc08c8d0c0F87; + } + + function getDsaAddress() private pure returns(address) { + return address(0); // DSA address + } + + function getGuageAddress() private pure returns(address) { + return 0xAf615b36Db171fD5A369A0060b9bCB88fFf0190d; + } + + function getGuageName() private pure returns(string memory) { + return "guage-3"; + } + + function getCurveConnectAddress() private pure returns(address) { + return 0x1568a9D336A7aC051DCC4bdcc4A0B09299DE5Daf; + } + + function getCurveGuageConnectAddress() private pure returns(address) { + return 0xAf615b36Db171fD5A369A0060b9bCB88fFf0190d; + } + + function getUniswapConnectAddress() private pure returns(address) { + return 0x62EbfF47B2Ba3e47796efaE7C51676762dC961c0; + } + + function mineCrv(address token, uint amt, uint unitAmt) external { + address[] memory _targets = new address[](2); + bytes[] memory _data = new bytes[](2); + _targets[1] = getCurveConnectAddress(); + _data[1] = abi.encodeWithSignature("deposit(address,uint256,uint256,uint256,uint256)", token, amt, unitAmt, uint(0), uint(0)); + _targets[2] = getCurveGuageConnectAddress(); + _data[2] = abi.encodeWithSignature("deposit(string,uint256,uint256,uint256)", getGuageName(), uint(-1), uint(0), uint(0)); + DSAInterface(getDsaAddress()).cast(_targets, _data, getOriginAddress()); + } + + function redeemCrv(address token, uint amt, uint unitAmt) external { + address[] memory _targets; + bytes[] memory _data; + if (amt == uint(-1)) { + _targets = new address[](2); + _data = new bytes[](2); + } else { + _targets = new address[](3); + _data = new bytes[](3); + } + _targets[0] = getCurveGuageConnectAddress(); + _data[0] = abi.encodeWithSignature("withdraw(string,uint256,uint256,uint256,uint256,uint256)", getGuageName(), uint(-1), uint(0), uint(0), uint(0), uint(0)); + _targets[1] = getCurveConnectAddress(); + _data[1] = abi.encodeWithSignature("withdraw(address,uint256,uint256,uint256,uint256)", token, amt, unitAmt, uint(0), uint(0)); + if (amt != uint(-1)) { + _targets[2] = getCurveGuageConnectAddress(); + _data[2] = abi.encodeWithSignature("deposit(string,uint256,uint256,uint256)", getGuageName(), uint(-1), uint(0), uint(0)); + } + DSAInterface(getDsaAddress()).cast(_targets, _data, getOriginAddress()); + } + + function claimCrv() external { + address[] memory _target = new address[](1); + bytes[] memory _data = new bytes[](1); + _target[0] = getCurveGuageConnectAddress(); + _data[0] = abi.encodeWithSignature("claimReward(string,uint256,uint256)", getGuageName(), 0, 0); + DSAInterface(getDsaAddress()).cast(_target, _data, getOriginAddress()); + } + + function claimCrvAndSwap(uint amt, uint unitAmt) external { + address crv = getCrvAddress(); + address eth = getEthAddress(); + address[] memory _target = new address[](1); + bytes[] memory _data = new bytes[](1); + _target[0] = getUniswapConnectAddress(); + _data[0] = abi.encodeWithSignature("sell(address,address,unit256,unit256,unit256,unit256)", eth, crv, amt, unitAmt, 0, 0); + DSAInterface(getDsaAddress()).cast(_target, _data, getOriginAddress()); + } +} diff --git a/contracts/logics/settle/eth/exchangeRate.sol b/contracts/logics/settle/eth/exchangeRate.sol new file mode 100644 index 0000000..e0ace7e --- /dev/null +++ b/contracts/logics/settle/eth/exchangeRate.sol @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; + +import { DSMath } from "../../../libs/safeMath.sol"; + +interface PoolInterface { + function setExchangeRate() external; +} + +contract LogicOne { + + function setExchangeRate() public payable { + PoolInterface(address(this)).setExchangeRate(); + } + +} diff --git a/contracts/logics/settle/eth/maker.sol b/contracts/logics/settle/eth/maker.sol new file mode 100644 index 0000000..504f82c --- /dev/null +++ b/contracts/logics/settle/eth/maker.sol @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; +pragma experimental ABIEncoderV2; + +import { DSMath } from "../../../libs/safeMath.sol"; + +interface VaultDataInterface { + + struct VaultData { + uint id; + address owner; + string colType; + uint collateral; + uint art; + uint debt; + uint liquidatedCol; + uint borrowRate; + uint colPrice; + uint liquidationRatio; + address vaultAddress; + } + + function getVaultById(uint id) external view returns (VaultData memory); + +} + +interface DSAInterface { + function cast(address[] calldata _targets, bytes[] calldata _datas, address _origin) external payable; +} + +contract LogicOne is DSMath { + + function getOriginAddress() private pure returns(address) { + return 0xB7fA44c2E964B6EB24893f7082Ecc08c8d0c0F87; // DSA address + } + + function getMcdAddresses() public pure returns (address) { + return 0xF23196DF1C440345DE07feFbe556a5eF0dcD29F0; + } + + function getInstaMakerResolver() public pure returns (address) { + return 0x0A7008B38E7015F8C36A49eEbc32513ECA8801E5; + } + + function getMakerConnectAddress() public pure returns (address) { + return 0x6c4E4D4aB22cAB08b8498a3A232D92609e8b2d62; + } + + function getDsaAddress() private pure returns(address) { + return address(0); // DSA address + } + + function vaultId() private pure returns(uint) { + return 0; // vault ID + } + + function checkMakerVault() private view { + VaultDataInterface.VaultData memory vaultData = VaultDataInterface(getInstaMakerResolver()).getVaultById(vaultId()); + uint col = vaultData.collateral; + uint debt = vaultData.debt; + uint price = vaultData.colPrice / 10 ** 9; // making 18 decimal + // uint liquidation = vaultData.liqInk / 10 ** 9; // making 18 decimal + uint currentRatio = wdiv(wmul(col, price), debt); + require(200 * 10 ** 18 < currentRatio, "position-risky"); // ratio should be less than 50% (should we keep it 60%?) + } + + function depositAndBorrow(uint depositAmt, uint borrowAmt) public { + address[] memory _targets = new address[](2); + bytes[] memory _data = new bytes[](2); + _targets[0] = getMakerConnectAddress(); + _data[0] = abi.encodeWithSignature("deposit(uint256,uint256,uint256,uint256)", vaultId(), depositAmt, uint(0), uint(0)); + _targets[1] = getMakerConnectAddress(); + _data[1] = abi.encodeWithSignature("borrow(uint256,uint256,uint256,uint256)", vaultId(), borrowAmt, uint(0), uint(0)); + DSAInterface(getDsaAddress()).cast(_targets, _data, getOriginAddress()); + checkMakerVault(); + } + + function paybackAndWithdraw(uint withdrawAmt, uint paybackAmt) public { + address[] memory _targets = new address[](2); + bytes[] memory _data = new bytes[](2); + _targets[0] = getMakerConnectAddress(); + _data[0] = abi.encodeWithSignature("payback(uint256,uint256,uint256,uint256)", vaultId(), paybackAmt, uint(0), uint(0)); + _targets[1] = getMakerConnectAddress(); + _data[1] = abi.encodeWithSignature("withdraw(uint256,uint256,uint256,uint256)", vaultId(), withdrawAmt, uint(0), uint(0)); + DSAInterface(getDsaAddress()).cast(_targets, _data, getOriginAddress()); + checkMakerVault(); + } +} diff --git a/contracts/logics/settle/eth/maxComp.sol b/contracts/logics/settle/eth/maxComp.sol new file mode 100644 index 0000000..44dfe30 --- /dev/null +++ b/contracts/logics/settle/eth/maxComp.sol @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.6.8; +pragma experimental ABIEncoderV2; + +import { DSMath } from "../../../libs/safeMath.sol"; + +interface CTokenInterface { + function borrowBalanceCurrent(address account) external returns (uint256); + function exchangeRateCurrent() external returns (uint256); + + function balanceOf(address owner) external view returns (uint256); + + function underlying() external view returns (address); +} + +interface DSAInterface { + function cast(address[] calldata _targets, bytes[] calldata _datas, address _origin) external payable; +} + +interface CompTroller { + function getAllMarkets() external view returns (address[] memory); +} + +interface OracleComp { + function getUnderlyingPrice(address) external view returns (uint); +} + +interface InstaMapping { + function cTokenMapping(address) external view returns (address); +} + +contract LogicOne is DSMath { + + struct CastData { + address[] dsaTargets; + bytes[] dsaData; + } + + function getOriginAddress() private pure returns(address) { + return 0xB7fA44c2E964B6EB24893f7082Ecc08c8d0c0F87; // DSA address + } + + function getEthAddress() private pure returns(address) { + return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; // DSA address + } + + function getCompAddress() private pure returns(address) { + return 0xc00e94Cb662C3520282E6f5717214004A7f26888; // DSA address + } + + function getComptrollerAddress() private pure returns (address) { + return 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B; + } + + function getDaiAddress() private pure returns(address) { + return 0x6B175474E89094C44Da98b954EedeAC495271d0F; // DAI address + } + + function getCdaiAddress() private pure returns(address) { + return 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643; // CDAI address + } + + function getDsaAddress() private pure returns(address) { + return address(0); // DSA address + } + + function getCompoundConnectAddress() private pure returns(address) { + return 0x07F81230d73a78f63F0c2A3403AD281b067d28F8; + } + + function getFlashloanConnectAddress() private pure returns(address) { + return 0xaA3EA0b22802d68DA73D5f4D3f9F1C7C238fE03A; + } + + function getCompConnectAddress() private pure returns(address) { + return 0xB4a04F1C194bEed64FCE27843B5b3079339cdaD4; + } + + function getUniswapConnectAddress() private pure returns(address) { + return 0x62EbfF47B2Ba3e47796efaE7C51676762dC961c0; + } + + function checkCompoundAssets() private { + address[] memory allMarkets = CompTroller(getComptrollerAddress()).getAllMarkets(); + uint supply; + uint borrow; + for (uint i = 0; i < allMarkets.length; i++) { + CTokenInterface ctoken = CTokenInterface(allMarkets[i]); + if (allMarkets[i] == getCdaiAddress()) { + supply = wmul(ctoken.balanceOf(getDsaAddress()), ctoken.exchangeRateCurrent()); + } + borrow = ctoken.borrowBalanceCurrent(getDsaAddress()); + + if (allMarkets[i] != getCdaiAddress()) { + require(borrow == 0, "assets"); + } else { + require(wdiv(borrow, supply) < 745 * 10 ** 15, "position-risky"); // DAI ratio - should be less than 74.5% + } + } + } + + function maxComp(uint flashAmt, uint route, address[] calldata _targets, bytes[] calldata _data) external { + address compoundConnect = getCompoundConnectAddress(); + address flashloanConnect = getFlashloanConnectAddress(); + for (uint i = 0; i < _targets.length; i++) { + require(_targets[i] == compoundConnect || _targets[i] == flashloanConnect, "not-authorised-connector"); + } + bytes memory _dataEncode = abi.encode(_targets, _data); + address[] memory _targetFlash = new address[](1); + bytes[] memory _dataFlash = new bytes[](1); + _targetFlash[0] = flashloanConnect; + _dataFlash[0] = abi.encodeWithSignature("flashBorrowAndCast(address,uint256,uint256,bytes)", getDaiAddress(), flashAmt, route, _dataEncode); + DSAInterface(getDsaAddress()).cast(_targetFlash, _dataFlash, getOriginAddress()); + checkCompoundAssets(); + } + + function claimComp(address[] calldata tokens) external { + address[] memory _target = new address[](1); + bytes[] memory _data = new bytes[](1); + _target[0] = getCompConnectAddress(); + _data[0] = abi.encodeWithSignature("ClaimCompTwo(address[],uint256)", tokens, 0); + DSAInterface(getDsaAddress()).cast(_target, _data, getOriginAddress()); + } + + function swapComp(uint amt, uint unitAmt) external { + address[] memory _target = new address[](1); + bytes[] memory _data = new bytes[](1); + _target[0] = getUniswapConnectAddress(); + _data[0] = abi.encodeWithSignature("sell(address,address,unit256,unit256,unit256,unit256)", getEthAddress(), getCompAddress(), amt, unitAmt, 0, 0); + DSAInterface(getDsaAddress()).cast(_target, _data, getOriginAddress()); + } +}