Unused funds are not returned and not counted in `GeVault`

User can steal refunded underlying tokens from `initRange` operation inside `RangeManager`

ERC777 and similar token implementations allow stealing of funds when transferring tokens

Gas fees are refunded to a wrong address when transferring tokens via `InterchainToken.interchainTransferFrom`

Proposal requiring native coin transfers cannot be executed

`RemoteAddressValidator` can incorrectly convert addresses to lower case

Increasing reserves breaks PrizePool accounting

Resetting delegation will result in user funds being lost forever

Delegated amounts can be forcefully removed from anyone in the TwabController

`Vault.mintYieldFee` FUNCTION CAN BE CALLED BY ANYONE TO MINT `Vault Shares` TO ANY RECIPIENT ADDRESS

`VaultFactory` allows deployment of vaults with non-authentic `TwabController` and `PrizePool`

Unintended or Malicious Use of Prize Winners' Hooks

ETH is never refunded in `ArrakisV2Router.addLiquidityPermit2`

Changing manager fee BPS affects past shares conversion rates, making users lose a portion of rewards or getting extra rewards

Chainlink oracles staleness check can cause regular lengthy denials of service

Legacy withdrawals can be relayed twice, causing double spending of bridged assets

Gas usage of cross-chain messages is undercounted, causing discrepancy between L1 and L2 and impacting intrinsic gas calculation

User transactions can call system contracts directly

Underflow of `lpPosition.points` during withdrawLP causes huge reward minting

Cross-chain message authentication can be bypassed, allowing an attacker to disrupt the state of vaults

On-chain slippage calculation can be manipulated, causing stealing of rewards in sandwich attacks

Gamers and depositors lose rewards in Idle and Beta protocols

Rebalancing can stuck due to the inability to increase slippage and relayer fee

Incorrect underlying balance calculation disrupts accounting of funds deposited to Compound

Rebalancing can be indefinitely blocked due to ever-increasing `totalWithdrawalRequests`, causing locking of funds in vaults

Gamer rewards are reduced due to fund pulls before accrual of rewards

Gamers will not receive rewards for allocating to Aave and Beta vaults, while the vaults do generate yield

Vaults may become insolvent due to a missing conversion between protocol underlying tokens and vault underlying tokens

Delayed Compound and Beta interest accrual reduces gamer rewards and affects funds distribution to vaults

Deposited funds are locked in inactive vaults

The guardian may not be able to blacklist a protocol

Missing transaction expiration check result in reward tokens selling at a lower price

`XProvider` forces increased relayer fees when transferring tokens cross-chain

An inactive vault can disrupt rebalancing of active vaults

Rebalancing can be blocked when pulling funds from a TrueFi or a Idle vault

Withdrawals locking can be bypassed, potentially disrupting the supply and demand balance

`GoldfinchAdapter` fails to detect late payments at or after pool's term has ended

Protection can be bought in late pools, allowing buyers to pay minimal premium and increase the chance of a compensation

Earned interest is not accounted in position's risk value, causing increased debt accumulation

Earned interest is lost when withdrawing tokens lent to a bank

Users may borrow more than the `MaxLTV` value of a strategy

Wrong amount of LP tokens is removed from ICHI vaults when closing a position

Liquidations are enabled when repayments are disabled, causing borrowers to lose funds without a chance to repay

Claiming of rewards can be indefinitely blocked by a malicious ERC20 token

Refunded NFT can indefinitely block bounty rewards claiming

Griefing attack may cause indefinite DoS on refunding

Disproportional distribution of deposited funds causes some depositors to lose funds

Bounty contract funding can be blocked by an attack filling the limit of token addresses

The NFT deposit limit may be not enough for tiered bounties

Payout schedule cannot be shrunk due to a revert

CryptoPunks NFTs may be stolen via deposit frontrunning

Missing bankruptcy detection when removing NFT collateral lets bad debt accumulate

Anyone who approved quote tokens to a pool can be forced to take

Incorrect MOMP calculation in neutral price calculation

Anyone can transfer approved LP tokens

