Gas in Sui works differently because transactions can run in parallel if they don’t touch the same objects. New developers often:

Mistake 1: Forget to optimize object dependencies, causing unnecessary contention.

Mistake 2: Overlook that gas is also an object, which can expire if not handled correctly.

Best Practice:

Minimize shared object usage unless necessary.

Benchmark gas usage early with testnet tools.

Always design transactions to maximize parallelism → cheaper and faster execution.

When you build on Sui, gas can trip you up if you do not plan carefully. One common issue is setting a gas budget that is too low, which causes your transaction to fail with an "insufficient gas" error. Another pitfall is overestimating the budget so much that you end up locking up more SUI than necessary during execution. Developers also forget that publishing Move packages costs more gas than calling simple functions, so if you are testing a lot without using dev inspect simulations, you will waste tokens quickly. Some get stuck when they use a gas coin with too small a balance, since every publish and call consumes gas no matter how simple it looks. A smart practice is to split coins and keep a few with enough balance so you do not run out mid-testing. Finally, overlooking the parallel execution model can make you think gas usage is higher than it really is when in fact it depends on object dependencies. By keeping track of budgets, reusing dev inspect for testing, and managing gas coins properly, you save costs and avoid unnecessary errors.

Many new Sui developers waste gas by overusing shared objects, rewriting large pieces of state, and fragmenting coins into too many Coin objects. Other pitfalls include storing big maps inside objects, mutating when read-only access would suffice, and emitting heavy events instead of lean diffs. Inefficient batching—splitting actions across multiple transactions instead of combining them—also drives up costs. To optimize, devs should minimize shared state, consolidate coins with Balance, favor child objects and events over big rewrites, mark inputs as read-only when possible, and bundle multi-step actions into single transactions. This keeps gas usage low while preserving safety and parallelism.

Common gas pitfalls in Sui development include:

Unnecessary object reads/writes → every storage access costs gas.

Redundant checks or loops → avoid re-validating data already guaranteed by types.

Creating too many small coin objects → causes fragmentation and higher merge costs.

Excessive event emission/logging → useful for debugging, but bloats gas.

Inefficient data structures → e.g., large vectors instead of maps for frequent lookups.

Improper batching → multiple small transactions instead of one well-structured batch.

Forgetting to reuse capabilities or references → leads to duplicate state changes.

Best practice: profile with Sui’s gas tools, minimize writes, and rely on Move’s type-safety to remove redundant runtime checks.

When you build on Sui one of the biggest challenges you face is managing gas correctly. A common mistake is setting the gas budget too low which causes transactions to fail even though your code is fine. Another issue is not checking the gas object itself since gas is paid from a coin object that must have enough balance and be properly owned. Developers also sometimes forget that every publish call or object creation has storage costs so transactions that mint lots of objects can unexpectedly drain gas. If you are running tests without using dev-inspect you can burn gas unnecessarily instead of simulating first. Another pitfall is assuming parallel execution means lower gas by default but in reality poorly designed contracts that touch shared objects still need consensus and therefore consume more gas. The safest approach is to always set a reasonable gas budget test transactions with dev-inspect and keep object design efficient so you avoid unnecessary consensus work. By doing this you keep transactions reliable and cheap.

1. Overusing Dynamic Data Structures

Pitfall: Using large vector or frequently growing vectors without pre-allocation.

Why It Costs: Each push or pop on a vector involves dynamic memory allocation, which adds significant gas.

Fix:

Use fixed-size data when possible.

Pre-allocate vectors with vector::empty() and reserve if the size is known in advance.

2. Excessive Object Reads and Writes

Pitfall: Unnecessarily mutating or re-writing entire objects when only a field needs to change.

Why It Costs: Each mutation triggers full object serialization.

Fix:

Use &mut references instead of moving full objects.

For large shared objects, minimize mutable access and prefer read-only when possible.

3. Multiple Transactions Instead of Batching

Pitfall: Sending multiple small transactions when operations could be batched.

Why It Costs: Each transaction incurs base gas fees.

Fix:

Batch operations (e.g., multiple transfers, claims) into one transaction using Move calls.

Use TransactionBlock in the SDK for grouping.

4. Over-Validation of Invariants

Pitfall: Adding redundant runtime checks (e.g., double-checking balances, re-validating input constraints that were already guaranteed).

Why It Costs: Each check adds computation.

Fix:

Decide what is essential on-chain versus what can be enforced off-chain in the frontend or SDK.

For invariant checks, consider debug-only assertions in development mode.

5. Creating Too Many Temporary Objects

Pitfall: Splitting and merging coins or tokens unnecessarily.

Why It Costs: Each coin split or merge is a storage operation, adding I/O cost.

Fix:

Reuse existing coins instead of creating many small ones.

Use coin::join and coin::split efficiently.

6. Storing Large Data On-Chain

Pitfall: Writing big strings, metadata, or large structs directly into objects.

Why It Costs: Storage gas is high on Sui for persistent data.

Fix:

Store only hashes or references on-chain, and keep full data off-chain (IPFS, Arweave).

Use event emission for logs instead of permanent storage.

7. Misusing Events

Pitfall: Emitting large event payloads frequently.

Why It Costs: Event storage fees scale with size.

Fix:

Keep event fields minimal and store only identifiers or hashes.

8. Forgetting About Gas Budget

Pitfall: Not setting a proper gas budget for transactions with multiple calls.

Why It Costs: Transactions can fail and still charge gas.

Fix:

Use dryRunTransactionBlock (or Sui Simulator) to estimate gas.

Always budget slightly higher than estimated to prevent failure.

9. Over-Relying on Shared Objects

