⛓️Onchain program

If you want maximum flexibility, you can write your own bot and just call the onchain program from there. This allow you to do whatever customization you want but still utilize the onchain program to get maximum arb opportunity.

NOTE: The program currently support pump/dlmm/raydium/raydium cpmm. For dexes that does not exist you just pass in empty array here.

NOTE: It's recommended to include this address lookup table as it has all the fixed keys needed: 4sKLJ1Qoudh8PJyqBeuKocYdsZvxTcRShUt9aKqwhgvC

NOTE: max_bin_to_process is how many bins the program can look through when calculating optimal trade size. Each bin lookup will take ~10k compute units. So you should setup your compute unit limit accordingly. For example, I usually use 650_000 compute unit limit with max_bin_to_process = 50.

Here's a simplified Rust example for how to interact with the program. You can include multiple X mints with their according pools here.

pub fn generate_onchain_swap_instruction(
    wallet: &Pubkey,
    sol_mint: &Pubkey,
    wallet_sol_account: &Pubkey,
    dlmm_program_id: &Pubkey,
    raydium_program_id: &Pubkey,
    raydium_cp_program_id: &Pubkey,
    token_program: &Pubkey,
    system_program: &Pubkey,
    associated_token_program: &Pubkey,
    raydium_authority: &Pubkey,
    raydium_cp_authority: &Pubkey,
    dlmm_event_authority: &Pubkey,
    pump_program_id: &Pubkey,
    pump_id_1: &Pubkey,
    pump_id_2: &Pubkey,
    pump_fee_wallet: &Pubkey,
    token_pools: &[(
        Pubkey, // X mint
        Pubkey, // Wallet X account
        Vec<(
            // Raydium pools
            Pubkey, // Raydium AMM account
            Pubkey, // Raydium token X vault
            Pubkey, // Raydium SOL vault
        )>,
        Vec<(
            // Raydium CP pools
            Pubkey, // Raydium CP pool
            Pubkey, // Raydium CP amm config
            Pubkey, // Raydium CP token X vault
            Pubkey, // Raydium CP SOL vault
            Pubkey, // Raydium CP observation
        )>,
        Vec<(
            // Pump pools
            Pubkey, // Pump pool
            Pubkey, // Pump token X vault
            Pubkey, // Pump SOL vault
            Pubkey, // Pump fee token wallet
        )>,
        Vec<(
            // DLMM pairs
            Pubkey,           // DLMM pair account
            Pubkey,           // DLMM token X vault
            Pubkey,           // DLMM SOL vault
            Pubkey,           // DLMM oracle
            Vec<AccountMeta>, // Bin array accounts
        )>,
    )],
    program_id: &Pubkey,
    minimum_profit: u64,
    max_bin_to_process: u64,
) -> Instruction {
    // Create the list of accounts required for the instruction
    let fee_collector = Pubkey::from_str("6AGB9kqgSp2mQXwYpdrV4QVV8urvCaDS35U1wsLssy6H").unwrap();
    let mut accounts = vec![
        // Fixed accounts (0-16)
        AccountMeta::new_readonly(*wallet, true), // 0. Wallet (signer)
        AccountMeta::new_readonly(*sol_mint, false), // 1. SOL mint
        AccountMeta::new(fee_collector, false),   // 2. Fee collector
        AccountMeta::new(*wallet_sol_account, false), // 3. Wallet SOL account
        AccountMeta::new_readonly(*dlmm_program_id, false), // 4. DLMM program ID
        AccountMeta::new_readonly(*raydium_program_id, false), // 5. Raydium program ID
        AccountMeta::new_readonly(*raydium_cp_program_id, false), // 6. Raydium CP program ID
        AccountMeta::new_readonly(*token_program, false), // 7. Token program
        AccountMeta::new_readonly(*system_program, false), // 8. System program
        AccountMeta::new_readonly(*associated_token_program, false), // 9. Associated Token program
        AccountMeta::new_readonly(*raydium_authority, false), // 10. Raydium authority
        AccountMeta::new_readonly(*raydium_cp_authority, false), // 11. Raydium CP authority
        AccountMeta::new(*dlmm_event_authority, false), // 12. DLMM event authority
        AccountMeta::new_readonly(*pump_program_id, false), // 13. Pump program ID
        AccountMeta::new_readonly(*pump_id_1, false), // 14. Pump Global Config
        AccountMeta::new_readonly(*pump_id_2, false), // 15. Pump Event Authority
        AccountMeta::new_readonly(*pump_fee_wallet, false), // 16. Pump fee wallet
    ];

    // Add accounts for each token X and its pools
    for (x_mint, wallet_x_account, raydium_pools, raydium_cp_pools, pump_pools, dlmm_pairs) in
        token_pools
    {
        // Add token X mint and wallet account
        accounts.push(AccountMeta::new_readonly(*x_mint, false));
        accounts.push(AccountMeta::new(*wallet_x_account, false));

        // Add Raydium pools
        for (amm, x_vault, sol_vault) in raydium_pools.iter() {
            accounts.push(AccountMeta::new(*amm, false));
            accounts.push(AccountMeta::new(*x_vault, false));
            accounts.push(AccountMeta::new(*sol_vault, false));
        }

        // Add Raydium CP pools
        for (pool, amm_config, x_vault, sol_vault, observation) in raydium_cp_pools.iter() {
            accounts.push(AccountMeta::new(*pool, false));
            accounts.push(AccountMeta::new_readonly(*amm_config, false));
            accounts.push(AccountMeta::new(*x_vault, false));
            accounts.push(AccountMeta::new(*sol_vault, false));
            accounts.push(AccountMeta::new(*observation, false));
        }

        // Add Pump pools
        for (pool, x_account, sol_account, fee_token_wallet) in pump_pools.iter() {
            accounts.push(AccountMeta::new_readonly(*pool, false));
            accounts.push(AccountMeta::new(*x_account, false));
            accounts.push(AccountMeta::new(*sol_account, false));
            accounts.push(AccountMeta::new(*fee_token_wallet, false));
        }

        // Add DLMM pairs
        for (pair, x_vault, sol_vault, oracle, bin_arrays) in dlmm_pairs.iter() {
            accounts.push(AccountMeta::new(*pair, false));
            accounts.push(AccountMeta::new(*x_vault, false));
            accounts.push(AccountMeta::new(*sol_vault, false));
            accounts.push(AccountMeta::new(*oracle, false));
            accounts.extend(bin_arrays.clone());
        }
    }

    // Create instruction data
    let mut data = vec![9u8];
    data.extend_from_slice(&minimum_profit.to_le_bytes());
    data.extend_from_slice(&max_bin_to_process.to_le_bytes());

    Instruction {
        program_id: *program_id,
        accounts,
        data,
    }
}

To get the bin array, here is an example code once you decode the LBPair for DLMM pool. You need the meteora dlmm sdk to make this work: https://github.com/MeteoraAg/dlmm-sdk/tree/main

You want to periodically update the bin array accounts as bin may move out of the list you have.

fn update_bin_array_accounts(dlmm_pool: &Pubkey, lb_pair: &LbPair) -> Result<Vec<AccountMeta>> {
    // Calculate the bin array index from the active bin ID
    let bin_array_index =
        meteora_dlmm::state::bin::BinArray::bin_id_to_bin_array_index(lb_pair.active_id)
            .map_err(|e| anyhow!("Failed to convert bin ID to bin array index: {:?}", e))?;

    // Calculate a range of bin array indices centered on the active bin's array index
    let mut bin_array_accounts = vec![];
    let offsets = [-1, 0, 1];

    for offset in offsets {
        let array_idx = bin_array_index + offset;
        let (array_pda, _) =
            meteora_dlmm::utils::pda::derive_bin_array_pda(*dlmm_pool, array_idx as i64);
        bin_array_accounts.push(AccountMeta::new(array_pda, false));
    }

    Ok(bin_array_accounts)
}