Datasets:

msc-smart-contract-auditing

/

vulnerable-functions-base

like 2

Follow

Smart Contract Auditing 3

On liquidation, if netPnLE36 <= 0, the premium paid by the liquidator is locked in the contract.

high

When liquidating a position, the liquidator is required to pay premium to Lender, which is accumulated in sharingProfitTokenAmts together with Lender's profit and paid to Lender in `_shareProfitsAndRepayAllDebts()`.\\n```\\n (\\n netPnLE36,\\n lenderProfitUSDValueE36,\\n borrowTotalUSDValueE36,\\n positionOpenUSDValueE36,\\n sharingProfitTokenAmts ) = calcProfitInfo(_positionManager, _user, _posId);\\n // 2. add liquidation premium to the shared profit amounts\\n uint lenderLiquidatationPremiumBPS = IConfig(config).lenderLiquidatePremiumBPS();\\n for (uint i; i < sharingProfitTokenAmts.length; ) {\\n sharingProfitTokenAmts[i] +=\\n (pos.openTokenInfos[i].borrowAmt * lenderLiquidatationPremiumBPS) / BPS;\\n unchecked {\\n ++i;\\n }\\n }\\n```\\n\\nHowever, if netPnLE36 <= 0, `_shareProfitsAndRepayAllDebts()` will not pay any profit to Lender and the premium in sharingProfitTokenAmts will also not be paid to Lender, which means that the premium paid by the liquidator will be locked in the contract.\\n```\\n function _shareProfitsAndRepayAllDebts( address _positionManager, address _posOwner, uint _posId,\\n int _netPnLE36, uint[] memory _shareProfitAmts, address[] memory _tokens,\\n OpenTokenInfo[] memory _openTokenInfos\\n ) internal {\\n // 0. load states\\n address _lendingProxy = lendingProxy;\\n // 1. if net pnl is positive, share profits to lending proxy\\n if (_netPnLE36 > 0) {\\n for (uint i; i < _shareProfitAmts.length; ) {\\n if (_shareProfitAmts[i] > 0) {\\n ILendingProxy(_lendingProxy).shareProfit(_tokens[i], _shareProfitAmts[i]);\\n }\\n unchecked {\\n ++i;\\n }\\n }\\n emit ProfitShared(_posOwner, _posId, _tokens, _shareProfitAmts);\\n }\\n```\\n\\nAlso, when the position is closed, the tokens in the contract will be sent to the caller, so the next person who closes the position will get the locked tokens.\\n```\\n underlyingAmts = new uint[](underlyingTokens.length);\\n for (uint i; i < underlyingTokens.length; ) {\\n underlyingAmts[i] = IERC20(underlyingTokens[i]).balanceOf(address(this));\\n if (underlyingAmts[i] < _params.minUnderlyingAmts[i]) {\\n revert TokenAmountLessThanExpected(\\n underlyingTokens[i],\\n underlyingAmts[i],\\n _params.minUnderlyingAmts[i]\\n );\\n }\\n _doRefund(underlyingTokens[i], underlyingAmts[i]);\\n unchecked {\\n ++i;\\n }\\n```\\n

Modify `shareProfitsAndRepayAllDebts()` as follows:\\n```\\n function _shareProfitsAndRepayAllDebts(\\n address _positionManager,\\n address _posOwner,\\n uint _posId,\\n int _netPnLE36,\\n uint[] memory _shareProfitAmts,\\n address[] memory _tokens,\\n OpenTokenInfo[] memory _openTokenInfos\\n ) internal {\\n // 0. load states\\n address _lendingProxy = lendingProxy;\\n // 1. if net pnl is positive, share profits to lending proxy\\n - if (_netPnLE36 > 0) {\\n for (uint i; i < _shareProfitAmts.length; ) {\\n if (_shareProfitAmts[i] > 0) {\\n ILendingProxy(_lendingProxy).shareProfit(_tokens[i], _shareProfitAmts[i]);\\n }\\n unchecked {\\n ++i;\\n }\\n }\\n emit ProfitShared(_posOwner, _posId, _tokens, _shareProfitAmts);\\n - }\\n```\\n

```\\n (\\n netPnLE36,\\n lenderProfitUSDValueE36,\\n borrowTotalUSDValueE36,\\n positionOpenUSDValueE36,\\n sharingProfitTokenAmts ) = calcProfitInfo(_positionManager, _user, _posId);\\n // 2. add liquidation premium to the shared profit amounts\\n uint lenderLiquidatationPremiumBPS = IConfig(config).lenderLiquidatePremiumBPS();\\n for (uint i; i < sharingProfitTokenAmts.length; ) {\\n sharingProfitTokenAmts[i] +=\\n (pos.openTokenInfos[i].borrowAmt * lenderLiquidatationPremiumBPS) / BPS;\\n unchecked {\\n ++i;\\n }\\n }\\n```\\n

The liquidated person can make the liquidator lose premium by adding collateral in advance

high

When the position with debtRatioE18 >= 1e18 or startLiqTimestamp ! = 0, the position can be liquidated. On liquidation, the liquidator needs to pay premium, but the profit is related to the position's health factor and deltaTime, and when discount == 0, the liquidator loses premium.\\n```\\n uint deltaTime;\\n // 1.1 check the amount of time since position is marked\\n if (pos.startLiqTimestamp > 0) {\\n deltaTime = Math.max(deltaTime, block.timestamp - pos.startLiqTimestamp);\\n }\\n // 1.2 check the amount of time since position is past the deadline\\n if (block.timestamp > pos.positionDeadline) {\\n deltaTime = Math.max(deltaTime, block.timestamp - pos.positionDeadline);\\n }\\n // 1.3 cap time-based discount, as configured\\n uint timeDiscountMultiplierE18 = Math.max(\\n IConfig(config).minLiquidateTimeDiscountMultiplierE18(),\\n ONE_E18 - deltaTime * IConfig(config).liquidateTimeDiscountGrowthRateE18()\\n );\\n // 2. calculate health-based discount factor\\n uint curHealthFactorE18 = (ONE_E18 * ONE_E18) /\\n getPositionDebtRatioE18(_positionManager, _user, _posId);\\n uint minDesiredHealthFactorE18 = IConfig(config).minDesiredHealthFactorE18s(strategy);\\n // 2.1 interpolate linear health discount factor (according to the diagram in documentation)\\n uint healthDiscountMultiplierE18 = ONE_E18;\\n if (curHealthFactorE18 < ONE_E18) {\\n healthDiscountMultiplierE18 = curHealthFactorE18 > minDesiredHealthFactorE18\\n ? ((curHealthFactorE18 - minDesiredHealthFactorE18) * ONE_E18) /\\n (ONE_E18 - minDesiredHealthFactorE18)\\n : 0;\\n }\\n // 3. final liquidation discount = apply the two discount methods together\\n liquidationDiscountMultiplierE18 =\\n (timeDiscountMultiplierE18 * healthDiscountMultiplierE18) /\\n ONE_E18;\\n```\\n\\nConsider the following scenario.\\nAlice notices Bob's position with debtRatioE18 >= 1e18 and calls `liquidatePosition()` to liquidate.\\nBob observes Alice's transaction, frontruns a call `markLiquidationStatus()` to make startLiqTimestamp == block.timestamp, and calls `adjustExtraColls()` to bring the position back to the health state.\\nAlice's transaction is executed, and since the startLiqTimestamp of Bob's position.startLiqTimestamp ! = 0, it can be liquidated, but since discount = 0, Alice loses premium. This breaks the protocol's liquidation mechanism and causes the liquidator not to launch liquidation for fear of losing assets, which will lead to more bad debts

Consider having the liquidated person bear the premium, or at least have the liquidator use the minDiscount parameter to set the minimum acceptable discount.

```\\n uint deltaTime;\\n // 1.1 check the amount of time since position is marked\\n if (pos.startLiqTimestamp > 0) {\\n deltaTime = Math.max(deltaTime, block.timestamp - pos.startLiqTimestamp);\\n }\\n // 1.2 check the amount of time since position is past the deadline\\n if (block.timestamp > pos.positionDeadline) {\\n deltaTime = Math.max(deltaTime, block.timestamp - pos.positionDeadline);\\n }\\n // 1.3 cap time-based discount, as configured\\n uint timeDiscountMultiplierE18 = Math.max(\\n IConfig(config).minLiquidateTimeDiscountMultiplierE18(),\\n ONE_E18 - deltaTime * IConfig(config).liquidateTimeDiscountGrowthRateE18()\\n );\\n // 2. calculate health-based discount factor\\n uint curHealthFactorE18 = (ONE_E18 * ONE_E18) /\\n getPositionDebtRatioE18(_positionManager, _user, _posId);\\n uint minDesiredHealthFactorE18 = IConfig(config).minDesiredHealthFactorE18s(strategy);\\n // 2.1 interpolate linear health discount factor (according to the diagram in documentation)\\n uint healthDiscountMultiplierE18 = ONE_E18;\\n if (curHealthFactorE18 < ONE_E18) {\\n healthDiscountMultiplierE18 = curHealthFactorE18 > minDesiredHealthFactorE18\\n ? ((curHealthFactorE18 - minDesiredHealthFactorE18) * ONE_E18) /\\n (ONE_E18 - minDesiredHealthFactorE18)\\n : 0;\\n }\\n // 3. final liquidation discount = apply the two discount methods together\\n liquidationDiscountMultiplierE18 =\\n (timeDiscountMultiplierE18 * healthDiscountMultiplierE18) /\\n ONE_E18;\\n```\\n

First depositor can steal asset tokens of others

high

The first depositor can be front run by an attacker and as a result will lose a considerable part of the assets provided. When the pool has no share supply, in `_mintInternal()`, the amount of shares to be minted is equal to the assets provided. An attacker can abuse of this situation and profit of the rounding down operation when calculating the amount of shares if the supply is non-zero.\\n```\\n function _mintInternal(address _receiver, uint _balanceIncreased, uint _totalAsset\\n ) internal returns (uint mintShares) {\\n unfreezeTime[_receiver] = block.timestamp + mintFreezeInterval;\\n if (freezeBuckets.interval > 0) {\\n FreezeBuckets.addToFreezeBuckets(freezeBuckets, _balanceIncreased.toUint96());\\n }\\n uint _totalSupply = totalSupply();\\n if (_totalAsset == 0 || _totalSupply == 0) {\\n mintShares = _balanceIncreased + _totalAsset;\\n } else {\\n mintShares = (_balanceIncreased * _totalSupply) / _totalAsset;\\n }\\n if (mintShares == 0) {\\n revert ZeroAmount();\\n }\\n _mint(_receiver, mintShares);\\n }\\n```\\n\\nConsider the following scenario.\\nAlice wants to deposit 2M * 1e6 USDC to a pool.\\nBob observes Alice's transaction, frontruns to deposit 1 wei USDC to mint 1 wei share, and transfers 1 M * 1e6 USDC to the pool.\\nAlice's transaction is executed, since _totalAsset = 1M * 1e6 + 1 and totalSupply = 1, Alice receives 2M * 1e6 * 1 / (1M * 1e6 + 1) = 1 share.\\nThe pool now has 3M*1e6 +1 assets and distributed 2 shares. Bob profits 0.5 M and Alice loses 0.5 M USDC.

