Gas System

pub struct GasCosts;

impl GasCosts {
    // Tier 1: Very cheap (simple register operations)
    pub const ZERO: u64 = 0;      // HALT, NOP
    pub const BASE: u64 = 2;      // ADD, SUB, AND, OR, MOV

    // Tier 2: Cheap (more complex ALU operations)
    pub const LOW: u64 = 3;       // MUL, comparison ops

    // Tier 3: Medium (division, shifts)
    pub const MID: u64 = 5;       // DIV, MOD, SHL, SHR

    // Tier 4: Memory operations
    pub const MEMORY_READ: u64 = 3;
    pub const MEMORY_WRITE: u64 = 3;
    pub const MEMORY_GROW_PER_BYTE: u64 = 1;

    // Tier 5: Storage (expensive!)
    pub const SLOAD: u64 = 100;           // Read from storage
    pub const SSTORE_SET: u64 = 20000;    // Write to empty slot
    pub const SSTORE_RESET: u64 = 5000;   // Overwrite existing slot

    // Control flow
    pub const JUMP: u64 = 8;
    pub const CALL: u64 = 700;
}

pub struct GasMeter {
    remaining: u64,
    used: u64,
}

impl GasMeter {
    pub fn new(limit: u64) -> Self {
        Self {
            remaining: limit,
            used: 0,
        }
    }

    /// Consume gas, returning error if insufficient.
    pub fn consume(&mut self, amount: u64) -> Result<(), VmError> {
        if self.remaining < amount {
            return Err(VmError::OutOfGas {
                required: amount,
                remaining: self.remaining,
            });
        }
        self.remaining -= amount;
        self.used += amount;
        Ok(())
    }

    pub fn remaining(&self) -> u64 {
        self.remaining
    }

    pub fn used(&self) -> u64 {
        self.used
    }
}

// 1. Decode opcode
let opcode = Opcode::from_byte(bytecode[pc])?;

// 2. Consume gas BEFORE execution
let cost = match opcode {
    Opcode::ADD => GasCosts::BASE,
    Opcode::MUL => GasCosts::LOW,
    Opcode::DIV => GasCosts::MID,
    Opcode::SLOAD => GasCosts::SLOAD,
    Opcode::SSTORE => {
        // Dynamic cost based on storage state
        if storage_slot_is_empty {
            GasCosts::SSTORE_SET
        } else {
            GasCosts::SSTORE_RESET
        }
    }
    _ => GasCosts::BASE,
};
gas_meter.consume(cost)?;

// 3. Execute operation
execute_opcode(opcode)?;

// 4. Move to next instruction
pc += opcode.instruction_size();

#[derive(Error, Debug, Clone, PartialEq, Eq)]
pub enum VmError {
    #[error("Out of gas: required {required}, remaining {remaining}")]
    OutOfGas { required: u64, remaining: u64 },
    // ... other errors
}

// Example:
// Trying to execute SLOAD (cost: 100) with only 50 gas remaining
// Error: Out of gas: required 100, remaining 50

pub struct Transaction {
    // ... other fields
    /// Maximum gas to use.
    pub gas_limit: u64,
    /// Price per unit of gas.
    pub gas_price: u64,
    // ...
}

impl Transaction {
    /// Calculate the maximum cost of this transaction.
    pub fn max_cost(&self) -> u64 {
        self.value
            .saturating_add(self.gas_limit.saturating_mul(self.gas_price))
    }
}

// Example:
// value = 1000
// gas_limit = 50000
// gas_price = 2
// max_cost = 1000 + (50000 * 2) = 101,000

// Sender must have enough for value + max gas cost
let max_cost = tx.max_cost();
if account.balance < max_cost {
    return Err(ValidationError::InsufficientBalance {
        required: max_cost,
        available: account.balance,
    });
}

// 1. Deduct max gas cost upfront
let max_gas_cost = tx.gas_limit * tx.gas_price;
account.debit(tx.value + max_gas_cost)?;

// 2. Execute transaction
let result = vm.execute(bytecode, tx.gas_limit)?;

// 3. Refund unused gas
let gas_used = result.gas_used;
let gas_refund = (tx.gas_limit - gas_used) * tx.gas_price;
account.credit(gas_refund);

// 4. Charge only for gas actually used
let actual_cost = tx.value + (gas_used * tx.gas_price);

// Base cost for a transfer transaction
const BASE_TX_GAS: u64 = 21_000;

let tx = Transaction::transfer(
    from,
    to,
    amount,
    nonce,
    gas_price,
);

assert_eq!(tx.gas_limit, 21_000);

const DEPLOYMENT_GAS_PER_BYTE: u64 = 200;

// Calculate deployment cost
let bytecode_size = bytecode.len() as u64;
let deployment_gas = bytecode_size * DEPLOYMENT_GAS_PER_BYTE;
let total_gas = BASE_TX_GAS + deployment_gas;

// Example: 100-byte contract
// total_gas = 21,000 + (100 * 200) = 41,000

const BASE_CALL_GAS: u64 = 21_000;

// Total cost = base + execution
let total_gas = BASE_CALL_GAS + execution_gas;

impl GasMeter {
    /// Calculate gas for memory expansion.
    pub fn memory_expansion_cost(current_size: usize, new_size: usize) -> u64 {
        if new_size <= current_size {
            return 0;
        }
        let expansion = (new_size - current_size) as u64;
        expansion * GasCosts::MEMORY_GROW_PER_BYTE
    }
}

// Example: Growing memory from 1024 to 2048 bytes
let expansion_cost = GasMeter::memory_expansion_cost(1024, 2048);
// expansion_cost = (2048 - 1024) * 1 = 1024 gas

.entry main

main:
    LOADI R0, 0          ; Load slot 0          - 2 gas
    SLOAD R1, R0         ; Read counter         - 100 gas
    LOADI R2, 1          ; Load constant 1      - 2 gas
    ADD R1, R1, R2       ; Increment            - 2 gas
    SSTORE R0, R1        ; Save counter         - 5,000 gas (update)
    HALT                 ; Stop                 - 0 gas

; Total execution: ~5,106 gas
; Plus base transaction cost: 21,000 gas
; Total: ~26,106 gas

// Estimate gas for contract call
let estimated_gas = 30_000;

// Add 20% buffer for safety
let gas_limit = (estimated_gas as f64 * 1.2) as u64;

// Create transaction
let tx = Transaction::call(
    from,
    contract,
    calldata,
    0,
    nonce,
    gas_limit,  // 36,000
    gas_price,
);

// If actual usage is 28,000:
// - Gas used: 28,000
// - Gas refunded: 36,000 - 28,000 = 8,000
// - Final cost: 28,000 * gas_price

// Enable tracing
let mut vm = Vm::new_with_context(
    bytecode,
    gas_limit,
    caller,
    address,
    value,
    block_number,
    timestamp,
);

let tracer = Tracer::new();
vm.set_tracer(Some(tracer));

// Execute
let result = vm.execute()?;

// Analyze trace
let trace = vm.get_tracer().unwrap();
for step in trace.steps() {
    println!(
        "PC: {:4} | Opcode: {:?} | Gas: {} | Remaining: {}",
        step.pc,
        step.opcode,
        step.gas_cost,
        step.gas_remaining,
    );
}

println!("Total gas used: {}", result.gas_used);