defituna_client/generated/accounts/
tuna_position.rs1use solana_program::pubkey::Pubkey;
9use crate::generated::types::TunaPositionState;
10use crate::generated::types::MarketMaker;
11use borsh::BorshSerialize;
12use borsh::BorshDeserialize;
13
14
15#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
16#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17pub struct TunaPosition {
18pub discriminator: [u8; 8],
19pub version: u16,
21pub bump: [u8; 1],
23#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]
25pub authority: Pubkey,
26#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]
28pub pool: Pubkey,
29#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]
31pub mint_a: Pubkey,
32#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]
34pub mint_b: Pubkey,
35#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]
37pub position_mint: Pubkey,
38pub liquidity: u128,
40pub tick_lower_index: i32,
42pub tick_upper_index: i32,
44pub loan_shares_a: u64,
46pub loan_shares_b: u64,
48pub loan_funds_a: u64,
50pub loan_funds_b: u64,
52pub leftovers_a: u64,
54pub leftovers_b: u64,
56pub tick_entry_index: i32,
58pub tick_stop_loss_index: i32,
60pub tick_take_profit_index: i32,
62pub state: TunaPositionState,
64pub swap_to_token_on_limit_order: u8,
68pub compounded_yield_a: u64,
70pub compounded_yield_b: u64,
72pub flags: u32,
77pub market_maker: MarketMaker,
79pub rebalance_threshold_ticks: u32,
82#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::Bytes>"))]
84pub reserved: [u8; 57],
85}
86
87
88impl TunaPosition {
89 pub const LEN: usize = 339;
90
91
92
93 #[inline(always)]
94 pub fn from_bytes(data: &[u8]) -> Result<Self, std::io::Error> {
95 let mut data = data;
96 Self::deserialize(&mut data)
97 }
98}
99
100impl<'a> TryFrom<&solana_program::account_info::AccountInfo<'a>> for TunaPosition {
101 type Error = std::io::Error;
102
103 fn try_from(account_info: &solana_program::account_info::AccountInfo<'a>) -> Result<Self, Self::Error> {
104 let mut data: &[u8] = &(*account_info.data).borrow();
105 Self::deserialize(&mut data)
106 }
107}
108
109#[cfg(feature = "fetch")]
110pub fn fetch_tuna_position(
111 rpc: &solana_client::rpc_client::RpcClient,
112 address: &solana_program::pubkey::Pubkey,
113) -> Result<crate::shared::DecodedAccount<TunaPosition>, std::io::Error> {
114 let accounts = fetch_all_tuna_position(rpc, &[*address])?;
115 Ok(accounts[0].clone())
116}
117
118#[cfg(feature = "fetch")]
119pub fn fetch_all_tuna_position(
120 rpc: &solana_client::rpc_client::RpcClient,
121 addresses: &[solana_program::pubkey::Pubkey],
122) -> Result<Vec<crate::shared::DecodedAccount<TunaPosition>>, std::io::Error> {
123 let accounts = rpc.get_multiple_accounts(addresses)
124 .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
125 let mut decoded_accounts: Vec<crate::shared::DecodedAccount<TunaPosition>> = Vec::new();
126 for i in 0..addresses.len() {
127 let address = addresses[i];
128 let account = accounts[i].as_ref()
129 .ok_or(std::io::Error::new(std::io::ErrorKind::Other, format!("Account not found: {}", address)))?;
130 let data = TunaPosition::from_bytes(&account.data)?;
131 decoded_accounts.push(crate::shared::DecodedAccount { address, account: account.clone(), data });
132 }
133 Ok(decoded_accounts)
134}
135
136#[cfg(feature = "fetch")]
137pub fn fetch_maybe_tuna_position(
138 rpc: &solana_client::rpc_client::RpcClient,
139 address: &solana_program::pubkey::Pubkey,
140) -> Result<crate::shared::MaybeAccount<TunaPosition>, std::io::Error> {
141 let accounts = fetch_all_maybe_tuna_position(rpc, &[*address])?;
142 Ok(accounts[0].clone())
143}
144
145#[cfg(feature = "fetch")]
146pub fn fetch_all_maybe_tuna_position(
147 rpc: &solana_client::rpc_client::RpcClient,
148 addresses: &[solana_program::pubkey::Pubkey],
149) -> Result<Vec<crate::shared::MaybeAccount<TunaPosition>>, std::io::Error> {
150 let accounts = rpc.get_multiple_accounts(addresses)
151 .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
152 let mut decoded_accounts: Vec<crate::shared::MaybeAccount<TunaPosition>> = Vec::new();
153 for i in 0..addresses.len() {
154 let address = addresses[i];
155 if let Some(account) = accounts[i].as_ref() {
156 let data = TunaPosition::from_bytes(&account.data)?;
157 decoded_accounts.push(crate::shared::MaybeAccount::Exists(crate::shared::DecodedAccount { address, account: account.clone(), data }));
158 } else {
159 decoded_accounts.push(crate::shared::MaybeAccount::NotFound(address));
160 }
161 }
162 Ok(decoded_accounts)
163}
164
165 #[cfg(feature = "anchor")]
166 impl anchor_lang::AccountDeserialize for TunaPosition {
167 fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_lang::Result<Self> {
168 Ok(Self::deserialize(buf)?)
169 }
170 }
171
172 #[cfg(feature = "anchor")]
173 impl anchor_lang::AccountSerialize for TunaPosition {}
174
175 #[cfg(feature = "anchor")]
176 impl anchor_lang::Owner for TunaPosition {
177 fn owner() -> Pubkey {
178 crate::TUNA_ID
179 }
180 }
181
182 #[cfg(feature = "anchor-idl-build")]
183 impl anchor_lang::IdlBuild for TunaPosition {}
184
185
186 #[cfg(feature = "anchor-idl-build")]
187 impl anchor_lang::Discriminator for TunaPosition {
188 const DISCRIMINATOR: [u8; 8] = [0; 8];
189 }
190