The user can send tokens to any address by using two bridge transfers, even when transfers are restricted.

Improper Transfer Restrictions on Non-Bridged Tokens Due to Boolean Bridged Token Tracking, Allowing a DoS Attack Vector

`updateParticipation()` incorrectly adds/subtracts different tokens when performing critical operations

NFTs in protected listings that are unlocked but not withdrawn can be stolen

Native tokens donations to UniswapV4 pools can be stolen by adding/removing liquidity before/after a swap

Quorum votes downcasting in `CollectionShutdown.sol` leads to lower quorum and stolen funds

Voters can't withdraw their collection tokens after a shutdown is canceled

It's possible to cancel a shutdown after it's been executed

It's possible to create listings with an arbitrary start timestamp

Relisting liquidated listings should not distribute taxes and refunds

`ProtectedListings::_createCheckpoint()` returns wrong checkpoint index in some cases

`ProtectedListings::adjustPosition()` doesn't adjust the taxes to pay

First liquidity providers lose all of their assets

Lack of caller validation in `InfernalRiftAbove::claimRoyalties()` allows to steal royalties

`InfernalRiftBelow` lacks a way to withdraw ERC1155 royalties

`Listings::reserve()` doesn't delete the old listing

`Listings::reserve()` doesn't clear the `isLiquidation[collection][tokenId]` mapping

Protected listings checkpoints are not always updated when the total supply changes

Collection tokens fees price can be manipulated in the `beforeSwap()` hook

`CollectionShutdown::execute()` doesn't ensure that all locked NFTs are sold

Fee exemptions are never applied

If the royalties receiver it's a smart contract it might be impossible to collect L2 royalties

Moongate assumes royalties are always implemented as a fixed percentage of the price, leading to discrepancies or locked tokens

`UniswapImplementation::beforeSwap()` might revert when swapping native tokens to collection tokens

Maximum borrowable amount in protected listings should be lower

`initializeCollection()` doesn't refund native tokens

`ethToeETH()` returns the amount of shares minted instead of the amount of tokens received

`depositSteth()` and `depositeEth()` will revert

`setStartBlock()` doesn't change the block at which already existing pools will start accumulating points

Users can frontrun LSTs/LRTs tokens prices decrease in order to avoid losses

`_stake()` function in `PufEthAdapter` will always revert

Adapters revert when 0 shares are minted, making it impossible to deposit under certain conditions

Kelp adapter won't allow users to deposit in some situations

Kelp adapter won't allow users to deposit if `getAssetCurrentLimit` returns `0`

`_stake()` function in `RenzoAdaper` and `RsETHAdapter` doesn't check if max TVL is reached

`RsETHAdapter` adapter `_stake()` function lacks slippage control

The amount of `xezETH` in circulation will not represent the amount of `ezETH` tokens 1:1

Incorrect withdraw queue balance in TVL calculation

Withdrawals logic allows MEV exploits of TVL changes and zero-slippage zero-fee swaps

ETH withdrawals from EigenLayer always fail due to `OperatorDelegator`'s nonReentrant `receive()`

Deposits will always revert if the amount being deposited is less than the bufferToFill value

`calculateTVL` may run out of gas for modest number of operators and tokens breaking deposits, withdrawals, and trades

Donating (and syncing) tokens to an Aerodrome allows to bypass exposure limits

Swapping large amounts of assets back and forth in an Aerodrome pool allows to bypass exposure limits

Liquidity provider fees can be stolen from any pair

The router is not compatible with fee on transfers tokens

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

Users can cancel their own highest bid of any round, including the current one

Currently auctioned NFTs can be transferred to a different address in a specific edge case

Claiming a deposit (or redeem) on the same epoch it has been requested leads to stuck funds

Exchange rate is calculated incorrectly when the vault is closed, potentially leading to funds being stolen

Requesting a redeem sets `lastRedeemRequestId` to the wrong address

Wrong allowance check on the vault zapper

It's possible to steal funds via donations to Eigenlayer strategies

Operators can undelegate `LRTRioOperatorDelegator` instances from Eigenlayer, leading to loss of funds

Malicious operator can steal stakers ETH by setting a validator withdrawal credentials to an address he controls

Epoch currently queued for settlement might get settled via `rebalance()` leading to stuck funds

Increase in Eigenlayer strategies shares value might lead `rebalance()` reverting

`RioLRTOperatorRegistry::verifyWithdrawalCredentials()` doesn't verify that the validator has 32ETH deposited from the rio protocol

The protocol can't receive rewards because of low gas limits on ETH transfers

Stakers can avoid validator penalties

LRT that accepts both ETH and non-ETH assets can be forced to exit validators and receive less rewards

Up to 1 ETH might get stuck in an EigenPod

A part of ETH rewards can be stolen by sandwiching `claimDelayedWithdrawals()`

Lending pools that accept both ERC777 and UniswapV3 positions as collateral can be drained

Lending pools with ERC777 as an underlying asset can be drained

Account auction price will keep decreasing even when bids can't be placed

Possible griefing attack on lending pools interest rates

Stargate `STG` rewards are accounted incorrectly by `StakedStargateAM.sol`

An attacker can win a round while depositing no assets

It's possible to bypass the `MAXIMUM_NUMBER_OF_DEPOSITS_PER_ROUND`

The `burn()` function logic in `CouncilMember.sol` will prevent some council member from claiming their tokens

The `topUp()` function distributes tokens to the wrong contracts

Arbitrary `delegatecall` in the `VestingEscrow.sol` implementation

TRUF tokens in `TrufVesting.sol` can be drained

The `cancelVesting()` function does not return the user locked funds

An expired lock can be extended with a past `end` timestamp while increasing points

Incorrect `blocksPerYear` constant in `WhitepaperInterestRateModel`

ecrecover missing address(0) check allows for fund draining, if the vault delegate is the 0 address

`_deleteLienPosition` visibility allows for fund draining

`yIntercept` is not correctly updated in `PublicVault.beforePayment()`

Users calling `makePayment()` for collaterals with multiple liens might lose funds

The function buyoutLien always revert

in `_validateCommitment` the potentialDebt is calculated wrongly

VAULT_FEE() getter returns from the wrong offset, returning a wrong fee

Attacker can steal entire reserves by abusing fee calculation

Very critical `Owner` privileges can cause complete destruction of the project in a possible privateKey exploit

StandardPolicyERC1155.sol returns amount == 1 instead of amount == order.amount

Supply cap of VariableSupplyERC20Token is not properly enforced

Can Recover Gobblers Burnt In Legendary Mint

The reveal process could brick if `randProvider` stops working

Wrong balanceOf user after minting legendary gobbler