When _totalSupply == 0, send the first min liquidity LP tokens to the zero address to enable share dilution Another option is to use the ERC4626 implementation(https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC4626.sol#L199C14-L208) from OZ.

```\\n function _mintInternal(address _receiver, uint _balanceIncreased, uint _totalAsset\\n ) internal returns (uint mintShares) {\\n unfreezeTime[_receiver] = block.timestamp + mintFreezeInterval;\\n if (freezeBuckets.interval > 0) {\\n FreezeBuckets.addToFreezeBuckets(freezeBuckets, _balanceIncreased.toUint96());\\n }\\n uint _totalSupply = totalSupply();\\n if (_totalAsset == 0 || _totalSupply == 0) {\\n mintShares = _balanceIncreased + _totalAsset;\\n } else {\\n mintShares = (_balanceIncreased * _totalSupply) / _totalAsset;\\n }\\n if (mintShares == 0) {\\n revert ZeroAmount();\\n }\\n _mint(_receiver, mintShares);\\n }\\n```\\n

The attacker can use larger dust when opening a position to perform griefing attacks

high

When opening a position, unused assets are sent to dustVault as dust, but since these dust are not subtracted from inputAmt, they are included in the calculation of positionOpenUSDValueE36, resulting in a small netPnLE36, which can be used by an attacker to perform a griefing attack.\\n```\\n uint inputTotalUSDValueE36;\\n for (uint i; i < openTokenInfos.length; ) {\\n inputTotalUSDValueE36 += openTokenInfos[i].inputAmt * tokenPriceE36s[i];\\n borrowTotalUSDValueE36 += openTokenInfos[i].borrowAmt * tokenPriceE36s[i];\\n unchecked {\\n ++i;\\n }\\n }\\n // 1.3 calculate net pnl (including strategy users & borrow profit)\\n positionOpenUSDValueE36 = inputTotalUSDValueE36 + borrowTotalUSDValueE36;\\n netPnLE36 = positionCurUSDValueE36.toInt256() - positionOpenUSDValueE36.toInt256();\\n```\\n

Consider subtracting dust from inputAmt when opening a position.

```\\n uint inputTotalUSDValueE36;\\n for (uint i; i < openTokenInfos.length; ) {\\n inputTotalUSDValueE36 += openTokenInfos[i].inputAmt * tokenPriceE36s[i];\\n borrowTotalUSDValueE36 += openTokenInfos[i].borrowAmt * tokenPriceE36s[i];\\n unchecked {\\n ++i;\\n }\\n }\\n // 1.3 calculate net pnl (including strategy users & borrow profit)\\n positionOpenUSDValueE36 = inputTotalUSDValueE36 + borrowTotalUSDValueE36;\\n netPnLE36 = positionCurUSDValueE36.toInt256() - positionOpenUSDValueE36.toInt256();\\n```\\n

An attacker can increase liquidity to the position's UniswapNFT to prevent the position from being closed

high

UniswapV3NPM allows the user to increase liquidity to any NFT.\\n```\\n function increaseLiquidity(IncreaseLiquidityParams calldata params)\\n external payable override checkDeadline(params.deadline)\\n returns (\\n uint128 liquidity, uint256 amount0, uint256 amount1)\\n {\\n Position storage position = _positions[params.tokenId];\\n PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];\\n IUniswapV3Pool pool;\\n (liquidity, amount0, amount1, pool) = addLiquidity(\\n```\\n\\nWhen closing a position, in `_redeemPosition()`, only the initial liquidity of the NFT will be decreased, and then the NFT will be burned.\\n```\\n function _redeemPosition(\\n address _user, uint _posId\\n ) internal override returns (address[] memory rewardTokens, uint[] memory rewardAmts) {\\n address _positionManager = positionManager;\\n uint128 collAmt = IUniswapV3PositionManager(_positionManager).getPositionCollAmt(_user, \\n _posId);\\n // 1. take lp & extra coll tokens from lending proxy\\n _takeAllCollTokens(_positionManager, _user, _posId, address(this));\\n UniV3ExtraPosInfo memory extraPosInfo = IUniswapV3PositionManager(_positionManager)\\n .getDecodedExtraPosInfo(_user, _posId);\\n address _uniswapV3NPM = uniswapV3NPM; // gas saving\\n // 2. remove underlying tokens from lp (internal remove in NPM)\\n IUniswapV3NPM(_uniswapV3NPM).decreaseLiquidity(\\n IUniswapV3NPM.DecreaseLiquidityParams({\\n tokenId: extraPosInfo.uniV3PositionId,liquidity: collAmt, amount0Min: 0,\\n amount1Min: 0,\\n deadline: block.timestamp\\n })\\n );\\n // rest of code\\n // 4. burn LP position\\n IUniswapV3NPM(_uniswapV3NPM).burn(extraPosInfo.uniV3PositionId);\\n }\\n```\\n\\nIf the liquidity of the NFT is not 0, burning will fail.\\n```\\n function burn(uint256 tokenId) external payable override isAuthorizedForToken(tokenId) {\\n Position storage position = _positions[tokenId];\\n require(position.liquidity == 0 && position.tokensOwed0 == 0 && position.tokensOwed1 == 0,'Not cleared');\\n delete _positions[tokenId];\\n _burn(tokenId);\\n }\\n```\\n\\nThis allows an attacker to add 1 wei liquidity to the position's NFT to prevent the position from being closed, and later when the position expires, the attacker can liquidate it.

Consider decreasing the actual liquidity(using uniswapV3NPM.positions to get it) of the NFT in `_redeemPosition()`, instead of the initial liquidity

```\\n function increaseLiquidity(IncreaseLiquidityParams calldata params)\\n external payable override checkDeadline(params.deadline)\\n returns (\\n uint128 liquidity, uint256 amount0, uint256 amount1)\\n {\\n Position storage position = _positions[params.tokenId];\\n PoolAddress.PoolKey memory poolKey = _poolIdToPoolKey[position.poolId];\\n IUniswapV3Pool pool;\\n (liquidity, amount0, amount1, pool) = addLiquidity(\\n```\\n

SwapHelper.getCalldata should check whitelistedRouters[_router]

medium

`SwapHelper.getCalldata()` returns data for swap based on the input, and uses whitelistedRouters to limit the _router param. The issue here is that when `setWhitelistedRouters()` sets the _routers state to false, it does not reset the data in routerTypes and swapInfos, which results in the router still being available in `getCalldata()`. As a result, users can still swap with invalid router data.\\n```\\n for (uint i; i < _statuses.length; ) {\\n whitelistedRouters[_routers[i]] = _statuses[i];\\n if (_statuses[i]) {\\n routerTypes[_routers[i]] = _types[i];\\n emit SetRouterType(_routers[i], _types[i]);\\n }\\n emit SetWhitelistedRouter(_routers[i], _statuses[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n```\\n

Consider checking whitelistedRouters[_router] in SwapHelper.getCalldata()

```\\n for (uint i; i < _statuses.length; ) {\\n whitelistedRouters[_routers[i]] = _statuses[i];\\n if (_statuses[i]) {\\n routerTypes[_routers[i]] = _types[i];\\n emit SetRouterType(_routers[i], _types[i]);\\n }\\n emit SetWhitelistedRouter(_routers[i], _statuses[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n```\\n

The swap when closing a position does not consider shareProfitAmts

medium

When closing a position, token swap is performed to ensure that the closer can repay the debt, for example, when operation == EXACT_IN, tokens of borrowAmt are required to be excluded from the swap, and when operation == EXACT_OUT, tokens of borrowAmt are required to be swapped. The issue here is that the closer needs to pay not only the borrowAmt but also the shareProfitAmts, which causes the closure to fail when percentSwapE18 = 100% due to insufficient tokens. Although the closer can adjust the percentSwapE18 to make the closure successful, it greatly increases the complexity.\\n```\\n for (uint i; i < swapParams.length; ) {\\n // find excess amount after repay\\n uint swapAmt = swapParams[i].operation == SwapOperation.EXACT_IN\\n ? IERC20(swapParams[i].tokenIn).balanceOf(address(this)) - openTokenInfos[i].borrowAmt\\n : openTokenInfos[i].borrowAmt - IERC20(swapParams[i].tokenOut).balanceOf(address(this));\\n swapAmt = (swapAmt * swapParams[i].percentSwapE18) / ONE_E18\\n if (swapAmt == 0) {\\n revert SwapZeroAmount();\\n }\\n```\\n

Consider taking shareProfitAmts into account when calculating swapAmt

```\\n for (uint i; i < swapParams.length; ) {\\n // find excess amount after repay\\n uint swapAmt = swapParams[i].operation == SwapOperation.EXACT_IN\\n ? IERC20(swapParams[i].tokenIn).balanceOf(address(this)) - openTokenInfos[i].borrowAmt\\n : openTokenInfos[i].borrowAmt - IERC20(swapParams[i].tokenOut).balanceOf(address(this));\\n swapAmt = (swapAmt * swapParams[i].percentSwapE18) / ONE_E18\\n if (swapAmt == 0) {\\n revert SwapZeroAmount();\\n }\\n```\\n

The freeze mechanism reduces the borrowableAmount, which reduces Lender's yield

medium

The contract has two freeze intervals, mintFreezeInterval and freezeBuckets.interval, the former to prevent users from making flash accesses and the latter to prevent borrowers from running out of funds. Both freeze intervals are applied when a user deposits, and due to the difference in unlocking time, it significantly reduces borrowableAmount and thus reduces Lender's yield.\\n```\\n function _mintInternal(address _receiver,uint _balanceIncreased, uint _totalAsset\\n ) internal returns (uint mintShares) {\\n unfreezeTime[_receiver] = block.timestamp + mintFreezeInterval;\\n if (freezeBuckets.interval > 0) {\\n FreezeBuckets.addToFreezeBuckets(freezeBuckets, _balanceIncreased.toUint96());\\n }\\n```\\n\\nConsider freezeBuckets.interval == mintFreezeInterval = 1 day, 100 ETH in the LendingPool, and borrowableAmount = 100 ETH. At day 0 + 1s, Alice deposits 50 ETH, borrowableAmount = 150 ETH**-** lockedAmount(50 ETH) = 100 ETH, the 50 ETH frozen in freezeBuckets will be unlocked on day 2, while unfreezeTime[alice] = day 1 + 1s. At day 1 + 1s, unfreezeTime[Alice] is reached, Alice can withdraw 50 ETH, borrowableAmount = 100 ETH - LockedAmount(50 ETH) = 50 ETH. If Bob wants to borrow the available funds in the Pool at this time, Bob can only borrow 50 ETH, while the available funds are actually 100 ETH, which will reduce Lender's yield by half. At day 2 + 1s, freezeBuckets is unfrozen and borrowableAmount = 100 ETH -LockedAmount(0 ETH) = 100 ETH.

Consider making mintFreezeInterval >= 2 * freezeBuckets.interval, which makes unfreezeTime greater than the unfreeze time of freezeBuckets.

```\\n function _mintInternal(address _receiver,uint _balanceIncreased, uint _totalAsset\\n ) internal returns (uint mintShares) {\\n unfreezeTime[_receiver] = block.timestamp + mintFreezeInterval;\\n if (freezeBuckets.interval > 0) {\\n FreezeBuckets.addToFreezeBuckets(freezeBuckets, _balanceIncreased.toUint96());\\n }\\n```\\n

A malicious operator can drain the vault funds in one transaction

high

The vault operator can swap tokens using the `trade()` function. They pass the following structure for each trade:\\n```\\n struct tradeInput { \\n address spendToken;\\n address receiveToken;\\n uint256 spendAmt;\\n uint256 receiveAmtMin;\\n address routerAddress;\\n uint256 pathIndex;\\n }\\n```\\n\\nNotably, receiveAmtMin is used to guarantee acceptable slippage. An operator can simply pass 0 to make sure the trade is executed. This allows an operator to steal all the funds in the vault by architecting a sandwich attack.\\nFlashloan a large amount of funds\\nSkew the token proportions in a pool which can be used for trading, by almost completely depleting the target token.\\nPerform the trade at >99% slippage\\nSell target tokens for source tokens on the manipulated pool, returning to the original ratio.\\nPay off the flashloan, and keep the tokens traded at 99% slippage. In fact, this attack can be done in one TX, different to most sandwich attacks.

The contract should enforce sensible slippage parameters.

```\\n struct tradeInput { \\n address spendToken;\\n address receiveToken;\\n uint256 spendAmt;\\n uint256 receiveAmtMin;\\n address routerAddress;\\n uint256 pathIndex;\\n }\\n```\\n

A malicious operator can steal all user deposits

high

In the Orbital architecture, each Vault user has a numerator which represents their share of the vault holdings. The denominator is by design the sum of all numerators of users, an invariant kept at deposits and withdrawals. For maximum precision, the denominator should be a very large value. Intuitively, numerators could be spread across different users without losing precision. The critical calculations occur in these lines in deposit():\\n```\\n if (D == 0) { //initial deposit\\n uint256 sumDenoms = 0; \\n for (uint256 i = 0; i < tkns.length; i++) {\\n sumDenoms += \\n AI.getAllowedTokenInfo(tkns[i]).initialDenominator;\\n }\\n require(sumDenoms > 0 && sumDenoms <= maxInitialDenominator, \\n "invalid sumDenoms");\\n deltaN = sumDenoms; //initial numerator and denominator are the \\n same, and are greater than any possible balance in the vault.\\n //this ensures precision in the vault's \\n balances. User Balance = (N*T)/D will have rounding errors always 1 \\n wei or less. \\n } else { \\n // deltaN = (amt * D)/T;\\n deltaN = Arithmetic.overflowResistantFraction(amt, D, T);\\n }\\n```\\n\\nIn the initial deposit, Vault sums all token initialDenominators to get the final denominator. It is assumed that the vault will never have this amount in total balances (each token denominator is worth around $100m dollars).\\nIn any other deposit, the deltaN (numerator) credited to the depositor is (denominator * deposit amount / existing balance). When denominator is huge, this calculation is highly precise. However, when denominator is 1, a serious issue oc**curs. If user's deposit amount is one wei smaller than existing balance, deltaN would be zero. This property has lead to the well-known ERC4626 inflation attack, where an attacker donates (sends directly to the contract) an amount so that the following deposit is consumed without any shares given to the user. In fact, it is possible to reduce the denominator to 1 and resurrect that attack. The root cause is that the initial deposit denominator is not linear to the deposit amount. Consider the attack flow below, done by a malicious operator:\\nDeploy an ETH/BTC pool\\nFlash loan $100mm in ETH and BTC each\\nPerform an initial deposit of $100mm in ETH/BTC\\nFrom another account, deposit 1 wei ETH / BTC -> receive 1 deltaN\\nWithdraw 100% as operator, reducing denominator to 1.\\nPay off flash loan\\nWait for victim deposits\\nWhen a deposit arrives at the mempool, frontrun with a donation of an equivalent amount. The victim will not receive any shares ( numerator).\\nAny future deposits can be frontran again. Any deposit of less than the current balance will be lost.

Consider checking that user's received deltaN is reasonable. Calculate the expected withdrawable value (deltaN / denominator * balance), and verify that is close enough to the deposited amount.

```\\n if (D == 0) { //initial deposit\\n uint256 sumDenoms = 0; \\n for (uint256 i = 0; i < tkns.length; i++) {\\n sumDenoms += \\n AI.getAllowedTokenInfo(tkns[i]).initialDenominator;\\n }\\n require(sumDenoms > 0 && sumDenoms <= maxInitialDenominator, \\n "invalid sumDenoms");\\n deltaN = sumDenoms; //initial numerator and denominator are the \\n same, and are greater than any possible balance in the vault.\\n //this ensures precision in the vault's \\n balances. User Balance = (N*T)/D will have rounding errors always 1 \\n wei or less. \\n } else { \\n // deltaN = (amt * D)/T;\\n deltaN = Arithmetic.overflowResistantFraction(amt, D, T);\\n }\\n```\\n

Removing a trade path in router will cause serious data corruption

medium

The RouterInfo represents a single UniV3-compatible router which supports a list of token paths. It uses the following data structures:\\n```\\n mapping(address => mapping(address => listInfo)) private allowedPairsMap;\\n pair[] private allowedPairsList;\\n```\\n\\n```\\n struct listInfo {\\n bool allowed;\\n uint256 listPosition;\\n }\\n struct pair {\\n address token0;\\n address token1;\\n uint256 numPathsAllowed;\\n }\\n```\\n\\nWhen an admin specifies a new path from token0 to token1, `_increasePairPaths()` is called.\\n```\\n function _increasePairPaths(address token0, address token1) private {\\n listInfo storage LI = allowedPairsMap[token0][token1];\\n if (!LI.allowed){\\n LI.allowed = true;\\n LI.listPosition = allowedPairsList.length;\\n allowedPairsList.push(pair(token0, token1, 0));\\n }\\n allowedPairsList[LI.listPosition].numPathsAllowed++;\\n }\\n```\\n\\nWhen a path is removed, the complementary function is called.\\n```\\n function _decreasePairPaths(address token0, address token1) private {\\n listInfo storage LI = allowedPairsMap[token0][token1];\\n require(LI.allowed, "RouterInfo: pair not allowed");\\n allowedPairsList[LI.listPosition].numPathsAllowed--;\\n if (allowedPairsList[LI.listPosition].numPathsAllowed == 0){\\n allowedPairsList[LI.listPosition] = \\n allowedPairsList[allowedPairsList.length - 1];\\n allowedPairsList.pop();\\n LI.allowed = false;\\n }\\n }\\n```\\n\\nWhen the last path is removed, the contract reuses the index of the removed pair, to store the last pair in the list. It then removes the last pair, having already copied it. The issue is that the corresponding listInfo structure is not updated, to keep track of index in the pairs list. Future usage of the last pair will use a wrong index, which at this moment, is over the array bounds. When a new pair will be created, it will share the index with the corrupted pair. This can cause a variety of serious issues. For example, it will not be possible to remove paths from the corrupted pair until a new pair is created, at which point the new pair will have a wrong numPathsAllowed as it is shared.

Update the listPosition member of the last pair in the list, before repositioning it.

```\\n mapping(address => mapping(address => listInfo)) private allowedPairsMap;\\n pair[] private allowedPairsList;\\n```\\n

Attacker can DOS deposit transactions due to strict verifications

medium

When users deposit funds to the Vault, it verifies that the proportion between the tokens inserted to the vault matches the current vault token balances.\\n```\\n uint256[] memory balances = vlt.balances();\\n //ensure deposits are in the same ratios as the vault's current balances\\n require(functions.ratiosMatch(balances, amts), "ratios don't match");\\n```\\n\\nThe essential part of the check is below:\\n```\\n for (uint256 i = 0; i < sourceRatios.length; i++) {\\n // if (targetRatios[i] != (targetRatios[greatestIndex] * \\n sourceRatios[i]) / greatest) {\\n if (targetRatios[i] != \\n Arithmetic.overflowResistantFraction(targetRatios[greatestIndex], sourceRatios[i], greatest)) {\\n return false;\\n }\\n }\\n```\\n\\nThe exact logic here is not important, but note that a small change in the balance of one of the vault tokens will affect the expected number of tokens that need to be inserted to maintain correct ratio. The exact amounts to be deposited are passed as targetRatios, and sourceRatios is the current balances. Therefore, an attacker can directly transfer a negligible amount of some vault token to the contract to make the amount the user specified in targetRatios not line up with the expected proportion. As a result, the deposit would revert. Essentially it is an abuse of the over-granular verification of ratios, leading to a DOS of any deposit in the mempool.

Loosen the restriction on deposit ratios. A DOS attack should cost an amount that the vault creditors would be happy to live with.

```\\n uint256[] memory balances = vlt.balances();\\n //ensure deposits are in the same ratios as the vault's current balances\\n require(functions.ratiosMatch(balances, amts), "ratios don't match");\\n```\\n

User deposits can fail despite using the correct method for calculation of deposit amounts

medium

Users can use the `getAmtsNeededForDeposit()` function to get the amount of tokens that maintain the desired proportion for vault deposits. It will perform a calculation very similar to the one in `ratiosMatch()`, which will verify the deposit.\\n```\\n for (uint256 i = 0; i < balances.length; i++) {\\n if (i == indexOfReferenceToken) {\\n amtsNeeded[i] = amtIn;\\n } else {\\n // amtsNeeded[i] = (amtIn * balances[i]) / \\n balances[indexOfReferenceToken];\\n amtsNeeded[i] = Arithmetic.overflowResistantFraction(amtIn, \\n balances[i], balances[indexOfReferenceToken]);\\n }\\n }\\n```\\n\\nHowever, a difference between the verification function and the getter function is that the getter receives any reference token, while the verification will use proportions based on the deposit amount in the largest balance in the vault. Indeed, these fractions may differ by a small amount. This could cause the `getAmtsNeededForDeposit()` function to respond with values which will not be accepted at deposit, since they will be rounded differently.

Calculation amounts needed using the ratio between largest balance and the deposit amount. This would line up the numbers as verification would expect.

```\\n for (uint256 i = 0; i < balances.length; i++) {\\n if (i == indexOfReferenceToken) {\\n amtsNeeded[i] = amtIn;\\n } else {\\n // amtsNeeded[i] = (amtIn * balances[i]) / \\n balances[indexOfReferenceToken];\\n amtsNeeded[i] = Arithmetic.overflowResistantFraction(amtIn, \\n balances[i], balances[indexOfReferenceToken]);\\n }\\n }\\n```\\n

Several popular ERC20 tokens are incompatible with the vault due to MAX approve

low

There are several instances where the vault approves use of funds to the manager or a trade router. It will set approval to MAX_UINT256.\\n```\\n for (uint i = 0; i < tokens.length; i++) {\\n //allow vault manager to withdraw tokens\\n IERC20(tokens[i]).safeIncreaseAllowance(ownerIn, \\n type(uint256).max); \\n }\\n```\\n\\nThe issue is that there are several popular tokens(https://github.com/d-xo/weird-erc20#revert-on-large-approvals--transfers) (UNI, COMP and others) which do not support allowances of above UINT_96. The contract will not be able to interoperate with them.

Consider setting allowance to UINT_96. Whenever the allowance is consumed, perform re-approval up to UINT_96.

```\\n for (uint i = 0; i < tokens.length; i++) {\\n //allow vault manager to withdraw tokens\\n IERC20(tokens[i]).safeIncreaseAllowance(ownerIn, \\n type(uint256).max); \\n }\\n```\\n

Attacker can freeze deposits and withdrawals indefinitely by submitting a bad withdrawal

high

Users request to queue a withdrawal using the function below in Vault.\\n```\\n function addWithdrawRequest(uint256 _amountMLP, address _token) external {\\n require(isAcceptingToken(_token), "ERROR: Invalid token");\\n require(_amountMLP != 0, "ERROR: Invalid amount");\\n \\n address _withdrawer = msg.sender;\\n // Get the pending buffer and staged buffer.\\n RequestBuffer storage _pendingBuffer = _requests(false);\\n RequestBuffer storage _stagedBuffer = _requests(true);\\n // Check if the withdrawer have enough balance to withdraw.\\n uint256 _bookedAmountMLP = _stagedBuffer.withdrawAmountPerUser[_withdrawer] + \\n _pendingBuffer.withdrawAmountPerUser[_withdrawer];\\n require(_bookedAmountMLP + _amountMLP <= \\n MozaicLP(mozLP).balanceOf(_withdrawer), "Withdraw amount > amount MLP");\\n …\\n emit WithdrawRequestAdded(_withdrawer, _token, chainId, _amountMLP);\\n }\\n```\\n\\nNotice that the function only validates that the user has a sufficient LP token balance to withdraw at the moment of execution. After it is queued up, a user can move their tokens to another wallet. Later in `_settleRequests()`, the Vault will attempt to burn user's tokens:\\n```\\n // Burn moazic LP token.\\n MozaicLP(mozLP).burn(request.user, _mlpToBurn);\\n```\\n\\nThis would revert and block any other settlements from occurring. Therefore, users can block the entire settlement process by requesting a tiny withdrawal amount in every epoch and moving funds to another wallet.

Vault should take custody of user's LP tokens when they request withdrawals. If the entire withdrawal cannot be satisfied, it can refund some tokens back to the user.

```\\n function addWithdrawRequest(uint256 _amountMLP, address _token) external {\\n require(isAcceptingToken(_token), "ERROR: Invalid token");\\n require(_amountMLP != 0, "ERROR: Invalid amount");\\n \\n address _withdrawer = msg.sender;\\n // Get the pending buffer and staged buffer.\\n RequestBuffer storage _pendingBuffer = _requests(false);\\n RequestBuffer storage _stagedBuffer = _requests(true);\\n // Check if the withdrawer have enough balance to withdraw.\\n uint256 _bookedAmountMLP = _stagedBuffer.withdrawAmountPerUser[_withdrawer] + \\n _pendingBuffer.withdrawAmountPerUser[_withdrawer];\\n require(_bookedAmountMLP + _amountMLP <= \\n MozaicLP(mozLP).balanceOf(_withdrawer), "Withdraw amount > amount MLP");\\n …\\n emit WithdrawRequestAdded(_withdrawer, _token, chainId, _amountMLP);\\n }\\n```\\n

Removal of Multisig members will corrupt data structures

medium

The Mozaic Multisig (the senate) can remove council members using the TYPE_DEL_OWNER operation:\\n```\\n if(proposals[_proposalId].actionType == TYPE_DEL_OWNER) {\\n (address _owner) = abi.decode(proposals[_proposalId].payload, (address));\\n require(contains(_owner) != 0, "Invalid owner address");\\n uint index = contains(_owner);\\n for (uint256 i = index; i < councilMembers.length - 1; i++) {\\n councilMembers[i] = councilMembers[i + 1];\\n }\\n councilMembers.pop();\\n proposals[_proposalId].executed = true;\\n isCouncil[_owner] = false;\\n }\\n```\\n\\nThe code finds the owner's index in the councilMembers array, copies all subsequent members downwards, and deletes the last element. Finally, it deletes the isCouncil[_owner] entry. The issue is actually in the contains() function.\\n```\\n function contains(address _owner) public view returns (uint) {\\n for (uint i = 1; i <= councilMembers.length; i++) {\\n if (councilMembers[i - 1] == _owner) {\\n return i;\\n }\\n }\\n return 0;\\n }\\n```\\n\\nThe function returns the index following the owner's index. Therefore, the intended owner is not deleted from councilMembers, instead the one after it is. The `submitProposal()` and `confirmTransaction()` privileged functions will not be affected by the bug, as they filter by isCouncil. However, the corruption of councilMembers will make deleting the member following the currently deleted owner fail, as deletion relies on finding the member in councilMembers.

Fix the `contains()` function to return the correct index of _owner

```\\n if(proposals[_proposalId].actionType == TYPE_DEL_OWNER) {\\n (address _owner) = abi.decode(proposals[_proposalId].payload, (address));\\n require(contains(_owner) != 0, "Invalid owner address");\\n uint index = contains(_owner);\\n for (uint256 i = index; i < councilMembers.length - 1; i++) {\\n councilMembers[i] = councilMembers[i + 1];\\n }\\n councilMembers.pop();\\n proposals[_proposalId].executed = true;\\n isCouncil[_owner] = false;\\n }\\n```\\n

Attacker could abuse victim's vote to pass their own proposal

medium

Proposals are created using submitProposal():\\n```\\n function submitProposal(uint8 _actionType, bytes memory _payload) public onlyCouncil {\\n uint256 proposalId = proposalCount;\\n proposals[proposalId] = Proposal(msg.sender,_actionType, \\n _payload, 0, false);\\n proposalCount += 1;\\n emit ProposalSubmitted(proposalId, msg.sender);\\n }\\n```\\n\\nAfter submission, council members approve them by calling confirmTransaction():\\n```\\n function confirmTransaction(uint256 _proposalId) public onlyCouncil \\n notConfirmed(_proposalId) {\\n confirmations[_proposalId][msg.sender] = true;\\n proposals[_proposalId].confirmation += 1;\\n emit Confirmation(_proposalId, msg.sender);\\n }\\n```\\n\\nNotably, the _proposalId passed to `confirmTransaction()` is simply the proposalCount at time of submission. This design allows the following scenario to occur:\\nUser A submits proposal P1\\nUser B is interested in the proposal and confirms it\\nAttacker submits proposal P2\\nA blockchain re-org occurs. Submission of P1 is dropped in place of P2.\\nUser B's confirmation is applied on top of the re-orged blockchain. Attacker gets their vote. We've seen very large re-orgs in top blockchains such as Polygon, so this threat remains a possibility to be aware of.

Calculate proposalId as a hash of the proposal properties. This way, votes cannot be misdirected.

```\\n function submitProposal(uint8 _actionType, bytes memory _payload) public onlyCouncil {\\n uint256 proposalId = proposalCount;\\n proposals[proposalId] = Proposal(msg.sender,_actionType, \\n _payload, 0, false);\\n proposalCount += 1;\\n emit ProposalSubmitted(proposalId, msg.sender);\\n }\\n```\\n

MozToken will have a much larger fixed supply than intended.

medium

MozToken is planned to be deployed on all supported chains. Its total supply will be 1B. However, its constructor will mint 1B tokens on each deployment.\\n```\\n constructor( address _layerZeroEndpoint, uint8 _sharedDecimals\\n ) OFTV2("Mozaic Token", "MOZ", _sharedDecimals, _layerZeroEndpoint) {\\n _mint(msg.sender, 1000000000 * 10 ** _sharedDecimals);\\n isAdmin[msg.sender] = true;\\n }\\n```\\n

Pass the minted supply as a parameter. Only on the main chain, mint 1B tokens.

```\\n constructor( address _layerZeroEndpoint, uint8 _sharedDecimals\\n ) OFTV2("Mozaic Token", "MOZ", _sharedDecimals, _layerZeroEndpoint) {\\n _mint(msg.sender, 1000000000 * 10 ** _sharedDecimals);\\n isAdmin[msg.sender] = true;\\n }\\n```\\n

Theoretical reentrancy attack when TYPE_MINT_BURN proposals are executed

low

The senate can pass a proposal to mint or burn tokens.\\n```\\n if(proposals[_proposalId].actionType == TYPE_MINT_BURN) {\\n (address _token, address _to, uint256 _amount, bool _flag) = \\n abi.decode(proposals[_proposalId].payload, (address, address, uint256, bool));\\n if(_flag) {\\n IXMozToken(_token).mint(_amount, _to);\\n } else {\\n IXMozToken(_token).burn(_amount, _to);\\n }\\n proposals[_proposalId].executed = true;\\n }\\n```\\n\\nNote that the proposal is only marked as executed at the end of execution, but execution is checked at the start of the function.\\n```\\n function execute(uint256 _proposalId) public onlyCouncil {\\n require(proposals[_proposalId].executed == false, "Error: \\n Proposal already executed.");\\n require(proposals[_proposalId].confirmation >= threshold, "Error: Not enough confirmations.");\\n```\\n\\nInteraction with tokens should generally be assumed to grant arbitrary call execution to users. If the mint or `burn()` calls call `execute()` again, the proposal will be executed twice, resulting in double the amount minted or burned. Specifically for XMoz, it is not anticipated to yield execution to the to address, so the threat remains theoretical.

Follow the Check-Effects-Interactions design pattern, mark the function as executed at the start.

```\\n if(proposals[_proposalId].actionType == TYPE_MINT_BURN) {\\n (address _token, address _to, uint256 _amount, bool _flag) = \\n abi.decode(proposals[_proposalId].payload, (address, address, uint256, bool));\\n if(_flag) {\\n IXMozToken(_token).mint(_amount, _to);\\n } else {\\n IXMozToken(_token).burn(_amount, _to);\\n }\\n proposals[_proposalId].executed = true;\\n }\\n```\\n

XMozToken permits transfers from non-whitelisted addresses

low

The XMozToken is documented to forbid transfers except from whitelisted addresses or mints.\\n```\\n /**\\n * @dev Hook override to forbid transfers except from whitelisted \\n addresses and minting\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 \\n /*amount*/) internal view override {\\n require(from == address(0) || _transferWhitelist.contains(from) \\n || _transferWhitelist.contains(to), "transfer: not allowed");\\n }\\n```\\n\\nHowever, as can be seen, non-whitelisted users can still transfer tokens, so long as it is to whitelisted destinations.

Remove the additional check in `_beforeTokenTransfer()`, or update the documentation accordingly.

```\\n /**\\n * @dev Hook override to forbid transfers except from whitelisted \\n addresses and minting\\n */\\n function _beforeTokenTransfer(address from, address to, uint256 \\n /*amount*/) internal view override {\\n require(from == address(0) || _transferWhitelist.contains(from) \\n || _transferWhitelist.contains(to), "transfer: not allowed");\\n }\\n```\\n

XMozToken cannot be added to its own whitelist

low

By design, XMozToken should always be in the whitelist. However, `updateTransferWhitelist()` implementation forbids both removal and insertion of XMozToken to the whitelist.\\n```\\n function updateTransferWhitelist(address account, bool add) external onlyMultiSigAdmin {\\n require(account != address(this), "updateTransferWhitelist: \\n Cannot remove xMoz from whitelist");\\n if(add) _transferWhitelist.add(account);\\n else _transferWhitelist.remove(account);\\n emit SetTransferWhitelist(account, add);\\n }\\n```\\n

Move the require statement into the else clause.

```\\n function updateTransferWhitelist(address account, bool add) external onlyMultiSigAdmin {\\n require(account != address(this), "updateTransferWhitelist: \\n Cannot remove xMoz from whitelist");\\n if(add) _transferWhitelist.add(account);\\n else _transferWhitelist.remove(account);\\n emit SetTransferWhitelist(account, add);\\n }\\n```\\n

User fee token balance can be drained in a single operation by a malicious bot

high

In `_buildFeeExecutable()`, BrahRouter calculates the total fee charged to the wallet. It uses tx. gas price to get the gas price specified by the bot.\\n```\\n if (feeToken == ETH) \\n {uint256 totalFee = (gasUsed + GAS_OVERHEAD_NATIVE) * tx.gasprice;\\n totalFee = _applyMultiplier(totalFee);\\n return (totalFee, recipient, TokenTransfer._nativeTransferExec(recipient, totalFee));\\n } else {uint256 totalFee = (gasUsed + GAS_OVERHEAD_ERC20) * tx.gasprice;\\n // Convert fee amount value in fee tokenuint256 feeToCollect =PriceFeedManager(_addressProvider.priceFeedManager()).getTokenXPriceInY(totalFee, ETH, feeToken);\\n feeToCollect = _applyMultiplier(feeToCollect);\\n return (feeToCollect, recipient, TokenTransfer._erc20TransferExec(feeToken, recipient, feeToCollect));}\\n```\\n

Use a gas oracle or a capped priority fee to ensure an inflated gas price down not harm the user.

```\\n if (feeToken == ETH) \\n {uint256 totalFee = (gasUsed + GAS_OVERHEAD_NATIVE) * tx.gasprice;\\n totalFee = _applyMultiplier(totalFee);\\n return (totalFee, recipient, TokenTransfer._nativeTransferExec(recipient, totalFee));\\n } else {uint256 totalFee = (gasUsed + GAS_OVERHEAD_ERC20) * tx.gasprice;\\n // Convert fee amount value in fee tokenuint256 feeToCollect =PriceFeedManager(_addressProvider.priceFeedManager()).getTokenXPriceInY(totalFee, ETH, feeToken);\\n feeToCollect = _applyMultiplier(feeToCollect);\\n return (feeToCollect, recipient, TokenTransfer._erc20TransferExec(feeToken, recipient, feeToCollect));}\\n```\\n

Users can drain Gelato deposit at little cost

high

In Console automation, fees are collected via the `claimExecutionFees()` modifier:\\n```\\n modifier claimExecutionFees(address _wallet) {\\n uint256 startGas = gasleft();\\n _;\\n if (feeMultiplier > 0) {\\n address feeToken = FeePayer._feeToken(_wallet);\\n uint256 gasUsed = startGas -gasleft();\\n (uint256 feeAmount, address recipient, Types.Executable memory feeTransferTxn)=FeePayer._buildFeeExecutable\\n (gasUsed, feeToken);\\n emit FeeClaimed(_wallet, feeToken, feeAmount);\\n if (feeToken != ETH) {uint256 initialBalance = IERC20(feeToken).balanceOf(recipient);_\\n executeSafeERC20Transfer(_wallet, feeTransferTxn);\\n if (IERC20(feeToken).balanceOf(recipient) -initialBalance < feeAmount){\\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);}\\n } else {\\n uint256 initialBalance = recipient.balance;\\n Executor._executeOnWallet(_wallet, feeTransferTxn);\\n if (recipient.balance -initialBalance < feeAmount) {\\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);\\n }\\n }\\n }\\n }\\n```\\n

When calculating fees in buildFeeExecutable(), there are assumptions about the gas cost of an ERC20 transfer and a native transfer.\\n```\\n // Keeper network overhead -150k\\n uint256 internal constant GAS_OVERHEAD_NATIVE = 150_000 + 40_000;\\n uint256 internal constant GAS_OVERHEAD_ERC20 = 150_000 + 90_000;\\n```\\n\\nA good fix would be to check the actual gas usage and require it to be under the hard cap.Team responseAdded a gas check for this attack.Mitigation reviewApplied fix has been applied.

```\\n modifier claimExecutionFees(address _wallet) {\\n uint256 startGas = gasleft();\\n _;\\n if (feeMultiplier > 0) {\\n address feeToken = FeePayer._feeToken(_wallet);\\n uint256 gasUsed = startGas -gasleft();\\n (uint256 feeAmount, address recipient, Types.Executable memory feeTransferTxn)=FeePayer._buildFeeExecutable\\n (gasUsed, feeToken);\\n emit FeeClaimed(_wallet, feeToken, feeAmount);\\n if (feeToken != ETH) {uint256 initialBalance = IERC20(feeToken).balanceOf(recipient);_\\n executeSafeERC20Transfer(_wallet, feeTransferTxn);\\n if (IERC20(feeToken).balanceOf(recipient) -initialBalance < feeAmount){\\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);}\\n } else {\\n uint256 initialBalance = recipient.balance;\\n Executor._executeOnWallet(_wallet, feeTransferTxn);\\n if (recipient.balance -initialBalance < feeAmount) {\\n revert UnsuccessfulFeeTransfer(_wallet, feeToken);\\n }\\n }\\n }\\n }\\n```\\n

Attackers can drain users over time by donating negligible ERC20 amount

high

In the Console automation model, a strategy shall keep executing until its trigger check fails. For DCA strategies, the swapping trigger is defined as:\\n```\\n function canInitSwap(address subAccount, address inputToken, uint256 interval, uint256 lastSwap)\\n external view returns (bool)\\n {\\n if (hasZeroBalance(subAccount, inputToken)) \\n { return false;\\n }\\n return ((lastSwap + interval) < block.timestamp);\\n }\\n```\\n

Define a DUST_AMOUNT, below that amount exit is allowed, while above that amount swap execution is allowed. User should only stand to gain from another party donating ERC20 tokens to their account.

```\\n function canInitSwap(address subAccount, address inputToken, uint256 interval, uint256 lastSwap)\\n external view returns (bool)\\n {\\n if (hasZeroBalance(subAccount, inputToken)) \\n { return false;\\n }\\n return ((lastSwap + interval) < block.timestamp);\\n }\\n```\\n

When FeePayer is subsidizing, users can steal gas

medium

```\\nThe feeMultiplier enables the admin to subsidize or upcharge for the automation service.\\n/**\\n⦁ @notice feeMultiplier represents the total fee to be charged on the transaction\\n⦁ Is set to 100% by default\\n⦁ @dev In case feeMultiplier is less than BASE_BPS, fees charged will be less than 100%,\\n⦁ subsidizing the transaction\\n⦁ In case feeMultiplier is greater than BASE_BPS, fees charged will be greater than 100%,\\n⦁ charging the user for the transaction\\n*/ \\n uint16 public feeMultiplier = 10_000;\\n // The normal fee is calculated and then processed by the multiplier.\\n if (feeToken == ETH) {\\n uint256 totalFee = (gasUsed + GAS_OVERHEAD_NATIVE) * tx.gasprice; \\n totalFee = _applyMultiplier(totalFee);\\n return (totalFee, recipient, TokenTransfer._nativeTransferExec(recipient, totalFee));\\n } else {\\n```\\n

The root cause is that the gasUsed amount is subsidized as well as GAS_OVERHEAD_NATIVE, which is the gas reserved for the delivery from Gelato executors. By subsidizing only the Gelato gas portion, users will not gain from gas minting attacks, while the intention of improving user experience is maintained.

```\\nThe feeMultiplier enables the admin to subsidize or upcharge for the automation service.\\n/**\\n⦁ @notice feeMultiplier represents the total fee to be charged on the transaction\\n⦁ Is set to 100% by default\\n⦁ @dev In case feeMultiplier is less than BASE_BPS, fees charged will be less than 100%,\\n⦁ subsidizing the transaction\\n⦁ In case feeMultiplier is greater than BASE_BPS, fees charged will be greater than 100%,\\n⦁ charging the user for the transaction\\n*/ \\n uint16 public feeMultiplier = 10_000;\\n // The normal fee is calculated and then processed by the multiplier.\\n if (feeToken == ETH) {\\n uint256 totalFee = (gasUsed + GAS_OVERHEAD_NATIVE) * tx.gasprice; \\n totalFee = _applyMultiplier(totalFee);\\n return (totalFee, recipient, TokenTransfer._nativeTransferExec(recipient, totalFee));\\n } else {\\n```\\n

Strategy actions could be executed out of order due to lack of reentrancy guard

medium

The Execute module performs automation of the fetched Executable array on wallet subaccounts.\\n```\\n function _executeAutomation( address _wallet, address _subAccount, address _strategy,\\n Types.Executable[] memory _actionExecs ) internal {\\n uint256 actionLen = _actionExecs.length;\\n if (actionLen == 0) {\\n revert InvalidActions();\\n } else {\\n uint256 idx = 0;\\n do {\\n _executeOnSubAccount(_wallet, _subAccount, _strategy,\\n _actionExecs[idx]);\\n unchecked {\\n ++idx;\\n }\\n } while (idx < actionLen);\\n }\\n }\\n```\\n

Add a reentrancy guard for `executeAutomationViaBot()` and `executeTrustedAutomation()`.

```\\n function _executeAutomation( address _wallet, address _subAccount, address _strategy,\\n Types.Executable[] memory _actionExecs ) internal {\\n uint256 actionLen = _actionExecs.length;\\n if (actionLen == 0) {\\n revert InvalidActions();\\n } else {\\n uint256 idx = 0;\\n do {\\n _executeOnSubAccount(_wallet, _subAccount, _strategy,\\n _actionExecs[idx]);\\n unchecked {\\n ++idx;\\n }\\n } while (idx < actionLen);\\n }\\n }\\n```\\n

Anyone can make creating strategies extremely expensive for the user

medium

In Console architecture, users can deploy spare subaccounts (Gnosis Safes) so that when they will subscribe to a strategy most of the gas spending would have been spent at a low-gas phase.\\n```\\n function deploySpareSubAccount(address _wallet) external { address subAccount =\\n SafeDeployer(addressProvider.safeDeployer()).deploySubAccount(_wallet);\\n subAccountToWalletMap[subAccount] = _wallet; walletToSubAccountMap[_wallet].push(subAccount);\\n // No need to update subAccountStatus as it is already set to false\\n emit SubAccountAllocated(_wallet, subAccount);\\n }\\n```\\n\\nImpact The issue is that anyone can call the deploy function and specify another user's wallet. While on the surface that sounds like donating gas costs, in practice this functionality can make operating with strategies prohibitively expensive. When users will subscribe to strategies, the StrategyRegistry will request a subaccount using this function:\\n```\\n function requestSubAccount(address _wallet) external returns (address) {\\n if (msg.sender != subscriptionRegistry) \\n revert OnlySubscriptionRegistryCallable();\\n // Try to find a subAccount which already exists\\n address[] memory subAccountList = walletToSubAccountMap[_wallet];\\n```\\n\\nAt this point, the entire subaccount array will be copied from storage to memory. Therefore, attackers can fill the array with hundreds of elements at a low-gas time and make creation of strategies very difficult.

Limit the amount of spare subaccount to something reasonable, like 10 Team Response: Removing the spare subaccount deployment Mitigation review: Attack surface has been removed.

```\\n function deploySpareSubAccount(address _wallet) external { address subAccount =\\n SafeDeployer(addressProvider.safeDeployer()).deploySubAccount(_wallet);\\n subAccountToWalletMap[subAccount] = _wallet; walletToSubAccountMap[_wallet].push(subAccount);\\n // No need to update subAccountStatus as it is already set to false\\n emit SubAccountAllocated(_wallet, subAccount);\\n }\\n```\\n

DCA Strategies build orders that may not be executable, wasting fees

medium

In `_buildInitiateSwapExecutable()`, DCA strategies determine the swap parameters for the CoW Swap. The code has recently been refactored so that there may be more than one active order simultaneously. The issue is that the function assumes the user's entire ERC20 balance to be available for the order being built.\\n```\\n // Check if enough balance present to swap, else swap entire balance\\n uint256 amountIn = (inputTokenBalance < params.amountToSwap) ? \\n inputTokenBalance : params.amountToSwap;\\n```\\n\\nImpact This is a problem because if the previous order will be executed before the current order, there may not be enough funds to pull from the user to execute the swap. As a result, transaction execution fees are wasted.

Ensure only one swap can be in-flight at a time, or deduct the in-flight swap amounts from the current balance.

```\\n // Check if enough balance present to swap, else swap entire balance\\n uint256 amountIn = (inputTokenBalance < params.amountToSwap) ? \\n inputTokenBalance : params.amountToSwap;\\n```\\n

User will lose all Console functionality when upgrading their wallet and an upgrade target has not been set up

medium

Console supports upgrading of the manager wallet using the `upgradeWalletType()` function.\\n```\\n function upgradeWalletType() external {\\n if (!isWallet(msg.sender)) \\n revert WalletDoesntExist(msg.sender); uint8 fromWalletType = _walletDataMap[msg.sender].walletType;\\n _setWalletType(msg.sender, _upgradablePaths[fromWalletType]);\\n emit WalletUpgraded(msg.sender, fromWalletType,\\n _upgradablePaths[fromWalletType]);\\n }\\n```\\n\\nNote that upgradablePaths are set by governance. There is a lack of check that the upgradable path is defined before performing the upgrade.\\n```\\n function _setWalletType(address _wallet, uint8 _walletType) private {\\n _walletDataMap[_wallet].walletType = _walletType;\\n }\\n```\\n\\nIf _upgradablePaths[fromWalletType] is zero (uninitialized), the user's wallet type shall become zero too. However, zero is an invalid value, as defined by the isWallet() view function:\\n```\\n function isWallet(address _wallet) public view returns (bool) \\n { WalletData memory walletData = _walletDataMap[_wallet];\\n if (walletData.walletType == 0 || walletData.feeToken == address(0)){\\n return false;\\n }\\n return true;\\n }\\n```\\n\\nImpact As a result, most of the functionality of Console is permanently broken when users upgrade their wallet when an upgrade path isn't set. They can salvage their funds if it is a Safe account, as they can still execute on it directly.

When settings a new wallet type, make sure the new type is not zero.

```\\n function upgradeWalletType() external {\\n if (!isWallet(msg.sender)) \\n revert WalletDoesntExist(msg.sender); uint8 fromWalletType = _walletDataMap[msg.sender].walletType;\\n _setWalletType(msg.sender, _upgradablePaths[fromWalletType]);\\n emit WalletUpgraded(msg.sender, fromWalletType,\\n _upgradablePaths[fromWalletType]);\\n }\\n```\\n

Rounding error causes an additional iteration of DCA strategies

low

Both CoW strategies receive an interval and total amountIn of tokens to swap. They calculate the amount per iteration as below:\\n```\\n Types.TokenRequest[] memory tokens = new Types.TokenRequest[](1); \\n tokens[0] = Types.TokenRequest({token: inputToken, amount: amountIn});\\n amountIn = amountIn / iterations;\\n StrategyParams memory params = StrategyParams({ tokenIn: inputToken,\\n tokenOut: outputToken, amountToSwap: amountIn, interval: interval, remitToOwner: remitToOwner\\n });\\n```\\n

Change the amount requested from the management wallet to amountIn / iterations * iterations.

```\\n Types.TokenRequest[] memory tokens = new Types.TokenRequest[](1); \\n tokens[0] = Types.TokenRequest({token: inputToken, amount: amountIn});\\n amountIn = amountIn / iterations;\\n StrategyParams memory params = StrategyParams({ tokenIn: inputToken,\\n tokenOut: outputToken, amountToSwap: amountIn, interval: interval, remitToOwner: remitToOwner\\n });\\n```\\n

Fee mismatch between contracts can make strategies unusable

low

In CoW Swap strategies, fee is set in the strategy contracts and then passed to `initiateSwap()`. It is built in _buildInitiateSwapExecutable():\\n```\\n // Generate executable to initiate swap on DCACoWAutomation return Types.Executable({\\n callType: Types.CallType.DELEGATECALL, target: dcaCoWAutomation,\\n value: 0,\\n data: abi.encodeCall( DCACoWAutomation.initiateSwap,\\n (params.tokenIn, params.tokenOut, swapRecipient, amountIn, minAmountOut, swapFee)\\n )\\n });\\n```\\n\\nThere is a mismatch between the constraints around fees between the strategy contracts and the `initiateSwap()` function:\\n```\\n function setSwapFee(uint256 _swapFee) external {\\n _onlyGov();\\n if (_swapFee > 10_000) { revert InvalidSlippage();\\n }\\n swapFee = _swapFee;\\n }\\n if (feeBps > 0) {\\n if (feeBps > 1_000) revert FeeTooHigh();\\n amountIn = amountToSwap * (MAX_BPS - feeBps) / MAX_BPS;\\n```\\n

Enforce the same constraints on the fee percentage in both contracts, or remove the check from one of them as part of a simplified security model.

```\\n // Generate executable to initiate swap on DCACoWAutomation return Types.Executable({\\n callType: Types.CallType.DELEGATECALL, target: dcaCoWAutomation,\\n value: 0,\\n data: abi.encodeCall( DCACoWAutomation.initiateSwap,\\n (params.tokenIn, params.tokenOut, swapRecipient, amountIn, minAmountOut, swapFee)\\n )\\n });\\n```\\n

Reentrancy protection can likely be bypassed

high

The KeyManager offers reentrancy protection for interactions with the associated account. Through the LSP20 callbacks or through the `execute()` calls, it will call `_nonReentrantBefore()` before execution, and `_nonReentrantAfter()` post-execution. The latter will always reset the flag signaling entry.\\n```\\n function _nonReentrantAfter() internal virtual {\\n // By storing the original value once again, a refund is triggered \\n (see // https://eips.ethereum.org/EIPS/eip-2200)\\n _reentrancyStatus = false;\\n }\\n```\\n\\nAn attacker can abuse it to reenter provided that there exists some third-party contract with REENTRANCY_PERMISSION that performs some interaction with the contract. The attacker would trigger the third-party code path, which will clear the reentrancy status, and enable attacker to reenter. This could potentially be chained several times. Breaking the reentrancy assumption would make code that assumes such flows to be impossible to now be vulnerable.

In `_nonReentrantAfter()`, the flag should be returned to the original value before reentry, rather than always setting it to false.

```\\n function _nonReentrantAfter() internal virtual {\\n // By storing the original value once again, a refund is triggered \\n (see // https://eips.ethereum.org/EIPS/eip-2200)\\n _reentrancyStatus = false;\\n }\\n```\\n

LSP20 verification library deviates from spec and will accept fail values

medium

The functions `lsp20VerifyCall()` and `lsp20VerifyCallResult()` are called to validate the owner accepts some account interaction. The specification states they must return a specific 4 byte magic value. However, the implementation will accept any byte array that starts with the required magic value.\\n```\\n function _verifyCall(address logicVerifier) internal virtual returns (bool verifyAfter) {\\n (bool success, bytes memory returnedData) = logicVerifier.call(\\n abi.encodeWithSelector(ILSP20.lsp20VerifyCall.selector, msg.sender, msg.value, msg.data)\\n );\\n if (!success) _revert(false, returnedData);\\n if (returnedData.length < 32) revert \\n LSP20InvalidMagicValue(false, returnedData);\\n bytes32 magicValue = abi.decode(returnedData, (bytes32));\\n if (bytes3(magicValue) != \\n bytes3(ILSP20.lsp20VerifyCall.selector))\\n revert LSP20InvalidMagicValue(false, returnedData);\\n return bytes1(magicValue[3]) == 0x01 ? true : false;\\n }\\n```\\n\\nTherefore, implementations of the above functions which intend to signal failure status may be accepted by the verification wrapper above.

Verify that the return data length is 32 bytes (the 4 bytes are extended by the compiler), and that all other bytes are zero.

```\\n function _verifyCall(address logicVerifier) internal virtual returns (bool verifyAfter) {\\n (bool success, bytes memory returnedData) = logicVerifier.call(\\n abi.encodeWithSelector(ILSP20.lsp20VerifyCall.selector, msg.sender, msg.value, msg.data)\\n );\\n if (!success) _revert(false, returnedData);\\n if (returnedData.length < 32) revert \\n LSP20InvalidMagicValue(false, returnedData);\\n bytes32 magicValue = abi.decode(returnedData, (bytes32));\\n if (bytes3(magicValue) != \\n bytes3(ILSP20.lsp20VerifyCall.selector))\\n revert LSP20InvalidMagicValue(false, returnedData);\\n return bytes1(magicValue[3]) == 0x01 ? true : false;\\n }\\n```\\n

Deviation from spec will result in dislocation of receiver delegate

medium

The LSP0 `universalReceiver()` function looks up the receiver delegate by crafting a mapping key type.\\n```\\n bytes32 lsp1typeIdDelegateKey = LSP2Utils.generateMappingKey(\\n _LSP1_UNIVERSAL_RECEIVER_DELEGATE_PREFIX, bytes20(typeId));\\n```\\n\\nMapping keys are constructed of a 10-byte prefix, 2 zero bytes and a 20-byte suffix. However, followers of the specification will use an incorrect suffix. The docs do not discuss the trimming of bytes32 into a bytes20 type. The mismatch may cause various harmful scenarios when interacting with the delegate not using the reference implementation.

Document the trimming action in the LSP0 specification.

```\\n bytes32 lsp1typeIdDelegateKey = LSP2Utils.generateMappingKey(\\n _LSP1_UNIVERSAL_RECEIVER_DELEGATE_PREFIX, bytes20(typeId));\\n```\\n

KeyManager ERC165 does not support LSP20

medium

LSP6KeyManager supports LSP20 call verification. However, in `supportInterface()` it does not return the LSP20 interfaceId.\\n```\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return\\n interfaceId == _INTERFACEID_LSP6 || interfaceId == _INTERFACEID_ERC1271 ||\\n super.supportsInterface(interfaceId);\\n }\\n```\\n\\nAs a result, clients which correctly check for support of LSP20 methods will not operate with the KeyManager implementation.

Insert another supported interfaceId under `supportsInterface()`.

```\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return\\n interfaceId == _INTERFACEID_LSP6 || interfaceId == _INTERFACEID_ERC1271 ||\\n super.supportsInterface(interfaceId);\\n }\\n```\\n

LSP0 ownership functions deviate from specification and reject native tokens

low

The LSP specifications define the following functions for LSP0:\\n```\\n function transferOwnership(address newPendingOwner) external payable;\\n function renounceOwnership() external payable;\\n```\\n\\nHowever, their implementations are not payable.\\n```\\n function transferOwnership(address newOwner) public virtual\\n override(LSP14Ownable2Step, OwnableUnset)\\n {\\n```\\n\\n```\\n function renounceOwnership() public virtual override(LSP14Ownable2Step, OwnableUnset) {\\n address _owner = owner();\\n```\\n\\nThis may break interoperation between conforming and non-confirming contracts.

Remove the payable keyword in the specification for the above functions, or make the implementations payable

```\\n function transferOwnership(address newPendingOwner) external payable;\\n function renounceOwnership() external payable;\\n```\\n

Transfers of vaults from an invalid source are not treated correctly by receiver delegate

low

In the universalReceiver() function, if the notifying contract does not support LSP9, yet the typeID corresponds to an LSP9 transfer, the function will return instead of reverting.\\n```\\n if (\\n mapPrefix == _LSP10_VAULTS_MAP_KEY_PREFIX && notifier.code.length > 0 &&\\n !notifier.supportsERC165InterfaceUnchecked(_INTERFACEID_LSP9)\\n ) {\\n return "LSP1: not an LSP9Vault ownership transfer";\\n }\\n```\\n

Revert when dealing with transfers that cannot be valid.

```\\n if (\\n mapPrefix == _LSP10_VAULTS_MAP_KEY_PREFIX && notifier.code.length > 0 &&\\n !notifier.supportsERC165InterfaceUnchecked(_INTERFACEID_LSP9)\\n ) {\\n return "LSP1: not an LSP9Vault ownership transfer";\\n }\\n```\\n

Relayer can choose amount of gas for delivery of message

low

LSP6 supports relaying of calls using a supplied signature. The encoded message is defined as:\\n```\\n bytes memory encodedMessage = abi.encodePacked( LSP6_VERSION,\\n block.chainid,\\n nonce,\\n msgValue,\\n payload\\n );\\n```\\n\\nThe message doesn't include a gas parameter, which means the relayer can specify any gas amount. If the provided gas is insufficient, the entire transaction will revert. However, if the called contract exhibits different behavior depending on the supplied gas, a relayer (attacker) has control over that behavior.

Signed message should include the gas amount passed. Care should be taken to verify there is enough gas in the current state for the gas amount not to be truncated due to the 63/64 rule.

```\\n bytes memory encodedMessage = abi.encodePacked( LSP6_VERSION,\\n block.chainid,\\n nonce,\\n msgValue,\\n payload\\n );\\n```\\n

_calculateClaim() does not distribute boost emissions correctly

high

The function `_calculateClaim()` is responsible for the calculations of the amount of emissions a specific veSatin is entitled to claim. The idea is to distribute emissions only to veSatin tokens locked for more than minLockDurationForReward and only for the extra time the veSatin is locked for on top of minLockDurationForReward. As an example, if minLockDurationForReward is set to 6 months a veSatin locked for 7 months would receive emissions for 1 month and a veSatin locked for 5 months would receive no emissions at all. To do so the following code is executed in a loop, where every loop calculates the amount of emissions the veSatin accumulated during a specific week, in chronological order:\\n```\\n if ((lockEndTime - oldUserPoint.ts) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n\\nThe code distributes the rewards if the elapsed time between lockEndTime (the locking end timestamp) and oldUserPoint.ts is bigger than minLockDurationForReward. However, oldUserPoint.ts is the timestamp of the last user action on a veSatin, for example depositing LP by calling `increaseAmount()`. As an example, a user that locks his veSatin and does nothing else will receive rewards for the whole locking duration. In contrast, a user that performs one action a week would only receive rewards for the locking duration minus minLockDurationForReward

The variable weekCursor should be used instead of oldUserPoint.ts in the if condition:\\n```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n```\\n

```\\n if ((lockEndTime - oldUserPoint.ts) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n

Users will be unable to claim emissions from veSatin tokens if they withdraw it or merge it

high

The function `_calculateClaim()` uses the variable lockEndTime when checking if a veSatin is entitled to emissions for a particular week (code with mitigation from TRST-H-1):\\n```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n\\nHowever lockEndTime is set to 0 whenever a user withdraws a veSatin by calling `withdraw()` or merges one by calling `merge()`. When this is the case the operation lockEndTime - weekCursor underflows, thus reverting. This results in users being unable to claim veSatin emissions if they withdraw or merge it first

In the `withdraw()` and `merge()` functions, call `claim()` in VeDist.sol to claim emissions before setting the lock end timestamp to 0. In `merge()` this is only necessary for the veSatin passed as _from

```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n

It's never possible to vote for new pools until setMaxVotesForPool() is called

high

The function `_vote()` allows voting on a pool only when the current amount of votes plus the new votes is lower or equal to the value returned by _calculateMaxVotePossible():\\n```\\n require(_poolWeights <= _calculateMaxVotePossible(_pool), "Max votes exceeded");\\n```\\n\\nHowever, `_calculateMaxVotePossible()` returns 0 for every pool in which the variable maxVotesForPool has not been initialized, thus making `_vote()` revert:\\n```\\n return ((totalVotingPower * maxVotesForPool[_pool]) / 100);\\n```\\n

In `createGauge()` and `createGauge4Pool()` set maxVotesForPool for the pool the gauge is being created for to 100.

```\\n require(_poolWeights <= _calculateMaxVotePossible(_pool), "Max votes exceeded");\\n```\\n

The protocol might transfer extra SATIN emissions to veSatin holders potentially making SatinVoter.sol insolvent

high

The function `_distribute()` in SatinVoter.sol is generally responsible for distributing weekly emissions to a gauge based on the percentage of total votes the associated pool received. In particular, it's called by `updatePeriod()` (as per fix TRST-H-4) on the gauge associated with the Satin / $CASH pool. The variable veShare is set to be equal to the returned value of `calculateSatinCashLPVeShare()`, which is calculated as the percentage of Satin / $CASH LP times claimable[gauge] and represents the amount of SATIN that will be transferred to VeDist.sol when checkpointing emissions in checkpointEmissions():\\n```\\n uint _claimable = claimable[_gauge];\\n if (SATIN_CASH_LP_GAUGE == _gauge) {\\n veShare = calculateSatinCashLPVeShare(_claimable);\\n _claimable -= veShare;\\n }\\n if (_claimable > IMultiRewardsPool(_gauge).left(token) && _claimable / DURATION > 0) {\\n claimable[_gauge] = 0;\\n if (is4poolGauge[_gauge]) {\\n IGauge(_gauge).notifyRewardAmount(token, _claimable, true);\\n } else {\\n IGauge(_gauge).notifyRewardAmount(token, _claimable, false);\\n }\\n emit DistributeReward(msg.sender, _gauge, _claimable);\\n }\\n```\\n\\nHowever, when the if condition (_claimable > IMultiRewardsPool(_gauge).left(token) && _claimable / DURATION > 0) is false the variable claimable[_gauge] will not be set to 0, meaning the next time veShare will be calculated it will include emissions that have already been distributed, potentially making SatinVoter.sol insolvent

Adjust claimable[gauge] after calculating veShare and calculate veShare only if the msg.sender is SatinMinter.sol to prevent potential attackers from manipulating the value by repeatedly calling _distribute():\\n```\\n if (SATIN_CASH_LP_GAUGE == _gauge && msg.sender == minter) {\\n veShare = calculateSatinCashLPVeShare(_claimable);\\n claimable[_gauge] -= veShare;\\n _claimable -= veShare;\\n }\\n```\\n

```\\n uint _claimable = claimable[_gauge];\\n if (SATIN_CASH_LP_GAUGE == _gauge) {\\n veShare = calculateSatinCashLPVeShare(_claimable);\\n _claimable -= veShare;\\n }\\n if (_claimable > IMultiRewardsPool(_gauge).left(token) && _claimable / DURATION > 0) {\\n claimable[_gauge] = 0;\\n if (is4poolGauge[_gauge]) {\\n IGauge(_gauge).notifyRewardAmount(token, _claimable, true);\\n } else {\\n IGauge(_gauge).notifyRewardAmount(token, _claimable, false);\\n }\\n emit DistributeReward(msg.sender, _gauge, _claimable);\\n }\\n```\\n

It's possible to drain all the funds from ExternalBribe

high

The function `earned()` is used to calculate the amount rewards owed to a tokenId, to do so it performs a series operations over a loop and then it always executes:\\n```\\n Checkpoint memory cp = checkpoints[tokenId][_endIndex];\\n uint _lastEpochStart = _bribeStart(cp.timestamp);\\n uint _lastEpochEnd = _lastEpochStart + DURATION;\\n if (block.timestamp > _lastEpochEnd) {\\n reward += (cp.balanceOf * \\n tokenRewardsPerEpoch[token][_lastEpochStart]) /\\n supplyCheckpoints[getPriorSupplyIndex(_lastEpochEnd)].supply;\\n```\\n\\nwhich adds to reward the amount of rewards earned by the tokenId during the last epoch in which it was used to vote, but only if that happened at least a week prior (block.timestamp > _lastEpochEnd). Because of this, it's possible to call `earned()` multiple times in a row with a tokenId that voted more than a week before to drain the contract funds.

The function `earned()` is taken from the Velodrome protocol and is known to have issues. Because it uses the convoluted logic of looping over votes to calculate the rewards per epoch instead of looping over epochs, we recommend using the Velodrome fixed implementation, which we reviewed:\\n```\\n function earned(address token, uint tokenId) public view returns (uint) {\\n if (numCheckpoints[tokenId] == 0) {\\n return 0;\\n }\\n uint reward = 0;\\n uint _ts = 0;\\n uint _bal = 0;\\n uint _supply = 1;\\n uint _index = 0;\\n uint _currTs = _bribeStart(lastEarn[token][tokenId]); // take epoch last claimed in as starting point\\n _index = getPriorBalanceIndex(tokenId, _currTs);\\n _ts = checkpoints[tokenId][_index].timestamp;\\n _bal = checkpoints[tokenId][_index].balanceOf;\\n // accounts for case where lastEarn is before first checkpoint\\n _currTs = Math.max(_currTs, _bribeStart(_ts));\\n // get epochs between current epoch and first checkpoint in same epoch as last claim\\n uint numEpochs = (_bribeStart(block.timestamp) - _currTs) / DURATION;\\n if (numEpochs > 0) {\\n for (uint256 i = 0; i < numEpochs; i++) {\\n // get index of last checkpoint in this epoch\\n _index = getPriorBalanceIndex(tokenId, _currTs + DURATION);\\n // get checkpoint in this epoch\\n _ts = checkpoints[tokenId][_index].timestamp;\\n _bal = checkpoints[tokenId][_index].balanceOf;\\n // get supply of last checkpoint in this epoch\\n _supply = supplyCheckpoints[getPriorSupplyIndex(_currTs + DURATION)].supply;\\n reward += _bal * tokenRewardsPerEpoch[token][_currTs] / _supply;\\n _currTs += DURATION;\\n }\\n }\\n return reward;\\n }\\n```\\n

```\\n Checkpoint memory cp = checkpoints[tokenId][_endIndex];\\n uint _lastEpochStart = _bribeStart(cp.timestamp);\\n uint _lastEpochEnd = _lastEpochStart + DURATION;\\n if (block.timestamp > _lastEpochEnd) {\\n reward += (cp.balanceOf * \\n tokenRewardsPerEpoch[token][_lastEpochStart]) /\\n supplyCheckpoints[getPriorSupplyIndex(_lastEpochEnd)].supply;\\n```\\n

Division by 0 can freeze emissions claims for veSatin holders

medium

The function `_calculateClaim()` is responsible for the calculations of the amount of emissions a specific veSatin is entitled to claim. In doing so, this code is executed (code with mitigation from TRST-H-1):\\n```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n\\nThe variable veSupply[weekCursor] is used as a denominator without checking if it's 0, which could make the function revert. If the protocol ever reaches a state where veSupply[weekCursor] is 0, all the claims for veSatin that were locked during that week would fail for both past and future claims. The same issue is present in the function `_calculateEmissionsClaim()`

Ensure veSupply[weekCursor] is not 0 when performing the division.

```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n

BaseV1Pair could break because of overflow

medium

In the function _update(), called internally by `mint()`, `burn()` and `swap()`, the following code is executed:\\n```\\n uint256 timeElapsed = blockTimestamp - blockTimestampLast;\\n // overflow is desired\\n if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {\\n reserve0CumulativeLast += _reserve0 * timeElapsed;\\n reserve1CumulativeLast += _reserve1 * timeElapsed;\\n }\\n```\\n\\nThis is forked from UniswapV2 source code, and it's meant and known to overflow. It works fine if solidity < 0.8.0 is used but reverts when solidity >= 0.8.0 is used. If this happens all the core functionalities of the pool would break, including `mint()`, `burn()`, and `swap()`.

Wrap the operation around an unchecked{} block so that when the variable overflows it loops back to 0 instead of reverting.

```\\n uint256 timeElapsed = blockTimestamp - blockTimestampLast;\\n // overflow is desired\\n if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {\\n reserve0CumulativeLast += _reserve0 * timeElapsed;\\n reserve1CumulativeLast += _reserve1 * timeElapsed;\\n }\\n```\\n

createGauge4Pool() lacks proper checks and/or access control

medium

The function createGauge4Pool() can be called by anybody at any time and is used to create a Gauge for a special pool, the 4pool. It takes 5 parameters as inputs:\\n```\\n function createGauge4pool(\\n address _4pool,\\n address _dai,\\n address _usdc,\\n address _usdt,\\n address _cash\\n ) external returns (address) {\\n```\\n\\nNone of the parameters are properly sanitized, meaning _dai, _usdc, _usdt, _cash could be any whitelisted token and not necessarily DAI, USDC, USDT, and cash while _4pool could be any custom contract, including a malicious one. The function also sets the variable FOUR_POOL_GAUGE_ADDRESS to the newly created gauge, overwriting the previous value.

Make the function only callable by an admin, and if it can be called multiple times, turn the variable FOUR_POOL_GAUGE_ADDRESS to a mapping from address to boolean to support multiple 4 pools.

```\\n function createGauge4pool(\\n address _4pool,\\n address _dai,\\n address _usdc,\\n address _usdt,\\n address _cash\\n ) external returns (address) {\\n```\\n

The logic in _calculateClaim() can leave some tokens locked and waste gas

low

The function `_calculateClaim()` is responsible for the calculations of the amount of emissions a specific veSatin is entitled to claim. To do so, this code is executed in a loop for each week from the current timestamp to the last claim (code with mitigation from TRST-H-1):\\n```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n\\nWhen the if condition is not met two things happen:\\nAn amount of emissions that was supposed to be distributed ((balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor])) is skipped, meaning it will stay locked in the contract.\\nThe function `_calculateClaim()` will loop for the maximum number of times (50), because weekCursor is not increased, wasting users' gas.

When the if condition is not met burn the tokens that were supposed to be distributed and exit the loop. Since the non-distributed tokens would stay locked it's not strictly necessary to burn them.

```\\n if ((lockEndTime - weekCursor) > (minLockDurationForReward)) {\\n toDistribute +=\\n (balanceOf * tokensPerWeek[weekCursor]) / veSupply[weekCursor];\\n weekCursor += WEEK;\\n }\\n```\\n

More than one hat of the same hatId can be assigned to a user

high

Hats are minted internally using `_mintHat()`.\\n```\\n /// @notice Internal call to mint a Hat token to a wearer\\n /// @dev Unsafe if called when `_wearer` has a non-zero balance of `_hatId`\\n /// @param _wearer The wearer of the Hat and the recipient of the newly minted token\\n /// @param _hatId The id of the Hat to mint\\n function _mintHat(address _wearer, uint256 _hatId) internal {\\n unchecked {\\n // should not overflow since `mintHat` enforces max balance of 1\\n _balanceOf[_wearer][_hatId] = 1;\\n // increment Hat supply counter\\n // should not overflow given AllHatsWorn check in `mintHat` ++_hats[_hatId].supply;\\n }\\n emit TransferSingle(msg.sender, address(0), _wearer, _hatId, 1);\\n }\\n```\\n\\nAs documentation states, it is unsafe if _wearer already has the hatId. However, this could easily be the case when called from `mintHat()`.\\n```\\n function mintHat(uint256 _hatId, address _wearer) public returns (bool) {\\n Hat memory hat = _hats[_hatId];\\n if (hat.maxSupply == 0) revert HatDoesNotExist(_hatId);\\n // only the wearer of a hat's admin Hat can mint it\\n _checkAdmin(_hatId);\\n if (hat.supply >= hat.maxSupply) {\\n revert AllHatsWorn(_hatId);\\n }\\n if (isWearerOfHat(_wearer, _hatId)) {\\n revert AlreadyWearingHat(_wearer, _hatId);\\n }\\n _mintHat(_wearer, _hatId);\\n return true;\\n }\\n```\\n\\nThe function validates _wearer doesn't currently wear the hat, but its balance could still be over 0, if the hat is currently toggled off or the wearer is not eligible. The impact is that the hat supply is forever spent, while nobody actually received the hat. This could be used maliciously or occur by accident. When the hat is immutable, the max supply can never be corrected for this leak. It could be used to guarantee no additional, unfriendly hats can be minted to maintain permanent power.

Instead of checking if user currently wears the hat, check if its balance is over 0.

```\\n /// @notice Internal call to mint a Hat token to a wearer\\n /// @dev Unsafe if called when `_wearer` has a non-zero balance of `_hatId`\\n /// @param _wearer The wearer of the Hat and the recipient of the newly minted token\\n /// @param _hatId The id of the Hat to mint\\n function _mintHat(address _wearer, uint256 _hatId) internal {\\n unchecked {\\n // should not overflow since `mintHat` enforces max balance of 1\\n _balanceOf[_wearer][_hatId] = 1;\\n // increment Hat supply counter\\n // should not overflow given AllHatsWorn check in `mintHat` ++_hats[_hatId].supply;\\n }\\n emit TransferSingle(msg.sender, address(0), _wearer, _hatId, 1);\\n }\\n```\\n

TXs can be executed by less than the minimum required signatures

high

In HatsSignerGateBase, `checkTransaction()` is the function called by the Gnosis safe to approve the transaction. Several checks are in place.\\n```\\n uint256 safeOwnerCount = safe.getOwners().length;\\n if (safeOwnerCount < minThreshold) {\\n revert BelowMinThreshold(minThreshold, safeOwnerCount);\\n }\\n```\\n\\n```\\n uint256 validSigCount = countValidSignatures(txHash, signatures, signatures.length / 65);\\n // revert if there aren't enough valid signatures\\n if (validSigCount < safe.getThreshold()) {\\n revert InvalidSigners();\\n }\\n```\\n\\nThe first check is that the number of owners registered on the safe is at least minThreshold. The second check is that the number of valid signatures (wearers of relevant hats) is not below the safe's threshold. However, it turns out these requirements are not sufficient. A possible situation is that there are plenty of owners registered, but currently most do not wear a hat. `reconcileSignerCount()` could be called to reduce the safe's threshold to the current validSigCount, which can be below minThreshold. That would make both the first and second check succeed. However, minThreshold is defined to be the smallest number of signers that must come together to make a TX. The result is that a single signer could execute a TX on the safe, if the other signers are not wearers of hats (for example, their toggle has been temporarily set off in the case of multi-hat signer gate.

Add another check in `checkTransaction()`, which states that validSigCount >= minThreshold.

```\\n uint256 safeOwnerCount = safe.getOwners().length;\\n if (safeOwnerCount < minThreshold) {\\n revert BelowMinThreshold(minThreshold, safeOwnerCount);\\n }\\n```\\n

Target signature threshold can be bypassed leading to minority TXs

high

`checkTransaction()` is the enforcer of the HSG logic, making sure signers are wearers of hats and so on. The check below makes sure sufficient hat wearers signed the TX:\\n```\\n uint256 validSigCount = countValidSignatures(txHash, signatures, signatures.length / 65);\\n // revert if there aren't enough valid signatures\\n if (validSigCount < safe.getThreshold()) {\\n revert InvalidSigners();\\n }\\n```\\n\\nThe issue is that the safe's threshold is not guaranteed to be up to date. For example, initially there were 5 delegated signers. At some point, three lost eligibility. `reconcileSignerCount()` is called to update the safe's threshold to now have 2 signers. At a later point, the three signers which lost eligibility regained it. At this point, the threshold is still two, but there are 5 valid signers, so if targetThreshold is not below 5, they should all sign for a TX to be executed. That is not the case, as the old threshold is used. There are various scenarios which surface the lack of synchronization between the wearer status and safe's stored threshold.

Call `reconcileSignerCount()` before the validation code in `checkTransaction()`.

```\\n uint256 validSigCount = countValidSignatures(txHash, signatures, signatures.length / 65);\\n // revert if there aren't enough valid signatures\\n if (validSigCount < safe.getThreshold()) {\\n revert InvalidSigners();\\n }\\n```\\n

maxSigners can be bypassed

high

maxSigners is specified when creating an HSG and is left constant. It is enforced in two ways -targetThreshold may never be set above it, and new signers cannot register to the HSG when the signer count reached maxSigners. Below is the implementation code in HatsSignerGate.\\n```\\n function claimSigner() public virtual {\\n if (signerCount == maxSigners) {\\n revert MaxSignersReached();\\n }\\n if (safe.isOwner(msg.sender)) {\\n revert SignerAlreadyClaimed(msg.sender);\\n }\\n if (!isValidSigner(msg.sender)) {\\n revert NotSignerHatWearer(msg.sender);\\n }\\n _grantSigner(msg.sender);\\n }\\n```\\n\\nAn issue that arises is that this doesn't actually limit the number of registered signers. Indeed, signerCount is a variable that can fluctuate when wearers lose eligibility or a hat is inactive. At this point, `reconcileSignerCount()` can be called to update the signerCount to the current valid wearer count. A simple attack which achieves unlimited claims is as follows:\\nAssume maxSigners = 10\\n10 signers claim their spot, so signerCount is maxed out\\nA signer misbehaves, loses eligibility and the hat.\\nreconcile() is called, so signerCount is updated to 9\\nA new signer claims, making signerCount = 10\\nThe malicious signer behaves nicely and regains the hat.\\nreconcile() is called again, making signerCount = 11\\nAt this point, any eligible hat wearer can claim their hat, easily overrunning the maxSigners restriction.

The root cause is that users which registered but lose their hat are still stored in the safe's owners array, meaning they can always get re-introduced and bump the signerCount. Instead of checking the signerCount, a better idea would be to compare with the list of owners saved on the safe. If there are owners that are no longer holders, `removeSigner()` can be called to vacate space for new signers.

```\\n function claimSigner() public virtual {\\n if (signerCount == maxSigners) {\\n revert MaxSignersReached();\\n }\\n if (safe.isOwner(msg.sender)) {\\n revert SignerAlreadyClaimed(msg.sender);\\n }\\n if (!isValidSigner(msg.sender)) {\\n revert NotSignerHatWearer(msg.sender);\\n }\\n _grantSigner(msg.sender);\\n }\\n```\\n

Attacker can DOS minting of new top hats in low-fee chains

medium

In Hats protocol, anyone can be assigned a top hat via the `mintTopHat()` function. The top hats are structured with top 32 bits acting as a domain ID, and the lower 224 bits are cleared. There are therefore up to 2^32 = ~ 4 billion top hats. Once they are all consumed, `mintTopHat()` will always fail:\\n```\\n // uint32 lastTopHatId will overflow in brackets\\n topHatId = uint256(++lastTopHatId) << 224;\\n```\\n\\nThis behavior exposes the project to a DOS vector, where an attacker can mint 4 billion top hats in a loop and make the function unusable, forcing a redeploy of Hats protocol. This is unrealistic on ETH mainnet due to gas consumption, but definitely achievable on the cheaper L2 networks. As the project will be deployed on a large variety of EVM blockchains, this poses a significant risk.

Require a non-refundable deposit fee (paid in native token) when minting a top hat. Price it so that consuming the 32-bit space will be impossible. This can also serve as a revenue stream for the Hats project.

```\\n // uint32 lastTopHatId will overflow in brackets\\n topHatId = uint256(++lastTopHatId) << 224;\\n```\\n

Linking of hat trees can freeze hat operations

medium

Hats support tree-linking, where hats from one node link to the first level of a different domain. This way, the amount of levels for the linked-to tree increases by the linked-from level count. This is generally fine, however lack of checking of the new total level introduces severe risks.\\n```\\n /// @notice Identifies the level a given hat in its hat tree\\n /// @param _hatId the id of the hat in question\\n /// @return level (0 to type(uint8).max)\\n function getHatLevel(uint256 _hatId) public view returns (uint8) {\\n```\\n\\nThe `getHatLevel()` function can only return up to level 255. It is used by the `checkAdmin()` call used in many of the critical functions in the Hats contract. Therefore, if for example, 17 hat domains are joined together in the most stretched way possible, It would result in a correct hat level of 271, making this calculation revert:\\n```\\n if (treeAdmin != 0) {\\n return 1 + uint8(i) + getHatLevel(treeAdmin);\\n }\\n```\\n\\nThe impact is that intentional or accidental linking that creates too many levels would freeze the higher hat levels from any interaction with the contract.

It is recommended to add a check in `_linkTopHatToTree()`, that the new accumulated level can fit in uint8. Another option would be to change the maximum level type to uint32.

```\\n /// @notice Identifies the level a given hat in its hat tree\\n /// @param _hatId the id of the hat in question\\n /// @return level (0 to type(uint8).max)\\n function getHatLevel(uint256 _hatId) public view returns (uint8) {\\n```\\n

Attacker can make a signer gate creation fail

medium

DAOs can deploy a HSG using `deployHatsSignerGateAndSafe()` or deployMultiHatsSignerGateAndSafe().The parameters are encoded and passed to moduleProxyFactory.deployModule():\\n```\\n bytes memory initializeParams = abi.encode(_ownerHatId, _signersHatId, _safe, hatsAddress, _minThreshold, \\n _targetThreshold, _maxSigners, version );\\n hsg = moduleProxyFactory.deployModule(hatsSignerGateSingleton, abi.encodeWithSignature("setUp(bytes)", \\n initializeParams), _saltNonce );\\n```\\n\\nThis function will call createProxy():\\n```\\n proxy = createProxy( masterCopy, keccak256(abi.encodePacked(keccak256(initializer), saltNonce)) );\\n```\\n\\nThe second parameter is the generated salt, which is created from the initializer and passed saltNonce. Finally `createProxy()` will use CREATE2 to create the contract:\\n```\\n function createProxy(address target, bytes32 salt) internal returns (address result)\\n {\\n if (address(target) == address(0)) revert ZeroAddress(target);\\n if (address(target).code.length == 0) revert \\n TargetHasNoCode(target);\\n bytes memory deployment = abi.encodePacked(\\n hex"602d8060093d393df3363d3d373d3d3d363d73", target, hex"5af43d82803e903d91602b57fd5bf3" );\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n result := create2(0, add(deployment, 0x20), \\n mload(deployment), salt)\\n }\\n if (result == address(0)) revert TakenAddress(result);\\n }\\n```\\n\\nAn issue could be that an attacker can frontrun the creation TX with their own creation request, with the same parameters. This would create the exact address created by the CREATE2 call, since the parameters and therefore the final salt will be the same. When the victim's transaction would be executed, the address is non-empty so the EVM would reject its creation. This would result in a bad UX for a user, who thinks the creation did not succeed. The result contract would still be usable, but would be hard to track as it was created in another TX.

Use an ever-increasing nonce counter to guarantee unique contract addresses.

```\\n bytes memory initializeParams = abi.encode(_ownerHatId, _signersHatId, _safe, hatsAddress, _minThreshold, \\n _targetThreshold, _maxSigners, version );\\n hsg = moduleProxyFactory.deployModule(hatsSignerGateSingleton, abi.encodeWithSignature("setUp(bytes)", \\n initializeParams), _saltNonce );\\n```\\n

Signers can backdoor the safe to execute any transaction in the future without consensus

medium

The function `checkAfterExecution()` is called by the safe after signer's request TX was executed (and authorized). It mainly checks that the linkage between the safe and the HSG has not been compromised.\\n```\\n function checkAfterExecution(bytes32, bool) external override {\\n if (abi.decode(StorageAccessible(address(safe)).getStorageAt(uint256(GUARD_STORAGE_SLOT), 1), (address))\\n != address(this)) \\n {\\n revert CannotDisableThisGuard(address(this));\\n }\\n if (!IAvatar(address(safe)).isModuleEnabled(address(this))) {\\n revert CannotDisableProtectedModules(address(this));\\n }\\n if (safe.getThreshold() != _correctThreshold()) {\\n revert SignersCannotChangeThreshold();\\n }\\n // leave checked to catch underflows triggered by re-erntry\\n attempts\\n --guardEntries;\\n }\\n```\\n\\nHowever, it is missing a check that no new modules have been introduced to the safe. When modules execute TXs on a Gnosis safe, the guard safety callbacks do not get called. As a result, any new module introduced is free to execute whatever it wishes on the safe. It constitutes a serious backdoor threat and undermines the HSG security model.

Check that no new modules have been introduced to the safe, using the `getModulesPaginated()` utility.

```\\n function checkAfterExecution(bytes32, bool) external override {\\n if (abi.decode(StorageAccessible(address(safe)).getStorageAt(uint256(GUARD_STORAGE_SLOT), 1), (address))\\n != address(this)) \\n {\\n revert CannotDisableThisGuard(address(this));\\n }\\n if (!IAvatar(address(safe)).isModuleEnabled(address(this))) {\\n revert CannotDisableProtectedModules(address(this));\\n }\\n if (safe.getThreshold() != _correctThreshold()) {\\n revert SignersCannotChangeThreshold();\\n }\\n // leave checked to catch underflows triggered by re-erntry\\n attempts\\n --guardEntries;\\n }\\n```\\n

createHat does not detect MAX_LEVEL admin correctly

low

In `createHat()`, the contract checks user is not minting hats for the lowest hat tier:\\n```\\n function createHat( uint256 _admin, string memory _details, uint32 _maxSupply, address _eligibility,\\n address _toggle, bool _mutable, string memory _imageURI) \\n public returns (uint256 newHatId) {\\n if (uint8(_admin) > 0) {\\n revert MaxLevelsReached();\\n }\\n ….\\n }\\n```\\n\\nThe issue is that it does not check for max level correctly, as it looks only at the lowest 8 bits. Each level is composed of 16 bits, so ID xx00 would pass this check. Fortunately, although the check is passed, the function will revert later. The call to `getNextId(_admin)` will return 0 for max-level admin, and _checkAdmin(0) is guaranteed to fail. However, the check should still be fixed as it is not exploitable only by chance.

Change the conversion to uint16.

```\\n function createHat( uint256 _admin, string memory _details, uint32 _maxSupply, address _eligibility,\\n address _toggle, bool _mutable, string memory _imageURI) \\n public returns (uint256 newHatId) {\\n if (uint8(_admin) > 0) {\\n revert MaxLevelsReached();\\n }\\n ….\\n }\\n```\\n

Incorrect imageURI is returned for hats in certain cases

low

Function `getImageURIForHat()` should return the most relevant imageURI for the requested hatId. It will iterate backwards from the current level down to level 0, and return an image if it exists for that level.\\n```\\n function getImageURIForHat(uint256 _hatId) public view returns (string memory) {\\n // check _hatId first to potentially avoid the `getHatLevel` call\\n Hat memory hat = _hats[_hatId];\\n string memory imageURI = hat.imageURI; // save 1 SLOAD\\n // if _hatId has an imageURI, we return it\\n if (bytes(imageURI).length > 0) {\\n return imageURI;\\n }\\n // otherwise, we check its branch of admins\\n uint256 level = getHatLevel(_hatId);\\n // but first we check if _hatId is a tophat, in which case we fall back to the global image uri\\n if (level == 0) return baseImageURI;\\n // otherwise, we check each of its admins for a valid imageURI\\n uint256 id;\\n // already checked at `level` above, so we start the loop at `level - 1`\\n for (uint256 i = level - 1; i > 0;) {\\n id = getAdminAtLevel(_hatId, uint8(i));\\n hat = _hats[id];\\n imageURI = hat.imageURI;\\n if (bytes(imageURI).length > 0) {\\n return imageURI;\\n }\\n // should not underflow given stopping condition is > 0\\n unchecked {\\n --i;\\n }\\n }\\n // if none of _hatId's admins has an imageURI of its own, we \\n again fall back to the global image uri\\n return baseImageURI;\\n }\\n```\\n\\nIt can be observed that the loop body will not run for level 0. When the loop is finished, the code just returns the baseImageURI, which is a Hats-level fallback, rather than top hat level fallback. As a result, the image displayed will not be correct when querying for a level above 0, when all levels except level 0 have no registered image.

Before returning the baseImageURI, check if level 0 admin has a registered image.

```\\n function getImageURIForHat(uint256 _hatId) public view returns (string memory) {\\n // check _hatId first to potentially avoid the `getHatLevel` call\\n Hat memory hat = _hats[_hatId];\\n string memory imageURI = hat.imageURI; // save 1 SLOAD\\n // if _hatId has an imageURI, we return it\\n if (bytes(imageURI).length > 0) {\\n return imageURI;\\n }\\n // otherwise, we check its branch of admins\\n uint256 level = getHatLevel(_hatId);\\n // but first we check if _hatId is a tophat, in which case we fall back to the global image uri\\n if (level == 0) return baseImageURI;\\n // otherwise, we check each of its admins for a valid imageURI\\n uint256 id;\\n // already checked at `level` above, so we start the loop at `level - 1`\\n for (uint256 i = level - 1; i > 0;) {\\n id = getAdminAtLevel(_hatId, uint8(i));\\n hat = _hats[id];\\n imageURI = hat.imageURI;\\n if (bytes(imageURI).length > 0) {\\n return imageURI;\\n }\\n // should not underflow given stopping condition is > 0\\n unchecked {\\n --i;\\n }\\n }\\n // if none of _hatId's admins has an imageURI of its own, we \\n again fall back to the global image uri\\n return baseImageURI;\\n }\\n```\\n

Fetching of hat status may fail due to lack of input sanitization

low

The functions `_isActive()` and `_isEligible()` are used by `balanceOf()` and other functions, so they should not ever revert. However, they perform ABI decoding from external inputs.\\n```\\n function _isActive(Hat memory _hat, uint256 _hatId) internal view returns (bool) {\\n bytes memory data = \\n abi.encodeWithSignature("getHatStatus(uint256)", _hatId);\\n (bool success, bytes memory returndata) = \\n _hat.toggle.staticcall(data);\\n if (success && returndata.length > 0) {\\n return abi.decode(returndata, (bool));\\n } else {\\n return _getHatStatus(_hat);\\n }\\n }\\n```\\n\\nIf toggle returns invalid return data (whether malicious or by accident), `abi.decode()` would revert causing the entire function to revert.

Wrap the decoding operation for both affected functions in a try/catch statement. Fall back to the `_getHatStatus()` result if necessary. Checking that returndata size is correct is not enough as bool encoding must be 64-bit encoded 0 or 1.

```\\n function _isActive(Hat memory _hat, uint256 _hatId) internal view returns (bool) {\\n bytes memory data = \\n abi.encodeWithSignature("getHatStatus(uint256)", _hatId);\\n (bool success, bytes memory returndata) = \\n _hat.toggle.staticcall(data);\\n if (success && returndata.length > 0) {\\n return abi.decode(returndata, (bool));\\n } else {\\n return _getHatStatus(_hat);\\n }\\n }\\n```\\n

Attacker can take over GMXAdapter implementation contract

low

GMXAdapter inherits from BaseExchangeAdapter. It is an implementation contract for a transparent proxy and has the following initializer:\\n```\\n function initialize() external initializer {\\n __Ownable_init();\\n }\\n```\\n\\nTherefore, an attacker can call initialize() on the implementation contract and become the owner. At this point they can do just about anything to this contract, but it has no impact on the proxy as it is using separate storage. If there was a delegatecall coded in GMXAdapter, attacker could have used it to call an attacker's contract and execute the SELFDESTRUCT opcode, killing the implementation. With no implementation, the proxy itself would not be functional until it is updated to a new implementation. It is ill-advised to allow anyone to have control over implementation contracts as future upgrades may make the attack surface exploitable.

The standard approach is to call from the constructor the _disableInitializers() from Open Zeppelin's Initializable module

```\\n function initialize() external initializer {\\n __Ownable_init();\\n }\\n```\\n

disordered fee calculated causes collateral changes to be inaccurate

high

`_increasePosition()` changes the Hedger's GMX position by sizeDelta amount and collateralDelta collateral. There are two collateralDelta corrections - one for swap fees and one for position fees. Since the swap fee depends on up-to-date collateralDelta, it's important to calculate it after the position fee, contrary to the current state. In practice, it may lead to the leverage ratio being higher than intended as collateralDelta sent to GMX is lower than it should be.\\n```\\n if (isLong) {\\n uint swapFeeBP = getSwapFeeBP(isLong, true, collateralDelta);\\n collateralDelta = (collateralDelta * (BASIS_POINTS_DIVISOR + swapFeeBP)) / BASIS_POINTS_DIVISOR;\\n }\\n // add margin fee\\n // when we increase position, fee always got deducted from collateral\\n collateralDelta += _getPositionFee(currentPos.size, sizeDelta, currentPos.entryFundingRate);\\n```\\n

Flip the order of `getSwapFeeBP()` and `_getPositionFee()`.

```\\n if (isLong) {\\n uint swapFeeBP = getSwapFeeBP(isLong, true, collateralDelta);\\n collateralDelta = (collateralDelta * (BASIS_POINTS_DIVISOR + swapFeeBP)) / BASIS_POINTS_DIVISOR;\\n }\\n // add margin fee\\n // when we increase position, fee always got deducted from collateral\\n collateralDelta += _getPositionFee(currentPos.size, sizeDelta, currentPos.entryFundingRate);\\n```\\n

small LP providers may be unable to withdraw their deposits

medium

In LiquidityPool's initiateWithdraw(), it's required that withdrawn value is above a minimum parameter, or that withdrawn tokens is above the minimum parameter.\\n```\\n if (withdrawalValue < lpParams.minDepositWithdraw && \\n amountLiquidityToken < lpParams.minDepositWithdraw) {\\n revert MinimumWithdrawNotMet(address(this), withdrawalValue, lpParams.minDepositWithdraw);\\n }\\n```\\n\\nThe issue is that minDepositWithdraw is measured in dollars while amountLiquidityToken is LP tokens. The intention was that if LP tokens lost value and a previous deposit is now worth less than minDepositWithdraw, it would still be withdrawable. However, the current implementation doesn't check for that correctly, since the LP to dollar exchange rate at deposit time is not known, and is practically being hardcoded as 1:1 here. The impact is that users may not be able to withdraw LP with the token amount that was above the minimum at deposit time, or vice versa

Consider calculating an average exchange rate at which users have minted and use it to verify withdrawal amount is satisfactory.

```\\n if (withdrawalValue < lpParams.minDepositWithdraw && \\n amountLiquidityToken < lpParams.minDepositWithdraw) {\\n revert MinimumWithdrawNotMet(address(this), withdrawalValue, lpParams.minDepositWithdraw);\\n }\\n```\\n

base to quote swaps trust GMX-provided minPrice and maxPrice to be correct, which may be manipulated

medium

exchangeFromExactBase() in GMXAdapter converts an amount of base to quote. It implements slippage protection by using the GMX vault's getMinPrice() and getMaxPrice() utilities. However, such protection is insufficient because GMX prices may be manipulated. Indeed, GMX supports “AMM pricing” mode where quotes are calculated from Uniswap reserves. A possible attack would be to drive up the base token (e.g. ETH) price, sell a large ETH amount to the GMXAdapter, and repay the flashloan used for manipulation. exchangeFromExactBase() is attacker-reachable from LiquidityPool's exchangeBase().\\n```\\n uint tokenInPrice = _getMinPrice(address(baseAsset));\\n uint tokenOutPrice = _getMaxPrice(address(quoteAsset));\\n // rest of code\\n uint minOut = tokenInPrice\\n .multiplyDecimal(marketPricingParams[_optionMarket].minReturnPercent)\\n .multiplyDecimal(_amountBase)\\n .divideDecimal(tokenOutPrice);\\n```\\n

Verify `getMinPrice()`, `getMinPrice()` outputs are close to Chainlink-provided prices as done in `getSpotPriceForMarket()`.

```\\n uint tokenInPrice = _getMinPrice(address(baseAsset));\\n uint tokenOutPrice = _getMaxPrice(address(quoteAsset));\\n // rest of code\\n uint minOut = tokenInPrice\\n .multiplyDecimal(marketPricingParams[_optionMarket].minReturnPercent)\\n .multiplyDecimal(_amountBase)\\n .divideDecimal(tokenOutPrice);\\n```\\n

recoverFunds() does not handle popular ERC20 tokens like BNB

medium

recoverFunds() is used for recovery in case of mistakenly-sent tokens. However, it uses unsafe transfer to send tokens back, which will not support 100s of non-compatible ERC20 tokens. Therefore it is likely unsupported tokens will be unrecoverable.\\n```\\n if (token == quoteAsset || token == baseAsset || token == weth) {\\n revert CannotRecoverRestrictedToken(address(this));\\n }\\n token.transfer(recipient, token.balanceOf(address(this)));\\n```\\n

Use Open Zeppelin's SafeERC20 encapsulation of ERC20 transfer functions.

```\\n if (token == quoteAsset || token == baseAsset || token == weth) {\\n revert CannotRecoverRestrictedToken(address(this));\\n }\\n token.transfer(recipient, token.balanceOf(address(this)));\\n```\\n

setPositionRouter leaks approval to previous positionRouter

low

positionRouter is used to change GMX positions in GMXFuturesPoolHedger. It can be replaced by a new router if GMX redeploys, for example if a bug is found or the previous one is hacked. The new positionRouter receives approval from the contract. However, approval to the previous positionRouter is not revoked.\\n```\\n function setPositionRouter(IPositionRouter _positionRouter) external onlyOwner {\\n positionRouter = _positionRouter;\\n router.approvePlugin(address(positionRouter));\\n emit PositionRouterSet(_positionRouter);\\n }\\n```\\n\\nA number of unlikely, yet dire scenarios could occur.

Use router.denyPlugin() to remove privileges from the previous positionRouter.

```\\n function setPositionRouter(IPositionRouter _positionRouter) external onlyOwner {\\n positionRouter = _positionRouter;\\n router.approvePlugin(address(positionRouter));\\n emit PositionRouterSet(_positionRouter);\\n }\\n```\\n

PoolHedger can receive ETH directly from anyone

low

A `receive()` function has been added to GMXFuturesPoolHedger, so that it is able to receive ETH from GMX as request refunds. However, it is not advisable to have an open `receive()` function if it is not necessary. Users may wrongly send ETH directly to PoolHedger and lose it forever.\\n```\\n receive() external payable {}\\n```\\n

Add a msg.sender check in the receive() function, and make sure sender is positionRouter.

```\\n receive() external payable {}\\n```\\n

Attacker can freeze profit withdrawals from V3 vaults

high

Users of Ninja can use Vault's `withdrawProfit()` to withdraw profits. It starts with the following check:\\n```\\n if (block.timestamp <= lastProfitTime) {\\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\\n }\\n```\\n\\nIf attacker can front-run user's `withdrawProfit()` TX and set lastProfitTime to block.timestamp, they would effectively freeze the user's yield. That is indeed possible using the Vault paired strategy's `harvest()` function. It is permissionless and calls `_harvestCore()`. The attack path is shown in bold.\\n```\\n function harvest() external override whenNotPaused returns (uint256 callerFee) {\\n require(lastHarvestTimestamp != block.timestamp);\\n uint256 harvestSeconds = lastHarvestTimestamp > 0 ? block.timestamp \\n - lastHarvestTimestamp : 0;\\n lastHarvestTimestamp = block.timestamp;\\n uint256 sentToVault;\\n uint256 underlyingTokenCount;\\n (callerFee, underlyingTokenCount, sentToVault) = _harvestCore();\\n emit StrategyHarvest(msg.sender, underlyingTokenCount, \\n harvestSeconds, sentToVault);\\n }\\n```\\n\\n```\\n function _harvestCore() internal override returns (uint256 callerFee, uint256 underlyingTokenCount, uint256 sentToVault)\\n {\\n IMasterChef(SPOOKY_SWAP_FARM_V2).deposit(POOL_ID, 0);\\n _swapFarmEmissionTokens();\\n callerFee = _chargeFees();\\n underlyingTokenCount = balanceOf();\\n sentToVault = _sendYieldToVault();\\n } \\n```\\n\\n```\\n function _sendYieldToVault() internal returns (uint256 sentToVault) {\\n sentToVault = IERC20Upgradeable(USDC).balanceOf(address(this));\\n if (sentToVault > 0) {\\n IERC20Upgradeable(USDC).approve(vault, sentToVault);\\n IVault(vault).depositProfitTokenForUsers(sentToVault);\\n }\\n }\\n```\\n\\n```\\n function depositProfitTokenForUsers(uint256 _amount) external nonReentrant {\\n if (_amount == 0) {\\n revert NYProfitTakingVault__ZeroAmount();\\n }\\n if (block.timestamp <= lastProfitTime) {\\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\\n }\\n if (msg.sender != strategy) {\\n revert NYProfitTakingVault__OnlyStrategy();\\n }\\n uint256 totalShares = totalSupply();\\n if (totalShares == 0) {\\n lastProfitTime = block.timestamp;\\n return;\\n }\\n accProfitTokenPerShare += ((_amount * PROFIT_TOKEN_PER_SHARE_PRECISION) / totalShares);\\n lastProfitTime = block.timestamp;\\n // Now pull in the tokens (Should have permission)\\n // We only want to pull the tokens with accounting\\n profitToken.transferFrom(strategy, address(this), _amount);\\n emit ProfitReceivedFromStrategy(_amount);\\n }\\n```\\n

Do not prevent profit withdrawals during lastProfitTime block.

```\\n if (block.timestamp <= lastProfitTime) {\\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\\n }\\n```\\n

Lack of child rewarder reserves could lead to freeze of funds

high

In ComplexRewarder.sol, `onReward()` is used to distribute rewards for previous time period, using the complex rewarder and any child rewarders. If the complex rewarder does not have enough tokens to hand out the reward, it correctly stores the rewards owed in storage. However, child rewarded will attempt to hand out the reward and may revert:\\n```\\n function onReward(uint _pid, address _user, address _to, uint, uint _amt) external override onlyParent nonReentrant {\\n PoolInfo memory pool = updatePool(_pid);\\n if (pool.lastRewardTime == 0) return;\\n UserInfo storage user = userInfo[_pid][_user];\\n uint pending;\\n if (user.amount > 0) {\\n pending = ((user.amount * pool.accRewardPerShare) / ACC_TOKEN_PRECISION) - user.rewardDebt;\\n rewardToken.safeTransfer(_to, pending);\\n }\\n user.amount = _amt;\\n user.rewardDebt = (_amt * pool.accRewardPerShare) / \\n ACC_TOKEN_PRECISION;\\n emit LogOnReward(_user, _pid, pending, _to);\\n }\\n```\\n\\nImportantly, if the child rewarder fails, the parent's `onReward()` reverts too:\\n```\\n uint len = childrenRewarders.length();\\n for (uint i = 0; i < len; ) {\\n IRewarder(childrenRewarders.at(i)).onReward(_pid, _user, _to, 0, \\n _amt);\\n unchecked {\\n ++i;\\n }\\n }\\n```\\n\\nIn the worst-case scenario, this will lead the user's `withdraw()` call to V3 Vault, to revert.

Introduce sufficient exception handling in the CompexRewarder.sol contract, so that `onReward()` would never fail.

```\\n function onReward(uint _pid, address _user, address _to, uint, uint _amt) external override onlyParent nonReentrant {\\n PoolInfo memory pool = updatePool(_pid);\\n if (pool.lastRewardTime == 0) return;\\n UserInfo storage user = userInfo[_pid][_user];\\n uint pending;\\n if (user.amount > 0) {\\n pending = ((user.amount * pool.accRewardPerShare) / ACC_TOKEN_PRECISION) - user.rewardDebt;\\n rewardToken.safeTransfer(_to, pending);\\n }\\n user.amount = _amt;\\n user.rewardDebt = (_amt * pool.accRewardPerShare) / \\n ACC_TOKEN_PRECISION;\\n emit LogOnReward(_user, _pid, pending, _to);\\n }\\n```\\n

Wrong accounting of user's holdings allows theft of reward

high

In `deposit()`, `withdraw()` and `withdrawProfit()`, `rewarder.onReward()` is called for reward bookkeeping. It will transfer previous eligible rewards and update the current amount user has:\\n```\\n user.amount = _amt;\\n user.rewardDebt = (_amt * pool.accRewardPerShare) / ACC_TOKEN_PRECISION;\\n user.rewardsOwed = rewardsOwed;\\n```\\n\\nIn `withdraw()`, there is a critical issue where `onReward()` is called too early:\\n```\\n // Update rewarder for this user\\n if (address(rewarder) != address(0)) {\\n rewarder.onReward(0, msg.sender, msg.sender, pending, user.amount);\\n }\\n // Burn baby burn\\n _burn(msg.sender, _shares);\\n // User accounting\\n uint256 userAmount = balanceOf(msg.sender);\\n // - Underlying (Frontend ONLY)\\n if (userAmount == 0) {\\n user.amount = 0;\\n } else {\\n user.amount -= r;\\n }\\n```\\n\\nThe new _amt which will be stored in reward contract's user.amount is vault's user.amount, before decrementing the withdrawn amount. Therefore, the withdrawn amount is still gaining rewards even though it's no longer in the contract. Effectively it is stealing the rewards of others, leading to reward insolvency. In order to exploit this flaw, attacker will deposit a larger amount and immediately withdraw it, except for one wei. When they would like to receive the rewards accrued for others, they will withdraw the remaining wei, which will trigger `onReward()`, which will calculate and send pending awards for the previously withdrawn amount.

Move the `onReward()` call to after user.amount is updated.

```\\n user.amount = _amt;\\n user.rewardDebt = (_amt * pool.accRewardPerShare) / ACC_TOKEN_PRECISION;\\n user.rewardsOwed = rewardsOwed;\\n```\\n

Unsafe transferFrom breaks compatibility with 100s of ERC20 tokens

medium

In Ninja vaults, the delegated strategy sends profit tokens to the vault using `depositProfitTokenForUsers()`. The vault transfers the tokens in using:\\n```\\n // Now pull in the tokens (Should have permission)\\n // We only want to pull the tokens with accounting\\n profitToken.transferFrom(strategy, address(this), _amount);\\n emit ProfitReceivedFromStrategy(_amount);\\n```\\n\\nThe issue is that the code doesn't use the `safeTransferFrom()` utility from SafeERC20. Therefore, profitTokens that don't return a bool in `transferFrom()` will cause a revert which means they are stuck in the strategy. Examples of such tokens are USDT, BNB, among hundreds of other tokens.

Use `safeTransferFrom()` from SafeERC20.sol

```\\n // Now pull in the tokens (Should have permission)\\n // We only want to pull the tokens with accounting\\n profitToken.transferFrom(strategy, address(this), _amount);\\n emit ProfitReceivedFromStrategy(_amount);\\n```\\n

Attacker can force partial withdrawals to fail

medium

In Ninja vaults, users call `withdraw()` to take back their deposited tokens. There is bookkeeping on remaining amount:\\n```\\n uint256 userAmount = balanceOf(msg.sender);\\n // - Underlying (Frontend ONLY)\\n if (userAmount == 0) {\\n user.amount = 0;\\n } else {\\n user.amount -= r;\\n }\\n```\\n\\nIf the withdraw is partial (some tokens are left), user.amount is decremented by r.\\n```\\n uint256 r = (balance() * _shares) / totalSupply();\\n```\\n\\nAbove, r is calculated as the relative share of the user's _shares of the total balance kept in the vault.\\nWe can see that user.amount is incremented in deposit().\\n```\\n function deposit(uint256 _amount) public nonReentrant {\\n …\\n user.amount += _amount;\\n …\\n }\\n```\\n\\nThe issue is that the calculated r can be more than _amount , causing an overflow in `withdraw()` and freezing the withdrawal. All attacker needs to do is send a tiny amount of underlying token directly to the contract, to make the shares go out of sync.

Redesign user structure, taking into account that balance of underlying can be externally manipulated

```\\n uint256 userAmount = balanceOf(msg.sender);\\n // - Underlying (Frontend ONLY)\\n if (userAmount == 0) {\\n user.amount = 0;\\n } else {\\n user.amount -= r;\\n }\\n```\\n

Rewards may be stuck due to unchangeable slippage parameter

medium

In NyPtvFantomWftmBooSpookyV2StrategyToUsdc.sol, MAX_SLIPPAGE is used to limit slippage in trades of BOO tokens to USDC, for yield:\\n```\\n function _swapFarmEmissionTokens() internal { IERC20Upgradeable boo = IERC20Upgradeable(BOO);\\n uint256 booBalance = boo.balanceOf(address(this));\\n if (booToUsdcPath.length < 2 || booBalance == 0) {\\n return;\\n }\\n boo.safeIncreaseAllowance(SPOOKY_ROUTER, booBalance);\\n uint256[] memory amounts = \\n IUniswapV2Router02(SPOOKY_ROUTER).getAmountsOut(booBalance, booToUsdcPath);\\n uint256 amountOutMin = (amounts[amounts.length - 1] * MAX_SLIPPAGE) / PERCENT_DIVISOR;\\n IUniswapV2Router02(SPOOKY_ROUTER).swapExactTokensForTokensSupportingFeeOnTransferTokens( booBalance, amountOutMin, booToUsdcPath, address(this), block.timestamp );\\n }\\n```\\n\\nIf slippage is not satisfied the entire transaction reverts. Since MAX_SLIPPAGE is constant, it is possible that harvesting of the strategy will be stuck, due to operations leading to too high of a slippage. For example, strategy might accumulate a large amount of BOO, or `harvest()` can be sandwich-attacked.

Allow admin to set slippage after some timelock period.

```\\n function _swapFarmEmissionTokens() internal { IERC20Upgradeable boo = IERC20Upgradeable(BOO);\\n uint256 booBalance = boo.balanceOf(address(this));\\n if (booToUsdcPath.length < 2 || booBalance == 0) {\\n return;\\n }\\n boo.safeIncreaseAllowance(SPOOKY_ROUTER, booBalance);\\n uint256[] memory amounts = \\n IUniswapV2Router02(SPOOKY_ROUTER).getAmountsOut(booBalance, booToUsdcPath);\\n uint256 amountOutMin = (amounts[amounts.length - 1] * MAX_SLIPPAGE) / PERCENT_DIVISOR;\\n IUniswapV2Router02(SPOOKY_ROUTER).swapExactTokensForTokensSupportingFeeOnTransferTokens( booBalance, amountOutMin, booToUsdcPath, address(this), block.timestamp );\\n }\\n```\\n

potential overflow in reward accumulator may freeze functionality

medium

Note the above description of `updatePool()` functionality. We can see that accRewardPerShare is only allocated 128 bits in PoolInfo:\\n```\\n struct PoolInfo {\\n uint128 accRewardPerShare;\\n uint64 lastRewardTime;\\n uint64 allocPoint;\\n```\\n\\nTherefore, even if truncation issues do not occur, it is likely that continuous incrementation of the counter would cause accRewardPerShare to overflow, which would freeze vault functionalities such as withdrawal.

Steal 32 bits from lastRewardTime and 32 bits from allocPoint to make the accumulator have 192 bits, which should be enough for safe calculations.

```\\n struct PoolInfo {\\n uint128 accRewardPerShare;\\n uint64 lastRewardTime;\\n uint64 allocPoint;\\n```\\n

when using fee-on-transfer tokens in VaultV3, capacity is limited below underlyingCap

low

Vault V3 documentation states it accounts properly for fee-on-transfer tokens. It calculates actual transferred amount as below:\\n```\\n uint256 _pool = balance();\\n if (_pool + _amount > underlyingCap) {\\n revert NYProfitTakingVault__UnderlyingCapReached(underlyingCap);\\n }\\n uint256 _before = underlying.balanceOf(address(this));\\n underlying.safeTransferFrom(msg.sender, address(this), _amount);\\n uint256 _after = underlying.balanceOf(address(this));\\n _amount = _after - _before;\\n```\\n\\nA small issue is that underlyingCap is compared to the _amount before correction for actual transferred amount. Therefore, it cannot actually be reached, and limits the maximum capacity of the vault to underlyingCap minus a factor of the fee %.

Move the underlyingCap check to below the effective _amount calculation

```\\n uint256 _pool = balance();\\n if (_pool + _amount > underlyingCap) {\\n revert NYProfitTakingVault__UnderlyingCapReached(underlyingCap);\\n }\\n uint256 _before = underlying.balanceOf(address(this));\\n underlying.safeTransferFrom(msg.sender, address(this), _amount);\\n uint256 _after = underlying.balanceOf(address(this));\\n _amount = _after - _before;\\n```\\n

Redundant checks in Vault V3

low

`depositProfitTokenForUsers()` and `withdrawProfit()` contain the following check:\\n```\\n if (block.timestamp <= lastProfitTime) {\\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\\n }\\n```\\n\\nHowever, lastProfitTime is only ever set to block.timestamp. Therefore, it can never be larger than block.timestamp.

It would be best in terms of gas costs and logical clarity to change the comparison to !=

```\\n if (block.timestamp <= lastProfitTime) {\\n revert NYProfitTakingVault__ProfitTimeOutOfBounds();\\n }\\n```\\n

createUniswapRangeOrder() charges manager instead of pool

high

_createUniswapRangeOrder() can be called either from manager flow, with createUniswapRangeOrder(), or pool-induced from hedgeDelta(). The issue is that the function assumes the sender is the parentLiquidityPool, for example:\\n```\\n if (inversed && balance < amountDesired) {\\n // collat = 0\\n uint256 transferAmount = amountDesired - balance;\\n uint256 parentPoolBalance = \\n ILiquidityPool(parentLiquidityPool).getBalance(address(token0));\\n if (parentPoolBalance < transferAmount) { revert \\n CustomErrors.WithdrawExceedsLiquidity(); \\n }\\n SafeTransferLib.safeTransferFrom(address(token0), msg.sender, \\n address(this), transferAmount);\\n } \\n```\\n\\nBalance check is done on pool, but money is transferred from sender. It will cause the order to use manager's funds.\\n```\\n function createUniswapRangeOrder(\\n RangeOrderParams calldata params,\\n uint256 amountDesired\\n ) external {\\n require(!_inActivePosition(), "RangeOrder: active position");\\n _onlyManager();\\n bool inversed = collateralAsset == address(token0);\\n _createUniswapRangeOrder(params, amountDesired, inversed);\\n }\\n```\\n

Ensure safeTransfer from uses parentLiquidityPool as source.

```\\n if (inversed && balance < amountDesired) {\\n // collat = 0\\n uint256 transferAmount = amountDesired - balance;\\n uint256 parentPoolBalance = \\n ILiquidityPool(parentLiquidityPool).getBalance(address(token0));\\n if (parentPoolBalance < transferAmount) { revert \\n CustomErrors.WithdrawExceedsLiquidity(); \\n }\\n SafeTransferLib.safeTransferFrom(address(token0), msg.sender, \\n address(this), transferAmount);\\n } \\n```\\n

hedgeDelta() priceToUse is calculated wrong, which causes bad hedges

high

When _delta parameter is negative for `hedgeDelta()`, priceToUse will be the minimum between quotePrice and underlyingPrice.\\n```\\n // buy wETH\\n // lowest price is best price when buying\\n uint256 priceToUse = quotePrice < underlyingPrice ? quotePrice : \\n underlyingPrice;\\n RangeOrderDirection direction = inversed ? RangeOrderDirection.ABOVE \\n : RangeOrderDirection.BELOW;\\n RangeOrderParams memory rangeOrder = \\n _getTicksAndMeanPriceFromWei(priceToUse, direction);\\n```\\n\\nThis works fine when direction is BELOW, because the calculated lowerTick and upperTick from _getTicksAndMeanPriceFromWei are guaranteed to be lower than current price.\\n```\\n int24 lowerTick = direction == RangeOrderDirection.ABOVE ? \\n nearestTick + tickSpacing : nearestTick - (2 * tickSpacing);\\n int24 tickUpper = direction ==RangeOrderDirection.ABOVE ? lowerTick + \\n tickSpacing : nearestTick - tickSpacing;\\n```\\n\\nTherefore, the fulfill condition is not true and we mint from the correct base. However, when direction is ABOVE, it is possible that the oracle supplied price (underlyingPrice) is low enough in comparison to pool price, that the fulfill condition is already active. In that case, the contract tries to mint from the wrong asset which will cause the wrong tokens to be sent in. In effect, the contract is not hedging. A similar situation occurs when _delta parameter is greater than zero.

Verify the calculated priceToUse is on the same side as pool-calculated tick price.

```\\n // buy wETH\\n // lowest price is best price when buying\\n uint256 priceToUse = quotePrice < underlyingPrice ? quotePrice : \\n underlyingPrice;\\n RangeOrderDirection direction = inversed ? RangeOrderDirection.ABOVE \\n : RangeOrderDirection.BELOW;\\n RangeOrderParams memory rangeOrder = \\n _getTicksAndMeanPriceFromWei(priceToUse, direction);\\n```\\n

multiplication overflow in getPoolPrice() likely

medium

`getPoolPrice()` is used in hedgeDelta to get the price directly from Uniswap v3 pool:\\n```\\n function getPoolPrice() public view returns (uint256 price, uint256 \\n inversed){\\n (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();\\n uint256 p = uint256(sqrtPriceX96) * uint256(sqrtPriceX96) * (10 \\n ** token0.decimals());\\n // token0/token1 in 1e18 format\\n price = p / (2 ** 192);\\n inversed = 1e36 / price;\\n }\\n```\\n\\nThe issue is that calculation of p is likely to overflow. sqrtPriceX96 has 96 bits for decimals, 10** `token0.decimals()` will have 60 bits when decimals is 18, therefore there is only (256 - 2 * 96 - 60) / 2 = 2 bits for non-decimal part of sqrtPriceX96.

Consider converting the sqrtPrice to a 60x18 format and performing arithmetic operations using the PRBMathUD60x18 library.

```\\n function getPoolPrice() public view returns (uint256 price, uint256 \\n inversed){\\n (uint160 sqrtPriceX96, , , , , , ) = pool.slot0();\\n uint256 p = uint256(sqrtPriceX96) * uint256(sqrtPriceX96) * (10 \\n ** token0.decimals());\\n // token0/token1 in 1e18 format\\n price = p / (2 ** 192);\\n inversed = 1e36 / price;\\n }\\n```\\n

Hedging won't work if token1.decimals() < token0.decimals()

medium

`tickToToken0PriceInverted()` performs some arithmetic calculations. It's called by `_getTicksAndMeanPriceFromWei()`, which is called by `hedgeDelta()`. This line can overflow:\\n```\\n uint256 intermediate = inWei.div(10**(token1.decimals() -\\n token0.decimals()));\\n```\\n\\nAlso, this line would revert even if the above calculation was done correctly:\\n```\\n meanPrice = OptionsCompute.convertFromDecimals(meanPrice, \\n token0.decimals(), token1.decimals());\\n```\\n\\n```\\n function convertFromDecimals(uint256 value, uint8 decimalsA, uint8 decimalsB) internal pure\\n returns (uint256) {\\n if (decimalsA > decimalsB) {\\n revert();\\n }\\n …\\n```\\n\\nThe impact is that when `token1.decimals()` < `token0.decimals()`, the contract's main function is unusable.

Refactor the calculation to support different decimals combinations. Additionally, add more comprehensive tests to detect similar issues in the future.

```\\n uint256 intermediate = inWei.div(10**(token1.decimals() -\\n token0.decimals()));\\n```\\n

Overflow danger in _sqrtPriceX96ToUint

medium

_sqrtPriceX96ToUint will only work when the non-fractional component of sqrtPriceX96 takes up to 32 bits. This represents a price ratio of 18446744073709551616. With different token digits it is not unlikely that this ratio will be crossed which will make hedgeDelta() revert.\\n```\\n function _sqrtPriceX96ToUint(uint160 sqrtPriceX96) private pure returns (uint256)\\n {\\n uint256 numerator1 = uint256(sqrtPriceX96) * \\n uint256(sqrtPriceX96);\\n return FullMath.mulDiv(numerator1, 1, 1 << 192);\\n }\\n```\\n

Perform the multiplication after converting the numbers to 60x18 variables

```\\n function _sqrtPriceX96ToUint(uint160 sqrtPriceX96) private pure returns (uint256)\\n {\\n uint256 numerator1 = uint256(sqrtPriceX96) * \\n uint256(sqrtPriceX96);\\n return FullMath.mulDiv(numerator1, 1, 1 << 192);\\n }\\n```\\n

Insufficient dust checks

low

In `hedgeDelta()`, there is a dust check in the case of sell wETH order:\\n```\\n // sell wETH\\n uint256 wethBalance = inversed ? amount1Current : amount0Current;\\n if (wethBalance < minAmount) return 0;\\n```\\n\\nHowever, the actual used amount is _delta\\n```\\n uint256 deltaToUse = _delta > int256(wethBalance) ? wethBalance : \\n uint256(_delta);\\n _createUniswapRangeOrder(rangeOrder, deltaToUse, inversed);\\n```\\n\\nThe check should be applied on deltaToUse rather than wethBalance because it will be the minimum of wethBalance and _delta. Additionally, there is no corresponding check for minting with collateral in case _delta is negative.

Correct current dust checks and add them also in the if clause.

```\\n // sell wETH\\n uint256 wethBalance = inversed ? amount1Current : amount0Current;\\n if (wethBalance < minAmount) return 0;\\n```\\n

Linear vesting users may not receive vested amount

high

TokenTransmuter supports two types of transmutations, linear and instant. In linear, allocated amount is released across time until fully vested, while in instant the entire amount is released immediately. transmuteLinear() checks that there is enough output tokens left in the contract before accepting transfer of input tokens.\\n```\\n require(IERC20(outputTokenAddress).balanceOf(address(this)) >= \\n (totalAllocatedOutputToken - totalReleasedOutputToken), \\n "INSUFFICIENT_OUTPUT_TOKEN");\\n IERC20(inputTokenAddress).transferFrom(msg.sender, address(0), \\n _inputTokenAmount);\\n```\\n\\nHowever, `transmuteInstant()` lacks any remaining balance checks, and will operate as long as the function has enough output tokens to satisfy the request.\\n```\\n IERC20(inputTokenAddress).transferFrom(msg.sender, address(0), \\n _inputTokenAmount);\\n SafeERC20.safeTransfer(IERC20(outputTokenAddress), msg.sender, \\n allocation);\\n emit OutputTokenInstantReleased(msg.sender, allocation, \\n outputTokenAddress);\\n```\\n\\nAs a result, it is not ensured that tokens that have been reserved for linear distribution will be available when users request to claim them. An attacker may empty the output balance with a large instant transmute and steal future vested tokens of users.

In transmuteInstant, add a check similar to the one in transmuteLinear. It will ensure allocations are kept faithfully.

```\\n require(IERC20(outputTokenAddress).balanceOf(address(this)) >= \\n (totalAllocatedOutputToken - totalReleasedOutputToken), \\n "INSUFFICIENT_OUTPUT_TOKEN");\\n IERC20(inputTokenAddress).transferFrom(msg.sender, address(0), \\n _inputTokenAmount);\\n```\\n

Multiplier implementation causes limited functionality

low

linearMultiplier and instantMultiplier are used to calculate output token amount from input token amount in transmute functions.\\n```\\n uint256 allocation = (_inputTokenAmount * linearMultiplier) / \\n tokenDecimalDivider;\\n …\\n uint256 allocation = (_inputTokenAmount * instantMultiplier) / \\n tokenDecimalDivider;\\n```\\n\\nThe issue is that they are uint256 variables and can only multiply _inputTokenAmount, not divide it. It results in limited functionality of the protocol as vesting pairs where output tokens are valued more than input tokens cannot be used.

Add a boolean state variable which will describe whether to multiply or divide by the multiplier.

```\\n uint256 allocation = (_inputTokenAmount * linearMultiplier) / \\n tokenDecimalDivider;\\n …\\n uint256 allocation = (_inputTokenAmount * instantMultiplier) / \\n tokenDecimalDivider;\\n```\\n

Empty orders do not request from oracle and during settlement they use an invalid oracle version with `price=0` which messes up a lot of fees and funding accounting leading to loss of funds for the makers

high

When `market.update` which doesn't change user's position is called, a new (current) global order is created, but the oracle version is not requested due to empty order. This means that during the order settlement, it will use non-existant invalid oracle version with `price = 0`. This price is then used to accumulate all the data in this invalid `Version`, meaning accounting is done using `price = 0`, which is totally incorrect. For instance, all funding and fees calculations multiply by oracle version's price, thus all time periods between empty order and the next valid oracle version will not accumulate any fees, which is funds usually lost by makers (as makers won't receive fees/funding for the risk they take).\\nWhen `market.update` is called, it requests a new oracle version at the current order's timestamp unless the order is empty:\\n```\\n// request version\\nif (!newOrder.isEmpty()) oracle.request(IMarket(this), account);\\n```\\n\\nThe order is empty when it doesn't modify user position:\\n```\\nfunction isEmpty(Order memory self) internal pure returns (bool) {\\n return pos(self).isZero() && neg(self).isZero();\\n}\\n\\nfunction pos(Order memory self) internal pure returns (UFixed6) {\\n return self.makerPos.add(self.longPos).add(self.shortPos);\\n}\\n\\nfunction neg(Order memory self) internal pure returns (UFixed6) {\\n return self.makerNeg.add(self.longNeg).add(self.shortNeg);\\n}\\n```\\n\\nLater, when a valid oracle version is commited, during the settlement process, oracle version at the position is used:\\n```\\nfunction _processOrderGlobal(\\n Context memory context,\\n SettlementContext memory settlementContext,\\n uint256 newOrderId,\\n Order memory newOrder\\n) private {\\n // @audit no oracle version at this timestamp, thus it's invalid with `price=0`\\n OracleVersion memory oracleVersion = oracle.at(newOrder.timestamp); \\n\\n context.pending.global.sub(newOrder);\\n // @audit order is invalidated (it's already empty anyway), but the `price=0` is still used everywhere\\n if (!oracleVersion.valid) newOrder.invalidate();\\n\\n VersionAccumulationResult memory accumulationResult;\\n (settlementContext.latestVersion, context.global, accumulationResult) = VersionLib.accumulate(\\n settlementContext.latestVersion,\\n context.global,\\n context.latestPosition.global,\\n newOrder,\\n settlementContext.orderOracleVersion,\\n oracleVersion, // @audit <<< when oracleVersion is invalid, the `price=0` will still be used here\\n context.marketParameter,\\n context.riskParameter\\n );\\n// rest of code\\n```\\n\\nIf the oracle version is invalid, the order is invalidated, but the `price=0` is still used to accumulate. It doesn't affect pnl from price move, because the final oracle version is always valid, thus the correct price is used to evaluate all possible account actions, however it does affect accumulated fees and funding:\\n```\\nfunction _accumulateLinearFee(\\n Version memory next,\\n AccumulationContext memory context,\\n VersionAccumulationResult memory result\\n) private pure {\\n (UFixed6 makerLinearFee, UFixed6 makerSubtractiveFee) = _accumulateSubtractiveFee(\\n context.riskParameter.makerFee.linear(\\n Fixed6Lib.from(context.order.makerTotal()),\\n context.toOracleVersion.price.abs() // @audit <<< price == 0 for invalid oracle version\\n ),\\n context.order.makerTotal(),\\n context.order.makerReferral,\\n next.makerLinearFee\\n );\\n// rest of code\\n // Compute long-short funding rate\\n Fixed6 funding = context.global.pAccumulator.accumulate(\\n context.riskParameter.pController,\\n toSkew.unsafeDiv(Fixed6Lib.from(context.riskParameter.takerFee.scale)).min(Fixed6Lib.ONE).max(Fixed6Lib.NEG_ONE),\\n context.fromOracleVersion.timestamp,\\n context.toOracleVersion.timestamp,\\n context.fromPosition.takerSocialized().mul(context.fromOracleVersion.price.abs()) // @audit <<< price == 0 for invalid oracle version\\n );\\n// rest of code\\nfunction _accumulateInterest(\\n Version memory next,\\n AccumulationContext memory context\\n) private pure returns (Fixed6 interestMaker, Fixed6 interestLong, Fixed6 interestShort, UFixed6 interestFee) {\\n // @audit price = 0 and notional = 0 for invalid oracle version\\n UFixed6 notional = context.fromPosition.long.add(context.fromPosition.short).min(context.fromPosition.maker).mul(context.fromOracleVersion.price.abs());\\n// rest of code\\n```\\n\\nAs can be seen, all funding and fees accumulations multiply by oracle version's price (which is 0), thus during these time intervals fees and funding are 0.\\nThis will happen by itself during any period when there are no orders, because oracle provider's settlement callback uses `market.update` with empty order to settle user account, thus any non-empty order is always followed by an empty order for the next version and `price = 0` will be used to settle it until the next non-empty order:\\n```\\nfunction _settle(IMarket market, address account) private {\\n market.update(account, UFixed6Lib.MAX, UFixed6Lib.MAX, UFixed6Lib.MAX, Fixed6Lib.ZERO, false);\\n}\\n```\\n\\nThe scenario above is demonstrated in the test, add this to test/unit/market/Market.test.ts:\\n```\\nit('no fees accumulation due to invalid version with price = 0', async () => {\\n\\nfunction setupOracle(price: string, timestamp : number, nextTimestamp : number) {\\n const oracleVersion = {\\n price: parse6decimal(price),\\n timestamp: timestamp,\\n valid: true,\\n }\\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\\n oracle.status.returns([oracleVersion, nextTimestamp])\\n oracle.request.returns()\\n}\\n\\nfunction setupOracleAt(price: string, valid : boolean, timestamp : number) {\\n const oracleVersion = {\\n price: parse6decimal(price),\\n timestamp: timestamp,\\n valid: valid,\\n }\\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\\n}\\n\\nconst riskParameter = { // rest of code(await market.riskParameter()) }\\nconst riskParameterMakerFee = { // rest of coderiskParameter.makerFee }\\nriskParameterMakerFee.linearFee = parse6decimal('0.005')\\nriskParameterMakerFee.proportionalFee = parse6decimal('0.0025')\\nriskParameterMakerFee.adiabaticFee = parse6decimal('0.01')\\nriskParameter.makerFee = riskParameterMakerFee\\nconst riskParameterTakerFee = { // rest of coderiskParameter.takerFee }\\nriskParameterTakerFee.linearFee = parse6decimal('0.005')\\nriskParameterTakerFee.proportionalFee = parse6decimal('0.0025')\\nriskParameterTakerFee.adiabaticFee = parse6decimal('0.01')\\nriskParameter.takerFee = riskParameterTakerFee\\nawait market.connect(owner).updateRiskParameter(riskParameter)\\n\\ndsu.transferFrom.whenCalledWith(user.address, market.address, COLLATERAL.mul(1e12)).returns(true)\\ndsu.transferFrom.whenCalledWith(userB.address, market.address, COLLATERAL.mul(1e12)).returns(true)\\n\\nsetupOracle('100', TIMESTAMP, TIMESTAMP + 100);\\n\\nawait market\\n .connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, COLLATERAL, false);\\nawait market\\n .connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, POSITION, 0, COLLATERAL, false);\\n\\nsetupOracle('100', TIMESTAMP + 100, TIMESTAMP + 200);\\nawait market\\n .connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, 0, false);\\n\\n// oracle is commited at timestamp+200\\nsetupOracle('100', TIMESTAMP + 200, TIMESTAMP + 300);\\nawait market\\n .connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, 0, false);\\n\\n// oracle is not commited at timestamp+300\\nsetupOracle('100', TIMESTAMP + 200, TIMESTAMP + 400);\\nsetupOracleAt('0', false, TIMESTAMP + 300);\\nawait market\\n .connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, 0, false);\\n\\n// settle to see makerValue at all versions\\nsetupOracle('100', TIMESTAMP + 400, TIMESTAMP + 500);\\n\\nawait market.settle(user.address);\\nawait market.settle(userB.address);\\n\\nvar ver = await market.versions(TIMESTAMP + 200);\\nconsole.log("version 200: longValue: " + ver.longValue + " makerValue: " + ver.makerValue);\\nvar ver = await market.versions(TIMESTAMP + 300);\\nconsole.log("version 300: longValue: " + ver.longValue + " makerValue: " + ver.makerValue);\\nvar ver = await market.versions(TIMESTAMP + 400);\\nconsole.log("version 400: longValue: " + ver.longValue + " makerValue: " + ver.makerValue);\\n})\\n```\\n\\nConsole log:\\n```\\nversion 200: longValue: -318 makerValue: 285\\nversion 300: longValue: -100000637 makerValue: 100500571\\nversion 400: longValue: -637 makerValue: 571\\n```\\n\\nNotice, that fees are accumulated between versions 200 and 300, version 300 has huge pnl (because it's evaluated at price = 0), which then returns to normal at version 400, but no fees are accumulated between version 300 and 400 due to version 300 having `price = 0`.

Keep the price from the previous valid oracle version and use it instead of oracle version's one if oracle version's price == 0.

All fees and funding are incorrectly calculated as 0 during any period when there are no non-empty orders (which will be substantially more than 50% of the time, more like 90% of the time). Since most fees and funding are received by makers as a compensation for their price risk, this means makers will lose all these under-calculated fees and will receive a lot less fees and funding than expected.

```\\n// request version\\nif (!newOrder.isEmpty()) oracle.request(IMarket(this), account);\\n```\\n

Vault global shares and assets change will mismatch local shares and assets change during settlement due to incorrect `_withoutSettlementFeeGlobal` formula

high

Every vault update, which involves change of position in the underlying markets, `settlementFee` is charged by the Market. Since many users can deposit and redeem during the same oracle version, this `settlementFee` is shared equally between all users of the same oracle version. However, there is an issue in that `settlementFee` is charged once both for deposits and redeems, however `_withoutSettlementFeeGlobal` subtracts `settlementFee` in full both for deposits and redeems, meaning that for global fee, it's basically subtracted twice (once for deposits, and another time for redeems). But for local fee, it's subtracted proportional to `checkpoint.orders`, with sum of fee subtracted equal to exactly `settlementFee` (once). This difference in global and local `settlementFee` calculations leads to inflated `shares` and `assets` added for user deposits (local state) compared to vault overall (global state).\\nHere is an easy scenario to demonstrate the issue:\\nSettlementFee = `$10`\\nUser1 deposits `$10` for oracle version `t = 100`\\nUser2 redeems `10 shares` (worth $10) for the same oracle version `t = 100` (checkpoint.orders = 2)\\nOnce the oracle version `t = 100` settles, we have the following: 4.1. Global deposits = `$10`, redeems = `$10` 4.2. Global deposits convert to `0 shares` (because `_withoutSettlementFeeGlobal(10)` applies `settlementFee` of `$10` in full, returning 10-10=0) 4.3. Global redeems convert to `0 assets` (because `_withoutSettlementFeeGlobal(10)` applies `settlementFee` of `$10` in full, returning 10-10=0) 4.4. User1 deposit of `$10` converts to `5 shares` (because `_withoutSettlementFeeLocal(10)` applies `settlementFee` of `$5` (because there are 2 orders), returning 10-5=5) 4.5. User2 redeem of `10 shares` converts to `$5` (for the same reason)\\nFrom the example above it can be seen that:\\nUser1 receives 5 shares, but global vault shares didn't increase. Over time this difference will keep growing potentially leading to a situation where many user redeems will lead to 0 global shares, but many users will still have local shares which they will be unable to redeem due to underflow, thus losing funds.\\nUser2's assets which he can claim increase by $5, but global claimable assets didn't change, meaning User2 will be unable to claim assets due to underflow when trying to decrease global assets, leading to loss of funds for User2.\\nThe underflow in both cases will happen in `Vault._update` when trying to update global account:\\n```\\nfunction update(\\n Account memory self,\\n uint256 currentId,\\n UFixed6 assets,\\n UFixed6 shares,\\n UFixed6 deposit,\\n UFixed6 redemption\\n) internal pure {\\n self.current = currentId;\\n // @audit global account will have less assets and shares than sum of local accounts\\n (self.assets, self.shares) = (self.assets.sub(assets), self.shares.sub(shares));\\n (self.deposit, self.redemption) = (self.deposit.add(deposit), self.redemption.add(redemption));\\n}\\n```\\n

Calculate total orders to deposit and total orders to redeem (in addition to total orders overall). Then `settlementFee` should be multiplied by `deposit/orders` for `toGlobalShares` and by `redeems/orders` for `toGlobalAssets`. This weightening of `settlementFee` will make it in-line with local order weights.

Any time there are both deposits and redeems in the same oracle version, the users receive more (local) shares and assets than overall vault shares and assets increase (global). This mismatch causes:\\nSystematic increase of (sum of user shares - global shares), which can lead to bank run since the last users who try to redeem will be unable to do so due to underflow.\\nSystematic increase of (sum of user assets - global assets), which will lead to users being unable to claim their redeemed assets due to underflow.\\nThe total difference in local and global `shares+assets` equals to `settlementFee` per each oracle version with both deposits and redeems. This can add up to significant amounts (at `settlementFee` = $1 this can be $100-$1000 per day), meaning it will quickly become visible especially for point 2., because typically global claimable assets are at or near 0 most of the time, since users usually redeem and then immediately claim, thus any difference of global and local assets will quickly lead to users being unable to claim.

```\\nfunction update(\\n Account memory self,\\n uint256 currentId,\\n UFixed6 assets,\\n UFixed6 shares,\\n UFixed6 deposit,\\n UFixed6 redemption\\n) internal pure {\\n self.current = currentId;\\n // @audit global account will have less assets and shares than sum of local accounts\\n (self.assets, self.shares) = (self.assets.sub(assets), self.shares.sub(shares));\\n (self.deposit, self.redemption) = (self.deposit.add(deposit), self.redemption.add(redemption));\\n}\\n```\\n

Requested oracle versions, which have expired, must return this oracle version as invalid, but they return it as a normal version with previous version's price instead

high

Each market action requests a new oracle version which must be commited by the keepers. However, if keepers are unable to commit requested version's price (for example, no price is available at the time interval, network or keepers are down), then after a certain timeout this oracle version will be commited as invalid, using the previous valid version's price.\\nThe issue is that when this expired oracle version is used by the market (using oracle.at), the version returned will be valid (valid = true), because oracle returns version as invalid only if `price = 0`, but the `commit` function sets the previous version's price for these, thus it's not 0.\\nThis leads to market using invalid versions as if they're valid, keeping the orders (instead of invalidating them), which is a broken core functionality and a security risk for the protocol.\\nWhen requested oracle version is commited, but is expired (commited after a certain timeout), the price of the previous valid version is set to this expired oracle version:\\n```\\nfunction _commitRequested(OracleVersion memory version) private returns (bool) {\\n if (block.timestamp <= (next() + timeout)) {\\n if (!version.valid) revert KeeperOracleInvalidPriceError();\\n _prices[version.timestamp] = version.price;\\n } else {\\n // @audit previous valid version's price is set for expired version\\n _prices[version.timestamp] = _prices[_global.latestVersion]; \\n }\\n _global.latestIndex++;\\n return true;\\n}\\n```\\n\\nLater, `Market._processOrderGlobal` reads the oracle version using the `oracle.at`, invalidating the order if the version is invalid:\\n```\\nfunction _processOrderGlobal(\\n Context memory context,\\n SettlementContext memory settlementContext,\\n uint256 newOrderId,\\n Order memory newOrder\\n) private {\\n OracleVersion memory oracleVersion = oracle.at(newOrder.timestamp);\\n\\n context.pending.global.sub(newOrder);\\n if (!oracleVersion.valid) newOrder.invalidate();\\n```\\n\\nHowever, expired oracle version will return `valid = true`, because this flag is only set to `false` if price = 0:\\n```\\nfunction at(uint256 timestamp) public view returns (OracleVersion memory oracleVersion) {\\n (oracleVersion.timestamp, oracleVersion.price) = (timestamp, _prices[timestamp]);\\n oracleVersion.valid = !oracleVersion.price.isZero(); // @audit <<< valid = false only if price = 0\\n}\\n```\\n\\nThis means that `_processOrderGlobal` will treat this expired oracle version as valid and won't invalidate the order.

Add validity map along with the price map to `KeeperOracle` when recording commited price.

Market uses invalid (expired) oracle versions as if they're valid, keeping the orders (instead of invalidating them), which is a broken core functionality and a security risk for the protocol.

```\\nfunction _commitRequested(OracleVersion memory version) private returns (bool) {\\n if (block.timestamp <= (next() + timeout)) {\\n if (!version.valid) revert KeeperOracleInvalidPriceError();\\n _prices[version.timestamp] = version.price;\\n } else {\\n // @audit previous valid version's price is set for expired version\\n _prices[version.timestamp] = _prices[_global.latestVersion]; \\n }\\n _global.latestIndex++;\\n return true;\\n}\\n```\\n

When vault's market weight is set to 0 to remove the market from the vault, vault's leverage in this market is immediately set to max leverage risking position liquidation

medium

If any market has to be removed from the vault, the only way to do this is via setting this market's weight to 0. The problem is that the first vault rebalance will immediately withdraw max possible collateral from this market, leaving vault's leverage at max possible leverage, risking the vault's position liquidation. This is especially dangerous if vault's position in this removed market can not be closed due to high skew, so min position is not 0, but the leverage will be at max possible value. As a result, vault depositors can lose funds due to liquidation of vault's position in this market.\\nWhen vault is rebalanced, each market's collateral is calculated as following:\\n```\\n marketCollateral = marketContext.margin\\n .add(collateral.sub(totalMargin).mul(marketContext.registration.weight));\\n\\n UFixed6 marketAssets = assets\\n .mul(marketContext.registration.weight)\\n .min(marketCollateral.mul(LEVERAGE_BUFFER));\\n```\\n\\nFor removed markets (weight = 0), `marketCollateral` will be set to `marketContext.margin` (i.e. minimum valid collateral to have position at max leverage), `marketAssets` will be set to 0. But later the position will be adjusted in case minPosition is not 0:\\n```\\n target.position = marketAssets\\n .muldiv(marketContext.registration.leverage, marketContext.latestPrice.abs())\\n .max(marketContext.minPosition)\\n .min(marketContext.maxPosition);\\n```\\n\\nThis means that vault's position in the market with weight 0 will be at max leverage until liquidated or position can be closed.\\nThe scenario above is demonstrated in the test, change the following test in test/integration/vault/Vault.test.ts:\\n```\\n it('simple deposits and redemptions', async () => {\\n// rest of code\\n // Now we should have opened positions.\\n // The positions should be equal to (smallDeposit + largeDeposit) * leverage originalOraclePrice.\\n expect(await position()).to.equal(\\n smallDeposit.add(largeDeposit).mul(leverage).mul(4).div(5).div(originalOraclePrice),\\n )\\n expect(await btcPosition()).to.equal(\\n smallDeposit.add(largeDeposit).mul(leverage).div(5).div(btcOriginalOraclePrice),\\n )\\n\\n /*** remove all lines after this and replace with the following code: ***/\\n\\n console.log("pos1 = " + (await position()) + " pos2 = " + (await btcPosition()) + " col1 = " + (await collateralInVault()) + " col2 = " + (await btcCollateralInVault()));\\n\\n // update weight\\n await vault.connect(owner).updateWeights([parse6decimal('1.0'), parse6decimal('0')])\\n\\n // do small withdrawal to trigger rebalance\\n await vault.connect(user).update(user.address, 0, smallDeposit, 0)\\n await updateOracle()\\n\\n console.log("pos1 = " + (await position()) + " pos2 = " + (await btcPosition()) + " col1 = " + (await collateralInVault()) + " col2 = " + (await btcCollateralInVault()));\\n })\\n```\\n\\nConsole log:\\n```\\npos1 = 12224846 pos2 = 206187 col1 = 8008000000 col2 = 2002000000\\npos1 = 12224846 pos2 = 206187 col1 = 9209203452 col2 = 800796548\\n```\\n\\nNotice, that after rebalance, position in the removed market (pos2) is still the same, but the collateral (col2) reduced to minimum allowed.

Ensure that the market's collateral is based on leverage even if `weight = 0`

Market removed from the vault (weight set to 0) is put at max leverage and has a high risk of being liquidated, thus losing vault depositors funds.

```\\n marketCollateral = marketContext.margin\\n .add(collateral.sub(totalMargin).mul(marketContext.registration.weight));\\n\\n UFixed6 marketAssets = assets\\n .mul(marketContext.registration.weight)\\n .min(marketCollateral.mul(LEVERAGE_BUFFER));\\n```\\n

Makers can lose funds from price movement even when no long and short positions are opened, due to incorrect distribution of adiabatic fees exposure between makers

medium

Adiabatic fees introduced in this new update of the protocol (v2.3) were introduced to solve the problem of adiabatic fees netting out to 0 in market token's rather than in USD terms. With the new versions, this problem is solved and adiabatic fees now net out to 0 in USD terms. However, they net out to 0 only for the whole makers pool, but each individual maker can have profit or loss from adiabatic fees at different price levels all else being equal. This creates unexpected risk of loss of funds from adiabatic fees for individual makers, which can be significant, up to several percents of the amount invested.\\nThe issue is demonstrated in the following scenario:\\n`price = 1`\\nAlice open `maker = 10` (collateral = +0.9 from adiabatic fee)\\nBob opens `maker = 10` (collateral = +0.7 from adiabatic fee)\\nPath A. `price = 1`. Bob closes (final collateral = +0), Alice closes (final collaterral = +0)\\nPath B. `price = 2`. Bob closes (final collateral = +0.1), Alice closes (final collaterral = -0.1)\\nPath C. `price = 0.5`. Bob closes (final collateral = -0.05), Alice closes (final collateral = +0.05)\\nNotice that both Alice and Bob are the only makers, there are 0 longs and 0 shorts, but still both Alice and Bob pnl depends on the market price due to pnl from adiabatic fees. Adiabatic fees net out to 0 for all makers aggregated (Alice + Bob), but not for individual makers. Individual makers pnl from adiabatic fees is more or less random depending on the other makers who have opened.\\nIf Alice were the only maker, then:\\nprice = 1\\nAlice opens `maker = 10` (collateral = +0.9)\\nprice = 2: exposure adjusted +0.9 (Alice collateral = +1.8)\\nAlice closes `maker = 10` (adiabatic fees = `-1.8`, Alice final collateral = 0)\\nFor the lone maker there is no such problem, final collateral is 0 regardless of price. The core of the issue lies in the fact that the maker's adiabatic fees exposure adjustment is weighted by makers open maker amount. So in the first example:\\nprice = 1. Alice `maker = 10, exposure = +0.9`, Bob `maker = 10, exposure = +0.7`\\nprice = 2. Total exposure is adjusted by +1.6, split evenly between Alice and Bob (+0.8 for each)\\nAlice new exposure = 0.9 + 0.8 = +1.7 (but adiabatic fees paid to close = -1.8)\\nBob new exposure = 0.7 + 0.8 = +1.5 (but adiabatic fees paid to close = -1.4)\\nIf maker exposure adjustment was weighted by individual makers exposure, then all is correct:\\nprice = 1. Alice `maker = 10, exposure = +0.9`, Bob `maker = 10, exposure = +0.7`\\nprice = 2. Total exposure is adjusted by +1.6, split 0.9:0.7 between Alice and Bob, e.g. +0.9 for Alice, +0.7 for Bob\\nAlice new exposure = 0.9 + 0.9 = +1.8 (adiabatic fees paid to close = -1.8, net out to 0)\\nBob new exposure = 0.7 + 0.7 = +1.4 (adiabatic fees paid to close = -1.4, net out to 0)\\nIn the worst case, in the example above, if Bob opens `maker = 40` (adiabatic fees scale = 50), then at `price = 2`, Alice's final collateral is `-0.4` due to adiabatic fees. Given that Alice's position is 10 at `price = 2` (notional = 20), a loss of `-0.4` is a loss of `-2%` at 1x leverage, which is quite significant.\\nThe scenario above is demonstrated in the test, change the following test in test/unit/market/Market.test.ts:\\n```\\nit('adiabatic fee', async () => {\\n function setupOracle(price: string, timestamp : number, nextTimestamp : number) {\\n const oracleVersion = {\\n price: parse6decimal(price),\\n timestamp: timestamp,\\n valid: true,\\n }\\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\\n oracle.status.returns([oracleVersion, nextTimestamp])\\n oracle.request.returns()\\n }\\n\\n async function showInfo() {\\n await market.settle(user.address);\\n await market.settle(userB.address);\\n await market.settle(userC.address);\\n var sum : BigNumber = BigNumber.from('0');\\n var info = await market.locals(user.address);\\n console.log("user collateral = " + info.collateral);\\n sum = sum.add(info.collateral);\\n var info = await market.locals(userB.address);\\n sum = sum.add(info.collateral);\\n console.log("userB collateral = " + info.collateral);\\n var info = await market.locals(userC.address);\\n sum = sum.add(info.collateral);\\n }\\n\\n async function showVer(ver : number) {\\n var v = await market.versions(ver);\\n console.log("ver" + ver + ": makerValue=" + v.makerValue + " longValue=" + v.longValue + \\n " makerPosFee=" + v.makerPosFee + " makerNegFee=" + v.makerNegFee +\\n " takerPosFee=" + v.takerPosFee + " takerNegFee=" + v.takerNegFee\\n );\\n }\\n\\n const riskParameter = { // rest of code(await market.riskParameter()) }\\n const riskParameterMakerFee = { // rest of coderiskParameter.makerFee }\\n riskParameterMakerFee.linearFee = parse6decimal('0.00')\\n riskParameterMakerFee.proportionalFee = parse6decimal('0.00')\\n riskParameterMakerFee.adiabaticFee = parse6decimal('0.01')\\n riskParameterMakerFee.scale = parse6decimal('50.0')\\n riskParameter.makerFee = riskParameterMakerFee\\n const riskParameterTakerFee = { // rest of coderiskParameter.takerFee }\\n riskParameterTakerFee.linearFee = parse6decimal('0.00')\\n riskParameterTakerFee.proportionalFee = parse6decimal('0.00')\\n riskParameterTakerFee.adiabaticFee = parse6decimal('0.01')\\n riskParameterTakerFee.scale = parse6decimal('50.0')\\n riskParameter.takerFee = riskParameterTakerFee\\n await market.connect(owner).updateRiskParameter(riskParameter)\\n\\n marketParameter = {\\n fundingFee: parse6decimal('0.0'),\\n interestFee: parse6decimal('0.0'),\\n oracleFee: parse6decimal('0.0'),\\n riskFee: parse6decimal('0.0'),\\n positionFee: parse6decimal('0.0'),\\n maxPendingGlobal: 5,\\n maxPendingLocal: 3,\\n settlementFee: 0,\\n makerCloseAlways: false,\\n takerCloseAlways: false,\\n closed: false,\\n settle: false,\\n }\\n await market.connect(owner).updateParameter(beneficiary.address, coordinator.address, marketParameter)\\n\\n var time = TIMESTAMP;\\n\\n setupOracle('1', time, time + 100);\\n await market.connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, COLLATERAL, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('1', time, time + 100);\\n await market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, POSITION, 0, 0, COLLATERAL, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('1', time, time + 100);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('2', time, time + 100);\\n await market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, 0, 0, 0, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('2', time, time + 100);\\n await market.connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, 0, 0, 0, 0, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('0.5', time, time + 100);\\n await showInfo()\\n await showVer(time)\\n})\\n```\\n\\nConsole log:\\n```\\nuser collateral = 10000000000\\nuserB collateral = 0\\nver1636401093: makerValue=0 longValue=0 makerPosFee=0 makerNegFee=0 takerPosFee=0 takerNegFee=0\\nuser collateral = 10000090000\\nuserB collateral = 10000000000\\nver1636401193: makerValue=0 longValue=0 makerPosFee=9000 makerNegFee=0 takerPosFee=0 takerNegFee=0\\nuser collateral = 10000090000\\nuserB collateral = 10000070000\\nver1636401293: makerValue=0 longValue=0 makerPosFee=7000 makerNegFee=0 takerPosFee=0 takerNegFee=0\\nuser collateral = 10000170000\\nuserB collateral = 10000150000\\nver1636401393: makerValue=8000 longValue=0 makerPosFee=0 makerNegFee=0 takerPosFee=0 takerNegFee=0\\nuser collateral = 10000170000\\nuserB collateral = 10000010000\\nver1636401493: makerValue=8000 longValue=0 makerPosFee=0 makerNegFee=-14000 takerPosFee=0 takerNegFee=0\\nuser collateral = 9999990000\\nuserB collateral = 10000010000\\nver1636401593: makerValue=-5500 longValue=0 makerPosFee=0 makerNegFee=-4500 takerPosFee=0 takerNegFee=0\\n```\\n\\nNotice, that final user balance is -0.1 and final userB balance is +0.1

Split the total maker exposure by individual maker's exposure rather than by their position size. To do this:\\nAdd another accumulator to track total `exposure`\\nAdd individual maker `exposure` to user's `Local` storage\\nWhen accumulating local storage in the checkpoint, account global accumulator `exposure` weighted by individual user's `exposure`.

Individual makers bear an additional undocumented price risk due to adiabatic fees, which is quite significant (can be several percentages of the notional).

```\\nit('adiabatic fee', async () => {\\n function setupOracle(price: string, timestamp : number, nextTimestamp : number) {\\n const oracleVersion = {\\n price: parse6decimal(price),\\n timestamp: timestamp,\\n valid: true,\\n }\\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\\n oracle.status.returns([oracleVersion, nextTimestamp])\\n oracle.request.returns()\\n }\\n\\n async function showInfo() {\\n await market.settle(user.address);\\n await market.settle(userB.address);\\n await market.settle(userC.address);\\n var sum : BigNumber = BigNumber.from('0');\\n var info = await market.locals(user.address);\\n console.log("user collateral = " + info.collateral);\\n sum = sum.add(info.collateral);\\n var info = await market.locals(userB.address);\\n sum = sum.add(info.collateral);\\n console.log("userB collateral = " + info.collateral);\\n var info = await market.locals(userC.address);\\n sum = sum.add(info.collateral);\\n }\\n\\n async function showVer(ver : number) {\\n var v = await market.versions(ver);\\n console.log("ver" + ver + ": makerValue=" + v.makerValue + " longValue=" + v.longValue + \\n " makerPosFee=" + v.makerPosFee + " makerNegFee=" + v.makerNegFee +\\n " takerPosFee=" + v.takerPosFee + " takerNegFee=" + v.takerNegFee\\n );\\n }\\n\\n const riskParameter = { // rest of code(await market.riskParameter()) }\\n const riskParameterMakerFee = { // rest of coderiskParameter.makerFee }\\n riskParameterMakerFee.linearFee = parse6decimal('0.00')\\n riskParameterMakerFee.proportionalFee = parse6decimal('0.00')\\n riskParameterMakerFee.adiabaticFee = parse6decimal('0.01')\\n riskParameterMakerFee.scale = parse6decimal('50.0')\\n riskParameter.makerFee = riskParameterMakerFee\\n const riskParameterTakerFee = { // rest of coderiskParameter.takerFee }\\n riskParameterTakerFee.linearFee = parse6decimal('0.00')\\n riskParameterTakerFee.proportionalFee = parse6decimal('0.00')\\n riskParameterTakerFee.adiabaticFee = parse6decimal('0.01')\\n riskParameterTakerFee.scale = parse6decimal('50.0')\\n riskParameter.takerFee = riskParameterTakerFee\\n await market.connect(owner).updateRiskParameter(riskParameter)\\n\\n marketParameter = {\\n fundingFee: parse6decimal('0.0'),\\n interestFee: parse6decimal('0.0'),\\n oracleFee: parse6decimal('0.0'),\\n riskFee: parse6decimal('0.0'),\\n positionFee: parse6decimal('0.0'),\\n maxPendingGlobal: 5,\\n maxPendingLocal: 3,\\n settlementFee: 0,\\n makerCloseAlways: false,\\n takerCloseAlways: false,\\n closed: false,\\n settle: false,\\n }\\n await market.connect(owner).updateParameter(beneficiary.address, coordinator.address, marketParameter)\\n\\n var time = TIMESTAMP;\\n\\n setupOracle('1', time, time + 100);\\n await market.connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, COLLATERAL, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('1', time, time + 100);\\n await market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, POSITION, 0, 0, COLLATERAL, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('1', time, time + 100);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('2', time, time + 100);\\n await market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, 0, 0, 0, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('2', time, time + 100);\\n await market.connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, 0, 0, 0, 0, false);\\n await showInfo()\\n await showVer(time)\\n\\n time += 100;\\n setupOracle('0.5', time, time + 100);\\n await showInfo()\\n await showVer(time)\\n})\\n```\\n

All transactions to claim assets from the vault will revert in some situations due to double subtraction of the claimed assets in market position allocations calculation.

medium

When `assets` are claimed from the vault (Vault.update(0,0,x) called), the vault rebalances its collateral. There is an issue with market positions allocation calculations: the `assets` ("total position") subtract claimed amount twice. This leads to revert in case this incorrect `assets` amount is less than `minAssets` (caused by market's minPosition). In situations when the vault can't redeem due to some market's position being at the `minPosition` (because of the market's skew, which disallows makers to reduce their positions), this will lead to all users being unable to claim any `assets` which were already redeemed and settled.\\n`Vault.update` rebalances collateral by calling _manage:\\n```\\n_manage(context, depositAssets, claimAmount, !depositAssets.isZero() || !redeemShares.isZero());\\n```\\n\\nIn the rebalance calculations, collateral and assets (assets here stands for "total vault position") are calculated as following:\\n```\\n UFixed6 collateral = UFixed6Lib.unsafeFrom(strategy.totalCollateral).add(deposit).unsafeSub(withdrawal);\\n UFixed6 assets = collateral.unsafeSub(ineligable);\\n\\n if (collateral.lt(strategy.totalMargin)) revert StrategyLibInsufficientCollateralError();\\n if (assets.lt(strategy.minAssets)) revert StrategyLibInsufficientAssetsError();\\n```\\n\\n`ineligable` is calculated as following:\\n```\\nfunction _ineligable(Context memory context, UFixed6 withdrawal) private pure returns (UFixed6) {\\n // assets eligable for redemption\\n UFixed6 redemptionEligable = UFixed6Lib.unsafeFrom(context.totalCollateral)\\n .unsafeSub(withdrawal)\\n .unsafeSub(context.global.assets)\\n .unsafeSub(context.global.deposit);\\n\\n return redemptionEligable\\n // approximate assets up for redemption\\n .mul(context.global.redemption.unsafeDiv(context.global.shares.add(context.global.redemption)))\\n // assets pending claim\\n .add(context.global.assets)\\n // assets withdrawing\\n .add(withdrawal);\\n}\\n```\\n\\nNotice that `ineligable` adds `withdrawal` in the end (which is the assets claimed by the user). Now back to collateral and assets calculation:\\n`collateral = totalCollateral + deposit - withdrawal`\\n`assets = collateral - ineligable = collateral - (redemptionEligable * redemption / (redemption + shares) + global.assets + withdrawal)`\\n`assets = totalCollateral + deposit - withdrawal - [redemptionIneligable] - global.assets - withdrawal`\\n`assets = totalCollateral + deposit - [redemptionIneligable] - global.assets - 2 * withdrawal`\\nSee that `withdrawal` (assets claimed by the user) is subtracted twice in assets calculations. This means that assets calculated are smaller than it should. In particular, assets might become less than minAssets thus reverting in the following line:\\n```\\n if (assets.lt(strategy.minAssets)) revert StrategyLibInsufficientAssetsError();\\n```\\n\\nPossible scenario for this issue to cause inability to claim funds:\\nSome vault market's has a high skew (|long - short|), which means that minimum maker position is limited by the skew.\\nUser redeems large amount from the vault, reducing vault's position in that market so that market maker ~= |long - short|. This means that further redeems from the vault are not possible because the vault can't reduce its position in the market.\\nAfter that, the user tries to claim what he has redeemed, but all attempts to redeem will revert (both for this user and for any other user that might want to claim)\\nThe scenario above is demonstrated in the test, change the following test in test/integration/vault/Vault.test.ts:\\n```\\n it('simple deposits and redemptions', async () => {\\n// rest of code\\n // Now we should have opened positions.\\n // The positions should be equal to (smallDeposit + largeDeposit) * leverage originalOraclePrice.\\n expect(await position()).to.equal(\\n smallDeposit.add(largeDeposit).mul(leverage).mul(4).div(5).div(originalOraclePrice),\\n )\\n expect(await btcPosition()).to.equal(\\n smallDeposit.add(largeDeposit).mul(leverage).div(5).div(btcOriginalOraclePrice),\\n )\\n\\n /*** remove all lines after this and replace with the following code: ***/\\n\\n var half = smallDeposit.add(largeDeposit).div(2).add(smallDeposit);\\n await vault.connect(user).update(user.address, 0, half, 0)\\n\\n await updateOracle()\\n await vault.connect(user2).update(user2.address, smallDeposit, 0, 0) // this will create min position in the market\\n await vault.connect(user).update(user.address, 0, 0, half) // this will revert even though it's just claiming\\n })\\n```\\n\\nThe last line in the test will revert, even though it's just claiming assets. If the pre-last line is commented out (no "min position" created in the market), it will work normally.

Remove `add(withdrawal)` from `_ineligable` calculation in the vault.

In certain situations (redeem not possible from the vault due to high skew in some underlying market) claiming assets from the vault will revert for all users, temporarily (and sometimes permanently) locking user funds in the contract.

```\\n_manage(context, depositAssets, claimAmount, !depositAssets.isZero() || !redeemShares.isZero());\\n```\\n

If referral or liquidator is the same address as the account, then liquidation/referral fees will be lost due to local storage being overwritten after the `claimable` amount is credited to liquidator or referral

medium

Any user (address) can be liquidator and/or referral, including account's own address (the user can self-liquidate or self-refer). During the market settlement, liquidator and referral fees are credited to liquidator/referral's `local.claimable` storage. The issue is that the account's local storage is held in the memory during the settlement process, and is saved into storage after settlement/update. This means that `local.claimable` storage changes for the account are not reflected in the in-memory cached copy and discarded when the cached copy is saved after settlement.\\nThis leads to liquidator and referral fees being lost when these are the account's own address.\\nDuring market account settlement process, in the `_processOrderLocal`, liquidator and referral fees are credited to corresponding accounts via:\\n```\\n// rest of code\\n _credit(liquidators[account][newOrderId], accumulationResult.liquidationFee);\\n _credit(referrers[account][newOrderId], accumulationResult.subtractiveFee);\\n// rest of code\\nfunction _credit(address account, UFixed6 amount) private {\\n if (amount.isZero()) return;\\n\\n Local memory newLocal = _locals[account].read();\\n newLocal.credit(amount);\\n _locals[account].store(newLocal);\\n}\\n```\\n\\nHowever, for the account the cached copy of `_locals[account]` is stored after the settlement in _storeContext:\\n```\\nfunction _storeContext(Context memory context, address account) private {\\n // state\\n _global.store(context.global);\\n _locals[account].store(context.local);\\n// rest of code\\n```\\n\\nThe order of these actions is:\\n```\\nfunction settle(address account) external nonReentrant whenNotPaused {\\n Context memory context = _loadContext(account);\\n\\n _settle(context, account);\\n\\n _storeContext(context, account);\\n}\\n```\\n\\nLoad `_locals[account]` into memory (context.local)\\nSettle: during settlement `_locals[account].claimable` is increased for liquidator and referral. Note: this is not reflected in `context.local`\\nStore cached context: `_locals[account]` is overwritten with the `context.local`, losing `claimable` increased during settlement.\\nThe scenario above is demonstrated in the test, add this to test/unit/market/Market.test.ts:\\n```\\nit('self-liquidation fees lost', async () => {\\nconst POSITION = parse6decimal('100.000')\\nconst COLLATERAL = parse6decimal('120')\\n\\nfunction setupOracle(price: string, timestamp : number, nextTimestamp : number) {\\n const oracleVersion = {\\n price: parse6decimal(price),\\n timestamp: timestamp,\\n valid: true,\\n }\\n oracle.at.whenCalledWith(oracleVersion.timestamp).returns(oracleVersion)\\n oracle.status.returns([oracleVersion, nextTimestamp])\\n oracle.request.returns()\\n}\\n\\ndsu.transferFrom.whenCalledWith(user.address, market.address, COLLATERAL.mul(1e12)).returns(true)\\ndsu.transferFrom.whenCalledWith(userB.address, market.address, COLLATERAL.mul(1e12)).returns(true)\\n\\nvar time = TIMESTAMP;\\n\\nsetupOracle('1', time, time + 100);\\nawait market.connect(user)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](user.address, POSITION, 0, 0, COLLATERAL, false);\\n\\ntime += 100;\\nsetupOracle('1', time, time + 100);\\nawait market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, POSITION, 0, COLLATERAL, false);\\n\\ntime += 100;\\nsetupOracle('1', time, time + 100);\\n\\ntime += 100;\\nsetupOracle('0.7', time, time + 100);\\n\\n// self-liquidate\\nsetupOracle('0.7', time, time + 100);\\nawait market.connect(userB)\\n ['update(address,uint256,uint256,uint256,int256,bool)'](userB.address, 0, 0, 0, 0, true);\\n\\n// settle liquidation\\ntime += 100;\\nsetupOracle('0.7', time, time + 100);\\nawait market.settle(userB.address);\\nvar info = await market.locals(userB.address);\\nconsole.log("Claimable userB: " + info.claimable);\\n```\\n\\nConsole log:\\n```\\nClaimable userB: 0\\n```\\n

