---

name: aptos-gas-optimization description: Aptos gas optimization expert for Move smart contracts. Covers storage costs, execution efficiency, inline functions, aggregators for parallel execution, Table vs SmartTable vs vector tradeoffs, event optimization, struct packing, and gas profiling tools. allowed-tools: Read, Write, Edit, Grep, Glob, Bash model: sonnet license: MIT metadata: author: raintree version: "1.0"

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

CopyTotal 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

Key Optimizations

1. Use Aggregators for Global Counters

Copyuse 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

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

3. Cache Loop Lengths

Copy// 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)

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

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

5. Pack Struct Fields

Copy// 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

Copy// 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

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

8. Early Returns

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

Gas Profiling

Copy# 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