Instadapp/InstaContract
1
0
Fork 0
mirror of https://github.com/Instadapp/InstaContract.git synced 2024-07-29 22:47:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2 from InstaDApp/dev

Browse Source 
Merging Dev Commits.
This commit is contained in:
Sowmay Jain 2018-12-01 03:38:10 +05:30 committed by GitHub
commit 1cf4f8dcd0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 203 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
contracts/MoatAddress.sol → contracts/InstaAddress.sol
View File

150
contracts/protocols/MoatKyber.sol → contracts/protocols/InstaKyber.sol
View File

@ -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,
dest,
srcAmt
src, 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 {
event AssetsCollected(address name, uint addr);
contract InstaKyber is Trade {
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);
}
}

195
contracts/protocols/MoatMaker.sol → contracts/protocols/InstaMaker.sol
View File

@ -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
// address public weth = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
// address public peth = 0xf4d791139cE033Ad35DB2B2201435fAd668B1b64;
// 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
bytes32 blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000;
address cdpAddr; // cups
mapping (address => bytes32) 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) {
cdps[msg.sender] = loanMaster.open();
emit OpenedNewCDP(msg.sender, cdps[msg.sender]);
}
if (msg.value > 0) {lockETH();}
if (msg.value > 0) {lockETH(msg.sender);}
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
emit LockedETH(msg.sender, msg.value, pethToLock);
loanMaster.lock(cdps[borrower], pethToLock); // PETH to CDP
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(
uint daiWipe,
uint ethFree,
uint mkrFees, // either this...
uint feeMinConRate // or this is 0
) public payable
{
if (daiWipe > 0) {wipeDAI(daiWipe, mkrFees, feeMinConRate);}
function repay(uint daiWipe, uint ethFree) public payable {
if (daiWipe > 0) {wipeDAI(daiWipe, msg.sender);}
if (ethFree > 0) {unlockETH(ethFree);}
}
function wipeDAI(uint daiWipe, uint mkrFees, uint feeMinConRate) public payable {
IERC20 daiTkn = IERC20(getAddress("dai"));
IERC20 mkrTkn = IERC20(getAddress("mkr"));
function wipeDAI(uint daiWipe, address borrower) public payable {
address dai = getAddress("dai");
address mkr = getAddress("mkr");
address eth = getAddress("eth");
// MKR now balance
uint nowBal = mkrTkn.balanceOf(address(this));
IERC20 daiTkn = IERC20(dai);
IERC20 mkrTkn = IERC20(mkr);
// fetch DAI
daiTkn.transferFrom(msg.sender, address(this), daiWipe); // DAI to pay the debt
// wipe DAI
loanMaster.wipe(cdps[msg.sender], daiWipe);
uint contractMKR = mkrTkn.balanceOf(address(this)); // contract MKR balance before wiping
daiTkn.transferFrom(msg.sender, address(this), daiWipe); // get DAI to pay the debt
MakerCDP loanMaster = MakerCDP(cdpAddr);
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
uint mkrCharged = nowBal - mkrTkn.balanceOf(address(this));
// if fees paid in MKR
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
// claiming paid MKR back
if (msg.value > 0) { // Interacting with Kyber to swap ETH with MKR
swapETHMKR(
eth, mkr, mkrCharged, msg.value
);
if (mkrBought > mkrCharged) {
mkrTkn.transfer(msg.sender, mkrBought - mkrCharged); // pay back balanced MKR tokens
}
} else { // take MKR directly from address
mkrTkn.transferFrom(msg.sender, address(this), mkrCharged); // user paying MKR fees
}
require(mkrTkn.balanceOf(address(this)) == nowBal, "MKR balance not reimbursed");
emit WipedDAI(msg.sender, daiWipe, mkrCharged);
emit WipedDAI(
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) {
return uint(cdps[borrower]);
function getCDP(address borrower) public view returns (uint, bytes32) {
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);
}
}