Modify `Market._credit` function to increase `context.local.claimable` if account to be credited matches account which is being updated.

If user self-liquidates or self-refers, the liquidation and referral fees are lost by the user (and are stuck in the contract, because they're still subtracted from the user's collateral).

```\\n// rest of code\\n _credit(liquidators[account][newOrderId], accumulationResult.liquidationFee);\\n _credit(referrers[account][newOrderId], accumulationResult.subtractiveFee);\\n// rest of code\\nfunction _credit(address account, UFixed6 amount) private {\\n if (amount.isZero()) return;\\n\\n Local memory newLocal = _locals[account].read();\\n newLocal.credit(amount);\\n _locals[account].store(newLocal);\\n}\\n```\\n

_loadContext() uses the wrong pendingGlobal.

medium

`StrategyLib._loadContext()` is using the incorrect `pendingGlobal`, causing `currentPosition`, `minPosition`, and `maxPosition` to be incorrect, leading to incorrect rebalance operation.\\nIn `StrategyLib._loadContext()`, there is a need to compute `currentPosition`, `minPosition`, and `maxPosition`. The code as follows:\\n```\\n function _loadContext(\\n Registration memory registration\\n ) private view returns (MarketStrategyContext memory marketContext) {\\n// rest of code\\n // current position\\n Order memory pendingGlobal = registration.market.pendings(address(this));\\n marketContext.currentPosition = registration.market.position();\\n marketContext.currentPosition.update(pendingGlobal);\\n marketContext.minPosition = marketContext.currentAccountPosition.maker\\n .unsafeSub(marketContext.currentPosition.maker\\n .unsafeSub(marketContext.currentPosition.skew().abs()).min(marketContext.closable));\\n marketContext.maxPosition = marketContext.currentAccountPosition.maker\\n .add(marketContext.riskParameter.makerLimit.unsafeSub(marketContext.currentPosition.maker));\\n }\\n```\\n\\nThe code above `pendingGlobal = registration.market.pendings(address(this));` is wrong It takes the address(this)'s `pendingLocal`. The correct approach is to use `pendingGlobal = registration.market.pending();`.