When Public Vault A buys out Public Vault B's lien tokens, it does not increase Public Vault A's liensOpenForEpoch, which would result in the lien tokens not being repaid

Buying out corrupts the slope of a vault, reducing rewards of LPs

Vault may be drained after a liquidated NFT was claimed by the liquidator

Strategist can fail to withdraw asset token from a private vault

Improper validations in Clearinghouse. possible to lock collateral NFT in contract.

Deadlock in valuts with underlying token with less then 18 decimals

Users are unable to mint shares from a public vault using `AstariaRouter` contract when share price is bigger than one

Wrong `wrappedScaleFactor` calculation disrupts spot price calculation

`MetaStable2TokenAuraVault` doesn't support new Balancer pools

Wrong fee calculation when opening a short position on Perpetual Protocol

`Uniswapper` cannot be used in rebalancing due to missed approval

Collateral NFT deposited to a wrong address, when transferred directly to `PaprController`

Users may be liquidated right after taking maximal debt

`PaprController` pays swap fee in `buyAndReduceDebt`, not user

Hijacking of node operators minipool causes loss of staked funds

State Transition: Minipools can be created using other operator's AVAX deposit via recreateMinipool

Recreated pools receive a wrong AVAX amount due to miscalculated compounded liquid staker amount

Rialto may not be able to cancel minipools created by contracts that cannot receive AVAX

`requireNextActiveMultisig` will always return the first enabled multisig which increases the probability of stuck minipools

Liquidity providers may lose funds when adding liquidity

First depositor can break minting of shares

Rounding error in buyQuote might result in free tokens

Pair price may be manipulated by direct transfers

Not enough margin pulled or burned from user when adding to a position

`executeLimitOrder()` modifies open-interest with a wrong position value

Chainlink price feed is not sufficiently validated and can return stale price

NFTFloorOracle's asset and feeder structures can be corrupted

Data corruption in NFTFloorOracle; Denial of Service

Front-running admin setPrice call allows a single compromised oracle to set any price, allowing the oracle manipulator to drain all protocol funds

Users can be locked out of providing Uniswap V3 NFTs as collateral

LooksRare orders using WETH as currency cannot be paid with WETH

During oracle outages or feeder outages/disagreement, the `ParaSpaceFallbackOracle` is not used

A registered contract won't earn fees if `_recipient` is a fresh address

`PostTxProcessing` can revert user transactions not interacting with Turnstile

Gas griefing vulnerability in `netAtPrice`, `depositAuction`, and `withdrawAuction`

Missing tokens spending approval from a trader can impair the auction

Contract owner can lock user funds indefinitely

Debt miscalculation applies an increased interest rate to debts in the Synth vault

AMM tokens can be stolen from Depositor

Collateral virtual price growth can be slowed down due to rounding in virtual price calculation

Dangerous assumption on the peg of USDC can lead to manipulations

Wrong `CHANGE_COLLATERAL_DELAY` value

Underlying assets stealing in `AutoPxGmx` and `AutoPxGlp` via share price manipulation

broken logic in configureGmxState() of PirexGmx contract because it doesn't properly call safeApprove() for stakedGmx address

Reward tokens mismanagement can cause users losing rewards

Anyone can call AutoPxGmx.compound and perform sandwich attacks with control parameters

Incorrect accounting in SyndicateRewardsProcessor results in any LP token holder being able to steal other LP tokens holder's ETH from the fees and MEV vault.

Giant pools can be drained due to weak vault authenticity check

Old stakers can steal deposits of new stakers in `StakingFundsVault`

Calling `updateNodeRunnerWhitelistStatus` function always reverts

Freezing of funds - Hacker can prevent users withdraws in giant pools

GiantPool should not check ETH amount on withdrawal

Adding non EOA representative

Borrower can close a credit without repaying debt

Whitelisted functions aren't scoped to revenue contracts and may lead to unnoticed calls due to selector clashing

Mutual consent cannot be revoked and stays valid forever

Variable balance ERC20 support

Lender can reject closing a position

