fix(Vault): cast balance updates to uint96

src/Vault.sol

@@ -33,7 +33,7 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
   /* ============ Variables ============ */
 
   /// The maximum amount of shares that can be minted.
-  uint256 private constant UINT112_MAX = type(uint112).max;
+  uint256 private constant UINT96_MAX = type(uint96).max;
 
   /// @notice Address of the underlying asset used by the Vault.
   IERC20 private immutable _asset;
@@ -751,7 +751,10 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
   }
 
   /// @inheritdoc ILiquidationSource
-  function isLiquidationPair(address _tokenOut, address liquidationPair_) external view returns (bool) {
+  function isLiquidationPair(
+    address _tokenOut,
+    address liquidationPair_
+  ) external view returns (bool) {
     return _tokenOut == address(this) && liquidationPair_ == _liquidationPair;
   }
 
@@ -860,9 +863,7 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
    * @param liquidationPair_ New liquidationPair address
    * @return address New liquidationPair address
    */
-  function setLiquidationPair(
-    address liquidationPair_
-  ) external onlyOwner returns (address) {
+  function setLiquidationPair(address liquidationPair_) external onlyOwner returns (address) {
     if (address(liquidationPair_) == address(0)) revert LPZeroAddress();
 
     _liquidationPair = liquidationPair_;
@@ -1108,12 +1109,12 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
 
   /**
    * @notice Returns the maximum amount of underlying assets that can be deposited into the Vault.
-   * @dev We use type(uint112).max cause this is the type used to store balances in TwabController.
+   * @dev We use type(uint96).max cause this is the type used to store balances in TwabController.
    * @param _depositedAssets Assets deposited into the YieldVault
    * @return uint256 Amount of underlying assets that can be deposited
    */
   function _maxDeposit(uint256 _depositedAssets) internal view returns (uint256) {
-    uint256 _vaultMaxDeposit = UINT112_MAX - _depositedAssets;
+    uint256 _vaultMaxDeposit = UINT96_MAX - _depositedAssets;
     uint256 _yieldVaultMaxDeposit = _yieldVault.maxDeposit(address(this));
 
     // Vault shares are minted 1:1 when the vault is collateralized,
@@ -1384,7 +1385,7 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
    * @param _shares Shares to mint
    */
   function _mint(address _receiver, uint256 _shares) internal virtual override {
-    _twabController.mint(_receiver, SafeCast.toUint112(_shares));
+    _twabController.mint(_receiver, SafeCast.toUint96(_shares));
     emit Transfer(address(0), _receiver, _shares);
   }
 
@@ -1397,7 +1398,7 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
    * @param _shares The shares to burn
    */
   function _burn(address _owner, uint256 _shares) internal virtual override {
-    _twabController.burn(_owner, SafeCast.toUint112(_shares));
+    _twabController.burn(_owner, SafeCast.toUint96(_shares));
     emit Transfer(_owner, address(0), _shares);
   }
 
@@ -1411,7 +1412,7 @@ contract Vault is IERC4626, ERC20Permit, ILiquidationSource, IClaimable, Ownable
    * @param _shares Shares to transfer
    */
   function _transfer(address _from, address _to, uint256 _shares) internal virtual override {
-    _twabController.transfer(_from, _to, SafeCast.toUint112(_shares));
+    _twabController.transfer(_from, _to, SafeCast.toUint96(_shares));
     emit Transfer(_from, _to, _shares);
   }
 

test/contracts/external/LiquidatorLib.sol

@@ -157,10 +157,10 @@ library LiquidatorLib {
     uint256 reserve1_1 = FixedMathLib.div(_amountIn1, _liquidityFraction);
 
     // Ensure we can fit K into a uint256
-    // Ensure new virtual reserves fit into uint112
+    // Ensure new virtual reserves fit into uint96
     if (
-      reserve0_1 <= type(uint112).max &&
-      reserve1_1 <= type(uint112).max &&
+      reserve0_1 <= type(uint96).max &&
+      reserve1_1 <= type(uint96).max &&
       uint256(reserve1_1) * reserve0_1 > _minK
     ) {
       reserve0 = uint128(reserve0_1);

test/fuzz/Vault.t.sol

@@ -336,8 +336,8 @@ contract VaultFuzzTest is ERC4626Test, Helpers {
   }
 
   function test_liquidate(Init memory init, uint256 shares) public virtual {
-    // We set the higher bound to uint104 to avoid overflowing above uint112
-    init.yield = int256(bound(shares, 10e18, type(uint104).max));
+    // We set the higher bound to uint88 to avoid overflowing above uint96
+    init.yield = int256(bound(shares, 10e18, type(uint88).max));
 
     setUpVault(init);
     vault.setLiquidationPair(address(liquidationPair));
@@ -368,15 +368,15 @@ contract VaultFuzzTest is ERC4626Test, Helpers {
     }
   }
 
-  // We set the higher bound to uint104 to avoid overflowing above uint112
+  // We set the higher bound to uint88 to avoid overflowing above uint96
   function setUpVault(Init memory init) public virtual override {
     for (uint256 i = 0; i < N; i++) {
       init.user[i] = makeAddr(Strings.toString(i));
       address user = init.user[i];
 
       vm.assume(_isEOA(user));
 
-      uint256 shares = bound(init.share[i], 0, type(uint104).max);
+      uint256 shares = bound(init.share[i], 0, type(uint88).max);
       try IMockERC20(_underlying_).mint(user, shares) {} catch {
         vm.assume(false);
       }
@@ -388,7 +388,7 @@ contract VaultFuzzTest is ERC4626Test, Helpers {
         vm.assume(false);
       }
 
-      uint256 assets = bound(init.asset[i], 0, type(uint104).max);
+      uint256 assets = bound(init.asset[i], 0, type(uint88).max);
       try IMockERC20(_underlying_).mint(user, assets) {} catch {
         vm.assume(false);
       }
@@ -398,22 +398,22 @@ contract VaultFuzzTest is ERC4626Test, Helpers {
   }
 
   function _max_deposit(address from) internal virtual override returns (uint256) {
-    if (_unlimitedAmount) return type(uint104).max;
-    return uint104(IERC20(_underlying_).balanceOf(from));
+    if (_unlimitedAmount) return type(uint88).max;
+    return uint88(IERC20(_underlying_).balanceOf(from));
   }
 
   function _max_mint(address from) internal virtual override returns (uint256) {
-    if (_unlimitedAmount) return type(uint112).max;
-    return uint104(vault_convertToShares(IERC20(_underlying_).balanceOf(from)));
+    if (_unlimitedAmount) return type(uint96).max;
+    return uint88(vault_convertToShares(IERC20(_underlying_).balanceOf(from)));
   }
 
   function _max_withdraw(address from) internal virtual override returns (uint256) {
-    if (_unlimitedAmount) return type(uint104).max;
-    return uint104(vault_convertToAssets(IERC20(_vault_).balanceOf(from)));
+    if (_unlimitedAmount) return type(uint88).max;
+    return uint88(vault_convertToAssets(IERC20(_vault_).balanceOf(from)));
   }
 
   function _max_redeem(address from) internal virtual override returns (uint256) {
-    if (_unlimitedAmount) return type(uint104).max;
-    return uint104(IERC20(_vault_).balanceOf(from));
+    if (_unlimitedAmount) return type(uint88).max;
+    return uint88(IERC20(_vault_).balanceOf(from));
   }
 }

test/unit/Vault/Deposit.feature

@@ -57,7 +57,7 @@ Feature: Deposit
   # Deposit - Errors
   Scenario: Alice deposits into the Vault
     Given Alice owns 0 Vault shares
-    When Alice deposits type(uint112).max + 1 underlying assets
+    When Alice deposits type(uint96).max + 1 underlying assets
     Then the transaction reverts with the custom error `DepositMoreThanMax`
 
   Scenario: Alice deposits into the Vault
@@ -110,7 +110,7 @@ Feature: Deposit
   # Mint - Errors
   Scenario: Alice mints shares from the Vault
     Given Alice owns 0 Vault shares
-    When Alice mints type(uint112).max + 1 shares
+    When Alice mints type(uint96).max + 1 shares
     Then the transaction reverts with the custom error `MintMoreThanMax`
 
   Scenario: Alice mints shares from the Vault

test/unit/Vault/Deposit.t.sol

@@ -185,13 +185,13 @@ contract VaultDepositTest is UnitBaseSetup, BrokenToken {
   function testDepositMoreThanMax() external {
     vm.startPrank(alice);
 
-    uint256 _amount = uint256(type(uint112).max) + 1;
+    uint256 _amount = uint256(type(uint96).max) + 1;
 
     underlyingAsset.mint(alice, _amount);
     underlyingAsset.approve(address(vault), type(uint256).max);
 
     vm.expectRevert(
-      abi.encodeWithSelector(Vault.DepositMoreThanMax.selector, alice, _amount, type(uint112).max)
+      abi.encodeWithSelector(Vault.DepositMoreThanMax.selector, alice, _amount, type(uint96).max)
     );
 
     vault.deposit(_amount, alice);
@@ -384,13 +384,13 @@ contract VaultDepositTest is UnitBaseSetup, BrokenToken {
   function testMintMoreThanMax() external {
     vm.startPrank(alice);
 
-    uint256 _amount = uint256(type(uint112).max) + 1;
+    uint256 _amount = uint256(type(uint96).max) + 1;
 
     underlyingAsset.mint(alice, _amount);
     underlyingAsset.approve(address(vault), type(uint256).max);
 
     vm.expectRevert(
-      abi.encodeWithSelector(Vault.MintMoreThanMax.selector, alice, _amount, type(uint112).max)
+      abi.encodeWithSelector(Vault.MintMoreThanMax.selector, alice, _amount, type(uint96).max)
     );
 
     vault.mint(_amount, alice);

test/unit/Vault/DepositBrokenToken.t.sol

@@ -40,10 +40,10 @@ contract VaultDepositBrokenTokenTest is UnitBrokenTokenBaseSetup {
     vm.startPrank(alice);
     underlyingAsset.approve(address(vault), type(uint256).max);
 
-    // Token with 50 decimals, amount is greater than type(uint112).max
+    // Token with 50 decimals, amount is greater than type(uint96).max
     if (brokenERC20Name == keccak256(bytes("HighDecimalToken"))) {
       vm.expectRevert(
-        abi.encodeWithSelector(Vault.DepositMoreThanMax.selector, alice, _amount, type(uint112).max)
+        abi.encodeWithSelector(Vault.DepositMoreThanMax.selector, alice, _amount, type(uint96).max)
       );
 
       vault.deposit(_amount, alice);

test/unit/Vault/Liquidate.feature

@@ -98,6 +98,6 @@ Feature: Liquidate
     Then the transaction reverts with the custom error `YieldFeeGTAvailable`
 
   Scenario: Bob mints 1e18 yield fee shares
-    Given Bob owns type(uint112).max Vault shares and 10e18 of yield fee shares have accrued
+    Given Bob owns type(uint96).max Vault shares and 10e18 of yield fee shares have accrued
     When Bob mints 1e18 yield fee shares
     Then the transaction reverts with the error SafeCast: value doesn't fit in 112 bits

test/unit/Vault/Liquidate.t.sol

@@ -324,7 +324,7 @@ contract VaultLiquidateTest is UnitBaseSetup {
     vault.setYieldFeeRecipient(bob);
 
     uint256 _yield = 10e18;
-    uint256 _amount = type(uint112).max - _yield;
+    uint256 _amount = type(uint96).max - _yield;
 
     underlyingAsset.mint(address(this), _amount);
     _sponsor(underlyingAsset, vault, _amount);
@@ -361,7 +361,7 @@ contract VaultLiquidateTest is UnitBaseSetup {
 
     assertEq(vault.balanceOf(bob), 0);
 
-    // _yieldFeeShares has not been minted yet, so totatSupply is type(uint112).max - _yield
+    // _yieldFeeShares has not been minted yet, so totatSupply is type(uint96).max - _yield
     assertEq(vault.totalSupply(), _amount);
     assertEq(vault.yieldFeeShares(), _yieldFeeShares);
 
@@ -509,15 +509,15 @@ contract VaultLiquidateTest is UnitBaseSetup {
     vm.stopPrank();
   }
 
-  function testTransferTokensOut_AmountOutGTUint112() public {
+  function testTransferTokensOut_AmountOutGTuint96() public {
     _setLiquidationPair();
 
     uint256 _amount = 1000e18;
 
     underlyingAsset.mint(address(this), _amount);
     _sponsor(underlyingAsset, vault, _amount);
 
-    uint256 _amountOut = type(uint120).max;
+    uint256 _amountOut = type(uint104).max;
     _accrueYield(underlyingAsset, yieldVault, _amountOut);
 
     vm.startPrank(address(alice));
@@ -533,7 +533,7 @@ contract VaultLiquidateTest is UnitBaseSetup {
 
     vm.startPrank(address(liquidationPair));
 
-    vm.expectRevert(bytes("SafeCast: value doesn't fit in 112 bits"));
+    vm.expectRevert(bytes("SafeCast: value doesn't fit in 96 bits"));
 
     vault.transferTokensOut(address(this), alice, address(vault), _amountOut);
 

test/unit/Vault/Vault.t.sol

@@ -381,9 +381,7 @@ contract VaultTest is UnitBaseSetup {
   }
 
   function testSetLiquidationPairOnlyOwner() public {
-    address _newLiquidationPair = address(
-      0xff3c527f9F5873bd735878F23Ff7eC5AB2E3b820
-    );
+    address _newLiquidationPair = address(0xff3c527f9F5873bd735878F23Ff7eC5AB2E3b820);
 
     vm.startPrank(alice);
 
@@ -395,9 +393,7 @@ contract VaultTest is UnitBaseSetup {
 
   /* ============ isLiquidationPair ============ */
   function testIsLiquidationPair() public {
-    address _newLiquidationPair = address(
-      0xff3c527f9F5873bd735878F23Ff7eC5AB2E3b820
-    );
+    address _newLiquidationPair = address(0xff3c527f9F5873bd735878F23Ff7eC5AB2E3b820);
 
     vault.setLiquidationPair(address(liquidationPair));
     assertEq(vault.isLiquidationPair(address(vault), address(_newLiquidationPair)), false);