1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

mod clock;
mod events;
mod instructions;
use anchor_lang::{prelude::*, AccountsExit};
pub use clock::*;
pub use events::*;
pub use instructions::raydium_stake_lp_compound::*;
use vipers::Validate;

declare_id!("DTQ4xCxT3isWPbEJMB5eAct49ofbK9tNMyBTQniFKb8h");

/// Program which manages Raydium LPs.
#[program]
pub mod strategy_vaults {

    use super::*;

    /// Creates a [Vault] with a given admin.
    #[access_control(ctx.accounts.validate())]
    pub fn create_vault(
        ctx: Context<CreateVault>,
        manager: Pubkey,
        serum_program_id: Pubkey,
        pool_program_id: Pubkey,
        farm_program_id: Pubkey,
        farm: Pubkey,
        farm_authority: Pubkey,
        serum_market: Pubkey,
        serum_vault_signer: Pubkey,
        amm_authority: Pubkey,
    ) -> Result<()> {
        instructions::raydium_stake_lp_compound::create_vault::handler(
            ctx,
            manager,
            serum_program_id,
            pool_program_id,
            farm_program_id,
            farm,
            farm_authority,
            serum_market,
            serum_vault_signer,
            amm_authority,
        )
    }

    /// Creates a [Vault] with a given admin.
    #[access_control(ctx.accounts.validate())]
    pub fn create_vault_two(ctx: Context<CreateVaultTwo>, farm_version: u64) -> Result<()> {
        instructions::raydium_stake_lp_compound::create_vault_two::handler(ctx, farm_version)
    }

    /// Creates a [Vault] with a given admin.
    #[access_control(ctx.accounts.validate())]
    pub fn create_vault_three(ctx: Context<CreateVaultThree>) -> Result<()> {
        instructions::raydium_stake_lp_compound::create_vault_three::handler(ctx)
    }

    /// Creates a [UserInfo] with a given admin.
    #[access_control(ctx.accounts.validate())]
    pub fn create_user_info(ctx: Context<CreateUserInfo>, user_account: Pubkey) -> Result<()> {
        instructions::raydium_stake_lp_compound::create_user_info::handler(ctx, user_account)
    }

    /// takes some treasury tokens and invests them into Raydium Pools
    #[access_control(ctx.accounts.validate())]
    pub fn add_liquidity(
        ctx: Context<AddLiquidity>,
        token_a_amount: u64,
        token_b_amount: u64,
    ) -> Result<()> {
        instructions::raydium_stake_lp_compound::add_liquidity::handler(
            ctx,
            token_a_amount,
            token_b_amount,
        )
    }

    /// takes lp tokens and stakes them in farms.
    #[access_control(ctx.accounts.validate())]
    pub fn stake(ctx: Context<Stake>, amount: u64) -> Result<()> {
        instructions::raydium_stake_lp_compound::stake::handler(ctx, amount)
    }

    /// removes underlying liquidity from the pool
    #[access_control(ctx.accounts.validate())]
    pub fn remove_liquidity(ctx: Context<RemoveLiquidity>) -> Result<()> {
        instructions::raydium_stake_lp_compound::remove_liquidity::handler(ctx)
    }

    // unlocks liquidity by unstaking from the farm
    #[access_control(ctx.accounts.validate())]
    pub fn unlock_liquidity(ctx: Context<UnlockLiquidity>, amount: u64) -> Result<()> {
        instructions::raydium_stake_lp_compound::unlock_liquidity::handler(ctx, amount)
    }
    // Crank 1
    #[access_control(ctx.accounts.validate())]
    pub fn crank1(ctx: Context<Crank1>) -> Result<()> {
        instructions::raydium_stake_lp_compound::crank1::handler(ctx)
    }

    // Crank 2
    #[access_control(ctx.accounts.validate())]
    pub fn crank2(ctx: Context<Crank2>) -> Result<()> {
        instructions::raydium_stake_lp_compound::crank2::handler(ctx)
    }

    // Crank 3
    #[access_control(ctx.accounts.validate())]
    pub fn crank3(ctx: Context<Crank3>) -> Result<()> {
        instructions::raydium_stake_lp_compound::crank3::handler(ctx)
    }
}