Sui Move isn't just another smart contract language. It takes a fundamentally different approach to how programs manage assets, enforce access control, and express ownership — and those differences have real consequences for how you build, audit, and secure a Sui Move smart contract.
If you're coming from Solidity or even Aptos Move, Sui's object model will feel unfamiliar at first. This article covers the three areas that matter most when building on Sui: capability objects, the ownership model, and what both of those mean for your audit surface.
How Sui Move Differs From Other Move Variants
Move was designed to treat digital assets as first-class values — things that can't be accidentally copied or destroyed. Sui takes that foundation and builds an object-centric model on top of it.
In Sui, everything is an object with a unique ID. Each object has an explicit owner, and the runtime enforces ownership rules at the transaction level. That's a meaningful departure from account-based models where contracts hold state in mappings and callers prove access through signatures alone.
The practical result: many common Solidity vulnerabilities — reentrancy, unauthorized state mutation, unchecked access — are either impossible or require deliberate misuse in Sui Move. But Sui introduces its own class of risks, particularly around how capabilities are designed and delegated.
Capability Objects: The Access Control Primitive
In Sui Move, capability objects are the standard pattern for access control. A capability is a struct that represents the right to perform a specific action. Hold the capability object, and you can call the function. Don't hold it, and you can't.
public struct AdminCap has key, store { id: UID }
public fun mint(cap: &AdminCap, ctx: &mut TxContext) {
// only callable by whoever holds AdminCap
}
This is clean and auditable. The capability is a concrete on-chain object — not an implicit role buried in a mapping. Auditors can trace exactly who holds it, how it was issued, and whether it can be transferred.
Transferable vs. Non-Transferable Capabilities
The store ability is what makes a capability transferable. A capability with only key (no store) can exist as an owned object but can't be placed inside another object or sent to a different address through standard transfer functions.
This distinction matters a lot for security. A transferable admin capability can be sold, delegated, or accidentally sent to the wrong address. A non-transferable capability stays permanently bound to whoever received it at creation.
When designing a protocol, think carefully about whether each capability actually needs to be transferable. Many teams add store out of habit, which widens the attack surface without any real benefit.
Capability Proliferation
A common mistake is minting multiple copies of a capability without a clear issuance policy. If your init function creates three AdminCap objects and sends them to three addresses, you've created three independent admin keys. Compromise any one of those addresses, and an attacker has full admin access.
Better practice: issue capabilities sparingly, document the issuance logic explicitly, and consider whether high-privilege capabilities should be held by a multisig or governance contract rather than an individual wallet.
Sui's Ownership Model
Sui distinguishes between four ownership types. Understanding them is essential for both design and security review.
Owned Objects
An owned object belongs to a specific address or another object. Only the owner can use it as a transaction input. This is the most common type and the safest from an access control perspective — the runtime enforces ownership, so no contract-level check is needed.
Shared Objects
A shared object can be read and written by any transaction. Shared objects require consensus and introduce ordering dependencies between transactions. They're necessary for things like order books or shared pools, but they expand the attack surface considerably.
Any function that takes a shared object as a mutable input can be called by anyone. That means the function itself must enforce all access control — the runtime won't do it for you. This is where many Sui Move vulnerabilities appear: developers assume ownership protection that simply doesn't exist for shared objects.
Immutable Objects
Immutable objects can be read by anyone but never modified. They're useful for published package metadata, configuration constants, and reference data. Once frozen, an object cannot be unfrozen.
Object-Owned Objects
An object can own another object — useful for composable assets like a character object that owns equipment. But this creates transfer restrictions: to move a child object, you need access to the parent. If not designed carefully, this can create unexpected lock-in.
The Audit Surface in Sui Move
Because Sui Move's type system eliminates several classic vulnerability classes, auditors focus on a different set of concerns.
Shared Object Access Control
Every public function that accepts a shared object by mutable reference is a potential entry point for any caller. Auditors check whether these functions enforce appropriate capability checks, whether the logic holds under concurrent execution, and whether the object can be left in an inconsistent state.
Capability Issuance and Lifecycle
Where is each capability created? Can it be created more than once? Is there a way to revoke it? Sui Move doesn't answer these questions automatically — the developer has to design them explicitly. An audit will trace every capability from creation through all transfer paths to map the full privilege surface.
Witness Patterns
Sui Move uses one-time witness types for certain initialization patterns, particularly with the sui::coin module. A one-time witness is a struct that can only be created once, during module publication. Misuse — or failing to consume the witness properly — can leave a module in an uninitialized state or allow re-initialization.
Dynamic Fields
Sui supports dynamic fields, which let you attach arbitrary typed data to an object at runtime. They're powerful but opaque — they don't appear in the object's static type definition. Auditors check whether dynamic field keys are predictable (which can allow overwriting), whether field existence is verified before access, and whether removed fields are handled correctly.
Upgrade Authority
Sui packages can be upgraded, but upgrade authority is controlled by an UpgradeCap object. If a single address holds the UpgradeCap, the package can be changed unilaterally. Many protocols burn it to signal immutability, or transfer it to a governance contract. Auditors verify that the upgrade policy matches what the protocol actually claims.
Designing for Auditability
A Sui Move contract that's easy to audit is usually a better-designed contract. A few principles help get there:
Keep capability scope narrow. A capability that grants one specific permission is easier to reason about than one that grants many. If you're checking if has_admin_cap before ten different operations, consider splitting into purpose-specific capabilities.
Make ownership intent explicit. When you create an object, document whether it's meant to be owned, shared, or immutable. That choice should follow from the use case — not from convenience.
Avoid unnecessary shared objects. Every shared object is a surface any caller can touch. If an object only needs to be used by its owner, keep it owned.
Test capability transfer paths. Write tests that explicitly verify what happens when a capability moves to a different address. Make sure the new holder has exactly the access you intend — no more.
Working With Sui Move in Production
Getting the Move code right is only part of the picture. A production protocol on Sui also needs a deployment strategy, an upgrade policy, on-chain state monitoring, and a security review that actually understands Sui's risk model.
DappWeb works with teams building on Sui from architecture through mainnet launch — covering smart contract development, security modeling, and audit preparation, including the object design decisions and capability patterns described here. You can learn more about the approach to Sui Move application development on the DappWeb site.
For teams building on other Move-based chains, the ownership and capability concepts carry over, though the implementation details differ. Aptos Move development follows a resource-based model without Sui's object IDs, which shifts the audit surface in specific ways.
If you're evaluating multiple chains and considering EVM alongside Sui, the security considerations look quite different. Ethereum smart contract development involves a different threat model entirely — reentrancy, storage layout, and proxy patterns rather than capability objects and ownership types.
Frequently Asked Questions
What is a capability object in Sui Move? A capability object is a struct that represents the right to perform a specific action. Functions requiring elevated access take a reference to the capability as a parameter. Whoever holds the capability object can call those functions; no one else can.
What is the difference between owned and shared objects in Sui? An owned object belongs to a specific address, and only that address can use it as a transaction input. A shared object can be accessed by any transaction, which means the contract must enforce all access control itself — the runtime places no restrictions on who can call functions on shared objects.
Why does the store ability matter for capability security?
Adding store to a capability struct makes it transferable — it can be sent to other addresses or wrapped inside other objects. Without store, the capability stays with its original recipient. Applying store unnecessarily to high-privilege capabilities increases the risk of accidental delegation or theft.
What are dynamic fields and why do auditors focus on them? Dynamic fields let you attach typed data to an object at runtime. They're useful for extensible designs but don't appear in the static type definition, making them harder to reason about. Auditors look for predictable key collisions, missing existence checks, and improper handling of removed fields.
How does upgrade authority work in Sui Move?
When you publish a Sui package, you receive an UpgradeCap object. Whoever holds it can upgrade the package. Protocols that want to signal immutability burn the UpgradeCap. Those that want governed upgrades transfer it to a multisig or governance contract.
How is Sui Move different from Aptos Move? Both are derived from the original Move language, but Sui uses an object-centric model where every value has a unique ID and an explicit owner. Aptos uses a resource model where state is stored in accounts. The capability and ownership patterns differ between the two, which affects both design and audit approach.
What should I prioritize when auditing a Sui Move smart contract? Focus on shared object access control, capability issuance and transfer paths, one-time witness usage, dynamic field handling, and upgrade authority. These are where Sui-specific risks concentrate, and they require reviewers who understand Sui's object model — not just a generic smart contract audit checklist.
Sui Move gives you strong safety guarantees by default, but those guarantees only hold when you use the ownership and capability model correctly. The most consequential decisions happen at the design stage: which objects are shared, who holds which capabilities, and what the upgrade policy looks like. Getting those right before writing the first line of business logic is what separates a protocol that audits cleanly from one that needs significant rework. Learn more about what full-cycle Sui engineering looks like at dappweb.ai.