volt_abi/
contexts.rs

1use std::collections::{BTreeMap, BTreeSet};
2
3use anchor_lang::prelude::*;
4use anchor_spl::token::{Mint, Token, TokenAccount};
5
6use crate::{
7    ExtraVoltData, FriktionEpochInfo, PendingDeposit, PendingWithdrawal,
8    PrincipalProtectionVaultV1, Round, VoltVault,
9};
10
11#[derive(Accounts, Clone)]
12pub struct EntropyBaseAccountsWithoutBanks<'info> {
13    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
14
15    /// CHECK: skip, checked by macro
16    #[account(address=extra_volt_data.entropy_program_id)]
17    pub program: AccountInfo<'info>,
18    /// CHECK: skip, checked by macro
19    #[account( address=extra_volt_data.entropy_group)]
20    pub group: AccountInfo<'info>,
21
22    /// CHECK: skip, checked by macro
23    #[account(address=extra_volt_data.entropy_cache)]
24    pub cache: AccountInfo<'info>,
25
26    /// CHECK: skip, checked by macro
27    #[account(address=extra_volt_data.entropy_account)]
28    pub account: AccountInfo<'info>,
29}
30
31impl<'info> EntropyBaseAccountsWithoutBanks<'info> {
32    pub fn from_remaining_accounts(accounts: &mut &[AccountInfo<'info>]) -> Result<Self> {
33        EntropyBaseAccountsWithoutBanks::try_accounts(
34            &crate::id(),
35            accounts,
36            &vec![] as &[u8],
37            &mut BTreeMap::<String, u8>::new(),
38            &mut BTreeSet::<Pubkey>::new(),
39        )
40    }
41}
42
43#[derive(Accounts, Clone)]
44pub struct PrincipalProtectionContextAccounts<'info> {
45    pub volt_vault: Box<Account<'info, VoltVault>>,
46
47    #[account(
48        seeds = [
49          &volt_vault.key().to_bytes()[..],
50          b"protectionVault"
51      ],
52      bump
53    )]
54    pub pp_vault: Box<Account<'info, PrincipalProtectionVaultV1>>,
55
56    #[account(mut, address=pp_vault.get_deposit_tracking_account())]
57    /// CHECK: checked by macro
58    pub deposit_tracking_account: AccountInfo<'info>,
59
60    #[account(mut, address=pp_vault.get_lending_shares_pool())]
61    /// CHECK: checked by macro
62    pub lending_shares_pool: Box<Account<'info, TokenAccount>>,
63
64    #[account(mut, address=pp_vault.get_primary_lending_vault_pk())]
65    /// CHECK: checked by macro
66    pub lending_vault: AccountInfo<'info>,
67
68    #[account(address=pp_vault.get_primary_lending_vault_program_id(), executable)]
69    /// CHECK: checked by macro
70    pub lending_vault_program: AccountInfo<'info>,
71}
72
73impl<'info> PrincipalProtectionContextAccounts<'info> {
74    pub fn from_remaining_accounts(
75        accounts: &mut &[AccountInfo<'info>],
76    ) -> Result<PrincipalProtectionContextAccounts<'info>> {
77        PrincipalProtectionContextAccounts::try_accounts(
78            &crate::id(),
79            accounts,
80            &vec![] as &[u8],
81            &mut BTreeMap::<String, u8>::new(),
82            &mut BTreeSet::<Pubkey>::new(),
83        )
84    }
85}
86
87#[derive(Accounts)]
88#[instruction(
89    deposit_amount: u64,
90)]
91pub struct Deposit<'info> {
92    #[account(mut)]
93    pub payer_authority: Signer<'info>,
94
95    #[account(signer)]
96    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
97    pub non_payer_authority: AccountInfo<'info>,
98
99    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
100    pub authority_check: AccountInfo<'info>,
101
102    #[account(mut, address=volt_vault.vault_mint)]
103    pub vault_mint: Box<Account<'info, Mint>>,
104
105    #[account(mut)]
106    pub volt_vault: Box<Account<'info, VoltVault>>,
107
108    #[account(address=volt_vault.vault_authority)]
109    /// CHECK: skip, checked by macro
110    pub vault_authority: AccountInfo<'info>,
111
112    #[account(
113        seeds = [
114            &volt_vault.key().to_bytes()[..],
115            b"extraVoltData"
116        ],
117        bump,
118      )]
119    // main data struct. stores any persistent metadata about the volt and its strategy
120    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
121
122    #[account(address=extra_volt_data.whitelist)]
123    /// CHECK: skip, checked by macro
124    /// NOTE: this is a vector of pubkeys that can interact with the volt, NOT related to the whitelist MM token
125    pub whitelist: AccountInfo<'info>,
126
127    #[account(mut, address=volt_vault.deposit_pool)]
128    pub deposit_pool: Box<Account<'info, TokenAccount>>,
129
130    /// CHECK: skip, checked by macro
131    #[account(address=volt_vault.writer_token_pool)]
132    pub writer_token_pool: AccountInfo<'info>,
133
134    // no token::authority check here so that it can be either payer_authority or non_payer_authority
135    #[account(mut)]
136    // user controlled token account w/ mint == vault mint
137    pub user_vault_tokens: Box<Account<'info, TokenAccount>>,
138
139    // no token::authority check here so that it can be either payer_authority or non_payer_authority
140    #[account(mut)]
141    // user controlled token account w/ mint == underlying mint
142    pub user_ul_tokens: Box<Account<'info, TokenAccount>>,
143
144    #[account(mut,
145        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
146        bump)]
147    pub round_info: Box<Account<'info, Round>>,
148
149    #[account(mut,
150        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundVoltTokens"],
151        bump)]
152    pub round_volt_tokens: Box<Account<'info, TokenAccount>>,
153
154    #[account(mut,
155        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundUnderlyingTokens"],
156        bump)]
157    pub round_underlying_tokens: Box<Account<'info, TokenAccount>>,
158
159    #[account(init_if_needed,
160        space=PendingDeposit::LEN + 8,
161        seeds = [volt_vault.key().as_ref(), authority_check.key().as_ref() ,b"pendingDeposit"],
162        bump,
163        payer = payer_authority)]
164    pub pending_deposit_info: Box<Account<'info, PendingDeposit>>,
165
166    #[account(
167        mut,
168        seeds = [&volt_vault.key().to_bytes()[..], (volt_vault.round_number).to_le_bytes().as_ref() ,b"epochInfo"],
169        bump,
170    )]
171    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
172
173    pub system_program: Program<'info, System>,
174    pub token_program: Program<'info, Token>,
175}
176#[derive(Accounts)]
177#[instruction(
178    withdraw_amount: u64,
179)]
180pub struct Withdraw<'info> {
181    #[account(mut)]
182    pub payer_authority: Signer<'info>,
183
184    #[account(signer)]
185    /// CHECK: skip, attributes may change depending on use case. validation happens in handler,
186    /// if is authority on token accounts (aka === authority_check), should be a signer
187    pub non_payer_authority: AccountInfo<'info>,
188
189    /// CHECK: skip, attributes may change depending on use case. validation happens in handler. hoowever,
190    /// should be equal to 1 of authority or non_payer_authority
191    pub authority_check: AccountInfo<'info>,
192
193    #[account(mut)]
194    pub vault_mint: Box<Account<'info, Mint>>,
195
196    pub volt_vault: Box<Account<'info, VoltVault>>,
197
198    #[account(
199        seeds = [
200            &volt_vault.key().to_bytes()[..],
201            b"extraVoltData"
202        ],
203        bump,
204    )]
205    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
206
207    /// CHECK: skip, checked by macro
208    #[account(address=volt_vault.vault_authority)]
209    pub vault_authority: AccountInfo<'info>,
210
211    #[account(address=extra_volt_data.whitelist)]
212    /// CHECK: skip, checked by macro
213    pub whitelist: AccountInfo<'info>,
214
215    #[account(mut, address=volt_vault.deposit_pool)]
216    pub deposit_pool: Box<Account<'info, TokenAccount>>,
217
218    // user token accounts
219    #[account(mut)]
220    pub underlying_token_destination: Box<Account<'info, TokenAccount>>,
221
222    #[account(mut)]
223    pub vault_token_source: Box<Account<'info, TokenAccount>>,
224
225    // round accounts
226    #[account(mut,
227        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
228        bump)]
229    pub round_info: Box<Account<'info, Round>>,
230
231    #[account(mut,
232        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundUnderlyingTokens"],
233        bump)]
234    pub round_underlying_tokens: Box<Account<'info, TokenAccount>>,
235
236    #[account(init_if_needed,
237        space=PendingWithdrawal::LEN + 8,
238        seeds = [volt_vault.key().as_ref(), authority_check.key().as_ref(), b"pendingWithdrawal"],
239        bump,
240        payer=payer_authority
241    )]
242    pub pending_withdrawal_info: Box<Account<'info, PendingWithdrawal>>,
243
244    #[account(mut,
245        seeds = [&volt_vault.key().to_bytes()[..], (volt_vault.round_number).to_le_bytes().as_ref() ,b"epochInfo"],
246        bump,
247    )]
248    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
249
250    #[account(mut)]
251    pub fee_acct: Box<Account<'info, TokenAccount>>,
252
253    // system accounts
254    pub system_program: Program<'info, System>,
255    pub token_program: Program<'info, Token>,
256    rent: Sysvar<'info, Rent>,
257}
258
259#[derive(Accounts)]
260#[instruction(
261    deposit_amount: u64,
262    do_sol_transfer: bool,
263)]
264pub struct DepositWithClaim<'info> {
265    #[account(mut)]
266    pub payer_authority: Signer<'info>,
267
268    #[account(signer)]
269    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
270    pub non_payer_authority: AccountInfo<'info>,
271
272    #[account()]
273    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
274    pub sol_transfer_authority: AccountInfo<'info>,
275
276    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
277    #[account()]
278    pub authority_check: AccountInfo<'info>,
279
280    #[account(mut, address=volt_vault.vault_mint)]
281    pub vault_mint: Box<Account<'info, Mint>>,
282
283    #[account(mut)]
284    pub volt_vault: Box<Account<'info, VoltVault>>,
285
286    /// CHECK: skip, checked by macro
287    #[account(address=volt_vault.vault_authority)]
288    pub vault_authority: AccountInfo<'info>,
289
290    #[account(
291        seeds = [
292            &volt_vault.key().to_bytes()[..],
293            b"extraVoltData"
294        ],
295        bump,
296      )]
297    // main data struct. stores any persistent metadata about the volt and its strategy
298    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
299
300    #[account(mut, address=volt_vault.deposit_pool)]
301    pub deposit_pool: Box<Account<'info, TokenAccount>>,
302
303    /// CHECK: skip, checked by macro
304    #[account(address=volt_vault.writer_token_pool)]
305    pub writer_token_pool: AccountInfo<'info>,
306
307    #[account(mut)]
308    // user controlled token account w/ mint == vault mint
309    pub vault_token_destination: Box<Account<'info, TokenAccount>>,
310
311    #[account(mut)]
312    // user controlled token account w/ mint == underlying mint
313    pub underlying_token_source: Box<Account<'info, TokenAccount>>,
314
315    #[account(mut,
316        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
317        bump)]
318    pub round_info: Box<Account<'info, Round>>,
319
320    #[account(mut,
321        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundUnderlyingTokens"],
322        bump)]
323    pub round_underlying_tokens: Box<Account<'info, TokenAccount>>,
324
325    #[account(init_if_needed,
326        space=PendingDeposit::LEN + 8,
327        seeds = [volt_vault.key().as_ref(), authority_check.key().as_ref() ,b"pendingDeposit"],
328        bump,
329        payer = payer_authority)]
330    pub pending_deposit_info: Box<Account<'info, PendingDeposit>>,
331
332    /// CHECK: skip, checked by PDA, can't require an object because may not exist (if round number is 0)
333    #[account(mut,
334        seeds = [volt_vault.key().as_ref(), pending_deposit_info.round_number.to_le_bytes().as_ref() , b"roundInfo"],
335        bump)]
336    pub pending_deposit_round_info: AccountInfo<'info>,
337
338    /// CHECK: skip, checked by PDA, can't require an object because may not exist (if round number is 0)
339    #[account(mut,
340        seeds = [volt_vault.key().as_ref(), pending_deposit_info.round_number.to_le_bytes().as_ref() , b"roundVoltTokens"],
341        bump)]
342    pub pending_deposit_round_volt_tokens: AccountInfo<'info>,
343
344    /// CHECK: skip, checked by PDA, can't require an object because may not exist (if round number is 0)
345    #[account(mut,
346            seeds = [volt_vault.key().as_ref(), pending_deposit_info.round_number.to_le_bytes().as_ref() , b"roundUnderlyingTokens"],
347            bump)]
348    pub pending_deposit_round_underlying_tokens: AccountInfo<'info>,
349
350    #[account(mut,
351        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"epochInfo"],
352        bump)]
353    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
354
355    pub system_program: Program<'info, System>,
356    pub token_program: Program<'info, Token>,
357}
358
359#[derive(Accounts)]
360#[instruction(
361    withdraw_amount: u64,
362)]
363pub struct WithdrawWithClaim<'info> {
364    #[account(mut)]
365    pub payer_authority: Signer<'info>,
366
367    #[account(signer)]
368    /// CHECK: skip, attributes may change depending on use case. validation happens in handler
369    pub non_payer_authority: AccountInfo<'info>,
370
371    /// CHECK: skip, attributes may change depending on use case. validation happens in handler. hoowever,
372    /// should be equal to 1 of authority or non_payer_authority
373    pub authority_check: AccountInfo<'info>,
374
375    #[account(mut)]
376    pub vault_mint: Box<Account<'info, Mint>>,
377
378    #[account(mut)]
379    pub volt_vault: Box<Account<'info, VoltVault>>,
380
381    /// CHECK: skip, checked by macro
382    #[account(address=volt_vault.vault_authority)]
383    pub vault_authority: AccountInfo<'info>,
384
385    #[account(
386        seeds = [
387            &volt_vault.key().to_bytes()[..],
388            b"extraVoltData"
389        ],
390        bump,
391      )]
392    // main data struct. stores any persistent metadata about the volt and its strategy
393    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
394
395    #[account(mut,address=volt_vault.deposit_pool)]
396    pub deposit_pool: Box<Account<'info, TokenAccount>>,
397
398    // user token accounts
399    #[account(mut)]
400    pub underlying_token_destination: Box<Account<'info, TokenAccount>>,
401
402    #[account(mut)]
403    pub vault_token_source: Box<Account<'info, TokenAccount>>,
404
405    // round accounts
406    #[account(mut,
407        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
408        bump)]
409    pub round_info: Box<Account<'info, Round>>,
410
411    #[account(mut,
412        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundUnderlyingTokens"],
413        bump)]
414    pub round_underlying_tokens: Box<Account<'info, TokenAccount>>,
415
416    #[account(init_if_needed,
417        space=PendingWithdrawal::LEN + 8,
418        seeds = [volt_vault.key().as_ref(), authority_check.key().as_ref(), b"pendingWithdrawal"],
419        bump,
420        payer = payer_authority)]
421    pub pending_withdrawal_info: Box<Account<'info, PendingWithdrawal>>,
422
423    /// CHECK: skip, checked by PDA. may be a non-existent account if there is no pendign withdrawal to process
424    #[account(mut,
425      seeds = [volt_vault.key().as_ref(), pending_withdrawal_info.round_number.to_le_bytes().as_ref() , b"roundInfo"],
426      bump)]
427    pub pending_withdrawal_round_info: AccountInfo<'info>,
428
429    /// CHECK: skip, checked by PDA. may be a non-existent account if there is no pendign withdrawal to process
430    #[account(mut,
431        seeds = [volt_vault.key().as_ref(), pending_withdrawal_info.round_number.to_le_bytes().as_ref() , b"roundUlPending"],
432    bump)]
433    pub pending_withdrawal_round_underlying_tokens_for_pws: AccountInfo<'info>,
434
435    #[account(mut,
436        seeds = [&volt_vault.key().to_bytes()[..], (volt_vault.round_number).to_le_bytes().as_ref() ,b"epochInfo"],
437        bump,
438    )]
439    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
440
441    #[account(mut)]
442    pub fee_acct: Box<Account<'info, TokenAccount>>,
443
444    // system accounts
445    pub system_program: Program<'info, System>,
446    pub token_program: Program<'info, Token>,
447    rent: Sysvar<'info, Rent>,
448}
449
450#[derive(Accounts)]
451pub struct ClaimPendingDeposit<'info> {
452    pub authority: Signer<'info>,
453
454    pub volt_vault: Box<Account<'info, VoltVault>>,
455
456    #[account(
457        seeds = [
458            &volt_vault.key().to_bytes()[..],
459            b"extraVoltData"
460        ],
461        bump,
462      )]
463    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
464
465    /// CHECK: skip, checked by macro
466    #[account(address=volt_vault.vault_authority)]
467    pub vault_authority: AccountInfo<'info>,
468
469    #[account(mut, token::authority=authority.key())]
470    // user controlled token account w/ mint == vault mint
471    pub user_vault_tokens: Box<Account<'info, TokenAccount>>,
472
473    #[account(mut,
474        seeds = [volt_vault.key().as_ref(), pending_deposit_info.round_number.to_le_bytes().as_ref() , b"roundInfo"],
475        bump)]
476    pub pending_deposit_round_info: Box<Account<'info, Round>>,
477
478    #[account(mut,
479        seeds = [volt_vault.key().as_ref(), pending_deposit_info.round_number.to_le_bytes().as_ref() , b"roundVoltTokens"],
480        bump)]
481    pub pending_deposit_round_volt_tokens: Box<Account<'info, TokenAccount>>,
482
483    #[account(mut,
484        seeds = [volt_vault.key().as_ref(), authority.key().as_ref(), b"pendingDeposit"],
485        bump)]
486    pub pending_deposit_info: Box<Account<'info, PendingDeposit>>,
487
488    pub system_program: Program<'info, System>,
489    pub token_program: Program<'info, Token>,
490}
491
492#[derive(Accounts)]
493pub struct ClaimPendingWithdrawal<'info> {
494    pub authority: Signer<'info>,
495
496    pub volt_vault: Box<Account<'info, VoltVault>>,
497
498    #[account(
499        seeds = [
500            &volt_vault.key().to_bytes()[..],
501            b"extraVoltData"
502        ],
503        bump,
504      )]
505    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
506
507    /// CHECK: skip, checked by macro
508    #[account(address=volt_vault.vault_authority)]
509    pub vault_authority: AccountInfo<'info>,
510
511    #[account(address=volt_vault.vault_mint)]
512    pub vault_mint: Box<Account<'info, Mint>>,
513
514    // user underlying token account
515    #[account(mut, token::authority=authority.key())]
516    pub underlying_token_destination: Box<Account<'info, TokenAccount>>,
517
518    #[account(mut,
519        seeds = [volt_vault.key().as_ref(), pending_withdrawal_info.round_number.to_le_bytes().as_ref() , b"roundInfo"],
520        bump)]
521    pub pending_withdrawal_round_info: Box<Account<'info, Round>>,
522
523    #[account(mut,
524        seeds = [volt_vault.key().as_ref(), authority.key().as_ref(), b"pendingWithdrawal"],
525        bump,
526    )]
527    pub pending_withdrawal_info: Box<Account<'info, PendingWithdrawal>>,
528
529    #[account(mut,
530        seeds = [volt_vault.key().as_ref(), (pending_withdrawal_info.round_number).to_le_bytes().as_ref() ,b"roundUlPending"],
531        bump,
532    )]
533    pub round_underlying_tokens_for_pending_withdrawals: Box<Account<'info, TokenAccount>>,
534
535    pub system_program: Program<'info, System>,
536    pub token_program: Program<'info, Token>,
537}
538
539#[derive(Accounts)]
540pub struct CancelPendingDeposit<'info> {
541    pub authority: Signer<'info>,
542
543    pub volt_vault: Box<Account<'info, VoltVault>>,
544
545    #[account(
546        seeds = [
547            &volt_vault.key().to_bytes()[..],
548            b"extraVoltData"
549        ],
550        bump,
551      )]
552    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
553
554    #[account(address=volt_vault.vault_authority)]
555    /// CHECK: skip, checked by macro
556    pub vault_authority: AccountInfo<'info>,
557
558    // user token accounts
559    #[account(mut)]
560    pub underlying_token_destination: Account<'info, TokenAccount>,
561
562    // round accounts
563    #[account(mut,
564        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
565        bump)]
566    pub round_info: Box<Account<'info, Round>>,
567
568    #[account(mut,
569      seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundUnderlyingTokens"],
570      bump)]
571    pub round_underlying_tokens: Box<Account<'info, TokenAccount>>,
572
573    #[account(mut,
574        seeds = [volt_vault.key().as_ref(), authority.key().as_ref(), b"pendingDeposit"],
575        bump)]
576    pub pending_deposit_info: Box<Account<'info, PendingDeposit>>,
577
578    #[account(mut,
579        seeds = [&volt_vault.key().to_bytes()[..], (volt_vault.round_number).to_le_bytes().as_ref() ,b"epochInfo"],
580        bump,
581    )]
582    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
583
584    pub system_program: Program<'info, System>,
585    pub token_program: Program<'info, Token>,
586}
587
588#[derive(Accounts)]
589pub struct CancelPendingWithdrawal<'info> {
590    pub authority: Signer<'info>,
591
592    #[account(mut)]
593    pub vault_mint: Account<'info, Mint>,
594
595    pub volt_vault: Box<Account<'info, VoltVault>>,
596
597    #[account(
598        seeds = [
599            &volt_vault.key().to_bytes()[..],
600            b"extraVoltData"
601        ],
602        bump,
603      )]
604    pub extra_volt_data: Box<Account<'info, ExtraVoltData>>,
605
606    #[account(address=volt_vault.vault_authority)]
607    /// CHECK: skip, checked by macro
608    pub vault_authority: AccountInfo<'info>,
609
610    #[account(mut)]
611    pub vault_token_destination: Account<'info, TokenAccount>,
612
613    // round accounts
614    #[account(mut,
615        seeds = [volt_vault.key().as_ref(), volt_vault.round_number.to_le_bytes().as_ref() ,b"roundInfo"],
616        bump)]
617    pub round_info: Box<Account<'info, Round>>,
618
619    #[account(mut,
620        seeds = [volt_vault.key().as_ref(), authority.key().as_ref(), b"pendingWithdrawal"],
621        bump)]
622    pub pending_withdrawal_info: Box<Account<'info, PendingWithdrawal>>,
623
624    #[account(mut,
625        seeds = [&volt_vault.key().to_bytes()[..], (volt_vault.round_number).to_le_bytes().as_ref() ,b"epochInfo"],
626        bump,
627    )]
628    pub epoch_info: Box<Account<'info, FriktionEpochInfo>>,
629
630    // system accounts
631    pub system_program: Program<'info, System>,
632    pub token_program: Program<'info, Token>,
633}
volt_abi/contexts.rs

volt_abi/
contexts.rs
