Tag

The main categories for classifying data based on root causes and vulnerabilities.

Title Description Knowledge Related subtag
DAO Security vulnerabilities related to governance logic, permission control, voting mechanisms, member management, or cross-chain governance information verification in Decentralized Autonomous Organizations (DAOs). 📚 State Update Inconsistency,Does not match with Doc,Bad Condition,Precision Loss,Invalid Validation,Centralization Risk,Invariant Violation,Implementation Error
DoS When there are flaws in the logic of a contract or protocol, it can lead to certain operations (such as deposits, withdrawals, transfers, proposals, liquidations, etc.) being unable to execute successfully for an extended period or permanently, which constitutes a type of Denial of Service (DoS) vulnerability.
Such issues prevent the affected functionalities from being restored under unchanged contract states and hinder legitimate users from performing expected actions, often resulting in locked funds/assets, governance standoffs, or disruptions to business processes. ✍️ Out of Gas,Stale Value,State Update Inconsistency,Missing Initialization,Invariant Violation,Deprecated Library,Bad Condition,Duplicate Value,Front Run,Implementation Error,Invalid Validation,Precision Loss,payable / receive(),No Recovery Mechanism,Incorrect Parameter,Fee On Transfer Token,Typo,Missing minOut / maxAmount,Missing Approval,Execution Order Dependency,Missing Functionality,Reward Manipulation,Refund Failed,ERC777 Callback,Missing Upper/Lower Bound Check,Does not match with Doc,Nonce,1/64 Gas Rule,Arbitrary Add/Remove/Set/Call,Peg / Depeg,Hardcoded Parameter,EVM Compatibility,Liquidation - Dust repay / front run evade liquidation,Whale,Case Sensitive,Token Decimal,onERC721Received callback,Price Manipulation / Arbitrage opportunity
Flashloan When a protocol relies on instantaneous states (such as spot prices, real-time asset ratios, or current voting rights) to calculate yields, voting rights, minting limits, and liquidity operations without implementing time-weighted mechanisms or stabilization constraints, it allows attackers to temporarily dominate the system's ratios through flash loans or large capital within a single transaction or a few blocks. This manipulation can skew calculation results, enabling them to gain undue benefits or manipulate governance outcomes before the state is restored. ✍️ Reward Manipulation,Whale,Bypass Mechanism,Price Manipulation / Arbitrage opportunity,Peg / Depeg,slot0,Incorrect Parameter,Bad Condition,State Update Inconsistency,Missing Time Constraint,Asset Theft
Oracle When a protocol obtains data from on-chain or off-chain external price sources, any flaws in the selection of data sources, update frequency, verification methods, scaling conversions, or calculation methods can lead to distorted, outdated, manipulated, or unusable prices. This, in turn, can affect critical functions such as trade matching, collateral liquidation, asset valuation, and minting/redeeming processes, which constitutes such vulnerabilities. Price Manipulation / Arbitrage opportunity,Incorrect Formula,Hardcoded Parameter,Token Decimal,Precision Loss,Incorrect Parameter,Bad Condition,Scaling,Stale Value,Invalid Validation,State Update Inconsistency,Duplicate Value,Missing Return Check,Misuse of Dependency,Unsafe Downcast,Does not match with Doc,Implementation Error,Bypass Mechanism,Rounding Error
Logic error When there are logical errors in the implementation of a protocol that do not conform to the expected design or specification, such as issues with conditional statements, loop logic, index boundaries, variable update order, cross-module state synchronization, and special case handling, resulting in incorrect fund calculations, inaccurate balances/shares, incorrect states, or the inability to execute functions correctly, these are considered vulnerabilities of this type. Bad Condition,Invalid Validation,Stale Value,State Update Inconsistency,Price Manipulation / Arbitrage opportunity,Incorrect Parameter,Does not match with Doc,Reward Manipulation,Invariant Violation,Bypass Mechanism,Missing Approval,Implementation Error,Missing Functionality,No Recovery Mechanism,Missing Upper/Lower Bound Check,Centralization Risk,Missing Return Check,Asset Theft,Out of Gas,Incorrect Formula,Unfair Liquidation,Cannot partial liquidations,Front Run
Reentrancy When a contract updates critical states before implementing a locking mechanism (such as nonReentrant or the Checks-Effects-Interactions pattern) and executes external calls (like transfer, call, safeTransferFrom, ERC777/1155 callbacks, etc.), it may allow malicious contracts (or token standards with hooks) to re-enter the original contract's functions or other related functions during the external call. This can lead to repeated execution of business logic, circumvention of condition checks, or state alteration for the purpose of stealing assets or manipulating processes, which constitutes such vulnerabilities. ✍️ Violating CEI / Missing nonReentrant,Cross-Function Reentrancy,Invalid Validation,onERC721Received callback,Execution Order Dependency,ERC777 Callback,Asset Theft,Bypass Mechanism
Access Control The lack of proper authentication, authorization checks, or controls for key functions can result in unauthorized users being able to perform operations that should only be executable by specific roles (such as owner, admin, governance, etc.). Additionally, defects in authorization revocation, role transfer, or state-checking logic can lead to ongoing privilege leaks, which may ultimately be exploited to steal assets, compromise system configurations, or permanently lock funds. ✍️ Asset Theft,Arbitrary Add/Remove/Set/Call,Invalid Validation,Cannot Revoke,Implementation Error,Missing Functionality,Centralization Risk,Price Manipulation / Arbitrage opportunity,Role Takeover,Unauthorized Upgrade,Missing Initialization,State Update Inconsistency,Fee On Transfer Token,Does not match with Doc,Bypass Mechanism,Reward Manipulation,Bad Condition,Missing Upper/Lower Bound Check,No Recovery Mechanism,Incorrect Parameter,Front Run,Out of Gas,Duplicate Value,Invariant Violation
Liquidation When there are design flaws in the liquidation process of lending or collateral contracts, including errors in triggering conditions, authorization checks, incentive mechanisms, calculation logic, and asset transfer steps this can result in defaults or under-collateralized positions not being liquidated as expected, being over-liquidated, or liquidators taking advantage of logical errors to steal assets or harm the interests of other users. ✍️ Bypass Mechanism,Does not match with Doc,Invalid Validation,Incorrect Parameter,No Incentive to Liquidate,Bad Condition,Invariant Violation,Liquidation - Dust repay / front run evade liquidation,ERC777 Callback,Missing Functionality,Price Manipulation / Arbitrage opportunity,Unfair Liquidation,State Update Inconsistency,Cannot partial liquidations,Implementation Error,Whale,Out of Gas,Refund Failed
Slippage When a contract performs operations that require interaction with external prices, such as executing trades, exchanging tokens, adding or removing liquidity, and minting/redeeming assets it may lack mechanisms like minimum acceptable output (minOut), maximum acceptable prices, market volatility/slippage protection, and deadline checks. This can lead to users experiencing slippage beyond their expectations during transactions and suffering losses due to price manipulation or Miner Extractable Value (MEV) attacks (such as front-running or sandwich attacks). 📚 Missing minOut / maxAmount,Hardcoded Parameter,Fee On Transfer Token,minOut set to 0,Missing deadline,Invalid Slippage Control / Missing slippage check,Incorrect Formula
ERC4626 When an asset pool (Vault) based on the ERC-4626 standard is implemented without adhering to the specifications for design and mathematical handling, such as method behaviors, boundary conditions, rounding direction, and consistency between return values and states or if there are vulnerabilities in the economic design like initial deposit manipulation or share inflation attacks, this can result in the Vault being incompatible with other protocols, incorrect calculations of user assets, or malicious damage to the system. ✍️ Incorrect Parameter,Inflation Attack,Not EIP Compliant,Rounding Error,Price Manipulation / Arbitrage opportunity,Missing minOut / maxAmount
Input Validation When a contract lacks proper input parameter checks, asset/authority ownership verification, state validity checks, or invariants verification during the handling of critical processes (such as transactions, liquidations, governance, fund transfers, asset minting/burning, etc.), it may allow malicious or improper inputs to bypass intended restrictions. This can lead to asset theft, logical inconsistencies, irreversible system failures, or the compromise of the protocol. Not EIP Compliant,Invalid Validation,Asset Theft,Duplicate Value,Precision Loss,Bypass Mechanism,Bad Condition,No Recovery Mechanism,Hardcoded Parameter,Does not match with Doc,Implementation Error,Incorrect Parameter,Reward Manipulation,Inflation Attack,Peg / Depeg,Price Manipulation / Arbitrage opportunity,Missing Time Constraint,Missing Upper/Lower Bound Check,Front Run,Stale Value,State Update Inconsistency,Invariant Violation,Nonce
Bad Randomness When a contract relies on randomness to determine outcomes (such as selecting a tokenId, choosing a winner, validators, conducting lottery draws, or sorting), flaws in the generation or usage patterns of random numbers, such as using predictable or manipulatable on-chain variables (like block information, timestamps, or miner-controllable values), allowing users to control the seed, lacking verification of result submissions, or having issues with re-draw/re-use can enable attackers or privileged roles to bias or select specific outcomes, thereby undermining fairness. ✍️ Bad Condition, Reward Manipulation, Front Run
Chainlink When a contract relies on Chainlink oracles as a source for prices or randomness but utilizes outdated APIs, lacks necessary data validity checks (such as update times, round completeness, or min/max boundaries), is missing protective or fallback mechanisms, or uses incorrect feeds, it can result in the oracle returning values that may be outdated, erroneous, or manipulatable. ✍️ Deprecated Library,Stale Value,Invalid Validation,Price Manipulation / Arbitrage opportunity,Missing Return Check,Unsafe Downcast,Bad Condition,Front Run,Peg / Depeg
Arithmetic When there are flaws in the mathematical calculation logic of a contract, including issues such as overflow/underflow, division by zero, unsafe type conversions, incorrect precision scaling, rounding direction errors, and deviations from the intended design rules in computation formulas, it can lead to abnormal numerical results, incorrect asset calculations, and errors in incentives or penalties. Unsafe Downcast,Token Decimal,Precision Loss,Invalid Validation,Scaling,Incorrect Formula,Peg / Depeg,Price Manipulation / Arbitrage opportunity,Implementation Error,Front Run,Rounding Error,Missing Initialization,Incorrect Parameter,Bad Condition,Missing Upper/Lower Bound Check,Stale Value,Bypass Mechanism,State Update Inconsistency,Block Time / Block Number,Hardcoded Parameter,Does not match with Doc
Re-org Attack A vulnerability that arises when smart contract logic assumes finality or determinism in block ordering, making it exploitable via chain reorganizations that reorder or replace recent blocks. ✍️ State Update Inconsistency
Pause When a contract provides mechanisms to pause system functionalities (such as Pausable, whenPaused, or whenNotPaused modifiers), flaws in the logic design or usage, such as allowing disallowed operations to be executed while in a paused state, failing to include pause checks in necessary functions, enabling circumvention of pause restrictions, or permanently locking the system can lead to an irrecoverable contract state or allow privileged roles to perform unauthorized actions. ✍️ Missing Functionality,Centralization Risk,State Update Inconsistency,Invalid Validation,1/64 Gas Rule,Does not match with Doc,Front Run,Invariant Violation,No Recovery Mechanism
Accounting Error When a protocol tracks, calculates, or synchronizes assets, discrepancies can arise between state records and actual asset changes, or the true behavior of assets may be overlooked in the numerical calculation logic. For example, the internal records may not synchronize with actual balances (due to state delays or missed updates), assumptions about asset quantities may be invalid (such as assuming that the amount transferred always equals the requested amount), and there may be systematic errors in calculation formulas. This can lead to discrepancies in shares, fees, rewards, and entitlement distributions. Additionally, cross-module or cross-asset records or calculations may not be consistently updated, resulting in duplicate calculations or omissions. Fee On Transfer Token,State Update Inconsistency,Bad Condition,Incorrect Parameter,Peg / Depeg,Price Manipulation / Arbitrage opportunity,Reward Manipulation,Implementation Error,Incorrect Formula,Rebase Token,Asset Theft,Does not match with Doc,Invalid Validation,Invariant Violation,payable / receive(),Precision Loss,No Recovery Mechanism,Scaling
MEV The act of maximizing the extraction of economic value within a blockchain system by manipulating the ordering of transactions, front-running transactions, or reordering transactions within a block. This typically results in losses for users or unfair distribution of system resources. Front Run,Price Manipulation / Arbitrage opportunity,Asset Theft,State Update Inconsistency,Reward Manipulation,Bad Condition,Execution Order Dependency,Bypass Mechanism
Upgradeable When a contract is designed to be upgradeable (through proxy patterns, module replacements, etc.), but there are flaws in the upgrade logic, initialization processes, state storage consistency, upgrade permission protections, or compatibility of old states after an upgrade, it may allow unauthorized upgrades, initialization oversights, or other related vulnerabilities. ✍️ Centralization Risk,Misuse of Dependency,Unauthorized Upgrade,Storage Gap,Diamond,Missing Initialization,Implementation Error,Not EIP Compliant,No Recovery Mechanism,Invalid Validation,Does not match with Doc,Bad Condition
ERC20 When a contract interacts with ERC20 tokens, it may operate under erroneous assumptions about ERC20 behaviors, lack checks for return values, or fail to properly handle special token behaviors (such as fee-on-transfer, rebasing, non-standard return values, and unique approve rules). This can lead to unexpected results or vulnerabilities in the contract's functionality. ✍️ Missing Return Check,State Update Inconsistency,Not EIP Compliant,Fee On Transfer Token,No Recovery Mechanism,Asset Theft,Invalid Validation,Rebase Token,safeApprove,Bad Condition,Bypass Mechanism,Does not match with Doc,Implementation Error,Refund Failed
call / delegatecall When a protocol uses low-level Solidity calls (such as call(), delegatecall(), staticcall(), or inline Yul call instructions) for transfers or cross-contract interactions, if it does not check whether the return values indicate success and instead directly updates the state or assumes the operation has completed, it may lead to situations where the operation was not actually executed but is treated as successful. Missing Return Check
Uniswap When integrating with Uniswap V2 / V3 / V4 , there are implementation errors or missing safeguards in core areas such as price calculation, path encoding, initialization constants, liquidity ratio calculation, and output validation. These issues lead to distorted or manipulable pricing bases (e.g., incorrect TWAP calculation, reliance on easily manipulated spot prices), corrupted trade path encoding (e.g., incorrect reversal of path bytes), incorrect initialization hash constants causing pair location failures, mistaken liquidity ratio and asset boundary assumptions (e.g., treating the entire pool as protocol assets, inaccurate share calculations, dust accumulation), and missing minimum-value checks on AMM operation min output values, which allow outputs that are not as expect. 📚 Incorrect Formula,Implementation Error,Hardcoded Parameter,Inflation Attack,Incorrect Parameter,No Recovery Mechanism,Rounding Error,Price Manipulation / Arbitrage opportunity,slot0,Invalid Slippage Control / Missing slippage check
Cross-Chain When a protocol designs or implements features such as cross-chain asset bridges, cross-chain messaging / proposal execution, or cross-chain governance, there may be defects in asset verification, message verification, inter-chain format compatibility, and state synchronization/rollback mechanisms. These issues can allow unsupported or unauthorized asset/address types to enter the cross-chain process; prevent assets from being automatically returned or rolled back after a cross-chain message fails on the target chain; and cause misinterpretation or asset loss due to differences in asset formats, decimal precision, or address formats between chains. They may also lead to unsynchronized state updates between source and target chains or malicious replay, resulting in unintended operations across chains, as well as a lack of permission checks or chain ID validation in cross-chain operations. Implementation Error,No Recovery Mechanism,Does not match with Doc,Asset Theft,Invalid Validation,Whale,Case Sensitive,Incorrect Parameter,Token Decimal,EVM Compatibility,State Update Inconsistency,Missing Initialization,Rebase Token,Bypass Mechanism
ERC777 When a contract executes an asset transfer that triggers an external ERC777 contract callback the tokensReceived() / tokensToSend() hook and performs sensitive asset calculations or state updates before the callback occurs (violating the Checks‑Effects‑Interactions pattern), or uses a revert that causes a DoS. 📚 ERC777 Callback,Violating CEI / Missing nonReentrant,Refund Failed,Cross-Function Reentrancy
Governance In the logic for voting power calculation, threshold checks, snapshots, proposal processes, and member management, there are design flaws or missing validations that allow voting power to be temporarily manipulated (via flash loans or instant token acquisition/disposal), proposal processes to be bypassed or repeatedly triggered, valid proposals to be cancelled, threshold or ratio calculations to be incorrect so that insufficiently supported proposals can pass, and inconsistencies in member management where removed members can rejoin or retain privileges. Governance parameters or conditions can also be altered midway through voting, directly affecting the outcome, ultimately resulting in governance manipulation and even malicious fund extraction. ✍️ State Update Inconsistency,Invalid Validation,Bypass Mechanism,Incorrect Parameter,Bad Condition,Missing Time Constraint,Does not match with Doc,Implementation Error,Front Run,Missing Upper/Lower Bound Check,Invariant Violation,Nonce,Centralization Risk,Arbitrary Add/Remove/Set/Call,Missing Functionality
Multisig When a contract implements a multi-signature mechanism (Multi-signature wallet / multi-signature governance module) to authorize transactions or perform sensitive operations, flaws in signature verification, threshold counting, proposal execution process, and member management can allow unauthorized transactions to be executed, or enable bypassing of the authorization threshold, as well as errors in signature counting/threshold logic. Nonce
Rebalance When a protocol performs asset rebalancing or position redistribution operations to adjust the ratios of different assets or pools, design or validation flaws in processes such as calculation formulas, price dependencies, asset transfers, and state updates can result in incorrect rebalancing ratios, leading to asset allocation imbalances, share mismatches, and failure to properly synchronize state variables (e.g., pool balances, asset weights). This can cause subsequent logic errors or lock funds. Missing boundary checks may also allow a malicious user to exploit the rebalancing process to seize assets. Incorrect Parameter
ERC1155 When a contract implements or extends the EIP‑1155 multi‑token standard and its business logic, flaws in standard behavior compliance, callback handling, supply and enumeration maintenance, and leasing/business validations may occur. These issues can lead to function behaviors that do not comply with the EIP‑1155 specification, breaking interoperability with other protocols, supply or token index miscalculations that cause data inconsistencies or asset mismatches, and the onERC1155Received callback being triggered or used at the wrong time. Such flaws can be exploited by attackers to perform reentrancy attacks or disrupt business processes. 📚 Not EIP Compliant,Reward Manipulation,State Update Inconsistency,Violating CEI / Missing nonReentrant,Asset Theft,Invalid Validation,Bad Condition
XSS Attack Refers to a vulnerability in a contract or Web3 application where improper filtering, encoding, or validation of external inputs allows an attacker to inject and execute malicious JavaScript code. 📚 Invalid Validation
ERC721 When a contract implements or extends the EIP‑721 NFT standard, flaws in standard compliance, tokenId generation and management, transfer/approval logic, callback security handling, and asset protection can occur. These issues can damage interoperability and composability with other protocols (by violating standard behaviors), allow malicious reentrancy, asset theft, or blocking (DoS), cause tokenId duplication or incorrect ownership records leading to asset mismatches, and result in insufficient business safeguards that let assets be burned, hijacked, or permanently locked. 📚 Not EIP Compliant,Asset Theft,Invalid Validation,Violating CEI / Missing nonReentrant,onERC721Received callback,Duplicate Value,Incorrect Parameter,Invariant Violation,Missing Functionality,State Update Inconsistency
Gnosis safe When an extension module (Guard, Extension, Handler) based on Gnosis Safe or other Safe‑like multi‑signature/smart wallets lacks necessary authorization checks, security validation, or state management in processes such as enabling, configuring, disabling, or parameter validation. 📚 Bypass Mechanism,Invalid Validation,Invariant Violation,Cannot Revoke
Opensea Issues related to Opensea integrations. ✍️ Refund Failed,Asset Theft,Invalid Validation
EIP712 When a contract’s signature verification or EIP‑712 typed data parsing process contains flaws such as incorrect encoding methods, mismatched hashing order, missing required fields, or insufficient nonce/replay protection, it can cause valid standard‑compliant signatures to fail verification (legitimate calls reverting), allow invalid or replayed signatures to pass verification, and enable attackers to reuse a signature across transactions or functions to repeatedly execute sensitive operations. 📚 Not EIP Compliant,Nonce
Bridge A protocol component used for transferring assets or data between different blockchain networks (L1, L2, or between different L1 networks). Incorrect Parameter,Cannot Revoke,Invalid Validation,Nonce
Zksync Issues related to Zksync. 📚 EVM Compatibility,payable / receive()
Replay Attack An attacker resubmits previously executed valid messages, transactions, or data. Invalid Validation,Asset Theft,Nonce,State Update Inconsistency
Solmate Issues related to Solmate lib ✍️ Missing Return Check
Compound Issues related to Compound integrations. 📚 Reward Manipulation
Solidity Version Vulnerabilities caused by behaviors of specific Solidity compiler versions or optimizer errors. Misuse of Dependency
EIP4494 Issues related to EIP4494 📚 Not EIP Compliant
TWAP Covers all design or implementation errors related to obtaining, calculating, verifying, or using time-weighted average price (TWAP) data from an AMM, DEX, or oracle source.This includes incorrect TWAP computation formulas, failure to account for time between observations, use of inadequate observation windows susceptible to manipulation, reliance on spot prices instead of TWAP, handling of negative ticks or rounding errors incorrectly, processing outdated or zero-initialized data, reliance on low-liquidity pools for TWAP resulting in inaccurate or manipulable prices, missing validations on upstream oracle results, or design flaws that lock assets due to overly strict TWAP constraints.Vulnerabilities often lead to exploitable price manipulation, inaccurate valuations, DoS conditions in TWAP update loops, and incorrect automated trading or liquidation decisions. ✍️ Price Manipulation / Arbitrage opportunity,Implementation Error,Rounding Error,slot0
RCE Covers all vulnerabilities that allow an attacker to remotely execute arbitrary code or commands on the target system (application server, backend service, node environment, or integrated off-chain component).
This includes unsafe deserialization, injection into dynamic code execution functions, improper sandboxing, insecure use of eval or similar interpreters, lack of input sanitization in code compilation paths, and insecure integration with remote modules or plugins.
Exploiting an RCE vulnerability enables an attacker to run arbitrary logic within the application's execution environment, potentially leading to complete system compromise, data exfiltration, service disruption, or lateral movement inside the infrastructure. 📚 Misuse of Dependency

