State Management

Managing blockchain state efficiently and securely.

Advanced⏱️ 50 min📚 Prerequisites: 1

State Management

State management is crucial for blockchain performance. The state represents the current snapshot of all accounts, balances, and contract data.

State Structure


RUST
struct BlockchainState {
    accounts: HashMap<String, Account>,
    contracts: HashMap<String, ContractState>,
    balances: HashMap<String, u64>,
    nonces: HashMap<String, u64>,
}

struct Account {
    address: String,
    balance: u64,
    nonce: u64,
    code: Option<Vec<u8>>,
}

State Updates

State changes when:

Transactions: Transfer funds, call contracts
Blocks: Apply all transactions in block
Reorganizations: Revert and reapply on fork

State Trie (Merkle Patricia Tree)

Ethereum uses a Merkle Patricia Tree:

Efficient: O(log n) lookups
Verifiable: Root hash proves state
Incremental: Only changed nodes updated

State Caching


RUST
struct StateCache {
    cache: HashMap<String, Account>,
    dirty: HashSet<String>,
}

impl StateCache {
    fn get_account(&mut self, address: &str) -> Option<&Account> {
        // Check cache first
        // If miss, load from storage
    }
    
    fn commit(&mut self) {
        // Write dirty accounts to storage
    }
}

State Snapshots

Checkpoints: Save state at certain heights
Rollback: Revert to previous state
Fork handling: Switch states on reorganization

Storage Backends

In-memory: Fast but limited size
Database: Persistent storage (RocksDB, etc.)
Hybrid: Hot data in memory, cold in DB

Gas Optimization

Minimize storage: Use storage efficiently
Batch updates: Group state changes
Cache reads: Avoid repeated storage access

Code Examples

State Structure

Basic blockchain state structure

RUST

use std::collections::HashMap;
struct Account {
    address: String,
    balance: u64,
    nonce: u64,
}
struct BlockchainState {
    accounts: HashMap<String, Account>,
}
impl BlockchainState {
    fn new() -> Self {
        BlockchainState {
            accounts: HashMap::new(),
        }
    }
    fn get_account(&self, address: &str) -> Option<&Account> {
        self.accounts.get(address)
    }
    fn create_account(&mut self, address: String, initial_balance: u64) {
        self.accounts.insert(address.clone(), Account {
            address,
            balance: initial_balance,
            nonce: 0,
        });
    }
    fn update_balance(&mut self, address: &str, new_balance: u64) -> Result<(), String> {
        if let Some(account) = self.accounts.get_mut(address) {
            account.balance = new_balance;
            Ok(())
        } else {
            Err(String::from("Account not found"))
        }
    }
}
fn main() {
    let mut state = BlockchainState::new();
    state.create_account(String::from("0xAlice"), 1000);
    state.update_balance("0xAlice", 1500).unwrap();
    if let Some(account) = state.get_account("0xAlice") {
        println!("Balance: {}", account.balance);
    }
}

Explanation:

Blockchain state maintains account information. It's updated when transactions are processed and must be efficiently stored and retrieved.

State Cache

Caching state for performance

RUST

use std::collections::{HashMap, HashSet};
struct Account {
    balance: u64,
}
struct StateCache {
    cache: HashMap<String, Account>,
    dirty: HashSet<String>,
}
impl StateCache {
    fn new() -> Self {
        StateCache {
            cache: HashMap::new(),
            dirty: HashSet::new(),
        }
    }
    fn get(&mut self, address: &str) -> Option<&Account> {
        self.cache.get(address)
    }
    fn set(&mut self, address: String, account: Account) {
        self.cache.insert(address.clone(), account);
        self.dirty.insert(address);
    }
    fn commit(&mut self) {
        println!("Committing {} dirty accounts", self.dirty.len());
        self.dirty.clear();
    }
}
fn main() {
    let mut cache = StateCache::new();
    cache.set(String::from("0xAlice"), Account { balance: 1000 });
    cache.set(String::from("0xBob"), Account { balance: 500 });
    cache.commit();
}

Explanation:

State caching improves performance by keeping frequently accessed data in memory. Dirty tracking ensures only changed data is written to storage.

Exercises

State Management

Create a state structure that manages accounts!

Medium

Starter Code:

RUST

use std::collections::HashMap;
struct Account {
    balance: u64,
}
struct State {
    accounts: HashMap<String, Account>,
}
fn main() {
    let mut state = State::new();
    state.add_account(String::from("Alice"), 1000);
    println!("Balance: {}", state.get_balance("Alice"));
}

Previous Lesson

← 45 network sync

Next Lesson

47 transaction pool →