Description

Rounding errors in financial calculations can lead to significant vulnerabilities in Solana programs. Different rounding directions (up vs down) must be carefully chosen based on the context to prevent value extraction attacks. Common issues include: always rounding in the user's favor allowing dust accumulation attacks, inconsistent rounding between deposit/withdrawal operations, precision loss in integer division, and incorrect decimal scaling. These bugs are often subtle but can be systematically exploited to drain funds from protocols, especially in high-frequency operations like swaps, lending, or staking rewards.

Impact

Dust Accumulation Attacks: Attackers can repeatedly extract small amounts through rounding errors.
Exchange Rate Manipulation: Incorrect rounding in share calculations can dilute other users' positions.
Arbitrage Exploitation: Rounding inconsistencies create risk-free profit opportunities.
Protocol Insolvency: Accumulated rounding errors can make protocols technically insolvent.
Unfair Value Distribution: Users may receive more or less than their fair share due to rounding.

Example

Vulnerable rounding implementation

// ❌ Vulnerable: Always rounds in user's favor
pub fn withdraw_shares(ctx: Context<Withdraw>, shares: u64) -> Result<()> {
    let vault = &mut ctx.accounts.vault;
    let total_assets = vault.total_assets;
    let total_shares = vault.total_shares;
    
    // WRONG: Division truncates, but we're giving user the truncated amount + 1
    let assets_to_withdraw = (shares * total_assets / total_shares) + 1;
    
    // User can repeatedly withdraw 1 share and get extra tokens
    transfer_tokens(
        &ctx.accounts.vault_token_account,
        &ctx.accounts.user_token_account,
        assets_to_withdraw,
    )?;
    
    vault.total_shares -= shares;
    vault.total_assets -= assets_to_withdraw; // Vault slowly drains!
    
    Ok(())
}

// ❌ Vulnerable: Inconsistent rounding between deposit and withdraw
pub fn calculate_shares_unsafe(amount: u64, total_assets: u64, total_shares: u64) -> u64 {
    if total_shares == 0 {
        amount
    } else {
        // Simple division - truncates unpredictably
        amount * total_shares / total_assets
    }
}

Safe rounding implementation with proper direction

// ✅ Safe: Explicit rounding direction based on operation
use uint::construct_uint;

construct_uint! {
    pub struct U256(4);
}

/// Round down when calculating shares to mint (conservative for protocol)
pub fn calculate_shares_to_mint(
    assets: u64,
    total_assets: u64,
    total_shares: u64,
) -> Result<u64> {
    if total_shares == 0 || total_assets == 0 {
        return Ok(assets);
    }
    
    // Use higher precision to avoid intermediate overflow
    let assets_u256 = U256::from(assets);
    let total_shares_u256 = U256::from(total_shares);
    let total_assets_u256 = U256::from(total_assets);
    
    // Round DOWN when minting shares (conservative)
    let shares_u256 = assets_u256
        .checked_mul(total_shares_u256)
        .ok_or(ErrorCode::MathOverflow)?
        .checked_div(total_assets_u256)
        .ok_or(ErrorCode::DivisionByZero)?;
    
    // Ensure result fits in u64
    u64::try_from(shares_u256).map_err(|_| ErrorCode::MathOverflow.into())
}

/// Round up when calculating assets to withdraw (conservative for protocol)
pub fn calculate_assets_to_withdraw(
    shares: u64,
    total_assets: u64,
    total_shares: u64,
) -> Result<u64> {
    require!(total_shares > 0, ErrorCode::NoSharesExist);
    
    let shares_u256 = U256::from(shares);
    let total_assets_u256 = U256::from(total_assets);
    let total_shares_u256 = U256::from(total_shares);
    
    // Calculate with rounding UP
    let assets_u256 = shares_u256
        .checked_mul(total_assets_u256)
        .ok_or(ErrorCode::MathOverflow)?
        .checked_add(total_shares_u256 - 1)  // Add (divisor - 1) to round up
        .ok_or(ErrorCode::MathOverflow)?
        .checked_div(total_shares_u256)
        .ok_or(ErrorCode::DivisionByZero)?;
    
    u64::try_from(assets_u256).map_err(|_| ErrorCode::MathOverflow.into())
}

// ✅ Safe: Consistent rounding with slippage protection
pub fn swap_exact_in(
    ctx: Context<Swap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    let pool = &mut ctx.accounts.pool;
    
    // Calculate output amount (round DOWN in user's favor here is OK because of slippage check)
    let amount_out = calculate_swap_output(
        amount_in,
        pool.reserve_in,
        pool.reserve_out,
        pool.fee_basis_points,
    )?;
    
    // Slippage protection prevents exploitation
    require!(
        amount_out >= minimum_amount_out,
        ErrorCode::SlippageExceeded
    );
    
    // Calculate fee (round UP to ensure protocol receives full fee)
    let fee = amount_in
        .checked_mul(pool.fee_basis_points as u64)
        .ok_or(ErrorCode::MathOverflow)?
        .checked_add(9999)  // Round up by adding (10000 - 1)
        .ok_or(ErrorCode::MathOverflow)?
        .checked_div(10000)
        .ok_or(ErrorCode::MathOverflow)?;
    
    Ok(())
}

