eric861129/aptos-gas-optimization

Aptos Gas & Performance Optimization Expert

Expert on optimizing gas costs and performance for Aptos Move smart contracts.

Triggers

• gas optimization, gas cost, gas fees
• performance tuning, execution efficiency
• storage fees, storage optimization
• inline functions, aggregator
• parallel execution, throughput
• Table vs vector, SmartTable
• gas profiling, benchmarking

Gas Model Overview

Total Gas Cost = Execution Gas + Storage Gas + IO Gas

Gas Fee (APT) = Gas Units x Gas Unit Price
1 APT = 100,000,000 octas

Data Structure Costs

| Structure | Read | Write | Best For | |-----------|------|-------|----------| | vector | O(n) | O(n) | Small lists (<1000) | | SimpleMap | O(n) | O(n) | Small maps (<1000) | | Table | O(1) | O(1) | Large maps | | SmartTable | O(1) | O(1) | Very large maps (100k+) | | Aggregator | O(1) | O(1) | Parallel counters |

Key Optimizations

1. Use Aggregators for Global Counters

use aptos_framework::aggregator_v2::{Self, Aggregator};

struct Stats has key {
    total_users: Aggregator<u64>  // Concurrent-safe!
}

public fun increment() acquires Stats {
    let stats = borrow_global_mut<Stats>(@protocol);
    aggregator_v2::add(&mut stats.total_users, 1);
    // Multiple txns can do this in parallel!
}

2. Inline Small Functions

inline fun min(a: u64, b: u64): u64 {
    if (a < b) a else b
}

3. Cache Loop Lengths

// Bad: calls length() every iteration
while (i < vector::length(v)) { ... }

// Good: cache length
let len = vector::length(v);
while (i < len) { ... }

4. Use Event V2 (Cheaper)

#[event]
struct TransferEvent has drop, store {
    from: address,
    to: address,
    amount: u64,
}

event::emit(TransferEvent { from, to, amount });

5. Pack Struct Fields

// Bad: 8 bytes wasted on padding
struct Data { flag1: bool, value1: u64, flag2: bool, value2: u64 }

// Good: group bools together
struct Data { flag1: bool, flag2: bool, value1: u64, value2: u64 }

// Best: pack into bitmap
struct Data { flags: u8, value1: u64, value2: u64 }

6. Use Table/SmartTable for Large Data

// Bad for large datasets
struct Registry { users: vector<User> }

// Good for large datasets
struct Registry { users: Table<address, User> }

// Best for very large datasets (100k+)
struct Registry { users: SmartTable<address, User> }

7. Batch Operations

// Single transaction for multiple transfers
public entry fun batch_transfer(
    sender: &signer,
    recipients: vector<address>,
    amounts: vector<u64>
) { ... }

8. Early Returns

// Check cheapest conditions first
if (amount == 0) return;
if (amount >= MAX) return;
if (!is_valid(user)) return;
// Then do expensive work

Gas Profiling

# Run tests with gas profiling
aptos move test --gas

# Simulate transaction
aptos move run --function-id 0x1::module::func --profile gas

Checklist Before Mainnet

• [ ] Use aggregators for global counters
• [ ] Inline small helper functions
• [ ] Use Event V2 for all events
• [ ] Use Table/SmartTable for large datasets
• [ ] Pack struct fields efficiently
• [ ] Cache loop lengths
• [ ] Batch operations where possible
• [ ] Early returns for validation
• [ ] Profile with --gas flag