diff --git a/core/contracts/Allocator.sol b/core/contracts/Allocator.sol new file mode 100644 index 000000000..92c773386 --- /dev/null +++ b/core/contracts/Allocator.sol @@ -0,0 +1,576 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol"; + +import {IMinimal4626} from "./interfaces/IMinimal4626.sol"; +import {ILP4626} from "./interfaces/ILP4626.sol"; + +import {stBTC} from "./stBTC.sol"; +import {IReserve} from "./interfaces/IReserve.sol"; + +contract Allocator is Ownable { + using SafeERC20 for IERC20; + + // Strategies + struct Strategy { + // additional reserve token that strategy is allowed to use + address baseToken; + // block timestamp of last allocate/free + uint64 blockTimestamp; + // percent of allocator assets allocated to strategy, 0 is inactive + uint32 weight; + // ratio of base token + uint32 baseRatio; + /*////////////////////////////////////////////////////////////// + allocate/free related + //////////////////////////////////////////////////////////////*/ + + // current total asset after each allocate/free + uint96 totalAssets; + /*////////////////////////////////////////////////////////////// + settlement related + //////////////////////////////////////////////////////////////*/ + uint128 lastTotalAssets; + int128 netFlow; + // strategy last pricePerShare from last allocate/free + uint128 pricePerShare; + } + + IERC20 public immutable tbtcToken; + stBTC public immutable stbtc; + IReserve public reserve; + + uint128 public lastTotalAssets; + + IMinimal4626[] public strategyList; + mapping(IMinimal4626 => Strategy) public strategies; + + event Settlement( + uint256 indexed blockNumber, + uint128 lastTotalAssets, + int256 netPerformance, + uint256 performanceFee, + uint256 lossCover, + uint256 divergenceCover + ); + + constructor( + IERC20 _tBTC, + stBTC _stBTC, + IReserve _reserve + ) Ownable(msg.sender) { + tbtcToken = _tBTC; + stbtc = _stBTC; + reserve = _reserve; + } + + /*////////////////////////////////////////////////////////////// + ADMIN ONLY + //////////////////////////////////////////////////////////////*/ + + function addStrategy( + IMinimal4626 _strategy, + Strategy memory _strategyData + ) external onlyOwner { + require(address(_strategy) != address(0), "ZERO_ADDRESS"); + require( + strategies[_strategy].baseToken == address(0), + "STRATEGY_EXISTS" + ); + strategyList.push(_strategy); + /* solhint-disable-next-line not-rely-on-time */ + _strategyData.blockTimestamp = uint64(block.timestamp); + strategies[_strategy] = _strategyData; + + /*============================================= + LP4626 Specific + =============================================*/ + if (_strategyData.baseRatio > 0) { + _approve( + _strategyData.baseToken, + address(_strategy), + type(uint256).max + ); + reserve.approve( + _strategyData.baseToken, + address(_strategy), + type(uint256).max + ); + _approve( + _strategyData.baseToken, + address(reserve), + type(uint256).max + ); + } + /*==========/ LP4626 Specific =================*/ + } + + function updateStrategy( + IMinimal4626 _strategy, + Strategy memory _strategyData + ) external onlyOwner { + require(address(_strategy) != address(0), "ZERO_ADDRESS"); + address baseToken = strategies[_strategy].baseToken; + require(baseToken != address(0), "STRATEGY_ABSENT"); + + /* solhint-disable-next-line not-rely-on-time */ + _strategyData.blockTimestamp = uint64(block.timestamp); + strategies[_strategy] = _strategyData; + } + + function settle() external onlyOwner { + // 1. collect all unclaimed rewards & free all reserve assets + (uint256[][] memory amountsList, int256 netPerformance) = _free(); + + // 2. profit settlement + uint256 performanceFee; + uint256 lossCover; + uint256 divergenceCover; + (performanceFee, lossCover, divergenceCover, amountsList) = _settle( + amountsList, + netPerformance + ); + + // 3. syncRewards + stbtc.syncRewards(); + + // 4. re-allocate all assets + _allocate(amountsList, true); + + // 5. reset settlement deltas + for (uint256 i; i < amountsList.length; i++) { + strategies[strategyList[i]].netFlow = 0; + } + + emit Settlement( + block.number, + lastTotalAssets, + netPerformance, + performanceFee, + lossCover, + divergenceCover + ); + } + + /*////////////////////////////////////////////////////////////// + stBTC ONLY + //////////////////////////////////////////////////////////////*/ + + function withdraw(uint256 _assets, address _receiver) external { + require(msg.sender == address(stbtc), "ONLY_STBTC"); + (uint256[][] memory amountsList, ) = _free(); + + // exchange base tokens to tbtcToken if needed + uint256 tBTCBalance = _balanceOf(address(tbtcToken), address(this)); + if (tBTCBalance < _assets) { + _swap(amountsList); + amountsList = new uint256[][](0); + } + + uint256 fee; + uint256 withdrawFeeRatio = reserve.withdrawFeeRatio(); + if (withdrawFeeRatio > 0) { + fee = (_assets * withdrawFeeRatio) / 10_000; + tbtcToken.approve(address(reserve), fee); + reserve.takeWithdrawFee(address(tbtcToken), fee); + } + tBTCBalance = _balanceOf(address(tbtcToken), address(this)); + uint256 withdrawAmount = _assets - fee; + if (tBTCBalance < withdrawAmount) withdrawAmount = tBTCBalance; + _transfer(address(tbtcToken), _receiver, withdrawAmount); + + _allocate(amountsList, false); + } + + /*////////////////////////////////////////////////////////////// + ADMIN or stBTC ONLY + //////////////////////////////////////////////////////////////*/ + + function allocate() external { + require( + msg.sender == owner() || msg.sender == address(stbtc), + "UNAUTHORIZED" + ); + _allocate(new uint256[][](0), false); + } + + function free() external { + require( + msg.sender == owner() || msg.sender == address(stbtc), + "UNAUTHORIZED" + ); + (uint256[][] memory amountsList, ) = _free(); + _swap(amountsList); + } + + /*////////////////////////////////////////////////////////////// + Public Methods + //////////////////////////////////////////////////////////////*/ + + function strategyLength() external view returns (uint256) { + return strategyList.length; + } + + function totalAssets() public view returns (uint256 totalAmount) { + // current strategy totalAssets + for (uint256 i = 0; i < strategyList.length; i++) { + totalAmount += strategyList[i].totalAssets(); + } + + // unused quote token in allocator + totalAmount += _balanceOf(address(tbtcToken), address(this)); + } + + /*////////////////////////////////////////////////////////////// + Internal Helpers + //////////////////////////////////////////////////////////////*/ + + function _allocate( + uint256[][] memory amountsList, + bool _settlement + ) internal { + uint256 totalWeight = _totalWeight(); + if (totalWeight == 0) return; + + uint256 totalQuoteAmount = _balanceOf( + address(tbtcToken), + address(this) + ); + + for (uint256 i = 0; i < strategyList.length; i++) { + IMinimal4626 strategy = strategyList[i]; + bool isMinimalStrategy = strategies[strategy].baseRatio == 0; + Strategy storage strategyInfo = strategies[strategy]; + uint256 quoteAmount = (totalQuoteAmount * strategyInfo.weight) / + totalWeight; + + if (quoteAmount > 0) { + // allocate allocator's quote token to strategy + _approve(address(tbtcToken), address(strategy), quoteAmount); + strategy.deposit(quoteAmount, address(this)); + } + + if (isMinimalStrategy) { + if (quoteAmount == 0) continue; + strategyInfo.netFlow += int128(int256(quoteAmount)); + if (_settlement) { + strategyInfo.lastTotalAssets = uint128( + strategy.totalAssets() + ); + } + } else { + /*============================================= + LP4626 Specific + =============================================*/ + uint256 baseAmount = amountsList.length > 0 + ? amountsList[i][1] + : 0; + if (quoteAmount == 0 && baseAmount == 0) continue; + + ILP4626 lpStrategy = ILP4626(address(strategy)); + address baseToken = lpStrategy.baseToken(); + + // allocate allocator's base token to strategy if needed + if (baseAmount > 0) { + lpStrategy.depositToken( + baseToken, + baseAmount, + address(this) + ); + strategyInfo.netFlow += int128( + int256( + quoteAmount + lpStrategy.convert(baseAmount, true) + ) + ); + } else { + strategyInfo.netFlow += int128(int256(quoteAmount)); + } + if (_settlement) { + strategyInfo.lastTotalAssets = uint128( + strategy.totalAssets() + ); + } + + // allocate reserve's base token to strategy + reserve.allocate( + lpStrategy, + baseToken, + baseAmount, + quoteAmount, + strategyInfo.baseRatio + ); + /*==========/ LP4626 Specific =================*/ + } + + // update strategy records + strategyInfo.totalAssets = uint96(strategy.totalAssets()); + strategyInfo.pricePerShare = uint128(strategy.pricePerShare()); + /* solhint-disable-next-line not-rely-on-time */ + strategyInfo.blockTimestamp = uint64(block.timestamp); + } + } + + function _free() + internal + returns (uint256[][] memory amountsList, int256 netPerformance) + { + amountsList = new uint256[][](strategyList.length); + for (uint256 i = 0; i < strategyList.length; i++) { + IMinimal4626 strategy = strategyList[i]; + // calculate compareTotalAsset + int256 compareTotalAsset = int256( + uint256(strategies[strategy].lastTotalAssets) + ) + strategies[strategy].netFlow; + + // free all positions + strategy.free(); + + // redeem allocator tokens + uint256 allocatorShares = strategy.maxRedeem(address(this)); + if (allocatorShares > 0) { + bool isMinimalStrategy = strategies[strategy].baseRatio == 0; + int256 currentTotalAsset; + uint256[] memory amounts = new uint256[]( + isMinimalStrategy ? 1 : 2 + ); + amounts[0] = _balanceOf(address(tbtcToken), address(this)); + + if (isMinimalStrategy) { + strategy.redeem( + allocatorShares, + address(this), + address(this) + ); + amounts[0] = + _balanceOf(address(tbtcToken), address(this)) - + amounts[0]; + currentTotalAsset = int256(amounts[0]); + } else { + /*============================================= + LP4626 Specific + =============================================*/ + ILP4626 lpStrategy = ILP4626(address(strategy)); + address baseTokenAddr = lpStrategy.baseToken(); + amounts[1] = _balanceOf(baseTokenAddr, address(this)); + strategy.redeem( + allocatorShares, + address(this), + address(this) + ); + amounts[0] = + _balanceOf(address(tbtcToken), address(this)) - + amounts[0]; + amounts[1] = + _balanceOf(baseTokenAddr, address(this)) - + amounts[1]; + currentTotalAsset = int256( + amounts[0] + lpStrategy.convert(amounts[1], true) + ); + /*==========/ LP4626 Specific =================*/ + } + + amountsList[i] = amounts; + strategies[strategy].netFlow -= int128( + int256(currentTotalAsset) + ); + netPerformance += (currentTotalAsset - compareTotalAsset); + } + + // redeem reserve tokens + reserve.free(strategy); + + // update strategy records + strategies[strategy].totalAssets = uint96(strategy.totalAssets()); + strategies[strategy].pricePerShare = uint128( + strategy.pricePerShare() + ); + /* solhint-disable-next-line not-rely-on-time */ + strategies[strategy].blockTimestamp = uint64(block.timestamp); + } + } + + function _settle( + uint256[][] memory amountsList, + int256 netPerformance + ) + internal + returns ( + uint256 performanceFee_, + uint256 lossCover_, + uint256 divergenceCover_, + uint256[][] memory amountsList_ + ) + { + amountsList_ = amountsList; + + // in profit + if (netPerformance > 0) { + // reserve takes a performance fee when profitable + performanceFee_ = + (uint256(netPerformance) * reserve.performanceFeeRatio()) / + 10_000; + if (performanceFee_ > 0) { + _approve(address(tbtcToken), address(reserve), performanceFee_); + reserve.takePerformanceFee(address(tbtcToken), performanceFee_); + } + } else if (netPerformance < 0) { + // reserve covers the loss if needed + lossCover_ = _reserveCoverage(uint256(-netPerformance)); + + /*============================================= + LP4626 Specific + =============================================*/ + // reserve covers the divergence if needed + for (uint256 i; i < amountsList.length; i++) { + bool isMinimalStrategy = strategies[strategyList[i]] + .baseRatio == 0; + if (isMinimalStrategy) continue; + + ILP4626 lpStrategy = ILP4626(address(strategyList[i])); + address baseToken = lpStrategy.baseToken(); + if (amountsList[i][1] == 0) continue; + + uint256 baseTotal = ((amountsList[i][1] + + lpStrategy.convert(amountsList[i][0], false)) * + strategies[lpStrategy].baseRatio) / 10_000; + if (amountsList[i][1] <= baseTotal) continue; + + // reserve transfers quote token to strategy + // strategy transfers base token to reserve + uint256 baseAmount = amountsList[i][1] - baseTotal; + uint256 quoteAmount = lpStrategy.convert(baseAmount, true); + if ( + _balanceOf(address(tbtcToken), address(reserve)) > + quoteAmount + ) { + _transfer(baseToken, address(reserve), baseAmount); + reserve.coverDivergence( + baseToken, + baseAmount, + address(tbtcToken), + quoteAmount + ); + divergenceCover_ = quoteAmount; + amountsList_[i][1] -= baseAmount; + } + } + /*==========/ LP4626 Specific =================*/ + } + + uint256 currTotalAssets = totalAssets(); + + /*============================================= + LP4626 Specific + =============================================*/ + // adding unused strategy base token into current totalAssets + for (uint256 i; i < amountsList.length; i++) { + bool isMinimalStrategy = strategies[strategyList[i]].baseRatio == 0; + if (isMinimalStrategy) continue; + + if (strategies[strategyList[i]].baseRatio > 0) { + // unused strategy base token in allocator + if (amountsList[i][1] > 0) { + currTotalAssets += ILP4626(address(strategyList[i])) + .convert(amountsList[i][1], true); + } + } + } + /*==========/ LP4626 Specific =================*/ + + // additional totalAssets check after loss cover & divergence cover + if (netPerformance < 0) { + uint256 stBTCTotalAssets = stbtc.totalAssets(); + if (stBTCTotalAssets > currTotalAssets) { + uint256 coverAmount = _reserveCoverage( + stBTCTotalAssets - currTotalAssets + ); + lossCover_ += coverAmount; + currTotalAssets += coverAmount; + } + } + + lastTotalAssets = uint96(currTotalAssets); + } + + /*============================================= + LP4626 Specific + =============================================*/ + // - swap base to quote from reserve first + // - swap via v3Pool if needed + function _swap(uint256[][] memory amountsList) internal { + for (uint256 i = 0; i < amountsList.length; i++) { + ILP4626 lpStrategy = ILP4626(address(strategyList[i])); + uint256 baseAmount = amountsList[i][1]; + if (baseAmount > 0) { + uint256 baseLeft = reserve.swap( + lpStrategy, + address(tbtcToken), + baseAmount + ); + // swap base token to quote token via uniswap v3 pool + if (baseLeft > 0) { + _transfer( + lpStrategy.baseToken(), + address(lpStrategy), + baseLeft + ); + lpStrategy.swapBaseToQuote(baseLeft); + } + } + } + } + + /*==========/ LP4626 Specific =================*/ + + // reserve covers the loss if possible + function _reserveCoverage( + uint256 _lossAmount + ) internal returns (uint256 lossCover) { + uint256 reserveBalance = _balanceOf( + address(tbtcToken), + address(reserve) + ); + if (reserveBalance > _lossAmount) { + reserve.coverLoss(address(tbtcToken), _lossAmount); + lossCover = _lossAmount; + } + } + + function _transferFrom( + address _token, + address _from, + address _to, + uint256 _amount + ) internal { + IERC20(_token).safeTransferFrom(_from, _to, _amount); + } + + function _transfer(address _token, address _to, uint256 _amount) internal { + IERC20(_token).safeTransfer(_to, _amount); + } + + function _approve( + address _token, + address _spender, + uint256 _amount + ) internal { + IERC20(_token).approve(_spender, _amount); + } + + function _totalWeight() internal view returns (uint256 totalWeight) { + for (uint256 i = 0; i < strategyList.length; i++) { + totalWeight += strategies[strategyList[i]].weight; + } + } + + function _balanceOf( + address _token, + address _account + ) internal view returns (uint256) { + return IERC20(_token).balanceOf(_account); + } +} diff --git a/core/contracts/Reserve.sol b/core/contracts/Reserve.sol new file mode 100644 index 000000000..d6857d441 --- /dev/null +++ b/core/contracts/Reserve.sol @@ -0,0 +1,301 @@ +// SPDX-License-Identifier: UNLICENSED + +// Source: https://github.com/decoupleco/stBTC/blob/main/contracts/reserve.sol +// Differences: +// - Replacing Solmate with OpenZeppelin imports +pragma solidity ^0.8.21; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +import {IMinimal4626} from "./interfaces/IMinimal4626.sol"; +import {ILP4626} from "./interfaces/ILP4626.sol"; +import {IReserve} from "./interfaces/IReserve.sol"; + +contract Reserve is IReserve, Ownable { + using SafeERC20 for IERC20; + + address public allocator; + uint64 public performanceFeeRatio; + uint64 public withdrawFeeRatio; + + // token specific deposits + // tBTC += amount + // WBTC += amount + mapping(address => uint256) public totalDeposits; + // token specific withdraws + // tBTC += amount + // WBTC += amount + mapping(address => uint256) public totalWithdraws; + // token specific accumulators, can be negative + // tBTC -= amount + // WBTC += amount + mapping(address => int256) public divergenceCover; + // tBTC accumulators, updated on settlement + uint128 public profitFee; + uint128 public lossCover; + // tBTC accumulators, updates on every withdraw + uint128 public withdrawFee; + // updated at + uint128 public blockTimestamp; + + modifier onlyAllocator() { + require(msg.sender == allocator, "AllocatorOnly"); + _; + } + + constructor( + uint64 _performanceFeeRatio, + uint64 _withdrawFeeRatio + ) Ownable(msg.sender) { + performanceFeeRatio = _performanceFeeRatio; + withdrawFeeRatio = _withdrawFeeRatio; + } + + /*////////////////////////////////////////////////////////////// + Admin Only + //////////////////////////////////////////////////////////////*/ + + function setAllocator(address _allocator) external onlyOwner { + require(_allocator != address(0), "ZERO_ADDRESS"); + allocator = _allocator; + } + + function setPerformanceFeeRatio( + uint64 _performanceFeeRatio + ) external onlyOwner { + performanceFeeRatio = _performanceFeeRatio; + } + + function setWithdrawFeeRatio(uint64 _withdrawFeeRatio) external onlyOwner { + withdrawFeeRatio = _withdrawFeeRatio; + } + + function deposit(address _token, uint256 _amount) external onlyOwner { + _deposit(_token, msg.sender, _amount); + } + + function withdraw(address _token, uint256 _amount) external onlyOwner { + _withdraw(_token, msg.sender, _amount); + } + + /*////////////////////////////////////////////////////////////// + Allocator Only + //////////////////////////////////////////////////////////////*/ + + function allocate( + ILP4626 _strategy, + address _baseToken, + uint256 _baseAmount, + uint256 _quoteAmount, + uint32 _baseRatio + ) external onlyAllocator { + if (_baseRatio == 0) return; + + uint256 reserveBaseAmount; + if (_baseAmount > 0) { + uint256 baseTotal = ((_baseAmount + + _strategy.convert(_quoteAmount, false)) * _baseRatio) / 10_000; + if (baseTotal > _baseAmount) + reserveBaseAmount = baseTotal - _baseAmount; + } else { + reserveBaseAmount = + (_strategy.convert(_quoteAmount, false) * _baseRatio) / + 10_000; + } + + if (reserveBaseAmount > 0) { + uint256 reserveBaseBalance = _balanceOf(_baseToken, address(this)); + if (reserveBaseAmount > reserveBaseBalance) { + reserveBaseAmount = reserveBaseBalance; + } + _strategy.depositToken( + _baseToken, + reserveBaseAmount, + address(this) + ); + + // update stats + totalWithdraws[_baseToken] += reserveBaseAmount; + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + } + } + + function free(IMinimal4626 _strategy) external onlyAllocator { + uint256 reserveShares = _strategy.maxRedeem(address(this)); + if (reserveShares > 0) { + _strategy.redeem(reserveShares, address(this), address(this)); + } + } + + // swap quote to base + function swap( + ILP4626 _strategy, + address _quoteToken, + uint256 _baseAmountDesired + ) external onlyAllocator returns (uint256 baseLeft) { + uint256 reserveQuoteBalance = _balanceOf(_quoteToken, address(this)); + uint256 quoteAmountDesired = _strategy.convert( + _baseAmountDesired, + true + ); + uint256 quoteAmount; + uint256 baseAmount; + if (quoteAmountDesired > reserveQuoteBalance) { + quoteAmount = quoteAmountDesired - reserveQuoteBalance; + baseAmount = _strategy.convert(quoteAmount, false); + } else { + quoteAmount = quoteAmountDesired; + baseAmount = _baseAmountDesired; + } + + // transfer quote token (tBTC) from reserve to allocator + _withdraw(_quoteToken, msg.sender, quoteAmount); + // transfer base token from allocator to reserve + _deposit(_strategy.baseToken(), msg.sender, baseAmount); + baseLeft = _baseAmountDesired - baseAmount; + } + + function coverLoss(address _token, uint256 _amount) external onlyAllocator { + // update stats + lossCover += uint128(_amount); + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + // transfer tokens out + _transfer(_token, msg.sender, _amount); + } + + // transfers quote token to strategy + // receive base token from strategy + function coverDivergence( + address _baseToken, + uint256 _baseAmount, + address _quoteToken, + uint256 _quoteAmount + ) external onlyAllocator { + // update stats + divergenceCover[_baseToken] += int256(_baseAmount); + divergenceCover[_quoteToken] += -int256(_quoteAmount); + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + _transfer(_quoteToken, msg.sender, _quoteAmount); + } + + function takePerformanceFee( + address _token, + uint256 _amount + ) external onlyAllocator { + // update stats + profitFee += uint128(_amount); + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + // transfer tokens from msg.sender to current contract + _transferFrom(_token, msg.sender, address(this), _amount); + } + + function takeWithdrawFee( + address _token, + uint256 _amount + ) external onlyAllocator { + // update stats + withdrawFee += uint128(_amount); + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + // transfer tokens from msg.sender to current contract + _transferFrom(_token, msg.sender, address(this), _amount); + } + + function approve( + address _token, + address _spender, + uint256 _amount + ) external onlyAllocator { + IERC20(_token).approve(_spender, _amount); + } + + /*////////////////////////////////////////////////////////////// + Public Helpers + //////////////////////////////////////////////////////////////*/ + + function getStats( + address[] calldata _addrList + ) + external + view + returns ( + uint256[] memory totalDeposits_, + uint256[] memory totalWithdraws_, + int256[] memory divergenceCover_, + uint256 profitFee_, + uint256 lossCover_, + uint256 withdrawFee_, + uint256 blockTimestamp_ + ) + { + uint256 addrLength = _addrList.length; + totalDeposits_ = new uint256[](addrLength); + totalWithdraws_ = new uint256[](addrLength); + divergenceCover_ = new int256[](addrLength); + + for (uint256 i = 0; i < addrLength; i++) { + totalDeposits_[i] = totalDeposits[_addrList[i]]; + totalWithdraws_[i] = totalWithdraws[_addrList[i]]; + divergenceCover_[i] = divergenceCover[_addrList[i]]; + } + + profitFee_ = profitFee; + lossCover_ = lossCover; + withdrawFee_ = withdrawFee; + blockTimestamp_ = blockTimestamp; + } + + /*////////////////////////////////////////////////////////////// + Internal Helpers + //////////////////////////////////////////////////////////////*/ + + function _deposit(address _token, address _from, uint256 _amount) internal { + // update stats + totalDeposits[_token] += _amount; + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + // transfer tokens from msg.sender to current contract + _transferFrom(_token, _from, address(this), _amount); + } + + function _withdraw(address _token, address _to, uint256 _amount) internal { + // update stats + totalWithdraws[_token] += _amount; + /* solhint-disable-next-line not-rely-on-time */ + blockTimestamp = uint128(block.timestamp); + + // transfer tokens to msg.sender + _transfer(_token, _to, _amount); + } + + function _transferFrom( + address _token, + address _from, + address _to, + uint256 _amount + ) internal { + IERC20(_token).safeTransferFrom(_from, _to, _amount); + } + + function _transfer(address _token, address _to, uint256 _amount) internal { + IERC20(_token).safeTransfer(_to, _amount); + } + + function _balanceOf( + address _token, + address _account + ) internal view returns (uint256) { + return IERC20(_token).balanceOf(_account); + } +} diff --git a/core/contracts/interfaces/ILP4626.sol b/core/contracts/interfaces/ILP4626.sol new file mode 100644 index 000000000..de2bb89a3 --- /dev/null +++ b/core/contracts/interfaces/ILP4626.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.21; + +import {IMinimal4626} from "./IMinimal4626.sol"; + +interface ILP4626 is IMinimal4626 { + function depositToken( + address _token, + uint256 _amount, + address _receiver + ) external returns (uint256 shares); + + function swapBaseToQuote(uint256 _amountIn) external; + + function baseToken() external view returns (address); + + function convert( + uint256 _baseAmount, + bool _baseToQuote + ) external view returns (uint256); +} diff --git a/core/contracts/interfaces/IMinimal4626.sol b/core/contracts/interfaces/IMinimal4626.sol new file mode 100644 index 000000000..49d84651c --- /dev/null +++ b/core/contracts/interfaces/IMinimal4626.sol @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.21; + +interface IMinimal4626 { + function deposit( + uint256 assets, + address receiver + ) external returns (uint256 shares); + + function redeem( + uint256 shares, + address receiver, + address owner + ) external returns (uint256 assets); + + function free() external; + + function totalAssets() external view returns (uint256); + + function pricePerShare() external view returns (uint256); + + function maxRedeem(address owner) external view returns (uint256); +} diff --git a/core/contracts/interfaces/IReserve.sol b/core/contracts/interfaces/IReserve.sol new file mode 100644 index 000000000..a813c4b20 --- /dev/null +++ b/core/contracts/interfaces/IReserve.sol @@ -0,0 +1,50 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.21; + +import {IMinimal4626} from "./IMinimal4626.sol"; +import {ILP4626} from "./ILP4626.sol"; + +interface IReserve { + function deposit(address _token, uint256 _amount) external; + + function withdraw(address _token, uint256 _amount) external; + + function coverLoss(address _token, uint256 _amount) external; + + function coverDivergence( + address _baseToken, + uint256 _baseAmount, + address _quoteToken, + uint256 _quoteAmount + ) external; + + function takePerformanceFee(address _token, uint256 _amount) external; + + function takeWithdrawFee(address _token, uint256 _amount) external; + + function approve( + address _token, + address _spender, + uint256 _amount + ) external; + + function allocate( + ILP4626 _strategy, + address _baseToken, + uint256 _baseAmount, + uint256 _quoteAmount, + uint32 _baseRatio + ) external; + + function free(IMinimal4626 _strategy) external; + + function swap( + ILP4626 _strategy, + address _quoteToken, + uint256 _baseAmountDesired + ) external returns (uint256 baseLeft); + + function performanceFeeRatio() external view returns (uint64); + + function withdrawFeeRatio() external view returns (uint64); +} diff --git a/core/contracts/interfaces/IxERC4626.sol b/core/contracts/interfaces/IxERC4626.sol new file mode 100644 index 000000000..4dec2724c --- /dev/null +++ b/core/contracts/interfaces/IxERC4626.sol @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: MIT +// Rewards logic inspired by xERC20 (https://github.com/ZeframLou/playpen/blob/main/src/xERC20.sol) + +// Source: https://github.com/ERC4626-Alliance/ERC4626-Contracts/blob/main/src/interfaces/IxERC4626.sol +// Differences: +// - replaced import from Solmate's ERC4626 with OpenZeppelin ERC4626 +// - replaced import from Solmate's SafeCastLib with OpenZeppelin SafeCast +// - functions reorder to make Slither happy + +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol"; +import "@openzeppelin/contracts/utils/math/SafeCast.sol"; + +/** + @title An xERC4626 Single Staking Contract Interface + @notice This contract allows users to autocompound rewards denominated in an underlying reward token. + It is fully compatible with [ERC4626](https://eips.ethereum.org/EIPS/eip-4626) allowing for DeFi composability. + It maintains balances using internal accounting to prevent instantaneous changes in the exchange rate. + NOTE: an exception is at contract creation, when a reward cycle begins before the first deposit. After the first deposit, exchange rate updates smoothly. + + Operates on "cycles" which distribute the rewards surplus over the internal balance to users linearly over the remainder of the cycle window. +*/ +interface IxERC4626 { + /*//////////////////////////////////////////////////////// + Events + ////////////////////////////////////////////////////////*/ + + /// @dev emit every time a new rewards cycle starts + event NewRewardsCycle(uint32 indexed cycleEnd, uint256 rewardAmount); + + /*//////////////////////////////////////////////////////// + Custom Errors + ////////////////////////////////////////////////////////*/ + + /// @dev thrown when syncing before cycle ends. + error SyncError(); + + /*//////////////////////////////////////////////////////// + State Changing Methods + ////////////////////////////////////////////////////////*/ + + /// @notice Distributes rewards to xERC4626 holders. + /// All surplus `asset` balance of the contract over the internal balance becomes queued for the next cycle. + function syncRewards() external; + + /*//////////////////////////////////////////////////////// + View Methods + ////////////////////////////////////////////////////////*/ + + /// @notice the maximum length of a rewards cycle + function rewardsCycleLength() external view returns (uint32); + + /// @notice the effective start of the current cycle + /// NOTE: This will likely be after `rewardsCycleEnd - rewardsCycleLength` as this is set as block.timestamp of the last `syncRewards` call. + function lastSync() external view returns (uint32); + + /// @notice the end of the current cycle. Will always be evenly divisible by `rewardsCycleLength`. + function rewardsCycleEnd() external view returns (uint32); + + /// @notice the amount of rewards distributed in a the most recent cycle + function lastRewardAmount() external view returns (uint192); +} diff --git a/core/contracts/lib/ERC4626Fees.sol b/core/contracts/lib/ERC4626Fees.sol deleted file mode 100644 index cb44dddb6..000000000 --- a/core/contracts/lib/ERC4626Fees.sol +++ /dev/null @@ -1,99 +0,0 @@ -// SPDX-License-Identifier: MIT - -// Inspired by https://docs.openzeppelin.com/contracts/5.x/erc4626#fees - -pragma solidity ^0.8.20; - -import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import {ERC4626} from "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol"; -import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; - -/// @dev ERC4626 vault with entry/exit fees expressed in https://en.wikipedia.org/wiki/Basis_point[basis point (bp)]. -abstract contract ERC4626Fees is ERC4626 { - using Math for uint256; - - uint256 private constant _BASIS_POINT_SCALE = 1e4; - - // === Overrides === - - /// @dev Preview taking an entry fee on deposit. See {IERC4626-previewDeposit}. - function previewDeposit( - uint256 assets - ) public view virtual override returns (uint256) { - uint256 fee = _feeOnTotal(assets, _entryFeeBasisPoints()); - return super.previewDeposit(assets - fee); - } - - /// @dev Preview adding an entry fee on mint. See {IERC4626-previewMint}. - function previewMint( - uint256 shares - ) public view virtual override returns (uint256) { - uint256 assets = super.previewMint(shares); - return assets + _feeOnRaw(assets, _entryFeeBasisPoints()); - } - - // TODO: add previewWithraw - - // TODO: add previewRedeem - - /// @dev Send entry fee to {_feeRecipient}. See {IERC4626-_deposit}. - function _deposit( - address caller, - address receiver, - uint256 assets, - uint256 shares - ) internal virtual override { - uint256 fee = _feeOnTotal(assets, _entryFeeBasisPoints()); - address recipient = _feeRecipient(); - - super._deposit(caller, receiver, assets, shares); - - if (fee > 0 && recipient != address(this)) { - SafeERC20.safeTransfer(IERC20(asset()), recipient, fee); - } - } - - // TODO: add withdraw - - // === Fee configuration === - - // slither-disable-next-line dead-code - function _entryFeeBasisPoints() internal view virtual returns (uint256); - - // TODO: add exitFeeBasisPoints - - // slither-disable-next-line dead-code - function _feeRecipient() internal view virtual returns (address); - - // === Fee operations === - - /// @dev Calculates the fees that should be added to an amount `assets` - /// that does not already include fees. - /// Used in {IERC4626-mint} and {IERC4626-withdraw} operations. - function _feeOnRaw( - uint256 assets, - uint256 feeBasisPoints - ) private pure returns (uint256) { - return - assets.mulDiv( - feeBasisPoints, - _BASIS_POINT_SCALE, - Math.Rounding.Ceil - ); - } - - /// @dev Calculates the fee part of an amount `assets` that already includes fees. - /// Used in {IERC4626-deposit} and {IERC4626-redeem} operations. - function _feeOnTotal( - uint256 assets, - uint256 feeBasisPoints - ) private pure returns (uint256) { - return - assets.mulDiv( - feeBasisPoints, - feeBasisPoints + _BASIS_POINT_SCALE, - Math.Rounding.Ceil - ); - } -} diff --git a/core/contracts/lib/xERC4626.sol b/core/contracts/lib/xERC4626.sol new file mode 100644 index 000000000..934b679b8 --- /dev/null +++ b/core/contracts/lib/xERC4626.sol @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: MIT +// Rewards logic inspired by xERC20 (https://github.com/ZeframLou/playpen/blob/main/src/xERC20.sol) +// Source: https://github.com/ERC4626-Alliance/ERC4626-Contracts +// Differences: +// - replaced import from Solmate's ERC4626 with OpenZeppelin ERC4626 +// - replaced import from Solmate's SafeCastLib with OpenZeppelin SafeCast +// - removed super.beforeWithdraw and super.afterDeposit calls +// - removed overrides from beforeWithdraw and afterDeposit +// - replaced `asset.balanceOf(address(this))` with `IERC20(asset()).balanceOf(address(this))` +// - removed unused `shares` param from `beforeWithdraw` and `afterDeposit` +// - minor formatting changes and solhint additions + +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol"; +import "@openzeppelin/contracts/utils/math/SafeCast.sol"; + +import "../interfaces/IxERC4626.sol"; + +/** + @title An xERC4626 Single Staking Contract + @notice This contract allows users to autocompound rewards denominated in an underlying reward token. + It is fully compatible with [ERC4626](https://eips.ethereum.org/EIPS/eip-4626) allowing for DeFi composability. + It maintains balances using internal accounting to prevent instantaneous changes in the exchange rate. + NOTE: an exception is at contract creation, when a reward cycle begins before the first deposit. After the first deposit, exchange rate updates smoothly. + + Operates on "cycles" which distribute the rewards surplus over the internal balance to users linearly over the remainder of the cycle window. +*/ +abstract contract xERC4626 is IxERC4626, ERC4626 { + using SafeCast for *; + + /// @notice the maximum length of a rewards cycle + uint32 public immutable rewardsCycleLength; + + /// @notice the effective start of the current cycle + uint32 public lastSync; + + /// @notice the end of the current cycle. Will always be evenly divisible by `rewardsCycleLength`. + uint32 public rewardsCycleEnd; + + /// @notice the amount of rewards distributed in a the most recent cycle. + uint192 public lastRewardAmount; + + uint256 internal storedTotalAssets; + + constructor(uint32 _rewardsCycleLength) { + rewardsCycleLength = _rewardsCycleLength; + // seed initial rewardsCycleEnd + /* solhint-disable not-rely-on-time */ + // slither-disable-next-line divide-before-multiply + rewardsCycleEnd = + (block.timestamp.toUint32() / rewardsCycleLength) * + rewardsCycleLength; + } + + /// @notice Distributes rewards to xERC4626 holders. + /// All surplus `asset` balance of the contract over the internal + /// balance becomes queued for the next cycle. + function syncRewards() public virtual { + uint192 lastRewardAmount_ = lastRewardAmount; + /* solhint-disable-next-line not-rely-on-time */ + uint32 timestamp = block.timestamp.toUint32(); + + if (timestamp < rewardsCycleEnd) revert SyncError(); + + uint256 storedTotalAssets_ = storedTotalAssets; + uint256 nextRewards = IERC20(asset()).balanceOf(address(this)) - + storedTotalAssets_ - + lastRewardAmount_; + + storedTotalAssets = storedTotalAssets_ + lastRewardAmount_; // SSTORE + + // slither-disable-next-line divide-before-multiply + uint32 end = ((timestamp + rewardsCycleLength) / rewardsCycleLength) * + rewardsCycleLength; + + // Combined single SSTORE + lastRewardAmount = nextRewards.toUint192(); + lastSync = timestamp; + rewardsCycleEnd = end; + + emit NewRewardsCycle(end, nextRewards); + } + + /// @notice Compute the amount of tokens available to share holders. + /// Increases linearly during a reward distribution period from the + /// sync call, not the cycle start. + function totalAssets() public view override returns (uint256) { + // cache global vars + uint256 storedTotalAssets_ = storedTotalAssets; + uint192 lastRewardAmount_ = lastRewardAmount; + uint32 rewardsCycleEnd_ = rewardsCycleEnd; + uint32 lastSync_ = lastSync; + + /* solhint-disable-next-line not-rely-on-time */ + if (block.timestamp >= rewardsCycleEnd_) { + // no rewards or rewards fully unlocked + // entire reward amount is available + return storedTotalAssets_ + lastRewardAmount_; + } + + // rewards not fully unlocked + // add unlocked rewards to stored total + /* solhint-disable not-rely-on-time */ + uint256 unlockedRewards = (lastRewardAmount_ * + (block.timestamp - lastSync_)) / (rewardsCycleEnd_ - lastSync_); + return storedTotalAssets_ + unlockedRewards; + } + + // Commenting out for Slither to pass the "dead-code" warning. Uncomment once + // we add withdrawals. + // Update storedTotalAssets on withdraw/redeem + // function beforeWithdraw(uint256 amount) internal virtual { + // storedTotalAssets -= amount; + // } + + // Update storedTotalAssets on deposit/mint + function afterDeposit(uint256 amount) internal virtual { + storedTotalAssets += amount; + } +} diff --git a/core/contracts/stBTC.sol b/core/contracts/stBTC.sol index 2eb0e5198..88f80ee31 100644 --- a/core/contracts/stBTC.sol +++ b/core/contracts/stBTC.sol @@ -5,7 +5,7 @@ import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "./Dispatcher.sol"; -import "./lib/ERC4626Fees.sol"; +import "./lib/xERC4626.sol"; /// @title stBTC /// @notice This contract implements the ERC-4626 tokenized vault standard. By @@ -18,7 +18,7 @@ import "./lib/ERC4626Fees.sol"; /// of yield-bearing vaults. This contract facilitates the minting and /// burning of shares (stBTC), which are represented as standard ERC20 /// tokens, providing a seamless exchange with tBTC tokens. -contract stBTC is ERC4626Fees, Ownable { +contract stBTC is xERC4626, Ownable { using SafeERC20 for IERC20; /// Dispatcher contract that routes tBTC from stBTC to a given vault and back. @@ -27,10 +27,7 @@ contract stBTC is ERC4626Fees, Ownable { /// Address of the treasury wallet, where fees should be transferred to. address public treasury; - /// Entry fee basis points applied to entry fee calculation. - uint256 public entryFeeBasisPoints; - - /// Minimum amount for a single deposit operation. Includes treasury fee. + /// Minimum amount for a single deposit operation. uint256 public minimumDepositAmount; /// Maximum total amount of tBTC token held by Acre protocol. uint256 public maximumTotalAssets; @@ -52,10 +49,6 @@ contract stBTC is ERC4626Fees, Ownable { /// @param newDispatcher Address of the new dispatcher contract. event DispatcherUpdated(address oldDispatcher, address newDispatcher); - /// Emitted when the entry fee basis points are updated. - /// @param entryFeeBasisPoints New value of the fee basis points. - event EntryFeeBasisPointsUpdated(uint256 entryFeeBasisPoints); - /// Reverts if the amount is less than the minimum deposit amount. /// @param amount Amount to check. /// @param min Minimum amount to check 'amount' against. @@ -69,8 +62,14 @@ contract stBTC is ERC4626Fees, Ownable { constructor( IERC20 _tbtc, - address _treasury - ) ERC4626(_tbtc) ERC20("Acre Staked Bitcoin", "stBTC") Ownable(msg.sender) { + address _treasury, + uint32 _rewardsCycleLength + ) + ERC4626(_tbtc) + ERC20("Acre Staked Bitcoin", "stBTC") + Ownable(msg.sender) + xERC4626(_rewardsCycleLength) // TODO: revisit initialization + { if (address(_treasury) == address(0)) { revert ZeroAddress(); } @@ -78,7 +77,6 @@ contract stBTC is ERC4626Fees, Ownable { // TODO: Revisit the exact values closer to the launch. minimumDepositAmount = 0.001 * 1e18; // 0.001 tBTC maximumTotalAssets = 25 * 1e18; // 25 tBTC - entryFeeBasisPoints = 5; // 5bps == 0.05% == 0.0005 } /// @notice Updates treasury wallet address. @@ -146,45 +144,25 @@ contract stBTC is ERC4626Fees, Ownable { IERC20(asset()).forceApprove(address(dispatcher), type(uint256).max); } - // TODO: Implement a governed upgrade process that initiates an update and - // then finalizes it after a delay. - /// @notice Update the entry fee basis points. - /// @param newEntryFeeBasisPoints New value of the fee basis points. - function updateEntryFeeBasisPoints( - uint256 newEntryFeeBasisPoints - ) external onlyOwner { - entryFeeBasisPoints = newEntryFeeBasisPoints; - - emit EntryFeeBasisPointsUpdated(newEntryFeeBasisPoints); - } - - /// @notice Returns value of assets that would be exchanged for the amount of - /// shares owned by the `account`. - /// @param account Owner of shares. - /// @return Assets amount. - function assetsBalanceOf(address account) public view returns (uint256) { - return convertToAssets(balanceOf(account)); - } - /// @notice Mints shares to receiver by depositing exactly amount of /// tBTC tokens. /// @dev Takes into account a deposit parameter, minimum deposit amount, /// which determines the minimum amount for a single deposit operation. /// The amount of the assets has to be pre-approved in the tBTC /// contract. - /// @param assets Approved amount of tBTC tokens to deposit. This includes - /// treasury fees for staking tBTC. + /// @param assets Approved amount of tBTC tokens to deposit. /// @param receiver The address to which the shares will be minted. - /// @return Minted shares adjusted for the fees taken by the treasury. + /// @return shares Minted shares. function deposit( uint256 assets, address receiver - ) public override returns (uint256) { + ) public override returns (uint256 shares) { if (assets < minimumDepositAmount) { revert LessThanMinDeposit(assets, minimumDepositAmount); } - return super.deposit(assets, receiver); + shares = super.deposit(assets, receiver); + afterDeposit(assets); } /// @notice Mints shares to receiver by depositing tBTC tokens. @@ -193,9 +171,7 @@ contract stBTC is ERC4626Fees, Ownable { /// The amount of the assets has to be pre-approved in the tBTC /// contract. /// The msg.sender is required to grant approval for the transfer of a - /// certain amount of tBTC, and in addition, approval for the associated - /// fee. Specifically, the total amount to be approved (amountToApprove) - /// should be equal to the sum of the deposited amount and the fee. + /// certain amount of tBTC. /// To determine the total assets amount necessary for approval /// corresponding to a given share amount, use the `previewMint` function. /// @param shares Amount of shares to mint. @@ -207,16 +183,24 @@ contract stBTC is ERC4626Fees, Ownable { if ((assets = super.mint(shares, receiver)) < minimumDepositAmount) { revert LessThanMinDeposit(assets, minimumDepositAmount); } + afterDeposit(assets); + } + + /// @notice Returns value of assets that would be exchanged for the amount of + /// shares owned by the `account`. + /// @param account Owner of shares. + /// @return Assets amount. + function assetsBalanceOf(address account) public view returns (uint256) { + return convertToAssets(balanceOf(account)); } /// @notice Returns the maximum amount of the tBTC token that can be /// deposited into the vault for the receiver through a deposit /// call. It takes into account the deposit parameter, maximum total /// assets, which determines the total amount of tBTC token held by - /// Acre. This function always returns available limit for deposits, - /// but the fee is not taken into account. As a result of this, there - /// always will be some dust left. If the dust is lower than the - /// minimum deposit amount, this function will return 0. + /// Acre protocol. + /// @dev When the remaining amount of unused limit is less than the minimum + /// deposit amount, this function returns 0. /// @return The maximum amount of tBTC token that can be deposited into /// Acre protocol for the receiver. function maxDeposit(address) public view override returns (uint256) { @@ -224,14 +208,12 @@ contract stBTC is ERC4626Fees, Ownable { return type(uint256).max; } - uint256 currentTotalAssets = totalAssets(); - if (currentTotalAssets >= maximumTotalAssets) return 0; - - // Max amount left for next deposits. If it is lower than the minimum - // deposit amount, return 0. - uint256 unusedLimit = maximumTotalAssets - currentTotalAssets; + uint256 _totalAssets = totalAssets(); - return minimumDepositAmount > unusedLimit ? 0 : unusedLimit; + return + _totalAssets >= maximumTotalAssets + ? 0 + : maximumTotalAssets - _totalAssets; } /// @notice Returns the maximum amount of the vault shares that can be @@ -253,15 +235,4 @@ contract stBTC is ERC4626Fees, Ownable { function depositParameters() public view returns (uint256, uint256) { return (minimumDepositAmount, maximumTotalAssets); } - - /// @notice Redeems shares for tBTC tokens. - function _entryFeeBasisPoints() internal view override returns (uint256) { - return entryFeeBasisPoints; - } - - /// @notice Returns the address of the treasury wallet, where fees should be - /// transferred to. - function _feeRecipient() internal view override returns (address) { - return treasury; - } } diff --git a/core/deploy/01_deploy_stbtc.ts b/core/deploy/01_deploy_stbtc.ts index d5ac48523..a72532870 100644 --- a/core/deploy/01_deploy_stbtc.ts +++ b/core/deploy/01_deploy_stbtc.ts @@ -6,10 +6,11 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => { const { deployer, treasury } = await getNamedAccounts() const tbtc = await deployments.get("TBTC") + const rewardsCycleLength = 7 * 24 * 60 * 60 // 7 days await deployments.deploy("stBTC", { from: deployer, - args: [tbtc.address, treasury], + args: [tbtc.address, treasury, rewardsCycleLength], log: true, waitConfirmations: 1, }) diff --git a/core/test/Deployment.test.ts b/core/test/Deployment.test.ts index 4c0d9233b..5a31dfdce 100644 --- a/core/test/Deployment.test.ts +++ b/core/test/Deployment.test.ts @@ -27,7 +27,7 @@ describe("Deployment", () => { await loadFixture(fixture)) }) - describe("Acre", () => { + describe("stBTC", () => { describe("constructor", () => { context("when treasury has been set", () => { it("should be set to a treasury address", async () => { @@ -36,6 +36,14 @@ describe("Deployment", () => { expect(actualTreasury).to.be.equal(await treasury.getAddress()) }) }) + + context("when rewardsCycleLength has been set", () => { + it("should be set to a rewardsCycleLength", async () => { + const actualRewardsCycleLength = await stbtc.rewardsCycleLength() + + expect(actualRewardsCycleLength).to.be.equal(7 * 24 * 60 * 60) + }) + }) }) describe("updateDispatcher", () => { diff --git a/core/test/stBTC.test.ts b/core/test/stBTC.test.ts index 45dea676e..684547b89 100644 --- a/core/test/stBTC.test.ts +++ b/core/test/stBTC.test.ts @@ -1,14 +1,17 @@ import { takeSnapshot, loadFixture, + SnapshotRestorer, + time, + mine, } from "@nomicfoundation/hardhat-toolbox/network-helpers" import { expect } from "chai" import { ContractTransactionResponse, MaxUint256, ZeroAddress } from "ethers" import { ethers } from "hardhat" import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers" -import type { SnapshotRestorer } from "@nomicfoundation/hardhat-toolbox/network-helpers" import { + beforeAfterEachSnapshotWrapper, beforeAfterSnapshotWrapper, deployment, getNamedSigner, @@ -42,9 +45,6 @@ async function fixture() { } describe("stBTC", () => { - const entryFeeBasisPoints = 5n - const basisPointScale = 10000n - let stbtc: stBTC let tbtc: TestERC20 let dispatcher: Dispatcher @@ -53,7 +53,8 @@ describe("stBTC", () => { let depositor1: HardhatEthersSigner let depositor2: HardhatEthersSigner let thirdParty: HardhatEthersSigner - let treasury: HardhatEthersSigner + + const rewardsCycleLength = 604800n // 7days before(async () => { ;({ @@ -64,62 +65,14 @@ describe("stBTC", () => { dispatcher, governance, thirdParty, - treasury, } = await loadFixture(fixture)) }) - describe("feeOnTotal - internal test helper", () => { - context("when the fee's modulo remainder is greater than 0", () => { - it("should add 1 to the result", () => { - // feeOnTotal - test's internal function simulating the OZ mulDiv - // function. - const fee = feeOnTotal(to1e18(1)) - // fee = (1e18 * 5) / (10000 + 5) = 499750124937531 + 1 - const expectedFee = 499750124937532 - expect(fee).to.be.eq(expectedFee) - }) - }) - - context("when the fee's modulo remainder is equal to 0", () => { - it("should return the actual result", () => { - // feeOnTotal - test's internal function simulating the OZ mulDiv - // function. - const fee = feeOnTotal(2001n) - // fee = (2001 * 5) / (10000 + 5) = 1 - const expectedFee = 1n - expect(fee).to.be.eq(expectedFee) - }) - }) - }) - - describe("feeOnRaw - internal test helper", () => { - context("when the fee's modulo remainder is greater than 0", () => { - it("should return the correct amount of fees", () => { - // feeOnRaw - this is a test internal function - const fee = feeOnRaw(to1e18(1)) - // fee = (1e18 * 5) / (10000) = 500000000000000 - const expectedFee = 500000000000000 - expect(fee).to.be.eq(expectedFee) - }) - }) - - context("when the fee's modulo remainder is equal to 0", () => { - it("should return the actual result", () => { - // feeOnTotal - test's internal function simulating the OZ mulDiv - // function. - const fee = feeOnTotal(2000n) - // fee = (2000 * 5) / 10000 = 1 - const expectedFee = 1n - expect(fee).to.be.eq(expectedFee) - }) - }) - }) - describe("previewDeposit", () => { beforeAfterSnapshotWrapper() context("when the vault is empty", () => { - const amountToDeposit = to1e18(1) + const amountToDeposit = to1e18(9) before(async () => { await tbtc @@ -127,33 +80,19 @@ describe("stBTC", () => { .approve(await stbtc.getAddress(), amountToDeposit) }) - context("when validating preview deposit against hardcoded value", () => { + context("when validating preview deposit", () => { it("should return the correct amount of shares", async () => { const shares = await stbtc.previewDeposit(amountToDeposit) - // amount to deposit = 1 tBTC - // fee = (1e18 * 5) / (10000 + 5) = 499750124937532 - // shares = 1e18 - 499750124937532 = 999500249875062468 - const expectedShares = 999500249875062468n + // amount to deposit = 9 tBTC + // shares same as deposit amount + const expectedShares = amountToDeposit expect(shares).to.be.eq(expectedShares) }) }) - - context( - "when previewing shares against programatically calculated values", - () => { - it("should return the correct amount of shares", async () => { - const shares = await stbtc.previewDeposit(amountToDeposit) - const expectedShares = amountToDeposit - feeOnTotal(amountToDeposit) - expect(shares).to.be.eq(expectedShares) - }) - }, - ) }) context("when the vault is not empty", () => { - beforeAfterSnapshotWrapper() - - const amountToDeposit1 = to1e18(1) + const amountToDeposit1 = to1e18(14) const amountToDeposit2 = to1e18(2) before(async () => { @@ -167,7 +106,7 @@ describe("stBTC", () => { }) it("should return the correct amount of shares", async () => { - const expectedShares = amountToDeposit2 - feeOnTotal(amountToDeposit2) + const expectedShares = amountToDeposit2 const shares = await stbtc.previewDeposit(amountToDeposit2) expect(shares).to.be.eq(expectedShares) }) @@ -175,17 +114,14 @@ describe("stBTC", () => { }) describe("previewMint", () => { - let amountToDeposit: bigint - beforeAfterSnapshotWrapper() context("when validating preview mint against hardcoded value", () => { it("should return the correct amount of assets", async () => { - // 1e18 + 500000000000000 - amountToDeposit = 1000500000000000000n + const expectedAssets = to1e18(1) const assetsToDeposit = await stbtc.previewMint(to1e18(1)) - expect(assetsToDeposit).to.be.eq(amountToDeposit) + expect(assetsToDeposit).to.be.eq(expectedAssets) }) }) @@ -196,13 +132,11 @@ describe("stBTC", () => { const sharesToMint1 = to1e18(1) const sharesToMint2 = to1e18(2) - // To receive 1 stBTC, a user must deposit 1.0005 tBTC where 0.0005 tBTC - // is a fee. - const amountToDeposit1 = sharesToMint1 + feeOnRaw(sharesToMint1) + // To receive 1 stBTC, a user must deposit 1 tBTC + const amountToDeposit1 = sharesToMint1 - // To receive 2 stBTC, a user must deposit 2.001 tBTC where 0.001 tBTC - // is a fee. - const amountToDeposit2 = sharesToMint2 + feeOnRaw(sharesToMint2) + // To receive 2 stBTC, a user must deposit 2 tBTC + const amountToDeposit2 = sharesToMint2 it("should preview the correct amount of assets for deposit 2", async () => { await tbtc @@ -228,11 +162,6 @@ describe("stBTC", () => { describe("assetsBalanceOf", () => { beforeAfterSnapshotWrapper() - before(async () => { - // Disable entry fee - await stbtc.connect(governance).updateEntryFeeBasisPoints(0n) - }) - context("when the vault is empty", () => { it("should return zero", async () => { expect(await stbtc.assetsBalanceOf(depositor1.address)).to.be.equal(0) @@ -313,6 +242,7 @@ describe("stBTC", () => { before(async () => { await tbtc.mint(await stbtc.getAddress(), earnedYield) + await syncRewards() }) it("should return the correct amount of assets", async () => { @@ -401,14 +331,12 @@ describe("stBTC", () => { let amountToDeposit: bigint let tx: ContractTransactionResponse let expectedReceivedShares: bigint - let fee: bigint before(async () => { const minimumDepositAmount = await stbtc.minimumDepositAmount() amountToDeposit = minimumDepositAmount - fee = feeOnTotal(amountToDeposit) - expectedReceivedShares = amountToDeposit - fee + expectedReceivedShares = amountToDeposit await tbtc.approve(await stbtc.getAddress(), amountToDeposit) tx = await stbtc @@ -417,10 +345,6 @@ describe("stBTC", () => { }) it("should emit Deposit event", async () => { - // "It is less clear in the EIP spec itself, but there seems to be - // consensus that this event should include the number of assets paid - // for by the user, including the fees." - // https://docs.openzeppelin.com/contracts/5.x/erc4626#fees await expect(tx).to.emit(stbtc, "Deposit").withArgs( // Caller. depositor1.address, @@ -442,7 +366,7 @@ describe("stBTC", () => { }) it("should transfer tBTC tokens to Acre", async () => { - const actualDepositdAmount = amountToDeposit - fee + const actualDepositdAmount = amountToDeposit await expect(tx).to.changeTokenBalances( tbtc, @@ -450,14 +374,6 @@ describe("stBTC", () => { [-amountToDeposit, actualDepositdAmount], ) }) - - it("should transfer tBTC fee to treasury", async () => { - await expect(tx).to.changeTokenBalances( - tbtc, - [treasury.address], - [fee], - ) - }) }) context("when the receiver is zero address", () => { @@ -479,76 +395,6 @@ describe("stBTC", () => { .withArgs(ZeroAddress) }) }) - - context( - "when a depositor approved and deposited tokens and wants to deposit more but w/o another approval", - () => { - beforeAfterSnapshotWrapper() - - const amountToDeposit = to1e18(10) - - before(async () => { - await tbtc - .connect(depositor1) - .approve(await stbtc.getAddress(), amountToDeposit) - - await stbtc - .connect(depositor1) - .deposit(amountToDeposit, depositor1.address) - }) - - it("should revert", async () => { - await expect( - stbtc - .connect(depositor1) - .deposit(amountToDeposit, depositor1.address), - ) - .to.be.revertedWithCustomError( - stbtc, - "ERC20InsufficientAllowance", - ) - .withArgs(await stbtc.getAddress(), 0, amountToDeposit) - }) - }, - ) - - context("when there is no entry fee, i.e. fee is 0", () => { - beforeAfterSnapshotWrapper() - - const amountToDeposit = to1e18(10) - const expectedReceivedShares = amountToDeposit - - let tx: ContractTransactionResponse - - before(async () => { - await stbtc.connect(governance).updateEntryFeeBasisPoints(0n) - await tbtc.approve(await stbtc.getAddress(), amountToDeposit) - - tx = await stbtc - .connect(depositor1) - .deposit(amountToDeposit, receiver.address) - }) - - it("should mint stBTC tokens", async () => { - await expect(tx).to.changeTokenBalance( - stbtc, - receiver, - expectedReceivedShares, - ) - }) - - it("should transfer tBTC tokens to stBTC contract", async () => { - await expect(tx).to.changeTokenBalances( - tbtc, - [depositor1, stbtc], - [-amountToDeposit, amountToDeposit], - ) - }) - - it("should not transfer tBTC fee to treasury", async () => { - await expect(tx).to.changeTokenBalance(tbtc, treasury.address, 0n) - }) - }) }) describe("when staking by multiple depositors", () => { @@ -592,7 +438,7 @@ describe("stBTC", () => { afterDepositsSnapshot = await takeSnapshot() }) - it("depositor A should receive shares equal to a deposited amount minus fee", async () => { + it("depositor 1 should receive shares equal to a deposited amount", async () => { const expectedShares = await stbtc.previewDeposit( depositor1AmountToDeposit, ) @@ -604,7 +450,7 @@ describe("stBTC", () => { ) }) - it("depositor B should receive shares equal to a deposited amount", async () => { + it("depositor 2 should receive shares equal to a deposited amount", async () => { const expectedShares = await stbtc.previewDeposit( depositor2AmountToDeposit, ) @@ -617,29 +463,13 @@ describe("stBTC", () => { }) it("the total assets amount should be equal to all deposited tokens", async () => { - const actualDepositAmount1 = - depositor1AmountToDeposit - feeOnTotal(depositor1AmountToDeposit) - const actualDepositAmount2 = - depositor2AmountToDeposit - feeOnTotal(depositor2AmountToDeposit) + const actualDepositAmount1 = depositor1AmountToDeposit + const actualDepositAmount2 = depositor2AmountToDeposit expect(await stbtc.totalAssets()).to.eq( actualDepositAmount1 + actualDepositAmount2, ) }) - - it("should transfer fee to treasury after staking by two depositors", async () => { - await expect(depositTx1).to.changeTokenBalances( - tbtc, - [treasury], - [feeOnTotal(depositor1AmountToDeposit)], - ) - - await expect(depositTx2).to.changeTokenBalances( - tbtc, - [treasury], - [feeOnTotal(depositor2AmountToDeposit)], - ) - }) }) }) @@ -650,9 +480,9 @@ describe("stBTC", () => { before(async () => { // Current state: - // depositor 1 shares = deposit amount - fee = 7 - (~0,0035) = ~6.9965 - // depositor 2 shares = deposit amount - fee = 3 - (~0,0015) = ~2.9985 - // Total assets = ~6.9965(depositor 1) + 2.9985(depositor 2) + 5(yield) + // depositor 1 shares = deposit amount = 7 + // depositor 2 shares = deposit amount = 3 + // Total assets = 7 + 3 + 5 (yield) = 15 await afterDepositsSnapshot.restore() depositor1SharesBefore = await stbtc.balanceOf(depositor1.address) @@ -662,17 +492,16 @@ describe("stBTC", () => { // more tokens than deposited which causes the exchange rate to // change. await tbtc.mint(await stbtc.getAddress(), earnedYield) + await syncRewards() }) after(async () => { afterSimulatingYieldSnapshot = await takeSnapshot() }) - it("the vault should hold more assets minus fees", async () => { - const actualDepositAmount1 = - depositor1AmountToDeposit - feeOnTotal(depositor1AmountToDeposit) - const actualDepositAmount2 = - depositor2AmountToDeposit - feeOnTotal(depositor2AmountToDeposit) + it("the vault should hold more assets", async () => { + const actualDepositAmount1 = depositor1AmountToDeposit + const actualDepositAmount2 = depositor2AmountToDeposit expect(await stbtc.totalAssets()).to.be.eq( actualDepositAmount1 + actualDepositAmount2 + earnedYield, @@ -683,44 +512,36 @@ describe("stBTC", () => { expect(await stbtc.balanceOf(depositor1.address)).to.be.eq( depositor1SharesBefore, ) + expect(await stbtc.balanceOf(depositor2.address)).to.be.eq( depositor2SharesBefore, ) }) - it("the depositor A should be able to redeem more tokens than before", async () => { + it("the depositor 1 should be able to redeem more tokens than before", async () => { const shares = await stbtc.balanceOf(depositor1.address) const availableAssetsToRedeem = await stbtc.previewRedeem(shares) - // Expected amount: - // 6.996501749125437281 * 14.995002498750624689 / 9.995002498750624689 - // =~ 10.496501749125437280 - // As of writing this test the fractional part after 18 decimals is - // floor rounded in Solidity when redeeming tokens. This will change - // to ceiling rounding once we introduce fees on reedeming and - // withdrawals actions. - const expectedAssetsToRedeem = 10496501749125437280n + // 7 * 15 / 10 = 10.5 + // Due to Solidity's mulDiv functions the result is floor rounded. + const expectedAssetsToRedeem = 10499999999999999999n expect(availableAssetsToRedeem).to.be.eq(expectedAssetsToRedeem) }) - it("the depositor B should be able to redeem more tokens than before", async () => { + it("the depositor 2 should be able to redeem more tokens than before", async () => { const shares = await stbtc.balanceOf(depositor2.address) const availableAssetsToRedeem = await stbtc.previewRedeem(shares) - // Expected amount with trancation after 18 decimals: - // 2.998500749625187406 * 14.995002498750624689 / 9.995002498750624689 = ~4.498500749625187405 - // As of writing this test the fractional part after 18 decimals is - // floor rounded in Solidity when redeeming tokens. This will change - // to ceiling rounding once we introduce fees on reedeming and - // withdrawals actions. - const expectedAssetsToRedeem = 4498500749625187405n + // 3 * 15 / 10 = 4.5 + // Due to Solidity's mulDiv functions the result is floor rounded. + const expectedAssetsToRedeem = 4499999999999999999n expect(availableAssetsToRedeem).to.be.eq(expectedAssetsToRedeem) }) }) - context("when depositor A deposits more tokens", () => { + context("when depositor 1 deposits more tokens", () => { context( "when total tBTC amount after staking would not exceed max amount", () => { @@ -741,17 +562,13 @@ describe("stBTC", () => { .connect(depositor1) .approve(await stbtc.getAddress(), newAmountToDeposit) - // State after deposit: - // - // Total assets = 6.996501749125437281(depositor 1) + - // 2.998500749625187406(depositor 2) + 5(yield) + - // 1.999000499750124937(depositorA) = 16.994002998500749624 - // - // Total shares = 6.996501749125437281 + 2.998500749625187406 + - // 1.332444925679136768 = 11.327447424429761455 await stbtc .connect(depositor1) .deposit(newAmountToDeposit, depositor1.address) + // State after deposit: + // Shares to mint = (assets * stBTCSupply / totalTBTCInAcre) = 2 * 10 / 15 = ~1.333333333333333333 + // Total assets = 7(depositor 1) + 3(depositor 2) + 5(yield) + 2 = 17 + // Total shares = 7 + 3 + ~1.3 = 11.333333333333333333 }) it("should receive more shares", async () => { @@ -768,11 +585,9 @@ describe("stBTC", () => { const availableToRedeem = await stbtc.previewRedeem(shares) // Expected amount to redeem by depositor 1: - // - // (6.996501749125437281 + 1.332444925679136768) * - // 16.994002998500749624 / 11.327447424429761455 = 12.495502248875562217 + // (7 + ~1.3) * 17 / ~11.3 = ~12.49 const expectedTotalAssetsAvailableToRedeem = - 12495502248875562217n + 12499999999999999999n expect(availableToRedeem).to.be.greaterThan( availableToRedeemBefore, @@ -825,10 +640,12 @@ describe("stBTC", () => { "when total tBTC amount after staking would be equal to the max amount", () => { let amountToDeposit: bigint + let maxDeposit: bigint let tx: ContractTransactionResponse before(async () => { - amountToDeposit = await stbtc.maxDeposit(depositor1.address) + maxDeposit = await stbtc.maxDeposit(depositor1.address) + amountToDeposit = maxDeposit await tbtc .connect(depositor1) @@ -841,21 +658,13 @@ describe("stBTC", () => { await expect(tx).to.emit(stbtc, "Deposit") }) - it("the max deposit amount should be equal to a fee taken for the last deposit", async () => { - const fee = feeOnTotal(amountToDeposit) - - expect(await stbtc.maxDeposit(depositor1)).to.eq(fee) - }) - it("should not be able to deposit more tokens than the max deposit allow", async () => { - const fee = feeOnTotal(amountToDeposit) - - await expect(stbtc.deposit(amountToDeposit, depositor1)) + await expect(stbtc.deposit(to1e18(2), depositor1)) .to.be.revertedWithCustomError( stbtc, "ERC4626ExceededMaxDeposit", ) - .withArgs(depositor1.address, amountToDeposit, fee) + .withArgs(depositor1.address, to1e18(2), 0n) }) }, ) @@ -877,12 +686,11 @@ describe("stBTC", () => { beforeAfterSnapshotWrapper() const sharesToMint = to1e18(1) - const fee = feeOnRaw(sharesToMint) let tx: ContractTransactionResponse let amountToDeposit: bigint before(async () => { - amountToDeposit = sharesToMint + fee + amountToDeposit = sharesToMint await tbtc .connect(depositor1) @@ -918,13 +726,9 @@ describe("stBTC", () => { await expect(tx).to.changeTokenBalances( tbtc, [depositor1.address, stbtc], - [-amountToDeposit, amountToDeposit - fee], + [-amountToDeposit, amountToDeposit], ) }) - - it("should transfer fee to tresury", async () => { - await expect(tx).to.changeTokenBalances(tbtc, [treasury], [fee]) - }) }) context( @@ -982,44 +786,6 @@ describe("stBTC", () => { }) }, ) - - context("when there is no entry fee, i.e. fee is 0", () => { - beforeAfterSnapshotWrapper() - - const sharesToMint = to1e18(2) - const amountToDeposit = sharesToMint - - let tx: ContractTransactionResponse - - before(async () => { - await stbtc.connect(governance).updateEntryFeeBasisPoints(0n) - await tbtc.approve(await stbtc.getAddress(), amountToDeposit) - - tx = await stbtc - .connect(depositor1) - .mint(sharesToMint, receiver.address) - }) - - it("should mint stBTC tokens", async () => { - await expect(tx).to.changeTokenBalance( - stbtc, - receiver.address, - sharesToMint, - ) - }) - - it("should transfer tBTC tokens to Acre", async () => { - await expect(tx).to.changeTokenBalances( - tbtc, - [depositor1.address, stbtc], - [-amountToDeposit, amountToDeposit], - ) - }) - - it("should not transfer tBTC fee to treasury", async () => { - await expect(tx).to.changeTokenBalance(tbtc, treasury.address, 0n) - }) - }) }) describe("updateDepositParameters", () => { @@ -1115,71 +881,13 @@ describe("stBTC", () => { }) }) - describe("updateEntryFeeBasisPoints", () => { - beforeAfterSnapshotWrapper() - - const validEntryFeeBasisPoints = 100n // 1% - - context("when is called by governance", () => { - context("when entry fee basis points are valid", () => { - beforeAfterSnapshotWrapper() - - let tx: ContractTransactionResponse - - before(async () => { - tx = await stbtc - .connect(governance) - .updateEntryFeeBasisPoints(validEntryFeeBasisPoints) - }) - - it("should emit EntryFeeBasisPointsUpdated event", async () => { - await expect(tx) - .to.emit(stbtc, "EntryFeeBasisPointsUpdated") - .withArgs(validEntryFeeBasisPoints) - }) - - it("should update entry fee basis points correctly", async () => { - expect(await stbtc.entryFeeBasisPoints()).to.be.eq( - validEntryFeeBasisPoints, - ) - }) - }) - - context("when entry fee basis points are 0", () => { - beforeAfterSnapshotWrapper() - - const newEntryFeeBasisPoints = 0 - - before(async () => { - await stbtc - .connect(governance) - .updateEntryFeeBasisPoints(newEntryFeeBasisPoints) - }) - - it("should update entry fee basis points correctly", async () => { - expect(await stbtc.entryFeeBasisPoints()).to.be.eq( - newEntryFeeBasisPoints, - ) - }) - }) - }) - - context("when is called by non-governance", () => { - it("should revert", async () => { - await expect( - stbtc.connect(depositor1).updateEntryFeeBasisPoints(100n), - ).to.be.revertedWithCustomError(stbtc, "OwnableUnauthorizedAccount") - }) - }) - }) - describe("maxDeposit", () => { - beforeAfterSnapshotWrapper() + beforeAfterEachSnapshotWrapper() let maximumTotalAssets: bigint let minimumDepositAmount: bigint - before(async () => { + beforeEach(async () => { ;[minimumDepositAmount, maximumTotalAssets] = await stbtc.depositParameters() }) @@ -1187,15 +895,12 @@ describe("stBTC", () => { context( "when total assets is greater than maximum total assets amount", () => { - beforeAfterSnapshotWrapper() - - before(async () => { - const toMint = maximumTotalAssets + 1n - - await tbtc.mint(await stbtc.getAddress(), toMint) - }) - it("should return 0", async () => { + await tbtc.mint( + await stbtc.getAddress(), + BigInt(maximumTotalAssets) + 1n, + ) + await syncRewards() expect(await stbtc.maxDeposit(depositor1.address)).to.be.eq(0) }) }, @@ -1212,33 +917,12 @@ describe("stBTC", () => { context( "when the unused limit is less than the minimum deposit amount", () => { - beforeAfterSnapshotWrapper() - - before(async () => { - const toMint = 24999100000000000000n // 24.9991 tBTC - await tbtc.mint(await stbtc.getAddress(), toMint) - }) - - it("should return 0", async () => { - expect(await stbtc.maxDeposit(depositor1.address)).to.be.eq(0) - }) - }, - ) - - context( - "when the unused limit is equal to the minimum deposit amount", - () => { - beforeAfterSnapshotWrapper() - - before(async () => { - const toMint = 24999000000000000000n // 24.999 tBTC - await tbtc.mint(await stbtc.getAddress(), toMint) - }) - it("should return 0", async () => { - expect(await stbtc.maxDeposit(depositor1.address)).to.be.eq( - minimumDepositAmount, - ) + const toMint = maximumTotalAssets - 1n + await tbtc + .connect(depositor1) + .approve(await stbtc.getAddress(), toMint) + await stbtc.connect(depositor1).deposit(toMint, depositor1.address) }) }, ) @@ -1250,9 +934,10 @@ describe("stBTC", () => { before(async () => { const toMint = to1e18(2) - expectedValue = maximumTotalAssets - toMint + await tbtc.connect(depositor1).approve(await stbtc.getAddress(), toMint) + await stbtc.connect(depositor1).deposit(toMint, depositor1.address) - await tbtc.mint(await stbtc.getAddress(), toMint) + expectedValue = maximumTotalAssets - toMint }) it("should return correct value", async () => { @@ -1416,7 +1101,7 @@ describe("stBTC", () => { }) describe("maxMint", () => { - beforeAfterSnapshotWrapper() + beforeAfterEachSnapshotWrapper() let maximumTotalAssets: bigint let minimumDepositAmount: bigint @@ -1429,15 +1114,12 @@ describe("stBTC", () => { context( "when total assets is greater than maximum total assets amount", () => { - beforeAfterSnapshotWrapper() - - before(async () => { + it("should return 0", async () => { const toMint = maximumTotalAssets + 1n await tbtc.mint(await stbtc.getAddress(), toMint) - }) + await syncRewards() - it("should return 0", async () => { expect(await stbtc.maxMint(depositor1.address)).to.be.eq(0) }) }, @@ -1459,10 +1141,10 @@ describe("stBTC", () => { let expectedValue: bigint before(async () => { - const toMint = to1e18(2) - const amountToDeposit = to1e18(3) + const toMint = to1e18(4) + const amountToDeposit = to1e18(2) - // depositor deposits 3 tBTC including fee. + // depositor deposits 2 tBTC. await tbtc .connect(depositor1) .approve(await stbtc.getAddress(), amountToDeposit) @@ -1470,19 +1152,18 @@ describe("stBTC", () => { .connect(depositor1) .deposit(amountToDeposit, depositor1.address) - // Vault earns 2 tBTC. + // Vault earns 4 tBTC. await tbtc.mint(await stbtc.getAddress(), toMint) + await syncRewards() // The current state is: - // Total assets: 2 + 2.998500749625187406 (fee was taken) = 4.998500749625187406 - // Total supply: 2.998500749625187406 - // Maximum total assets: 30 - // Current max deposit: 25 - 4.998500749625187406 = 20.001499250374812594 + // Total assets: 4 + 2 = 6 + // Total supply: 2 + // Maximum total assets: 25 + // Current max deposit: 25 - 6 = 19 // Max stBTC shares: (mulDiv added 1 to totalSupply and totalAssets to help with floor rounding) - // 20.001499250374812594 * 2.998500749625187407 / 4.998500749625187407 = 11.998499850254836590 - // Internal calculation of _convertToShares in ERC4626 added 2 decimals - // to the result to help with rounding and division. - expectedValue = 11998499850254836590n + // 19 * 6 / 2 = 22 + expectedValue = 6333333333333333335n }) it("should return correct value", async () => { @@ -1529,31 +1210,12 @@ describe("stBTC", () => { }) }) - // Calculates the fee when it's included in the amount to deposit. - // One is added to the result if there is a remainder to match the Solidity - // mulDiv() math which rounds up towards infinity (Ceil) when fees are - // calculated. - function feeOnTotal(amount: bigint) { - const result = - (amount * entryFeeBasisPoints) / (entryFeeBasisPoints + basisPointScale) - if ( - (amount * entryFeeBasisPoints) % (entryFeeBasisPoints + basisPointScale) > - 0 - ) { - return result + 1n - } - return result - } - - // Calculates the fee when it's not included in the amount to deposit. - // One is added to the result if there is a remainder to match the Solidity - // mulDiv() math which rounds up towards infinity (Ceil) when fees are - // calculated. - function feeOnRaw(amount: bigint) { - const result = (amount * entryFeeBasisPoints) / basisPointScale - if ((amount * entryFeeBasisPoints) % basisPointScale > 0) { - return result + 1n - } - return result + async function syncRewards() { + // sync rewards + await stbtc.syncRewards() + const rewardsCycleEnd = await stbtc.rewardsCycleEnd() + await time.setNextBlockTimestamp(rewardsCycleEnd + rewardsCycleLength) + await mine(1) + await stbtc.syncRewards() } })