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

Simplified Address, Maker. Removed Resolver.

Browse Source
This commit is contained in:
Sowmayjain 2018-10-29 04:23:17 +05:30
parent 78d4a174a6
commit b27c1d5881
4 changed files with 88 additions and 219 deletions

108
contracts/MoatAddress.sol
View File

@ -1,105 +1,27 @@
pragma solidity ^0.4.24;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
contract AddressRegistry {
event SetGov(address person, bool assigned);
event AddressChanged(string name, address addr);
event PendingAdmin(string name, address addr);
event ResolverApproved(address user, address addr);
event ResolverDisapproved(address user, address addr);
// Addresses managing the protocol governance
mapping(address => bool) public governors;
// Address registry of connected smart contracts
event AddressSet(string name, address addr);
mapping(bytes32 => address) public registry;
// Contract addresses having rights to perform tasks, approved by users
// Resolver Contract >> User >> Approved
mapping(address => mapping(address => bool)) public resolvers;
}
contract ManageRegistry is AddressRegistry {
using SafeMath for uint;
using SafeMath for uint256;
address public pendingAdmin;
uint public pendingTime;
function setPendingAdmin() public {
require(block.timestamp > pendingTime, "Pending!");
registry[keccak256("admin")] = pendingAdmin;
emit PendingAdmin("admin", pendingAdmin);
}
function setAddr(string name, address newAddr) public {
if (keccak256(abi.encodePacked(name)) != keccak256(abi.encodePacked("admin"))) {
require(
governors[msg.sender],
"Permission Denied"
);
pendingAdmin = newAddr;
pendingTime = block.timestamp.add(24 * 60 * 60); // adding 24 hours
} else {
require(
msg.sender == getAddr("admin"),
"Permission Denied"
);
registry[keccak256(abi.encodePacked(name))] = newAddr;
}
emit AddressChanged(name, newAddr);
}
function getAddr(string name) public view returns(address addr) {
addr = registry[keccak256(abi.encodePacked(name))];
require(addr != address(0), "Not a valid address.");
}
}
contract ManageGovernors is ManageRegistry {
function setGovernor(address person, bool assigned) public {
require(
msg.sender == getAddr("admin"),
"Permission Denied"
);
governors[person] = assigned;
emit SetGov(person, assigned);
}
}
contract ManageResolvers is ManageGovernors {
function approveResolver() public {
resolvers[getAddr("resolver")][msg.sender] = true;
emit ResolverApproved(msg.sender, getAddr("resolver"));
}
function disapproveResolver() public {
resolvers[getAddr("resolver")][msg.sender] = false;
emit ResolverDisapproved(msg.sender, getAddr("resolver"));
}
function isApprovedResolver(address user) public view returns(bool) {
return resolvers[getAddr("resolver")][user];
}
}
contract InitRegistry is ManageResolvers {
constructor() public {
registry[keccak256(abi.encodePacked("admin"))] = msg.sender;
}
function getAddr(string name) public view returns(address) {
return registry[keccak256(abi.encodePacked(name))];
}
function setAddr(string name, address addr) public {
require(
msg.sender == getAddr("admin") ||
msg.sender == getAddr("owner"),
"Permission Denied"
);
registry[keccak256(abi.encodePacked(name))] = addr;
emit AddressSet(name, addr);
}
}

0
contracts/MoatResolver.sol → contracts/bin/MoatResolver.sol
View File

34
contracts/protocols/MoatKyber.sol
View File

