Skip to main content

ore_stake_api/
sdk.rs

1use solana_program::pubkey::Pubkey;
2use spl_associated_token_account::get_associated_token_address;
3use steel::*;
4
5use crate::{
6    consts::{MINT_ADDRESS, TREASURY},
7    instruction::*,
8    state::*,
9};
10
11pub fn log(signer: Pubkey, msg: &[u8]) -> Instruction {
12    let mut data = Log {}.to_bytes();
13    data.extend_from_slice(msg);
14    Instruction {
15        program_id: crate::ID,
16        accounts: vec![AccountMeta::new(signer, true)],
17        data: data,
18    }
19}
20
21pub fn program_log(accounts: &[AccountInfo], msg: &[u8]) -> Result<(), ProgramError> {
22    invoke_signed(
23        &log(*accounts[0].key, msg),
24        accounts,
25        &crate::ID,
26        &[TREASURY],
27    )
28}
29
30pub fn deposit(
31    signer: Pubkey,
32    payer: Pubkey,
33    amount: u64,
34    compound_fee: u64,
35    compound_fee_deposit: u64,
36) -> Instruction {
37    let mint_address = MINT_ADDRESS;
38    let stake_address = stake_pda(signer).0;
39    let stake_tokens_address = get_associated_token_address(&stake_address, &MINT_ADDRESS);
40    let sender_address = get_associated_token_address(&signer, &MINT_ADDRESS);
41    let treasury_address = treasury_pda().0;
42    Instruction {
43        program_id: crate::ID,
44        accounts: vec![
45            AccountMeta::new(signer, true),
46            AccountMeta::new(payer, true),
47            AccountMeta::new_readonly(mint_address, false),
48            AccountMeta::new(sender_address, false),
49            AccountMeta::new(stake_address, false),
50            AccountMeta::new(stake_tokens_address, false),
51            AccountMeta::new(treasury_address, false),
52            AccountMeta::new_readonly(system_program::ID, false),
53            AccountMeta::new_readonly(spl_token::ID, false),
54            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
55            AccountMeta::new_readonly(crate::ID, false),
56        ],
57        data: Deposit {
58            amount: amount.to_le_bytes(),
59            compound_fee: compound_fee.to_le_bytes(),
60            compound_fee_deposit: compound_fee_deposit.to_le_bytes(),
61        }
62        .to_bytes(),
63    }
64}
65
66pub fn withdraw(signer: Pubkey, amount: u64) -> Instruction {
67    let stake_address = stake_pda(signer).0;
68    let stake_tokens_address = get_associated_token_address(&stake_address, &MINT_ADDRESS);
69    let mint_address = MINT_ADDRESS;
70    let recipient_address = get_associated_token_address(&signer, &MINT_ADDRESS);
71    let treasury_address = treasury_pda().0;
72    Instruction {
73        program_id: crate::ID,
74        accounts: vec![
75            AccountMeta::new(signer, true),
76            AccountMeta::new_readonly(mint_address, false),
77            AccountMeta::new(recipient_address, false),
78            AccountMeta::new(stake_address, false),
79            AccountMeta::new(stake_tokens_address, false),
80            AccountMeta::new(treasury_address, false),
81            AccountMeta::new_readonly(system_program::ID, false),
82            AccountMeta::new_readonly(spl_token::ID, false),
83            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
84            AccountMeta::new_readonly(crate::ID, false),
85        ],
86        data: Withdraw {
87            amount: amount.to_le_bytes(),
88        }
89        .to_bytes(),
90    }
91}
92
93pub fn claim(signer: Pubkey, amount: u64) -> Instruction {
94    let stake_address = stake_pda(signer).0;
95    let mint_address = MINT_ADDRESS;
96    let recipient_address = get_associated_token_address(&signer, &MINT_ADDRESS);
97    let treasury_address = treasury_pda().0;
98    let treasury_tokens_address = treasury_tokens_address();
99    Instruction {
100        program_id: crate::ID,
101        accounts: vec![
102            AccountMeta::new(signer, true),
103            AccountMeta::new_readonly(mint_address, false),
104            AccountMeta::new(recipient_address, false),
105            AccountMeta::new(stake_address, false),
106            AccountMeta::new(treasury_address, false),
107            AccountMeta::new(treasury_tokens_address, false),
108            AccountMeta::new_readonly(system_program::ID, false),
109            AccountMeta::new_readonly(spl_token::ID, false),
110            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
111            AccountMeta::new_readonly(crate::ID, false),
112        ],
113        data: Claim {
114            amount: amount.to_le_bytes(),
115        }
116        .to_bytes(),
117    }
118}
119
120pub fn compound(signer: Pubkey) -> Instruction {
121    let stake_address = stake_pda(signer).0;
122    let mint_address = MINT_ADDRESS;
123    let stake_tokens_address = get_associated_token_address(&stake_address, &MINT_ADDRESS);
124    let treasury_address = treasury_pda().0;
125    let treasury_tokens_address = treasury_tokens_address();
126    Instruction {
127        program_id: crate::ID,
128        accounts: vec![
129            AccountMeta::new(signer, true),
130            AccountMeta::new_readonly(mint_address, false),
131            AccountMeta::new(stake_address, false),
132            AccountMeta::new(stake_tokens_address, false),
133            AccountMeta::new(treasury_address, false),
134            AccountMeta::new(treasury_tokens_address, false),
135            AccountMeta::new_readonly(system_program::ID, false),
136            AccountMeta::new_readonly(spl_token::ID, false),
137            AccountMeta::new_readonly(crate::ID, false),
138        ],
139        data: Compound {}.to_bytes(),
140    }
141}
142
143pub fn init(signer: Pubkey) -> Instruction {
144    let mint_address = MINT_ADDRESS;
145    let treasury_address = treasury_pda().0;
146    let treasury_tokens_info = treasury_tokens_address();
147    Instruction {
148        program_id: crate::ID,
149        accounts: vec![
150            AccountMeta::new(signer, true),
151            AccountMeta::new_readonly(mint_address, false),
152            AccountMeta::new(treasury_address, false),
153            AccountMeta::new(treasury_tokens_info, false),
154            AccountMeta::new_readonly(system_program::ID, false),
155            AccountMeta::new_readonly(spl_token::ID, false),
156            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
157        ],
158        data: Init {}.to_bytes(),
159    }
160}
161
162pub fn distribute(signer: Pubkey, amount: u64) -> Instruction {
163    let sender_address = get_associated_token_address(&signer, &MINT_ADDRESS);
164    let ore_mint_info = MINT_ADDRESS;
165    let treasury_info = treasury_pda().0;
166    let treasury_tokens_info = treasury_tokens_address();
167    Instruction {
168        program_id: crate::ID,
169        accounts: vec![
170            AccountMeta::new(signer, true),
171            AccountMeta::new(sender_address, false),
172            AccountMeta::new_readonly(ore_mint_info, false),
173            AccountMeta::new(treasury_info, false),
174            AccountMeta::new(treasury_tokens_info, false),
175            AccountMeta::new_readonly(spl_token::ID, false),
176            AccountMeta::new_readonly(crate::ID, false),
177        ],
178        data: Distribute {
179            amount: amount.to_le_bytes(),
180        }
181        .to_bytes(),
182    }
183}