Internal function renaming

contracts/connectors/reflexer/events.sol

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

contracts/connectors/reflexer/helpers.sol

@@ -3,57 +3,57 @@ 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, CoinJoinInterface, SafeEngineLike, TaxCollectorLike } from "./interface.sol";
+import { ManagerLike, CoinJoinInterface, SafeEngineLike, TaxCollectorLike, TokenJoinInterface } from "./interface.sol";
 
 abstract contract Helpers is DSMath, Basic {
     /**
      * @dev Manager Interface
      */
-    ManagerLike internal constant managerContract = ManagerLike(0x5ef30b9986345249bc32d8928B7ee64DE9435E39);
+    ManagerLike internal constant managerContract = ManagerLike(0xEfe0B4cA532769a3AE758fD82E1426a03A94F185);
 
     /**
-     * @dev DAI Join
+     * @dev Coin Join
      */
-    CoinJoinInterface internal constant daiJoinContract = CoinJoinInterface(0x9759A6Ac90977b93B58547b4A71c78317f391A28);
+    CoinJoinInterface internal constant coinJoinContract = CoinJoinInterface(0x0A5653CCa4DB1B6E265F47CAf6969e64f1CFdC45);
 
     /**
-     * @dev Maker MCD Jug Address.
+     * @dev Reflexer Tax collector Address.
     */
-    TaxCollectorLike internal constant mcdJug = TaxCollectorLike(0x19c0976f590D67707E62397C87829d896Dc0f1F1);
+    TaxCollectorLike internal constant taxCollectorContract = TaxCollectorLike(0xcDB05aEda142a1B0D6044C09C64e4226c1a281EB);
 
     /**
-     * @dev Return Close Vault Address.
+     * @dev Return Close Safe Address.
     */
     address internal constant giveAddr = 0x4dD58550eb15190a5B3DfAE28BB14EeC181fC267;
 
     /**
-     * @dev Get Vault's ilk.
+     * @dev Get Safe's collateral type.
     */
-    function getVaultData(uint vault) internal view returns (bytes32 ilk, address urn) {
+    function getSafeData(uint safe) internal view returns (bytes32 collateralType, address handler) {
-        ilk = managerContract.collateralTypes(vault);
+        collateralType = managerContract.collateralTypes(safe);
-        urn = managerContract.safes(vault);
+        handler = managerContract.safes(safe);
     }
 
     /**
-     * @dev Gem Join address is ETH type collateral.
+     * @dev Collateral Join address is ETH type collateral.
     */
     function isEth(address tknAddr) internal pure returns (bool) {
         return tknAddr == ethAddr ? true : false;
     }
 
     /**
-     * @dev Get Vault Debt Amount.
+     * @dev Get Safe Debt Amount.
     */
-    function _getVaultDebt(
+    function _getSafeDebt(
-        address vat,
+        address safeEngine,
-        bytes32 ilk,
+        bytes32 collateralType,
-        address urn
+        address handler
     ) internal view returns (uint wad) {
-        (, uint rate,,,) = SafeEngineLike(vat).collateralTypes(ilk);
+        (, uint rate,,,) = SafeEngineLike(safeEngine).collateralTypes(collateralType);
-        (, uint art) = SafeEngineLike(vat).safes(ilk, urn);
+        (, uint debt) = SafeEngineLike(safeEngine).safes(collateralType, handler);
-        uint coin = SafeEngineLike(vat).coin(urn);
+        uint coin = SafeEngineLike(safeEngine).coin(handler);
 
-        uint rad = sub(mul(art, rate), coin);
+        uint rad = sub(mul(debt, rate), coin);
         wad = rad / RAY;
 
         wad = mul(wad, RAY) < rad ? wad + 1 : wad;
@@ -63,17 +63,17 @@ abstract contract Helpers is DSMath, Basic {
      * @dev Get Borrow Amount.
     */
     function _getBorrowAmt(
-        address vat,
+        address safeEngine,
-        address urn,
+        address handler,
-        bytes32 ilk,
+        bytes32 collateralType,
         uint amt
-    ) internal returns (int dart)
+    ) internal returns (int deltaDebt)
     {
-        uint rate = mcdJug.taxSingle(ilk);
+        uint rate = taxCollectorContract.taxSingle(collateralType);
-        uint coin = SafeEngineLike(vat).coin(urn);
+        uint coin = SafeEngineLike(safeEngine).coin(handler);
         if (coin < mul(amt, RAY)) {
-            dart = toInt(sub(mul(amt, RAY), coin) / rate);
+            deltaDebt = toInt(sub(mul(amt, RAY), coin) / rate);
-            dart = mul(uint(dart), rate) < mul(amt, RAY) ? dart + 1 : dart;
+            deltaDebt = mul(uint(deltaDebt), rate) < mul(amt, RAY) ? deltaDebt + 1 : deltaDebt;
         }
     }
 
@@ -81,16 +81,16 @@ abstract contract Helpers is DSMath, Basic {
      * @dev Get Payback Amount.
     */
     function _getWipeAmt(
-        address vat,
+        address safeEngine,
         uint amt,
-        address urn,
+        address handler,
-        bytes32 ilk
+        bytes32 collateralType
-    ) internal view returns (int dart)
+    ) internal view returns (int deltaDebt)
     {
-        (, uint rate,,,) = SafeEngineLike(vat).collateralTypes(ilk);
+        (, uint rate,,,) = SafeEngineLike(safeEngine).collateralTypes(collateralType);
-        (, uint art) = SafeEngineLike(vat).safes(ilk, urn);
+        (, uint debt) = SafeEngineLike(safeEngine).safes(collateralType, handler);
-        dart = toInt(amt / rate);
+        deltaDebt = toInt(amt / rate);
-        dart = uint(dart) <= art ? - dart : - toInt(art);
+        deltaDebt = uint(deltaDebt) <= debt ? - deltaDebt : - toInt(debt);
     }
 
     /**
@@ -105,14 +105,14 @@ abstract contract Helpers is DSMath, Basic {
     }
 
     /**
-     * @dev Get vault ID. If `vault` is 0, get lastSAFEID opened vault.
+     * @dev Get safe ID. If `safe` is 0, get lastSAFEID opened safe.
     */
-    function getVault(uint vault) internal view returns (uint _vault) {
+    function getSafe(uint safe) internal view returns (uint _safe) {
-        if (vault == 0) {
+        if (safe == 0) {
-            require(managerContract.safeCount(address(this)) > 0, "no-vault-opened");
+            require(managerContract.safeCount(address(this)) > 0, "no-safe-opened");
-            _vault = managerContract.lastSAFEID(address(this));
+            _safe = managerContract.lastSAFEID(address(this));
         } else {
-            _vault = vault;
+            _safe = safe;
         }
     }
 

contracts/connectors/reflexer/interface.sol

@@ -18,7 +18,7 @@ interface ManagerLike {
 }
 
 interface SafeEngineLike {
-    function can(address, address) external view returns (uint);
+    function safeRights(address, address) external view returns (uint);
     function collateralTypes(bytes32) external view returns (uint, uint, uint, uint, uint);
     function coin(address) external view returns (uint);
     function safes(bytes32, address) external view returns (uint, uint);
@@ -38,6 +38,7 @@ interface SafeEngineLike {
 interface TokenJoinInterface {
     function decimals() external returns (uint);
     function collateral() external returns (TokenInterface);
+    function collateralType() external returns (bytes32);
     function join(address, uint) external payable;
     function exit(address, uint) external;
 }
@@ -52,3 +53,11 @@ interface CoinJoinInterface {
 interface TaxCollectorLike {
     function taxSingle(bytes32) external returns (uint);
 }
+
+interface ConnectorsInterface {
+    function chief(address) external view returns (bool);
+}
+
+interface IndexInterface {
+    function master() external view returns (address);
+}

contracts/connectors/reflexer/main.sol

@@ -5,56 +5,56 @@ import { Helpers } from "./helpers.sol";
 import { Events } from "./events.sol";
 import { SafeEngineLike, TokenJoinInterface } from "./interface.sol";
 
-abstract contract MakerResolver is Helpers, Events {
+abstract contract GebResolver is Helpers, Events {
     /**
-     * @dev Open Vault
+     * @dev Open Safe
      * @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);
+        bytes32 collateralType = stringToBytes32(colType);
-        require(instaMapping.gemJoinMapping(ilk) != address(0), "wrong-col-type");
+        require(instaMapping.gemJoinMapping(collateralType) != address(0), "wrong-col-type");
-        uint256 vault = managerContract.openSAFE(ilk, address(this));
+        uint256 safe = managerContract.openSAFE(collateralType, address(this));
 
         _eventName = "LogOpen(uint256,bytes32)";
-        _eventParam = abi.encode(vault, ilk);
+        _eventParam = abi.encode(safe, collateralType);
     }
 
     /**
-     * @dev Close Vault
+     * @dev Close Safe
-     * @param vault Vault ID to close.
+     * @param safe Safe ID to close.
     */
-    function close(uint256 vault) external payable returns (string memory _eventName, bytes memory _eventParam) {
+    function close(uint256 safe) external payable returns (string memory _eventName, bytes memory _eventParam) {
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
-        (uint ink, uint art) = SafeEngineLike(managerContract.safeEngine()).safes(ilk, urn);
+        (uint collateral, uint debt) = SafeEngineLike(managerContract.safeEngine()).safes(collateralType, handler);
 
-        require(ink == 0 && art == 0, "vault-has-assets");
+        require(collateral == 0 && debt == 0, "safe-has-assets");
-        require(managerContract.ownsSAFE(_vault) == address(this), "not-owner");
+        require(managerContract.ownsSAFE(_safe) == address(this), "not-owner");
 
-        managerContract.transferSAFEOwnership(_vault, giveAddr);
+        managerContract.transferSAFEOwnership(_safe, giveAddr);
 
         _eventName = "LogClose(uint256,bytes32)";
-        _eventParam = abi.encode(_vault, ilk);
+        _eventParam = abi.encode(_safe, collateralType);
     }
 
     /**
      * @dev Deposit ETH/ERC20_Token Collateral.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
-        uint256 vault,
+        uint256 safe,
         uint256 amt,
         uint256 getId,
         uint256 setId
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
         uint _amt = getUint(getId, amt);
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
 
-        address colAddr = instaMapping.gemJoinMapping(ilk);
+        address colAddr = instaMapping.gemJoinMapping(collateralType);
         TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
         TokenInterface tokenContract = tokenJoinContract.collateral();
 
@@ -69,8 +69,8 @@ abstract contract MakerResolver is Helpers, Events {
         tokenJoinContract.join(address(this), _amt);
 
         SafeEngineLike(managerContract.safeEngine()).modifySAFECollateralization(
-            ilk,
+            collateralType,
-            urn,
+            handler,
             address(this),
             address(this),
             toInt(convertTo18(tokenJoinContract.decimals(), _amt)),
@@ -80,45 +80,45 @@ abstract contract MakerResolver is Helpers, Events {
         setUint(setId, _amt);
 
         _eventName = "LogDeposit(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(_safe, collateralType, _amt, getId, setId);
     }
 
     /**
      * @dev Withdraw ETH/ERC20_Token Collateral.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
-        uint256 vault,
+        uint256 safe,
         uint256 amt,
         uint256 getId,
         uint256 setId
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
         uint _amt = getUint(getId, amt);
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
 
-        address colAddr = instaMapping.gemJoinMapping(ilk);
+        address colAddr = instaMapping.gemJoinMapping(collateralType);
         TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
 
         uint _amt18;
         if (_amt == uint(-1)) {
-            (_amt18,) = SafeEngineLike(managerContract.safeEngine()).safes(ilk, urn);
+            (_amt18,) = SafeEngineLike(managerContract.safeEngine()).safes(collateralType, handler);
             _amt = convert18ToDec(tokenJoinContract.decimals(), _amt18);
         } else {
             _amt18 = convertTo18(tokenJoinContract.decimals(), _amt);
         }
 
         managerContract.modifySAFECollateralization(
-            _vault,
+            _safe,
             -toInt(_amt18),
             0
         );
 
         managerContract.transferCollateral(
-            _vault,
+            _safe,
             address(this),
             _amt18
         );
@@ -135,131 +135,131 @@ abstract contract MakerResolver is Helpers, Events {
         setUint(setId, _amt);
 
         _eventName = "LogWithdraw(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(_safe, collateralType, _amt, getId, setId);
     }
 
     /**
-     * @dev Borrow DAI.
+     * @dev Borrow Coin.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
-        uint256 vault,
+        uint256 safe,
         uint256 amt,
         uint256 getId,
         uint256 setId
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
         uint _amt = getUint(getId, amt);
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
 
-        SafeEngineLike vatContract = SafeEngineLike(managerContract.safeEngine());
+        SafeEngineLike safeEngineContract = SafeEngineLike(managerContract.safeEngine());
 
         managerContract.modifySAFECollateralization(
-            _vault,
+            _safe,
             0,
             _getBorrowAmt(
-                address(vatContract),
+                address(safeEngineContract),
-                urn,
+                handler,
-                ilk,
+                collateralType,
                 _amt
             )
         );
 
         managerContract.transferInternalCoins(
-            _vault,
+            _safe,
             address(this),
             toRad(_amt)
         );
 
-        if (vatContract.can(address(this), address(daiJoinContract)) == 0) {
+        if (safeEngineContract.safeRights(address(this), address(coinJoinContract)) == 0) {
-            vatContract.approveSAFEModification(address(daiJoinContract));
+            safeEngineContract.approveSAFEModification(address(coinJoinContract));
         }
 
-        daiJoinContract.exit(address(this), _amt);
+        coinJoinContract.exit(address(this), _amt);
 
         setUint(setId, _amt);
 
         _eventName = "LogBorrow(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(_safe, collateralType, _amt, getId, setId);
     }
 
     /**
-     * @dev Payback borrowed DAI.
+     * @dev Payback borrowed Coin.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
-        uint256 vault,
+        uint256 safe,
         uint256 amt,
         uint256 getId,
         uint256 setId
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
         uint _amt = getUint(getId, amt);
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
 
-        address vat = managerContract.safeEngine();
+        address safeEngine = managerContract.safeEngine();
 
-        uint _maxDebt = _getVaultDebt(vat, ilk, urn);
+        uint _maxDebt = _getSafeDebt(safeEngine, collateralType, handler);
 
         _amt = _amt == uint(-1) ? _maxDebt : _amt;
 
         require(_maxDebt >= _amt, "paying-excess-debt");
 
-        daiJoinContract.coin().approve(address(daiJoinContract), _amt);
+        coinJoinContract.coin().approve(address(coinJoinContract), _amt);
-        daiJoinContract.join(urn, _amt);
+        coinJoinContract.join(handler, _amt);
 
         managerContract.modifySAFECollateralization(
-            _vault,
+            _safe,
             0,
             _getWipeAmt(
-                vat,
+                safeEngine,
-                SafeEngineLike(vat).coin(urn),
+                SafeEngineLike(safeEngine).coin(handler),
-                urn,
+                handler,
-                ilk
+                collateralType
             )
         );
 
         setUint(setId, _amt);
 
         _eventName = "LogPayback(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(_safe, collateralType, _amt, getId, setId);
     }
 
     /**
      * @dev Withdraw leftover ETH/ERC20_Token after Liquidation.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
-        uint256 vault,
+        uint256 safe,
         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);
+        (bytes32 collateralType, address handler) = getSafeData(safe);
 
-        address colAddr = instaMapping.gemJoinMapping(ilk);
+        address colAddr = instaMapping.gemJoinMapping(collateralType);
         TokenJoinInterface tokenJoinContract = TokenJoinInterface(colAddr);
 
         uint _amt18;
         if (_amt == uint(-1)) {
-            _amt18 = SafeEngineLike(managerContract.safeEngine()).tokenCollateral(ilk, urn);
+            _amt18 = SafeEngineLike(managerContract.safeEngine()).tokenCollateral(collateralType, handler);
             _amt = convert18ToDec(tokenJoinContract.decimals(), _amt18);
         } else {
             _amt18 = convertTo18(tokenJoinContract.decimals(), _amt);
         }
 
         managerContract.transferCollateral(
-            vault,
+            safe,
             address(this),
             _amt18
         );
@@ -273,19 +273,19 @@ abstract contract MakerResolver is Helpers, Events {
         setUint(setId, _amt);
 
         _eventName = "LogWithdrawLiquidated(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(safe, collateralType, _amt, getId, setId);
     }
 
-    struct MakerData {
+    struct GebData {
-        uint _vault;
+        uint _safe;
         address colAddr;
         TokenJoinInterface tokenJoinContract;
-        SafeEngineLike vatContract;
+        SafeEngineLike safeEngineContract;
         TokenInterface tokenContract;
     }
     /**
-     * @dev Deposit ETH/ERC20_Token Collateral and Borrow DAI.
+     * @dev Deposit ETH/ERC20_Token Collateral and Borrow Coin.
-     * @param vault Vault ID.
+     * @param safe Safe 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.
@@ -294,7 +294,7 @@ abstract contract MakerResolver is Helpers, Events {
      * @param setIdBorrow Set borrow token amount at this ID in `InstaMemory` Contract.
     */
     function depositAndBorrow(
-        uint256 vault,
+        uint256 safe,
         uint256 depositAmt,
         uint256 borrowAmt,
         uint256 getIdDeposit,
@@ -302,58 +302,58 @@ abstract contract MakerResolver is Helpers, Events {
         uint256 setIdDeposit,
         uint256 setIdBorrow
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
-        MakerData memory makerData;
+        GebData memory gebData;
         uint _amtDeposit = getUint(getIdDeposit, depositAmt);
         uint _amtBorrow = getUint(getIdBorrow, borrowAmt);
 
-        makerData._vault = getVault(vault);
+        gebData._safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(makerData._vault);
+        (bytes32 collateralType, address handler) = getSafeData(gebData._safe);
 
-        makerData.colAddr = instaMapping.gemJoinMapping(ilk);
+        gebData.colAddr = instaMapping.gemJoinMapping(collateralType);
-        makerData.tokenJoinContract = TokenJoinInterface(makerData.colAddr);
+        gebData.tokenJoinContract = TokenJoinInterface(gebData.colAddr);
-        makerData.vatContract = SafeEngineLike(managerContract.safeEngine());
+        gebData.safeEngineContract = SafeEngineLike(managerContract.safeEngine());
-        makerData.tokenContract = makerData.tokenJoinContract.collateral();
+        gebData.tokenContract = gebData.tokenJoinContract.collateral();
 
-        if (isEth(address(makerData.tokenContract))) {
+        if (isEth(address(gebData.tokenContract))) {
             _amtDeposit = _amtDeposit == uint(-1) ? address(this).balance : _amtDeposit;
-            makerData.tokenContract.deposit{value: _amtDeposit}();
+            gebData.tokenContract.deposit{value: _amtDeposit}();
         } else {
-            _amtDeposit = _amtDeposit == uint(-1) ?  makerData.tokenContract.balanceOf(address(this)) : _amtDeposit;
+            _amtDeposit = _amtDeposit == uint(-1) ?  gebData.tokenContract.balanceOf(address(this)) : _amtDeposit;
         }
 
-        makerData.tokenContract.approve(address(makerData.colAddr), _amtDeposit);
+        gebData.tokenContract.approve(address(gebData.colAddr), _amtDeposit);
-        makerData.tokenJoinContract.join(urn, _amtDeposit);
+        gebData.tokenJoinContract.join(handler, _amtDeposit);
 
         managerContract.modifySAFECollateralization(
-            makerData._vault,
+            gebData._safe,
-            toInt(convertTo18(makerData.tokenJoinContract.decimals(), _amtDeposit)),
+            toInt(convertTo18(gebData.tokenJoinContract.decimals(), _amtDeposit)),
             _getBorrowAmt(
-                address(makerData.vatContract),
+                address(gebData.safeEngineContract),
-                urn,
+                handler,
-                ilk,
+                collateralType,
                 _amtBorrow
             )
         );
 
         managerContract.transferInternalCoins(
-            makerData._vault,
+            gebData._safe,
             address(this),
             toRad(_amtBorrow)
         );
 
-        if (makerData.vatContract.can(address(this), address(daiJoinContract)) == 0) {
+        if (gebData.safeEngineContract.safeRights(address(this), address(coinJoinContract)) == 0) {
-            makerData.vatContract.approveSAFEModification(address(daiJoinContract));
+            gebData.safeEngineContract.approveSAFEModification(address(coinJoinContract));
         }
 
-        daiJoinContract.exit(address(this), _amtBorrow);
+        coinJoinContract.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,
+            gebData._safe,
-            ilk,
+            collateralType,
             _amtDeposit,
             _amtBorrow,
             getIdDeposit,
@@ -364,48 +364,48 @@ abstract contract MakerResolver is Helpers, Events {
     }
 
     /**
-     * @dev Exit DAI from urn.
+     * @dev Exit Coin from handler.
-     * @param vault Vault ID.
+     * @param safe Safe 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(
+    function exit(
-        uint256 vault,
+        uint256 safe,
         uint256 amt,
         uint256 getId,
         uint256 setId
     ) external payable returns (string memory _eventName, bytes memory _eventParam) {
         uint _amt = getUint(getId, amt);
-        uint _vault = getVault(vault);
+        uint _safe = getSafe(safe);
-        (bytes32 ilk, address urn) = getVaultData(_vault);
+        (bytes32 collateralType, address handler) = getSafeData(_safe);
 
-        SafeEngineLike vatContract = SafeEngineLike(managerContract.safeEngine());
+        SafeEngineLike safeEngineContract = SafeEngineLike(managerContract.safeEngine());
         if(_amt == uint(-1)) {
-            _amt = vatContract.coin(urn);
+            _amt = safeEngineContract.coin(handler);
             _amt = _amt / 10 ** 27;
         }
 
         managerContract.transferInternalCoins(
-            _vault,
+            _safe,
             address(this),
             toRad(_amt)
         );
 
-        if (vatContract.can(address(this), address(daiJoinContract)) == 0) {
+        if (safeEngineContract.safeRights(address(this), address(coinJoinContract)) == 0) {
-            vatContract.approveSAFEModification(address(daiJoinContract));
+            safeEngineContract.approveSAFEModification(address(coinJoinContract));
         }
 
-        daiJoinContract.exit(address(this), _amt);
+        coinJoinContract.exit(address(this), _amt);
 
         setUint(setId, _amt);
 
-        _eventName = "LogExitDai(uint256,bytes32,uint256,uint256,uint256)";
+        _eventName = "LogExit(uint256,bytes32,uint256,uint256,uint256)";
-        _eventParam = abi.encode(_vault, ilk, _amt, getId, setId);
+        _eventParam = abi.encode(_safe, collateralType, _amt, getId, setId);
     }
 
 }
 
-contract ConnectV2Maker is MakerResolver {
+contract ConnectV2Reflexer is GebResolver {
-    string public constant name = "MakerDao-v1";
+    string public constant name = "Reflexer-v1";
 }