// Utility functions for safe rounding
pub mod rounding {
    /// Multiply then divide with rounding down
    pub fn mul_div_down(a: u64, b: u64, denominator: u64) -> Result<u64> {
        let result = (a as u128)
            .checked_mul(b as u128)
            .ok_or(ErrorCode::MathOverflow)?
            .checked_div(denominator as u128)
            .ok_or(ErrorCode::DivisionByZero)?;
        
        u64::try_from(result).map_err(|_| ErrorCode::MathOverflow.into())
    }
    
    /// Multiply then divide with rounding up
    pub fn mul_div_up(a: u64, b: u64, denominator: u64) -> Result<u64> {
        let numerator = (a as u128)
            .checked_mul(b as u128)
            .ok_or(ErrorCode::MathOverflow)?;
        
        let result = numerator
            .checked_add(denominator as u128 - 1)
            .ok_or(ErrorCode::MathOverflow)?
            .checked_div(denominator as u128)
            .ok_or(ErrorCode::DivisionByZero)?;
        
        u64::try_from(result).map_err(|_| ErrorCode::MathOverflow.into())
    }
}

Recommendation

Explicit Rounding Direction: Always be explicit about rounding direction:

// Document rounding behavior
/// Calculates shares to mint. Rounds DOWN to protect protocol.
pub fn shares_to_mint() -> u64 { ... }

/// Calculates assets to withdraw. Rounds UP to protect protocol.
pub fn assets_to_withdraw() -> u64 { ... }

Consistent Rounding Rules:
- When minting shares: Round DOWN (user gets fewer shares)
- When burning shares: Round UP (user pays more shares)
- When collecting fees: Round UP (protocol gets more)
- When distributing rewards: Round DOWN (conservative distribution)

Use Higher Precision: Perform intermediate calculations in higher precision:

// Use u128 or U256 for intermediate calculations
let precise_result = (amount as u128) * (rate as u128) / (PRECISION as u128);

Decimal Libraries: Consider using fixed-point decimal libraries:

use decimal::Decimal;
let amount = Decimal::from_u64(1000);
let rate = Decimal::from_str("1.05")?;

Invariant Checks: Add checks to ensure rounding doesn't break invariants:

// After any operation involving rounding
assert!(pool.k_constant <= calculate_k(&pool));

Dust Thresholds: Implement minimum amounts to prevent dust attacks:

const DUST_THRESHOLD: u64 = 1000; // Minimum meaningful amount
require!(amount >= DUST_THRESHOLD, ErrorCode::AmountTooSmall);

Response incompletely copy (remained)

## Tags

math
rounding
precision
decimal
overflow
defi
exchange
calculation

Response completely copy

# Avoid reusing addresses in Lookup Tables

Description

Address Lookup Tables (ALTs) should maintain unique addresses to prevent account confusion and ensure predictable transaction behavior. When the same address appears multiple times in an ALT, it creates ambiguity about which index refers to which account instance, potentially leading to incorrect account references, wasted space, and security vulnerabilities. Attackers can exploit duplicate addresses to manipulate transaction logic by controlling which index gets resolved to their malicious account.

Impact

Account Confusion: Multiple indices pointing to the same address can cause programs to reference unintended account instances.
Index Manipulation: Attackers can exploit duplicate addresses to redirect account references to malicious accounts.
Wasted Resources: Duplicate addresses consume unnecessary ALT space, reducing efficiency and increasing costs.
Logic Errors: Programs may make incorrect assumptions about account uniqueness, leading to flawed business logic.

Example

Vulnerable ALT with duplicate addresses

use anchor_lang::prelude::*;

#[derive(Accounts)]
pub struct VulnerableDuplicateAlt<'info> {
    pub user: Signer<'info>,
    /// CHECK: Could be duplicate address at different ALT indices
    pub account_a: UncheckedAccount<'info>, // ALT index 0
    /// CHECK: Could be duplicate address at different ALT indices  
    pub account_b: UncheckedAccount<'info>, // ALT index 1
    /// CHECK: Could be duplicate address at different ALT indices
    pub account_c: UncheckedAccount<'info>, // ALT index 2
}

