Add more connectors

contracts/common/interfaces.sol

@@ -17,6 +17,7 @@ interface MemoryInterface {
 
 interface InstaMapping {
     function cTokenMapping(address) external view returns (address);
+    function gemJoinMapping(bytes32) external view returns (address);
 }
 
 interface AccountInterface {

contracts/common/math.sol

@@ -38,4 +38,13 @@ contract DSMath {
     z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY;
   }
 
+  function toInt(uint x) internal pure returns (int y) {
+    y = int(x);
+    require(y >= 0, "int-overflow");
+  }
+
+  function toRad(uint wad) internal pure returns (uint rad) {
+    rad = mul(wad, 10 ** 27);
+  }
+
 }

contracts/connectors/instapool/main.sol

@@ -35,7 +35,6 @@ abstract contract LiquidityManage is Helpers, Events {
         instaPool.deposit{value: ethAmt}(token, _amt);
         setUint(setId, _amt);
 
-        emit LogDepositLiquidity(token, _amt, getId, setId);
         _eventName = "LogDepositLiquidity(address,uint256,uint256,uint256)";
         _eventParam = abi.encode(token, _amt, getId, setId);
     }

contracts/connectors/kyber/events.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogSell(
+        address indexed buyToken,
+        address indexed sellToken,
+        uint256 buyAmt,
+        uint256 sellAmt,
+        uint256 getId,
+        uint256 setId
+    );
+}

contracts/connectors/kyber/helpers.sol

@@ -0,0 +1,14 @@
+pragma solidity ^0.7.0;
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { KyberInterface } from "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+    /**
+     * @dev Kyver Interface
+     */
+    KyberInterface internal constant kyber = KyberInterface(0x818E6FECD516Ecc3849DAf6845e3EC868087B755);
+
+    address internal constant referalAddr = 0x7284a8451d9a0e7Dc62B3a71C0593eA2eC5c5638;
+}

contracts/connectors/kyber/interface.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.7.0;
+
+interface KyberInterface {
+    function trade(
+        address src,
+        uint srcAmount,
+        address dest,
+        address destAddress,
+        uint maxDestAmount,
+        uint minConversionRate,
+        address walletId
+    ) external payable returns (uint);
+
+    function getExpectedRate(
+        address src,
+        address dest,
+        uint srcQty
+    ) external view returns (uint, uint);
+}

contracts/connectors/kyber/main.sol

