Smart Contract Security Audit (EVM + Move)

    1

    Most "smart contract audits" from generic tooling fail the same way: they drown you in a hundred pattern-matched warnings, inflate severities, and never prove a single exploit.

    $45

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Smart Contract Security Audit (EVM + Move)

    Example session with this skill installed

    Audit my Smart-contracts before launch. use smart contract audit skill It's an ERC-4626 vault with a new strategy loss-report path (upgrade/vault-v2 vs main). It's an upgradable proxy — check the storage diff too. I don't know where the risk is, so handle the scope yourself. Critical/High only, and kill your own findings before you show them to me.

    • Read your context and instructions
    • Compiled the smart contract security

    Audit Result — Meridian Vault upgrade/vault-v2 vs main (v5.2.0, Mode B)
    Summary — 1 High, 1 Medium, 1 candidate discarded by the gate. PoC executed on a fork pinned to the upgrade block. Negative controls pass. No style/gas noise.

    Scope (guided — buyer didn't specify): scope card presented, buyer chose (a) risk-based. T1 fully audited (Vault.sol, Strategy.sol), T2 read (Splitter.sol, RewardsDistributor.sol), T3 (mocks/test helpers) skipped with buyer's approval, named below. Storage layout diffed against main — clean.

    Findings

    Severity Location OWASP One-liner Cap at risk

    V-1 High src/Vault.sol:reportLoss:301 SC02:2026 (Business Logic) Loss tolerance measured against invested value — attacker drains insurance with a manufactured loss report 248,130 USDC (24.8% of TVL @ block 21,407,331)
    V-2 Medium src/Strategy.sol:withdraw:154 SC05:2026 (Input Validation) maxWithdraw advisory bypassed via second withdrawal of the same request; bounded by queue cap ≤ 41,000 USDC per epoch
    V-1 — attack path → PoC → negative control

    Attacker forces strategy holdings 400k → 0 (attacker-timed external call) before reportLoss().
    lossToleranceBps validates the rate, not the denominator — it's computed from invested balance, which the attacker moved. Insurance pays from the vault for a loss that never happened.
    Repeatable each rebalance cycle.
    solidity

    function test_poc_lossReport_drainsInsurance() public {
        // fork: block 21_407_331
        assertEq(insurancePayout(attacker), 248_130e6, "payout must be zero"); // FAILS on unpatched ✔ PoC passes (attack confirmed)
    }
    PoC on patched (min(reported, realized)): reverts "loss exceeds realized"; payout 0 ✔
    

    Fix: bind denominator to realized, on-chain-verified withdrawal.

    Self-adversarial review (logged, then discarded): "Reentrancy in claimRewards via reward-token callback" — killed at the §12 gate (Q3): balances are written before the transfer (CEI) and nonReentrant is set. Not in the report.

    Funnel: 312 in scope → 289 analyzed → 23 unread (test mocks) → 17 candidates → 6 clusters → 4 killed → 2 confirmed. 15 discarded candidates listed with reasons in the appendix.

    Next steps (yours): apply the V-1 fix (one-line denominator change), re-run the negative control, then ask me to re-audit the diff — that pass is where regressions hide. Want the Medium too? It's a 2-day patch; I'd bundle it with the same re-audit.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most "smart contract audits" from generic tooling fail the same way: they drown you in a hundred pattern-matched warnings, inflate severities, and never prove a single exploit. The result is fatigue, false confidence, and a report nobody trusts — while the bugs that actually drain protocols (access-control failures, business-logic breaks, rounding direction, bridge/verifier configuration, signing supply chains) sail through.

    Smart Contract Security Audit is an evidence-gated audit method, not a linter. It makes an AI agent work like a skeptical senior auditor and produce findings you can act on:

    Four audit modes — full repository, PR/diff, single module, or adversarial verification of someone else's finding (hostile by default; restate their path, find the check that defeats it). Coverage ledger — every external function in scope gets a status (analyzed-safe / candidate / out-of-scope / unread). "No issues found" becomes a falsifiable coverage claim, with a funnel you can check: functions → analyzed → candidates → confirmed. Invariant ledger first — quantitative, falsifiable invariants are written before hunting; every finding must cite one. Multi-lens fan-out — eight independent review lenses (Authority, Accounting, Control flow, Messages, Economics, Lifecycle, Domain, Configuration/supply-chain) so no single mental model blinds the audit. Executable proof — Foundry PoC recipes with quantity assertions, handler-based invariant fuzzing (including attacker actions like donation/warp), negative controls for every proposed fix, and state-delta traces when execution is impossible. False-positive elimination — a hard 12-point gate plus a self-adversarial review pass. Reasoning-only candidates are demoted to observations automatically. Severity is anchored to capital at risk, never inflated. OWASP SC Top 10:2026 classification on every finding — Access Control #1, Business Logic #2, Reentrancy demoted to #8 — with the 2025 incident data (122 deduplicated incidents, ≈$905M) baked in. 15 verified 2024–2026 incident case studies as checklists: Bybit ($1.5B blind-signed implementation swap), Cetus ($223M shift-bound in a dependency), Balancer V2 ($128M rounding direction), KelpDAO ($292M 1-of-1 DVN bridge config), GMX ($42M cross-contract reentrancy), and more — each with the exact audit rule extracted from the post-mortem. Domain playbooks for everything that ships today: ERC-4626 vaults, strategies/splitters/insurance, staking/rewards, AMMs + Uniswap v4 hooks (flash accounting, permission bitmaps), lending/liquidation, permits/Permit2/EIP-712, governance/timelock, ERC-4337, EIP-7702 delegated EOAs, cross-chain messaging (LayerZero/Axelar/CCIP receiver authentication + DVN threshold audit), multisig/Safe modules/guards and signing-supply-chain analysis, NFTs/ve-NFTs, escrow/factory/quest payout systems, plus the Sui/Move capability model, DeepBook-style DEXs, and bridges. Toolchain verification — compiler known-bugs with viaIR/evm_version/cancun conditions (incl. the 2026 Solidity releases), EVM-target vs deployment chain, bytecode-recompilation checks, storage-layout diffs on every upgrade, vendored-dependency diffing against upstream, and a grep sweep upgraded from the incidents that actually paid out. Honest reporting — Confirmed / Observations / Questions / Below-threshold kept separate, capital-at-risk per finding, limitations named explicitly. What you get is a report a client can rely on, not a wall of "maybes." Why you should buy it: the cost of a false negative is a drained protocol; the cost of a false positive is every real finding in your report being ignored. This skill is engineered around exactly that risk — evidence or silence. It is especially strong on the attack surface 2024–2026 proved most dangerous: authority, authorization, configuration, and the intent-to-bytes signing path — the layers above the code where the largest losses occurred.

    Best for: protocol teams, security researchers, audit reviewers, and bug-bounty hunters working on EVM/Solidity or Sui/Move codebases — full audits, diff reviews before upgrades, and second-opinion verification of external findings.

    Not for: style linting, gas optimization, or replacing formal audits/bug bounties for high-value deployments — it complements them, with proof instead of opinion.

    Safety first: Operating rule 1 makes no-broadcast-without-permission absolute. The agent cannot approve its own transactions; PoCs run on local forks; if it ever finds evidence a prior run broadcast without approval, it stops and reports it instead of hiding it.

    Evidence-gated smart-contract audits (EVM + Sui/Move) — 60+ vulns found in testing. Coverage ledger, multi-lens review, fork-based PoCs, OWASP SC Top 10:2026 tagging. Read-only on mainnet; nothing is broadcast without your approval.

    Requires full source or RPC for storage analysis. PoCs need a local Foundry environment. Does not support non-EVM/non-Move chains. Verification requires manual review of PoC output.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    Requires

    Git

    Permissions

    Read Files
    Write Files
    Terminal / Shell
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    Unlike tools that simply flag syntax errors, this skill requires every finding to be backed by a reachability path and an executable Foundry PoC (Proof of Concept), ensuring you only spend time on verified risks.

    The skill is optimized for EVM-compatible chains (Solidity) and the Sui ecosystem (Move), with specialized support for OpenZeppelin standards, Uniswap v4 hooks, and ERC-4626 vaults.

    You receive the full skill package including the multi-lens auditing logic, invariant mapping modules, and the 12-point false-positive gating system compatible with major AI agent frameworks.

    Yes, the 'Verify' mode allows the agent to act as a hostile reviewer, attempting to build executable PoCs to confirm or debunk findings from previous audits or bug bounty submissions.

    The skill requires access to your project's source code or a valid RPC endpoint for storage analysis, and it performs best when a local Foundry or Anvil environment is available for exploit simulation.

    New in Security