Find the vulnerabilities before the attacker does.

The contracts you deploy today are permanent. The vulnerabilities in them are too.

The largest smart contract exploits in history were not zero-day attacks on the EVM. They were exploits of incorrect assumptions — that a function would never be called twice in the same transaction, that an oracle price feed could not be manipulated within a single block, that a governance mechanism could not be captured by a flash loan. Every one of these was auditable before deployment. Smart contract code is immutable after deployment. You cannot patch a vulnerability on mainnet. You can only hope no one finds it before you do — or you can audit before you deploy. A PROPELOO audit does not just flag CVEs. It challenges the economic assumptions your protocol is built on.

What a production-grade audit covers.

A checkbox audit finds known vulnerability patterns. A production audit finds the vulnerabilities specific to your system — the ones no automated tool will ever flag.

System Layers

• Static Analysis Layer: Slither, Mythril and custom detectors run against every contract in the codebase
• Manual Review Layer: Line-by-line review of business logic, state transitions and access control
• Fuzz & Property Testing: Echidna and Foundry fuzz campaigns targeting protocol invariants
• Economic Model Review: Flash loan attack surface, oracle manipulation vectors, incentive misalignment
• Remediation Verification: Post-fix re-audit confirming all findings are resolved without introducing new issues

Core Technical Capabilities

• Reentrancy & Call Stack Analysis

  Cross-contract reentrancy, single-function reentrancy, read-only reentrancy and ERC-777 callback exploitation reviewed against every external call site.

• Access Control Review

  Role assignment logic, ownership transfer patterns, function visibility, proxy admin patterns and initialiser protection for upgradeable contracts.

• Arithmetic & Precision

  Integer overflow/underflow (Solidity <0.8 and unchecked blocks), precision loss in division, rounding direction and compound interest calculation errors.

• Oracle & Price Feed Security

  Spot price manipulation via flash loans, TWAP staleness, oracle fallback logic, deviation thresholds and single-source-of-truth price feed risks.

• Economic Attack Modelling

  Flash loan attack simulation, governance capture analysis, sandwich attack surface, front-running exposure and MEV extraction vectors specific to the protocol.

• Upgrade & Proxy Security

  Storage collision in proxy patterns, initialisation order vulnerabilities, delegatecall misuse, beacon proxy risks and governance-controlled upgrade mechanisms.

How we think about smart contract security.

An audit that only runs automated tools is not an audit. It is a linter. Real security requires an adversary mindset — asking not what the code does, but what an attacker can make it do.

• Automated tools find patterns. Humans find systems.

  Slither and Mythril are excellent at finding known vulnerability classes — reentrancy, unchecked returns, integer issues. They cannot understand the economic model of a DeFi protocol or recognise that a governance parameter is set to a value that makes attack profitable. That requires a human who has read the whitepaper and asked adversarial questions.

  Axiom:

• The most expensive bugs are in business logic

  Access control bugs, arithmetic errors and reentrancy are auditable mechanically. The bugs that cost $100M+ are in the assumptions: that a collateral asset cannot be manipulated, that a governance vote cannot be bought atomically, that a price feed represents real market prices. These require economic analysis, not just code review.

  Axiom:

• Test coverage is not security coverage

  A contract with 100% line coverage can have critical vulnerabilities. Test coverage measures what the developer thought to test. Fuzz testing and property-based testing find the inputs the developer did not anticipate. Both are required.

  Axiom:

• Remediation is part of the audit

  An audit report that lists 47 findings and hands them back to the developer is not useful. Every finding needs a clear severity, a specific recommendation and a re-verification step after the fix is applied. We treat remediation as part of the engagement, not an afterthought.

  Axiom:

The decisions that determine audit scope and depth.

Not every contract needs the same audit depth. These decisions determine what level of scrutiny is appropriate for your deployment.

• Manual review vs automated-only audit?

  Impact: Automated-only audits have been the stated methodology of firms whose clients were subsequently exploited. Do not deploy TVL-holding contracts without manual review.

  • Automated-only — fast, cheap, finds known patterns, misses logic bugs entirely
  • Manual review only — thorough for logic, misses mechanical issues automated tools catch in seconds
  • Automated + manual — industry standard for any contract holding real value
  • Automated + manual + formal verification — required for critical financial infrastructure

