1use crate::prelude::*;
2use solana_program::pubkey::Pubkey;
3
4pub use solana_program::system_program::ID;
5
6#[derive(Debug, Clone)]
7pub struct System;
8
9impl anchor_lang::Id for System {
10 fn id() -> Pubkey {
11 ID
12 }
13}
14
15pub fn advance_nonce_account<'info>(
16 ctx: CpiContext<'_, '_, '_, 'info, AdvanceNonceAccount<'info>>,
17) -> Result<()> {
18 let ix = crate::solana_program::system_instruction::advance_nonce_account(
19 ctx.accounts.nonce.key,
20 ctx.accounts.authorized.key,
21 );
22 crate::solana_program::program::invoke_signed(
23 &ix,
24 &[
25 ctx.accounts.nonce,
26 ctx.accounts.recent_blockhashes,
27 ctx.accounts.authorized,
28 ],
29 ctx.signer_seeds,
30 )
31 .map_err(Into::into)
32}
33
34#[derive(Accounts)]
35pub struct AdvanceNonceAccount<'info> {
36 pub nonce: AccountInfo<'info>,
37 pub authorized: AccountInfo<'info>,
38 pub recent_blockhashes: AccountInfo<'info>,
39}
40
41pub fn allocate<'info>(
42 ctx: CpiContext<'_, '_, '_, 'info, Allocate<'info>>,
43 space: u64,
44) -> Result<()> {
45 let ix = crate::solana_program::system_instruction::allocate(
46 ctx.accounts.account_to_allocate.key,
47 space,
48 );
49 crate::solana_program::program::invoke_signed(
50 &ix,
51 &[ctx.accounts.account_to_allocate],
52 ctx.signer_seeds,
53 )
54 .map_err(Into::into)
55}
56
57#[derive(Accounts)]
58pub struct Allocate<'info> {
59 pub account_to_allocate: AccountInfo<'info>,
60}
61
62pub fn allocate_with_seed<'info>(
63 ctx: CpiContext<'_, '_, '_, 'info, AllocateWithSeed<'info>>,
64 seed: &str,
65 space: u64,
66 owner: &Pubkey,
67) -> Result<()> {
68 let ix = crate::solana_program::system_instruction::allocate_with_seed(
69 ctx.accounts.account_to_allocate.key,
70 ctx.accounts.base.key,
71 seed,
72 space,
73 owner,
74 );
75 crate::solana_program::program::invoke_signed(
76 &ix,
77 &[ctx.accounts.account_to_allocate, ctx.accounts.base],
78 ctx.signer_seeds,
79 )
80 .map_err(Into::into)
81}
82
83#[derive(Accounts)]
84pub struct AllocateWithSeed<'info> {
85 pub account_to_allocate: AccountInfo<'info>,
86 pub base: AccountInfo<'info>,
87}
88
89pub fn assign<'info>(
90 ctx: CpiContext<'_, '_, '_, 'info, Assign<'info>>,
91 owner: &Pubkey,
92) -> Result<()> {
93 let ix = crate::solana_program::system_instruction::assign(
94 ctx.accounts.account_to_assign.key,
95 owner,
96 );
97 crate::solana_program::program::invoke_signed(
98 &ix,
99 &[ctx.accounts.account_to_assign],
100 ctx.signer_seeds,
101 )
102 .map_err(Into::into)
103}
104
105#[derive(Accounts)]
106pub struct Assign<'info> {
107 pub account_to_assign: AccountInfo<'info>,
108}
109
110pub fn assign_with_seed<'info>(
111 ctx: CpiContext<'_, '_, '_, 'info, AssignWithSeed<'info>>,
112 seed: &str,
113 owner: &Pubkey,
114) -> Result<()> {
115 let ix = crate::solana_program::system_instruction::assign_with_seed(
116 ctx.accounts.account_to_assign.key,
117 ctx.accounts.base.key,
118 seed,
119 owner,
120 );
121 crate::solana_program::program::invoke_signed(
122 &ix,
123 &[ctx.accounts.account_to_assign, ctx.accounts.base],
124 ctx.signer_seeds,
125 )
126 .map_err(Into::into)
127}
128
129#[derive(Accounts)]
130pub struct AssignWithSeed<'info> {
131 pub account_to_assign: AccountInfo<'info>,
132 pub base: AccountInfo<'info>,
133}
134
135pub fn authorize_nonce_account<'info>(
136 ctx: CpiContext<'_, '_, '_, 'info, AuthorizeNonceAccount<'info>>,
137 new_authority: &Pubkey,
138) -> Result<()> {
139 let ix = crate::solana_program::system_instruction::authorize_nonce_account(
140 ctx.accounts.nonce.key,
141 ctx.accounts.authorized.key,
142 new_authority,
143 );
144 crate::solana_program::program::invoke_signed(
145 &ix,
146 &[ctx.accounts.nonce, ctx.accounts.authorized],
147 ctx.signer_seeds,
148 )
149 .map_err(Into::into)
150}
151
152#[derive(Accounts)]
153pub struct AuthorizeNonceAccount<'info> {
154 pub nonce: AccountInfo<'info>,
155 pub authorized: AccountInfo<'info>,
156}
157
158pub fn create_account<'info>(
159 ctx: CpiContext<'_, '_, '_, 'info, CreateAccount<'info>>,
160 lamports: u64,
161 space: u64,
162 owner: &Pubkey,
163) -> Result<()> {
164 let ix = crate::solana_program::system_instruction::create_account(
165 ctx.accounts.from.key,
166 ctx.accounts.to.key,
167 lamports,
168 space,
169 owner,
170 );
171 crate::solana_program::program::invoke_signed(
172 &ix,
173 &[ctx.accounts.from, ctx.accounts.to],
174 ctx.signer_seeds,
175 )
176 .map_err(Into::into)
177}
178
179#[derive(Accounts)]
180pub struct CreateAccount<'info> {
181 pub from: AccountInfo<'info>,
182 pub to: AccountInfo<'info>,
183}
184
185pub fn create_account_with_seed<'info>(
186 ctx: CpiContext<'_, '_, '_, 'info, CreateAccountWithSeed<'info>>,
187 seed: &str,
188 lamports: u64,
189 space: u64,
190 owner: &Pubkey,
191) -> Result<()> {
192 let ix = crate::solana_program::system_instruction::create_account_with_seed(
193 ctx.accounts.from.key,
194 ctx.accounts.to.key,
195 ctx.accounts.base.key,
196 seed,
197 lamports,
198 space,
199 owner,
200 );
201 crate::solana_program::program::invoke_signed(
202 &ix,
203 &[ctx.accounts.from, ctx.accounts.to, ctx.accounts.base],
204 ctx.signer_seeds,
205 )
206 .map_err(Into::into)
207}
208
209#[derive(Accounts)]
210pub struct CreateAccountWithSeed<'info> {
211 pub from: AccountInfo<'info>,
212 pub to: AccountInfo<'info>,
213 pub base: AccountInfo<'info>,
214}
215
216pub fn create_nonce_account<'info>(
217 ctx: CpiContext<'_, '_, '_, 'info, CreateNonceAccount<'info>>,
218 lamports: u64,
219 authority: &Pubkey,
220) -> Result<()> {
221 let ixs = crate::solana_program::system_instruction::create_nonce_account(
222 ctx.accounts.from.key,
223 ctx.accounts.nonce.key,
224 authority,
225 lamports,
226 );
227 crate::solana_program::program::invoke_signed(
228 &ixs[0],
229 &[ctx.accounts.from, ctx.accounts.nonce.clone()],
230 ctx.signer_seeds,
231 )?;
232
233 crate::solana_program::program::invoke_signed(
234 &ixs[1],
235 &[
236 ctx.accounts.nonce,
237 ctx.accounts.recent_blockhashes,
238 ctx.accounts.rent,
239 ],
240 ctx.signer_seeds,
241 )
242 .map_err(Into::into)
243}
244
245#[derive(Accounts)]
246pub struct CreateNonceAccount<'info> {
247 pub from: AccountInfo<'info>,
248 pub nonce: AccountInfo<'info>,
249 pub recent_blockhashes: AccountInfo<'info>,
250 pub rent: AccountInfo<'info>,
251}
252
253pub fn create_nonce_account_with_seed<'info>(
254 ctx: CpiContext<'_, '_, '_, 'info, CreateNonceAccountWithSeed<'info>>,
255 lamports: u64,
256 seed: &str,
257 authority: &Pubkey,
258) -> Result<()> {
259 let ixs = crate::solana_program::system_instruction::create_nonce_account_with_seed(
260 ctx.accounts.from.key,
261 ctx.accounts.nonce.key,
262 ctx.accounts.base.key,
263 seed,
264 authority,
265 lamports,
266 );
267 crate::solana_program::program::invoke_signed(
268 &ixs[0],
269 &[
270 ctx.accounts.from,
271 ctx.accounts.nonce.clone(),
272 ctx.accounts.base,
273 ],
274 ctx.signer_seeds,
275 )?;
276
277 crate::solana_program::program::invoke_signed(
278 &ixs[1],
279 &[
280 ctx.accounts.nonce,
281 ctx.accounts.recent_blockhashes,
282 ctx.accounts.rent,
283 ],
284 ctx.signer_seeds,
285 )
286 .map_err(Into::into)
287}
288
289#[derive(Accounts)]
290pub struct CreateNonceAccountWithSeed<'info> {
291 pub from: AccountInfo<'info>,
292 pub nonce: AccountInfo<'info>,
293 pub base: AccountInfo<'info>,
294 pub recent_blockhashes: AccountInfo<'info>,
295 pub rent: AccountInfo<'info>,
296}
297
298pub fn transfer<'info>(
299 ctx: CpiContext<'_, '_, '_, 'info, Transfer<'info>>,
300 lamports: u64,
301) -> Result<()> {
302 let ix = crate::solana_program::system_instruction::transfer(
303 ctx.accounts.from.key,
304 ctx.accounts.to.key,
305 lamports,
306 );
307 crate::solana_program::program::invoke_signed(
308 &ix,
309 &[ctx.accounts.from, ctx.accounts.to],
310 ctx.signer_seeds,
311 )
312 .map_err(Into::into)
313}
314
315#[derive(Accounts)]
316pub struct Transfer<'info> {
317 pub from: AccountInfo<'info>,
318 pub to: AccountInfo<'info>,
319}
320
321pub fn transfer_with_seed<'info>(
322 ctx: CpiContext<'_, '_, '_, 'info, TransferWithSeed<'info>>,
323 from_seed: String,
324 from_owner: &Pubkey,
325 lamports: u64,
326) -> Result<()> {
327 let ix = crate::solana_program::system_instruction::transfer_with_seed(
328 ctx.accounts.from.key,
329 ctx.accounts.base.key,
330 from_seed,
331 from_owner,
332 ctx.accounts.to.key,
333 lamports,
334 );
335 crate::solana_program::program::invoke_signed(
336 &ix,
337 &[ctx.accounts.from, ctx.accounts.base, ctx.accounts.to],
338 ctx.signer_seeds,
339 )
340 .map_err(Into::into)
341}
342
343#[derive(Accounts)]
344pub struct TransferWithSeed<'info> {
345 pub from: AccountInfo<'info>,
346 pub base: AccountInfo<'info>,
347 pub to: AccountInfo<'info>,
348}
349
350pub fn withdraw_nonce_account<'info>(
351 ctx: CpiContext<'_, '_, '_, 'info, WithdrawNonceAccount<'info>>,
352 lamports: u64,
353) -> Result<()> {
354 let ix = crate::solana_program::system_instruction::withdraw_nonce_account(
355 ctx.accounts.nonce.key,
356 ctx.accounts.authorized.key,
357 ctx.accounts.to.key,
358 lamports,
359 );
360 crate::solana_program::program::invoke_signed(
361 &ix,
362 &[
363 ctx.accounts.nonce,
364 ctx.accounts.to,
365 ctx.accounts.recent_blockhashes,
366 ctx.accounts.rent,
367 ctx.accounts.authorized,
368 ],
369 ctx.signer_seeds,
370 )
371 .map_err(Into::into)
372}
373
374#[derive(Accounts)]
375pub struct WithdrawNonceAccount<'info> {
376 pub nonce: AccountInfo<'info>,
377 pub to: AccountInfo<'info>,
378 pub recent_blockhashes: AccountInfo<'info>,
379 pub rent: AccountInfo<'info>,
380 pub authorized: AccountInfo<'info>,
381}