```\\n function _loadContext(\\n Registration memory registration\\n ) private view returns (MarketStrategyContext memory marketContext) {\\n// rest of code\\n // current position\\n// Remove the line below\\n Order memory pendingGlobal = registration.market.pendings(address(this));\\n// Add the line below\\n Order memory pendingGlobal = registration.market.pending();\\n marketContext.currentPosition = registration.market.position();\\n marketContext.currentPosition.update(pendingGlobal);\\n marketContext.minPosition = marketContext.currentAccountPosition.maker\\n .unsafeSub(marketContext.currentPosition.maker\\n .unsafeSub(marketContext.currentPosition.skew().abs()).min(marketContext.closable));\\n marketContext.maxPosition = marketContext.currentAccountPosition.maker\\n .add(marketContext.riskParameter.makerLimit.unsafeSub(marketContext.currentPosition.maker));\\n }\\n```\\n

Since `pendingGlobal` is wrong, `currentPosition`, `minPosition` and `maxPosition` are all wrong. affects subsequent rebalance calculations, such as `target.position` etc. rebalance does not work properly

```\\n function _loadContext(\\n Registration memory registration\\n ) private view returns (MarketStrategyContext memory marketContext) {\\n// rest of code\\n // current position\\n Order memory pendingGlobal = registration.market.pendings(address(this));\\n marketContext.currentPosition = registration.market.position();\\n marketContext.currentPosition.update(pendingGlobal);\\n marketContext.minPosition = marketContext.currentAccountPosition.maker\\n .unsafeSub(marketContext.currentPosition.maker\\n .unsafeSub(marketContext.currentPosition.skew().abs()).min(marketContext.closable));\\n marketContext.maxPosition = marketContext.currentAccountPosition.maker\\n .add(marketContext.riskParameter.makerLimit.unsafeSub(marketContext.currentPosition.maker));\\n }\\n```\\n

