strategy-vaults 0.0.1

Farm Vaults
Documentation 
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)
    }
}