satrush_client/generated/accounts/
treasury.rs1use borsh::BorshSerialize;
9use borsh::BorshDeserialize;
10
11
12#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
13pub struct Treasury {
14pub discriminator: [u8; 8],
15pub version: u16,
17pub bump: u8,
19pub pending_usd_amount: u64,
21pub pending_btc_amount: u64,
23pub reserved: [u8; 32],
25}
26
27
28pub const TREASURY_DISCRIMINATOR: [u8; 8] = [238, 239, 123, 238, 89, 1, 168, 253];
29
30impl Treasury {
31 pub const LEN: usize = 59;
32
33
34
35 #[inline(always)]
36 pub fn from_bytes(data: &[u8]) -> Result<Self, std::io::Error> {
37 let mut data = data;
38 Self::deserialize(&mut data)
39 }
40}
41
42impl<'a> TryFrom<&solana_account_info::AccountInfo<'a>> for Treasury {
43 type Error = std::io::Error;
44
45 fn try_from(account_info: &solana_account_info::AccountInfo<'a>) -> Result<Self, Self::Error> {
46 let mut data: &[u8] = &(*account_info.data).borrow();
47 Self::deserialize(&mut data)
48 }
49}
50
51#[cfg(feature = "fetch")]
52pub fn fetch_treasury(
53 rpc: &solana_rpc_client::rpc_client::RpcClient,
54 address: &solana_address::Address,
55) -> Result<crate::shared::DecodedAccount<Treasury>, std::io::Error> {
56 let accounts = fetch_all_treasury(rpc, &[*address])?;
57 Ok(accounts[0].clone())
58}
59
60#[cfg(feature = "fetch")]
61pub fn fetch_all_treasury(
62 rpc: &solana_rpc_client::rpc_client::RpcClient,
63 addresses: &[solana_address::Address],
64) -> Result<Vec<crate::shared::DecodedAccount<Treasury>>, std::io::Error> {
65 let accounts = rpc.get_multiple_accounts(addresses)
66 .map_err(|e| std::io::Error::other(e.to_string()))?;
67 let mut decoded_accounts: Vec<crate::shared::DecodedAccount<Treasury>> = Vec::new();
68 for i in 0..addresses.len() {
69 let address = addresses[i];
70 let account = accounts[i].as_ref()
71 .ok_or(std::io::Error::other(format!("Account not found: {address}")))?;
72 let data = Treasury::from_bytes(&account.data)?;
73 decoded_accounts.push(crate::shared::DecodedAccount { address, account: account.clone(), data });
74 }
75 Ok(decoded_accounts)
76}
77
78#[cfg(feature = "fetch")]
79pub fn fetch_maybe_treasury(
80 rpc: &solana_rpc_client::rpc_client::RpcClient,
81 address: &solana_address::Address,
82) -> Result<crate::shared::MaybeAccount<Treasury>, std::io::Error> {
83 let accounts = fetch_all_maybe_treasury(rpc, &[*address])?;
84 Ok(accounts[0].clone())
85}
86
87#[cfg(feature = "fetch")]
88pub fn fetch_all_maybe_treasury(
89 rpc: &solana_rpc_client::rpc_client::RpcClient,
90 addresses: &[solana_address::Address],
91) -> Result<Vec<crate::shared::MaybeAccount<Treasury>>, std::io::Error> {
92 let accounts = rpc.get_multiple_accounts(addresses)
93 .map_err(|e| std::io::Error::other(e.to_string()))?;
94 let mut decoded_accounts: Vec<crate::shared::MaybeAccount<Treasury>> = Vec::new();
95 for i in 0..addresses.len() {
96 let address = addresses[i];
97 if let Some(account) = accounts[i].as_ref() {
98 let data = Treasury::from_bytes(&account.data)?;
99 decoded_accounts.push(crate::shared::MaybeAccount::Exists(crate::shared::DecodedAccount { address, account: account.clone(), data }));
100 } else {
101 decoded_accounts.push(crate::shared::MaybeAccount::NotFound(address));
102 }
103 }
104 Ok(decoded_accounts)
105}
106
107 #[cfg(feature = "anchor")]
108 impl anchor_lang::AccountDeserialize for Treasury {
109 fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_lang::Result<Self> {
110 Ok(Self::deserialize(buf)?)
111 }
112 }
113
114 #[cfg(feature = "anchor")]
115 impl anchor_lang::AccountSerialize for Treasury {}
116
117 #[cfg(feature = "anchor")]
118 impl anchor_lang::Owner for Treasury {
119 fn owner() -> anchor_lang::solana_program::pubkey::Pubkey {
120 anchor_lang::solana_program::pubkey::Pubkey::from(
121 crate::SATRUSH_ID.to_bytes()
122 )
123 }
124 }
125
126 #[cfg(feature = "anchor-idl-build")]
127 impl anchor_lang::IdlBuild for Treasury {}
128
129
130 #[cfg(feature = "anchor-idl-build")]
131 impl anchor_lang::Discriminator for Treasury {
132 const DISCRIMINATOR: &[u8] = &[0; 8];
133 }
134