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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

pub mod errors;
pub mod instructions;
pub mod state;
pub mod utils;

use anchor_lang::prelude::*;
use instructions::*;

declare_id!("stkBL96RZkjY5ine4TvPihGqW8UHJfch2cokjAPzV8i");

#[program]
pub mod cardinal_stake_pool {

    use super::*;

    pub fn init_identifier(ctx: Context<InitIdentifierCtx>) -> Result<()> {
        init_identifier::handler(ctx)
    }

    pub fn init_pool(ctx: Context<InitPoolCtx>, ix: InitPoolIx) -> Result<()> {
        init_pool::handler(ctx, ix)
    }

    pub fn init_entry(ctx: Context<InitEntryCtx>, user: Pubkey) -> Result<()> {
        init_entry::handler(ctx, user)
    }

    pub fn init_stake_mint(ctx: Context<InitStakeMintCtx>, ix: InitStakeMintIx) -> Result<()> {
        init_stake_mint::handler(ctx, ix)
    }

    pub fn authorize_mint(ctx: Context<AuthorizeMintCtx>, mint: Pubkey) -> Result<()> {
        authorize_mint::handler(ctx, mint)
    }

    pub fn deauthorize_mint(ctx: Context<DeauthorizeMintCtx>) -> Result<()> {
        deauthorize_mint::handler(ctx)
    }

    pub fn stake(ctx: Context<StakeCtx>, amount: u64) -> Result<()> {
        stake::handler(ctx, amount)
    }

    pub fn claim_receipt_mint<'key, 'accounts, 'remaining, 'info>(ctx: Context<'key, 'accounts, 'remaining, 'info, ClaimReceiptMintCtx<'info>>) -> Result<()> {
        claim_receipt_mint::handler(ctx)
    }

    pub fn unstake(ctx: Context<UnstakeCtx>) -> Result<()> {
        unstake::handler(ctx)
    }

    pub fn update_pool(ctx: Context<UpdatePoolCtx>, ix: UpdatePoolIx) -> Result<()> {
        update_pool::handler(ctx, ix)
    }

    pub fn update_total_stake_seconds(ctx: Context<UpdateTotalStakeSecondsCtx>) -> Result<()> {
        update_total_stake_seconds::handler(ctx)
    }

    pub fn return_receipt_mint<'key, 'accounts, 'remaining, 'info>(ctx: Context<'key, 'accounts, 'remaining, 'info, ReturnReceiptMintCtx<'info>>) -> Result<()> {
        return_receipt_mint::handler(ctx)
    }

    pub fn close_stake_pool(ctx: Context<CloseStakePoolCtx>) -> Result<()> {
        close_stake_pool::handler(ctx)
    }

    pub fn close_stake_entry(ctx: Context<CloseStakeEntryCtx>) -> Result<()> {
        close_stake_entry::handler(ctx)
    }

    pub fn stake_entry_fill_zeros(ctx: Context<StakeEntryFillZeros>) -> Result<()> {
        stake_entry_fill_zeros::handler(ctx)
    }

    pub fn stake_entry_resize(ctx: Context<StakeEntryResize>) -> Result<()> {
        stake_entry_resize::handler(ctx)
    }

    pub fn stake_pool_fill_zeros(ctx: Context<StakePoolFillZeros>) -> Result<()> {
        stake_pool_fill_zeros::handler(ctx)
    }

    pub fn reassign_stake_entry(ctx: Context<ReassignStakeEntryCtx>, ix: ReassignStakeEntryIx) -> Result<()> {
        reassign_stake_entry::handler(ctx, ix)
    }

    pub fn double_or_reset_total_stake_seconds(ctx: Context<DoubleOrResetTotalStakeSecondsCtx>) -> Result<()> {
        double_or_reset_total_stake_seconds::handler(ctx)
    }

    pub fn claim_stake_entry_funds(ctx: Context<ClaimStakeEntryFundsCtx>) -> Result<()> {
        claim_stake_entry_funds::handler(ctx)
    }

    //// programmable ////
    pub fn stake_programmable(ctx: Context<StakeProgrammableCtx>, amount: u64) -> Result<()> {
        programmable::stake_programmable::handler(ctx, amount)
    }

    pub fn unstake_programmable(ctx: Context<UnstakeProgrammableCtx>) -> Result<()> {
        programmable::unstake_programmable::handler(ctx)
    }

    pub fn unstake_custodial_programmable(ctx: Context<UnstakeCustodialProgrammableCtx>) -> Result<()> {
        programmable::unstake_custodial_programmable::handler(ctx)
    }

    //// stake_booster ////
    pub fn init_stake_booster(ctx: Context<InitStakeBoosterCtx>, ix: InitStakeBoosterIx) -> Result<()> {
        stake_booster::init_stake_booster::handler(ctx, ix)
    }

    pub fn update_stake_booster(ctx: Context<UpdateStakeBoosterCtx>, ix: UpdateStakeBoosterIx) -> Result<()> {
        stake_booster::update_stake_booster::handler(ctx, ix)
    }

    pub fn boost_stake_entry(ctx: Context<BoostStakeEntryCtx>, ix: BoostStakeEntryIx) -> Result<()> {
        stake_booster::boost_stake_entry::handler(ctx, ix)
    }

    pub fn close_stake_booster(ctx: Context<CloseStakeBoosterCtx>) -> Result<()> {
        stake_booster::close_stake_booster::handler(ctx)
    }

    //// groups ////
    pub fn init_group_entry(ctx: Context<InitGroupEntryCtx>, ix: InitGroupEntryIx) -> Result<()> {
        groups::init_group_entry::handler(ctx, ix)
    }

    pub fn add_to_group_entry(ctx: Context<AddToGroupEntryCtx>) -> Result<()> {
        groups::add_to_group_entry::handler(ctx)
    }

    pub fn remove_from_group_entry(ctx: Context<RemoveFromGroupEntryCtx>) -> Result<()> {
        groups::remove_from_group_entry::handler(ctx)
    }

    pub fn init_ungrouping(ctx: Context<InitUngroupingCtx>) -> Result<()> {
        groups::init_ungrouping::handler(ctx)
    }
}