Liquidator can set up referrals for other users

medium

If a user has met the liquidation criteria and currently has no referrer then a malicious liquidator can specify a referrer in the liquidation order. making it impossible for subsequent users to set up the referrer they want.\\nCurrently, there are 2 conditions to set up a referrer\\nthe order cannot be empty （Non-empty orders require authorization unless they are liquidation orders）\\nthere can't be another referrer already\\n```\\n function _loadUpdateContext(\\n Context memory context,\\n address account,\\n address referrer\\n ) private view returns (UpdateContext memory updateContext) {\\n// rest of code\\n updateContext.referrer = referrers[account][context.local.currentId];\\n updateContext.referralFee = IMarketFactory(address(factory())).referralFee(referrer);\\n }\\n\\n function _processReferrer(\\n UpdateContext memory updateContext,\\n Order memory newOrder,\\n address referrer\\n ) private pure {\\n if (newOrder.makerReferral.isZero() && newOrder.takerReferral.isZero()) return;\\n if (updateContext.referrer == address(0)) updateContext.referrer = referrer;\\n if (updateContext.referrer == referrer) return;\\n\\n revert MarketInvalidReferrerError();\\n }\\n\\n\\n function _storeUpdateContext(Context memory context, UpdateContext memory updateContext, address account) private {\\n// rest of code\\n referrers[account][context.local.currentId] = updateContext.referrer;\\n }\\n```\\n\\nHowever, if the user does not have a referrer, the liquidation order is able to meet both of these restrictions\\nThis allows the liquidator to set up referrals for other users.\\nWhen the user subsequently tries to set up a referrer, it will fail.