@@ -0,0 +1,52 @@
+pragma solidity ^0.7.0;
+
+import { TokenInterface } from "../../common/interfaces.sol";
+import { Helpers } from "./helpers.sol";
+import { Events } from "./events.sol";
+
+abstract contract KyberResolver is Helpers, Events {
+    /**
+     * @dev Sell ETH/ERC20_Token.
+     * @param buyAddr buying token address.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAddr selling token amount.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAmt selling token amount.
+     * @param unitAmt unit amount of buyAmt/sellAmt with slippage.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function sell(
+        address buyAddr,
+        address sellAddr,
+        uint sellAmt,
+        uint unitAmt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _sellAmt = getUint(getId, sellAmt);
+
+        uint ethAmt;
+        if (sellAddr == ethAddr) {
+            _sellAmt = _sellAmt == uint(-1) ? address(this).balance : _sellAmt;
+            ethAmt = _sellAmt;
+        } else {
+            TokenInterface sellContract = TokenInterface(sellAddr);
+            _sellAmt = _sellAmt == uint(-1) ? sellContract.balanceOf(address(this)) : _sellAmt;
+            sellContract.approve(address(kyber), _sellAmt);
+        }
+
+        uint _buyAmt = kyber.trade{value: ethAmt}(
+            sellAddr,
+            _sellAmt,
+            buyAddr,
+            address(this),
+            uint(-1),
+            unitAmt,
+            referalAddr
+        );
+
+        setUint(setId, _buyAmt);
+
+        _eventName = "LogSell(address,address,uint256,uint256,uint256,uint256)";
+        _eventParam = abi.encode(buyAddr, sellAddr, _buyAmt, _sellAmt, getId, setId);
+    }
+}

contracts/connectors/makerdao/events.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogOpen(uint256 indexed vault, bytes32 indexed ilk);
+    event LogClose(uint256 indexed vault, bytes32 indexed ilk);
+    event LogTransfer(uint256 indexed vault, bytes32 indexed ilk, address newOwner);
+    event LogDeposit(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogWithdraw(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogBorrow(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogPayback(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogWithdrawLiquidated(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogExitDai(uint256 indexed vault, bytes32 indexed ilk, uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogDepositDai(uint256 tokenAmt, uint256 getId, uint256 setId);
+    event LogWithdrawDai(uint256 tokenAmt, uint256 getId, uint256 setId);
+
+    event LogDepositAndBorrow(
+        uint256 indexed vault,
+        bytes32 indexed ilk,
+        uint256 depositAmt,
+        uint256 borrowAmt,
+        uint256 getIdDeposit,
+        uint256 getIdBorrow,
+        uint256 setIdDeposit,
+        uint256 setIdBorrow
+    );
+}

contracts/connectors/makerdao/helpers.sol

@@ -0,0 +1,124 @@
+pragma solidity ^0.7.0;
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { TokenInterface } from "../../common/interfaces.sol";
+import { ManagerLike, DaiJoinInterface, PotLike, VatLike, JugLike } from "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+    /**
+     * @dev Manager Interface
+     */
+    ManagerLike internal constant managerContract = ManagerLike(0x5ef30b9986345249bc32d8928B7ee64DE9435E39);
+
+    /**
+     * @dev DAI Join
+     */
+    DaiJoinInterface internal constant daiJoinContract = DaiJoinInterface(0x9759A6Ac90977b93B58547b4A71c78317f391A28);
+
+    /**
+     * @dev Pot
+     */
+    PotLike internal constant potContract = PotLike(0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7);
+
+    /**
+     * @dev Maker MCD Jug Address.
+    */
+    JugLike internal constant mcdJug = JugLike(0x19c0976f590D67707E62397C87829d896Dc0f1F1);
+
+    /**
+     * @dev Return Close Vault Address.
+    */
+    address internal constant giveAddr = 0x4dD58550eb15190a5B3DfAE28BB14EeC181fC267;
+
+    /**
+     * @dev Get Vault's ilk.
+    */
+    function getVaultData(uint vault) internal view returns (bytes32 ilk, address urn) {
+        ilk = managerContract.ilks(vault);
+        urn = managerContract.urns(vault);
+    }
+
+    /**
+     * @dev Gem Join address is ETH type collateral.
+    */
+    function isEth(address tknAddr) internal pure returns (bool) {
+        return tknAddr == ethAddr ? true : false;
+    }
+
+    /**
+     * @dev Get Vault Debt Amount.
+    */
+    function _getVaultDebt(
+        address vat,
+        bytes32 ilk,
+        address urn
+    ) internal view returns (uint wad) {
+        (, uint rate,,,) = VatLike(vat).ilks(ilk);
+        (, uint art) = VatLike(vat).urns(ilk, urn);
+        uint dai = VatLike(vat).dai(urn);
+
+        uint rad = sub(mul(art, rate), dai);
+        wad = rad / RAY;
+
+        wad = mul(wad, RAY) < rad ? wad + 1 : wad;
+    }
+
+    /**
+     * @dev Get Borrow Amount.
+    */
+    function _getBorrowAmt(
+        address vat,
+        address urn,
+        bytes32 ilk,
+        uint amt
+    ) internal returns (int dart)
+    {
+        uint rate = mcdJug.drip(ilk);
+        uint dai = VatLike(vat).dai(urn);
+        if (dai < mul(amt, RAY)) {
+            dart = toInt(sub(mul(amt, RAY), dai) / rate);
+            dart = mul(uint(dart), rate) < mul(amt, RAY) ? dart + 1 : dart;
+        }
+    }
+
+    /**
+     * @dev Get Payback Amount.
+    */
+    function _getWipeAmt(
+        address vat,
+        uint amt,
+        address urn,
+        bytes32 ilk
+    ) internal view returns (int dart)
+    {
+        (, uint rate,,,) = VatLike(vat).ilks(ilk);
+        (, uint art) = VatLike(vat).urns(ilk, urn);
+        dart = toInt(amt / rate);
+        dart = uint(dart) <= art ? - dart : - toInt(art);
+    }
+
+    /**
+     * @dev Convert String to bytes32.
+    */
+    function stringToBytes32(string memory str) internal pure returns (bytes32 result) {
+        require(bytes(str).length != 0, "string-empty");
+        // solium-disable-next-line security/no-inline-assembly
+        assembly {
+            result := mload(add(str, 32))
+        }
+    }
+
+    /**
+     * @dev Get vault ID. If `vault` is 0, get last opened vault.
+    */
+    function getVault(uint vault) internal view returns (uint _vault) {
+        if (vault == 0) {
+            require(managerContract.count(address(this)) > 0, "no-vault-opened");
+            _vault = managerContract.last(address(this));
+        } else {
+            _vault = vault;
+        }
+    }
+
+}

