satrush_client/generated/instructions/
create_grubstake_airdrop.rs

1//! This code was AUTOGENERATED using the codama library.
2//! Please DO NOT EDIT THIS FILE, instead use visitors
3//! to add features, then rerun codama to update it.
4//!
5//! <https://github.com/codama-idl/codama>
6//!
7
8use solana_address::Address;
9use borsh::BorshSerialize;
10use borsh::BorshDeserialize;
11
12pub const CREATE_GRUBSTAKE_AIRDROP_DISCRIMINATOR: [u8; 8] = [138, 150, 45, 171, 153, 87, 36, 30];
13
14/// Accounts.
15#[derive(Debug)]
16pub struct CreateGrubstakeAirdrop {
17      
18              
19          pub authority: solana_address::Address,
20          
21              
22          pub satrush_config: solana_address::Address,
23                /// The airdrop being issued; a fresh keypair signed by the issuer's client.
24
25    
26              
27          pub grubstake_airdrop: solana_address::Address,
28                /// The treasury: its unreserved grubstake backs the airdrop.
29
30    
31              
32          pub treasury: solana_address::Address,
33          
34              
35          pub system_program: solana_address::Address,
36      }
37
38impl CreateGrubstakeAirdrop {
39  pub fn instruction(&self, args: CreateGrubstakeAirdropInstructionArgs) -> solana_instruction::Instruction {
40    self.instruction_with_remaining_accounts(args, &[])
41  }
42  #[allow(clippy::arithmetic_side_effects)]
43  #[allow(clippy::vec_init_then_push)]
44  pub fn instruction_with_remaining_accounts(&self, args: CreateGrubstakeAirdropInstructionArgs, remaining_accounts: &[solana_instruction::AccountMeta]) -> solana_instruction::Instruction {
45    let mut accounts = Vec::with_capacity(5+ remaining_accounts.len());
46                            accounts.push(solana_instruction::AccountMeta::new(
47            self.authority,
48            true
49          ));
50                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
51            self.satrush_config,
52            false
53          ));
54                                          accounts.push(solana_instruction::AccountMeta::new(
55            self.grubstake_airdrop,
56            true
57          ));
58                                          accounts.push(solana_instruction::AccountMeta::new(
59            self.treasury,
60            false
61          ));
62                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
63            self.system_program,
64            false
65          ));
66                      accounts.extend_from_slice(remaining_accounts);
67    let mut data = CreateGrubstakeAirdropInstructionData::new().try_to_vec().unwrap();
68          let mut args = args.try_to_vec().unwrap();
69      data.append(&mut args);
70    
71    solana_instruction::Instruction {
72      program_id: crate::SATRUSH_ID,
73      accounts,
74      data,
75    }
76  }
77}
78
79#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
80 pub struct CreateGrubstakeAirdropInstructionData {
81            discriminator: [u8; 8],
82                        }
83
84impl CreateGrubstakeAirdropInstructionData {
85  pub fn new() -> Self {
86    Self {
87                        discriminator: [138, 150, 45, 171, 153, 87, 36, 30],
88                                                            }
89  }
90
91    pub(crate) fn try_to_vec(&self) -> Result<Vec<u8>, std::io::Error> {
92    borsh::to_vec(self)
93  }
94  }
95
96impl Default for CreateGrubstakeAirdropInstructionData {
97  fn default() -> Self {
98    Self::new()
99  }
100}
101
102#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
103 pub struct CreateGrubstakeAirdropInstructionArgs {
104                  pub airdrop_authority: Address,
105                pub usd_amount: u64,
106                pub expiration_timestamp: i64,
107      }
108
109impl CreateGrubstakeAirdropInstructionArgs {
110  pub(crate) fn try_to_vec(&self) -> Result<Vec<u8>, std::io::Error> {
111    borsh::to_vec(self)
112  }
113}
114
115
116/// Instruction builder for `CreateGrubstakeAirdrop`.
117///
118/// ### Accounts:
119///
120                      ///   0. `[writable, signer]` authority
121          ///   1. `[]` satrush_config
122                      ///   2. `[writable, signer]` grubstake_airdrop
123                ///   3. `[writable]` treasury
124                ///   4. `[optional]` system_program (default to `11111111111111111111111111111111`)
125#[derive(Clone, Debug, Default)]
126pub struct CreateGrubstakeAirdropBuilder {
127            authority: Option<solana_address::Address>,
128                satrush_config: Option<solana_address::Address>,
129                grubstake_airdrop: Option<solana_address::Address>,
130                treasury: Option<solana_address::Address>,
131                system_program: Option<solana_address::Address>,
132                        airdrop_authority: Option<Address>,
133                usd_amount: Option<u64>,
134                expiration_timestamp: Option<i64>,
135        __remaining_accounts: Vec<solana_instruction::AccountMeta>,
136}
137
138impl CreateGrubstakeAirdropBuilder {
139  pub fn new() -> Self {
140    Self::default()
141  }
142            #[inline(always)]
143    pub fn authority(&mut self, authority: solana_address::Address) -> &mut Self {
144                        self.authority = Some(authority);
145                    self
146    }
147            #[inline(always)]
148    pub fn satrush_config(&mut self, satrush_config: solana_address::Address) -> &mut Self {
149                        self.satrush_config = Some(satrush_config);
150                    self
151    }
152            /// The airdrop being issued; a fresh keypair signed by the issuer's client.
153#[inline(always)]
154    pub fn grubstake_airdrop(&mut self, grubstake_airdrop: solana_address::Address) -> &mut Self {
155                        self.grubstake_airdrop = Some(grubstake_airdrop);
156                    self
157    }
158            /// The treasury: its unreserved grubstake backs the airdrop.
159#[inline(always)]
160    pub fn treasury(&mut self, treasury: solana_address::Address) -> &mut Self {
161                        self.treasury = Some(treasury);
162                    self
163    }
164            /// `[optional account, default to '11111111111111111111111111111111']`
165#[inline(always)]
166    pub fn system_program(&mut self, system_program: solana_address::Address) -> &mut Self {
167                        self.system_program = Some(system_program);
168                    self
169    }
170                    #[inline(always)]
171      pub fn airdrop_authority(&mut self, airdrop_authority: Address) -> &mut Self {
172        self.airdrop_authority = Some(airdrop_authority);
173        self
174      }
175                #[inline(always)]
176      pub fn usd_amount(&mut self, usd_amount: u64) -> &mut Self {
177        self.usd_amount = Some(usd_amount);
178        self
179      }
180                #[inline(always)]
181      pub fn expiration_timestamp(&mut self, expiration_timestamp: i64) -> &mut Self {
182        self.expiration_timestamp = Some(expiration_timestamp);
183        self
184      }
185        /// Add an additional account to the instruction.
186  #[inline(always)]
187  pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
188    self.__remaining_accounts.push(account);
189    self
190  }
191  /// Add additional accounts to the instruction.
192  #[inline(always)]
193  pub fn add_remaining_accounts(&mut self, accounts: &[solana_instruction::AccountMeta]) -> &mut Self {
194    self.__remaining_accounts.extend_from_slice(accounts);
195    self
196  }
197  #[allow(clippy::clone_on_copy)]
198  pub fn instruction(&self) -> solana_instruction::Instruction {
199    let accounts = CreateGrubstakeAirdrop {
200                              authority: self.authority.expect("authority is not set"),
201                                        satrush_config: self.satrush_config.expect("satrush_config is not set"),
202                                        grubstake_airdrop: self.grubstake_airdrop.expect("grubstake_airdrop is not set"),
203                                        treasury: self.treasury.expect("treasury is not set"),
204                                        system_program: self.system_program.unwrap_or(solana_address::address!("11111111111111111111111111111111")),
205                      };
206          let args = CreateGrubstakeAirdropInstructionArgs {
207                                                              airdrop_authority: self.airdrop_authority.clone().expect("airdrop_authority is not set"),
208                                                                  usd_amount: self.usd_amount.clone().expect("usd_amount is not set"),
209                                                                  expiration_timestamp: self.expiration_timestamp.clone().expect("expiration_timestamp is not set"),
210                                    };
211    
212    accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
213  }
214}
215
216  /// `create_grubstake_airdrop` CPI accounts.
217  pub struct CreateGrubstakeAirdropCpiAccounts<'a, 'b> {
218          
219                    
220              pub authority: &'b solana_account_info::AccountInfo<'a>,
221                
222                    
223              pub satrush_config: &'b solana_account_info::AccountInfo<'a>,
224                        /// The airdrop being issued; a fresh keypair signed by the issuer's client.
225
226      
227                    
228              pub grubstake_airdrop: &'b solana_account_info::AccountInfo<'a>,
229                        /// The treasury: its unreserved grubstake backs the airdrop.
230
231      
232                    
233              pub treasury: &'b solana_account_info::AccountInfo<'a>,
234                
235                    
236              pub system_program: &'b solana_account_info::AccountInfo<'a>,
237            }
238
239/// `create_grubstake_airdrop` CPI instruction.
240pub struct CreateGrubstakeAirdropCpi<'a, 'b> {
241  /// The program to invoke.
242  pub __program: &'b solana_account_info::AccountInfo<'a>,
243      
244              
245          pub authority: &'b solana_account_info::AccountInfo<'a>,
246          
247              
248          pub satrush_config: &'b solana_account_info::AccountInfo<'a>,
249                /// The airdrop being issued; a fresh keypair signed by the issuer's client.
250
251    
252              
253          pub grubstake_airdrop: &'b solana_account_info::AccountInfo<'a>,
254                /// The treasury: its unreserved grubstake backs the airdrop.
255
256    
257              
258          pub treasury: &'b solana_account_info::AccountInfo<'a>,
259          
260              
261          pub system_program: &'b solana_account_info::AccountInfo<'a>,
262            /// The arguments for the instruction.
263    pub __args: CreateGrubstakeAirdropInstructionArgs,
264  }
265
266impl<'a, 'b> CreateGrubstakeAirdropCpi<'a, 'b> {
267  pub fn new(
268    program: &'b solana_account_info::AccountInfo<'a>,
269          accounts: CreateGrubstakeAirdropCpiAccounts<'a, 'b>,
270              args: CreateGrubstakeAirdropInstructionArgs,
271      ) -> Self {
272    Self {
273      __program: program,
274              authority: accounts.authority,
275              satrush_config: accounts.satrush_config,
276              grubstake_airdrop: accounts.grubstake_airdrop,
277              treasury: accounts.treasury,
278              system_program: accounts.system_program,
279                    __args: args,
280          }
281  }
282  #[inline(always)]
283  pub fn invoke(&self) -> solana_program_error::ProgramResult {
284    self.invoke_signed_with_remaining_accounts(&[], &[])
285  }
286  #[inline(always)]
287  pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> solana_program_error::ProgramResult {
288    self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
289  }
290  #[inline(always)]
291  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
292    self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
293  }
294  #[allow(clippy::arithmetic_side_effects)]
295  #[allow(clippy::clone_on_copy)]
296  #[allow(clippy::vec_init_then_push)]
297  pub fn invoke_signed_with_remaining_accounts(
298    &self,
299    signers_seeds: &[&[&[u8]]],
300    remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]
301  ) -> solana_program_error::ProgramResult {
302    let mut accounts = Vec::with_capacity(5+ remaining_accounts.len());
303                            accounts.push(solana_instruction::AccountMeta::new(
304            *self.authority.key,
305            true
306          ));
307                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
308            *self.satrush_config.key,
309            false
310          ));
311                                          accounts.push(solana_instruction::AccountMeta::new(
312            *self.grubstake_airdrop.key,
313            true
314          ));
315                                          accounts.push(solana_instruction::AccountMeta::new(
316            *self.treasury.key,
317            false
318          ));
319                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
320            *self.system_program.key,
321            false
322          ));
323                      remaining_accounts.iter().for_each(|remaining_account| {
324      accounts.push(solana_instruction::AccountMeta {
325          pubkey: *remaining_account.0.key,
326          is_signer: remaining_account.1,
327          is_writable: remaining_account.2,
328      })
329    });
330    let mut data = CreateGrubstakeAirdropInstructionData::new().try_to_vec().unwrap();
331          let mut args = self.__args.try_to_vec().unwrap();
332      data.append(&mut args);
333    
334    let instruction = solana_instruction::Instruction {
335      program_id: crate::SATRUSH_ID,
336      accounts,
337      data,
338    };
339    let mut account_infos = Vec::with_capacity(6 + remaining_accounts.len());
340    account_infos.push(self.__program.clone());
341                  account_infos.push(self.authority.clone());
342                        account_infos.push(self.satrush_config.clone());
343                        account_infos.push(self.grubstake_airdrop.clone());
344                        account_infos.push(self.treasury.clone());
345                        account_infos.push(self.system_program.clone());
346              remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
347
348    if signers_seeds.is_empty() {
349      solana_cpi::invoke(&instruction, &account_infos)
350    } else {
351      solana_cpi::invoke_signed(&instruction, &account_infos, signers_seeds)
352    }
353  }
354}
355
356/// Instruction builder for `CreateGrubstakeAirdrop` via CPI.
357///
358/// ### Accounts:
359///
360                      ///   0. `[writable, signer]` authority
361          ///   1. `[]` satrush_config
362                      ///   2. `[writable, signer]` grubstake_airdrop
363                ///   3. `[writable]` treasury
364          ///   4. `[]` system_program
365#[derive(Clone, Debug)]
366pub struct CreateGrubstakeAirdropCpiBuilder<'a, 'b> {
367  instruction: Box<CreateGrubstakeAirdropCpiBuilderInstruction<'a, 'b>>,
368}
369
370impl<'a, 'b> CreateGrubstakeAirdropCpiBuilder<'a, 'b> {
371  pub fn new(program: &'b solana_account_info::AccountInfo<'a>) -> Self {
372    let instruction = Box::new(CreateGrubstakeAirdropCpiBuilderInstruction {
373      __program: program,
374              authority: None,
375              satrush_config: None,
376              grubstake_airdrop: None,
377              treasury: None,
378              system_program: None,
379                                            airdrop_authority: None,
380                                usd_amount: None,
381                                expiration_timestamp: None,
382                    __remaining_accounts: Vec::new(),
383    });
384    Self { instruction }
385  }
386      #[inline(always)]
387    pub fn authority(&mut self, authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
388                        self.instruction.authority = Some(authority);
389                    self
390    }
391      #[inline(always)]
392    pub fn satrush_config(&mut self, satrush_config: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
393                        self.instruction.satrush_config = Some(satrush_config);
394                    self
395    }
396      /// The airdrop being issued; a fresh keypair signed by the issuer's client.
397#[inline(always)]
398    pub fn grubstake_airdrop(&mut self, grubstake_airdrop: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
399                        self.instruction.grubstake_airdrop = Some(grubstake_airdrop);
400                    self
401    }
402      /// The treasury: its unreserved grubstake backs the airdrop.
403#[inline(always)]
404    pub fn treasury(&mut self, treasury: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
405                        self.instruction.treasury = Some(treasury);
406                    self
407    }
408      #[inline(always)]
409    pub fn system_program(&mut self, system_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
410                        self.instruction.system_program = Some(system_program);
411                    self
412    }
413                    #[inline(always)]
414      pub fn airdrop_authority(&mut self, airdrop_authority: Address) -> &mut Self {
415        self.instruction.airdrop_authority = Some(airdrop_authority);
416        self
417      }
418                #[inline(always)]
419      pub fn usd_amount(&mut self, usd_amount: u64) -> &mut Self {
420        self.instruction.usd_amount = Some(usd_amount);
421        self
422      }
423                #[inline(always)]
424      pub fn expiration_timestamp(&mut self, expiration_timestamp: i64) -> &mut Self {
425        self.instruction.expiration_timestamp = Some(expiration_timestamp);
426        self
427      }
428        /// Add an additional account to the instruction.
429  #[inline(always)]
430  pub fn add_remaining_account(&mut self, account: &'b solana_account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
431    self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
432    self
433  }
434  /// Add additional accounts to the instruction.
435  ///
436  /// Each account is represented by a tuple of the `AccountInfo`, a `bool` indicating whether the account is writable or not,
437  /// and a `bool` indicating whether the account is a signer or not.
438  #[inline(always)]
439  pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
440    self.instruction.__remaining_accounts.extend_from_slice(accounts);
441    self
442  }
443  #[inline(always)]
444  pub fn invoke(&self) -> solana_program_error::ProgramResult {
445    self.invoke_signed(&[])
446  }
447  #[allow(clippy::clone_on_copy)]
448  #[allow(clippy::vec_init_then_push)]
449  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
450          let args = CreateGrubstakeAirdropInstructionArgs {
451                                                              airdrop_authority: self.instruction.airdrop_authority.clone().expect("airdrop_authority is not set"),
452                                                                  usd_amount: self.instruction.usd_amount.clone().expect("usd_amount is not set"),
453                                                                  expiration_timestamp: self.instruction.expiration_timestamp.clone().expect("expiration_timestamp is not set"),
454                                    };
455        let instruction = CreateGrubstakeAirdropCpi {
456        __program: self.instruction.__program,
457                  
458          authority: self.instruction.authority.expect("authority is not set"),
459                  
460          satrush_config: self.instruction.satrush_config.expect("satrush_config is not set"),
461                  
462          grubstake_airdrop: self.instruction.grubstake_airdrop.expect("grubstake_airdrop is not set"),
463                  
464          treasury: self.instruction.treasury.expect("treasury is not set"),
465                  
466          system_program: self.instruction.system_program.expect("system_program is not set"),
467                          __args: args,
468            };
469    instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
470  }
471}
472
473#[derive(Clone, Debug)]
474struct CreateGrubstakeAirdropCpiBuilderInstruction<'a, 'b> {
475  __program: &'b solana_account_info::AccountInfo<'a>,
476            authority: Option<&'b solana_account_info::AccountInfo<'a>>,
477                satrush_config: Option<&'b solana_account_info::AccountInfo<'a>>,
478                grubstake_airdrop: Option<&'b solana_account_info::AccountInfo<'a>>,
479                treasury: Option<&'b solana_account_info::AccountInfo<'a>>,
480                system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
481                        airdrop_authority: Option<Address>,
482                usd_amount: Option<u64>,
483                expiration_timestamp: Option<i64>,
484        /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
485  __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
486}
487
satrush_client/generated/instructions/create_grubstake_airdrop.rs

satrush_client/generated/instructions/
create_grubstake_airdrop.rs