• Fuzz testing depth?

  Impact: Protocols with complex state machines (AMMs, lending, derivatives) require invariant-based fuzz testing. Unit tests do not find flash loan attack vectors.

  • Basic Foundry unit tests — minimum baseline, not a security measure
  • Foundry fuzz with bounded inputs — finds many arithmetic edge cases
  • Echidna property testing — defines and tests protocol invariants systematically
  • Medusa + Echidna + Foundry campaign — maximum coverage, required for AMMs and lending protocols

• Scope definition?

  Impact: Scope gaps have been directly exploited. An attacker does not respect your audit boundary. If a contract can call an out-of-scope contract, that interaction must be reviewed.

  • All contracts in scope — highest confidence, highest cost
  • Core contracts only — pragmatic for large codebases, document what is out of scope
  • Changed contracts only (re-audit) — appropriate post-fix, risks missing interaction effects
  • New contracts + interfaces to existing — minimum for protocol upgrades

• Audit firm selection?

  Impact: The credibility of the audit firm matters to institutional users and integrators. A Trail of Bits audit opens doors a no-name audit will not.

  • Top-tier firm (Trail of Bits, Spearbit, OpenZeppelin) — highest credibility, 6–12 week wait, $80K+
  • Mid-tier specialist firm — strong for specific chains/protocols, faster, $20–60K
  • Code4rena/Sherlock competitive audit — broad coverage via competition, variable quality, public findings
  • Internal team + external review — cost-effective for upgrades, not appropriate for initial mainnet deployment

• Timing of audit in development cycle?

  Impact: Architecture-level vulnerabilities found at the end of development cost 10x more to fix than the same issues found during design.

  • Post-completion, pre-deployment — standard, but late discovery means expensive rewrites
  • Architecture review + code audit — catches systemic issues before implementation
  • Continuous audit during development — highest quality, highest cost, appropriate for protocols >$10M TVL
  • Testnet + audit simultaneously — never: testnet users are not protected by an incomplete audit

• What to do with findings?

  Impact: Medium-severity findings that are "not exploitable in isolation" have been chained with other mediums to produce critical exploits. Fix the mediums.

  • Fix all critical and high, accept mediums and informational — minimum viable
  • Fix all critical, high and medium, document accepted risk for informational — recommended
  • Fix everything including informational — appropriate for custody and financial infrastructure
  • Dispute findings, redeploy without fixes — this is how exploits happen

What PROPELOO audits.

• DeFi Protocol Audit

  AMMs, lending protocols, yield aggregators and derivatives contracts — including economic model review, oracle attack simulation and liquidity drain analysis.

• Token Contract Audit

  ERC-20, ERC-721 and ERC-1155 contracts — including transfer hooks, fee mechanics, permit functions, minting access control and upgrade patterns.

• Bridge & Cross-chain Audit

  Message passing contracts, validator sets, lock-and-mint mechanics and cross-chain governance — the highest-risk category in smart contract security.

• Governance Contract Audit

  On-chain governance, timelocks, multi-sig configurations, proposal execution and flash loan governance attack surface.

• Upgrade & Migration Audit

  Proxy contract upgrades, storage layout verification, initialisation order review and re-audit after significant code changes.

• Pre-launch Security Review

  Full protocol security review before mainnet deployment — combining static analysis, manual review, fuzz campaigns and economic attack modelling.

The audit toolchain.

Every tool has a specific job. The combination matters as much as the individual tools.

• Static Analysis

  Stack: Slither, Mythril, Semgrep (custom rules), Solhint, 4naly3er

• Fuzz & Property Testing

  Stack: Echidna, Medusa, Foundry (fuzz mode), Halmos (symbolic execution)

• Manual Review

  Stack: VS Code + Solidity plugins, Surya (contract graph), sol2uml, Custom checklist per vulnerability class

• Economic Modelling

  Stack: Python (attack simulation), Foundry fork tests, Tenderly fork simulation, Custom flash loan attack PoC scripts

• Formal Verification

  Stack: Certora Prover, Halmos, K Framework (EVM semantics), SMTChecker (built-in)

• Infrastructure

  Stack: Tenderly, Hardhat, Foundry, Ethereum Mainnet fork, Alchemy / Infura

The vulnerability classes we audit against.

Each class requires a different methodology. Automated tools catch some. Manual review catches the rest.

• Reentrancy (all variants)

  Single-function reentrancy, cross-function reentrancy, cross-contract reentrancy and read-only reentrancy — all require different detection approaches. Read-only reentrancy in particular is missed by most automated tools and has been responsible for multiple eight-figure exploits on protocols that believed they were protected.