Pitfall: Using shared objects for everything, even when owned objects would suffice.

Why It Costs: Shared objects introduce consensus overhead.

Fix:

Use owned objects for user-specific data, and shared objects only when truly needed (global state, pools).

10. Inefficient Error Handling

Pitfall: Using expensive abort codes in critical paths frequently.

Why It Costs: Aborts still consume gas for executed steps before failure.

Fix:

Validate early (fail fast) to reduce wasted computation.

Handle common checks off-chain where safe.

Common Gas Pitfalls in Sui Move Development

1. Large and Unnecessary Data Storage

Problem: Storing big structs, long strings, or heavy metadata on-chain.

Why It’s Bad: On-chain storage is permanent and costs a lot in Sui.

Solution:

Only store essential state on-chain.

Move heavy data off-chain (IPFS, Arweave) and store hashes or references instead.

2. Too Many Object Mutations

Problem: Rewriting entire objects when only one field changes.

Impact: Every mutation re-serializes the full object → higher gas.

Solution:

Use &mut references for updates.

Design your data model to minimize updates on large shared objects.

3. Inefficient Coin Splits and Joins

Problem: Splitting coins into too many small coins or merging repeatedly.

Impact: Each split/join is a storage and computation cost.

Solution:

Limit splits to what’s necessary for the transaction.

Reuse existing coin objects when possible.

4. Overuse of Shared Objects

Problem: Using shared objects for everything instead of owned objects.

Impact: Shared objects require consensus and more validation steps.

Solution:

Use owned objects for user-specific data.

Reserve shared objects for global state or pools.

5. Redundant Checks On-Chain

Problem: Revalidating conditions that can be enforced off-chain (e.g., amount > 0 after front-end check).

Impact: Every check adds cost and complexity.

Solution:

Keep only core security checks on-chain.

Push UI/SDK validation for non-critical constraints.

6. Multiple Small Transactions

Problem: Sending many small operations in separate transactions.

Impact: Base gas fee applies to each transaction.

Solution:

Batch operations in one transaction block.

Use Move calls with multi-operation support.

7. Large Event Payloads

Problem: Emitting large event data or doing it too often.

Impact: Events increase storage cost.

Solution:

Emit minimal data (IDs, hashes).

Offload detailed data to off-chain logs if needed.

8. Poor Error Handling

Problem: Checks happen late in execution, causing expensive aborts.

Impact: Gas is still spent for prior steps before abort.

Solution:

Validate early in functions.

Fail fast to minimize wasted gas.

9. Ignoring Gas Estimates

Problem: Not simulating transactions before sending them.

Impact: Failed transactions still cost gas.

Solution:

Use dryRunTransactionBlock to estimate cost.

Set proper gas budget in the transaction block.

10. Using Complex Loops

Problem: Iterating over large vectors or objects unnecessarily.

Impact: Loops scale gas with the size of data.

Solution:

Avoid unbounded loops in transactions.

Use indexed access or redesign data flow.

Common Gas Pitfalls in Sui Move Development

1. Storing Excessive Data On-Chain

Why It Happens: Developers keep full metadata (e.g., JSON or image data) in Move objects.

Impact: Permanent storage on Sui is costly because storage fees are proportional to object size.

Mitigation:

Store only essential state (e.g., ID, hash, amount).

Move heavy metadata off-chain (IPFS, Arweave) and store just references.

2. Overusing Shared Objects

Why It Happens: Shared objects are chosen for simplicity when global access isn’t required.

Impact: Shared objects require consensus and add overhead for every transaction.

Mitigation:

Use owned objects for user-specific data.

Reserve shared objects for global state (AMMs, order books).

3. Repeated Splits and Joins of Coins

Why It Happens: Multiple unnecessary split and merge operations for coins.

Impact: Each split/join increases computation and storage updates.

Mitigation:

Consolidate operations to minimize splits.

Keep reusable coin objects for fees and operations.

4. Late Aborts

Why It Happens: Validations happen after major processing steps.

Impact: Gas is consumed for steps before the abort occurs.

Mitigation:

Validate early (e.g., balance checks before loops).

Fail fast to minimize wasted computation.

5. Inefficient Vector Operations

Why It Happens: Loops over large vectors for simple checks or modifications.

Impact: Each iteration adds cost, scaling with data size.

Mitigation:

Avoid unbounded loops in on-chain logic.

Use indexing and constant-time operations where possible.

6. Redundant Checks On-Chain

Why It Happens: Adding multiple layers of validation that could be client-side.

Impact: Each check costs gas even if the condition is simple.

Mitigation:

Keep security-critical checks on-chain (ownership, permissions).

Move UX-related validations (limits, formatting) off-chain.

7. Excessive Event Emission

Why It Happens: Logging full transaction details for analytics.

Impact: Events add storage and increase gas costs.

Mitigation:

Emit minimal event data (e.g., IDs, amounts).

Push analytics off-chain.

8. Multiple Small Transactions Instead of Batching

Why It Happens: Sending sequential actions as separate transactions.

Impact: Each transaction incurs base gas cost.

Mitigation:

Use Transaction Blocks to batch related actions.

Reduce redundant object reads and writes across transactions.

9. Ignoring Dry Run Gas Estimation

Why It Happens: Developers skip simulating before submitting.

Impact: Failed transactions still consume gas.

Mitigation:

Use dryRunTransactionBlock to predict costs.

Adjust gas budget dynamically based on estimation.

10. Complex Object Serialization

Why It Happens: Designing deeply nested or large structs.

Impact: Serialization and deserialization costs scale with object complexity.

Mitigation:

Simplify struct design.

Avoid unnecessary nesting.