Composing Swaps On-Chain (CPI)

use anchor_lang::prelude::*;
use vulcx_cpi::{invoke_route_signed, Hop, RouteAccounts, RouteArgs, RoutePlanStep, VortexHop, MAX_HOPS};

pub const VAULT_AUTHORITY_SEED: &[u8] = b"vault_authority";

/// Swap `in_amount` of the vault's source token -> dest token via one Vortex hop,
/// signed by the vault PDA. `quoted_out_amount` / `slippage_bps` come from the
/// off-chain quote returned in Step 1.
pub fn swap_treasury(
    ctx: Context<SwapTreasury>,
    in_amount: u64,
    quoted_out_amount: u64,
    slippage_bps: u16,
) -> Result<()> {
    let bump = ctx.bumps.vault_authority;

    // 1. instruction args: one Vortex step, source(idx0) -> dest(idx1)
    let mut route_plan = [RoutePlanStep::default(); MAX_HOPS];
    route_plan[0] = RoutePlanStep {
        swap_type: RoutePlanStep::SWAP_TYPE_VORTEX,
        flags: RoutePlanStep::FLAG_A_TO_B, // a_to_b, not exact_out
        percent: 100,
        input_index: 0,  // -> token_accounts[0]
        output_index: 1, // -> token_accounts[1]
    };
    let args = RouteArgs {
        num_token_accounts: 2,
        num_steps: 1,
        route_plan,
        in_amount,
        quoted_out_amount,
        slippage_bps,
        simulate: false, // real execution — `true` skips the final min-out check
    };

    // 2. account list. token_accounts + the 7 Vortex accounts arrive in
    //    remaining_accounts — exactly what /cpi/route-accounts hands you.
    let ra = ctx.remaining_accounts;
    let accounts = RouteAccounts {
        token_program:           ctx.accounts.token_program.key(),
        user_transfer_authority: ctx.accounts.vault_authority.key(), // PDA, not a wallet
        protocol_config:         ctx.accounts.protocol_config.key(),
        vortex_program:          ctx.accounts.vortex_program.key(),
        fluxbeam_program:        ctx.accounts.fluxbeam_program.key(),
        program_signer:          ctx.accounts.program_signer.key(),
        token_accounts: vec![ra[0].key(), ra[1].key()], // source, dest ATAs
        hops: vec![Hop::Vortex(VortexHop {
            pool:    ra[2].key(),
            vault_a: ra[3].key(),
            vault_b: ra[4].key(),
            tick_0:  ra[5].key(),
            tick_1:  ra[6].key(),
            tick_2:  ra[7].key(),
            oracle:  ra[8].key(),
        })],
        protocol_fee_ata: None,
        referrer_ata:     None,
    };

    // 3. cheap pre-flight — catches off-by-one / swap-type mismatch with a clear
    //    error instead of a deep CPI failure.
    accounts.validate(&args)?;

    // 4. CPI, signing as the vault PDA. account_infos must contain every
    //    AccountInfo the metas reference + the aggregator program; order among
    //    them does not matter to the runtime.
    let mut infos = vec![
        ctx.accounts.token_program.to_account_info(),
        ctx.accounts.vault_authority.to_account_info(),
        ctx.accounts.protocol_config.to_account_info(),
        ctx.accounts.vortex_program.to_account_info(),
        ctx.accounts.fluxbeam_program.to_account_info(),
        ctx.accounts.program_signer.to_account_info(),
        ctx.accounts.vulcx_program.to_account_info(),
    ];
    infos.extend_from_slice(ra); // token accounts + hop accounts

    invoke_route_signed(
        &ctx.accounts.vulcx_program,
        &accounts,
        &args,
        &infos,
        &[&[VAULT_AUTHORITY_SEED, &[bump]]],
    )
    // ...your post-swap logic runs in the SAME transaction, atomically.
}

#[derive(Accounts)]
pub struct SwapTreasury<'info> {
    /// CHECK: the Vulcx aggregator we CPI into.
    #[account(address = vulcx_aggregator::ID)]
    pub vulcx_program: AccountInfo<'info>,

    /// CHECK: SPL Token or Token-2022, forwarded to route.
    pub token_program: AccountInfo<'info>,

    /// The vault PDA that owns the token accounts and signs the swap.
    /// CHECK: seeds-derived; owns the source/dest ATAs.
    #[account(mut, seeds = [VAULT_AUTHORITY_SEED], bump)]
    pub vault_authority: AccountInfo<'info>,

    /// CHECK: Vulcx protocol_config PDA (already initialized).
    pub protocol_config: AccountInfo<'info>,
    /// CHECK: forwarded to route (address-checked inside route).
    pub vortex_program: AccountInfo<'info>,
    /// CHECK: forwarded to route (address-checked inside route).
    pub fluxbeam_program: AccountInfo<'info>,
    /// CHECK: forwarded to route.program_signer.
    pub program_signer: AccountInfo<'info>,
    // remaining_accounts: [ source_ata, dest_ata, pool, vault_a, vault_b,
    //                       tick_0, tick_1, tick_2, oracle ]
}