Restrictions on Liquidation Orders Cannot Set a referrer\\n```\\n function _processReferrer(\\n UpdateContext memory updateContext,\\n Order memory newOrder,\\n address referrer\\n ) private pure {\\n// Add the line below\\n if (newOrder.protected() && referrer != address(0)) revert MarketInvalidReferrerError;\\n if (newOrder.makerReferral.isZero() && newOrder.takerReferral.isZero()) return;\\n if (updateContext.referrer == address(0)) updateContext.referrer = referrer;\\n if (updateContext.referrer == referrer) return;\\n\\n revert MarketInvalidReferrerError();\\n }\\n```\\n

If a user is set up as a referrer by a liquidated order in advance, the user cannot be set up as anyone else.

```\\n function _loadUpdateContext(\\n Context memory context,\\n address account,\\n address referrer\\n ) private view returns (UpdateContext memory updateContext) {\\n// rest of code\\n updateContext.referrer = referrers[account][context.local.currentId];\\n updateContext.referralFee = IMarketFactory(address(factory())).referralFee(referrer);\\n }\\n\\n function _processReferrer(\\n UpdateContext memory updateContext,\\n Order memory newOrder,\\n address referrer\\n ) private pure {\\n if (newOrder.makerReferral.isZero() && newOrder.takerReferral.isZero()) return;\\n if (updateContext.referrer == address(0)) updateContext.referrer = referrer;\\n if (updateContext.referrer == referrer) return;\\n\\n revert MarketInvalidReferrerError();\\n }\\n\\n\\n function _storeUpdateContext(Context memory context, UpdateContext memory updateContext, address account) private {\\n// rest of code\\n referrers[account][context.local.currentId] = updateContext.referrer;\\n }\\n```\\n