contracts/connectors/makerdao/interface.sol

@@ -0,0 +1,61 @@
+pragma solidity ^0.7.0;
+
+import { TokenInterface } from "../../common/interfaces.sol";
+
+interface ManagerLike {
+    function cdpCan(address, uint, address) external view returns (uint);
+    function ilks(uint) external view returns (bytes32);
+    function last(address) external view returns (uint);
+    function count(address) external view returns (uint);
+    function owns(uint) external view returns (address);
+    function urns(uint) external view returns (address);
+    function vat() external view returns (address);
+    function open(bytes32, address) external returns (uint);
+    function give(uint, address) external;
+    function frob(uint, int, int) external;
+    function flux(uint, address, uint) external;
+    function move(uint, address, uint) external;
+}
+
+interface VatLike {
+    function can(address, address) external view returns (uint);
+    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 frob(
+        bytes32,
+        address,
+        address,
+        address,
+        int,
+        int
+    ) external;
+    function hope(address) external;
+    function move(address, address, uint) external;
+    function gem(bytes32, address) external view returns (uint);
+}
+
+interface TokenJoinInterface {
+    function dec() external returns (uint);
+    function gem() external returns (TokenInterface);
+    function join(address, uint) external payable;
+    function exit(address, uint) external;
+}
+
+interface DaiJoinInterface {
+    function vat() external returns (VatLike);
+    function dai() external returns (TokenInterface);
+    function join(address, uint) external payable;
+    function exit(address, uint) external;
+}
+
+interface JugLike {
+    function drip(bytes32) external returns (uint);
+}
+
+interface PotLike {
+    function pie(address) external view returns (uint);
+    function drip() external returns (uint);
+    function join(uint) external;
+    function exit(uint) external;
+}

contracts/connectors/makerdao/main.sol

