Smart contract security · EVM · DeFi · Cross-chain
SENTRYX is a specialist smart contract security firm. We perform manual, adversarial review of EVM and DeFi systems — backed by invariant testing, fuzzing and verified remediation. Every Critical and High finding ships with a runnable proof of concept.
Track record
This band is driven by data/stats.js. Placeholders stay visible until a real, verifiable figure replaces them — we do not publish counts we cannot show you.
Threat classes
Most losses in DeFi come from a short list of well-understood flaw classes, applied to code that had never been read adversarially. We start every review with a threat model of your trust boundaries, then hunt these classes by hand before any tooling runs.
An external call made before state is updated lets the callee re-enter and repeat a withdrawal against stale balances. Classic, cross-function and cross-contract variants still appear in vaults, NFT mints and callbacks such as ERC-777 hooks and onERC721Received.
Reading a spot price from a single AMM pool, or a Chainlink feed without staleness and deviation checks, lets an attacker move the price inside one transaction with a flash loan and borrow, liquidate or mint against it.
Missing modifiers, initializers left callable, roles granted to the wrong address, or tx.origin authentication. The simplest class to describe and the one behind a large share of total losses, because one unguarded setter is enough.
Solidity 0.8 reverts on overflow, but unchecked blocks, casts, rounding direction and decimal mismatches still leak value. Share-price inflation on an empty vault and division-before-multiplication remain routine findings.
Any transaction whose outcome depends on ordering can be sandwiched or back-run: swaps without slippage bounds, approvals, commit-reveal schemes with weak commitments, and liquidations that pay the fastest bot rather than the protocol.
Storage layout collisions, uninitialised implementations, delegatecall to untrusted targets and admin keys held by a single EOA. Upgradeability multiplies attack surface; we review the migration path, not only the current code.
Flagship services
Every engagement produces the same artefacts: a written threat model, a findings register with severities, proofs of concept, and a remediation verification pass.
Line-by-line manual review of your Solidity or Vyper codebase against a written threat model. We enumerate trust assumptions, trace every external call and state transition, and then run static analysis and fuzzing to cover what humans miss. Findings are classified Critical to Informational, each with impact, likelihood and a PoC.
AMMs, lending, staking, vaults, perps and yield. Economic attack analysis, oracle dependencies, liquidation paths and accounting invariants under adversarial market conditions.
Message verification, relayer trust, replay protection, finality assumptions and the failure modes of every chain in the path. Bridges hold the largest single-exploit losses in the industry.
We write the properties your protocol must never violate — solvency, share-price monotonicity, conservation of value — and build Foundry, Echidna or Medusa suites that search for violations continuously.
Live triage during an exploit, root-cause analysis, fund tracing, coordination with white-hats and exchanges, and a post-mortem your users and investors can rely on.
For teams that ship every week. A dedicated reviewer reads each pull request that touches value flows, maintains your invariant suite, monitors dependencies and upgrades, and is on call when something looks wrong. Security that moves at the speed of your roadmap instead of gating it.
Chain specialisations, formal verification, MEV analysis, governance, RWA, restaking, due diligence and training.
Methodology
Six stages, each with a defined output. Scroll to move through them. The full methodology, including our severity matrix and what we need from you before day one, is on the process page.
We read the docs and the code before quoting. Together we fix the scope, list actors and privileges, external dependencies, and the assets at risk. The output is a written threat model that the review is measured against.
Two reviewers read every in-scope line independently, tracing value flows, state machines and every external call. This is where most Critical findings come from — no tool found the bugs behind the largest exploits.
Slither, Aderyn and Semgrep for known patterns; Foundry invariant tests, Echidna or Medusa fuzzing for the properties the protocol must hold. Where it pays off, Halmos or Certora for symbolic and formal checks on core maths.
Every Critical and High is reproduced as a runnable test against a fork, with the attacker's profit or the protocol's loss measured. If we cannot demonstrate it, we downgrade it and say so.
A report written for both your engineers and your investors: threat model, findings with remediation guidance, and a call to walk through each issue and its fix. The findings register is delivered as data, not only PDF.
You fix; we re-review every changed line, re-run the PoCs and the invariant suite, and mark each finding Fixed, Acknowledged or Open. The final report is publishable — and the invariant suite stays in your CI.
Severity system
Severity is a function of impact and likelihood, not of how clever the bug is. Select a level to see how we define it, the finding classes that usually land there, and what remediation typically involves.
What a finding looks like
Vault.withdraw() allows draining all deposits.withdraw() sends ETH to the caller before burning their shares. A contract receiving ETH re-enters withdraw() from its receive() hook; the balance check still passes because shares have not been updated, so the loop repeats until the vault is empty. The fix moves the state update before the transfer and adds a reentrancy guard as defence in depth.
function withdraw(uint256 shares) external { uint256 amount = shares * address(this).balance / totalShares; require(balanceOf[msg.sender] >= shares, "insufficient"); (bool ok, ) = msg.sender.call{value: amount}(""); // external call first require(ok, "transfer failed"); balanceOf[msg.sender] -= shares; // state updated after totalShares -= shares;}function withdraw(uint256 shares) external nonReentrant { uint256 amount = shares * address(this).balance / totalShares; require(balanceOf[msg.sender] >= shares, "insufficient"); balanceOf[msg.sender] -= shares; // effects first totalShares -= shares; (bool ok, ) = msg.sender.call{value: amount}(""); // interaction last require(ok, "transfer failed");}contract Attacker { Vault v; uint256 shares; receive() external payable { if (address(v).balance >= shares) v.withdraw(shares); // re-enter }}function test_drain() public { vm.deal(address(attacker), 1 ether); attacker.deposit{value: 1 ether}(); attacker.attack(); // one tx assertEq(address(vault).balance, 0); // vault emptied}How engagements run
An audit is only as good as the reading behind it, and from the outside every report looks the same. So we make the reading inspectable before you pay: the full methodology is public, the sample report is complete, and the scope document says exactly who is assigned to your code.
Staffing
We do not publish researcher profiles, and we do not hand you an anonymous “audit team” either. Before you sign, the scope document names the reviewers assigned to your codebase, what they have worked on, and any partner specialist involved. Nobody joins the engagement without you knowing.
Review model
Every standard audit gets two complete, separate readings of the full scope — not a junior pass with a senior sign-off. Independence is what makes a second read worth anything, and reconciling the two is where the disagreements that matter surface.
Questions buyers ask
More on the pricing page and in each service's FAQ.
Scope drives price. A pre-deployment assessment of a small contract set starts from $1,500; a standard smart contract audit from $3,000; a full DeFi protocol audit from $8,000; bridge and cross-chain audits from $15,000. Every engagement is quoted after a scoping review of the repository — lines of code, external integrations and the number of privileged roles matter more than contract count.
Typically one to four weeks depending on lines of code, complexity and external dependencies. A focused pre-deployment assessment can be delivered in under a week; a lending protocol with oracle and liquidation logic usually needs three to four weeks including remediation verification. Urgent timelines are possible at a premium if researcher capacity allows.
An executive summary, the threat model and trust assumptions, every finding with severity, impact, likelihood, a proof of concept where applicable, and specific remediation guidance. After fixes, we verify each remediation and publish the final status per finding. You receive the report as PDF and Markdown, plus the findings register as JSON.
Yes. Every Critical and High finding ships with a runnable proof of concept, usually a Foundry test against a fork, so your team can reproduce the issue and confirm the fix. If we cannot demonstrate an issue, we say so and downgrade it.
Core in-house strength is Solidity and the EVM across Ethereum and L2s such as Arbitrum, Optimism, Base and Polygon. Vyper, Rust (Solana), Move (Aptos, Sui) and Cairo (Starknet) engagements are delivered with vetted partner researchers, and we tell you up front who is on the engagement.
No audit can guarantee the absence of bugs. An audit is a time-boxed adversarial review that materially reduces risk. We recommend layering it with an invariant suite in CI, a bug bounty programme and on-chain monitoring, and re-auditing after any significant change — which is what the retainer is for.
Request an audit
Scoping is free and takes under two working days. You get a written scope, a fixed quote and a review plan for your codebase.