The problem we solve
Teams test what they expect: a cooperative user, inputs inside the intended range, transactions that succeed. Losses in this field come from everything else — an unexpected re-entrant call, a privileged function somebody left open, a storage slot that shifted during an upgrade, a price feed returning something absurd, a transaction ordering nobody imagined. These surface after deployment, when correction is at its most expensive, or come back from an external auditor late in a schedule with no room left to rebuild. Moving that examination earlier is the whole purpose of this engagement.
Expected outcomes
- An automated suite covering failure paths and edge conditions, not only the intended flow.
- A clear account of every privileged role in the system and what its holder can actually do.
- Severity-ranked findings with reproduction steps your developers can follow directly.
- Lower odds of discovering a material defect after deployment, when correction is costly or impossible.
- A codebase ready for independent audit without the review being consumed by basic findings.
- A permanent regression net that flags breakage on every future change to the contracts.
Who this is for
- Teams approaching a mainnet deployment who want independent examination beforehand.
- Companies that inherited contracts from a previous team or vendor and cannot describe their real condition.
- Teams heading into an external audit who want the fundamentals cleared before the review starts.
- Live products adding functionality to deployed or upgradeable contracts.
- Organisations evaluating a third-party contract or platform before depending on it operationally.
Use cases
- A full pre-deployment examination before going to mainnet.
- Assessing inherited contracts before building on top of them or routing funds through them.
- Preparing for independent audit and clearing predictable findings in advance.
- Verifying upgrade safety and storage layout before shipping a new implementation.
- Testing contract behaviour when an external data source stalls or returns an outlier.
- Establishing a testing practice for a team that has never worked with a suite.
Deliverables
- An automated test suite inside your repository, with a coverage report.
- A severity-ranked findings report: reproduction steps, potential impact and remediation guidance per item.
- An invariant document stating the conditions that must hold, and where each one is verified.
- A map of privileged roles, the accounts holding them, and what each one implies operationally.
- A step-by-step deployment and rollback runbook, rehearsed on a test network before approval.
- Post-deployment monitoring and alerting recommendations derived from your specific risk profile.
- A re-test memo recording what was fixed and what remains open by your decision.
Project phases
Framing and threat model
A working session on contract function, value flow and participants, and agreement on what counts as unacceptable failure.
Specification review
Documented behaviour compared against implemented behaviour, with every gap or ambiguity recorded before any test is written.
Test construction
Unit, integration, invariant and fuzz tests, run against a fork of live network state where the contract depends on it.
Review and analysis
Line-by-line reading against known weakness classes, supported by static analysis tooling and gas profiling.
Findings and remediation
A severity-ranked report, a walkthrough session with your developers, and technical support while fixes are made.
Re-test and readiness
The suite re-run after remediation, a deployment and rollback rehearsal on a test network, and a readiness memo.
- Estimated timeline
- 3 to 7 weeks
- An estimate that depends on scope and how quickly reviews come back — not a contractual commitment in itself.
- Pricing
- After scoping
- Scope depends on the number of contracts, code volume, complexity of external dependencies, and the state of any existing tests. We review the repository first, then send a scoped proposal.
Scope and working details
What is in and out of scope, how we work, and what we need from you.
What is included
- A framing session covering what each contract does, what value it guards, and who interacts with it.
- Specification versus implementation review: does the code do what your documentation claims.
- Unit and integration tests covering success, rejection and edge paths for every function.
- Fuzz and invariant testing against the conditions that must never break under any input.
- Manual code review against known weakness classes, supported by static analysis tooling.
- Review of privileged roles, upgrade paths and storage layout on upgradeable contracts.
- Testing against a fork of live network state, gas profiling, and a testnet deployment rehearsal.
- A severity-ranked findings report, remediation support, and re-testing once fixes land.
What is not included
- Issuing a formal audit certificate — independent audit is a separate engagement you contract directly; our role is to prepare the code for it.
- Any assertion that the code is free of vulnerabilities; systematic testing lowers risk but cannot prove absence of defects.
- Legal or regulatory advice, investment advice, promotion of digital assets, or fundraising assistance.
- Custody of private keys, treasury operations, or handling user funds.
- Rewriting contracts or building new functionality — we report and recommend; implementation is scoped separately.
How we work
We start from what must never happen — funds leaving without authorisation, a role escalating, an accounting invariant breaking — and work backwards into tests that try to make it happen. Material findings are raised the moment we have them rather than saved for a final document, because a critical issue days before launch is information you need immediately. Everything we write lives in your repository from the first commit, so the work stays visible throughout instead of arriving as a verdict at the end.
What we need from you
- Access to the code repository and its commit history.
- A written specification, or a documented explanation of what each contract is meant to do and for whom.
- A developer available for questions and remediation during the engagement.
- A description of external dependencies: price feeds, third-party contracts and backend services.
- A decision on whether fixes are made by your team or scoped separately with us.
Methodology and technology
Tests are written in Foundry and Hardhat against Solidity contracts, covering unit, integration, fuzz and invariant cases. Static analysis with Slither runs alongside manual review against known weakness classes: re-entrancy, access control errors, arithmetic behaviour, reliance on external data sources, and transaction ordering. Execution runs against a fork of live network state, with a deployment and rollback rehearsal on a test network before any mainnet step. Testing reduces risk but cannot prove the absence of defects, and it does not replace an independent audit. Any work touching financial assets or funding instruments is subject to independent legal and regulatory review before execution, and we make no investment or financial promises.
How this connects to the rest of our work
A service rarely works alone. These come before it or alongside it, and these are the solutions it forms part of.
Services that work with it
Smart Contract Development
Specified, tested and independently reviewed contracts — deployed with keys and admin rights you own.
dApp and Web3 Platform Development
Decentralised platforms non-technical users can operate — clear signing, honest states, fast data.
Blockchain Strategy and Use-Case Design
An honest read on whether blockchain fits your business, where value sits, and the simpler option.
Part of these solutions
Frequently asked questions
Is this a formal security audit?
No. We build the tests, review the code and issue a findings report, but we do not issue an audit certificate or present ourselves as an audit house. Independent audit is something you commission from a specialist firm; our role is to make sure the code reaches them with the fundamentals already resolved, which shortens review cycles and leaves the auditor time for what deserves it.
Can you confirm the contract is safe?
Nobody can say that honestly. Testing proves a defect exists when it finds one; it never proves absence. What we provide is documented coverage showing what was examined and how, plus an explicit statement of what fell outside that coverage, so the decision to deploy rests on specific knowledge rather than general confidence.
What happens if you find something critical days before launch?
You hear about it the moment we have it, not in the final report, with reproduction steps, likely impact and remediation options. The decision stays yours: delay, deploy with operational limits that contain the exposure, or reduce scope. Our job is to make sure the decision rests on clear information rather than schedule pressure.
Do we keep the tests afterwards?
Yes. The suite is written inside your repository and belongs to you, and it keeps working on every future change as a regression net. That is a core part of the value here, and we retain no copy or dependency of any kind.
Will you test contracts you did not write?
Yes, and much of our work is exactly that. We need repository access and an explanation of what each contract is supposed to do. Reviewing code written by another team carries added value, because an outside reader questions what the original author has stopped noticing.
What about contracts that are already deployed?
We review them as they are and separate what can be addressed through an upgrade mechanism, where one exists, from what cannot be changed and therefore has to be managed with operational controls, monitoring, alerting and value limits. The output is a realistic picture of your current position and defined options, not a blanket recommendation to rebuild.