pub fn vulnerable_multi_operation(ctx: Context<VulnerableDuplicateAlt>) -> Result<()> {
    let account_a = &ctx.accounts.account_a;
    let account_b = &ctx.accounts.account_b;
    let account_c = &ctx.accounts.account_c;
    
    // ❌ Dangerous assumption: accounts are different
    // If ALT has duplicates, these could all be the same account!
    msg!("Processing three different accounts:");
    msg!("Account A: {}", account_a.key());
    msg!("Account B: {}", account_b.key());
    msg!("Account C: {}", account_c.key());
    
    // ❌ Logic assumes accounts are unique
    // Could double-process the same account if duplicates exist
    if account_a.key() != account_b.key() {
        // This check might fail if ALT has duplicates
        // Process accounts...
    }
    
    Ok(())
}

Client-side: Creating ALT with duplicate addresses

// ❌ Vulnerable ALT creation with duplicates
async function createVulnerableAlt() {
    const accounts = [
        tokenAccount1,
        tokenAccount2,
        tokenAccount1, // ❌ Duplicate!
        destinationAccount,
        tokenAccount2, // ❌ Another duplicate!
    ];
    
    // This creates an ALT with duplicate addresses
    const [createAltIx, altAddress] = AddressLookupTableProgram.createLookupTable({
        authority: authority.publicKey,
        payer: payer.publicKey,
        recentSlot: await connection.getSlot() - 1,
    });
    
    const addAccountsIx = AddressLookupTableProgram.extendLookupTable({
        lookupTable: altAddress,
        authority: authority.publicKey,
        payer: payer.publicKey,
        addresses: accounts, // ❌ Contains duplicates
    });
    
    // This will succeed but create a problematic ALT
    return altAddress;
}

Recommendation

Validate Account Uniqueness in Program: Always check that accounts are unique when business logic requires it:

#[derive(Accounts)]
pub struct SecureUniqueAccounts<'info> {
    pub user: Signer<'info>,
    /// CHECK: We validate uniqueness
    pub account_a: UncheckedAccount<'info>,
    /// CHECK: We validate uniqueness
    pub account_b: UncheckedAccount<'info>,
    /// CHECK: We validate uniqueness
    pub account_c: UncheckedAccount<'info>,
}

pub fn secure_multi_operation(ctx: Context<SecureUniqueAccounts>) -> Result<()> {
    let account_a = &ctx.accounts.account_a;
    let account_b = &ctx.accounts.account_b;
    let account_c = &ctx.accounts.account_c;
    
    // ✅ Explicitly validate account uniqueness
    require_neq!(
        account_a.key(),
        account_b.key(),
        ErrorCode::DuplicateAccount
    );
    
    require_neq!(
        account_a.key(),
        account_c.key(),
        ErrorCode::DuplicateAccount
    );
    
    require_neq!(
        account_b.key(),
        account_c.key(),
        ErrorCode::DuplicateAccount
    );
    
    // ✅ Safe to process knowing accounts are unique
    msg!("Processing three unique accounts:");
    msg!("Account A: {}", account_a.key());
    msg!("Account B: {}", account_b.key());
    msg!("Account C: {}", account_c.key());
    
    // Business logic that requires unique accounts
    Ok(())
}

Implement Duplicate Detection in ALT Creation: Create utilities to ensure ALT uniqueness:

// ✅ Secure ALT creation with duplicate detection
class SecureAltBuilder {
    private connection: Connection;
    private authority: Keypair;
    
    async createUniqueAlt(accounts: PublicKey[]): Promise<PublicKey> {
        // ✅ Remove duplicates before creating ALT
        const uniqueAccounts = this.removeDuplicates(accounts);
        
        if (uniqueAccounts.length !== accounts.length) {
            console.warn(`Removed ${accounts.length - uniqueAccounts.length} duplicate addresses`);
        }
        
        // ✅ Validate we have meaningful number of accounts
        if (uniqueAccounts.length === 0) {
            throw new Error('No unique accounts provided for ALT');
        }
        
        const [createAltIx, altAddress] = AddressLookupTableProgram.createLookupTable({
            authority: this.authority.publicKey,
            payer: this.authority.publicKey,
            recentSlot: await this.connection.getSlot() - 1,
        });
        
        const addAccountsIx = AddressLookupTableProgram.extendLookupTable({
            lookupTable: altAddress,
            authority: this.authority.publicKey,
            payer: this.authority.publicKey,
            addresses: uniqueAccounts, // ✅ Only unique addresses
        });
        
        const transaction = new Transaction()
            .add(createAltIx)
            .add(addAccountsIx);
            
        await this.connection.sendTransaction(transaction, [this.authority]);
        
        return altAddress;
    }
    
    private removeDuplicates(accounts: PublicKey[]): PublicKey[] {
        const seen = new Set<string>();
        const unique: PublicKey[] = [];
        
        for (const account of accounts) {
            const key = account.toBase58();
            if (!seen.has(key)) {
                seen.add(key);
                unique.push(account);
            }
        }
        
        return unique;
    }
    
