ore_api/
sdk.rs

1use solana_program::pubkey::Pubkey;
2use spl_associated_token_account::get_associated_token_address;
3use steel::*;
4
5use crate::{
6    consts::{BOARD, MINT_ADDRESS, SOL_MINT, TREASURY_ADDRESS},
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(&log(*accounts[0].key, msg), accounts, &crate::ID, &[BOARD])
23}
24
25// let [signer_info, automation_info, executor_info, miner_info, system_program] = accounts else {
26
27pub fn automate(
28    signer: Pubkey,
29    amount: u64,
30    deposit: u64,
31    executor: Pubkey,
32    fee: u64,
33    mask: u64,
34    strategy: u8,
35    reload: bool,
36) -> Instruction {
37    let automation_address = automation_pda(signer).0;
38    let miner_address = miner_pda(signer).0;
39    Instruction {
40        program_id: crate::ID,
41        accounts: vec![
42            AccountMeta::new(signer, true),
43            AccountMeta::new(automation_address, false),
44            AccountMeta::new(executor, false),
45            AccountMeta::new(miner_address, false),
46            AccountMeta::new_readonly(system_program::ID, false),
47        ],
48        data: Automate {
49            amount: amount.to_le_bytes(),
50            deposit: deposit.to_le_bytes(),
51            fee: fee.to_le_bytes(),
52            mask: mask.to_le_bytes(),
53            strategy: strategy as u8,
54            reload: (reload as u64).to_le_bytes(),
55        }
56        .to_bytes(),
57    }
58}
59
60pub fn claim_sol(signer: Pubkey) -> Instruction {
61    let miner_address = miner_pda(signer).0;
62    Instruction {
63        program_id: crate::ID,
64        accounts: vec![
65            AccountMeta::new(signer, true),
66            AccountMeta::new(miner_address, false),
67            AccountMeta::new_readonly(system_program::ID, false),
68        ],
69        data: ClaimSOL {}.to_bytes(),
70    }
71}
72
73// let [signer_info, miner_info, mint_info, recipient_info, treasury_info, treasury_tokens_info, system_program, token_program, associated_token_program] =
74
75pub fn claim_ore(signer: Pubkey) -> Instruction {
76    let miner_address = miner_pda(signer).0;
77    let treasury_address = treasury_pda().0;
78    let treasury_tokens_address = get_associated_token_address(&treasury_address, &MINT_ADDRESS);
79    let recipient_address = get_associated_token_address(&signer, &MINT_ADDRESS);
80    Instruction {
81        program_id: crate::ID,
82        accounts: vec![
83            AccountMeta::new(signer, true),
84            AccountMeta::new(miner_address, false),
85            AccountMeta::new(MINT_ADDRESS, false),
86            AccountMeta::new(recipient_address, false),
87            AccountMeta::new(treasury_address, false),
88            AccountMeta::new(treasury_tokens_address, false),
89            AccountMeta::new_readonly(system_program::ID, false),
90            AccountMeta::new_readonly(spl_token::ID, false),
91            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
92        ],
93        data: ClaimORE {}.to_bytes(),
94    }
95}
96
97// let [signer_info, authority_info, automation_info, board_info, miner_info, round_info, system_program] =
98
99pub fn deploy(
100    signer: Pubkey,
101    authority: Pubkey,
102    amount: u64,
103    round_id: u64,
104    squares: [bool; 25],
105) -> Instruction {
106    let automation_address = automation_pda(authority).0;
107    let board_address = board_pda().0;
108    let miner_address = miner_pda(authority).0;
109    let round_address = round_pda(round_id).0;
110    let entropy_var_address = entropy_api::state::var_pda(board_address, 0).0;
111
112    // Convert array of 25 booleans into a 32-bit mask where each bit represents whether
113    // that square index is selected (1) or not (0)
114    let mut mask: u32 = 0;
115    for (i, &square) in squares.iter().enumerate() {
116        if square {
117            mask |= 1 << i;
118        }
119    }
120
121    Instruction {
122        program_id: crate::ID,
123        accounts: vec![
124            AccountMeta::new(signer, true),
125            AccountMeta::new(authority, false),
126            AccountMeta::new(automation_address, false),
127            AccountMeta::new(board_address, false),
128            AccountMeta::new(miner_address, false),
129            AccountMeta::new(round_address, false),
130            AccountMeta::new_readonly(system_program::ID, false),
131            // Entropy accounts.
132            AccountMeta::new(entropy_var_address, false),
133            AccountMeta::new_readonly(entropy_api::ID, false),
134        ],
135        data: Deploy {
136            amount: amount.to_le_bytes(),
137            squares: mask.to_le_bytes(),
138        }
139        .to_bytes(),
140    }
141}
142
143// let [pool, user_source_token, user_destination_token, a_vault, b_vault, a_token_vault, b_token_vault, a_vault_lp_mint, b_vault_lp_mint, a_vault_lp, b_vault_lp, protocol_token_fee, user_key, vault_program, token_program] =
144
145pub fn bury(signer: Pubkey, swap_accounts: &[AccountMeta], swap_data: &[u8]) -> Instruction {
146    let board_address = board_pda().0;
147    let config_address = config_pda().0;
148    let mint_address = MINT_ADDRESS;
149    let treasury_address = TREASURY_ADDRESS;
150    let treasury_ore_address = get_associated_token_address(&treasury_address, &MINT_ADDRESS);
151    let treasury_sol_address = get_associated_token_address(&treasury_address, &SOL_MINT);
152    let mut accounts = vec![
153        AccountMeta::new(signer, true),
154        AccountMeta::new(board_address, false),
155        AccountMeta::new_readonly(config_address, false),
156        AccountMeta::new(mint_address, false),
157        AccountMeta::new(treasury_address, false),
158        AccountMeta::new(treasury_ore_address, false),
159        AccountMeta::new(treasury_sol_address, false),
160        AccountMeta::new_readonly(spl_token::ID, false),
161        AccountMeta::new_readonly(crate::ID, false),
162    ];
163    for account in swap_accounts.iter() {
164        let mut acc_clone = account.clone();
165        acc_clone.is_signer = false;
166        accounts.push(acc_clone);
167    }
168    let mut data = Bury {}.to_bytes();
169    data.extend_from_slice(swap_data);
170    Instruction {
171        program_id: crate::ID,
172        accounts,
173        data,
174    }
175}
176
177// let [signer_info, sender_info, board_info, mint_info, treasury_info, treasury_ore_info, token_program, ore_program] =
178
179pub fn bury2(signer: Pubkey, amount: u64) -> Instruction {
180    let board_address = board_pda().0;
181    let sender_address = get_associated_token_address(&signer, &MINT_ADDRESS);
182    let mint_address = MINT_ADDRESS;
183    let treasury_address = TREASURY_ADDRESS;
184    let treasury_ore_address = get_associated_token_address(&treasury_address, &MINT_ADDRESS);
185    let token_program = spl_token::ID;
186    let ore_program = crate::ID;
187    Instruction {
188        program_id: crate::ID,
189        accounts: vec![
190            AccountMeta::new(signer, true),
191            AccountMeta::new(sender_address, false),
192            AccountMeta::new(board_address, false),
193            AccountMeta::new(mint_address, false),
194            AccountMeta::new(treasury_address, false),
195            AccountMeta::new(treasury_ore_address, false),
196            AccountMeta::new_readonly(token_program, false),
197            AccountMeta::new_readonly(ore_program, false),
198        ],
199        data: Bury2 {
200            amount: amount.to_le_bytes(),
201        }
202        .to_bytes(),
203    }
204}
205
206// let [signer_info, board_info, config_info, manager_info, manager_sol_info, treasury_info, treasury_sol_info, token_program, ore_program] =
207
208pub fn liq(signer: Pubkey, manager: Pubkey) -> Instruction {
209    let board_address = board_pda().0;
210    let config_address = config_pda().0;
211    let manager_sol_address = get_associated_token_address(&manager, &SOL_MINT);
212    let treasury_address = TREASURY_ADDRESS;
213    let treasury_sol_address = get_associated_token_address(&treasury_address, &SOL_MINT);
214    let token_program = spl_token::ID;
215    let ore_program = crate::ID;
216    Instruction {
217        program_id: crate::ID,
218        accounts: vec![
219            AccountMeta::new(signer, true),
220            AccountMeta::new(board_address, false),
221            AccountMeta::new(config_address, false),
222            AccountMeta::new(manager, false),
223            AccountMeta::new(manager_sol_address, false),
224            AccountMeta::new(treasury_address, false),
225            AccountMeta::new(treasury_sol_address, false),
226            AccountMeta::new_readonly(token_program, false),
227            AccountMeta::new_readonly(ore_program, false),
228        ],
229        data: Liq {}.to_bytes(),
230    }
231}
232
233pub fn wrap(signer: Pubkey) -> Instruction {
234    let config_address = config_pda().0;
235    let treasury_address = TREASURY_ADDRESS;
236    let treasury_sol_address = get_associated_token_address(&treasury_address, &SOL_MINT);
237    Instruction {
238        accounts: vec![
239            AccountMeta::new(signer, true),
240            AccountMeta::new_readonly(config_address, false),
241            AccountMeta::new(treasury_address, false),
242            AccountMeta::new(treasury_sol_address, false),
243            AccountMeta::new_readonly(system_program::ID, false),
244        ],
245        program_id: crate::ID,
246        data: Wrap {}.to_bytes(),
247    }
248}
249
250// let [signer_info, board_info, config_info, fee_collector_info, mint_info, round_info, round_next_info, top_miner_info, treasury_info, treasury_tokens_info, system_program, token_program, ore_program, slot_hashes_sysvar] =
251
252pub fn reset(
253    signer: Pubkey,
254    fee_collector: Pubkey,
255    round_id: u64,
256    top_miner: Pubkey,
257) -> Instruction {
258    let board_address = board_pda().0;
259    let config_address = config_pda().0;
260    let mint_address = MINT_ADDRESS;
261    let round_address = round_pda(round_id).0;
262    let round_next_address = round_pda(round_id + 1).0;
263    let top_miner_address = miner_pda(top_miner).0;
264    let treasury_address = TREASURY_ADDRESS;
265    let treasury_tokens_address = treasury_tokens_address();
266    let entropy_var_address = entropy_api::state::var_pda(board_address, 0).0;
267    Instruction {
268        program_id: crate::ID,
269        accounts: vec![
270            AccountMeta::new(signer, true),
271            AccountMeta::new(board_address, false),
272            AccountMeta::new(config_address, false),
273            AccountMeta::new(fee_collector, false),
274            AccountMeta::new(mint_address, false),
275            AccountMeta::new(round_address, false),
276            AccountMeta::new(round_next_address, false),
277            AccountMeta::new(top_miner_address, false),
278            AccountMeta::new(treasury_address, false),
279            AccountMeta::new(treasury_tokens_address, false),
280            AccountMeta::new_readonly(system_program::ID, false),
281            AccountMeta::new_readonly(spl_token::ID, false),
282            AccountMeta::new_readonly(crate::ID, false),
283            AccountMeta::new_readonly(sysvar::slot_hashes::ID, false),
284            // Entropy accounts.
285            AccountMeta::new(entropy_var_address, false),
286            AccountMeta::new_readonly(entropy_api::ID, false),
287        ],
288        data: Reset {}.to_bytes(),
289    }
290}
291
292// let [signer_info, board_info, rent_payer_info, round_info, treasury_info, system_program] =
293
294pub fn close(signer: Pubkey, round_id: u64, rent_payer: Pubkey) -> Instruction {
295    let board_address = board_pda().0;
296    let treasury_address = TREASURY_ADDRESS;
297    let round_address = round_pda(round_id).0;
298    Instruction {
299        program_id: crate::ID,
300        accounts: vec![
301            AccountMeta::new(signer, true),
302            AccountMeta::new(board_address, false),
303            AccountMeta::new(rent_payer, false),
304            AccountMeta::new(round_address, false),
305            AccountMeta::new(treasury_address, false),
306            AccountMeta::new_readonly(system_program::ID, false),
307        ],
308        data: Close {}.to_bytes(),
309    }
310}
311
312// let [signer_info, automation_info, board_info, miner_info, round_info, treasury_info, system_program] =
313
314pub fn checkpoint(signer: Pubkey, authority: Pubkey, round_id: u64) -> Instruction {
315    let miner_address = miner_pda(authority).0;
316    let board_address = board_pda().0;
317    let round_address = round_pda(round_id).0;
318    let treasury_address = TREASURY_ADDRESS;
319    Instruction {
320        program_id: crate::ID,
321        accounts: vec![
322            AccountMeta::new(signer, true),
323            AccountMeta::new(board_address, false),
324            AccountMeta::new(miner_address, false),
325            AccountMeta::new(round_address, false),
326            AccountMeta::new(treasury_address, false),
327            AccountMeta::new_readonly(system_program::ID, false),
328        ],
329        data: Checkpoint {}.to_bytes(),
330    }
331}
332
333pub fn set_admin(signer: Pubkey, admin: Pubkey) -> Instruction {
334    let config_address = config_pda().0;
335    Instruction {
336        program_id: crate::ID,
337        accounts: vec![
338            AccountMeta::new(signer, true),
339            AccountMeta::new(config_address, false),
340            AccountMeta::new_readonly(system_program::ID, false),
341        ],
342        data: SetAdmin {
343            admin: admin.to_bytes(),
344        }
345        .to_bytes(),
346    }
347}
348
349pub fn set_admin_fee(signer: Pubkey, admin_fee: u64) -> Instruction {
350    let config_address = config_pda().0;
351    Instruction {
352        program_id: crate::ID,
353        accounts: vec![
354            AccountMeta::new(signer, true),
355            AccountMeta::new(config_address, false),
356            AccountMeta::new_readonly(system_program::ID, false),
357        ],
358        data: SetAdminFee {
359            admin_fee: admin_fee.to_le_bytes(),
360        }
361        .to_bytes(),
362    }
363}
364
365pub fn set_fee_collector(signer: Pubkey, fee_collector: Pubkey) -> Instruction {
366    let config_address = config_pda().0;
367    Instruction {
368        program_id: crate::ID,
369        accounts: vec![
370            AccountMeta::new(signer, true),
371            AccountMeta::new(config_address, false),
372            AccountMeta::new_readonly(system_program::ID, false),
373        ],
374        data: SetFeeCollector {
375            fee_collector: fee_collector.to_bytes(),
376        }
377        .to_bytes(),
378    }
379}
380
381// let [signer_info, mint_info, sender_info, stake_info, stake_tokens_info, treasury_info, system_program, token_program, associated_token_program] =
382
383pub fn deposit(signer: Pubkey, payer: Pubkey, amount: u64) -> Instruction {
384    let mint_address = MINT_ADDRESS;
385    let stake_address = stake_pda(signer).0;
386    let stake_tokens_address = get_associated_token_address(&stake_address, &MINT_ADDRESS);
387    let sender_address = get_associated_token_address(&signer, &MINT_ADDRESS);
388    let treasury_address = TREASURY_ADDRESS;
389    Instruction {
390        program_id: crate::ID,
391        accounts: vec![
392            AccountMeta::new(signer, true),
393            AccountMeta::new(payer, true),
394            AccountMeta::new(mint_address, false),
395            AccountMeta::new(sender_address, false),
396            AccountMeta::new(stake_address, false),
397            AccountMeta::new(stake_tokens_address, false),
398            AccountMeta::new(treasury_address, false),
399            AccountMeta::new_readonly(system_program::ID, false),
400            AccountMeta::new_readonly(spl_token::ID, false),
401            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
402        ],
403        data: Deposit {
404            amount: amount.to_le_bytes(),
405        }
406        .to_bytes(),
407    }
408}
409
410// let [signer_info, mint_info, recipient_info, stake_info, stake_tokens_info, treasury_info, system_program, token_program, associated_token_program] =
411
412pub fn withdraw(signer: Pubkey, amount: u64) -> Instruction {
413    let stake_address = stake_pda(signer).0;
414    let stake_tokens_address = get_associated_token_address(&stake_address, &MINT_ADDRESS);
415    let mint_address = MINT_ADDRESS;
416    let recipient_address = get_associated_token_address(&signer, &MINT_ADDRESS);
417    let treasury_address = TREASURY_ADDRESS;
418    Instruction {
419        program_id: crate::ID,
420        accounts: vec![
421            AccountMeta::new(signer, true),
422            AccountMeta::new(mint_address, false),
423            AccountMeta::new(recipient_address, false),
424            AccountMeta::new(stake_address, false),
425            AccountMeta::new(stake_tokens_address, false),
426            AccountMeta::new(treasury_address, false),
427            AccountMeta::new_readonly(system_program::ID, false),
428            AccountMeta::new_readonly(spl_token::ID, false),
429            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
430        ],
431        data: Withdraw {
432            amount: amount.to_le_bytes(),
433        }
434        .to_bytes(),
435    }
436}
437
438// let [signer_info, automation_info, miner_info, system_program] = accounts else {
439
440pub fn reload_sol(signer: Pubkey, authority: Pubkey) -> Instruction {
441    let automation_address = automation_pda(authority).0;
442    let miner_address = miner_pda(authority).0;
443    Instruction {
444        program_id: crate::ID,
445        accounts: vec![
446            AccountMeta::new(signer, true),
447            AccountMeta::new(automation_address, false),
448            AccountMeta::new(miner_address, false),
449            AccountMeta::new_readonly(system_program::ID, false),
450        ],
451        data: ReloadSOL {}.to_bytes(),
452    }
453}
454
455// let [signer_info, mint_info, recipient_info, stake_info, treasury_info, treasury_tokens_info, system_program, token_program, associated_token_program] =
456
457pub fn claim_yield(signer: Pubkey, amount: u64) -> Instruction {
458    let stake_address = stake_pda(signer).0;
459    let mint_address = MINT_ADDRESS;
460    let recipient_address = get_associated_token_address(&signer, &MINT_ADDRESS);
461    let treasury_address = TREASURY_ADDRESS;
462    let treasury_tokens_address = treasury_tokens_address();
463    Instruction {
464        program_id: crate::ID,
465        accounts: vec![
466            AccountMeta::new(signer, true),
467            AccountMeta::new(mint_address, false),
468            AccountMeta::new(recipient_address, false),
469            AccountMeta::new(stake_address, false),
470            AccountMeta::new(treasury_address, false),
471            AccountMeta::new(treasury_tokens_address, false),
472            AccountMeta::new_readonly(system_program::ID, false),
473            AccountMeta::new_readonly(spl_token::ID, false),
474            AccountMeta::new_readonly(spl_associated_token_account::ID, false),
475        ],
476        data: ClaimYield {
477            amount: amount.to_le_bytes(),
478        }
479        .to_bytes(),
480    }
481}
482
483pub fn new_var(
484    signer: Pubkey,
485    provider: Pubkey,
486    id: u64,
487    commit: [u8; 32],
488    samples: u64,
489) -> Instruction {
490    let board_address = board_pda().0;
491    let config_address = config_pda().0;
492    let var_address = entropy_api::state::var_pda(board_address, id).0;
493    Instruction {
494        program_id: crate::ID,
495        accounts: vec![
496            AccountMeta::new(signer, true),
497            AccountMeta::new(board_address, false),
498            AccountMeta::new(config_address, false),
499            AccountMeta::new(provider, false),
500            AccountMeta::new(var_address, false),
501            AccountMeta::new_readonly(system_program::ID, false),
502            AccountMeta::new_readonly(entropy_api::ID, false),
503        ],
504        data: NewVar {
505            id: id.to_le_bytes(),
506            commit: commit,
507            samples: samples.to_le_bytes(),
508        }
509        .to_bytes(),
510    }
511}
512
513pub fn set_swap_program(signer: Pubkey, new_program: Pubkey) -> Instruction {
514    let config_address = config_pda().0;
515    Instruction {
516        program_id: crate::ID,
517        accounts: vec![
518            AccountMeta::new(signer, true),
519            AccountMeta::new(config_address, false),
520            AccountMeta::new_readonly(new_program, false),
521        ],
522        data: SetSwapProgram {}.to_bytes(),
523    }
524}
525
526pub fn set_var_address(signer: Pubkey, new_var_address: Pubkey) -> Instruction {
527    let board_address = board_pda().0;
528    let config_address = config_pda().0;
529    Instruction {
530        program_id: crate::ID,
531        accounts: vec![
532            AccountMeta::new(signer, true),
533            AccountMeta::new(board_address, false),
534            AccountMeta::new(config_address, false),
535            AccountMeta::new(new_var_address, false),
536        ],
537        data: SetVarAddress {}.to_bytes(),
538    }
539}
540
541// let [signer_info, authority_info, config_info, automation_info, system_program] = accounts
542
543pub fn migrate_automation(signer: Pubkey, authority: Pubkey) -> Instruction {
544    let config_address = config_pda().0;
545    let automation_address = automation_pda(authority).0;
546    Instruction {
547        program_id: crate::ID,
548        accounts: vec![
549            AccountMeta::new(signer, true),
550            AccountMeta::new(authority, false),
551            AccountMeta::new(config_address, false),
552            AccountMeta::new(automation_address, false),
553            AccountMeta::new_readonly(system_program::ID, false),
554        ],
555        data: MigrateAutomation {}.to_bytes(),
556    }
557}
558
559pub fn admin_execute(signer: Pubkey, ix_accounts: &[AccountMeta], ix_data: &[u8]) -> Instruction {
560    let config_address = config_pda().0;
561    let mint_address = MINT_ADDRESS;
562    let treasury_address = TREASURY_ADDRESS;
563    let treasury_ore_address = get_associated_token_address(&treasury_address, &MINT_ADDRESS);
564    let treasury_sol_address = get_associated_token_address(&treasury_address, &SOL_MINT);
565    let mut accounts = vec![
566        AccountMeta::new(signer, true),
567        AccountMeta::new_readonly(config_address, false),
568        AccountMeta::new(mint_address, false),
569        AccountMeta::new(treasury_address, false),
570        AccountMeta::new(treasury_ore_address, false),
571        AccountMeta::new(treasury_sol_address, false),
572    ];
573    for account in ix_accounts.iter() {
574        let mut acc_clone = account.clone();
575        acc_clone.is_signer = if acc_clone.pubkey == treasury_address {
576            false
577        } else {
578            acc_clone.is_signer
579        };
580        accounts.push(acc_clone);
581    }
582    let mut data = AdminExecute {}.to_bytes();
583    data.extend_from_slice(ix_data);
584    Instruction {
585        program_id: crate::ID,
586        accounts,
587        data,
588    }
589}
ore_api/sdk.rs

ore_api/
sdk.rs
