analyze-gas-optimization

Skill: analyze-gas-optimization

Analyze and optimize Aptos Move contracts for gas efficiency, identifying expensive operations and suggesting optimizations.

When to Use This Skill

Trigger phrases:

• "optimize gas", "reduce gas costs", "gas analysis"
• "make contract cheaper", "gas efficiency"
• "analyze gas usage", "gas optimization"
• "reduce transaction costs"

Use cases:

• Before mainnet deployment
• When transaction costs are high
• When optimizing for high-frequency operations
• When building DeFi protocols with many transactions

Core Gas Optimization Principles

1. Storage Optimization

• Minimize stored data size
• Use efficient data structures
• Pack struct fields efficiently
• Remove unnecessary fields

2. Computation Optimization

• Avoid loops over large collections
• Cache repeated calculations
• Use bitwise operations when possible
• Minimize vector operations

3. Reference Optimization

• Prefer borrowing over moving when possible
• Use & and &mut efficiently
• Avoid unnecessary copies

Gas Cost Analysis

Expensive Operations

1. Global Storage Operations

// EXPENSIVE: Writing to global storage
move_to(account, large_struct);

// EXPENSIVE: Reading and writing
let data = borrow_global_mut<LargeData>(addr);

// EXPENSIVE: Checking existence
if (exists<Resource>(addr)) { ... }

2. Vector Operations

// EXPENSIVE: Growing vectors dynamically
vector::push_back(&mut vec, item); // O(n) worst case

// EXPENSIVE: Searching vectors
vector::contains(&vec, &item); // O(n)

// EXPENSIVE: Removing from middle
vector::remove(&mut vec, index); // O(n)

3. String Operations

// EXPENSIVE: String concatenation
string::append(&mut s1, s2);

// EXPENSIVE: UTF8 validation
string::utf8(bytes);

Optimization Patterns

1. Batch Operations

// BAD: Multiple storage accesses
public fun update_values(account: &signer, updates: vector<Update>) {
    let i = 0;
    while (i < vector::length(&updates)) {
        let update = vector::borrow(&updates, i);
        let data = borrow_global_mut<Data>(update.address);
        data.value = update.value;
        i = i + 1;
    }
}

// GOOD: Single storage access with batch update
public fun batch_update(account: &signer, updates: vector<Update>) {
    let data = borrow_global_mut<Data>(signer::address_of(account));
    let i = 0;
    while (i < vector::length(&updates)) {
        let update = vector::borrow(&updates, i);
        // Update in memory
        update_memory_data(data, update);
        i = i + 1;
    }
}