Cross-Template Constraint Gap
Detects signals wired between template instances where the constraint chain is broken, leaving inter-template data flows unconstrained.
Read MoreChecking on-chain data...
Could not determine address type.
Security detectors, exploit generators, attack patterns, and remediation guides for EVM, Solana, and Zero-Knowledge smart contracts.
Detects signals wired between template instances where the constraint chain is broken, leaving inter-template data flows unconstrained.
Detects constraint expressions whose multiplicative degree exceeds the proof system's gate degree, forcing expansion or breaking compilation.
Detects divisions and modulo operations where the divisor has no non-zero binding, yielding undefined witness behaviour exploitable by the prover.
Detects circular signal dependencies in circuit constraints that prevent deterministic witness generation.
Detects arithmetic that may wrap the finite field prime, producing field-correct but semantically wrong results for circuits modelling bounded integers.
A family of checks for Noir-specific hazards: unconstrained functions, oracle responses, Brillig escapes, and assertion dependencies on mutable state.
Detects ternary and conditional expressions inside unconstrained assignments, where the prover chooses which branch produces the witness value.
Detects nondeterministic operators on the right-hand side of `<--` assignments where no constraint later rebinds the result.
Detects R1CS quadratic constraints where both multiplicative factors contain only unconstrained signals, breaking proof soundness.
Detects signals consumed by bit-width-sensitive components without a preceding range constraint, enabling silent overflow of comparators and bit decompositions.
Detects redundant equality constraints that create signal aliases without adding security, potentially masking missing constraints.
Detects array accesses indexed by an unconstrained signal, giving the prover a free choice of which element is read.
Detects self-referential signal mutation inside loops, where prover-controlled iteration counts allow arbitrary final values.
Detects signals assigned more than once, including silent unconstrained overwrites that bypass constraint generation.
Detects incorrect template instantiation patterns including unused outputs, parameter mismatches, and unconstrained component output reads.
Detects tautological constraints that are always satisfied regardless of signal values, providing no security guarantee.
Detects component instances whose inputs or outputs are never wired into the enclosing R1CS, leaving the component's internal constraints disconnected from the proof.
Detects comparison operators used in unconstrained assignments, producing prover-controlled boolean values with no verifier check.
Detects declared signals that never appear in any constraint or assignment, indicating dead code or incomplete circuit logic.
Detects unconstrained witness expressions that combine several nondeterministic operations, where the constraint set is unlikely to fully rebind the result.
How to fix missing or insufficient Anchor account constraints that allow unauthorized account substitution.
How to prevent spoofed Clock sysvar accounts from manipulating time-dependent program logic.
How to fix integer overflow and underflow vulnerabilities in Solana programs.
How to prevent PDA seed collisions that allow distinct logical accounts to resolve to the same address.
How to fix missing PDA address validation that allows attackers to substitute attacker-controlled accounts.
How to prevent read-only reentrancy attacks where stale state is observed mid-CPI.
Detects signature vulnerabilities in account abstraction implementations including missing chain ID, replay across accounts, and malleability.
Detects banned opcodes and storage access violations in ERC-4337 validation phase that cause bundler rejection.
Detects security issues in ERC-4337 account abstraction implementations including validation phase violations, paymaster abuse, and bundler manipulation.
Detects unsafe array element deletion that leaves stale indices or gaps, corrupting data structures that depend on contiguous arrays.
Detects parallel array operations that assume equal lengths without validation, risking out-of-bounds access or incomplete processing.
Analyzes inline assembly usage for memory safety violations, missing overflow checks, and incorrect return data handling.
Detects contracts that assume transfer amounts equal the actual balance change, failing to account for fee-on-transfer, rebasing, or deflationary tokens.
Detects batch operations that lack atomicity guarantees, allowing partial execution failures to leave the contract in an inconsistent state.
Detects contracts that depend on EIP-4844 blob data availability, which is only guaranteed for a limited time window.
Detects contracts approaching or exceeding the EIP-170 24KB bytecode size limit, which prevents deployment.
Detects excessive owner privileges, single points of failure, and centralization patterns that enable rug pulls or administrative abuse.
Detects combinations of individually lower-severity issues that together form exploitable attack chains.
Detects tainted data flowing from untrusted external calls into security-critical operations like access control checks or transfer amounts.
Detects unreachable code paths and unused internal functions that increase bytecode size and may indicate logic errors.
Detects vulnerabilities in EIP-7702 delegation targets where EOAs temporarily delegate to smart contract code.
Detects deviations from the ERC-1155 multi-token standard including missing batch transfer callbacks and incorrect event emissions.
Detects insecure ERC-1271 contract signature verification including missing magic value checks, reentrancy during verification, and gas griefing.
Detects contracts that falsely claim ERC-165 interface support, enabling type confusion attacks in routers, marketplaces, and bridges.
Detects deviations from the ERC-20 token standard including missing return values, incorrect event signatures, and non-standard behavior.
Detects security issues in modular smart account implementations including plugin validation gaps, execution hook bypass, and module isolation failures.
Detects deviations from the ERC-721 NFT standard including missing safe transfer checks, incorrect event emissions, and enumeration issues.
Detects contracts that assume their ETH balance equals the sum of deposits, ignoring forcibly sent ETH via selfdestruct or coinbase transactions.
Identifies opportunities to reduce gas consumption including storage packing, unnecessary SLOADs, and suboptimal loop patterns.
Detects hardcoded gas stipends and gas limits that break when EVM gas costs change across hard forks or L2 environments.
Detects incorrect C3 linearization order in multiple inheritance that can cause unexpected function resolution and storage layout issues.
Detects Layer 2-specific vulnerabilities including sequencer dependency, L1-L2 message replay, and gas price oracle manipulation.
Detects contracts that can receive ETH but have no mechanism to withdraw or transfer it, permanently trapping funds.
Detects contracts compiled with outdated Solidity versions that contain known bugs or miss important safety features.
Detects ERC-2612 permit implementation issues including front-running, nonce manipulation, and deadline bypass.
Detects contracts storing sensitive data in private or internal state variables, which remain readable on-chain despite the visibility modifier.
Detects functions where require/assert conditions can be violated through specific input combinations or state manipulation.
Detects NFT marketplace and token contracts where ERC-2981 royalty payments can be circumvented through wrapper contracts or direct transfers.
Detects ERC-20 transfer functions vulnerable to short address attacks where truncated addresses cause the amount parameter to be left-shifted.
Detects unsafe sign extension in type conversions between signed and unsigned integers, where negative values become large positive numbers.
Detects upgradeable contracts that lack reserved storage gaps, risking storage collisions when new state variables are added in future versions.
Detects time-weighted average price oracle implementations vulnerable to multi-block manipulation or insufficient observation windows.
Detects common typos in Solidity code including =+ instead of +=, =- instead of -=, and similar operator transpositions.
Detects array accesses without bounds validation, enabling out-of-bounds reads/writes that corrupt storage or cause unexpected reverts.
Detects state variables and local variables that are declared but never read, indicating dead state or incomplete logic.
Detects vulnerabilities in vote-escrowed token governance systems including flash-vote attacks, lock manipulation, and decay bypass.
Detects contracts that conflate WETH and native ETH handling, causing stuck funds or incorrect transfer logic.
Detects incomplete account close operations where lamports are drained but account data is not zeroed, enabling account resurrection attacks.
Detects account closes without discriminator zeroing, enabling resurrection attacks.
Detects race conditions from account close/reopen between transactions.
Detects missing executable flag validation before using accounts as program IDs in cross-program invocations.
Detects account array access without bounds validation, a vulnerability that appears in 30% of recent Solana audit findings.
Detects unsafe iteration over account arrays without bounds validation, which can lead to out-of-bounds panics or buffer overflows.
Detects account deserialization without version validation, which can cause silent data corruption when account structures are upgraded.
Detects missing account list size validation for programs that expect a fixed number of accounts.
Detects account owner validation issues across CPI boundaries where ownership assumptions break after cross-program invocations.
Detects account reallocation data corruption vulnerabilities.
Detects unsafe account reallocation patterns that can corrupt data.
Detects accounts that could be resurrected after closure via PDA re-derivation.
Detects account data size violations in Solana programs.
Detects reads or writes to accounts after they are logically closed.
Detects incomplete account verification chains where accounts undergo partial validation, allowing attackers to bypass security checks.
Detects unsafe use of Address Lookup Tables without authority validation, allowing attackers to substitute malicious accounts.
Detects unsafe admin key handling including hardcoded keys, missing validation, and single points of failure.
Detects when Anchor account constraints are checked in incorrect order.
Detects Time-of-Check-Time-of-Use vulnerabilities in Anchor constraint validation.
Detects missing or incorrect Anchor discriminator validation.
Detects inconsistencies between Anchor IDL and program implementation.
Detects unsafe account initialization and closing patterns in Anchor programs.
Detects incorrect space allocation in Anchor account initialization.
Detects unsafe Anchor program upgrade patterns and missing security controls.
Detects unbounded Borsh Vec/String length prefix usage that can cause DoS.
Detects user-controlled bump seeds in PDA derivation without validation against canonical values.
Detects Clock sysvar usage in financial logic without staleness bounds, exploitable after network halts.
Detects Bubblegum/compressed NFT Merkle proof and authority vulnerabilities.
Detects hardcoded compute budget assumptions vulnerable to injection.
Detects resource issues that could exhaust Solana compute unit budget.
Detects ownership checks that can be bypassed through conditional logic, allowing unauthorized access.
Detects CPI calls without proper account list validation, enabling privilege escalation.
Detects circular cross-program invocation patterns that could cause infinite loops or resource exhaustion.
Detects CPI calls with potentially tampered instruction data from untrusted sources.
Detects CPI calls inside loops that can cause compute exhaustion and denial of service.
Detects unsafe signer propagation in nested CPI calls without re-validation.
Detects CPI calls to critical system programs without explicit address validation.
Detects integer truncation in security-critical operations including lamport transfers, account storage, and access control.
Detects missing validation of relationships between related accounts in CPI operations.
Detects cross-account state consistency issues.
Detects cross-instruction state desynchronization vulnerabilities.
Detects accounts used after CPI without re-validating initialization state.
Detects state inconsistencies and race conditions across CPI boundaries.
Detects potential endianness mismatches in data deserialization.
Detects division and modulo operations where the divisor may be zero, causing runtime panics and DoS vulnerabilities.
Detects potential denial-of-service via unbounded compute unit consumption.
Detects missing validation when interacting with durable nonce accounts, enabling replay attacks or transaction reordering.
Detects Ed25519 signature verification without canonical signature checks, allowing signature malleability attacks.
Detects missing or vulnerable emergency pause mechanisms in Solana programs.
Detects initialization patterns vulnerable to frontrunning attacks.
Detects hardcoded system program addresses instead of using named constants for program IDs.
Detects hardcoded sysvar addresses instead of using proper sysvar::id() derivation functions.
Detects hash collision vulnerabilities in cryptographic operations including weak algorithms, truncated hashes, and merkle proof misuse.
Detects implicit instruction ordering dependencies not enforced on all control flow paths, enabling authorization bypass through path-selective attacks.
Detects silently ignored errors or improper error propagation in Solana programs.
Detects missing instruction data length validation before unpacking, the most common source of runtime panics in Solana programs.
Detects unsafe instruction data parsing patterns that may cause panics or errors with malformed data.
Detects unsafe fallback logic for unrecognized instruction discriminators that may allow attackers to execute unintended code paths.
Detects hardcoded instruction index comparisons that can be bypassed by attackers who control transaction structure.
Detects unsafe instruction introspection with missing bounds or length validation when accessing transaction instructions via sysvar.
Detects missing validation that the transaction sender has authority for privileged operations.
Detects incorrect ordering of validation checks and sensitive operations, where state modifications or CPIs occur before authorization.
Detects account data access without sufficient length validation, which can cause buffer overflows or runtime panics.
Detects lamport operations without sufficient balance validation.
Detects unsafe integer type casts that may truncate data, causing loss of significant bits and security vulnerabilities.
Detects lamport conservation violations where balances are not properly maintained.
Detects lamport dust exploitation vulnerabilities in Solana programs.
Detects confusion between native SOL (lamports) and SPL token operations leading to incorrect value calculations.
Detects lamport transfers that may exceed available balance, causing underflow, account closure, or rent-exempt violations.
Detects liquidity pool manipulation vulnerabilities.
Detects unsafe metadata authority transfers without proper verification of the new authority.
Detects missing update authority verification in Metaplex Token Metadata operations.
Detects Metaplex metadata standard compliance violations.
Detects MEV and transaction ordering vulnerabilities in Solana programs.
Detects account initialization without validating the account is empty first.
Detects critical state-changing operations that lack idempotency guards, allowing replay or double-execution.
Detects potential rent exemption issues from lamport transfers.
Detects dangerous multi-hop cross-program invocation chains.
Detects multi-signature validation issues including weak thresholds, missing signer verification, and replay vulnerabilities.
Detects native programs deserializing account data without discriminator checks.
Detects missing authority validation when invoking Solana native programs.
Detects missing creator signature verification in NFT metadata operations.
Detects NFT metadata validation issues.
Detects NFT royalty enforcement bypass patterns.
Detects missing instruction discrimination in non-Anchor Solana programs.
Detects oracle price usage without staleness validation.
Detects reuse of the same bump seed value across multiple PDA derivations.
Detects PDA usage without ownership validation, allowing unauthorized access.
Detects PDA derivations without program-specific namespace seeds, risking cross-program collisions.
Detects incorrect PDA seed derivation patterns including wrong order, missing seeds, and non-deterministic sources.
Detects PDA derivations with weak entropy that could collide with system program addresses.
Detects user-controlled input used in PDA seeds without validation, enabling arbitrary PDA derivation.
Detects precision loss and rounding errors in DeFi financial calculations.
Detects large swaps without price impact validation.
Detects program interface compliance issues.
Detects security risks in upgradeable Solana programs including authority validation issues.
Detects role-based access control vulnerabilities including missing role checks, escalation risks, and hardcoded permissions.
Detects attempts to modify accounts that have been verified as readonly.
Detects readonly accounts forwarded to CPI calls that may bypass write locks.
Detects semantic misuse of readonly accounts.
Detects rent collection exploit patterns and missing rent-exempt checks.
Detects improper rent epoch validation and handling.
Detects cached rent-exempt minimum balances that become stale across epoch transitions.
Detects account data writes before rent-exempt funding.
Detects account reallocations without rent-exemption lamport adjustments.
Detects rent exemption requirement violations in Solana programs.
Detects partial lamport withdrawals without rent-exemption balance checks.
Detects accounts with identity validation (CheckKey) but missing signer validation (CheckSigner), allowing authorization bypass.
Detects Secp256k1 signature verification without canonicalization checks.
Detects race conditions from shared mutable account access where the same account is modified through multiple paths without duplicate checks.
Detects privileged operations with signer checks but no authority role validation, allowing any signer to execute admin actions.
Detects missing slippage protection in token swap operations.
Detects Token-2022 extension vulnerabilities including transfer hooks, fees, and confidential transfers.
Detects unsafe account close operations including non-empty accounts and rent drain attacks.
Detects missing validation in SPL token operations including ownership, mint, and authority checks.
Detects improper Associated Token Account usage including wrong ATA, missing derivation validation, and mint mismatch.
Detects confusion between token account authorities (owner, delegate, close authority, mint authority, freeze authority).
Detects token account closure without validating the close_authority field.
Detects SPL Token standard compliance violations.
Detects excessive delegation chain depth that increases attack surface and complexity.
Detects integer overflow vulnerabilities in token delegation amount calculations.
Detects unsafe token delegation patterns including unlimited approvals and missing revocation.
Detects unsafe freeze and burn operations with missing authority validation or balance checks.
Detects token operations performed without checking if the account is frozen.
Detects metadata validation issues including missing PDA checks, update authority verification, and URI validation.
Detects mint authority vulnerabilities including missing validation and unlimited minting.
Detects transfer hook vulnerabilities including bypass, reentrancy, and missing validation.
Detects stack and CPI depth limit violations in Solana programs.
Detects use of cached account data after CPI without reload, leading to stale reads.
Detects missing validation in token swap operations.
Detects stale sysvar data usage across blocks beyond Clock.
Detects unverified sysvar account usage that could allow attackers to substitute fake system data.
Detects timelock bypass vulnerabilities, missing delays for critical operations, and timestamp validation issues.
Detects dangerous dependencies on block timestamps in security-critical logic including access control and randomness.
Detects Token-2022 confidential transfer vulnerabilities.
Detects missing account ownership validation before cross-program invocations, allowing attackers to pass fake token accounts.
Detects token account spoofing and aliasing vulnerabilities where fake token accounts can be substituted.
Detects token operations that violate balance invariants such as mint without supply update or burn without supply decrease.
Detects token transfers and swaps with mismatched decimals without proper conversion.
Detects Token-2022 extension security misconfigurations.
Detects token account initialization race conditions.
Detects Token-2022 Immutable Owner extension validation issues.
Detects token transfers that do not account for Token-2022 transfer fees.
Detects unbounded account lists in CPI that can cause transaction size DoS.
Detects unchecked arithmetic operations that could silently overflow or underflow in SVM programs.
Detects CPI calls without return value validation, allowing silent failures.
Detects unchecked deserialization of account data that may panic on malformed input.
Detects usage of uninitialized accounts before proper initialization.
Detects potentially unsafe account data access patterns without bounds checking.
Detects governance voting power manipulation vulnerabilities.
Detects PDA derivations with weak seed entropy, enabling prediction and front-running attacks.
Detects missing wrapped token supply vs collateral parity validation.
Detects token operations that may accept zero amounts without explicit validation.
Detects unsafe zero-copy deserialization patterns that can lead to memory corruption.
How to fix incomplete account close operations that leave data intact after draining lamports.
How to fix missing discriminator zeroing on account close.
How to fix TOCTOU race conditions from account close/reopen between transactions.
How to fix missing executable flag validation before cross-program invocations.
How to fix account array access without bounds validation.
How to fix unsafe iteration over account arrays without bounds validation.
How to fix account deserialization that lacks version validation.
How to fix missing account list size validation for fixed account layouts.
How to fix stale owner validation across CPI boundaries.
How to fix account reallocation data corruption vulnerabilities.
How to fix unsafe account reallocation patterns.
How to fix account resurrection vulnerabilities from PDA re-derivation.
How to fix account data size violations.
How to fix use-after-close vulnerabilities in Solana programs.
How to fix incomplete account verification chains by adding missing validation checks.
How to fix unsafe Address Lookup Table usage by validating table authority and loaded addresses.
How to fix unsafe admin key handling, hardcoded keys, and single points of failure.
How to fix incorrect Anchor constraint ordering.
How to fix TOCTOU race conditions in Anchor constraints.
How to fix missing Anchor discriminator validation.
How to fix Anchor IDL and program implementation mismatches.
How to fix unsafe Anchor init and close patterns.
How to fix incorrect Anchor space allocation.
How to fix unsafe Anchor program upgrade patterns.
How to fix unbounded Borsh length prefix DoS vulnerabilities.
How to fix user-controlled bump seeds in PDA derivation.
How to fix Clock sysvar usage in financial logic to prevent post-halt exploitation.
How to fix compressed NFT Merkle proof and authority vulnerabilities.
How to fix hardcoded compute budget assumptions.
How to fix compute unit budget exhaustion issues.
How to fix ownership checks that can be bypassed through conditional logic.
How to fix CPI calls with unvalidated account lists.
How to fix circular CPI patterns that cause infinite loops or depth limit failures.
How to fix CPI calls with unvalidated instruction data from untrusted sources.
How to fix CPI calls inside loops that can exhaust compute budget.
How to fix unsafe signer propagation in nested CPI calls.
How to fix missing validation of critical system program IDs before CPI.
How to fix integer truncation in lamport transfers, account storage, and access control.
How to fix missing relationship validation between related accounts.
How to fix cross-account state consistency issues.
How to fix cross-instruction state desynchronization.
How to fix cross-program re-initialization attack vulnerabilities.
How to fix cross-program state inconsistencies.
How to fix endianness mismatches in data deserialization.
How to fix division operations where the divisor may be zero, preventing panics and DoS.
How to fix denial-of-service via compute unit exhaustion.
How to fix missing validation when interacting with durable nonce accounts.
How to fix Ed25519 signature verification to prevent malleability attacks.
How to fix missing or vulnerable emergency pause mechanisms in Solana programs.
How to fix initialization frontrunning vulnerabilities.
How to fix hardcoded system program addresses by using named constants.
How to fix hardcoded sysvar addresses by using proper derivation functions.
How to fix hash collision vulnerabilities caused by truncation, weak algorithms, or small inputs.
How to fix implicit instruction ordering dependencies not enforced on all control flow paths.
How to fix silently ignored errors and improper error propagation.
How to fix missing instruction data length validation before unpacking.
How to fix unsafe instruction data parsing patterns that may cause panics or errors.
How to fix unsafe fallback logic for unrecognized instruction discriminators.
How to fix hardcoded instruction index comparisons that can be bypassed.
How to fix unsafe instruction introspection with missing bounds or length validation.
How to fix missing authority validation for transaction senders in privileged operations.
How to fix incorrect ordering of validation checks and sensitive operations.
How to fix account data access without sufficient length validation.
How to fix missing lamport balance validation before transfers.
How to fix unsafe integer type casts that truncate data.
How to fix lamport conservation violations in Solana programs.
How to fix lamport dust exploitation vulnerabilities.
How to fix confusion between native SOL and SPL token operations.
How to fix lamport transfers that may exceed available balance or violate rent-exempt minimums.
How to fix liquidity pool manipulation vulnerabilities.
How to fix unsafe metadata authority transfers in Solana programs.
How to fix missing update authority verification in Metaplex metadata operations.
How to fix Metaplex metadata standard violations.
How to fix MEV and transaction ordering vulnerabilities in Solana programs.
How to fix missing empty account validation before initialization.
How to fix missing idempotency guards on critical state-changing operations.
How to fix dangerous multi-hop CPI chain issues.
How to fix multi-signature validation weaknesses including thresholds, replay protection, and signer verification.
How to fix missing discriminator validation in native Solana programs.
How to fix missing authority validation for native program CPIs.
How to fix missing NFT creator signature verification.
How to fix NFT metadata validation issues.
How to fix NFT royalty enforcement bypass patterns.
How to fix missing instruction discrimination in non-Anchor programs.
How to fix stale oracle price data usage.
How to fix reuse of bump seeds across multiple PDA derivations.
How to fix PDA usage without ownership validation.
How to fix PDA derivations lacking program-specific namespace seeds.
How to fix incorrect PDA seed derivation patterns.
How to fix weak PDA seed patterns that could collide with system addresses.
How to fix unvalidated user-controlled input in PDA seeds.
How to fix precision loss and rounding errors in DeFi calculations.
How to fix missing price impact validation in large swaps.
How to fix program interface compliance issues.
How to fix security risks in upgradeable Solana programs.
How to fix missing role checks, privilege escalation risks, and hardcoded role permissions.
How to fix readonly account mutation logic errors.
How to fix readonly account write bypass via CPI.
How to fix readonly account misuse vulnerabilities.
How to fix rent collection exploit patterns.
How to fix improper rent epoch validation.
How to fix cached rent-exempt minimum balances.
How to fix account data writes that occur before rent-exempt funding.
How to fix account reallocations without rent-exemption adjustments.
How to fix rent exemption requirement violations.
How to fix partial lamport withdrawals without rent-exemption checks.
How to fix missing signer validation on identity-checked accounts.
How to fix Secp256k1 signature malleability vulnerabilities.
How to fix race conditions from shared mutable account access.
How to fix privileged operations that check signer status but not authority role.
How to fix missing slippage protection in token swaps.
How to fix Token-2022 extension vulnerabilities.
How to fix unsafe account close operations in Solana programs.
How to fix missing validation in SPL token operations.
How to fix improper Associated Token Account validation.
How to fix authority confusion between owner, delegate, close, mint, and freeze authorities.
How to fix missing close_authority validation when closing token accounts.
How to fix SPL Token standard compliance violations.
How to fix excessive delegation chain depth in Solana programs.
How to fix integer overflow vulnerabilities in token delegation amount calculations.
How to fix unsafe token delegation patterns in Solana programs.
How to fix unsafe freeze and burn operations in Solana programs.
How to fix missing frozen state checks before token operations.
How to fix metadata validation issues including PDA checks and URI validation.
How to fix mint authority vulnerabilities in Solana token programs.
How to fix transfer hook vulnerabilities in Token-2022 programs.
How to fix CPI depth limit violations.
How to fix stale account data usage after CPI calls.
How to fix missing validation in token swap operations.
How to fix stale sysvar data usage.
How to fix unverified sysvar account usage that allows data spoofing.
How to fix missing timelock delays, timestamp validation issues, and unprotected cancellation.
How to fix dangerous dependencies on block timestamps in security-critical logic.
How to fix Token-2022 confidential transfer vulnerabilities.
How to fix missing account ownership validation before CPI calls.
How to fix token account spoofing and aliasing vulnerabilities.
How to fix token operations that violate balance accounting invariants.
How to fix token decimal mismatch vulnerabilities in cross-token operations.
How to fix Token-2022 extension security misconfigurations.
How to fix token account initialization race conditions.
How to fix Token-2022 Immutable Owner extension issues.
How to fix Token-2022 transfer fee accounting issues.
How to fix transaction size DoS vulnerabilities.
How to fix unchecked arithmetic operations that could silently overflow or underflow.
How to fix CPI calls that ignore return values, preventing silent failures.
How to fix unchecked deserialization vulnerabilities.
How to fix uninitialized account access vulnerabilities.
How to fix unsafe account data access patterns.
How to fix governance voting power manipulation vulnerabilities.
How to fix PDA derivations using weak seed entropy.
How to fix missing wrapped token supply vs collateral parity validation.
How to fix missing zero-amount validation in token operations.
How to fix unsafe zero-copy deserialization patterns.
How to fix broken constraint chains between template instances by using constrained wiring.
How to fix constraints that exceed the R1CS quadratic degree limit by decomposing into intermediate signals.
How to prevent division-by-zero risks in ZK circuits by adding non-zero constraints on divisor signals.
How to fix circular signal dependencies that create unsatisfiable or ambiguous constraint systems.
How to prevent field overflow in ZK circuit arithmetic by adding range constraints on signals before operations.
How to fix Noir-specific vulnerabilities including unconstrained function misuse, oracle manipulation, and Brillig escapes.
How to fix ternary operators in unconstrained assignments where the prover controls which branch executes.
How to constrain nondeterministic operations in ZK witness generation to prevent prover manipulation.
How to fix constraint expressions with multiple multiplications that do not decompose cleanly into R1CS form.
How to fix missing range constraints on signals used in size-sensitive operations.
How to fix redundant equality constraints that create aliases without adding security.
How to fix unconstrained signals used as array indices by using constrained multiplexer circuits.
How to fix self-referential signal mutations in loops by using signal arrays with per-step constraints.
How to fix signals assigned multiple times by using distinct signals or arrays for each computed value.
How to fix incorrect template instantiation patterns including parameter mismatches and unconstrained wiring.
How to fix constraints that are always satisfied regardless of signal values.
How to fix component instances with disconnected inputs or outputs that do not contribute to circuit security.
How to fix comparison operators in unconstrained assignments by using constrained circomlib comparator components.
How to fix unused public inputs, unassigned signals, and dead signals in ZK circuits.
How to fix complex unconstrained witness computations by decomposing into simpler steps with per-step constraints.
Detects non-atomic multi-step state updates where intermediate consistency checks are missing between storage writes.
Detects state mutations after external calls that may trigger callbacks, violating the Checks-Effects-Interactions pattern.
Detects improper state initialization in constructors of upgradeable contracts where state is invisible to proxies.
Detects denial of service vulnerabilities where external calls in loops lack error handling, allowing one failed call to block entire batch operations.
Detects proxy initializer functions that make external calls before setting the initialized flag, enabling re-initialization attacks.
Detects loops without proper iteration bounds where the count can be influenced by external input, causing DoS via block gas limit exhaustion.
Detects unbounded memory allocation patterns that can cause out-of-gas denial of service attacks.
Detects insecure Merkle proof verification patterns vulnerable to second preimage attacks and proof malleability.
Detects contracts that can be destroyed and redeployed at the same address with different code using CREATE2 and SELFDESTRUCT.
Detects off-by-one errors in loop boundaries that can lead to skipped elements or out-of-bounds array access.
Detects security validations placed inside conditional branches that can be bypassed through alternate execution paths.
Detects privileged accounts being passed to unvalidated programs via CPI, enabling authority hijacking.
Detects CPI return data used for critical operations without independent on-chain state verification.
Detects false signer claims in cross-program invocations where accounts were not actually signed in the original transaction.
Detects DeFi-specific reentrancy patterns where external calls occur before state updates in vault, lending, and staking operations.
Detects missing repayment validation in flash loan patterns, allowing borrowers to avoid repaying borrowed funds.
Detects token minting operations without proper mint authority validation, enabling unauthorized token supply inflation.
Detects PDA signer seeds that can be extracted or predicted by attackers, enabling PDA authority bypass.
Detects missing safeguards in governance implementations that enable proposal manipulation and flash governance attacks.
Detects programs reading sysvar data from accounts without validating the account key matches the canonical sysvar address.
Detects unchecked arithmetic in fee and rent calculations that can overflow or underflow, leading to fund loss.
Detects unauthorized vault state modifications and missing invariant checks in DeFi vault operations.
Detects Noir private (witness) inputs of type Field that are not referenced in any assertion, allowing the prover to set them to arbitrary values.
Detects loop iteration bounds that depend on unconstrained signal values, allowing the prover to choose how many iterations execute.
Detects component instantiations where outputs are read but inputs are not wired, leaving the sub-circuit unconstrained and enabling proof forgery.
Detects circuit output signals that lack any constraining assignment or explicit constraint, allowing the prover to set outputs to arbitrary values.
Detects public input signals that are used in computations but never appear in any constraint, enabling the prover to forge the claimed public input value.
Detects signals assigned via unconstrained assignment without any corresponding constraint, allowing the prover to set them to arbitrary values.
How to ensure multi-step state updates maintain invariant consistency using intermediate checks, reentrancy guards, and explicit state machine patterns.
How to fix state mutations after external calls by applying the Checks-Effects-Interactions pattern and reentrancy guards.
How to move state initialization from constructors to initializer functions in proxy-based upgradeable contracts.
How to prevent denial of service from unchecked external calls in loops using error handling, pull patterns, and try/catch.
How to prevent reentrancy in proxy initializer functions by using OpenZeppelin's Initializable modifier and setting the initialization flag before external calls.
How to prevent DoS via block gas limit exhaustion by adding maximum iteration limits, pagination, and pull-over-push patterns.
How to prevent out-of-gas denial of service by bounding memory allocation size in functions that process untrusted input.
How to prevent second preimage attacks and proof malleability by using double-hashed leaves and audited Merkle proof libraries.
How to prevent code replacement attacks by removing SELFDESTRUCT from CREATE2-deployed contracts and using standard proxy patterns.
How to fix off-by-one errors in loop boundaries by using correct comparison operators and avoiding length-1 patterns.
How to ensure security validations execute unconditionally on all paths to critical operations.
How to prevent privileged accounts from being delegated to unvalidated programs via cross-program invocations.
How to prevent forged CPI return data from influencing critical program operations.
How to prevent false signer claims in cross-program invocations by validating signer status before CPI calls.
How to prevent DeFi reentrancy by following the checks-effects-interactions pattern in vault, lending, and staking operations.
How to enforce flash loan repayment validation to prevent borrowers from defaulting on loans.
How to validate mint authority before token minting operations to prevent unauthorized supply inflation.
How to protect PDA signer seeds from extraction by using domain separation and program-controlled seed components.
How to protect governance implementations from flash governance, quorum bypass, and timelock circumvention.
How to prevent sysvar spoofing by validating account keys or using the Sysvar::get() API.
How to use checked arithmetic in fee and rent calculations to prevent overflow and underflow exploits.
How to protect DeFi vault state from unauthorized modifications through access control and invariant enforcement.
How to fix unchecked private inputs in Noir by adding assertions that constrain witness values.
How to fix prover-controlled loop bounds by using constants, template parameters, or constrained signals.
How to fix unconnected component inputs by wiring all sub-circuit inputs to parent signals using constraining assignments.
How to fix unconstrained output signals by adding constraining assignments or explicit constraints.
How to fix unconstrained public inputs by adding constraints that bind them to the circuit's computation.
How to fix under-constrained signals by adding proper constraints to ensure circuit soundness.
Detects ERC-20 transfer and transferFrom calls where the recipient or amount is user-controlled without access control, enabling token theft.
Detects external calls to user-controlled addresses without validation, enabling attackers to redirect execution to malicious contracts.
Detects JUMP or JUMPI instructions where the destination is derived from user input, enabling control-flow hijacking.
Detects functions that write to storage slots determined by user-controlled input, enabling attackers to overwrite any state variable.
Detects reachable assert() statements that indicate invariant violations and potential logic bugs in smart contracts.
Detects unsafe bit shift operations where the shift amount is user-controlled or exceeds the operand width, causing silent data loss.
Detects external calls inside loops that can cause denial-of-service when any single call reverts or the loop exceeds the block gas limit.
Detects storage slot collisions in proxy contracts that occur only under specific execution paths or conditions, leading to intermittent state corruption.
Detects unbounded dynamic arrays that can grow without limit, enabling denial-of-service through gas exhaustion on iteration.
Detects CREATE2 deployments where salt values can be predicted or brute-forced, enabling address collision attacks.
Detects arithmetic operations that mix values with different decimal precision without normalization, causing massive over- or under-payments.
Detects functions and state variables with implicit visibility that may unintentionally be public.
Detects usage of deprecated Solidity functions and constructs that may be removed in future compiler versions.
Detects storage slot collisions between facets in EIP-2535 diamond proxy contracts, where independent facets may unknowingly share storage locations.
Detects arithmetic expressions where division precedes multiplication, causing precision loss from integer truncation.
Detects division and modulo operations where the divisor may be zero, causing transaction reverts that lock funds or enable denial of service.
Detects external calls to user-controlled addresses without verifying that the target has deployed code, where silent success masks failed interactions.
Detects ERC-20 approve functions vulnerable to the front-running race condition where a spender can spend both old and new allowances.
Detects access control checks using EXTCODESIZE that can be bypassed by calling from a contract's constructor, where code size is zero.
Detects contracts that assume the received token amount equals the transferred amount, failing to account for fee-on-transfer tokens.
Detects contracts compiled with a floating pragma version that may produce different bytecode across compiler versions.
Detects functions with colliding 4-byte selectors that can cause incorrect function dispatch or proxy confusion.
Detects external calls that forward insufficient gas or allow callers to specify gas amounts that cause downstream operations to fail.
Detects abi.encodePacked usage with multiple dynamic types that can produce hash collisions via data concatenation ambiguity.
Detects modifications to storage variables that should be immutable, including constructor-set values modified by public functions and view-named functions that write to storage.
Detects comparison operators that are likely wrong — using = instead of ==, > instead of >=, or comparing incompatible types.
Detects initialization functions that were intended as constructors but became callable public functions due to naming errors in Solidity 0.4.x contracts.
Detects confusion between the XOR operator (^) and exponentiation (**) in Solidity arithmetic expressions.
Detects AMM and DEX liquidity pool contracts vulnerable to first-depositor inflation attacks where an attacker manipulates the share price to steal from subsequent depositors.
Detects transaction ordering dependencies exploitable by miners and MEV searchers, including sandwich attacks, frontrunning, and backrunning patterns.
Detects DEX and AMM swap operations that lack transaction deadline validation, allowing pending transactions to execute at stale prices.
Detects critical state-changing operations that do not emit events, reducing transparency and making off-chain monitoring impossible.
Detects functions that accept address parameters without checking for the zero address, risking permanent fund loss.
Detects msg.value used inside loops where the same ETH value is counted multiple times, enabling fund theft or accounting errors.
Detects contracts with payable fallback or receive functions that accept ETH without proper handling or access control.
Detects ERC-2612 permit implementations where nonce mismanagement enables frontrunning attacks on gasless approvals.
Detects contracts that interact with rebasing tokens (like stETH or AMPL) without accounting for balance changes that occur outside of explicit transfers.
Detects reentrancy vulnerabilities arising from semantic state inconsistencies rather than direct balance manipulation.
Detects AMM and DEX contracts vulnerable to reserve manipulation via direct balance inflation, enabling attackers to skew prices or drain liquidity.
Detects external calls vulnerable to returnbomb attacks where a malicious callee returns excessive data to cause out-of-gas reverts.
Detects right-to-left override Unicode characters used in Trojan Source attacks to disguise malicious code as benign.
Detects DEX swap functions vulnerable to sandwich attacks where missing slippage and deadline protections allow value extraction by MEV searchers.
Detects local variables or inherited state variables that shadow declarations in parent contracts, causing confusion about which variable is accessed.
Detects ECDSA signature verification that fails to check s-value bounds, v-value validity, or zero-address returns from ecrecover.
Detects improper ECDSA signature verification patterns including missing checks, incorrect hash construction, and unsafe recovery.
Detects storage layout changes during proxy upgrades that could corrupt existing state, including reordered variables and changed types.
Detects comparisons that are always true or always false due to type constraints, rendering conditional logic dead.
Detects reentrancy through ERC-777, ERC-1155, and ERC-4626 token callback hooks where state updates occur after hook-triggering transfers.
Detects external calls where the target address is user-controlled and not validated against known-safe addresses, enabling call redirection attacks.
Detects ERC-20 token operations whose boolean return values are not checked, allowing silent transfer failures.
Detects storage variables and struct pointers used before initialization, where default zero values may cause unexpected behavior.
Detects functions that transfer Ether without verifying the caller's authorization, allowing anyone to drain the contract's ETH balance.
Detects external callback hooks that execute untrusted code without proper validation, gas limits, or reentrancy protection.
Detects delegatecall operations where the target address is user-controlled or loaded from storage without authorization, enabling complete contract takeover.
Detects type casts that silently truncate values when converting from a larger to a smaller integer type.
Detects rounding direction errors in ERC-4626 vault share calculations that allow attackers to extract value through precision manipulation.
Detects redundant storage writes where a variable is written twice without an intervening read, wasting gas and potentially indicating logic errors.
Detects accounts used in conflicting roles or deserialized as the wrong type, enabling attackers to substitute one account type for another.
Detects missing or incomplete Anchor account constraint validation that could allow unauthorized account substitution.
Detects programs that read time data from unvalidated accounts instead of the canonical Clock sysvar, enabling timestamp manipulation.
Detects missing validation of user-controlled inputs including instruction parameters, account data fields, and system call results in Solana programs.
Detects PDA derivations with weak seed patterns that could collide with other PDAs or system addresses, enabling account hijacking.
Detects potential read-only reentrancy through CPI calls where a callee reads stale state from the caller during a callback.
How to prevent external calls to user-controlled addresses by validating targets against whitelists.
How to normalize token decimal precision before arithmetic to prevent over/under-payment vulnerabilities.
How to enforce immutability of constructor-set variables using the immutable keyword and initialization guards.
How to prevent reentrancy through ERC-777, ERC-1155, and ERC-4626 callback hooks using the CEI pattern and reentrancy guards.
How to validate user-controlled instruction data and account fields in Solana programs.
How to harden bridge validator and relayer infrastructure against compromise through high consensus thresholds, hardware key management, validator diversity, rotation schedules, and fraud proof challenge windows.
How to verify rent exemption when creating or modifying Solana accounts to prevent garbage collection of program-owned accounts.
How to eliminate cross-chain oracle vulnerabilities by adding L2 sequencer uptime checks, grace period enforcement, and cross-source price deviation validation before reading any Chainlink price feed on L2 networks.
How to eliminate cross-chain bridge balance vulnerabilities by implementing proof deduplication, deep finality requirements, Merkle proof verification, and the lock-and-mint pattern.
How to secure cross-chain bridge message processing by implementing nonce-based replay protection, chain ID binding, explicit state initialization, and validator threshold requirements.
How to safely deserialize Solana account data by validating discriminators, checking program ownership, and using Anchor's typed account system.
How to eliminate cross-chain timestamp coordination vulnerabilities by replacing exact timestamp matching with nonce-based identifiers and time-window validation that tolerates clock drift and miner manipulation.
How to secure contracts that consume off-chain data by requiring cryptographic signatures, freshness timestamps, and multiple independent sources to prevent data injection and replay attacks.
How to eliminate requirement violation vulnerabilities by correcting comparison operators, adding missing input validation guards, replacing assert with require for user-facing checks, and upgrading to Solidity 0.8.0 for built-in overflow protection.
How to reduce centralization risk through timelocks, multi-signature wallets, on-chain governance, and hard-coded parameter caps that protect users from compromised or malicious admins.
How to protect DAO governance systems against flash loan vote acquisition, low quorum exploitation, and timelock bypass using voting snapshots, mandatory delays, and flash loan-resistant token designs.
How to prevent integer overflow and underflow in Solana programs by replacing unchecked arithmetic with checked methods and safe intermediate widening.
How attackers exploit missing or improper access restrictions on critical functions — responsible for over $1.3 billion in DeFi losses including the largest hack in history.
How attackers forge, replay, or bypass cross-chain bridge messages to mint unauthorized assets — responsible for over $1.2 billion in losses across the bridge ecosystem.
How attackers use uncollateralized flash loans to manipulate prices, exploit protocol logic, and drain funds within a single transaction.
How attackers manipulate price oracles to exploit lending protocols, inflate collateral, and drain DeFi platforms — the most costly attack class in DeFi history.
How attackers exploit external calls that execute before state updates to recursively drain funds from smart contracts.
How to validate account discriminators and use Anchor's typed account system to prevent attackers from substituting accounts of the wrong type.
How to safely handle ERC20 token transfers by using SafeERC20.safeTransfer, accounting for fee-on-transfer tokens, and avoiding the token approve-transferFrom race condition.
How to protect protocols from extreme price movements and flash loan manipulation using deviation bounds, TWAP comparison, circuit breakers, and absolute price range constraints.
How to eliminate single oracle dependency by implementing multi-source price architectures, cross-validation, and circuit breakers that keep protocols functioning when any individual feed fails.
How to eliminate stale Chainlink oracle vulnerabilities by validating all latestRoundData return fields, enforcing heartbeat-based freshness thresholds, and adding L2 sequencer uptime checks.
How to harden contracts against oracle failure modes — zero prices, extreme values, and feed unavailability — using input validation, bounds checking, fallback oracles, and circuit breakers.
How to eliminate arbitrary storage write vulnerabilities by removing user-controlled assembly SSTORE operations, using Solidity mappings, and enforcing slot allowlists for unavoidable inline assembly.
How to prevent ECDSA signature malleability attacks by enforcing EIP-2 low-s values and tracking message hashes as nonces instead of signature hashes.
How to eliminate ERC20 integration vulnerabilities by using SafeERC20 for all token operations, measuring actual received amounts for fee-on-transfer tokens, and handling non-standard token behaviors such as missing return values and rebase mechanics.
How to eliminate uninitialized storage pointer vulnerabilities by upgrading to Solidity 0.5.0+ and always assigning storage references to explicit mapping or array slots.
How to eliminate default visibility vulnerabilities by always specifying explicit visibility modifiers on all functions and state variables, and upgrading to Solidity 0.5.0+ which enforces this at compile time.
How to eliminate block.timestamp dependency vulnerabilities by replacing miner-manipulable timestamp randomness and time-locks with Chainlink VRF and block-number-based logic.
How to eliminate weak randomness vulnerabilities in Solana programs by replacing predictable on-chain entropy sources with Verifiable Random Functions (VRF) or commit-reveal schemes.
Detects Solana programs that derive randomness from predictable on-chain sources such as clock timestamps, slot numbers, or account hashes.
How to defend Solana DeFi programs against oracle price manipulation through account ownership verification, staleness checks, confidence interval validation, and multi-oracle aggregation.
Detects Solana programs that rely on unvalidated or manipulable price oracle data, enabling attackers to trigger liquidations, drain vaults, or manipulate DeFi calculations.
How to prevent signature replay in Solana programs by including a nonce and deadline in the signed message and incrementing the nonce after each successful verification.
Detects signature verification without nonce or deadline replay protection, allowing valid signatures to be reused across multiple transactions.
How to safely use ctx.remaining_accounts by validating account ownership, type discriminators, and writability before any privileged operations.
Detects use of ctx.remaining_accounts in privileged operations without ownership and discriminator validation, allowing attackers to inject malicious accounts that bypass Anchor's type system.
How to prevent account role confusion by explicitly validating that accounts in distinct roles have distinct addresses.
Detects when the same account is passed in multiple positions with incompatible role requirements, enabling an attacker to bypass security checks through role confusion.
How to protect cross-chain bridge implementations against missing message verification, replay attacks, unauthorized relay, and protocol-specific LayerZero, Axelar, and Hyperlane integration errors.
How to ensure that delegated PDA signing authority is verified at each hop in a multi-step CPI chain, preventing intermediate programs from abusing implicitly inherited authority.
Detects vulnerabilities in cross-chain bridge implementations including missing message verification, replay attack exposure, unauthorized relay functions, weak finality assumptions, and protocol-specific issues in LayerZero, Axelar, and Hyperlane integrations.
Detects multi-hop CPI authority chains where delegated signing authority is not validated at each intermediate hop, allowing an attacker to abuse implicitly inherited authority from a PDA signer.
How to identify and fix business logic errors by enforcing protocol invariants, correctly ordering state updates, and validating edge cases.
How to ensure Cross-Program Invocations target the intended program by validating program account keys before invocation.
Detects violations of protocol-specific invariants — conditions that must always hold true for the protocol to operate correctly — including incorrect reward calculations, fee logic, and state transition rules.
Detects Cross-Program Invocations where the target program account key is not verified against the expected program ID, allowing an attacker to substitute a malicious program that accepts the same instruction format.
How to protect UUPS proxy implementations from front-running attacks by disabling initializers on the implementation contract.
How to prevent unauthorized SOL transfers by validating signer authorization and stored authority before any lamport modification.
Detects UUPS upgradeable proxy contracts where the implementation contract is deployed without calling the initializer, leaving the proxy's ownership and upgrade authority unset.
Detects unauthorized lamport transfers where an account's SOL balance is transferred without proper signer, key, or owner authorization checks.
How to protect ERC-4626 vaults from first-depositor share price inflation attacks using virtual shares, dead share seeding, or minimum deposit requirements.
How to prevent duplicate mutable account aliasing in Solana programs by adding key equality constraints and explicit address comparisons.
Detects ERC-4626 tokenized vault implementations that are vulnerable to the first-depositor share price inflation attack, where an attacker manipulates the share price to cause subsequent depositors to receive zero shares.
Detects when the same account is passed at multiple positions in an instruction where both references are mutable, creating aliasing bugs and undefined behavior.
How to protect staking and yield farming contracts against flash loan pool manipulation, timestamp gaming, and division-before-multiplication precision loss.
How to prevent Cross-Program Invocation reentrancy by applying the check-effects-interactions pattern and using CPI guards in Solana programs.
Detects vulnerabilities in staking, yield farming, and reward distribution functions that allow attackers to inflate reward claims through flash loans, timestamp manipulation, or division-before-multiplication precision loss.
Detects Solana programs that modify state after making a cross-program invocation, allowing the called program to invoke back before the state update completes.
How to protect DAO governance mechanisms against flash loan voting, timelock bypass, quorum manipulation, and treasury drain attacks.
How to safely close Solana accounts by zeroing data, verifying authority, and using Anchor's close constraint to prevent rent lamport theft.
Detects vulnerabilities in DAO governance mechanisms including flash loan-based voting, timelock bypass, quorum manipulation, delegation exploits, treasury drain, and emergency action abuse.
Detects account closure patterns that leave residual lamports accessible to the program or allow the account to be drained without proper authorization.
How to prevent cross-function reentrancy by applying the Checks-Effects-Interactions pattern and reentrancy guards to all functions sharing the same state.
How to ensure PDA derivation uses the canonical bump seed from find_program_address rather than create_program_address with an attacker-supplied bump.
Detects reentrancy attacks that exploit multiple functions sharing the same state, where an attacker re-enters a different function before the original call completes its state updates.
Detects PDA operations using potentially non-canonical bump seeds via create_program_address, which can enable PDA collision and address confusion attacks.
How to prevent read-only reentrancy by ensuring state is consistent before external calls and protecting price-reading functions from mid-execution observations.
How to prevent account reinitialization attacks by adding an initialization guard that checks the discriminator or an explicit initialized flag before overwriting account state.
Detects view functions that read shared state mid-execution of a mutating call, allowing attackers to observe and exploit inconsistent intermediate state without modifying it.
Detects account data writes that lack a prior initialization check, allowing attackers to reset account state or overwrite existing data.
How to validate Chainlink oracle data freshness by checking the updatedAt timestamp, answer validity, and round completeness before consuming price data.
How to prevent type cosplay attacks by validating the account discriminator before deserializing account data.
Detects contracts that consume Chainlink oracle data without verifying that the price is recent, allowing protocols to operate on outdated prices during network disruptions.
Detects account data deserialization that reads past the discriminator prefix without first validating it, allowing attackers to pass accounts of a different type.
How to add slippage protection to DEX swap operations by exposing minimum output parameters and bounded deadlines to callers.
How to prevent integer overflow and underflow in Solana programs by using checked arithmetic methods and the Anchor checked_math! macro.
Detects missing or insufficient slippage protection in DEX swap and liquidity operations, allowing MEV bots and sandwich attackers to extract value from transactions.
Detects unchecked arithmetic operations on user-controlled values in Solana programs that may overflow or underflow, enabling fund manipulation.
Detects arithmetic operations in Solana programs that can overflow or underflow, producing wrapped values that corrupt financial state.
How to prevent signature replay attacks by binding signed messages to a nonce, deadline, chain ID, and contract address using EIP-712.
How to prevent PDA substitution attacks by using canonical bumps, storing bump seeds, and verifying PDA derivation with Anchor's seeds constraint.
Detects signature verification without chain ID, contract address, nonce, or deadline binding, allowing valid signatures to be reused across transactions, chains, or contracts.
Detects Program Derived Addresses that are used without verifying their seeds and bump, allowing attackers to substitute counterfeit PDAs.
How to reduce front-running exposure through commit-reveal schemes, slippage protection, and transaction batching.
How to validate cross-program invocation targets to prevent attackers from redirecting CPI calls to malicious programs.
Detects transactions where the outcome depends on call ordering, enabling miners or other users to manipulate execution order for profit.
Detects cross-program invocations (CPI) where the target program ID is user-controlled and not validated, allowing attackers to redirect calls to malicious programs.
How to eliminate oracle manipulation vulnerabilities by replacing spot prices with time-weighted averages and using decentralized oracle networks.
How to add is_writable validation before account modifications in Solana native programs and use Anchor's #[account(mut)] constraint.
Detects smart contracts that rely on manipulable on-chain price sources, such as DEX spot prices or single-source price feeds, without time-weighted averaging.
Detects account modifications performed without verifying the is_writable flag, allowing read-only accounts to be silently corrupted or causing runtime errors.
How to eliminate flash loan attack surfaces by replacing manipulable spot prices with time-weighted average prices and adding sanity bounds on price inputs.
How to add proper account ownership validation in Solana programs to prevent unauthorized access via accounts owned by other programs.
Detects protocol patterns that are susceptible to flash loan price manipulation — specifically, reliance on on-chain spot prices that can be manipulated within a single transaction.
Detects account data reads where the account's program owner is not verified, allowing attackers to pass maliciously crafted accounts with arbitrary data.
How to eliminate precision loss in Solidity financial calculations by reordering operations, using scaling factors, and applying explicit rounding direction.
How to add proper signer verification before privileged operations in Solana programs using both native and Anchor approaches.
Detects division-before-multiplication and rounding errors in financial calculations that cause systematic fund loss or enable economic attacks through precision manipulation.
Detects privileged operations — lamport transfers and account data writes — performed without verifying that the involved account has signed the transaction.
How to prevent proxy storage collisions by using EIP-1967 unstructured storage slots for all proxy administrative variables.
Detects proxy storage layout collisions where the implementation contract's variables overlap with the proxy contract's administrative slots, enabling state corruption and privilege escalation.
How to prevent integer underflow in Solidity by using Solidity 0.8+ default arithmetic, adding explicit balance checks before subtraction, and using SafeMath in legacy contracts.
Detects subtraction operations without underflow protection that can wrap around to a large value, bypassing balance checks and enabling fund theft.
How to properly validate user-supplied inputs in smart contracts to prevent arbitrary fund routing, unbounded operations, and zero-address vulnerabilities.
Detects functions that accept user-supplied parameters and use them in sensitive operations without sufficient bounds checking, type validation, or access control enforcement.
How to replace predictable on-chain entropy sources with verifiable off-chain randomness from Chainlink VRF or commit-reveal schemes.
Detects use of predictable on-chain values — blockhash, block.timestamp, block.prevrandao — as sources of randomness, which miners or validators can manipulate.
How to eliminate exploitable timestamp dependence by replacing block.timestamp with block numbers, commit-reveal schemes, or off-chain randomness.
Detects reliance on block.timestamp for time-sensitive logic where validator manipulation of the timestamp by up to ~15 seconds can influence outcomes.
How to eliminate denial-of-service vulnerabilities by replacing push-based ETH distribution with pull withdrawal patterns and adding maximum batch sizes and pagination to prevent unbounded loop gas exhaustion.
How to prevent DoS vulnerabilities in Solidity by replacing push-payment patterns with pull payments and bounding loop iterations.
Detects patterns that allow attackers to permanently block contract execution, including unbounded loops, push-payment patterns, and external call failures in critical paths.
How to eliminate selfdestruct vulnerabilities by replacing balance-dependent invariants with internal accounting, protecting library contracts from direct initialisation, and avoiding the SELFDESTRUCT opcode entirely.
Detects use of the selfdestruct opcode, which can permanently destroy a contract and forcibly send its Ether balance to an arbitrary address.
How to safely use delegatecall in proxy patterns by validating the target address and using EIP-1967 storage slots to prevent storage collisions.
Detects delegatecall patterns where user-controlled input can specify the target address or data, potentially redirecting execution to a malicious contract.
How to eliminate tx.origin authentication vulnerabilities by replacing all tx.origin identity checks with msg.sender, which correctly identifies the immediate caller and is not vulnerable to phishing via intermediary contracts.
Detects use of tx.origin for authentication or access control, which allows phishing attacks to bypass authorization checks.
How to safely handle external call return values in Solidity to prevent silent failures from ignored CALL, SEND, and low-level call results.
Detects external calls whose boolean return value is not checked, allowing silent failures that leave the contract in an inconsistent state.
How to implement proper access controls on privileged functions using ownership patterns, role-based access, and multi-signature authorization.
Detects missing or improperly implemented access controls on privileged functions, allowing unauthorized callers to execute restricted operations.
How to eliminate integer overflow and underflow vulnerabilities in Solidity by using Solidity 0.8+ checked arithmetic and safe unchecked block practices.
Detects arithmetic operations that may overflow or underflow, producing incorrect values that can lead to fund theft or unexpected behavior.
How to eliminate reentrancy vulnerabilities by applying the Checks-Effects-Interactions pattern and using reentrancy guards.
Detects functions that transfer Ether or call external contracts before completing state updates, allowing attackers to recursively re-enter and drain funds.
Sigvex exploit generator that validates Cross-Program Invocation (CPI) reentrancy vulnerabilities in Solana programs by simulating a malicious program that re-enters the victim program during a CPI callback before state is updated.
Sigvex exploit generator that validates ECDSA signature malleability vulnerabilities by computing the alternative valid s value and confirming that both signatures recover to the same address.
Sigvex exploit generator that validates missing replay protection in meta-transaction and permit functions by testing same-chain, cross-chain, and cross-contract replay scenarios.
Sigvex exploit generator that validates DAO governance vulnerabilities by simulating flash loan vote acquisition, insufficient quorum scenarios, and timelock bypass.
Sigvex exploit generator that validates cross-chain bridge vulnerabilities including message replay, cross-chain replay, and Nomad-style uninitialized state exploitation.
Sigvex exploit generator that validates cross-chain bridge balance inconsistency vulnerabilities including replay attacks, non-atomic operations, weak proof verification, and finality exploits that allow token supply inflation on the destination chain.
Sigvex exploit generator that validates bridge validator and relayer compromise vulnerabilities including low M-of-N thresholds, key management failures, centralized relayers, and missing validator rotation — with the Ronin Bridge ($625M) as the canonical attack scenario.
Sigvex exploit generator that validates account type confusion vulnerabilities in Solana programs by simulating an attack that passes a wrong account type to an instruction, bypassing type-based access controls.
Sigvex exploit generator that validates close account drain vulnerabilities in Solana programs where accounts are improperly closed, allowing an attacker to steal the rent lamports or reuse the account after closure.
Sigvex exploit generator that validates unsafe deserialization vulnerabilities in Solana programs where crafted account data causes incorrect state interpretation, type confusion, or panic in the deserialization layer.
Sigvex exploit generator that validates missing rent-exempt check vulnerabilities in Solana programs where accounts with insufficient lamport balances may be garbage-collected by the runtime, causing unexpected program failures.
Sigvex exploit generator that validates PDA (Program Derived Address) manipulation vulnerabilities in Solana programs by simulating an attack that passes a fake PDA to bypass program authority validation.
Sigvex exploit generator that validates lamport drain vulnerabilities in Solana programs by simulating an attack that drains all lamports from an account the program fails to adequately protect, with impact reported as potential SOL loss.
Sigvex exploit generator that validates missing signer check vulnerabilities in Solana programs by simulating instruction execution without required signatures, confirming unauthorized access to protected program logic.
Sigvex coverage-guided Solana program fuzzing framework with instruction-aware input generation, account state fuzzing, CPI simulation, invariant checking, and crash detection for Solana-specific vulnerability classes.
Sigvex exploit generator that validates off-chain data trust vulnerabilities where contracts accept external API data without signature verification, freshness checks, or redundancy — enabling data injection, replay attacks, and single-point-of-failure exploits.
Sigvex exploit generator that validates cross-chain oracle inconsistency vulnerabilities including L2 sequencer downtime, oracle price lag between chains, and missing Chainlink sequencer uptime feed checks.
Sigvex exploit generator that validates oracle failure vulnerabilities by testing contract behavior when price feeds return zero, extreme, or unavailable values.
Sigvex exploit generator that validates spot-price oracle manipulation by comparing contract execution under normal vs. artificially imbalanced DEX reserve configurations.
Sigvex exploit generator that validates price deviation vulnerabilities by submitting extreme price updates (10x increase, 90% crash) and confirming whether the contract accepts them without bounds checking.
Sigvex exploit generator that validates single oracle dependency vulnerabilities by simulating primary oracle failure with no fallback, confirming protocols that halt or misbehave when the sole price source goes offline.
Sigvex exploit generator that validates Chainlink oracle staleness vulnerabilities by executing contracts against fresh, stale (24-hour-old), and incomplete-round oracle configurations.
Sigvex exploit generator that validates transaction ordering vulnerabilities by simulating how different gas prices and transaction sequences affect contract outcomes.
Sigvex exploit generator that validates flash loan vulnerabilities by comparing contract execution under normal vs. temporarily-inflated balance conditions.
Sigvex exploit generator that validates centralization risk findings by classifying the specific privilege type and documenting the trust assumptions and attack scenarios enabled by single-owner control.
Sigvex exploit generator that validates ERC20 standard violations by simulating non-standard token behaviors including missing return values, fee-on-transfer tokens, and rebase tokens.
Sigvex exploit generator that validates unchecked arithmetic vulnerabilities by supplying maximum uint256 values and checking whether the execution reverts.
Exploit generator that validates unchecked arithmetic vulnerabilities in Solana programs where integer overflow or underflow in token balance calculations allows fund theft or state corruption.
Sigvex coverage-guided EVM fuzzing framework with ABI-aware input generation, property-based invariant checking, symbolic execution, multi-contract execution, and transaction sequence fuzzing.
Sigvex exploit generator that validates arbitrary storage write vulnerabilities by simulating user-controlled SSTORE operations targeting critical storage slots including the owner address.
Sigvex exploit generator that validates selfdestruct vulnerabilities including unprotected self-destruction, library-based destruction (Parity-style), and forced ETH reception.
Sigvex exploit generator that validates uninitialized storage pointer vulnerabilities by checking whether uninitialized struct or array pointers overwrite critical storage slots including owner and balance variables.
Sigvex exploit generator that validates randomness vulnerabilities by testing whether contract outcomes change predictably with controlled block environment variables.
Sigvex exploit generator that validates missing access control by calling privileged functions from an unauthorized address and checking for storage mutations.
Sigvex exploit generator that validates default visibility vulnerabilities in Solidity contracts where missing visibility modifiers default to public, exposing sensitive initialization and admin functions.
Sigvex exploit generator that validates unvalidated delegatecall targets by passing attacker-controlled contract addresses and checking for storage slot mutations.
Sigvex exploit generator that validates tx.origin authentication vulnerabilities by simulating a phishing scenario where an intermediary contract calls the victim with the owner's tx.origin.
Sigvex exploit generator that validates cross-chain timestamp coordination vulnerabilities including block time variation, clock drift between chains, and race conditions in time-sensitive cross-chain operations.
Sigvex exploit generator that validates block.timestamp dependency vulnerabilities by executing contracts at shifted timestamps (±900 seconds) to detect miner-manipulable randomness and time-lock bypasses.
Sigvex exploit generator that validates cross-function reentrancy vulnerabilities where shared state is inconsistent across multiple functions during an external call.
Sigvex exploit generator that validates read-only reentrancy vulnerabilities where view functions return stale state during an external call, misleading dependent protocols.
Sigvex exploit generator that validates reentrancy vulnerabilities by simulating recursive drain attacks against withdraw-pattern functions.
Sigvex exploit generator that validates DoS vulnerabilities by simulating unbounded loop execution and external call blocking scenarios to confirm contracts can be permanently disabled.
Sigvex exploit generator that validates requirement violation findings by classifying the specific check failure — incorrect comparison, missing validation, assert misuse, or arithmetic overflow — and documenting the exploit path.
Sigvex exploit generator that validates unchecked call return values by sending ETH to a contract that always reverts and checking whether the victim's state updates regardless.
Sigvex exploit generator that validates unsafe ERC20 token operations by simulating standard, USDT-like, and malicious token interactions to detect missing return value checks.
Sign in to access the knowledge base
Use the Sign In button in the navigation bar.
On Mac, use Cmd instead of Ctrl
Let's take a quick tour to help you get started with multi-runtime blockchain security analysis.