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

Fixed standard error and optimised code.

Browse Source
This commit is contained in:
Sowmayjain 2018-10-29 17:36:21 +05:30
parent 7b65b2c384
commit 399c068e54
4 changed files with 176 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
contracts/bin/MoatAsset.sol
View File

@ -1,116 +1,116 @@
// withdraw the extra assets other than global balance (in case anyone donated for free) and then no need for seperate brokerage calculation // // withdraw the extra assets other than global balance (in case anyone donated for free) and then no need for seperate brokerage calculation
// IMPORTANT CHECK - decimals() - how the balance of tokens with less than 18 decimals are stored. Factor it. // // IMPORTANT CHECK - decimals() - 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 // // update the balance along with "transferAssets" functions and also check the for onlyAllowedResolver
// transfer assets to different address (create 2 different mappings) - 48 hour time to transfer all - send email for this // // transfer assets to different address (create 2 different mappings) - 48 hour time to transfer all - send email for this
pragma solidity ^0.4.24; // pragma solidity ^0.4.24;
import "openzeppelin-solidity/contracts/math/SafeMath.sol"; // import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol"; // import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
interface AddressRegistry { // interface AddressRegistry {
function getAddr(string name) external view returns(address); // function getAddr(string name) external view returns(address);
function isApprovedResolver(address user) external view returns(bool); // function isApprovedResolver(address user) external view returns(bool);
} // }
contract Registry { // contract Registry {
address public registryAddress; // address public registryAddress;
AddressRegistry addrReg = AddressRegistry(registryAddress); // AddressRegistry addrReg = AddressRegistry(registryAddress);
modifier onlyAllowedResolver(address user) { // modifier onlyAllowedResolver(address user) {
require( // require(
addrReg.isApprovedResolver(user), // addrReg.isApprovedResolver(user),
"Permission Denied" // "Permission Denied"
); // );
_; // _;
} // }
function getAddress(string name) internal view returns(address addr) { // function getAddress(string name) internal view returns(address addr) {
addr = addrReg.getAddr(name); // addr = addrReg.getAddr(name);
require(addr != address(0), "Invalid Address"); // require(addr != address(0), "Invalid Address");
} // }
} // }
contract AssetDB is Registry { // contract AssetDB is Registry {
using SafeMath for uint; // using SafeMath for uint;
using SafeMath for uint256; // using SafeMath for uint256;
mapping(address => mapping(address => uint)) balances; // mapping(address => mapping(address => uint)) balances;
address eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; // address eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
function getBalance( // function getBalance(
address assetHolder, // address assetHolder,
address tokenAddr // address tokenAddr
) public view returns (uint256 balance) // ) public view returns (uint256 balance)
{ // {
balance = balances[assetHolder][tokenAddr]; // balance = balances[assetHolder][tokenAddr];
} // }
function deposit(address tknAddr, uint amount) public payable { // function deposit(address tknAddr, uint amount) public payable {
if (msg.value > 0) { // if (msg.value > 0) {
balances[msg.sender][eth] = balances[msg.sender][eth].add(msg.value); // balances[msg.sender][eth] = balances[msg.sender][eth].add(msg.value);
} else { // } else {
IERC20 tokenFunctions = IERC20(tknAddr); // IERC20 tokenFunctions = IERC20(tknAddr);
tokenFunctions.transferFrom(msg.sender, address(this), amount); // tokenFunctions.transferFrom(msg.sender, address(this), amount);
balances[msg.sender][tknAddr] = balances[msg.sender][tknAddr].add(amount); // balances[msg.sender][tknAddr] = balances[msg.sender][tknAddr].add(amount);
} // }
} // }
function withdraw(address tknAddr, uint amount) public { // function withdraw(address tknAddr, uint amount) public {
require(balances[msg.sender][tknAddr] >= amount, "Insufficient Balance"); // require(balances[msg.sender][tknAddr] >= amount, "Insufficient Balance");
balances[msg.sender][tknAddr] = balances[msg.sender][tknAddr].sub(amount); // balances[msg.sender][tknAddr] = balances[msg.sender][tknAddr].sub(amount);
if (tknAddr == eth) { // if (tknAddr == eth) {
msg.sender.transfer(amount); // msg.sender.transfer(amount);
} else { // } else {
IERC20 tokenFunctions = IERC20(tknAddr); // IERC20 tokenFunctions = IERC20(tknAddr);
tokenFunctions.transfer(msg.sender, amount); // tokenFunctions.transfer(msg.sender, amount);
} // }
} // }
function updateBalance( // function updateBalance(
address tokenAddr, // address tokenAddr,
uint amount, // uint amount,
bool credit, // bool credit,
address user // address user
) public onlyAllowedResolver(user) // ) public onlyAllowedResolver(user)
{ // {
if (credit) { // if (credit) {
balances[user][tokenAddr] = balances[user][tokenAddr].add(amount); // balances[user][tokenAddr] = balances[user][tokenAddr].add(amount);
} else { // } else {
balances[user][tokenAddr] = balances[user][tokenAddr].sub(amount); // balances[user][tokenAddr] = balances[user][tokenAddr].sub(amount);
} // }
} // }
function transferAssets( // function transferAssets(
address tokenAddress, // address tokenAddress,
uint amount, // uint amount,
address sendTo, // address sendTo,
address user // address user
) public onlyAllowedResolver(user) // ) public onlyAllowedResolver(user)
{ // {
if (tokenAddress == eth) { // if (tokenAddress == eth) {
sendTo.transfer(amount); // sendTo.transfer(amount);
} else { // } else {
IERC20 tokenFunctions = IERC20(tokenAddress); // IERC20 tokenFunctions = IERC20(tokenAddress);
tokenFunctions.transfer(sendTo, amount); // tokenFunctions.transfer(sendTo, amount);
} // }
balances[user][tokenAddress] = balances[user][tokenAddress].sub(amount); // balances[user][tokenAddress] = balances[user][tokenAddress].sub(amount);
} // }
} // }
contract MoatAsset is AssetDB { // contract MoatAsset is AssetDB {
constructor(address rAddr) public { // constructor(address rAddr) public {
registryAddress = rAddr; // registryAddress = rAddr;
} // }
function () public payable {} // function () public payable {}
} // }

