Move Smart Contract Audit

A Move audit is a security review of Move modules on Sui, Aptos or a Move-based appchain, focused on capability leakage, object ownership transitions, generic type and witness confusion, and the resource-accounting errors that survive Move's linear type system.

Why Move code needs a specialist review

Move was designed so that assets cannot be copied or accidentally destroyed, and the linear type system delivers on that. What it does not decide is who should hold a capability, whether a shared object can be mutated by two transactions in an order you did not consider, or whether a generic type parameter you accepted from the caller lets them bypass a check. Move removes the crude bugs and leaves the design-level ones fully intact.

We audit Move by tracing authority. Every capability object is followed from creation to storage: who can obtain it, can it be transferred, can it be wrapped in something publicly readable. Shared objects are reviewed for the interleavings the runtime permits, not the sequence the happy path assumes. Where an invariant is worth proving rather than testing, we write it for the Move Prover and prove it.

Move-specific security considerations

Capability custody and leakage

AdminCap and TreasuryCap style objects transferred, stored in a shared object, or derivable by a caller who should not have them.

Shared object contention

Invariants that hold per-transaction but break across concurrent mutations of a shared object, and consensus ordering assumptions in the module logic.

Generic type and witness confusion

Type parameters accepted without a phantom or witness constraint, letting a caller-supplied type satisfy a check it should not.

Object ownership transitions

Owned-to-shared transitions that cannot be reversed, wrapped objects that become unreachable, and dynamic fields with unbounded growth.

Coin and balance arithmetic

Split and merge maths, rounding direction in fee and reward paths, and balances double-counted through struct manipulation.

Module upgrade policy

What the upgrade policy allows, struct layout compatibility, and what a package upgrade can change about resources users already hold.

Tooling we run on Move

How the engagement runs

  1. Scoping and threat modelling

    We fix a commit hash, agree the in-scope contracts and read your architecture docs, then build a threat model: who the actors are, what the trust boundaries are, and which invariants must never break. Nothing is reviewed against assumptions we have not written down.

  2. Manual review

    Line-by-line review by at least two auditors working independently, focused on authorisation, accounting, upgrade paths, external integrations and the gap between what the code does and what the documentation claims it does. Most critical findings come from this phase, not from tooling.

  3. Static and dynamic analysis

    Static analysers appropriate to the language, plus property-based fuzzing and invariant testing to push the system into states no unit test covers. Tooling is used to widen coverage, never to replace the manual pass.

  4. Exploit-path simulation

    Candidate findings are proven on a forked network with a working proof of concept. We report what an attacker can actually do and what it costs them, not a theoretical severity label.

  5. Reporting

    Every finding gets a severity rating, reproduction steps, the affected code, the impact in concrete terms and a specific remediation. You get a draft for discussion before anything is finalised.

  6. Fix review and re-test

    We re-test every remediation against the original proof of concept and check that the fix has not opened a new path. The final report is yours to publish.

What you receive

Move audit: frequently asked questions

Does Move's type system make audits unnecessary?

No. Linear types stop assets being copied or dropped. They say nothing about who should hold a capability, how shared objects interleave, or whether your reward maths is correct — which is where Move findings concentrate.

Do you use the Move Prover?

Where it earns its cost. Proving a supply-conservation or solvency invariant is high value; proving trivial properties is theatre. We say which we chose and why.

Sui and Aptos both use Move — is the audit the same?

The language is shared, the object models are not. Sui's owned/shared object model and Aptos's account-and-resource model produce genuinely different bug classes, and we review each on its own terms.

Can you review our upgrade policy?

Yes, and we recommend it. An immutable package and an upgradeable one carry opposite risks, and teams frequently ship a policy that does not match what they told their users.

What do you need from us to start an audit?

A repository or contract address, a commit hash to freeze the scope, whatever architecture or spec documentation exists, and a point of contact who can answer design questions. If documentation is thin we will write our understanding of the system back to you and ask you to confirm it — that step alone catches design-level bugs.

How long does an audit take?

A single token contract is 24–48 hours. A typical dApp or mid-sized protocol runs one to two weeks. Large DeFi systems, L2s, bridges and ZK circuits are scoped per project after we have seen the code. We will give you a fixed timeline with the quote, not an estimate that moves.

Is a re-test included after we fix the issues?

Yes. Fix review is part of the engagement, not an upsell. We re-run the original proof of concept against your patched code and confirm the fix has not introduced a new path.

Chains that run Move

Related security services

Get a fixed quote in 24 hours

Send the repository and a commit hash through the contact form, message @bugtester25 on Telegram, or book a 30-minute scoping call. 200+ protocols audited · $4B+ secured · 0 hacks post-audit. Prefer email? info@safeedges.in.