• Access Control Failures

  Missing onlyOwner modifiers, incorrect role assignments, unprotected initialise functions in upgradeable contracts, public functions that should be internal, and ownership transfer patterns that allow front-running. Access control issues are the most common critical finding in our audits.

• Oracle Manipulation

  Protocols that read spot price from their own AMM pool are vulnerable to flash loan price manipulation. TWAP-based oracles reduce this risk but introduce staleness. Multi-source aggregation with deviation checks is the correct architecture for any protocol where price determines solvency.

• Flash Loan Attack Vectors

  Flash loans allow arbitrary capital to be borrowed and repaid within one transaction. Any protocol assumption that can be violated by temporarily holding large amounts of a token is a flash loan vulnerability. This includes: spot price oracles, governance snapshot timing, collateral value calculations and protocol-owned liquidity assumptions.

• Arithmetic & Precision Errors

  Solidity 0.8+ prevents basic overflow/underflow but unchecked blocks re-enable it. Division before multiplication causes precision loss. Rounding direction (always round in favour of the protocol, never in favour of the user) is frequently incorrect. Compound interest calculations with integer arithmetic accumulate errors over time.

• Upgrade & Proxy Vulnerabilities

  Storage slot collision between proxy and implementation, uninitialised proxies, delegatecall to user-controlled addresses, selfdestruct in implementation contracts and upgrade governance that can be bypassed. Upgradeable contracts have a larger attack surface than immutable contracts — the upgrade mechanism itself must be secured.

The PROPELOO audit process.

1. 01. Scope & Kickoff

   Define audit scope, gather documentation (whitepaper, architecture diagrams, prior audits), establish communication channels and confirm timeline.

2. 02. Automated Analysis

   Run full Slither, Mythril and Semgrep suites. Triage automated findings to remove false positives. Build contract dependency graph and call graph.

3. 03. Manual Review

   Line-by-line review of all in-scope contracts. Focus on business logic, state machine correctness, access control and economic model assumptions.

4. 04. Fuzz & Property Testing

   Define protocol invariants with the development team. Run Echidna property testing and Foundry fuzz campaigns targeting identified invariants and edge cases.

5. 05. Economic Attack Modelling

   Simulate flash loan attacks, oracle manipulation scenarios and governance attacks using Tenderly fork testing and custom PoC scripts.

6. 06. Report Delivery

   Deliver full audit report: executive summary, all findings with severity/impact/recommendation, PoC code for critical/high findings, and remediation guidance.

7. 07. Remediation Review

   Review all developer fixes. Verify each finding is correctly resolved. Confirm no new issues introduced. Issue final audit certificate and public report.

Smart Contract Audit Engagements

Adversarial security audits protecting hundreds of millions in TVL across EVM, Solana and Rust protocols.

• DeFi Protocol Pre-Launch Security Audit

  Challenge: Lending protocol with $40M target TVL needed deep adversarial security review before mainnet launch.

  Architecture: Hybrid audit methodology combining automated static analysis (Slither custom detectors), invariant-based fuzzing (Foundry + Echidna with 1M run cycles), and dual-auditor manual line-by-line inspection. Formal verification applied to liquidation math and interest rate accrual invariants.

  Outcome: Identified 2 Critical, 4 High, and 7 Medium vulnerabilities before deployment. Prevented a potential $12M reentrancy drain in flash loan callback handler. Protocol launched with zero post-deployment security incidents.

• Cross-Chain Bridge Contract Review & Remediation

  Challenge: Cross-chain messaging protocol required audit of relayer validation, proof verification, and signature replay prevention across 4 EVM networks.

  Architecture: Comprehensive cryptographic verification review. Validated Merkle Patricia proof verification contracts, validator signature multisig thresholds, and message sequencing nonces. Implemented custom symbolic execution harness for message payload parsing.

  Outcome: Flagged signature replay vulnerability across chain IDs and missing emergency pause timelock. Designed remediation architecture adopted across all target chains.

• RWA Tokenization & Compliance Contract Audit

  Challenge: Institutional real estate tokenization platform needed audit covering ERC-3643 identity verification, transfer restrictions, and administrative freeze mechanics.

  Architecture: Rigorous review of identity registry integrations, claim topic validation, compliance rules engine, and role-based access control. Validated that transfer restriction failures never brick user token balances or contract state.

  Outcome: 100% test coverage reached. Delivered institutional audit report satisfying regulatory compliance requirements for European security token offering.

Frequently Asked Questions