makerdao before tests

contracts/mainnet/connectors/b.protocol/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/mainnet/connectors/b.protocol/makerdao/helpers.sol

@@ -0,0 +1,130 @@
+pragma solidity ^0.7.0;
+
+import { DSMath } from "../../../common/math.sol";
+import { Basic } from "../../../common/basic.sol";
+import { TokenInterface } from "./../../../common/interfaces.sol";
+import { BManagerLike, DaiJoinInterface, PotLike, VatLike, JugLike } from "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+    /**
+     * @dev Manager Interface
+     */
+    BManagerLike internal constant managerContract = BManagerLike(0x3f30c2381CD8B917Dd96EB2f1A4F96D91324BBed);
+
+    /**
+     * @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 == wethAddr ? true : false;
+    }
+
+    /**
+     * @dev Get Vault Debt Amount.
+    */
+    function _getVaultDebt(
+        address vat,
+        bytes32 ilk,
+        address urn,
+        uint vault
+    ) internal view returns (uint wad) {
+        (, uint rate,,,) = VatLike(vat).ilks(ilk);
+        (, uint art) = VatLike(vat).urns(ilk, urn);
+        uint cushion = managerContract.cushion(vault);        
+        art = add(art, cushion);
+        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,
+        uint vault
+    ) internal view returns (int dart)
+    {
+        (, uint rate,,,) = VatLike(vat).ilks(ilk);
+        (, uint art) = VatLike(vat).urns(ilk, urn);
+        uint cushion = managerContract.cushion(vault);        
+        art = add(art, cushion);        
+        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/mainnet/connectors/b.protocol/makerdao/interface.sol

@@ -0,0 +1,65 @@
+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 BManagerLike is ManagerLike {
+    function cushion(uint) external view returns(uint);
+}
+
+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/mainnet/connectors/b.protocol/makerdao/main.sol

@@ -0,0 +1,524 @@
+pragma solidity ^0.7.0;
+
+/**
+ * @title MakerDAO.
+ * @dev Collateralized Borrowing.
+ */
+
+import { TokenInterface, AccountInterface } from "./../../../common/interfaces.sol";
+import { Helpers } from "./helpers.sol";
+import { Events } from "./events.sol";
+import { VatLike, TokenJoinInterface } from "./interface.sol";
+
+abstract contract BMakerResolver is Helpers, Events {
+    /**
+     * @dev Open Vault
+     * @notice Open a MakerDAO 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
+     * @notice Close a MakerDAO Vault
+     * @param vault Vault ID to close.
+    */
+    function close(uint256 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 Transfer Vault
+     * @notice Transfer a MakerDAO Vault to "nextOwner"
+     * @param vault Vault ID to close.
+     * @param nextOwner Address of the next owner of the vault.
+    */
+    function transfer(
+        uint vault,
+        address nextOwner
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        require(AccountInterface(address(this)).isAuth(nextOwner), "nextOwner-is-not-auth");
+
+        uint256 _vault = getVault(vault);
+        (bytes32 ilk,) = getVaultData(_vault);
+
+        require(managerContract.owns(_vault) == address(this), "not-owner");
+
+        managerContract.give(_vault, nextOwner);
+
+        _eventName = "LogTransfer(uint256,bytes32,address)";
+        _eventParam = abi.encode(_vault, ilk, nextOwner);
+    }
+
+    /**
+     * @dev Deposit ETH/ERC20_Token Collateral.
+     * @notice Deposit collateral to a MakerDAO vault
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt The amount of tokens to deposit. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of tokens deposited.
+    */
+    function deposit(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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;
+        }
+
+        approve(tokenContract, address(colAddr), _amt);
+        tokenJoinContract.join(address(this), _amt);
+
+        VatLike(managerContract.vat()).frob( // TODO zelda - make manager.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.
+     * @notice Withdraw collateral from a MakerDAO vault
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt The amount of tokens to withdraw. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of tokens withdrawn.
+    */
+    function withdraw(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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.
+     * @notice Borrow DAI using a MakerDAO vault
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt The amount of DAI to borrow.
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of DAI borrowed.
+    */
+    function borrow(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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.
+     * @notice Payback DAI debt owed by a MakerDAO vault
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt The amount of DAI to payback. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of DAI paid back.
+    */
+    function payback(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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, vault);
+
+        _amt = _amt == uint(-1) ? _maxDebt : _amt;
+
+        require(_maxDebt >= _amt, "paying-excess-debt");
+
+        approve(daiJoinContract.dai(), address(daiJoinContract), _amt);
+        daiJoinContract.join(urn, _amt);
+
+        managerContract.frob(
+            _vault,
+            0,
+            _getWipeAmt(
+                vat,
+                VatLike(vat).dai(urn),
+                urn,
+                ilk,
+                _vault
+            )
+        );
+
+        setUint(setId, _amt);
+
+        _eventName = "LogPayback(uint256,bytes32,uint256,uint256,uint256)";
+        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+    }
+
+    /**
+     * @dev Withdraw leftover ETH/ERC20_Token after Liquidation.
+     * @notice Withdraw leftover collateral after Liquidation.
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt token amount to Withdraw. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of collateral withdrawn.
+    */
+    function withdrawLiquidated(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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 = "LogWithdrawLiquidated(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.
+     * @notice Deposit collateral and borrow DAI.
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param depositAmt The amount of tokens to deposit. (For max: `uint256(-1)`)
+     * @param borrowAmt The amount of DAI to borrow.
+     * @param getIdDeposit ID to retrieve depositAmt.
+     * @param getIdBorrow ID to retrieve borrowAmt.
+     * @param setIdDeposit ID stores the amount of tokens deposited.
+     * @param setIdBorrow ID stores the amount of DAI borrowed.
+    */
+    function depositAndBorrow(
+        uint256 vault,
+        uint256 depositAmt,
+        uint256 borrowAmt,
+        uint256 getIdDeposit,
+        uint256 getIdBorrow,
+        uint256 setIdDeposit,
+        uint256 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;
+        }
+
+        approve(makerData.tokenContract, 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);
+
+        _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.
+     * @notice Exit DAI from urn.
+     * @param vault Vault ID. (Use 0 for last opened vault)
+     * @param amt The amount of DAI to exit. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of DAI exited.
+    */
+    function exitDai(
+        uint256 vault,
+        uint256 amt,
+        uint256 getId,
+        uint256 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.
+     * @notice Deposit DAI in DSR.
+     * @param amt The amount of DAI to deposit. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of DAI deposited.
+    */
+    function depositDai(
+        uint256 amt,
+        uint256 getId,
+        uint256 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();
+
+        approve(daiJoinContract.dai(), 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.
+     * @notice Withdraw DAI from DSR.
+     * @param amt The amount of DAI to withdraw. (For max: `uint256(-1)`)
+     * @param getId ID to retrieve amt.
+     * @param setId ID stores the amount of DAI withdrawn.
+    */
+    function withdrawDai(
+        uint256 amt,
+        uint256 getId,
+        uint256 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 ConnectV1BMakerDAO is BMakerResolver {
+    string public constant name = "B.MakerDAO-v1.0";
+}