Subtags

Detailed classifications within each root cause vulnerability or application-specific issue.

Title Description
Violating CEI / Missing nonReentrant Issues related to violation of Critical Event Identification or missing nonReentrant protection.
Missing Approval Missing approve() call before attempting transferFrom, causing token transfer to fail.
Inflation Attack An exploit where a malicious user artificially inflates the asset or share baseline through manipulating initial conditions or specific parameters, resulting in unfair gain and unequal distribution of assets or shares within the system.
Not EIP Compliant Implementation does not adhere to the standards and requirements defined in the relevant EIP, potentially causing unexpected behavior or vulnerabilities.
Asset Theft Allows an unauthorized user to illicitly transfer or misappropriate assets from other.
Rounding Error Issues arising from incorrect rounding direction in numeric operations, causing value misallocation or minor deviations from the protocol’s or standard’s expected behavior.
Invalid Validation Missing or incorrect verification of inputs or required conditions, allowing operations to proceed without ensuring they meet expected safety or correctness requirements.
Cannot partial liquidations Whales (large holders) cannot be liquidated due to specific limitations in the protocol.
Liquidation – Dust repay / front run evade liquidation Fine-grained errors related to dust repayment during liquidation and front running evasion.
onERC721Received callback Vulnerabilities associated with the callback function onERC721Received.
Price Manipulation / Arbitrage opportunity Opportunities for price manipulation or arbitrage within the system.
Bypass Mechanism This refers to flaws in the system's logic design, process control, or condition checks, allowing users or attackers to bypass intended security checks, charging processes, asset restrictions, or risk controls through specific sequences of operations or alternative processes.
Invariant Violation Breaches of assumed constants or invariants in system logic.
Implementation Error Implementation Error refers to design, logic, or coding flaws within the smart contract code.
Does not match with Doc Contract behavior deviates from its documented specification, comments, or referenced standards, potentially leading to misuse, unexpected behavior, or integration errors.
Invalid Slippage Control / Missing slippage check In price-sensitive operations such as swaps or liquidity changes, the contract omits any mechanism to enforce acceptable slippage (e.g., fails to require minOut, maxAmount, or equivalent constraints) where such protection is necessary. This includes cases with no slippage parameter at all or where the check is entirely absent.
No Incentive to Liquidate Lack of liquidation incentives leads to the generation of bad debts.
Hardcoded Parameter Important contract parameters, are hardcoded and cannot be dynamically configured, limiting flexibility and adaptability to changing conditions.
minOut set to 0 Setting minOut to zero disables slippage protection, allowing trades or liquidity operations to execute at any output amount regardless of price impact. This exposes users to unlimited slippage risk and potential severe asset loss.
Missing deadline Missing deadline in swaps or other price-sensitive operations, allowing transactions to execute much later and exposing them to excessive price impact and slippage risk.
Self liquidation Vulnerabilities or issues that allow self liquidation under non-ideal conditions.
Missing minOut / maxAmount Errors related to missing or improperly set minimum output (minOut) or maximum spend (maxAmount) parameters, which are essential for slippage protection.
Deprecated Library Usage of outdated or unsupported function libraries, which may lead to operational disruptions or security vulnerabilities.
Out of Gas Transaction fails due to exceeding the gas limit allocated for its execution.
Stale Value The system uses outdated or obsolete data, which can be manipulated or exploited by attackers.
Front Run The act of exploiting transaction ordering to execute a transaction before another, in order to manipulate price, contract state, or system behavior for unfair advantage.
Reward Manipulation Exploiting weaknesses in a protocol’s reward distribution logic—such as timing, balance tracking, or eligibility checks—to gain more rewards than fairly earned.
Token Decimal The precision used to define token fractions in smart contracts, where incorrect setting or manipulation can cause calculation errors and transaction inaccuracies.
Incorrect Parameter A flaw where the value used in a calculation or passed to a function is wrong, including wrong order, wrong type, or unintended variable reference. This covers both external inputs (function arguments) and internal values (state variables, constants) used in calculations. If the calculation formula itself is correct but a wrong value is used, it is classified as Incorrect Parameter.
No Recovery Mechanism Lack of mechanism to recover from failed, frozen, or misconfigured components.
Centralization Risk Critical functions or system components are controlled by a single party, creating a risk of misuse, censorship, or manipulation.
Precision Loss Loss of numeric precision due to integer division or insufficient scaling (e.g., result becomes 0).
Scaling Failure to apply proper unit conversion or scaling factor in arithmetic operations involving tokens with different denominations or expected decimal precision.
Peg / Depeg Covers all design or implementation errors related to asset peg mechanisms, including improper maintenance of the peg (depeg), return biases, reliance on incorrect sources, or lack of detachment handling.
State Update Inconsistency State Update Inconsistency occurs when the state of a smart contract is updated in an inconsistent or incorrect manner, leading to discrepancies, inaccuracies, and unintended outcomes in future operations, calculations, or decisions. This may impact various aspects of the contract, such as pricing mechanisms, liquidation processes, or liquidity management, and could result in financial losses or manipulative opportunities.
Duplicate Value A vulnerability where two or more distinct entities (e.g. assets, records, or users) unintentionally share the same key or identifier (e.g. mapping key, oracle reference), causing one to overwrite or shadow the other.
Arbitrary Add/Remove/Set/ Call The contract allows unauthorized addresses to arbitrarily add/remove/call or set key states or resources, leading to privilege abuse or system anomalies.
Storage Gap In upgradeable contracts, to avoid storage slot conflicts and overwrites during upgrades, a fixed-length gap of empty storage space is reserved for future extension of contract state variables. The absence of or incorrect design of the storage gap may lead to state corruption or data overwriting after the upgrade.
Missing Return Check The return value is not verified.
Misuse of Dependency When using external dependencies (libraries, modules, or contracts), failing to correctly reference them according to their security design, version security announcements, or the appropriate usage context can lead to functional anomalies, security risks, or upgrade failures. This includes but is not limited to: using versions of external libraries with known vulnerabilities, incorrectly integrating third-party module interfaces, or neglecting the security initialization processes of dependencies.
Role Takeover A situation where a user or contract illegitimately gains control over a privileged role by removing, overriding, or replacing the originally designated role holder.
Missing Time Constraint The contract does not check time-related conditions (such as block.timestamp, deadline, expiry)
Unauthorized Upgrade Refers to the lack of authorization checks during the contract upgrade process, allowing unauthorized addresses to perform contract upgrade operations.
Missing Initialization The contract does not properly initialize necessary states (such as permissions, dependencies, parameters), which may lead to the contract being unusable or exhibiting abnormal behavior.
slot0 The contract directly relies on Uniswap's slot0 (which provides instantaneous price and liquidity data) as its quoting source without applying any time-smoothing mechanisms (such as TWAP). This makes the price highly susceptible to short-term manipulations, for instance through flash loans.
Bad Condition This refers to errors or omissions in the conditional logic within the code that result in critical state checks, control flow branches, or security mechanisms not being triggered properly. Such errors can lead to severe issues, including loss of funds, permission bypasses, state inconsistencies, or logical corruption.
Unfair Liquidation This occurs when a user, despite not violating the protocol's rules, is liquidated due to insufficient protective measures or design flaws in the protocol.
Nonce The absence or misuse of a nonce mechanism can lead to operations being re-executed, replayed, or subjected to race conditions.
Fee On Transfer Token Vulnerability, incompatibility, or oversight arises due to the behavior of fee-on-transfer tokens — tokens that deduct a fee during transfers, causing the received amount to be less than the sent amount.