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

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

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!
}

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

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

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

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

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

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

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

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

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

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

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