Reward can be over- or undercounted in `extendPledge` and `increasePledgeRewardPerVote`

Owner can transfer all ERC20 reward token out using function recoverERC20

Pledge may be out of reward due to the decay in veCRV balance. targetVotes is never reached.

`viewPrice` doesn't always report dampened price

Calling `repay` function sends less DOLA to `Market` contract when `forceReplenish` function is not called while it could be called

Chainlink oracle data feed is not sufficiently validated and can return stale `price`

Users can receive less tokens during redeeming due to iPT inflation in the `mint` function

Re-entrancy during lending allows an attacker to mint iPT without paying underlying tokens

Re-entrancy in Sense redemption allows an attacker to inflate holdings and get more underlying tokens

Missing contract code existence check can cause free and unlimited iPT minting

iPT redeeming is possible when iPT redemptions are paused

User can accidentally burn their iPT tokens during redemption

Wrong return value in the Pendle's `lend` function can cause lose of funds or excessive iPT issuance

Cancelling an auction doesn't repay the entire debt and doesn't unlock collateral

A borrower can steal auctioned collateral for current bidder

Funds can be lost when repaying liens

The implied value of a public vault can be impaired, liquidity providers can lose funds

Incorrect maximum potential debt calculation causes denial of service

Denial of service in `AstariaRouter.commitToLiens`

Liquidity providers can lose funds when a withdraw proxy is not set for an epoch

Liquidity providers can lose funds due to vault share price manipulation

An auction can never be extended due to an underflow

If user sets a low `gasPrice` the operator would have to choose between being locked out of the pod or executing the job anyway

Source contract can steal NFTs from users

Wrong slashing calculation rewards for operator that did not do his job

Bond tokens (HLG) can get permanently stuck in operator

`_payoutToken[s]()` is not compatible with tokens with missing return value

`_payoutEth()` calculates `balance` with an offset, always leaving dust `ETH` in the contract

Outstanding reserved tokens are incorrectly counted in total redemption weight

NFT not minted when contributed via a supported payment terminal

Lack of validation of Synapse bridge calldata allows stealing of funds

Increased reward token inflation due to double counting of `totalFrozen`

`AssetManager.withdraw()` can lock user funds indefinitely

Removed money market adapters can drain `AssetManager` due to approved token spending

Removed adapter can still hold funds, removed token can still be deposited to a market

Incorrect output amount calculation for Trader Joe V1 pools

Wrong calculation in function `LBRouter._getAmountsIn` make user lose a lot of tokens when swap through JoePair (most of them will gifted to JoePair freely)

Depositors will never get the highest bonus after a new point is added to the end of a curve

Misconfigured pool can lead to rewards locked indefinitely

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

Oracle data misreporting can disrupt auction and options settlement

Undercounted liquidity leads to increased `volumePerLiquidityInBlock` and incorrect adaptive fee

Swapping can be impaired when `activeIncentive` is set

Missing slippage control system. Users may lose a lot of funds due to front-running MEV bots.

A "FrontRunning attack" can be made to the `initialize` function

`safeTransfer` function does not check for existence of ERC20 token contract

Incorrect handling of pricefeed.decimals()

Users who deposit in one vault can lose all deposits and receive nothing when counterparty vault has no deposits

Risk users are required to payout if the price of the pegged asset goes higher than underlying

Vault.sol is not EIP-4626 compliant

Different Oracle issues can return outdated prices

Calling `transferEth` function can revert if `receiver` input corresponds to a contract that is unable to receive ETH through its `receive` or `fallback` function

Flawed decimals check could lock funds in a 2-token Balancer Strategy Vault

Deprecated Balancer Price Oracles could lead to locked funds in the Balancer strategy vaults

Hackers can deploy token with respective name as the stable one to impersonate the stable token

Calculated `token0TVL` may be zero under certain scenarios

Tokens without properties can be minted and cannot be rendered

Minting is not possible when a property has no items

Index out of bounds error when properties length is more than attributes length breaks minting

Heart::beat() could be called several times in one block if no one called it for a some time

Admin cannot be changed to EOA after deployment