82
contracts/bin/MoatResolver.sol
View File

@ -1,58 +1,58 @@
pragma solidity ^0.4.24; // pragma solidity ^0.4.24;
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol"; // import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
interface AddressRegistry { // interface AddressRegistry {
function getAddr(string name) external view returns(address); // function getAddr(string name) external view returns(address);
} // }
contract Registry { // contract Registry {
address public registryAddress; // address public registryAddress;
modifier onlyAdmin() { // modifier onlyAdmin() {
require( // require(
msg.sender == getAddress("admin"), // msg.sender == getAddress("admin"),
"Permission Denied" // "Permission Denied"
); // );
_; // _;
} // }
function getAddress(string name) internal view returns(address addr) { // function getAddress(string name) internal view returns(address addr) {
AddressRegistry addrReg = AddressRegistry(registryAddress); // AddressRegistry addrReg = AddressRegistry(registryAddress);
addr = addrReg.getAddr(name); // addr = addrReg.getAddr(name);
require(addr != address(0), "Invalid Address"); // require(addr != address(0), "Invalid Address");
} // }
} // }
contract FeeDetail is Registry { // contract FeeDetail is Registry {
uint public fees; // uint public fees;
function setFees(uint cut) public onlyAdmin { // 200 means 0.5% // function setFees(uint cut) public onlyAdmin { // 200 means 0.5%
fees = cut; // fees = cut;
} // }
} // }
contract MoatResolver is FeeDetail { // contract MoatResolver is FeeDetail {
function () public payable {} // function () public payable {}
constructor(address rAddr, uint cut) public { // 200 means 0.5% // constructor(address rAddr, uint cut) public { // 200 means 0.5%
registryAddress = rAddr; // registryAddress = rAddr;
setFees(cut); // setFees(cut);
} // }
function collectAsset(address tokenAddress, uint amount) public onlyAdmin { // function collectAsset(address tokenAddress, uint amount) public onlyAdmin {
if (tokenAddress == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) { // if (tokenAddress == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
msg.sender.transfer(amount); // msg.sender.transfer(amount);
} else { // } else {
IERC20 tokenFunctions = IERC20(tokenAddress); // IERC20 tokenFunctions = IERC20(tokenAddress);
tokenFunctions.transfer(msg.sender, amount); // tokenFunctions.transfer(msg.sender, amount);
} // }
} // }
} // }

