fn perform_swap<'info>(
    whirlpool: &Account<'info, Whirlpool>,
    token_authority: &Signer<'info>,
    token_owner_account_a: &Account<'info, TokenAccount>,
    token_owner_account_b: &Account<'info, TokenAccount>,
    token_vault_a: &Account<'info, TokenAccount>,
    token_vault_b: &Account<'info, TokenAccount>,
    token_program: &Program<'info, Token>,
    amount_a: u64,
    amount_b: u64,
    a_to_b: bool,
) -> Result<()> {
    // Transfer from user to pool
    let deposit_account_user;
    let deposit_account_pool;
    let deposit_amount;

    // Transfer from pool to user
    let withdrawal_account_user;
    let withdrawal_account_pool;
    let withdrawal_amount;

    if a_to_b {
        deposit_account_user = token_owner_account_a;
        deposit_account_pool = token_vault_a;
        deposit_amount = amount_a;

        withdrawal_account_user = token_owner_account_b;
        withdrawal_account_pool = token_vault_b;
        withdrawal_amount = amount_b;
    } else {
        deposit_account_user = token_owner_account_b;
        deposit_account_pool = token_vault_b;
        deposit_amount = amount_b;

        withdrawal_account_user = token_owner_account_a;
        withdrawal_account_pool = token_vault_a;
        withdrawal_amount = amount_a;
    }

    transfer_from_owner_to_vault(
        token_authority,
        deposit_account_user,
        deposit_account_pool,
        token_program,
        deposit_amount,
    )?;

    transfer_from_vault_to_owner(
        whirlpool,
        withdrawal_account_pool,
        withdrawal_account_user,
        token_program,
        withdrawal_amount,
    )?;

    Ok(())
}