    // ✅ Validate existing ALT for duplicates
    async validateAltUniqueness(altAddress: PublicKey): Promise<boolean> {
        const altAccount = await this.connection.getAddressLookupTable(altAddress);
        
        if (!altAccount.value) {
            throw new Error('ALT not found');
        }
        
        const addresses = altAccount.value.state.addresses;
        const uniqueAddresses = this.removeDuplicates(addresses);
        
        const hasDuplicates = addresses.length !== uniqueAddresses.length;
        
        if (hasDuplicates) {
            console.warn(`ALT ${altAddress.toBase58()} contains duplicate addresses`);
            return false;
        }
        
        return true;
    }
}

Use Maps for Account Index Management: Track account-to-index mappings to avoid duplicates:

// ✅ Smart ALT management with index tracking
class AltIndexManager {
    private accountToIndex = new Map<string, number>();
    private indexToAccount = new Map<number, PublicKey>();
    private nextIndex = 0;
    
    addAccount(account: PublicKey): number {
        const accountKey = account.toBase58();
        
        // ✅ Return existing index if account already added
        if (this.accountToIndex.has(accountKey)) {
            return this.accountToIndex.get(accountKey)!;
        }
        
        // ✅ Add new unique account
        const index = this.nextIndex++;
        this.accountToIndex.set(accountKey, index);
        this.indexToAccount.set(index, account);
        
        return index;
    }
    
    getAccountIndex(account: PublicKey): number | undefined {
        return this.accountToIndex.get(account.toBase58());
    }
    
    getAccountAtIndex(index: number): PublicKey | undefined {
        return this.indexToAccount.get(index);
    }
    
    getAllUniqueAccounts(): PublicKey[] {
        return Array.from(this.indexToAccount.values());
    }
    
    // ✅ Build transaction with guaranteed unique accounts
    buildTransactionWithUniqueAccounts(
        instructions: TransactionInstruction[],
        requiredAccounts: PublicKey[]
    ): { accounts: PublicKey[], indexMap: Map<string, number> } {
        // Add all required accounts (duplicates automatically handled)
        for (const account of requiredAccounts) {
            this.addAccount(account);
        }
        
        return {
            accounts: this.getAllUniqueAccounts(),
            indexMap: new Map(this.accountToIndex)
        };
    }
}

Implement ALT Validation Utilities: Create tools to audit existing ALTs:

// ✅ ALT auditing utilities
class AltAuditor {
    static async auditAlt(
        connection: Connection,
        altAddress: PublicKey
    ): Promise<AltAuditResult> {
        const altAccount = await connection.getAddressLookupTable(altAddress);
        
        if (!altAccount.value) {
            throw new Error('ALT not found');
        }
        
        const addresses = altAccount.value.state.addresses;
        const duplicates = this.findDuplicates(addresses);
        const utilization = addresses.length / 256; // ALT max capacity
        
        return {
            totalAddresses: addresses.length,
            uniqueAddresses: addresses.length - duplicates.length,
            duplicates,
            utilization,
            isOptimal: duplicates.length === 0,
            recommendations: this.generateRecommendations(duplicates, utilization)
        };
    }
    
    private static findDuplicates(addresses: PublicKey[]): DuplicateInfo[] {
        const seen = new Map<string, number[]>();
        
        addresses.forEach((address, index) => {
            const key = address.toBase58();
            if (!seen.has(key)) {
                seen.set(key, []);
            }
            seen.get(key)!.push(index);
        });
        
        const duplicates: DuplicateInfo[] = [];
        for (const [address, indices] of seen.entries()) {
            if (indices.length > 1) {
                duplicates.push({
                    address: new PublicKey(address),
                    indices,
                    count: indices.length
                });
            }
        }
        
        return duplicates;
    }
    
    private static generateRecommendations(
        duplicates: DuplicateInfo[],
        utilization: number
    ): string[] {
        const recommendations: string[] = [];
        
        if (duplicates.length > 0) {
            recommendations.push(
                `Remove ${duplicates.length} duplicate addresses to save space`
            );
        }
        
        if (utilization > 0.9) {
            recommendations.push('ALT is near capacity, consider creating additional ALTs');
        }
        
        if (duplicates.length === 0 && utilization < 0.5) {
            recommendations.push('ALT is well-optimized');
        }
        
        return recommendations;
    }
}

interface AltAuditResult {
    totalAddresses: number;
    uniqueAddresses: number;
    duplicates: DuplicateInfo[];
    utilization: number;
    isOptimal: boolean;
    recommendations: string[];
}

interface DuplicateInfo {
    address: PublicKey;
    indices: number[];
    count: number;
}

Copy Button Fails to Copy Long AI Responses #202

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions