diff --git a/contracts/core/Controller.sol b/contracts/core/Controller.sol
index 1a6f7f030..0b240e654 100644
--- a/contracts/core/Controller.sol
+++ b/contracts/core/Controller.sol
@@ -21,16 +21,16 @@ import {CalleeInterface} from "../interfaces/CalleeInterface.sol";
 
 /**
  * Controller Error Codes
- * CO1: sender is not fullPauser
+ * CO10: sender is not fullPauser
  * CO2: sender is not partialPauser
  * CO3: callee is not a whitelisted address
- * CO4: system is partially paused
+ * CO34: system is partially paused
  * CO5: system is fully paused
  * CO6: msg.sender is not authorized to run action
  * CO7: invalid addressbook address
- * CO8: invalid owner address
+ * C28: invalid owner address
  * CO9: invalid input
- * CO10: fullPauser cannot be set to address zero
+ * CO1: fullPauser cannot be set to address zero
  * CO11: partialPauser cannot be set to address zero
  * CO12: can not run actions for different owners
  * CO13: can not run actions on different vaults
@@ -48,13 +48,13 @@ import {CalleeInterface} from "../interfaces/CalleeInterface.sol";
  * CO25: cannot burn from this address
  * CO26: can not burn expired otoken
  * CO27: otoken is not whitelisted to be redeemed
- * CO28: can not redeem un-expired otoken
+ * CO8: can not redeem un-expired otoken
  * CO29: asset prices not finalized yet
  * CO30: can't settle vault with no otoken
  * CO31: can not settle vault with un-expired otoken
  * CO32: can not settle undercollateralized vault
  * CO33: can not liquidate vault
- * CO34: can not leave less than collateral dust
+ * CO4: can not leave less than collateral dust
  * CO35: invalid vault id
  * CO36: cap amount should be greater than zero
  * CO37: collateral exceed naked margin cap
@@ -80,10 +80,10 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
 
     /// @notice address that has permission to partially pause the system, where system functionality is paused
     /// except redeem and settleVault
-    address public partialPauser;
+    // address public partialPauser;
 
-    /// @notice address that has permission to fully pause the system, where all system functionality is paused
-    address public fullPauser;
+    /// @notice address that has permission to fully or partially pause the system, where all system functionality is paused
+    address public pauser;
 
     /// @notice True if all system functionality is paused other than redeem and settle vault
     bool public systemPartiallyPaused;
@@ -198,9 +198,9 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
     /// @notice emits an event when a call action is executed
     event CallExecuted(address indexed from, address indexed to, bytes data);
     /// @notice emits an event when the fullPauser address changes
-    event FullPauserUpdated(address indexed oldFullPauser, address indexed newFullPauser);
+    event PauserUpdated(address indexed oldFullPauser, address indexed newFullPauser);
     /// @notice emits an event when the partialPauser address changes
-    event PartialPauserUpdated(address indexed oldPartialPauser, address indexed newPartialPauser);
+    // event PartialPauserUpdated(address indexed oldPartialPauser, address indexed newPartialPauser);
     /// @notice emits an event when the system partial paused status changes
     event SystemPartiallyPaused(bool isPaused);
     /// @notice emits an event when the system fully paused status changes
@@ -231,22 +231,22 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
     }
 
     /**
-     * @notice modifier to check if sender is the fullPauser address
+     * @notice modifier to check if sender is the pauser address
      */