Vault and oracle keepers DoS in some situations due to `market.update(account,max,max,max,0,false)`

medium

When user's market account is updated without position and collateral change (by calling market.update(account,max,max,max,0,false)), this serves as some kind of "settling" the account (which was the only way to settle the account before v2.3). However, this action still reverts if the account is below margin requirement.\\nThe issue is that some parts of the code use this action to "settle" the account in the assumption that it never reverts which is not true. This causes unpexpected reverts and denial of service to users who can not execute transactions in some situations, in particular:\\nOracle `KeeperFactory.settle` uses this method to settle all accounts in the market for the oracle verison and will revert entire market version's settlement if any account which is being settled is below margin requirement. Example scenario: 1.1. User increases position to the edge of margin requirement 1.2. The price rises slightly for the commited oracle version, and user position is settled and is now slightly below margin requirements 1.3. All attempts to settle accounts for the commited oracle version for this market will revert as user's account collateral is below margin requirements.\\nVault `Vault._updateUnderlying` uses this method to settle all vault's accounts in the markets. This function is called at the start of `rebalance` and `update`, with `rebalance` also being called before any admin vault parameters changes such as updating market leverages, weights or cap. This becomes especially problematic if any market is "removed" from the vault by setting its weight to 0, but the market still has some position due to `minPosition` limitation (as described in another issue). In such case each vault `update` will bring this market's position to exact edge of margin requirement, meaning a lot of times minimal price changes will put the vault's market account below margin requirement, and as such most Vault functions will revert (update, `rebalance` and admin param changes). Moreover, since the vault rebalances collateral and/or position size only in `_manage` (which is called only from `update` and rebalance), this means that the vault is basically bricked until this position is either liquidated or goes above margin requirement again due to price changes.\\nWhen `Market.update` is called, any parameters except `protected = true` will perform the following check from the InvariantLib.validate:\\n```\\nif (\\n !PositionLib.margined(\\n context.latestPosition.local.magnitude().add(context.pending.local.pos()),\\n context.latestOracleVersion,\\n context.riskParameter,\\n context.local.collateral\\n )\\n) revert IMarket.MarketInsufficientMarginError();\\n```\\n\\nThis means that even updates which do not change anything (empty order and 0 collateral change) still perform this check and revert if the user's collateral is below margin requirement.\\nSuch method to settle accounts is used in KeeperOracle._settle:\\n```\\nfunction _settle(IMarket market, address account) private {\\n market.update(account, UFixed6Lib.MAX, UFixed6Lib.MAX, UFixed6Lib.MAX, Fixed6Lib.ZERO, false);\\n}\\n```\\n\\nThis is called from `KeeperFactory.settle`, which the keepers are supposed to call to settle market accounts after the oracle version is commited. This will revert, thus keepers will temporarily be unable to call this function for the specific oracle version until all users are at or above margin.\\nThe same method is used to settle accounts in Vault._updateUnderlying:\\n```\\nfunction _updateUnderlying() private {\\n for (uint256 marketId; marketId < totalMarkets; marketId++)\\n _registrations[marketId].read().market.update(\\n address(this),\\n UFixed6Lib.MAX,\\n UFixed6Lib.ZERO,\\n UFixed6Lib.ZERO,\\n Fixed6Lib.ZERO,\\n false\\n );\\n}\\n```\\n

Depending on intended functionality:\\nIgnore the margin requirement for empty orders and collateral change which is >= 0. AND/OR\\nUse `Market.settle` instead of `Market.update` to `settle` accounts, specifically in `KeeperOracle._settle` and in `Vault._updateUnderlying`. There doesn't seem to be any reason or issue to use `settle` instead of `update`, it seems that `update` is there just because there was no `settle` function available before.

Keepers are unable to settle market accounts for the commited oracle version until all accounts are above margin. The oracle fees are still taken from all accounts, but the keepers are blocked from receiving it.\\nIf any Vault's market weight is set to 0 (or if vault's position in any market goes below margin for whatever other reason), most of the time the vault will temporarily be bricked until vault's position in that market is liquidated. The only function working in this state is `Vault.settle`, even all admin functions will revert.

```\\nif (\\n !PositionLib.margined(\\n context.latestPosition.local.magnitude().add(context.pending.local.pos()),\\n context.latestOracleVersion,\\n context.riskParameter,\\n context.local.collateral\\n )\\n) revert IMarket.MarketInsufficientMarginError();\\n```\\n

Vault checkpoints slightly incorrect conversion from assets to shares leads to slow loss of funds for long-time vault depositors

medium

