Built-In Adaptors by Voltr

The Voltr protocol includes four built-in adaptors (Kamino, Marginfi, Drift, Solend). Each adaptor implements standardized interfaces while handling protocol-specific logic and state management.

Core Interfaces

Each built-in adaptor implements three core instructions:

pub fn initialize(ctx: Context<Initialize>) -> Result<()>;
pub fn deposit(ctx: Context<Deposit>, amount: u64) -> Result<()>;
pub fn withdraw(ctx: Context<Withdraw>, amount: u64) -> Result<()>;

Key Features

• Lending market interactions

• Collateral management

• Position tracking

Account Structures

1. Strategy Account

pub struct Strategy {
    pub counterparty_asset_ta: Pubkey,    // Protocol token account
    pub protocol_program: Pubkey,         // Protocol program ID
    pub strategy_type: StrategyType,      // Type of strategy
}

2. Vault Strategy Account

pub struct VaultStrategy {
    pub vault_asset_idle_auth: Pubkey,   // Vault authority
    pub strategy: Pubkey,                // Strategy account
    pub current_amount: u64,             // Current balance
}

Error Handling

pub enum AdaptorError {
    InvalidAmount,
    InvalidAccountOwner,
    InvalidTokenMint,
    InvalidAccountInput,
    MathOverflow,
    KaminoDepositFailed,
    MarginfiInitializeFailed,
    SolendInitializeFailed,
    InvalidRemainingAccounts,
}

Security Considerations

1. Account Validation

• Verify program IDs for each protocol

• Validate account ownership

• Check account relationships

• Confirm authority permissions

2. Position Management

• Handle math overflow in calculations

• Verify exchange rates

• Validate deposit/withdrawal amounts

• Track protocol-specific limits

3. State Updates

• Refresh protocol state before operations

• Update positions after operations

• Verify state changes

• Handle failed transactions

Math Operations

1. Exchange Rate Calculations

// Example from Kamino adaptor
let exchange_rate: U68F60 = U68F60::from(mint_total_supply) / total_liquidity;
let liquidity_amount: U68F60 = U68F60::from(collateral_amount) / exchange_rate;

2. Position Calculations

// Example from Drift adaptor
let scaled_balance: u128 = position.scaled_balance.into();
let token_amount = scaled_balance
    .checked_mul(cumulative_deposit_interest)?
    .checked_div(precision_decrease)?;

Best Practices

1. State Management

• Always refresh protocol state before operations

• Verify calculations with protocol state

• Update strategy state after operations

• Handle partial operations

2. Error Handling

• Implement comprehensive error types

• Handle protocol-specific errors

• Provide clear error messages

• Include error context

3. Balance Tracking

• Maintain accurate position tracking

• Handle decimal conversions

• Verify balance updates

• Track cumulative amounts

Performance Considerations

1. Account Loading

   • Cache loaded accounts

   • Minimize redundant loads

   • Batch state updates

2. CPI Calls

   • Optimize remaining accounts

   • Minimize transaction size

   • Handle CPI restrictions

3. Calculations

   • Use efficient math operations

   • Handle precision correctly

   • Minimize redundant calculations

For detailed protocol specifications and implementation details, refer to each protocol's documentation.