Performance Optimization

[profile.release]
opt-level = "z"          # Optimize for size
overflow-checks = true    # Keep overflow checks for safety
debug = 0                # Strip debug info
strip = "symbols"        # Strip symbols
debug-assertions = false # Disable debug assertions
panic = "abort"          # Use abort instead of unwind
codegen-units = 1        # Better optimization, slower compile
lto = true               # Enable Link Time Optimization

lto = true              # Full LTO
lto = "thin"           # Faster compilation, less optimization
lto = "fat"            # Same as true
lto = false            # Disable LTO

codegen-units = 1      # Best optimization (slowest compile)
codegen-units = 16     # Default (faster compile)

[profile.release-with-logs]
inherits = "release"
debug-assertions = true

cargo build --profile release-with-logs --target wasm32-unknown-unknown

[profile.release-without-lto]
inherits = "release"
lto = false

[profile.dev]
overflow-checks = true   # Catch overflow bugs early
panic = "abort"         # Consistent with release

// ❌ Bad: Multiple storage operations
pub fn update_balances(env: Env, users: Vec<Address>) {
    for user in users.iter() {
        let balance = get_balance(&env, &user);
        set_balance(&env, &user, balance + 100);
    }
}

// ✅ Good: Minimize storage calls
pub fn update_balances(env: Env, users: Vec<Address>) {
    let mut updates = vec![&env];
    
    for user in users.iter() {
        let balance = get_balance(&env, &user);
        updates.push_back((user.clone(), balance + 100));
    }
    
    for (user, balance) in updates.iter() {
        set_balance(&env, &user, balance);
    }
}

use soroban_sdk::{Bytes, BytesN};

// ❌ Less efficient for fixed size
pub fn store_hash(env: Env, hash: Bytes) {
    // Bytes has runtime length checks
}

// ✅ More efficient
pub fn store_hash(env: Env, hash: BytesN<32>) {
    // BytesN<32> is compile-time fixed size
}

use soroban_sdk::{symbol_short, Symbol};

// ✅ Efficient: Compiled to a constant
const KEY: Symbol = symbol_short!("balance");

// ❌ Less efficient: Runtime string conversion
let key = Symbol::new(&env, "balance");

// ❌ Unnecessary clones
pub fn process(env: Env, data: Bytes) -> Bytes {
    let copy1 = data.clone();
    let copy2 = data.clone();
    // Use copy1 and copy2
}

// ✅ Use references when possible
pub fn process(env: Env, data: Bytes) -> Bytes {
    let len = data.len();
    // Work with data directly
    data
}

// For small, frequently-called functions
#[inline(always)]
pub fn is_authorized(env: &Env, addr: &Address) -> bool {
    env.storage().instance().has(&addr)
}

// For larger functions that might benefit
#[inline]
pub fn validate_transfer(from: &Address, to: &Address, amount: i128) -> bool {
    amount > 0 && from != to
}

// ❌ Inefficient: Repeated function calls
for i in 0..vec.len() {
    let item = vec.get(i);
    process(item);
}

// ✅ Better: Iterator pattern
for item in vec.iter() {
    process(item);
}

// ✅ Even better: Early termination when possible
for item in vec.iter() {
    if !should_continue(&item) {
        break;
    }
    process(item);
}

// ❌ Large stack allocation
pub fn process_data(env: Env) {
    let large_array = [0u8; 10000];
    // ...
}

// ✅ Use Bytes for large data
pub fn process_data(env: Env) {
    let large_data = Bytes::new(&env);
    // ...
}

// ✅ Reuse vector capacity
pub fn batch_process(env: Env, iterations: u32) {
    let mut buffer = Vec::new(&env);
    
    for i in 0..iterations {
        buffer.clear();  // Reuse capacity
        // Fill buffer...
        process_buffer(&buffer);
    }
}

# ❌ Unnecessary dependencies increase size
[dependencies]
serde = { version = "1.0", features = ["derive"] }
regex = "1.5"

# ✅ Only include what you need
[dependencies]
soroban-sdk = "25.1.1"

#[cfg(feature = "testutils")]
pub mod testutils {
    // Test utilities not included in release
}

#[cfg(not(target_family = "wasm"))]
pub fn debug_helper() {
    // Only compiled for native, not WASM
}

// ❌ Creates multiple versions
pub fn process_value<T>(value: T) where T: IntoVal<Env, Val> {
    // ...
}

// ✅ Use concrete types when you know them
pub fn process_u64(value: u64) {
    // ...
}

pub fn process_address(value: Address) {
    // ...
}

use soroban_sdk::{contract, contractimpl};

#[contract]
pub struct MyContract;

#[contractimpl]
impl MyContract {
    // Macros generate optimized entry points
}

# Install wasm-opt
cargo install wasm-opt

# Optimize WASM file
wasm-opt -Oz \
  target/wasm32-unknown-unknown/release/contract.wasm \
  -o contract_optimized.wasm

soroban contract optimize \
  --wasm target/wasm32-unknown-unknown/release/contract.wasm

# Check WASM file size
ls -lh target/wasm32-unknown-unknown/release/*.wasm

# Detailed size analysis
wasm-objdump -h target/wasm32-unknown-unknown/release/contract.wasm

# Time the build
time cargo build --release --target wasm32-unknown-unknown

# Verbose build with timing
cargo build --release --target wasm32-unknown-unknown --timings

#[test]
fn test_resource_usage() {
    let env = Env::default();
    env.budget().reset_default();
    
    // Run contract function
    client.expensive_operation();
    
    // Check resource usage
    let cpu = env.budget().cpu_instruction_cost();
    let mem = env.budget().memory_bytes_cost();
    
    println!("CPU instructions: {}", cpu);
    println!("Memory bytes: {}", mem);
}

// Logging in production increases size
pub fn transfer(env: Env, from: Address, to: Address) {
    env.logs().log("Starting transfer");
    // ...
    env.logs().log("Transfer complete");
}

// Dead code increases binary size
pub fn unused_function() {
    // This gets compiled but never called
}

// Large match statements increase size
match value {
    1 => do_something_1(),
    2 => do_something_2(),
    // ... 100 more arms
    100 => do_something_100(),
    _ => default(),
}

// Consider a lookup table or different design