-    modifier onlyFullPauser {
-        require(msg.sender == fullPauser, "CO1");
+    modifier onlyPauser {
+        require(msg.sender == pauser, "0");
 
         _;
     }
 
-    /**
-     * @notice modifier to check if the sender is the partialPauser address
-     */
-    modifier onlyPartialPauser {
-        require(msg.sender == partialPauser, "CO2");
+    // /**
+    //  * @notice modifier to check if the sender is the partialPauser address
+    //  */
+    // modifier onlyPartialPauser {
+    //     require(msg.sender == partialPauser, "10");
 
-        _;
-    }
+    //     _;
+    // }
 
     /**
      * @notice modifier to check if the sender is the account owner or an approved account operator
@@ -265,7 +265,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      */
     modifier onlyWhitelistedCallee(address _callee) {
         if (callRestricted) {
-            require(_isCalleeWhitelisted(_callee), "CO3");
+            require(_isCalleeWhitelisted(_callee), "2");
         }
 
         _;
@@ -275,14 +275,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @dev check if the system is not in a partiallyPaused state
      */
     function _isNotPartiallyPaused() internal view {
-        require(!systemPartiallyPaused, "CO4");
+        require(!systemPartiallyPaused, "3");
     }
 
     /**
      * @dev check if the system is not in an fullyPaused state
      */
     function _isNotFullyPaused() internal view {
-        require(!systemFullyPaused, "CO5");
+        require(!systemFullyPaused, "34");
     }
 
     /**
@@ -291,7 +291,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _accountOwner owner of a vault
      */
     function _isAuthorized(address _sender, address _accountOwner) internal view {
-        require((_sender == _accountOwner) || (operators[_accountOwner][_sender]), "CO6");
+        require((_sender == _accountOwner) || (operators[_accountOwner][_sender]), "5");
     }
 
     /**
@@ -300,8 +300,8 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _owner account owner address
      */
     function initialize(address _addressBook, address _owner) external initializer {
-        require(_addressBook != address(0), "CO7");
-        require(_owner != address(0), "CO8");
+        require(_addressBook != address(0), "6");
+        require(_owner != address(0), "7");
 
         __Ownable_init(_owner);
         __ReentrancyGuard_init_unchained();
@@ -329,8 +329,8 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @dev can only be called by the partialPauser
      * @param _partiallyPaused new boolean value to set systemPartiallyPaused to
      */
-    function setSystemPartiallyPaused(bool _partiallyPaused) external onlyPartialPauser {
-        require(systemPartiallyPaused != _partiallyPaused, "CO9");
+    function setSystemPartiallyPaused(bool _partiallyPaused) external onlyPauser {
+        require(systemPartiallyPaused != _partiallyPaused, "28");
 
         systemPartiallyPaused = _partiallyPaused;
 
@@ -342,8 +342,8 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @dev can only be called by the fullPauser
      * @param _fullyPaused new boolean value to set systemFullyPaused to
      */
-    function setSystemFullyPaused(bool _fullyPaused) external onlyFullPauser {
-        require(systemFullyPaused != _fullyPaused, "CO9");
+    function setSystemFullyPaused(bool _fullyPaused) external onlyPauser {
+        require(systemFullyPaused != _fullyPaused, "8");
 
         systemFullyPaused = _fullyPaused;
 
@@ -355,13 +355,13 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @dev can only be called by the owner
      * @param _fullPauser new fullPauser address
      */
-    function setFullPauser(address _fullPauser) external onlyOwner {
-        require(_fullPauser != address(0), "CO10");
-        require(fullPauser != _fullPauser, "CO9");
+    function setPauser(address _pauser) external onlyOwner {
+        require(_pauser != address(0), "9");
+        require(pauser != _pauser, "1");
 
-        emit FullPauserUpdated(fullPauser, _fullPauser);
+        emit FullPauserUpdated(pauser, _pauser);
 
-        fullPauser = _fullPauser;
+        pauser = _pauser;
     }
 
     /**
@@ -369,14 +369,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @dev can only be called by the owner
      * @param _partialPauser new partialPauser address
      */
-    function setPartialPauser(address _partialPauser) external onlyOwner {
-        require(_partialPauser != address(0), "CO11");
-        require(partialPauser != _partialPauser, "CO9");
+    // function setPartialPauser(address _partialPauser) external onlyOwner {
+    //     require(_partialPauser != address(0), "1");
+    //     require(partialPauser != _partialPauser, "8");
 
-        emit PartialPauserUpdated(partialPauser, _partialPauser);
+    //     emit PartialPauserUpdated(partialPauser, _partialPauser);
 
-        partialPauser = _partialPauser;
-    }
+    //     partialPauser = _partialPauser;
+    // }
 
     /**
      * @notice allows the owner to toggle the restriction on whitelisted call actions and only allow whitelisted
@@ -385,7 +385,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _isRestricted new call restriction state
      */
     function setCallRestriction(bool _isRestricted) external onlyOwner {
-        require(callRestricted != _isRestricted, "CO9");
+        require(callRestricted != _isRestricted, "8");
 
         callRestricted = _isRestricted;
 
@@ -399,7 +399,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _isOperator new boolean value that expresses if the sender is giving or revoking privileges for _operator
      */
     function setOperator(address _operator, bool _isOperator) external {
-        require(operators[msg.sender][_operator] != _isOperator, "CO9");
+        require(operators[msg.sender][_operator] != _isOperator, "8");
 
         operators[msg.sender][_operator] = _isOperator;
 
@@ -420,7 +420,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _cap cap amount, should be scaled by collateral asset decimals
      */
     function setNakedCap(address _collateral, uint256 _cap) external onlyOwner {
-        require(_cap > 0, "CO36");
+        require(_cap > 0, "35");
 
         nakedCap[_collateral] = _cap;
 
@@ -489,7 +489,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @return amount of collateral that can be taken out
      */
     function getProceed(address _owner, uint256 _vaultId) external view returns (uint256) {
-        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVault(_owner, _vaultId);
+        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVaultWithDetails(_owner, _vaultId);
 
         (uint256 netValue, bool isExcess) = calculator.getExcessCollateral(vault, typeVault);
 
@@ -581,7 +581,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _vaultId vault id of vault to return
      * @return Vault struct that corresponds to the _vaultId of _owner, vault type and the latest timestamp when the vault was updated
      */
-    function getVault(address _owner, uint256 _vaultId)
+    function getVaultWithDetails(address _owner, uint256 _vaultId)
         public
         view
         returns (
@@ -593,6 +593,10 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         return (vaults[_owner][_vaultId], vaultType[_owner][_vaultId], vaultLatestUpdate[_owner][_vaultId]);
     }
 
+    function getVault(address _owner, uint256 _vaultId) public view returns (MarginVault.Vault memory) {
+        return (vaults[_owner][_vaultId]);
+    }
+
     /**
      * @notice execute a variety of actions
      * @dev for each action in the action array, execute the corresponding action, only one vault can be modified
@@ -628,8 +632,8 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
             ) {
                 // check if this action is manipulating the same vault as all other actions, if a vault has already been updated
                 if (vaultUpdated) {
-                    require(vaultOwner == action.owner, "CO12");
-                    require(vaultId == action.vaultId, "CO13");
+                    require(vaultOwner == action.owner, "11");
+                    require(vaultId == action.vaultId, "12");
                 }
                 vaultUpdated = true;
                 vaultId = action.vaultId;
@@ -670,10 +674,10 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _vaultId vault id of the final vault
      */
     function _verifyFinalState(address _owner, uint256 _vaultId) internal view {
-        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVault(_owner, _vaultId);
+        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVaultWithDetails(_owner, _vaultId);
         (, bool isValidVault) = calculator.getExcessCollateral(vault, typeVault);
 
-        require(isValidVault, "CO14");
+        require(isValidVault, "13");
     }
 
     /**
@@ -688,7 +692,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
     {
         uint256 vaultId = accountVaultCounter[_args.owner].add(1);
 
-        require(_args.vaultId == vaultId, "CO15");
+        require(_args.vaultId == vaultId, "14");
 
         // store new vault
         accountVaultCounter[_args.owner] = vaultId;
@@ -707,15 +711,15 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         notPartiallyPaused
         onlyAuthorized(msg.sender, _args.owner)
     {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
         // only allow vault owner or vault operator to deposit long otoken
-        require((_args.from == msg.sender) || (_args.from == _args.owner), "CO16");
+        require((_args.from == msg.sender) || (_args.from == _args.owner), "15");
 
-        require(whitelist.isWhitelistedOtoken(_args.asset), "CO17");
+        require(whitelist.isWhitelistedOtoken(_args.asset), "16");
 
         OtokenInterface otoken = OtokenInterface(_args.asset);
 
-        require(now < otoken.expiryTimestamp(), "CO18");
+        require(now < otoken.expiryTimestamp(), "17");
 
         vaults[_args.owner][_args.vaultId].addLong(_args.asset, _args.amount, _args.index);
 
@@ -734,11 +738,11 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         notPartiallyPaused
         onlyAuthorized(msg.sender, _args.owner)
     {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
 
         OtokenInterface otoken = OtokenInterface(_args.asset);
 
-        require(now < otoken.expiryTimestamp(), "CO19");
+        require(now < otoken.expiryTimestamp(), "18");
 
         vaults[_args.owner][_args.vaultId].removeLong(_args.asset, _args.amount, _args.index);
 
@@ -757,18 +761,18 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         notPartiallyPaused
         onlyAuthorized(msg.sender, _args.owner)
     {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
         // only allow vault owner or vault operator to deposit collateral
-        require((_args.from == msg.sender) || (_args.from == _args.owner), "CO20");
+        require((_args.from == msg.sender) || (_args.from == _args.owner), "19");
 
-        require(whitelist.isWhitelistedCollateral(_args.asset), "CO21");
+        require(whitelist.isWhitelistedCollateral(_args.asset), "20");
 
-        (, uint256 typeVault, ) = getVault(_args.owner, _args.vaultId);
+        (, uint256 typeVault, ) = getVaultWithDetails(_args.owner, _args.vaultId);
 
         if (typeVault == 1) {
             nakedPoolBalance[_args.asset] = nakedPoolBalance[_args.asset].add(_args.amount);
 
-            require(nakedPoolBalance[_args.asset] <= nakedCap[_args.asset], "CO37");
+            require(nakedPoolBalance[_args.asset] <= nakedCap[_args.asset], "36");
         }
 
         vaults[_args.owner][_args.vaultId].addCollateral(_args.asset, _args.amount, _args.index);
@@ -788,14 +792,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         notPartiallyPaused
         onlyAuthorized(msg.sender, _args.owner)
     {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
 
-        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVault(_args.owner, _args.vaultId);
+        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVaultWithDetails(_args.owner, _args.vaultId);
 
         if (_isNotEmpty(vault.shortOtokens)) {
             OtokenInterface otoken = OtokenInterface(vault.shortOtokens[0]);
 
-            require(now < otoken.expiryTimestamp(), "CO22");
+            require(now < otoken.expiryTimestamp(), "21");
         }
 
         if (typeVault == 1) {
@@ -819,12 +823,12 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         notPartiallyPaused
         onlyAuthorized(msg.sender, _args.owner)
     {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
-        require(whitelist.isWhitelistedOtoken(_args.otoken), "CO23");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
+        require(whitelist.isWhitelistedOtoken(_args.otoken), "22");
 
         OtokenInterface otoken = OtokenInterface(_args.otoken);
 
-        require(now < otoken.expiryTimestamp(), "CO24");
+        require(now < otoken.expiryTimestamp(), "23");
 
         vaults[_args.owner][_args.vaultId].addShort(_args.otoken, _args.amount, _args.index);
 
@@ -844,14 +848,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         onlyAuthorized(msg.sender, _args.owner)
     {
         // check that vault id is valid for this vault owner
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
         // only allow vault owner or vault operator to burn otoken
-        require((_args.from == msg.sender) || (_args.from == _args.owner), "CO25");
+        require((_args.from == msg.sender) || (_args.from == _args.owner), "24");
 
         OtokenInterface otoken = OtokenInterface(_args.otoken);
 
         // do not allow burning expired otoken
-        require(now < otoken.expiryTimestamp(), "CO26");
+        require(now < otoken.expiryTimestamp(), "25");
 
         // remove otoken from vault
         vaults[_args.owner][_args.vaultId].removeShort(_args.otoken, _args.amount, _args.index);
@@ -871,14 +875,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         OtokenInterface otoken = OtokenInterface(_args.otoken);
 
         // check that otoken to redeem is whitelisted
-        require(whitelist.isWhitelistedOtoken(_args.otoken), "CO27");
+        require(whitelist.isWhitelistedOtoken(_args.otoken), "26");
 
         (address collateral, address underlying, address strike, , uint256 expiry, ) = otoken.getOtokenDetails();
 
         // only allow redeeming expired otoken
-        require(now >= expiry, "CO28");
+        require(now >= expiry, "27");
 
-        require(isSettlementAllowed(underlying, strike, collateral, expiry), "CO29");
+        require(isSettlementAllowed(underlying, strike, collateral, expiry), "8");
 
         uint256 payout = getPayout(_args.otoken, _args.amount);
 
@@ -895,9 +899,9 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _args SettleVaultArgs structure
      */
     function _settleVault(Actions.SettleVaultArgs memory _args) internal onlyAuthorized(msg.sender, _args.owner) {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
 
-        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVault(_args.owner, _args.vaultId);
+        (MarginVault.Vault memory vault, uint256 typeVault, ) = getVaultWithDetails(_args.owner, _args.vaultId);
 
         OtokenInterface otoken;
 
@@ -910,7 +914,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
             bool hasShort = _isNotEmpty(vault.shortOtokens);
             bool hasLong = _isNotEmpty(vault.longOtokens);
 
-            require(hasShort || hasLong, "CO30");
+            require(hasShort || hasLong, "29");
 
             otoken = hasShort ? OtokenInterface(vault.shortOtokens[0]) : OtokenInterface(vault.longOtokens[0]);
 
@@ -924,14 +928,14 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         (address collateral, address underlying, address strike, , uint256 expiry, ) = otoken.getOtokenDetails();
 
         // do not allow settling vault with un-expired otoken
-        require(now >= expiry, "CO31");
-        require(isSettlementAllowed(underlying, strike, collateral, expiry), "CO29");
+        require(now >= expiry, "30");
+        require(isSettlementAllowed(underlying, strike, collateral, expiry), "8");
 
         (uint256 payout, bool isValidVault) = calculator.getExcessCollateral(vault, typeVault);
 
         // require that vault is valid (has excess collateral) before settling
         // to avoid allowing settling undercollateralized naked margin vault
-        require(isValidVault, "CO32");
+        require(isValidVault, "31");
 
         delete vaults[_args.owner][_args.vaultId];
 
@@ -953,7 +957,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
      * @param _args liquidation action arguments struct
      */
     function _liquidate(Actions.LiquidateArgs memory _args) internal notPartiallyPaused {
-        require(_checkVaultId(_args.owner, _args.vaultId), "CO35");
+        require(_checkVaultId(_args.owner, _args.vaultId), "4");
 
         // check if vault is undercollateralized
         // the price is the amount of collateral asset to pay per 1 repaid debt(otoken)
@@ -964,7 +968,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
             _args.roundId
         );
 
-        require(isUnderCollat, "CO33");
+        require(isUnderCollat, "32");
 
         // amount of collateral to offer to liquidator
         uint256 collateralToSell = _args.amount.mul(price).div(1e8);
@@ -972,7 +976,7 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
         // if vault is partially liquidated (amount of short otoken is still greater than zero)
         // make sure remaining collateral amount is greater than dust amount
         if (vault.shortAmounts[0].sub(_args.amount) > 0) {
-            require(vault.collateralAmounts[0].sub(collateralToSell) >= collateralDust, "CO34");
+            require(vault.collateralAmounts[0].sub(collateralToSell) >= collateralDust, "33");
         }
 
         // burn short otoken from liquidator address, index of short otoken hardcoded at 0
@@ -1057,7 +1061,10 @@ contract Controller is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgrade
             uint256
         )
     {
-        (MarginVault.Vault memory vault, uint256 typeVault, uint256 latestUpdateTimestamp) = getVault(_owner, _vaultId);
+        (MarginVault.Vault memory vault, uint256 typeVault, uint256 latestUpdateTimestamp) = getVaultWithDetails(
+            _owner,
+            _vaultId
+        );
         (bool isUnderCollat, uint256 price, uint256 collateralDust) = calculator.isLiquidatable(
             vault,
             typeVault,
diff --git a/docs/contracts-documentation/core/Controller.md b/docs/contracts-documentation/core/Controller.md
index 865847ca5..48a73f7d9 100644
--- a/docs/contracts-documentation/core/Controller.md
+++ b/docs/contracts-documentation/core/Controller.md
@@ -62,7 +62,7 @@ Contract that controls the Gamma Protocol and the interaction of all sub contrac
 
 - `hasExpired(address _otoken) (external)`
 
-- `getVault(address _owner, uint256 _vaultId) (public)`
+- `getVaultWithDetails(address _owner, uint256 _vaultId) (public)`
 
 - `_runActions(struct Actions.ActionArgs[] _actions) (internal)`
 
@@ -420,7 +420,7 @@ check if an oToken has expired
 
 - True if the otoken has expired, False if not
 
-### Function `getVault(address _owner, uint256 _vaultId) → struct MarginVault.Vault, uint256, uint256 public`
+### Function `getVaultWithDetails(address _owner, uint256 _vaultId) → struct MarginVault.Vault, uint256, uint256 public`
 
 return a specific vault
 
diff --git a/docs/contracts-documentation/tests/MarginVaultTester.md b/docs/contracts-documentation/tests/MarginVaultTester.md
index e8f988618..2e51491cc 100644
--- a/docs/contracts-documentation/tests/MarginVaultTester.md
+++ b/docs/contracts-documentation/tests/MarginVaultTester.md
@@ -2,7 +2,7 @@
 
 ## Functions:
 
-- `getVault(uint256 _vaultIndex) (external)`
+- `getVaultWithDetails(uint256 _vaultIndex) (external)`
 
 - `testAddShort(uint256 _vaultIndex, address _shortOtoken, uint256 _amount, uint256 _index) (external)`
 
@@ -16,7 +16,7 @@
 
 - `testRemoveCollateral(uint256 _vaultIndex, address _collateralAsset, uint256 _amount, uint256 _index) (external)`
 
-### Function `getVault(uint256 _vaultIndex) → struct MarginVault.Vault external`
+### Function `getVaultWithDetails(uint256 _vaultIndex) → struct MarginVault.Vault external`
 
 ### Function `testAddShort(uint256 _vaultIndex, address _shortOtoken, uint256 _amount, uint256 _index) external`
 
diff --git a/docs/uml/GammaController.svg b/docs/uml/GammaController.svg
index 3b189cf5e..b53193527 100644
--- a/docs/uml/GammaController.svg
+++ b/docs/uml/GammaController.svg
@@ -101,7 +101,7 @@
 <text text-anchor="start" x="8" y="-59.1" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;&lt;&lt;modifier&gt;&gt; onlyWhitelistedCallee(_callee: address)</text>
 <text text-anchor="start" x="8" y="-42.3" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getPayout(_otoken: address, _amount: uint256): uint256</text>
 <text text-anchor="start" x="8" y="-25.5" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;isSettlementAllowed(_underlying: address, _strike: address, _collateral: address, _expiry: uint256): bool</text>
-<text text-anchor="start" x="8" y="-8.7" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getVault(_owner: address, _vaultId: uint256): (MarginVault.Vault, uint256, uint256)</text>
+<text text-anchor="start" x="8" y="-8.7" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getVaultWithDetails(_owner: address, _vaultId: uint256): (MarginVault.Vault, uint256, uint256)</text>
 </g>
 </g>
 </svg>
diff --git a/docs/uml/GammaUML.svg b/docs/uml/GammaUML.svg
index fc8838e5a..91d05afcc 100644
--- a/docs/uml/GammaUML.svg
+++ b/docs/uml/GammaUML.svg
@@ -142,7 +142,7 @@
 <text text-anchor="start" x="362.616" y="-59.1" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;&lt;&lt;modifier&gt;&gt; onlyWhitelistedCallee(_callee: address)</text>
 <text text-anchor="start" x="362.616" y="-42.3" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getPayout(_otoken: address, _amount: uint256): uint256</text>
 <text text-anchor="start" x="362.616" y="-25.5" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;isSettlementAllowed(_underlying: address, _strike: address, _collateral: address, _expiry: uint256): bool</text>
-<text text-anchor="start" x="362.616" y="-8.7" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getVault(_owner: address, _vaultId: uint256): (MarginVault.Vault, uint256, uint256)</text>
+<text text-anchor="start" x="362.616" y="-8.7" font-family="Times,serif" font-size="14.00" fill="#000000"> &#160;&#160;&#160;getVaultWithDetails(_owner: address, _vaultId: uint256): (MarginVault.Vault, uint256, uint256)</text>
 </g>
 <!-- 2 -->
 <g id="node3" class="node">
diff --git a/test/integration-tests/longCallSpreadExpireItm.test.ts b/test/integration-tests/longCallSpreadExpireItm.test.ts
index f86e9222c..fe81ac71b 100644
--- a/test/integration-tests/longCallSpreadExpireItm.test.ts
+++ b/test/integration-tests/longCallSpreadExpireItm.test.ts
@@ -268,7 +268,7 @@ contract('Long Call Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       const longOtokenSupplyBefore = new BigNumber(await lowerStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -336,7 +336,7 @@ contract('Long Call Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       assert.equal(longOtokenSupplyBefore.minus(scaledOptionsAmount).toString(), longOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -430,7 +430,7 @@ contract('Long Call Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       const lowerStrikeCallSupplyBefore = new BigNumber(await lowerStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), scaledCollateralAmount)
       assert.equal(vaultStateBefore[1], true)
@@ -471,7 +471,7 @@ contract('Long Call Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       assert.equal(lowerStrikeCallSupplyBefore.toString(), lowerStrikeCallSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/longCallSpreadExpireOtm.test.ts b/test/integration-tests/longCallSpreadExpireOtm.test.ts
index 7db278a7f..0a015e11a 100644
--- a/test/integration-tests/longCallSpreadExpireOtm.test.ts
+++ b/test/integration-tests/longCallSpreadExpireOtm.test.ts
@@ -267,7 +267,7 @@ contract('Long Call Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       const lowerStrikeCallSupplyBefore = new BigNumber(await lowerStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -322,7 +322,7 @@ contract('Long Call Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -397,7 +397,7 @@ contract('Long Call Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       const lowerStrikeCallSupplyBefore = new BigNumber(await lowerStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), scaledCollateralAmount)
       assert.equal(vaultStateBefore[1], true)
@@ -438,7 +438,7 @@ contract('Long Call Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       assert.equal(lowerStrikeCallSupplyBefore.toString(), lowerStrikeCallSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/longCallSpreadPreExpiry.test.ts b/test/integration-tests/longCallSpreadPreExpiry.test.ts
index c12f054ce..64ebf6d6e 100644
--- a/test/integration-tests/longCallSpreadPreExpiry.test.ts
+++ b/test/integration-tests/longCallSpreadPreExpiry.test.ts
@@ -232,7 +232,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await lowerStrikeCall.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -324,7 +324,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -370,7 +370,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await lowerStrikeCall.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -434,7 +434,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -472,7 +472,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       const marginPoolLowerStrikeCallBalanceBefore = new BigNumber(await lowerStrikeCall.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -527,7 +527,7 @@ contract('Long Call Spread Option closed before expiry flow', ([accountOwner1, n
       assert.equal(marginPoolLowerStrikeCallBalanceBefore.toString(), marginPoolLowerStrikeCallBalanceAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/longPutExpireItm.test.ts b/test/integration-tests/longPutExpireItm.test.ts
index 5d346e854..2d08f5c3f 100644
--- a/test/integration-tests/longPutExpireItm.test.ts
+++ b/test/integration-tests/longPutExpireItm.test.ts
@@ -228,7 +228,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -320,7 +320,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -365,7 +365,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -429,7 +429,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -466,7 +466,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       const higherStrikePutSupplyBefore = new BigNumber(await higherStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -519,7 +519,7 @@ contract('Long Put Spread Option closed ITM flow', ([accountOwner1, accountOwner
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/longPutExpireOtm.test.ts b/test/integration-tests/longPutExpireOtm.test.ts
index 675320051..677538aa4 100644
--- a/test/integration-tests/longPutExpireOtm.test.ts
+++ b/test/integration-tests/longPutExpireOtm.test.ts
@@ -269,7 +269,7 @@ contract('Long Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer,
       const longOtokenSupplyBefore = new BigNumber(await higherStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -328,7 +328,7 @@ contract('Long Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer,
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -400,7 +400,7 @@ contract('Long Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer,
       const scaledPayoutAmount = createTokenAmount(collateralPayout, usdcDecimals)
 
       // Check that after expiry, the vault excess balance has updated as expected
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBeforeSettlement = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBeforeSettlement[0].toString(), scaledPayoutAmount)
       assert.equal(vaultStateBeforeSettlement[1], true)
@@ -438,7 +438,7 @@ contract('Long Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer,
       assert.equal(shortOtokenSupplyBefore.toString(), shortOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/longPutPreExpiry.test.ts b/test/integration-tests/longPutPreExpiry.test.ts
index 838926632..c25e81e98 100644
--- a/test/integration-tests/longPutPreExpiry.test.ts
+++ b/test/integration-tests/longPutPreExpiry.test.ts
@@ -228,7 +228,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -320,7 +320,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -365,7 +365,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -429,7 +429,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -466,7 +466,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       const higherStrikePutSupplyBefore = new BigNumber(await higherStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -519,7 +519,7 @@ contract('Long Put Spread Option closed before expiry flow', ([accountOwner1, bu
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedCallExpireItm.test.ts b/test/integration-tests/nakedCallExpireItm.test.ts
index 26b011289..f1dd67aaf 100644
--- a/test/integration-tests/nakedCallExpireItm.test.ts
+++ b/test/integration-tests/nakedCallExpireItm.test.ts
@@ -188,7 +188,7 @@ contract('Naked Call Option expires Itm flow', ([accountOwner1, buyer]) => {
       const oTokenSupplyBefore = new BigNumber(await ethCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -249,7 +249,7 @@ contract('Naked Call Option expires Itm flow', ([accountOwner1, buyer]) => {
       assert.equal(oTokenSupplyBefore.toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedCallExpireOtm.test.ts b/test/integration-tests/nakedCallExpireOtm.test.ts
index 431322bce..dcf78c1c5 100644
--- a/test/integration-tests/nakedCallExpireOtm.test.ts
+++ b/test/integration-tests/nakedCallExpireOtm.test.ts
@@ -189,7 +189,7 @@ contract('Naked Call Option expires Otm flow', ([accountOwner1, buyer]) => {
       const oTokenSupplyBefore = new BigNumber(await ethCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -240,7 +240,7 @@ contract('Naked Call Option expires Otm flow', ([accountOwner1, buyer]) => {
       assert.equal(oTokenSupplyBefore.toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultBefore[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedCallPreExpiry.test.ts b/test/integration-tests/nakedCallPreExpiry.test.ts
index feb6d1e80..8be7a24ce 100644
--- a/test/integration-tests/nakedCallPreExpiry.test.ts
+++ b/test/integration-tests/nakedCallPreExpiry.test.ts
@@ -151,7 +151,7 @@ contract('Naked Call Option closed before expiry flow', ([accountOwner1]) => {
       const oTokenSupplyBefore = new BigNumber(await ethCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -225,7 +225,7 @@ contract('Naked Call Option closed before expiry flow', ([accountOwner1]) => {
       assert.equal(oTokenSupplyBefore.plus(scaledOptionsAmount).toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -266,7 +266,7 @@ contract('Naked Call Option closed before expiry flow', ([accountOwner1]) => {
       const oTokenSupplyBefore = new BigNumber(await ethCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -313,7 +313,7 @@ contract('Naked Call Option closed before expiry flow', ([accountOwner1]) => {
       assert.equal(oTokenSupplyBefore.minus(scaledOptionsAmount).toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedMarginCallPreExpiry.test.ts b/test/integration-tests/nakedMarginCallPreExpiry.test.ts
index 46fd13979..3c04699c4 100644
--- a/test/integration-tests/nakedMarginCallPreExpiry.test.ts
+++ b/test/integration-tests/nakedMarginCallPreExpiry.test.ts
@@ -233,7 +233,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       const userWethAfter = new BigNumber(await weth.balanceOf(accountOwner1))
       const poolWethAfter = new BigNumber(await weth.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userWethBefore.minus(userWethAfter).toString(),
@@ -279,7 +279,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
         wethDecimals,
         isPut,
       )
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const amountToWithdraw = new BigNumber(userVaultBefore[0].collateralAmounts[0]).minus(collateralNeeded)
       const withdrawArgs = [
         {
@@ -297,7 +297,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       await controllerProxy.operate(withdrawArgs, {from: accountOwner1})
 
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const userCollateralAfter = new BigNumber(await weth.balanceOf(accountOwner1))
 
       assert.equal(
@@ -332,7 +332,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       await controllerProxy.sync(accountOwner1, vaultCounter, {from: accountOwner1})
 
-      const userVault = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVault = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userVault[2].toString(),
@@ -395,12 +395,16 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
       ]
 
       const liquidatorCollateralBalanceBefore = new BigNumber(await weth.balanceOf(liquidator))
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       await controllerProxy.operate(liquidateArgs, {from: liquidator})
 
       const liquidatorCollateralBalanceAfter = new BigNumber(await weth.balanceOf(liquidator))
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       assert.equal(vaultAfterLiquidation.shortAmounts[0].toString(), '0', 'Vault was not fully liquidated')
       assert.isAtMost(
@@ -512,7 +516,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       const userWethAfter = new BigNumber(await weth.balanceOf(accountOwner1))
       const poolWethAfter = new BigNumber(await weth.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userWethBefore.minus(userWethAfter).toString(),
@@ -617,18 +621,22 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
         },
       ]
 
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
       const liquidatorWethBefore = new BigNumber(await weth.balanceOf(liquidator))
       const poolWethBefore = new BigNumber(await weth.balanceOf(marginPool.address))
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       await controllerProxy.operate(mintLiquidateArgs, {from: liquidator})
 
       const liquidatorWethAfter = new BigNumber(await weth.balanceOf(liquidator))
       const poolWethAfter = new BigNumber(await weth.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
-      const liquidatorVaultAfter = await controllerProxy.getVault(liquidator, liquidatorVaultCounter)
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
+      const liquidatorVaultAfter = await controllerProxy.getVaultWithDetails(liquidator, liquidatorVaultCounter)
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       assert.equal(vaultAfterLiquidation.shortAmounts[0].toString(), '0', 'Vault was not fully liquidated')
       assert.isAtMost(
@@ -698,7 +706,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       await time.increaseTo(optionExpiry.toNumber() + 10)
 
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const amountToWithdraw = new BigNumber(await controllerProxy.getProceed(accountOwner1, vaultCounter))
 
       const withdrawArgs = [
@@ -717,7 +725,7 @@ contract('Naked margin: call position pre expiry', ([owner, accountOwner1, liqui
 
       await controllerProxy.operate(withdrawArgs, {from: accountOwner1})
 
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const userCollateralAfter = new BigNumber(await weth.balanceOf(accountOwner1))
 
       assert.equal(
diff --git a/test/integration-tests/nakedMarginPutPreExpiry.test.ts b/test/integration-tests/nakedMarginPutPreExpiry.test.ts
index 0ddd4f277..1010d24cf 100644
--- a/test/integration-tests/nakedMarginPutPreExpiry.test.ts
+++ b/test/integration-tests/nakedMarginPutPreExpiry.test.ts
@@ -231,7 +231,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       const userUsdcAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
       const poolUsdcAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userUsdcBefore.minus(userUsdcAfter).toString(),
@@ -277,7 +277,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
         usdcDecimals,
         isPut,
       )
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const amountToWithdraw = new BigNumber(userVaultBefore[0].collateralAmounts[0]).minus(
         new BigNumber(collateralNeeded),
       )
@@ -297,7 +297,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       await controllerProxy.operate(withdrawArgs, {from: accountOwner1})
 
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const userCollateralAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
 
       assert.equal(
@@ -332,7 +332,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       await controllerProxy.sync(accountOwner1, vaultCounter, {from: accountOwner1})
 
-      const userVault = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVault = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userVault[2].toString(),
@@ -395,12 +395,16 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
       ]
 
       const liquidatorCollateralBalanceBefore = new BigNumber(await usdc.balanceOf(liquidator))
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       await controllerProxy.operate(liquidateArgs, {from: liquidator})
 
       const liquidatorCollateralBalanceAfter = new BigNumber(await usdc.balanceOf(liquidator))
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       assert.equal(vaultAfterLiquidation.shortAmounts[0].toString(), '0', 'Vault was not fully liquidated')
       assert.isAtMost(
@@ -512,7 +516,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       const userUsdcAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
       const poolUsdcAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       assert.equal(
         userUsdcBefore.minus(userUsdcAfter).toString(),
@@ -617,18 +621,22 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
         },
       ]
 
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
       const liquidatorUsdcBefore = new BigNumber(await usdc.balanceOf(liquidator))
       const poolUsdcBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
       await controllerProxy.operate(mintLiquidateArgs, {from: liquidator})
 
       const liquidatorUsdcAfter = new BigNumber(await usdc.balanceOf(liquidator))
       const poolUsdcAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
-      const liquidatorVaultAfter = await controllerProxy.getVault(liquidator, liquidatorVaultCounter)
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
+      const liquidatorVaultAfter = await controllerProxy.getVaultWithDetails(liquidator, liquidatorVaultCounter)
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       assert.equal(vaultAfterLiquidation.shortAmounts[0].toString(), '0', 'Vault was not fully liquidated')
       assert.isAtMost(
@@ -700,7 +708,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       await time.increaseTo(optionExpiry.toNumber() + 10)
 
-      const userVaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const amountToWithdraw = new BigNumber(await controllerProxy.getProceed(accountOwner1, vaultCounter))
 
       const withdrawArgs = [
@@ -719,7 +727,7 @@ contract('Naked margin: put position pre expiry', ([owner, accountOwner1, buyer1
 
       await controllerProxy.operate(withdrawArgs, {from: accountOwner1})
 
-      const userVaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const userVaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const userCollateralAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
 
       assert.equal(
diff --git a/test/integration-tests/nakedPutExpireITM.test.ts b/test/integration-tests/nakedPutExpireITM.test.ts
index 86a1eae6a..a823e3a22 100644
--- a/test/integration-tests/nakedPutExpireITM.test.ts
+++ b/test/integration-tests/nakedPutExpireITM.test.ts
@@ -190,7 +190,7 @@ contract('Naked Put Option expires Itm flow', ([accountOwner1, buyer]) => {
       const oTokenSupplyBefore = new BigNumber(await ethPut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -242,7 +242,7 @@ contract('Naked Put Option expires Itm flow', ([accountOwner1, buyer]) => {
       assert.equal(oTokenSupplyBefore.toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedPutExpireOTM.test.ts b/test/integration-tests/nakedPutExpireOTM.test.ts
index abb6d9afa..383e02833 100644
--- a/test/integration-tests/nakedPutExpireOTM.test.ts
+++ b/test/integration-tests/nakedPutExpireOTM.test.ts
@@ -189,7 +189,7 @@ contract('Naked Put Option expires Otm flow', ([accountOwner1, buyer]) => {
       const oTokenSupplyBefore = new BigNumber(await ethPut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBeforeExpiry = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBeforeExpiry[0].toString(), '0')
       assert.equal(vaultStateBeforeExpiry[1], true)
@@ -245,7 +245,7 @@ contract('Naked Put Option expires Otm flow', ([accountOwner1, buyer]) => {
       assert.equal(oTokenSupplyBefore.toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/nakedPutPreExpiry.test.ts b/test/integration-tests/nakedPutPreExpiry.test.ts
index 8b80a9bae..1af4f3f74 100644
--- a/test/integration-tests/nakedPutPreExpiry.test.ts
+++ b/test/integration-tests/nakedPutPreExpiry.test.ts
@@ -152,7 +152,7 @@ contract('Naked Put Option closed before expiry flow', ([accountOwner1]) => {
       const oTokenSupplyBefore = new BigNumber(await ethPut.totalSupply())
 
       // Check that the vault has 0 exess collateral
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0', 'Incorrect amount of excess collateral')
       assert.equal(vaultStateBefore[1], true, 'Incorrect boolean of excess collateral')
@@ -239,7 +239,7 @@ contract('Naked Put Option closed before expiry flow', ([accountOwner1]) => {
       )
 
       // Check that we have 0 excess collateral in the vault after
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0', 'Incorrect amount of excess collateral')
       assert.equal(vaultStateAfter[1], true, 'Incorrect boolean of excess collateral')
@@ -280,7 +280,7 @@ contract('Naked Put Option closed before expiry flow', ([accountOwner1]) => {
       const oTokenSupplyBefore = new BigNumber(await ethPut.totalSupply())
 
       // Check that there is 0 excess collateral
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0', 'Incorrect amount of excess collateral')
       assert.equal(vaultStateBefore[1], true, 'Incorrect boolean of excess collateral')
@@ -327,7 +327,7 @@ contract('Naked Put Option closed before expiry flow', ([accountOwner1]) => {
       assert.equal(oTokenSupplyBefore.minus(scaledOptionsAmount).toString(), oTokenSupplyAfter.toString())
 
       // Check that there is 0 excess collateral after
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0', 'Incorrect amount of excess collateral')
       assert.equal(vaultStateAfter[1], true, 'Incorrect boolean of excess collateral')
diff --git a/test/integration-tests/rollover.test.ts b/test/integration-tests/rollover.test.ts
index b98676205..024c7e6ef 100644
--- a/test/integration-tests/rollover.test.ts
+++ b/test/integration-tests/rollover.test.ts
@@ -179,7 +179,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       const oTokenSupplyBefore = new BigNumber(await ethPut1.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -256,7 +256,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       assert.equal(oTokenSupplyBefore.plus(scaledOptionsAmount).toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -302,7 +302,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       const oToken2SupplyBefore = new BigNumber(await ethPut2.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -373,7 +373,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       assert.equal(oToken2SupplyBefore.plus(scaledOptionsAmount).toString(), oToken2SupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -461,7 +461,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       const scaledCollateralAmount1 = createTokenAmount(collateralAmount1, usdcDecimals)
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBeforeExpiry = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBeforeExpiry[0].toString(), '0')
       assert.equal(vaultStateBeforeExpiry[1], true)
@@ -551,7 +551,7 @@ contract('Rollover Naked Put Option flow', ([accountOwner1, accountOperator1, bu
       assert.equal(oToken2SupplyBefore.plus(scaledOptionsAmount).toString(), oToken2SupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortCallSpreadExpireItm.test.ts b/test/integration-tests/shortCallSpreadExpireItm.test.ts
index 020742efe..0ab3581f3 100644
--- a/test/integration-tests/shortCallSpreadExpireItm.test.ts
+++ b/test/integration-tests/shortCallSpreadExpireItm.test.ts
@@ -280,7 +280,7 @@ contract('Short Call Spread Option expires Itm flow', ([accountOwner1, nakedBuye
       const longOtokenSupplyBefore = new BigNumber(await higherStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -341,7 +341,7 @@ contract('Short Call Spread Option expires Itm flow', ([accountOwner1, nakedBuye
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -414,7 +414,7 @@ contract('Short Call Spread Option expires Itm flow', ([accountOwner1, nakedBuye
       const shortOtokenSupplyBefore = new BigNumber(await higherStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
 
       const strikePriceChange = Math.max(expirySpotPrice - higherStrike, 0)
       const collateralAmount = optionsAmount
@@ -456,7 +456,7 @@ contract('Short Call Spread Option expires Itm flow', ([accountOwner1, nakedBuye
       assert.equal(shortOtokenSupplyBefore.toString(), shortOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortCallSpreadExpireOtm.test.ts b/test/integration-tests/shortCallSpreadExpireOtm.test.ts
index 87ef98145..e5ae3f54a 100644
--- a/test/integration-tests/shortCallSpreadExpireOtm.test.ts
+++ b/test/integration-tests/shortCallSpreadExpireOtm.test.ts
@@ -280,7 +280,7 @@ contract('Short Call Spread Option expires Otm flow', ([accountOwner1, nakedBuye
       const longOtokenSupplyBefore = new BigNumber(await higherStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -342,7 +342,7 @@ contract('Short Call Spread Option expires Otm flow', ([accountOwner1, nakedBuye
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -410,7 +410,7 @@ contract('Short Call Spread Option expires Otm flow', ([accountOwner1, nakedBuye
       const shortOtokenSupplyBefore = new BigNumber(await higherStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
 
       const strikePriceChange = Math.max(expirySpotPrice - higherStrike, 0)
       const collateralAmount = optionsAmount
@@ -452,7 +452,7 @@ contract('Short Call Spread Option expires Otm flow', ([accountOwner1, nakedBuye
       assert.equal(shortOtokenSupplyBefore.toString(), shortOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortCallSpreadPreExpiry.test.ts b/test/integration-tests/shortCallSpreadPreExpiry.test.ts
index 7720af8d2..2bfece062 100644
--- a/test/integration-tests/shortCallSpreadPreExpiry.test.ts
+++ b/test/integration-tests/shortCallSpreadPreExpiry.test.ts
@@ -232,7 +232,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikeCall.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -337,7 +337,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -388,7 +388,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await higherStrikeCall.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -465,7 +465,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -508,7 +508,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       const higherStrikeCallSupplyBefore = new BigNumber(await higherStrikeCall.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -561,7 +561,7 @@ contract('Short Call Spread Option closed before expiry flow', ([accountOwner1,
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortPutSpreadExpireItm.test.ts b/test/integration-tests/shortPutSpreadExpireItm.test.ts
index d200bcc8d..8ce9a799d 100644
--- a/test/integration-tests/shortPutSpreadExpireItm.test.ts
+++ b/test/integration-tests/shortPutSpreadExpireItm.test.ts
@@ -279,7 +279,7 @@ contract('Short Put Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       const longOtokenSupplyBefore = new BigNumber(await lowerStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -344,7 +344,7 @@ contract('Short Put Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -421,7 +421,7 @@ contract('Short Put Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       const scaledPayoutAmount = createTokenAmount(collateralPayout, usdcDecimals)
 
       // Check that after expiry, the vault excess balance has updated as expected
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBeforeSettlement = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBeforeSettlement[0].toString(), scaledPayoutAmount)
       assert.equal(vaultStateBeforeSettlement[1], true)
@@ -459,7 +459,7 @@ contract('Short Put Spread Option expires Itm flow', ([accountOwner1, nakedBuyer
       assert.equal(shortOtokenSupplyBefore.toString(), shortOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortPutSpreadExpireOtm.test.ts b/test/integration-tests/shortPutSpreadExpireOtm.test.ts
index 6890c232a..4283350d1 100644
--- a/test/integration-tests/shortPutSpreadExpireOtm.test.ts
+++ b/test/integration-tests/shortPutSpreadExpireOtm.test.ts
@@ -280,7 +280,7 @@ contract('Short Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       const longOtokenSupplyBefore = new BigNumber(await lowerStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -341,7 +341,7 @@ contract('Short Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -413,7 +413,7 @@ contract('Short Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       const scaledPayoutAmount = createTokenAmount(collateralPayout, usdcDecimals)
 
       // Check that after expiry, the vault excess balance has updated as expected
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBeforeSettlement = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBeforeSettlement[0].toString(), scaledPayoutAmount)
       assert.equal(vaultStateBeforeSettlement[1], true)
@@ -451,7 +451,7 @@ contract('Short Put Spread Option expires Otm flow', ([accountOwner1, nakedBuyer
       assert.equal(shortOtokenSupplyBefore.toString(), shortOtokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/shortPutSpreadPreExpiry.test.ts b/test/integration-tests/shortPutSpreadPreExpiry.test.ts
index 3027f8f28..843fb4a38 100644
--- a/test/integration-tests/shortPutSpreadPreExpiry.test.ts
+++ b/test/integration-tests/shortPutSpreadPreExpiry.test.ts
@@ -231,7 +231,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await lowerStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -336,7 +336,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -387,7 +387,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       const marginPoolLongOtokenBalanceBefore = new BigNumber(await lowerStrikePut.balanceOf(marginPool.address))
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -464,7 +464,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter1)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter1)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -506,7 +506,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       const lowerStrikePutSupplyBefore = new BigNumber(await lowerStrikePut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -559,7 +559,7 @@ contract('Short Put Spread Option closed before expiry flow', ([accountOwner1, n
       )
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner2, vaultCounter2)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner2, vaultCounter2)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/integration-tests/yieldFarming.test.ts b/test/integration-tests/yieldFarming.test.ts
index e45630eda..fa526a04c 100644
--- a/test/integration-tests/yieldFarming.test.ts
+++ b/test/integration-tests/yieldFarming.test.ts
@@ -298,7 +298,7 @@ contract('Yield Farming: Naked Put Option closed before expiry flow', ([admin, a
       const oTokenSupplyBefore = new BigNumber(await cusdcEthPut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -355,7 +355,7 @@ contract('Yield Farming: Naked Put Option closed before expiry flow', ([admin, a
       assert.equal(oTokenSupplyBefore.plus(scaledOptionsAmount).toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
@@ -400,7 +400,7 @@ contract('Yield Farming: Naked Put Option closed before expiry flow', ([admin, a
       const oTokenSupplyBefore = new BigNumber(await cusdcEthPut.totalSupply())
 
       // Check that we start at a valid state
-      const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateBefore = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
       assert.equal(vaultStateBefore[0].toString(), '0')
       assert.equal(vaultStateBefore[1], true)
@@ -460,7 +460,7 @@ contract('Yield Farming: Naked Put Option closed before expiry flow', ([admin, a
       assert.equal(oTokenSupplyBefore.toString(), oTokenSupplyAfter.toString())
 
       // Check that we end at a valid state
-      const vaultAfter = await controllerProxy.getVault(accountOwner1, vaultCounter)
+      const vaultAfter = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
       const vaultStateAfter = await calculator.getExcessCollateral(vaultAfter[0], vaultAfter[1])
       assert.equal(vaultStateAfter[0].toString(), '0')
       assert.equal(vaultStateAfter[1], true)
diff --git a/test/unit-tests/controller.test.ts b/test/unit-tests/controller.test.ts
index 60fcc7b91..3bca3d300 100644
--- a/test/unit-tests/controller.test.ts
+++ b/test/unit-tests/controller.test.ts
@@ -175,7 +175,7 @@ contract(
     describe('Vault', () => {
       it('should get vault', async () => {
         const vaultId = new BigNumber(0)
-        await controllerProxy.getVault(accountOwner1, vaultId)
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultId)
       })
 
       it('should get vault balance', async () => {
@@ -458,7 +458,7 @@ contract(
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -506,14 +506,14 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await longOtoken.balanceOf(accountOperator1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await longOtoken.approve(marginPool.address, longToDeposit, {from: accountOperator1})
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await longOtoken.balanceOf(accountOperator1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -565,14 +565,14 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await longOtoken.approve(marginPool.address, longToDeposit.multipliedBy(2).toString(), {from: accountOwner1})
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -780,7 +780,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
           const longToWithdraw = new BigNumber(vaultBefore.longAmounts[0]).plus(1)
           const actionArgs = [
             {
@@ -840,13 +840,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await longOtoken.balanceOf(random))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await longOtoken.balanceOf(random))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -891,13 +891,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await longOtoken.balanceOf(random))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await longOtoken.balanceOf(random))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -946,13 +946,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -976,7 +976,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           const longToWithdraw = new BigNumber(vaultBefore.longAmounts[0])
           const actionArgs = [
@@ -998,7 +998,7 @@ contract(
 
           const marginPoolBalanceAfter = new BigNumber(await longOtoken.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await longOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -1056,7 +1056,7 @@ contract(
             ]
             await expiredLongOtoken.approve(marginPool.address, longToDeposit, {from: accountOwner1})
             await controllerProxy.operate(actionArgs, {from: accountOwner1})
-            const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultId))[0]
+            const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultId))[0]
             assert.equal(vaultAfter.longOtokens.length, 1, 'Vault long otoken array length mismatch')
             assert.equal(
               vaultAfter.longOtokens[0],
@@ -1075,7 +1075,7 @@ contract(
             await time.increase(3601) // increase time with one hour in seconds
 
             const vaultId = new BigNumber('1')
-            const vault = (await controllerProxy.getVault(accountOwner1, vaultId))[0]
+            const vault = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultId))[0]
             const longToWithdraw = new BigNumber(vault.longAmounts[0])
             const actionArgs = [
               {
@@ -1132,7 +1132,7 @@ contract(
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -1177,14 +1177,14 @@ contract(
 
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await usdc.balanceOf(accountOperator1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await usdc.approve(marginPool.address, collateralToDeposit, {from: accountOperator1})
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await usdc.balanceOf(accountOperator1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -1306,14 +1306,14 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await usdc.approve(marginPool.address, collateralToDeposit.multipliedBy(2), {from: accountOwner1})
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -1446,7 +1446,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
           const collateralToWithdraw = new BigNumber(vaultBefore.collateralAmounts[0]).plus(1)
           const actionArgs = [
             {
@@ -1486,13 +1486,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await usdc.balanceOf(random))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await usdc.balanceOf(random))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -1539,13 +1539,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await usdc.balanceOf(random))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await usdc.balanceOf(random))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -1596,13 +1596,13 @@ contract(
           ]
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceBefore = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -1628,7 +1628,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           const collateralToWithdraw = new BigNumber(vaultBefore.collateralAmounts[0])
           const actionArgs = [
@@ -1650,7 +1650,7 @@ contract(
 
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const receiverBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceBefore.minus(marginPoolBalanceAfter).toString(),
@@ -1832,7 +1832,7 @@ contract(
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await usdc.balanceOf(accountOwner1))
           const senderShortBalanceBefore = new BigNumber(await shortOtoken.balanceOf(accountOwner1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await usdc.approve(marginPool.address, collateralToDeposit, {from: accountOwner1})
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
@@ -1840,7 +1840,7 @@ contract(
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
           const senderShortBalanceAfter = new BigNumber(await shortOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -1915,7 +1915,7 @@ contract(
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceBefore = new BigNumber(await usdc.balanceOf(accountOperator1))
           const senderShortBalanceBefore = new BigNumber(await shortOtoken.balanceOf(accountOperator1))
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           await usdc.approve(marginPool.address, collateralToDeposit, {from: accountOperator1})
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
@@ -1923,7 +1923,7 @@ contract(
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const senderBalanceAfter = new BigNumber(await usdc.balanceOf(accountOperator1))
           const senderShortBalanceAfter = new BigNumber(await shortOtoken.balanceOf(accountOperator1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -1970,7 +1970,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+          const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
 
           const [netValue, isExcess] = await calculator.getExcessCollateral(vaultBefore[0], vaultBefore[1])
 
@@ -2018,7 +2018,7 @@ contract(
           await usdc.approve(marginPool.address, excessCollateralToDeposit, {from: accountOwner1})
           await controllerProxy.operate(firstActionArgs, {from: accountOwner1})
 
-          const vaultBefore = await controllerProxy.getVault(accountOwner1, vaultCounter)
+          const vaultBefore = await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter)
           const marginPoolBalanceBefore = new BigNumber(await usdc.balanceOf(marginPool.address))
           const withdrawerBalanceBefore = new BigNumber(await usdc.balanceOf(accountOwner1))
 
@@ -2045,7 +2045,7 @@ contract(
 
           await controllerProxy.operate(secondActionArgs, {from: accountOwner1})
 
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
           const marginPoolBalanceAfter = new BigNumber(await usdc.balanceOf(marginPool.address))
           const withdrawerBalanceAfter = new BigNumber(await usdc.balanceOf(accountOwner1))
 
@@ -2357,7 +2357,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           const shortOtokenToBurn = new BigNumber(await shortOtoken.balanceOf(accountOperator1))
           const actionArgs = [
@@ -2377,7 +2377,7 @@ contract(
           await controllerProxy.operate(actionArgs, {from: accountOperator1})
 
           const sellerBalanceAfter = new BigNumber(await shortOtoken.balanceOf(accountOperator1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             sellerBalanceBefore.minus(sellerBalanceAfter).toString(),
@@ -2405,7 +2405,7 @@ contract(
           const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
           assert.isAbove(vaultCounter.toNumber(), 0, 'Account owner have no vault')
 
-          const vaultBefore = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultBefore = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           const shortOtokenToBurn = new BigNumber(vaultBefore.shortAmounts[0])
           const actionArgs = [
@@ -2425,7 +2425,7 @@ contract(
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
 
           const sellerBalanceAfter = new BigNumber(await shortOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
           assert.equal(
             sellerBalanceBefore.minus(sellerBalanceAfter).toString(),
@@ -2480,7 +2480,7 @@ contract(
           const senderShortBalanceBefore = new BigNumber(await shortOtoken.balanceOf(accountOwner1))
           await controllerProxy.operate(actionArgs, {from: accountOwner1})
           const senderShortBalanceAfter = new BigNumber(await shortOtoken.balanceOf(accountOwner1))
-          const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+          const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
           assert.equal(vaultAfter.shortOtokens.length, 1, 'Vault short otoken array length mismatch')
           assert.equal(vaultAfter.shortOtokens[0], ZERO_ADDR)
           assert.equal(
@@ -3940,13 +3940,13 @@ contract(
       it('should update vault latest update timestamp', async () => {
         const vaultCounter = new BigNumber(await controllerProxy.getAccountVaultCounter(accountOwner1))
         const timestampBefore = new BigNumber(
-          (await controllerProxy.getVault(accountOwner1, vaultCounter.toNumber()))[2],
+          (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toNumber()))[2],
         )
 
         await controllerProxy.sync(accountOwner1, vaultCounter.toNumber(), {from: random})
 
         const timestampAfter = new BigNumber(
-          (await controllerProxy.getVault(accountOwner1, vaultCounter.toNumber()))[2],
+          (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toNumber()))[2],
         )
         assert.isAbove(
           timestampAfter.toNumber(),
diff --git a/test/unit-tests/controllerNakedMargin.test.ts b/test/unit-tests/controllerNakedMargin.test.ts
index 073e9c9f9..a14a93a8f 100644
--- a/test/unit-tests/controllerNakedMargin.test.ts
+++ b/test/unit-tests/controllerNakedMargin.test.ts
@@ -365,7 +365,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       )
 
       const latestVaultUpdateTimestamp = new BigNumber(
-        (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[2],
+        (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString()))[2],
       )
 
       assert.equal(
@@ -397,7 +397,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       assert.equal(isLiquidatable[0], true, 'Vault liquidation state mismatch')
       assert.isTrue(new BigNumber(isLiquidatable[1]).isGreaterThan(0), 'Liquidation price is equal to zero')
 
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       const liquidateArgs = [
         {
@@ -418,7 +420,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       await controllerProxy.operate(liquidateArgs, {from: liquidator})
 
       const liquidatorCollateralBalanceAfter = new BigNumber(await usdc.balanceOf(liquidator))
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
       const nakedMarginPoolAfter = new BigNumber(await controllerProxy.getNakedPoolBalance(usdc.address))
 
       assert.equal(
@@ -449,7 +453,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
     })
 
     it('should be able to withdraw remaining collateral', async () => {
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+      const vaultAfterLiquidation = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
       const withdrawArgs = [
         {
@@ -577,7 +581,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       )
 
       const latestVaultUpdateTimestamp = new BigNumber(
-        (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[2],
+        (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString()))[2],
       )
 
       assert.equal(
@@ -609,7 +613,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       assert.equal(isLiquidatable[0], true, 'Vault liquidation state mismatch')
       assert.isTrue(new BigNumber(isLiquidatable[1]).isGreaterThan(0), 'Liquidation price is equal to zero')
 
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       const liquidateArgs = [
         {
@@ -630,7 +636,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       await controllerProxy.operate(liquidateArgs, {from: liquidator})
 
       const liquidatorCollateralBalanceAfter = new BigNumber(await weth.balanceOf(liquidator))
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
       const nakedMarginPoolAfter = new BigNumber(await controllerProxy.getNakedPoolBalance(weth.address))
 
       assert.equal(
@@ -661,7 +669,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
     })
 
     it('should be able to withdraw remaining collateral', async () => {
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+      const vaultAfterLiquidation = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
       const withdrawArgs = [
         {
@@ -780,7 +788,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       await controllerProxy.operate(mintArgs, {from: accountOwner1})
 
       const latestVaultUpdateTimestamp = new BigNumber(
-        (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[2],
+        (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString()))[2],
       )
 
       assert.equal(
@@ -813,7 +821,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       assert.equal(isLiquidatable[0], true, 'Vault liquidation state mismatch')
       assert.isTrue(new BigNumber(isLiquidatable[1]).isGreaterThan(0), 'Liquidation price is equal to zero')
 
-      const vaultBeforeLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultBeforeLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       const liquidateArgs = [
         {
@@ -833,7 +843,9 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
       await controllerProxy.operate(liquidateArgs, {from: liquidator})
 
       const liquidatorCollateralBalanceAfter = new BigNumber(await usdc.balanceOf(liquidator))
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter.toString()))[0]
+      const vaultAfterLiquidation = (
+        await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter.toString())
+      )[0]
 
       assert.equal(
         vaultAfterLiquidation.shortAmounts[0].toString(),
@@ -894,7 +906,7 @@ contract('Controller: naked margin', ([owner, accountOwner1, liquidator, random]
     })
 
     it('should be able to remove excess collateral after partially liquidating', async () => {
-      const vaultAfterLiquidation = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+      const vaultAfterLiquidation = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
       const requiredVaultMargin = await calculator.getNakedMarginRequired(
         weth.address,
diff --git a/test/unit-tests/marginVault.test.ts b/test/unit-tests/marginVault.test.ts
index 4b87b3fc7..14df29666 100644
--- a/test/unit-tests/marginVault.test.ts
+++ b/test/unit-tests/marginVault.test.ts
@@ -68,7 +68,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddShort(vaultCounter, otoken.address, 10, 0)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.shortAmounts[vault.shortAmounts.length - 1], new BigNumber(10))
     })
 
@@ -85,7 +85,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddShort(vaultCounter, otoken2.address, 11, 1)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.shortAmounts[vault.shortAmounts.length - 1], new BigNumber(11))
     })
 
@@ -93,7 +93,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddShort(vaultCounter, otoken2.address, 12, 1)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.shortAmounts[vault.shortAmounts.length - 1], new BigNumber(23))
     })
 
@@ -112,10 +112,10 @@ contract('MarginVault', ([deployer, controller]) => {
       const index = 0
       const toRemove = 5
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testRemoveShort(vaultCounter, otoken.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.shortAmounts[index]).minus(new BigNumber(vaultAfter.shortAmounts[index])).toString(),
@@ -126,12 +126,12 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to remove all of the remaining amount of first short otoken and delete short otoken address', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
       const index = 0
       const toRemove = vaultBefore.shortAmounts[index]
 
       await marginVaultTester.testRemoveShort(vaultCounter, otoken.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.shortAmounts[index]).minus(new BigNumber(vaultAfter.shortAmounts[index])).toString(),
@@ -152,10 +152,10 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to add different short in the index of the old short otoken without increase short array length', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testAddShort(vaultCounter, otoken2.address, 10, 0)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vaultAfter.shortAmounts[0], new BigNumber(10))
       assert.equal(
         vaultBefore.shortOtokens.length,
@@ -181,7 +181,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddLong(vaultCounter, otoken.address, amount, index)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.longAmounts[index], new BigNumber(amount))
     })
 
@@ -191,7 +191,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddLong(vaultCounter, otoken2.address, amount, index)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.longAmounts[index], new BigNumber(amount))
     })
 
@@ -201,7 +201,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddLong(vaultCounter, otoken2.address, amount, index)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.longAmounts[index], new BigNumber(20))
     })
 
@@ -222,10 +222,10 @@ contract('MarginVault', ([deployer, controller]) => {
       const index = 0
       const toRemove = 5
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testRemoveLong(vaultCounter, otoken.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.longAmounts[index]).minus(new BigNumber(vaultAfter.longAmounts[index])).toString(),
@@ -236,12 +236,12 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to remove all of the remaining amount of first long otoken and delete long otoken address', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
       const index = 0
       const toRemove = vaultBefore.longAmounts[index]
 
       await marginVaultTester.testRemoveLong(vaultCounter, otoken.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.longAmounts[index]).minus(new BigNumber(vaultAfter.longAmounts[index])).toString(),
@@ -262,10 +262,10 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to add different long in the index of the old long otoken without increase long array length', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testAddLong(vaultCounter, otoken2.address, 10, 0)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vaultAfter.shortAmounts[0], new BigNumber(10))
       assert.equal(vaultBefore.longOtokens.length, vaultAfter.longOtokens.length, 'long otokens array length mismatch')
     })
@@ -287,7 +287,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddCollateral(vaultCounter, weth.address, amount, index)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.collateralAmounts[index], new BigNumber(amount))
     })
 
@@ -295,10 +295,10 @@ contract('MarginVault', ([deployer, controller]) => {
       const changeAmt = 20
       const index = 0
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testAddCollateral(vaultCounter, weth.address, changeAmt, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultAfter.collateralAmounts[index])
@@ -314,7 +314,7 @@ contract('MarginVault', ([deployer, controller]) => {
       const vaultCounter = new BigNumber(0)
 
       await marginVaultTester.testAddCollateral(vaultCounter, usdc.address, amount, index)
-      const vault = await marginVaultTester.getVault(vaultCounter)
+      const vault = await marginVaultTester.getVaultWithDetails(vaultCounter)
       assert.equal(vault.collateralAmounts[index], new BigNumber(amount))
     })
 
@@ -333,10 +333,10 @@ contract('MarginVault', ([deployer, controller]) => {
       const changeAmt = 30
       const index = 1
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testAddCollateral(vaultCounter, usdc.address, changeAmt, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultAfter.collateralAmounts[index])
@@ -363,10 +363,10 @@ contract('MarginVault', ([deployer, controller]) => {
       const index = 0
       const toRemove = 5
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testRemoveCollateral(vaultCounter, weth.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.collateralAmounts[index])
@@ -379,12 +379,12 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to remove all of the remaining amount of first collateral asset and delete collateral asset address', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
       const index = 0
       const toRemove = vaultBefore.collateralAmounts[index]
 
       await marginVaultTester.testRemoveCollateral(vaultCounter, weth.address, toRemove, index)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(
         new BigNumber(vaultBefore.collateralAmounts[index])
@@ -407,10 +407,10 @@ contract('MarginVault', ([deployer, controller]) => {
 
     it('should be able to add different collateral asset in the index of the old collateral asset without increase collateral array length', async () => {
       const vaultCounter = new BigNumber(0)
-      const vaultBefore = await marginVaultTester.getVault(vaultCounter)
+      const vaultBefore = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       await marginVaultTester.testAddCollateral(vaultCounter, usdc.address, 10, 0)
-      const vaultAfter = await marginVaultTester.getVault(vaultCounter)
+      const vaultAfter = await marginVaultTester.getVaultWithDetails(vaultCounter)
 
       assert.equal(vaultAfter.collateralAmounts[0], new BigNumber(10))
       assert.equal(
diff --git a/test/unit-tests/payableProxyController.test.ts b/test/unit-tests/payableProxyController.test.ts
index 5813600c3..c7eb3a610 100644
--- a/test/unit-tests/payableProxyController.test.ts
+++ b/test/unit-tests/payableProxyController.test.ts
@@ -160,7 +160,7 @@ contract('PayableProxyController', ([owner, accountOwner1, holder1, random]) =>
       })
 
       const marginPoolBalanceAfter = new BigNumber(await weth.balanceOf(marginPool.address))
-      const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+      const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
       assert.equal(
         marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),
@@ -216,7 +216,7 @@ contract('PayableProxyController', ([owner, accountOwner1, holder1, random]) =>
       })
 
       const marginPoolBalanceAfter = new BigNumber(await weth.balanceOf(marginPool.address))
-      const vaultAfter = (await controllerProxy.getVault(accountOwner1, vaultCounter))[0]
+      const vaultAfter = (await controllerProxy.getVaultWithDetails(accountOwner1, vaultCounter))[0]
 
       assert.equal(
         marginPoolBalanceAfter.minus(marginPoolBalanceBefore).toString(),