@ -9,10 +9,6 @@ interface AddressRegistry {
function isApprovedResolver(address user) external view returns(bool);
}
interface Resolver {
function fees() external returns(uint);
}
interface Kyber {
function trade(
address src,
@ -27,24 +23,7 @@ interface Kyber {
contract Registry {
address public registryAddress;
modifier onlyUserOrResolver(address user) {
if (msg.sender != user) {
require(
msg.sender == getAddress("resolver"),
"Permission Denied"
);
AddressRegistry addrReg = AddressRegistry(registryAddress);
require(
addrReg.isApprovedResolver(user),
"Resolver Not Approved"
);
}
_;
}
address public addressRegistry;
modifier onlyAdmin() {
require(
msg.sender == getAddress("admin"),
@ -52,13 +31,10 @@ contract Registry {
);
_;
}
function getAddress(string name) internal view returns(address addr) {
AddressRegistry addrReg = AddressRegistry(registryAddress);
addr = addrReg.getAddr(name);
require(addr != address(0), "Invalid Address");
AddressRegistry addrReg = AddressRegistry(addressRegistry);
return addrReg.getAddr(name);
}
}
@ -77,7 +53,7 @@ contract Trade is Registry {
// ropsten network
address public kyberAddr = 0x818E6FECD516Ecc3849DAf6845e3EC868087B755;
address public eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
function executeTrade(
address trader,
@ -149,7 +125,7 @@ contract Trade is Registry {
contract MoatKyber is Trade {
constructor(address rAddr) public {
registryAddress = rAddr;
addressRegistry = rAddr;
}
function () public payable {}

165
contracts/protocols/MoatMaker.sol
View File

@ -6,11 +6,6 @@ import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
interface AddressRegistry {
function getAddr(string name) external view returns(address);
function isApprovedResolver(address user) external view returns(bool);
}
interface Resolver {
function fees() external returns(uint);
}
interface MakerCDP {
@ -33,8 +28,7 @@ interface WETHFace {
contract Registry {
address public registryAddress;
address public addressRegistry;
modifier onlyAdmin() {
require(
msg.sender == getAddress("admin"),
@ -42,47 +36,30 @@ contract Registry {
);
_;
}
modifier onlyUserOrResolver(address user) {
if (msg.sender != user) {
require(
msg.sender == getAddress("resolver"),
"Permission Denied"
);
AddressRegistry addrReg = AddressRegistry(registryAddress);
require(
addrReg.isApprovedResolver(user),
"Resolver Not Approved"
);
}
_;
}
function getAddress(string name) internal view returns(address addr) {
AddressRegistry addrReg = AddressRegistry(registryAddress);
addr = addrReg.getAddr(name);
require(addr != address(0), "Invalid Address");
AddressRegistry addrReg = AddressRegistry(addressRegistry);
return addrReg.getAddr(name);
}
}
contract GlobalVar is Registry {
// kovan network
address public weth = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
address public peth = 0xf4d791139cE033Ad35DB2B2201435fAd668B1b64;
address public mkr = 0xAaF64BFCC32d0F15873a02163e7E500671a4ffcD;
address public dai = 0xC4375B7De8af5a38a93548eb8453a498222C4fF2;
address public eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public eth = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
address public cdpAddr = 0xa71937147b55Deb8a530C7229C442Fd3F31b7db2;
MakerCDP loanMaster = MakerCDP(cdpAddr);
bytes32 public blankCDP = 0x0000000000000000000000000000000000000000000000000000000000000000;
mapping (address => bytes32) public cdps; // borrower >>> CDP Bytes
bool public freezed; // freeze few important tasks
bool public freezed;
uint public fees;
}
@ -92,49 +69,42 @@ contract IssueLoan is GlobalVar {
event LoanedDAI(address borrower, uint loanDAI, uint fees);
event OpenedNewCDP(address borrower, bytes32 cdpBytes);
function borrow(
address borrower,
uint ethLock,
uint daiDraw
) public payable onlyUserOrResolver(borrower)
{
if (cdps[borrower] == 0x0000000000000000000000000000000000000000000000000000000000000000) {
cdps[borrower] = loanMaster.open();
emit OpenedNewCDP(borrower, cdps[borrower]);
}
if (ethLock > 0) {lockETH(borrower, ethLock);}
if (daiDraw > 0) {drawDAI(borrower, daiDraw);}
}
function lockETH(address borrower, uint ethLock) public payable {
WETHFace wethFunction = WETHFace(weth);
wethFunction.deposit.value(ethLock)(); // ETH to WETH
uint pethToLock = ratioedPETH(ethLock);
loanMaster.join(pethToLock); // WETH to PETH
loanMaster.lock(cdps[borrower], pethToLock); // PETH to CDP
emit LockedETH(borrower, ethLock, pethToLock);
}
function drawDAI(address borrower, uint daiDraw) public onlyUserOrResolver(borrower) {
require(!freezed, "Operation Disabled");
loanMaster.draw(cdps[borrower], daiDraw);
uint fees = deductFees(daiDraw);
IERC20 tokenFunctions = IERC20(dai);
tokenFunctions.transfer(borrower, daiDraw - fees);
emit LoanedDAI(borrower, daiDraw, fees);
}
function ratioedPETH(uint eth) internal returns (uint rPETH) {
function pethPEReth(uint eth) public returns (uint rPETH) {
rPETH = eth * (10 ** 27) / loanMaster.per();
}
function deductFees(uint volume) internal returns(uint fees) {
Resolver moatRes = Resolver(getAddress("resolver"));
fees = moatRes.fees();
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 (daiDraw > 0) {drawDAI(daiDraw);}
}
function lockETH() public payable {
WETHFace wethFunction = WETHFace(weth);
wethFunction.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);
}
function drawDAI(uint daiDraw) public {
require(!freezed, "Operation Disabled");
loanMaster.draw(cdps[msg.sender], daiDraw);
uint fees = deductFees(daiDraw);
IERC20 tokenFunctions = IERC20(dai);
tokenFunctions.transfer(msg.sender, daiDraw - fees);
emit LoanedDAI(msg.sender, daiDraw, fees);
}
function deductFees(uint volume) internal returns(uint brokerage) {
if (fees > 0) {
fees = volume / fees;
brokerage = volume / fees;
IERC20 tokenFunctions = IERC20(dai);
tokenFunctions.transfer(getAddress("admin"), fees);
tokenFunctions.transfer(getAddress("admin"), brokerage);
}
}
@ -147,40 +117,33 @@ contract RepayLoan is IssueLoan {
event UnlockedETH(address borrower, uint ethFree);
function repay(
address borrower,
uint daiWipe,
uint mkrFees,
uint ethFree
) public onlyUserOrResolver(borrower)
{
if (daiWipe > 0) {wipeDAI(borrower, daiWipe, mkrFees);}
if (ethFree > 0) {unlockETH(borrower, ethFree);}
) public {
if (daiWipe > 0) {wipeDAI(daiWipe, mkrFees);}
if (ethFree > 0) {unlockETH(ethFree);}
}
function wipeDAI(address borrower, uint daiWipe, uint mkrFees) public {
// MKR tokens to pay the debt fees
// difference between MKR fees and transferred amount stays with contract
IERC20 mkrToken = IERC20(mkr);
mkrToken.transferFrom(borrower, address(this), mkrFees);
// DAI to pay the debt
IERC20 daiToken = IERC20(dai);
daiToken.transferFrom(borrower, address(this), daiWipe);
loanMaster.wipe(cdps[borrower], daiWipe);
emit WipedDAI(borrower, daiWipe);
function wipeDAI(uint daiWipe, uint mkrFees) public {
IERC20 mkrTkn = IERC20(mkr);
IERC20 daiTkn = IERC20(dai);
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
loanMaster.wipe(cdps[msg.sender], daiWipe);
mkrTkn.transfer(msg.sender, mkrTkn.balanceOf(address(this))); // pay back balanced MKR tokens
emit WipedDAI(msg.sender, daiWipe);
}
function unlockETH(address borrower, uint ethFree) public onlyUserOrResolver(borrower) {
function unlockETH(uint ethFree) public {
require(!freezed, "Operation Disabled");
uint pethToUnlock = ratioedPETH(ethFree);
loanMaster.free(cdps[borrower], pethToUnlock); // CDP to PETH
uint pethToUnlock = pethPEReth(ethFree);
loanMaster.free(cdps[msg.sender], pethToUnlock); // CDP to PETH
loanMaster.exit(pethToUnlock); // PETH to WETH
WETHFace wethFunction = WETHFace(weth);
wethFunction.withdraw(ethFree); // WETH to ETH
borrower.transfer(ethFree);
emit UnlockedETH(borrower, ethFree);
msg.sender.transfer(ethFree);
emit UnlockedETH(msg.sender, ethFree);
}
}
@ -188,13 +151,13 @@ contract RepayLoan is IssueLoan {
contract BorrowTasks is RepayLoan {
function freeze(bool stop) public onlyAdmin {
freezed = stop;
}
event TranferCDP(bytes32 cdp, address owner, address nextOwner);
function claimCDP(address nextOwner) public {
function transferCDP(address nextOwner) public {
require(nextOwner != 0, "Invalid Address.");
loanMaster.give(cdps[msg.sender], nextOwner);
emit TranferCDP(cdps[msg.sender], msg.sender, nextOwner);
cdps[msg.sender] = blankCDP;
}
function approveERC20() public {
@ -214,7 +177,7 @@ contract BorrowTasks is RepayLoan {
contract MoatMaker is BorrowTasks {
constructor(address rAddr) public {
registryAddress = rAddr;
addressRegistry = rAddr;
approveERC20();
}
@ -229,4 +192,12 @@ contract MoatMaker is BorrowTasks {
}
}
function freeze(bool stop) public onlyAdmin {
freezed = stop;
}
function setFees(uint cut) public onlyAdmin { // 200 means 0.5%
fees = cut;
}
}