When vault checkpoints convert assets to shares (specifically used to calculate user's shares for their deposit), it uses the following formula: `shares = (assets[before fee] - settlementFee) * checkpoint.shares/checkpoint.assets * (deposit + redeem - tradeFee) / (deposit + redeem)`\\n`settlementFee` in this formula is taken into account slightly incorrectly: in actual market collateral calculations, both settlement fee and trade fee are subtracted from collateral, but this formula basically multiplies `1 - settlement fee percentage` by `1 - trade fee percentage`, which is slightly different and adds the calculation error = `settlement fee percentage * trade fee percentage`.\\nThis is the scenario to better understand the issue:\\nLinear fee = 2%, settlement fee = $1\\nUser1 deposits $100 into the vault (linear fee = $2, settlement fee = $1)\\nVault assets = $97 (due to fees), User1 shares = 100\\nUser2 deposits $100 into the vault (linear fee = $2, settlement fee = $1)\\nVault assets = $194, User1 shares = 100, but User2 shares = 100.02, meaning User1's share value has slightly fallen due to a later deposit.\\nThis is the calculation for User2 shares: `shares = ($100 - $1) * 100/$97 * ($100 - $2) / $100 = $99 * 100/$97 * $98/$100 = $99 * 98/$97 = 100.02`\\nThe extra 0.02 this user has received is because the `tradeFee` is taken from the amount after settlement fee ($99) rather than full amount as it should ($100). This difference (settlementFee * `tradeFee` = $0.02) is unfair amount earned by User2 and loss of funds for User1.\\nWhen redeeming, the formula for shares -> assets vault checkpoint conversion is correct and the correct amount is redeemed.\\nThis issue leads to all vault depositors slowly losing share value with each deposit, and since no value is gained when redeeming, continuous deposits and redeems will lead to all long-time depositors continuously losing their funds.\\nThis is the formula for vault checkpoint toSharesGlobal:\\n```\\nfunction toSharesGlobal(Checkpoint memory self, UFixed6 assets) internal pure returns (UFixed6) {\\n // vault is fresh, use par value\\n if (self.shares.isZero()) return assets;\\n\\n // if vault is insolvent, default to par value\\n return self.assets.lte(Fixed6Lib.ZERO) ? assets : _toShares(self, _withoutSettlementFeeGlobal(self, assets));\\n}\\n\\nfunction _toShares(Checkpoint memory self, UFixed6 assets) private pure returns (UFixed6) {\\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\\n return _withSpread(self, assets.muldiv(self.shares, selfAssets));\\n}\\n\\nfunction _withSpread(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\\n UFixed6 totalAmount = self.deposit.add(self.redemption.muldiv(selfAssets, self.shares));\\n UFixed6 totalAmountIncludingFee = UFixed6Lib.unsafeFrom(Fixed6Lib.from(totalAmount).sub(self.tradeFee));\\n\\n return totalAmount.isZero() ?\\n amount :\\n amount.muldiv(totalAmountIncludingFee, totalAmount);\\n}\\n\\nfunction _withoutSettlementFeeGlobal(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\\n return _withoutSettlementFee(amount, self.settlementFee);\\n}\\n\\nfunction _withoutSettlementFee(UFixed6 amount, UFixed6 settlementFee) private pure returns (UFixed6) {\\n return amount.unsafeSub(settlementFee);\\n}\\n```\\n\\nThis code translates to a formula shown above, i.e. it first subtracts settlement fee from the assets (withoutSettlementFeeGlobal), then multiplies this by checkpoint's share value in `_toShares` (*checkpoint.shares/checkpoint.assets), and then multiplies this by trade fee adjustment in `_withSpread` (*(deposit+redeem-tradeFee) / (deposit+redeem)). Here is the formula again: `shares = (assets[before fee] - settlementFee) * checkpoint.shares/checkpoint.assets * (deposit + redeem - tradeFee) / (deposit + redeem)`\\nAs shown above, the formula is incorrect, because it basically does the following: `user_assets = (deposit - settlementFee) * (deposit - tradeFee)/deposit = deposit * (1 - settlementFeePct) * (1 - tradeFeePct)`\\nBut the actual user collateral after fees is calculated as: `user_assets = deposit - settlementFee - tradeFee = deposit * (1 - settlementFeePct - tradeFeePct)`\\nIf we subtract the actual collateral from the formula used in checkpoint, we get the error: `error = deposit * ((1 - settlementFeePct) * (1 - tradeFeePct) - (1 - settlementFeePct - tradeFeePct))` `error = deposit * settlementFeePct * tradeFeePct` `error = settlementFee * tradeFeePct`\\nSo this is systematic error, which inflates the shares given to users with any deposit by fixed amount of `settlementFee * tradeFeePct`

Re-work the assets to shares conversion in vault checkpoint to use the correct formula: `shares = (assets[before fee] - settlementFee - tradeFee * assets / (deposit + redeem)) * checkpoint.shares/checkpoint.assets`

Any vault deposit reduces the vault assets by `settlementFee * tradeFeePct`. While this amount is not very large (in the order of $0.1 - $0.001 per deposit transaction), this is amount lost with each deposit, and given that an active vault can easily have 1000s of transactions daily, this will be a loss of $1-$100/day, which is significant enough to make it a valid issue.

```\\nfunction toSharesGlobal(Checkpoint memory self, UFixed6 assets) internal pure returns (UFixed6) {\\n // vault is fresh, use par value\\n if (self.shares.isZero()) return assets;\\n\\n // if vault is insolvent, default to par value\\n return self.assets.lte(Fixed6Lib.ZERO) ? assets : _toShares(self, _withoutSettlementFeeGlobal(self, assets));\\n}\\n\\nfunction _toShares(Checkpoint memory self, UFixed6 assets) private pure returns (UFixed6) {\\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\\n return _withSpread(self, assets.muldiv(self.shares, selfAssets));\\n}\\n\\nfunction _withSpread(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\\n UFixed6 selfAssets = UFixed6Lib.unsafeFrom(self.assets);\\n UFixed6 totalAmount = self.deposit.add(self.redemption.muldiv(selfAssets, self.shares));\\n UFixed6 totalAmountIncludingFee = UFixed6Lib.unsafeFrom(Fixed6Lib.from(totalAmount).sub(self.tradeFee));\\n\\n return totalAmount.isZero() ?\\n amount :\\n amount.muldiv(totalAmountIncludingFee, totalAmount);\\n}\\n\\nfunction _withoutSettlementFeeGlobal(Checkpoint memory self, UFixed6 amount) private pure returns (UFixed6) {\\n return _withoutSettlementFee(amount, self.settlementFee);\\n}\\n\\nfunction _withoutSettlementFee(UFixed6 amount, UFixed6 settlementFee) private pure returns (UFixed6) {\\n return amount.unsafeSub(settlementFee);\\n}\\n```\\n

ChainlinkFactory will pay non-requested versions keeper fees

medium

Protocol definition: `Requested versions will pay out a keeper fee, non-requested versions will not.` But ChainlinkFactory ignores `numRequested`, which pays for both.\\nProtocol definition: `Requested versions will pay out a keeper fee, non-requested versions will not.`\\n```\\n /// @notice Commits the price to specified version\\n /// @dev Accepts both requested and non-requested versions.\\n /// Requested versions will pay out a keeper fee, non-requested versions will not.\\n /// Accepts any publish time in the underlying price message, as long as it is within the validity window,\\n /// which means its possible for publish times to be slightly out of order with respect to versions.\\n /// Batched updates are supported by passing in a list of price feed ids along with a valid batch update data.\\n /// @param ids The list of price feed ids to commit\\n /// @param version The oracle version to commit\\n /// @param data The update data to commit\\n function commit(bytes32[] memory ids, uint256 version, bytes calldata data) external payable {\\n```\\n\\ncommit()->_handleKeeperFee()->_applicableValue() `ChainlinkFactory._applicableValue ()` implements the following:\\n```\\n function _applicableValue(uint256, bytes memory data) internal view override returns (uint256) {\\n bytes[] memory payloads = abi.decode(data, (bytes[]));\\n uint256 totalFeeAmount = 0;\\n for (uint256 i = 0; i < payloads.length; i++) {\\n (, bytes memory report) = abi.decode(payloads[i], (bytes32[3], bytes));\\n (Asset memory fee, ,) = feeManager.getFeeAndReward(address(this), report, feeTokenAddress);\\n totalFeeAmount += fee.amount;\\n }\\n return totalFeeAmount;\\n }\\n```\\n\\nThe above method ignores the first parameter `numRequested`. This way, whether it is `Requested versions` or not, you will pay `keeper fees`. Violating `non-requested versions will not pay`

It is recommended that only `Requested versions` keeper fees'\\n```\\n// Remove the line below\\n function _applicableValue(uint256 , bytes memory data) internal view override returns (uint256) {\\n// Add the line below\\n function _applicableValue(uint256 numRequested, bytes memory data) internal view override returns (uint256) {\\n bytes[] memory payloads = abi.decode(data, (bytes[]));\\n uint256 totalFeeAmount = 0;\\n for (uint256 i = 0; i < payloads.length; i// Add the line below\\n// Add the line below\\n) {\\n (, bytes memory report) = abi.decode(payloads[i], (bytes32[3], bytes));\\n (Asset memory fee, ,) = feeManager.getFeeAndReward(address(this), report, feeTokenAddress);\\n totalFeeAmount // Add the line below\\n= fee.amount;\\n }\\n// Remove the line below\\n return totalFeeAmount;\\n// Add the line below\\n return totalFeeAmount * numRequested / payloads.length ;\\n }\\n```\\n

If `non-requested versions` will pay as well, it is easy to maliciously submit `non-requested` maliciously consume `ChainlinkFactory` fees balance (Note that needs at least one numRequested to call `_handleKeeperFee()` )

```\\n /// @notice Commits the price to specified version\\n /// @dev Accepts both requested and non-requested versions.\\n /// Requested versions will pay out a keeper fee, non-requested versions will not.\\n /// Accepts any publish time in the underlying price message, as long as it is within the validity window,\\n /// which means its possible for publish times to be slightly out of order with respect to versions.\\n /// Batched updates are supported by passing in a list of price feed ids along with a valid batch update data.\\n /// @param ids The list of price feed ids to commit\\n /// @param version The oracle version to commit\\n /// @param data The update data to commit\\n function commit(bytes32[] memory ids, uint256 version, bytes calldata data) external payable {\\n```\\n

Liquidity provider fees can be stolen from any pair

high

An attacker can steal the liquidiy providers fees by transfering liquidity tokens to the pair and then withdrawing fees on behalf of the pair itself.\\nThis is possible because of two reasons:\\nTransfering liquidity tokens to the pair itself doesn't update the fee tracking variables:\\n```\\nif (to != address(this)) {\\n _updateFeeRewards(to);\\n}\\n```\\n\\nwhich results in the variable `feesPerTokenPaid[address(pair)]` of the pair being equal to 0.\\nThe function withdrawFees() is a permissionless function that allows to withdraw fees on behalf of any address, including the pair itself.\\nBy combining this two quirks of the codebase an attacker can steal all of the currently pending liquidity provider fees by doing the following:\\nAdd liquidity to a pair, which will mint the attacker some liquidity tokens\\nTransfer the liquidity tokens to the pair directly\\nCall withdrawFees() by passing the address of the pair. Because `feesPerTokenPaid[address(pair)]` is 0 this will collect fees on behalf of the pair even if it shouldn't. The function will transfer an amount `x` of WETH from the pair to the pair itself and will lower the `_pendingLiquidityFee` variable by that same amount\\nBecause the variable `_pendingLiquidityFee` has been lowered by `x` the pool will assume someone transferred `x` WETH to it\\nAt this point the attacker can take advantage of this however he likes, but for the sake of the example let's suppose he calls swap() to swap `x` ETH into tokens that will be transferred to his wallet\\nThe attacker burns the liquidity transferred at point `2` to recover his funds\\nPOC\\n

In withdrawFees(pair) add a require statement to prevent fees being withdrawn on behalf of the pool.\\n```\\nrequire(to != address(this));\\n```\\n

Liquidity provider fees can be stolen from any pair.

```\\nif (to != address(this)) {\\n _updateFeeRewards(to);\\n}\\n```\\n

Some unusual problems arise in the use of the `GoatV1Factory.sol#createPair()` function.

medium

If you create a new pool for tokens and add liquidity using the `GoatRouterV1.sol#addLiquidity()` function, the bootstrap function of the protocol is broken. Therefore, an attacker can perform the front running attack on the `GoatRouterV1.sol#addLiquidity()` function by front calling `GoatV1Factory.sol#createPair()`.\\nIf a pool for the token does not exist, the LP can create a new pool using the `GoatV1Factory.sol#createPair()` function. Next he calls `GoatRouterV1.sol#addLiquidity()` to provide liquidity. At this time, the amount of WETH and ERC20Token provided to the pool is calculated in the `GoatRouterV1.sol#_addLiquidity()` function.\\n```\\n function _addLiquidity(\\n address token,\\n uint256 tokenDesired,\\n uint256 wethDesired,\\n uint256 tokenMin,\\n uint256 wethMin,\\n GoatTypes.InitParams memory initParams\\n ) internal returns (uint256, uint256, bool) {\\n GoatTypes.LocalVariables_AddLiquidity memory vars;\\n GoatV1Pair pair = GoatV1Pair(GoatV1Factory(FACTORY).getPool(token));\\n if (address(pair) == address(0)) {\\n // First time liquidity provider\\n pair = GoatV1Pair(GoatV1Factory(FACTORY).createPair(token, initParams));\\n vars.isNewPair = true;\\n }\\n\\n if (vars.isNewPair) {\\n// rest of codeSNIP\\n } else {\\n /**\\n * @dev This block is accessed after the presale period is over and the pool is converted to AMM\\n */\\n (uint256 wethReserve, uint256 tokenReserve) = pair.getReserves();\\n uint256 tokenAmountOptimal = GoatLibrary.quote(wethDesired, wethReserve, tokenReserve);\\n if (tokenAmountOptimal <= tokenDesired) {\\n if (tokenAmountOptimal < tokenMin) {\\n revert GoatErrors.InsufficientTokenAmount();\\n }\\n (vars.tokenAmount, vars.wethAmount) = (tokenAmountOptimal, wethDesired);\\n } else {\\n uint256 wethAmountOptimal = GoatLibrary.quote(tokenDesired, tokenReserve, wethReserve);\\n assert(wethAmountOptimal <= wethDesired);\\n if (wethAmountOptimal < wethMin) revert GoatErrors.InsufficientWethAmount();\\n (vars.tokenAmount, vars.wethAmount) = (tokenDesired, wethAmountOptimal);\\n }\\n }\\n return (vars.tokenAmount, vars.wethAmount, vars.isNewPair);\\n }\\n```\\n\\nFor simplicity, let's only consider from #L250 to #L256.\\nL250:wethReserve = virtualEth, tokenReserve = initialTokenMatch - (initialTokenMatch - ((virtualEth * initialTokenMatch)/(virtualEth + bootstrapEth)) + + (virtualEthinitialTokenMatchbootstrapEth)/(virtualEth + bootstrapEth) ^ 2) = = ((virtualEth * initialTokenMatch)/(virtualEth + bootstrapEth)) - (virtualEthinitialTokenMatchbootstrapEth)/(virtualEth + bootstrapEth) ^ 2 L251:tokenAmountOptimal = wethDesired * wethReserve / tokenReserve vars.tokenAmount = tokenAmountOptimal vars.wethAmount = wethDesired\\nAt this time, At this time, the calculated balance of ETH and token is sent to the pool, and `GoatV1Pair(vars.pair).mint()` is called in the `GoatRouterV1.sol#addLiquidity()` function.\\n```\\n function addLiquidity(\\n address token,\\n uint256 tokenDesired,\\n uint256 wethDesired,\\n uint256 tokenMin,\\n uint256 wethMin,\\n address to,\\n uint256 deadline,\\n GoatTypes.InitParams memory initParams\\n ) external nonReentrant ensure(deadline) returns (uint256, uint256, uint256) {\\n// rest of codeSNIP\\n IERC20(vars.token).safeTransferFrom(msg.sender, vars.pair, vars.actualTokenAmount);\\n if (vars.wethAmount != 0) {\\n IERC20(WETH).safeTransferFrom(msg.sender, vars.pair, vars.wethAmount);\\n }\\n vars.liquidity = GoatV1Pair(vars.pair).mint(to);\\n// rest of codeSNIP\\n }\\n```\\n\\nNext, the `GoatV1Pair(vars.pair).mint()` function checks the validity of the transmitted token.\\n```\\n function mint(address to) external nonReentrant returns (uint256 liquidity) {\\n // rest of codeSNIP\\n if (_vestingUntil == _MAX_UINT32) {\\n // Do not allow to add liquidity in presale period\\n if (totalSupply_ > 0) revert GoatErrors.PresalePeriod();\\n // don't allow to send more eth than bootstrap eth\\n if (balanceEth > mintVars.bootstrapEth) {\\n revert GoatErrors.SupplyMoreThanBootstrapEth();\\n }\\n\\n if (balanceEth < mintVars.bootstrapEth) {\\n (uint256 tokenAmtForPresale, uint256 tokenAmtForAmm) = _tokenAmountsForLiquidityBootstrap(\\n mintVars.virtualEth, mintVars.bootstrapEth, balanceEth, mintVars.initialTokenMatch\\n );\\n if (balanceToken != (tokenAmtForPresale + tokenAmtForAmm)) {\\n revert GoatErrors.InsufficientTokenAmount();\\n }\\n liquidity =\\n Math.sqrt(uint256(mintVars.virtualEth) * uint256(mintVars.initialTokenMatch)) - MINIMUM_LIQUIDITY;\\n } else {\\n // This means that user is willing to make this pool an amm pool in first liquidity mint\\n liquidity = Math.sqrt(balanceEth * balanceToken) - MINIMUM_LIQUIDITY;\\n uint32 timestamp = uint32(block.timestamp);\\n _vestingUntil = timestamp + VESTING_PERIOD;\\n }\\n mintVars.isFirstMint = true;\\n }\\n // rest of codeSNIP\\n }\\n```\\n\\nIn here, `balanceToken = vars.tokenAmount (value:tokenAmountOptimal)` and `tokenAmtForPresale + tokenAmtForAmm` is calculated follows.\\ntokenAmtForPresale = initialTokenMatch - (virtualEth * initialTokenMatch / (virtualEth + bootstrapEth)) - - (balanceEth(value:wethDesired)*initialTokenMatch/(virtualEth+balanceEth)) tokenAmtForAmm = (virtualEth * initialTokenMatch * bootstrapEth) / (virtualEth + bootstrapEth) ^ 2\\nAs a result, `(balanceToken != (tokenAmtForPresale + tokenAmtForAmm)) == true`, the `GoatRouterV1.sol#addLiquidity()` function is reverted. In this case, If the initial LP want to provide liquidity to the pool, he must pay an amount of WETH equivalent to bootstrapEth to execute #L146. As a result, the bootstrap function is broken.\\nBased on this fact, an attacker can front run the `createPair()` function if he finds the `addLiquidity()` function in the mempool.

It is recommended that the `GoatV1Factory.sol#.createPair()` function be called only from the `GoatRouterV1` contract.

The bootstrap function of the protocol is broken and the initial LP must pay an amount of WETH equivalent to bootstrapEth.

```\\n function _addLiquidity(\\n address token,\\n uint256 tokenDesired,\\n uint256 wethDesired,\\n uint256 tokenMin,\\n uint256 wethMin,\\n GoatTypes.InitParams memory initParams\\n ) internal returns (uint256, uint256, bool) {\\n GoatTypes.LocalVariables_AddLiquidity memory vars;\\n GoatV1Pair pair = GoatV1Pair(GoatV1Factory(FACTORY).getPool(token));\\n if (address(pair) == address(0)) {\\n // First time liquidity provider\\n pair = GoatV1Pair(GoatV1Factory(FACTORY).createPair(token, initParams));\\n vars.isNewPair = true;\\n }\\n\\n if (vars.isNewPair) {\\n// rest of codeSNIP\\n } else {\\n /**\\n * @dev This block is accessed after the presale period is over and the pool is converted to AMM\\n */\\n (uint256 wethReserve, uint256 tokenReserve) = pair.getReserves();\\n uint256 tokenAmountOptimal = GoatLibrary.quote(wethDesired, wethReserve, tokenReserve);\\n if (tokenAmountOptimal <= tokenDesired) {\\n if (tokenAmountOptimal < tokenMin) {\\n revert GoatErrors.InsufficientTokenAmount();\\n }\\n (vars.tokenAmount, vars.wethAmount) = (tokenAmountOptimal, wethDesired);\\n } else {\\n uint256 wethAmountOptimal = GoatLibrary.quote(tokenDesired, tokenReserve, wethReserve);\\n assert(wethAmountOptimal <= wethDesired);\\n if (wethAmountOptimal < wethMin) revert GoatErrors.InsufficientWethAmount();\\n (vars.tokenAmount, vars.wethAmount) = (tokenDesired, wethAmountOptimal);\\n }\\n }\\n return (vars.tokenAmount, vars.wethAmount, vars.isNewPair);\\n }\\n```\\n

No check for `initialEth` in `GoatV1Pair.takeOverPool()`.

medium

GoatV1Pair.takeOverPool() only checks the amount of `token` for initialization, not `initialETH`.\\n```\\n function takeOverPool(GoatTypes.InitParams memory initParams) external {\\n if (_vestingUntil != _MAX_UINT32) {\\n revert GoatErrors.ActionNotAllowed();\\n }\\n\\n GoatTypes.InitialLPInfo memory initialLpInfo = _initialLPInfo;\\n\\n GoatTypes.LocalVariables_TakeOverPool memory localVars;\\n address to = msg.sender;\\n localVars.virtualEthOld = _virtualEth;\\n localVars.bootstrapEthOld = _bootstrapEth;\\n localVars.initialTokenMatchOld = _initialTokenMatch;\\n\\n (localVars.tokenAmountForPresaleOld, localVars.tokenAmountForAmmOld) = _tokenAmountsForLiquidityBootstrap(\\n localVars.virtualEthOld,\\n localVars.bootstrapEthOld,\\n initialLpInfo.initialWethAdded,\\n localVars.initialTokenMatchOld\\n );\\n\\n // new token amount for bootstrap if no swaps would have occured\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, initParams.initialEth, initParams.initialTokenMatch\\n );\\n\\n // team needs to add min 10% more tokens than the initial lp to take over\\n localVars.minTokenNeeded =\\n ((localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld) * 11000) / 10000;\\n\\n481 if ((localVars.tokenAmountForAmmNew + localVars.tokenAmountForPresaleNew) < localVars.minTokenNeeded) {\\n revert GoatErrors.InsufficientTakeoverTokenAmount();\\n }\\n\\n localVars.reserveEth = _reserveEth;\\n\\n // Actual token amounts needed if the reserves have updated after initial lp mint\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, localVars.reserveEth, initParams.initialTokenMatch\\n );\\n localVars.reserveToken = _reserveToken;\\n\\n // amount of tokens transferred by the new team\\n uint256 tokenAmountIn = IERC20(_token).balanceOf(address(this)) - localVars.reserveToken;\\n\\n if (\\n tokenAmountIn\\n < (\\n localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld - localVars.reserveToken\\n + localVars.tokenAmountForPresaleNew + localVars.tokenAmountForAmmNew\\n )\\n ) {\\n revert GoatErrors.IncorrectTokenAmount();\\n }\\n\\n localVars.pendingLiquidityFees = _pendingLiquidityFees;\\n localVars.pendingProtocolFees = _pendingProtocolFees;\\n\\n // amount of weth transferred by the new team\\n uint256 wethAmountIn = IERC20(_weth).balanceOf(address(this)) - localVars.reserveEth\\n - localVars.pendingLiquidityFees - localVars.pendingProtocolFees;\\n\\n if (wethAmountIn < localVars.reserveEth) {\\n revert GoatErrors.IncorrectWethAmount();\\n }\\n\\n _handleTakeoverTransfers(\\n IERC20(_weth), IERC20(_token), initialLpInfo.liquidityProvider, localVars.reserveEth, localVars.reserveToken\\n );\\n\\n uint256 lpBalance = balanceOf(initialLpInfo.liquidityProvider);\\n _burn(initialLpInfo.liquidityProvider, lpBalance);\\n\\n // new lp balance\\n lpBalance = Math.sqrt(uint256(initParams.virtualEth) * initParams.initialTokenMatch) - MINIMUM_LIQUIDITY;\\n _mint(to, lpBalance);\\n\\n _updateStateAfterTakeover(\\n initParams.virtualEth,\\n initParams.bootstrapEth,\\n initParams.initialTokenMatch,\\n wethAmountIn,\\n tokenAmountIn,\\n lpBalance,\\n to,\\n initParams.initialEth\\n );\\n }\\n```\\n\\nAlthough there is a check for the amount of `token` at L481, if the caller sets `initParams.initialEth` to 0, it can easily pass L481 because a smaller `initParams.initialEth` results in a larger `localVars.tokenAmountForAmmNew + localVars.tokenAmountForPresaleNew`. This is due to the fact that the former initial provider's `initialEth` does not have any effect in preventing takeovers.

There should be a check for `initParams.initialEth`.

A pool could be unfairly taken over because the former initial provider's `initialEth` does not have any effect in preventing takeovers.

```\\n function takeOverPool(GoatTypes.InitParams memory initParams) external {\\n if (_vestingUntil != _MAX_UINT32) {\\n revert GoatErrors.ActionNotAllowed();\\n }\\n\\n GoatTypes.InitialLPInfo memory initialLpInfo = _initialLPInfo;\\n\\n GoatTypes.LocalVariables_TakeOverPool memory localVars;\\n address to = msg.sender;\\n localVars.virtualEthOld = _virtualEth;\\n localVars.bootstrapEthOld = _bootstrapEth;\\n localVars.initialTokenMatchOld = _initialTokenMatch;\\n\\n (localVars.tokenAmountForPresaleOld, localVars.tokenAmountForAmmOld) = _tokenAmountsForLiquidityBootstrap(\\n localVars.virtualEthOld,\\n localVars.bootstrapEthOld,\\n initialLpInfo.initialWethAdded,\\n localVars.initialTokenMatchOld\\n );\\n\\n // new token amount for bootstrap if no swaps would have occured\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, initParams.initialEth, initParams.initialTokenMatch\\n );\\n\\n // team needs to add min 10% more tokens than the initial lp to take over\\n localVars.minTokenNeeded =\\n ((localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld) * 11000) / 10000;\\n\\n481 if ((localVars.tokenAmountForAmmNew + localVars.tokenAmountForPresaleNew) < localVars.minTokenNeeded) {\\n revert GoatErrors.InsufficientTakeoverTokenAmount();\\n }\\n\\n localVars.reserveEth = _reserveEth;\\n\\n // Actual token amounts needed if the reserves have updated after initial lp mint\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, localVars.reserveEth, initParams.initialTokenMatch\\n );\\n localVars.reserveToken = _reserveToken;\\n\\n // amount of tokens transferred by the new team\\n uint256 tokenAmountIn = IERC20(_token).balanceOf(address(this)) - localVars.reserveToken;\\n\\n if (\\n tokenAmountIn\\n < (\\n localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld - localVars.reserveToken\\n + localVars.tokenAmountForPresaleNew + localVars.tokenAmountForAmmNew\\n )\\n ) {\\n revert GoatErrors.IncorrectTokenAmount();\\n }\\n\\n localVars.pendingLiquidityFees = _pendingLiquidityFees;\\n localVars.pendingProtocolFees = _pendingProtocolFees;\\n\\n // amount of weth transferred by the new team\\n uint256 wethAmountIn = IERC20(_weth).balanceOf(address(this)) - localVars.reserveEth\\n - localVars.pendingLiquidityFees - localVars.pendingProtocolFees;\\n\\n if (wethAmountIn < localVars.reserveEth) {\\n revert GoatErrors.IncorrectWethAmount();\\n }\\n\\n _handleTakeoverTransfers(\\n IERC20(_weth), IERC20(_token), initialLpInfo.liquidityProvider, localVars.reserveEth, localVars.reserveToken\\n );\\n\\n uint256 lpBalance = balanceOf(initialLpInfo.liquidityProvider);\\n _burn(initialLpInfo.liquidityProvider, lpBalance);\\n\\n // new lp balance\\n lpBalance = Math.sqrt(uint256(initParams.virtualEth) * initParams.initialTokenMatch) - MINIMUM_LIQUIDITY;\\n _mint(to, lpBalance);\\n\\n _updateStateAfterTakeover(\\n initParams.virtualEth,\\n initParams.bootstrapEth,\\n initParams.initialTokenMatch,\\n wethAmountIn,\\n tokenAmountIn,\\n lpBalance,\\n to,\\n initParams.initialEth\\n );\\n }\\n```\\n

Legitimate pools can be taken over and the penalty is not fair.

medium

In GoatV1Pair.takeOverPool(), a malicious user can take over pool from a legitimate user, because the mechanism for identifying is incorrect. And the penalty mechanism is not fair.\\nGoatV1Pair.takeOverPool() function exists to avoid grief, because only one pool can be created for each token. Doc says "They can then lower the amount of virtual Ether or Ether to be raised, but not make it higher." about GoatV1Pair.takeOverPool(). However, there is no checking for the amount of virtual Ether. This made it possible that legitimate pools can be taken over by malicious users.\\nL481 and L496 checks the amount of tokens, but there is no check for virtual Ether or Ether to be raised. So, a malicious user can take over a legitimate pool without any cost. He can remove his cost by increasing the amount of virtual Ether or reserved Ether. Paying +10 percent token can do nothing with it. Furthermore, the old liquidity provider should pay 5% penalty. This is very unfair. Generally, a malicious user have no Ether reserved. So, it is only harmful to legitimate users.\\n```\\n function takeOverPool(GoatTypes.InitParams memory initParams) external {\\n if (_vestingUntil != _MAX_UINT32) {\\n revert GoatErrors.ActionNotAllowed();\\n }\\n\\n GoatTypes.InitialLPInfo memory initialLpInfo = _initialLPInfo;\\n\\n GoatTypes.LocalVariables_TakeOverPool memory localVars;\\n address to = msg.sender;\\n localVars.virtualEthOld = _virtualEth;\\n localVars.bootstrapEthOld = _bootstrapEth;\\n localVars.initialTokenMatchOld = _initialTokenMatch;\\n\\n (localVars.tokenAmountForPresaleOld, localVars.tokenAmountForAmmOld) = _tokenAmountsForLiquidityBootstrap(\\n localVars.virtualEthOld,\\n localVars.bootstrapEthOld,\\n initialLpInfo.initialWethAdded,\\n localVars.initialTokenMatchOld\\n );\\n\\n // new token amount for bootstrap if no swaps would have occured\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, initParams.initialEth, initParams.initialTokenMatch\\n );\\n\\n // team needs to add min 10% more tokens than the initial lp to take over\\n localVars.minTokenNeeded =\\n ((localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld) * 11000) / 10000;\\n\\n481 if ((localVars.tokenAmountForAmmNew + localVars.tokenAmountForPresaleNew) < localVars.minTokenNeeded) {\\n revert GoatErrors.InsufficientTakeoverTokenAmount();\\n }\\n\\n localVars.reserveEth = _reserveEth;\\n\\n // Actual token amounts needed if the reserves have updated after initial lp mint\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, localVars.reserveEth, initParams.initialTokenMatch\\n );\\n localVars.reserveToken = _reserveToken;\\n\\n // amount of tokens transferred by the new team\\n uint256 tokenAmountIn = IERC20(_token).balanceOf(address(this)) - localVars.reserveToken;\\n\\n if (\\n496 tokenAmountIn\\n497 < (\\n498 localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld - localVars.reserveToken\\n499 + localVars.tokenAmountForPresaleNew + localVars.tokenAmountForAmmNew\\n500 )\\n ) {\\n revert GoatErrors.IncorrectTokenAmount();\\n }\\n\\n localVars.pendingLiquidityFees = _pendingLiquidityFees;\\n localVars.pendingProtocolFees = _pendingProtocolFees;\\n\\n // amount of weth transferred by the new team\\n uint256 wethAmountIn = IERC20(_weth).balanceOf(address(this)) - localVars.reserveEth\\n - localVars.pendingLiquidityFees - localVars.pendingProtocolFees;\\n\\n if (wethAmountIn < localVars.reserveEth) {\\n revert GoatErrors.IncorrectWethAmount();\\n }\\n\\n _handleTakeoverTransfers(\\n IERC20(_weth), IERC20(_token), initialLpInfo.liquidityProvider, localVars.reserveEth, localVars.reserveToken\\n );\\n\\n uint256 lpBalance = balanceOf(initialLpInfo.liquidityProvider);\\n _burn(initialLpInfo.liquidityProvider, lpBalance);\\n\\n // new lp balance\\n lpBalance = Math.sqrt(uint256(initParams.virtualEth) * initParams.initialTokenMatch) - MINIMUM_LIQUIDITY;\\n _mint(to, lpBalance);\\n\\n _updateStateAfterTakeover(\\n initParams.virtualEth,\\n initParams.bootstrapEth,\\n initParams.initialTokenMatch,\\n wethAmountIn,\\n tokenAmountIn,\\n lpBalance,\\n to,\\n initParams.initialEth\\n );\\n }\\n```\\n

I think that the mechanism for identifying should be improved.

Legitimate pools can be taken over unfairly.

```\\n function takeOverPool(GoatTypes.InitParams memory initParams) external {\\n if (_vestingUntil != _MAX_UINT32) {\\n revert GoatErrors.ActionNotAllowed();\\n }\\n\\n GoatTypes.InitialLPInfo memory initialLpInfo = _initialLPInfo;\\n\\n GoatTypes.LocalVariables_TakeOverPool memory localVars;\\n address to = msg.sender;\\n localVars.virtualEthOld = _virtualEth;\\n localVars.bootstrapEthOld = _bootstrapEth;\\n localVars.initialTokenMatchOld = _initialTokenMatch;\\n\\n (localVars.tokenAmountForPresaleOld, localVars.tokenAmountForAmmOld) = _tokenAmountsForLiquidityBootstrap(\\n localVars.virtualEthOld,\\n localVars.bootstrapEthOld,\\n initialLpInfo.initialWethAdded,\\n localVars.initialTokenMatchOld\\n );\\n\\n // new token amount for bootstrap if no swaps would have occured\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, initParams.initialEth, initParams.initialTokenMatch\\n );\\n\\n // team needs to add min 10% more tokens than the initial lp to take over\\n localVars.minTokenNeeded =\\n ((localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld) * 11000) / 10000;\\n\\n481 if ((localVars.tokenAmountForAmmNew + localVars.tokenAmountForPresaleNew) < localVars.minTokenNeeded) {\\n revert GoatErrors.InsufficientTakeoverTokenAmount();\\n }\\n\\n localVars.reserveEth = _reserveEth;\\n\\n // Actual token amounts needed if the reserves have updated after initial lp mint\\n (localVars.tokenAmountForPresaleNew, localVars.tokenAmountForAmmNew) = _tokenAmountsForLiquidityBootstrap(\\n initParams.virtualEth, initParams.bootstrapEth, localVars.reserveEth, initParams.initialTokenMatch\\n );\\n localVars.reserveToken = _reserveToken;\\n\\n // amount of tokens transferred by the new team\\n uint256 tokenAmountIn = IERC20(_token).balanceOf(address(this)) - localVars.reserveToken;\\n\\n if (\\n496 tokenAmountIn\\n497 < (\\n498 localVars.tokenAmountForPresaleOld + localVars.tokenAmountForAmmOld - localVars.reserveToken\\n499 + localVars.tokenAmountForPresaleNew + localVars.tokenAmountForAmmNew\\n500 )\\n ) {\\n revert GoatErrors.IncorrectTokenAmount();\\n }\\n\\n localVars.pendingLiquidityFees = _pendingLiquidityFees;\\n localVars.pendingProtocolFees = _pendingProtocolFees;\\n\\n // amount of weth transferred by the new team\\n uint256 wethAmountIn = IERC20(_weth).balanceOf(address(this)) - localVars.reserveEth\\n - localVars.pendingLiquidityFees - localVars.pendingProtocolFees;\\n\\n if (wethAmountIn < localVars.reserveEth) {\\n revert GoatErrors.IncorrectWethAmount();\\n }\\n\\n _handleTakeoverTransfers(\\n IERC20(_weth), IERC20(_token), initialLpInfo.liquidityProvider, localVars.reserveEth, localVars.reserveToken\\n );\\n\\n uint256 lpBalance = balanceOf(initialLpInfo.liquidityProvider);\\n _burn(initialLpInfo.liquidityProvider, lpBalance);\\n\\n // new lp balance\\n lpBalance = Math.sqrt(uint256(initParams.virtualEth) * initParams.initialTokenMatch) - MINIMUM_LIQUIDITY;\\n _mint(to, lpBalance);\\n\\n _updateStateAfterTakeover(\\n initParams.virtualEth,\\n initParams.bootstrapEth,\\n initParams.initialTokenMatch,\\n wethAmountIn,\\n tokenAmountIn,\\n lpBalance,\\n to,\\n initParams.initialEth\\n );\\n }\\n```\\n

The router is not compatible with fee on transfers tokens

medium

The router is not compatible with fee on transfers tokens.\\nLet's take as example the removeLiquidity function:\\n```\\naddress pair = GoatV1Factory(FACTORY).getPool(token);\\n\\nIERC20(pair).safeTransferFrom(msg.sender, pair, liquidity); //-> 1. Transfers liquidity tokens to the pair\\n(amountWeth, amountToken) = GoatV1Pair(pair).burn(to); //-> 2. Burns the liquidity tokens and sends WETH and TOKEN to the recipient\\nif (amountWeth < wethMin) { //-> 3. Ensures enough WETH has been transferred\\n revert GoatErrors.InsufficientWethAmount();\\n}\\nif (amountToken < tokenMin) { //4. Ensures enough TOKEN has been transferred\\n revert GoatErrors.InsufficientTokenAmount();\\n}\\n```\\n\\nIt does the following:\\nTransfers liquidity tokens `to` the pair.\\nBurns the liquidity tokens and sends WETH and TOKEN `to` the recipient `to`.\\nEnsures enough WETH has been transferred.\\nEnsures enough TOKEN has been transferred.\\nAt point `4` the router doesn't account for the fee paid to transfer TOKEN. The recipient didn't actually receive `amountToken`, but slightly less because a fee has been charged.\\nAnother interesting example is the removeLiquidityETH which first burns the liquidity and transfers the tokens to the router itself, and then from the router the tokens are transferred to the recipient. This will charge double the fees.\\nThis is just two examples to highlight the fact that these kind of tokens are not supported, but the other functions in the router have similar issues that can cause all sorts of trouble including reverts and loss of funds.

Add functionality to the router to support fee on transfer tokens, a good example of where this is correctly implememented is the Uniswap Router02.

The router is not compatible with fee on transfers tokens.

```\\naddress pair = GoatV1Factory(FACTORY).getPool(token);\\n\\nIERC20(pair).safeTransferFrom(msg.sender, pair, liquidity); //-> 1. Transfers liquidity tokens to the pair\\n(amountWeth, amountToken) = GoatV1Pair(pair).burn(to); //-> 2. Burns the liquidity tokens and sends WETH and TOKEN to the recipient\\nif (amountWeth < wethMin) { //-> 3. Ensures enough WETH has been transferred\\n revert GoatErrors.InsufficientWethAmount();\\n}\\nif (amountToken < tokenMin) { //4. Ensures enough TOKEN has been transferred\\n revert GoatErrors.InsufficientTokenAmount();\\n}\\n```\\n

It's possible to create pairs that cannot be taken over

medium

It's possible to create pairs that cannot be taken over and DOS a pair forever.\\nA pair is created by calling createPair() which takes the initial parameters of the pair as inputs but the initial parameters are never verified, which makes it possible for an attacker to create a token pair that's impossible to recover via takeOverPool().\\nThere's more ways to create a pair that cannot be taken over, a simple example is to set all of the initial parameters to the maximum possible value:\\n```\\nuint112 virtualEth = type(uint112).max;\\nuint112 bootstrapEth = type(uint112).max;\\nuint112 initialEth = type(uint112).max;\\nuint112 initialTokenMatch = type(uint112).max;\\n```\\n\\nThis will make takeOverPool() revert for overflow on the internal call to _tokenAmountsForLiquidityBootstrap:\\n```\\nuint256 k = virtualEth * initialTokenMatch;\\n tokenAmtForAmm = (k * bootstrapEth) / (totalEth * totalEth);\\n```\\n\\nHere `virtualEth`, `initialTokenMatch` and `bootstrapEth` are all setted to `type(uint112).max`. The multiplication `virtualEth` * `initialTokenMatch` * `bootstrapEth` performed to calculate `tokenAmtForAmm` will revert for overflow because `2^112 * 2^112 * 2^112 = 2^336` which is bigger than `2^256`.

Validate a pair initial parameters and mint liquidity on pool creation.

Creation of new pairs can be DOSed forever.

```\\nuint112 virtualEth = type(uint112).max;\\nuint112 bootstrapEth = type(uint112).max;\\nuint112 initialEth = type(uint112).max;\\nuint112 initialTokenMatch = type(uint112).max;\\n```\\n