@@ -0,0 +1,488 @@
+pragma solidity ^0.7.0;
+
+import { TokenInterface } from "../../common/interfaces.sol";
+import { Helpers } from "./helpers.sol";
+import { Events } from "./events.sol";
+import { VatLike, TokenJoinInterface } from "./interface.sol";
+
+abstract contract MakerResolver is Helpers, Events {
+    /**
+     * @dev Open Vault
+     * @param colType Type of Collateral.(eg: 'ETH-A')
+    */
+    function open(string calldata colType) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        bytes32 ilk = stringToBytes32(colType);
+        require(instaMapping.gemJoinMapping(ilk) != address(0), "wrong-col-type");
+        uint256 vault = managerContract.open(ilk, address(this));
+
+        _eventName = "LogOpen(uint256,bytes32)";
+        _eventParam = abi.encode(vault, ilk);
+    }
+
+    /**
+     * @dev Close Vault
+     * @param vault Vault ID to close.
+    */
+    function close(uint vault) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (uint ink, uint art) = VatLike(managerContract.vat()).urns(ilk, urn);
+
+        require(ink == 0 && art == 0, "vault-has-assets");
+        require(managerContract.owns(_vault) == address(this), "not-owner");
+
+        managerContract.give(_vault, giveAddr);
+
+        _eventName = "LogClose(uint256,bytes32)";
+        _eventParam = abi.encode(_vault, ilk);
+    }
+
+    /**
+     * @dev Deposit ETH/ERC20_Token Collateral.
+     * @param vault Vault ID.
+     * @param amt token amount to deposit.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function deposit(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+
+        address colAddr = instaMapping.gemJoinMapping(ilk);
+        TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
+        TokenInterface tokenContract = tokenJoinContract.gem();
+
+        if (isEth(address(tokenContract))) {
+            _amt = _amt == uint(-1) ? address(this).balance : _amt;
+            tokenContract.deposit{value: _amt}();
+        } else {
+            _amt = _amt == uint(-1) ?  tokenContract.balanceOf(address(this)) : _amt;
+        }
+
+        tokenContract.approve(address(colAddr), _amt);
+        tokenJoinContract.join(address(this), _amt);
+
+        VatLike(managerContract.vat()).frob(
+            ilk,
+            urn,
+            address(this),
+            address(this),
+            toInt(convertTo18(tokenJoinContract.dec(), _amt)),
+            0
+        );
+
+        setUint(setId, _amt);
+
+        _eventName = "LogDeposit(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw ETH/ERC20_Token Collateral.
+     * @param vault Vault ID.
+     * @param amt token amount to withdraw.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function withdraw(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+
+        address colAddr = instaMapping.gemJoinMapping(ilk);
+        TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
+
+        uint _amt18;
+        if (_amt == uint(-1)) {
+            (_amt18,) = VatLike(managerContract.vat()).urns(ilk, urn);
+            _amt = convert18ToDec(tokenJoinContract.dec(), _amt18);
+        } else {
+            _amt18 = convertTo18(tokenJoinContract.dec(), _amt);
+        }
+
+        managerContract.frob(
+            _vault,
+            -toInt(_amt18),
+            0
+        );
+
+        managerContract.flux(
+            _vault,
+            address(this),
+            _amt18
+        );
+
+        TokenInterface tokenContract = tokenJoinContract.gem();
+
+        if (isEth(address(tokenContract))) {
+            tokenJoinContract.exit(address(this), _amt);
+            tokenContract.withdraw(_amt);
+        } else {
+            tokenJoinContract.exit(address(this), _amt);
+        }
+
+        setUint(setId, _amt);
+
+        _eventName = "LogWithdraw(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Borrow DAI.
+     * @param vault Vault ID.
+     * @param amt token amount to borrow.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function borrow(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+
+        VatLike vatContract = VatLike(managerContract.vat());
+
+        managerContract.frob(
+            _vault,
+            0,
+            _getBorrowAmt(
+                address(vatContract),
+                urn,
+                ilk,
+                _amt
+            )
+        );
+
+        managerContract.move(
+            _vault,
+            address(this),
+            toRad(_amt)
+        );
+
+        if (vatContract.can(address(this), address(daiJoinContract)) == 0) {
+            vatContract.hope(address(daiJoinContract));
+        }
+
+        daiJoinContract.exit(address(this), _amt);
+
+        setUint(setId, _amt);
+
+        _eventName = "LogBorrow(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Payback borrowed DAI.
+     * @param vault Vault ID.
+     * @param amt token amount to payback.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function payback(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+
+        address vat = managerContract.vat();
+
+        uint _maxDebt = _getVaultDebt(vat, ilk, urn);
+
+        _amt = _amt == uint(-1) ? _maxDebt : _amt;
+
+        require(_maxDebt >= _amt, "paying-excess-debt");
+
+        daiJoinContract.dai().approve(address(daiJoinContract), _amt);
+        daiJoinContract.join(urn, _amt);
+
+        managerContract.frob(
+            _vault,
+            0,
+            _getWipeAmt(
+                vat,
+                VatLike(vat).dai(urn),
+                urn,
+                ilk
+            )
+        );
+
+        setUint(setId, _amt);
+
+        _eventName = "LogBorrow(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw leftover ETH/ERC20_Token after Liquidation.
+     * @param vault Vault ID.
+     * @param amt token amount to Withdraw.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function withdrawLiquidated(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        (bytes32 ilk, address urn) = getVaultData(vault);
+
+        address colAddr = instaMapping.gemJoinMapping(ilk);
+        TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
+
+        uint _amt18;
+        if (_amt == uint(-1)) {
+            _amt18 = VatLike(managerContract.vat()).gem(ilk, urn);
+            _amt = convert18ToDec(tokenJoinContract.dec(), _amt18);
+        } else {
+            _amt18 = convertTo18(tokenJoinContract.dec(), _amt);
+        }
+
+        managerContract.flux(
+            vault,
+            address(this),
+            _amt18
+        );
+
+        TokenInterface tokenContract = tokenJoinContract.gem();
+        tokenJoinContract.exit(address(this), _amt);
+        if (isEth(address(tokenContract))) {
+            tokenContract.withdraw(_amt);
+        }
+
+        setUint(setId, _amt);
+
+        _eventName = "LogBorrow(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(vault, ilk, _amt, getId, setId);
+    }
+
+    struct MakerData {
+        uint _vault;
+        address colAddr;
+        TokenJoinInterface tokenJoinContract;
+        VatLike vatContract;
+        TokenInterface tokenContract;
+    }
+    /**
+     * @dev Deposit ETH/ERC20_Token Collateral and Borrow DAI.
+     * @param vault Vault ID.
+     * @param depositAmt token deposit amount to Withdraw.
+     * @param borrowAmt token borrow amount to Withdraw.
+     * @param getIdDeposit Get deposit token amount at this ID from `InstaMemory` Contract.
+     * @param getIdBorrow Get borrow token amount at this ID from `InstaMemory` Contract.
+     * @param setIdDeposit Set deposit token amount at this ID in `InstaMemory` Contract.
+     * @param setIdBorrow Set borrow token amount at this ID in `InstaMemory` Contract.
+    */
+    function depositAndBorrow(
+        uint vault,
+        uint depositAmt,
+        uint borrowAmt,
+        uint getIdDeposit,
+        uint getIdBorrow,
+        uint setIdDeposit,
+        uint setIdBorrow
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        MakerData memory makerData;
+        uint _amtDeposit = getUint(getIdDeposit, depositAmt);
+        uint _amtBorrow = getUint(getIdBorrow, borrowAmt);
+
+        makerData._vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(makerData._vault);
+
+        makerData.colAddr = instaMapping.gemJoinMapping(ilk);
+        makerData.tokenJoinContract = TokenJoinInterface(makerData.colAddr);
+        makerData.vatContract = VatLike(managerContract.vat());
+        makerData.tokenContract = makerData.tokenJoinContract.gem();
+
+        if (isEth(address(makerData.tokenContract))) {
+            _amtDeposit = _amtDeposit == uint(-1) ? address(this).balance : _amtDeposit;
+            makerData.tokenContract.deposit{value: _amtDeposit}();
+        } else {
+            _amtDeposit = _amtDeposit == uint(-1) ?  makerData.tokenContract.balanceOf(address(this)) : _amtDeposit;
+        }
+
+        makerData.tokenContract.approve(address(makerData.colAddr), _amtDeposit);
+        makerData.tokenJoinContract.join(urn, _amtDeposit);
+
+        managerContract.frob(
+            makerData._vault,
+            toInt(convertTo18(makerData.tokenJoinContract.dec(), _amtDeposit)),
+            _getBorrowAmt(
+                address(makerData.vatContract),
+                urn,
+                ilk,
+                _amtBorrow
+            )
+        );
+
+        managerContract.move(
+            makerData._vault,
+            address(this),
+            toRad(_amtBorrow)
+        );
+
+        if (makerData.vatContract.can(address(this), address(daiJoinContract)) == 0) {
+            makerData.vatContract.hope(address(daiJoinContract));
+        }
+
+        daiJoinContract.exit(address(this), _amtBorrow);
+
+        setUint(setIdDeposit, _amtDeposit);
+        setUint(setIdBorrow, _amtBorrow);
+
+        emit LogDeposit(makerData._vault, ilk, _amtDeposit, getIdDeposit, setIdDeposit);
+
+        emit LogBorrow(makerData._vault, ilk, _amtBorrow, getIdBorrow, setIdBorrow);
+
+        _eventName = "LogDepositAndBorrow(uint256,bytes32,uint256,uint256,uint256,uint256,uint256,uint256)";
+        _eventParam = abi.encode(
+            makerData._vault,
+            ilk,
+            _amtDeposit,
+            _amtBorrow,
+            getIdDeposit,
+            getIdBorrow,
+            setIdDeposit,
+            setIdBorrow
+        );
+    }
+
+    /**
+     * @dev Exit DAI from urn.
+     * @param vault Vault ID.
+     * @param amt token amount to exit.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function exitDai(
+        uint vault,
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+        uint _vault = getVault(vault);
+        (bytes32 ilk, address urn) = getVaultData(_vault);
+
+        VatLike vatContract = VatLike(managerContract.vat());
+        if(_amt == uint(-1)) {
+            _amt = vatContract.dai(urn);
+            _amt = _amt / 10 ** 27;
+        }
+
+        managerContract.move(
+            _vault,
+            address(this),
+            toRad(_amt)
+        );
+
+        if (vatContract.can(address(this), address(daiJoinContract)) == 0) {
+            vatContract.hope(address(daiJoinContract));
+        }
+
+        daiJoinContract.exit(address(this), _amt);
+
+        setUint(setId, _amt);
+
+        _eventName = "LogExitDai(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Deposit DAI in DSR.
+     * @param amt DAI amount to deposit.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function depositDai(
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+
+        _amt = _amt == uint(-1) ?
+            daiJoinContract.dai().balanceOf(address(this)) :
+            _amt;
+
+        VatLike vat = daiJoinContract.vat();
+        uint chi = potContract.drip();
+
+        daiJoinContract.dai().approve(address(daiJoinContract), _amt);
+        daiJoinContract.join(address(this), _amt);
+        if (vat.can(address(this), address(potContract)) == 0) {
+            vat.hope(address(potContract));
+        }
+
+        potContract.join(mul(_amt, RAY) / chi);
+        setUint(setId, _amt);
+
+        _eventName = "LogDepositDai(uint256,uint256,uint256)";
+        _eventParam = abi.encode(_amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw DAI from DSR.
+     * @param amt DAI amount to withdraw.
+     * @param getId Get token amount at this ID from `InstaMemory` Contract.
+     * @param setId Set token amount at this ID in `InstaMemory` Contract.
+    */
+    function withdrawDai(
+        uint amt,
+        uint getId,
+        uint setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        uint _amt = getUint(getId, amt);
+
+        VatLike vat = daiJoinContract.vat();
+
+        uint chi = potContract.drip();
+        uint pie;
+        if (_amt == uint(-1)) {
+            pie = potContract.pie(address(this));
+            _amt = mul(chi, pie) / RAY;
+        } else {
+            pie = mul(_amt, RAY) / chi;
+        }
+
+        potContract.exit(pie);
+
+        uint bal = vat.dai(address(this));
+        if (vat.can(address(this), address(daiJoinContract)) == 0) {
+            vat.hope(address(daiJoinContract));
+        }
+        daiJoinContract.exit(
+            address(this),
+            bal >= mul(_amt, RAY) ? _amt : bal / RAY
+        );
+
+        setUint(setId, _amt);
+
+        _eventName = "LogWithdrawDai(uint256,uint256,uint256)";
+        _eventParam = abi.encode(_amt, getId, setId);
+    }
+}
+
+contract ConnectMaker is MakerResolver {
+    string public constant name = "MakerDao-v1.4";
+}