45
contracts/protocols/MoatKyber.sol
View File

@ -1,37 +1,7 @@
pragma solidity ^0.4.24; pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/math/SafeMath.sol"; import "openzeppelin-solidity/contracts/math/SafeMath.sol";
// import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol"; import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
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);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface AddressRegistry { interface AddressRegistry {
@ -78,8 +48,8 @@ contract Registry {
contract Trade is Registry { contract Trade is Registry {
// using SafeMath for uint; using SafeMath for uint;
// using SafeMath for uint256; using SafeMath for uint256;
uint public fees; uint public fees;
@ -103,6 +73,7 @@ contract Trade is Registry {
{ {
address protocolAdmin = getAddress("admin"); address protocolAdmin = getAddress("admin");
uint sellQty = srcAmt; uint sellQty = srcAmt;
uint ethQty;
uint feecut; uint feecut;
if (fees > 0) { if (fees > 0) {
feecut = srcAmt / fees; feecut = srcAmt / fees;
@ -114,13 +85,14 @@ contract Trade is Registry {
if (src == getAddress("eth")) { if (src == getAddress("eth")) {
require(msg.value == srcAmt, "Invalid Operation"); require(msg.value == srcAmt, "Invalid Operation");
if (feecut > 0) {protocolAdmin.transfer(feecut);} if (feecut > 0) {protocolAdmin.transfer(feecut);}
ethQty = sellQty;
} else { } else {
tokenFunctions.transferFrom(msg.sender, address(this), srcAmt); tokenFunctions.transferFrom(msg.sender, address(this), srcAmt);
if (feecut > 0) {tokenFunctions.transfer(protocolAdmin, feecut);} if (feecut > 0) {tokenFunctions.transfer(protocolAdmin, feecut);}
} }
Kyber kyberFunctions = Kyber(getAddress("kyber")); Kyber kyberFunctions = Kyber(getAddress("kyber"));
destAmt = kyberFunctions.trade.value(sellQty)( destAmt = kyberFunctions.trade.value(ethQty)(
src, src,
sellQty, sellQty,
dest, dest,
@ -147,7 +119,8 @@ contract Trade is Registry {
address src, address src,
address dest, address dest,
uint srcAmt uint srcAmt
) public view returns (uint, uint) { ) public view returns (uint, uint)
{
Kyber kyberFunctions = Kyber(getAddress("kyber")); Kyber kyberFunctions = Kyber(getAddress("kyber"));
return kyberFunctions.getExpectedRate( return kyberFunctions.getExpectedRate(
src, src,

61
contracts/protocols/MoatMaker.sol
View File

@ -21,7 +21,7 @@ interface MakerCDP {
} }
interface PriceInterface { interface PriceInterface {
function peek() public view returns (bytes32, bool); function peek() external view returns (bytes32, bool);
} }
interface WETHFace { interface WETHFace {
@ -55,15 +55,15 @@ contract GlobalVar is Registry {
using SafeMath for uint256; using SafeMath for uint256;
// kovan network // kovan network
address public weth = 0xd0A1E359811322d97991E03f863a0C30C2cF029C; // address public weth = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
address public peth = 0xf4d791139cE033Ad35DB2B2201435fAd668B1b64; // address public peth = 0xf4d791139cE033Ad35DB2B2201435fAd668B1b64;
address public mkr = 0xAaF64BFCC32d0F15873a02163e7E500671a4ffcD; // address public mkr = 0xAaF64BFCC32d0F15873a02163e7E500671a4ffcD;
address public dai = 0xC4375B7De8af5a38a93548eb8453a498222C4fF2; // address public dai = 0xC4375B7De8af5a38a93548eb8453a498222C4fF2;
address public eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; // address public eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
// address public pricefeed = 0xA944bd4b25C9F186A846fd5668941AA3d3B8425F;
// address public cdpAddr = 0xa71937147b55Deb8a530C7229C442Fd3F31b7db2;
address public pricefeed = 0xA944bd4b25C9F186A846fd5668941AA3d3B8425F; MakerCDP loanMaster = MakerCDP(getAddress("cdp"));
address public cdpAddr = 0xa71937147b55Deb8a530C7229C442Fd3F31b7db2;
MakerCDP loanMaster = MakerCDP(cdpAddr);
bytes32 public blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000; bytes32 public blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000;
mapping (address => bytes32) public cdps; // borrower >>> CDP Bytes mapping (address => bytes32) public cdps; // borrower >>> CDP Bytes
@ -78,8 +78,8 @@ contract IssueLoan is GlobalVar {
event LoanedDAI(address borrower, uint loanDAI, uint fees); event LoanedDAI(address borrower, uint loanDAI, uint fees);
event OpenedNewCDP(address borrower, bytes32 cdpBytes); event OpenedNewCDP(address borrower, bytes32 cdpBytes);
function pethPEReth(uint eth) public view returns (uint rPETH) { function pethPEReth(uint ethNum) public view returns (uint rPETH) {
rPETH = eth * (10 ** 27) / loanMaster.per(); rPETH = ethNum * (10 ** 27) / loanMaster.per();
} }
function borrow(uint daiDraw) public payable { function borrow(uint daiDraw) public payable {
@ -92,8 +92,8 @@ contract IssueLoan is GlobalVar {
} }
function lockETH() public payable { function lockETH() public payable {
WETHFace wethFunction = WETHFace(weth); WETHFace wethTkn = WETHFace(getAddress("weth"));
wethFunction.deposit.value(msg.value)(); // ETH to WETH wethTkn.deposit.value(msg.value)(); // ETH to WETH
uint pethToLock = pethPEReth(msg.value); uint pethToLock = pethPEReth(msg.value);
loanMaster.join(pethToLock); // WETH to PETH loanMaster.join(pethToLock); // WETH to PETH
loanMaster.lock(cdps[msg.sender], pethToLock); // PETH to CDP loanMaster.lock(cdps[msg.sender], pethToLock); // PETH to CDP
@ -104,16 +104,16 @@ contract IssueLoan is GlobalVar {
require(!freezed, "Operation Disabled"); require(!freezed, "Operation Disabled");
loanMaster.draw(cdps[msg.sender], daiDraw); loanMaster.draw(cdps[msg.sender], daiDraw);
uint feecut = deductFees(daiDraw); uint feecut = deductFees(daiDraw);
IERC20 tokenFunctions = IERC20(dai); IERC20 daiTkn = IERC20(getAddress("dai"));
tokenFunctions.transfer(msg.sender, daiDraw - feecut); daiTkn.transfer(msg.sender, daiDraw - feecut);
emit LoanedDAI(msg.sender, daiDraw, feecut); emit LoanedDAI(msg.sender, daiDraw, feecut);
} }
function deductFees(uint volume) internal returns(uint brokerage) { function deductFees(uint volume) internal returns(uint brokerage) {
if (fees > 0) { if (fees > 0) {
brokerage = volume / fees; brokerage = volume / fees;
IERC20 tokenFunctions = IERC20(dai); IERC20 daiTkn = IERC20(getAddress("dai"));
tokenFunctions.transfer(getAddress("admin"), brokerage); daiTkn.transfer(getAddress("admin"), brokerage);
} }
} }
@ -136,8 +136,8 @@ contract RepayLoan is IssueLoan {
} }
function wipeDAI(uint daiWipe, uint mkrFees) public { function wipeDAI(uint daiWipe, uint mkrFees) public {
IERC20 mkrTkn = IERC20(mkr); IERC20 mkrTkn = IERC20(getAddress("mkr"));
IERC20 daiTkn = IERC20(dai); IERC20 daiTkn = IERC20(getAddress("dai"));
mkrTkn.transferFrom(msg.sender, address(this), mkrFees); // MKR tokens to pay the debt fees mkrTkn.transferFrom(msg.sender, address(this), mkrFees); // MKR tokens to pay the debt fees
daiTkn.transferFrom(msg.sender, address(this), daiWipe); // DAI to pay the debt daiTkn.transferFrom(msg.sender, address(this), daiWipe); // DAI to pay the debt
loanMaster.wipe(cdps[msg.sender], daiWipe); loanMaster.wipe(cdps[msg.sender], daiWipe);
@ -150,8 +150,8 @@ contract RepayLoan is IssueLoan {
uint pethToUnlock = pethPEReth(ethFree); uint pethToUnlock = pethPEReth(ethFree);
loanMaster.free(cdps[msg.sender], pethToUnlock); // CDP to PETH loanMaster.free(cdps[msg.sender], pethToUnlock); // CDP to PETH
loanMaster.exit(pethToUnlock); // PETH to WETH loanMaster.exit(pethToUnlock); // PETH to WETH
WETHFace wethFunction = WETHFace(weth); WETHFace wethTkn = WETHFace(getAddress("weth"));
wethFunction.withdraw(ethFree); // WETH to ETH wethTkn.withdraw(ethFree); // WETH to ETH
msg.sender.transfer(ethFree); msg.sender.transfer(ethFree);
emit UnlockedETH(msg.sender, ethFree); emit UnlockedETH(msg.sender, ethFree);
} }
@ -170,9 +170,11 @@ contract BorrowTasks is RepayLoan {
cdps[msg.sender] = blankCDP; cdps[msg.sender] = blankCDP;
} }
function getETHRate() public view returns (uint ethprice) { function getETHRate() public view returns (uint) {
PriceInterface ethRate = PriceInterface(pricefeed); PriceInterface ethRate = PriceInterface(getAddress("price"));
(ethprice, ) = uint(ethRate.peek()) / 10**18; bytes32 ethrate;
(ethrate, ) = ethRate.peek();
return (uint(ethrate) / 10**18);
} }
function getCDPID(address borrower) public view returns (uint) { function getCDPID(address borrower) public view returns (uint) {
@ -180,13 +182,14 @@ contract BorrowTasks is RepayLoan {
} }
function approveERC20() public { function approveERC20() public {
IERC20 wethTkn = IERC20(weth); address cdpAddr = getAddress("cdp");
IERC20 wethTkn = IERC20(getAddress("weth"));
wethTkn.approve(cdpAddr, 2**256 - 1); wethTkn.approve(cdpAddr, 2**256 - 1);
IERC20 pethTkn = IERC20(peth); IERC20 pethTkn = IERC20(getAddress("peth"));
pethTkn.approve(cdpAddr, 2**256 - 1); pethTkn.approve(cdpAddr, 2**256 - 1);
IERC20 mkrTkn = IERC20(mkr); IERC20 mkrTkn = IERC20(getAddress("mkr"));
mkrTkn.approve(cdpAddr, 2**256 - 1); mkrTkn.approve(cdpAddr, 2**256 - 1);
IERC20 daiTkn = IERC20(dai); IERC20 daiTkn = IERC20(getAddress("dai"));
daiTkn.approve(cdpAddr, 2**256 - 1); daiTkn.approve(cdpAddr, 2**256 - 1);
} }
@ -203,7 +206,7 @@ contract MoatMaker is BorrowTasks {
function () public payable {} function () public payable {}
function collectAsset(address tokenAddress, uint amount) public onlyAdmin { function collectAsset(address tokenAddress, uint amount) public onlyAdmin {
if (tokenAddress == eth) { if (tokenAddress == getAddress("eth")) {
msg.sender.transfer(amount); msg.sender.transfer(amount);
} else { } else {
IERC20 tokenFunctions = IERC20(tokenAddress); IERC20 tokenFunctions = IERC20(tokenAddress);