Aritmética y Desbordamiento

Los programas en cadena utilizan enteros de tamaño fijo con aritmética de desbordamiento en operaciones no comprobadas. Los errores de desbordamiento y redondeo agotan las bóvedas, emiten acciones sin respaldo o bloquean cuentas permanentemente.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

let shares = deposit_amount
    .checked_mul(total_shares)
    .and_then(|v| v.checked_div(total_assets))
    .ok_or(ErrorCode::MathOverflow)?;
 
// Preferir intermediarios u128 para matemáticas de tokens
let out = (amount_in as u128)
    .checked_mul(reserve_out as u128)
    .and_then(|n| n.checked_div((reserve_in as u128) + (amount_in as u128)))
    .ok_or(ErrorCode::MathOverflow)? as u64;

Cuándo usar esto:

• Emisión/quema de acciones en bóvedas.
• Cálculos de swaps AMM dentro de programas.
• Acumulación de índices de interés en préstamos.
• Cualquier +, -, *, / en montos de tokens.

Ejemplo de Trabajo

use anchor_lang::prelude::*;
 
#[account]
pub struct Pool {
    pub total_assets: u64,
    pub total_shares: u64,
}
 
pub fn deposit(pool: &mut Pool, amount: u64) -> Result<u64> {
    let shares = if pool.total_shares == 0 {
        amount
    } else {
        (amount as u128)
            .checked_mul(pool.total_shares as u128)
            .and_then(|n| n.checked_div(pool.total_assets as u128))
            .ok_or(ErrorCode::MathOverflow)? as u64
    };
 
    pool.total_assets = pool
        .total_assets
        .checked_add(amount)
        .ok_or(ErrorCode::MathOverflow)?;
    pool.total_shares = pool
        .total_shares
        .checked_add(shares)
        .ok_or(ErrorCode::MathOverflow)?;
 
    Ok(shares)
}
 
#[error_code]
pub enum ErrorCode {
    MathOverflow,
}

Lo que esto demuestra:

• La división después de la multiplicación utiliza el margen de u128.
• El primer depositante emite 1:1 para evitar la división por cero.
• Las actualizaciones de estado utilizan checked_add para detectar desbordamientos.

Análisis Profundo

Cómo Funciona

• Las compilaciones BPF pueden no detenerse en desbordamientos para operadores simples en modo de lanzamiento.
• checked_* devuelve None en caso de desbordamiento - mapear a error del programa.
• La división trunca hacia cero - favorece al protocolo en la política de redondeo.
• Los cálculos de tarifas deben usar puntos base: amount * bps / 10_000.

Política de Redondeo

Notas de Rust

use anchor_lang::solana_program::native_token::LAMPORTS_PER_SOL;
 
const BPS: u128 = 10_000;
let fee = (amount as u128)
    .checked_mul(fee_bps as u128)
    .and_then(|v| v.checked_add(BPS - 1)) // truco de división ceil
    .and_then(|v| v.checked_div(BPS))
    .ok_or(ErrorCode::MathOverflow)? as u64;

Trampas

• + simple en saldos - Desbordamiento silencioso cerca de u64::MAX. Solución: checked_add en todas partes en los saldos de los usuarios.
• Dividir antes de multiplicar - Pierde precisión y permite ataques de polvo. Solución: Multiplicar primero en un tipo más amplio.
• Cero acciones totales - División por cero o ataque de inflación en el primer depósito. Solución: Bloqueo de liquidez mínima o desplazamiento virtual.
• El truncamiento de la conversión - u128 as u64 trunca silenciosamente. Solución: u64::try_from con verificación de rango.
• Confusión con signos - Uso de precios i64 sin límites. Solución: Documentar rangos; usar checked_* también en signos.
• Diferentes decimales de token - Mezcla de minutas con 6 y 9 decimales. Solución: Normalizar a precisión común antes de las matemáticas.

Alternativas

Preguntas Frecuentes

Relacionado

• Aritmética Segura - Patrones de Rust
• Ataques de Validación de Cuentas - exploits económicos
• Catálogo de Ataques de Sealevel - ataques de inflación
• Fuzzing de Programas - descubrimiento de casos límite

Versiones de la pila: Esta página fue escrita para Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0, y LiteSVM 0.6.x.