use borsh::{BorshDeserialize, BorshSerialize};
use solana_sdk::pubkey::Pubkey;
use std::io::{Error, ErrorKind};
use crate::{
error::{Result, SdkError},
generated::treasury::{PendingDeposit, UserPosition as RawUserPosition},
rpc::Rpc,
};
const USER_POSITION_HEADER_SIZE: usize = 80;
const BASE_PENDING_DEPOSIT_CAPACITY: usize = 50;
const PENDING_DEPOSIT_SIZE: usize = 25;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreasuryUserPositionWithPendingDeposits {
pub owner: Pubkey,
pub principal_amount: u64,
pub accumulated_yield: u64,
pub global_yield_index_on_last_update: u128,
pub pending_deposit_count: u16,
pub max_pending_deposits: u16,
pub bump: u8,
pub _padding: [u8; 3],
pub pending_deposits: Vec<PendingDeposit>,
}
impl TreasuryUserPositionWithPendingDeposits {
pub const DISCRIMINATOR: [u8; 8] = RawUserPosition::DISCRIMINATOR;
pub fn decode(data: &[u8]) -> std::io::Result<Self> {
if !data.starts_with(&Self::DISCRIMINATOR) {
return Err(Error::new(
ErrorKind::InvalidData,
"Invalid UserPosition discriminator",
));
}
if data.len() < USER_POSITION_HEADER_SIZE {
return Err(Error::new(
ErrorKind::UnexpectedEof,
"Treasury user position header is truncated",
));
}
let mut cursor = &data[Self::DISCRIMINATOR.len()..];
let owner = Pubkey::deserialize(&mut cursor)?;
let principal_amount = u64::deserialize(&mut cursor)?;
let accumulated_yield = u64::deserialize(&mut cursor)?;
let global_yield_index_on_last_update = u128::deserialize(&mut cursor)?;
let pending_deposit_count = u16::deserialize(&mut cursor)?;
let max_pending_deposits = u16::deserialize(&mut cursor)?;
let bump = u8::deserialize(&mut cursor)?;
let padding = <[u8; 3]>::deserialize(&mut cursor)?;
let allocated_slots = cursor.len() / PENDING_DEPOSIT_SIZE;
if pending_deposit_count > max_pending_deposits
|| usize::from(max_pending_deposits) > allocated_slots
{
return Err(Error::new(
ErrorKind::InvalidData,
"Treasury user position has an invalid pending-deposit capacity",
));
}
let mut pending_deposits = Vec::with_capacity(usize::from(pending_deposit_count));
for _ in 0..pending_deposit_count {
pending_deposits.push(PendingDeposit::deserialize(&mut cursor)?);
}
Ok(Self {
owner,
principal_amount,
accumulated_yield,
global_yield_index_on_last_update,
pending_deposit_count,
max_pending_deposits,
bump,
_padding: padding,
pending_deposits,
})
}
pub fn encode(&self) -> std::io::Result<Vec<u8>> {
if self.pending_deposit_count > self.max_pending_deposits
|| self.pending_deposits.len() < usize::from(self.pending_deposit_count)
|| self.pending_deposits.len() > usize::from(self.max_pending_deposits)
{
return Err(Error::new(
ErrorKind::InvalidInput,
"Treasury user position pending deposits do not match its count and capacity",
));
}
let capacity = BASE_PENDING_DEPOSIT_CAPACITY.max(usize::from(self.max_pending_deposits));
let size = USER_POSITION_HEADER_SIZE + capacity * PENDING_DEPOSIT_SIZE;
let mut data = Vec::with_capacity(size);
data.extend_from_slice(&Self::DISCRIMINATOR);
self.owner.serialize(&mut data)?;
self.principal_amount.serialize(&mut data)?;
self.accumulated_yield.serialize(&mut data)?;
self.global_yield_index_on_last_update
.serialize(&mut data)?;
self.pending_deposit_count.serialize(&mut data)?;
self.max_pending_deposits.serialize(&mut data)?;
self.bump.serialize(&mut data)?;
self._padding.serialize(&mut data)?;
for deposit in &self.pending_deposits {
deposit.serialize(&mut data)?;
}
data.resize(size, 0);
Ok(data)
}
pub async fn fetch_maybe<R: Rpc + ?Sized>(rpc: &R, address: &Pubkey) -> Result<Option<Self>> {
rpc.get_account(address)
.await?
.map(|account| Self::decode(&account.data).map_err(SdkError::from))
.transpose()
}
pub async fn fetch<R: Rpc + ?Sized>(rpc: &R, address: &Pubkey) -> Result<Self> {
Self::fetch_maybe(rpc, address)
.await?
.ok_or(SdkError::AccountNotFound(*address))
}
pub async fn fetch_all_maybe<R: Rpc + ?Sized>(
rpc: &R,
addresses: &[Pubkey],
) -> Result<Vec<Option<Self>>> {
let accounts = rpc.get_multiple_accounts(addresses).await?;
if accounts.len() != addresses.len() {
return Err(SdkError::Rpc(
"get_multiple_accounts returned an unexpected account count".into(),
));
}
accounts
.into_iter()
.map(|account| {
account
.map(|account| Self::decode(&account.data).map_err(SdkError::from))
.transpose()
})
.collect()
}
pub async fn fetch_all<R: Rpc + ?Sized>(rpc: &R, addresses: &[Pubkey]) -> Result<Vec<Self>> {
Self::fetch_all_maybe(rpc, addresses)
.await?
.into_iter()
.zip(addresses)
.map(|(account, address)| account.ok_or(SdkError::AccountNotFound(*address)))
.collect()
}
}
pub fn decode_treasury_user_position_with_pending_deposits(
data: &[u8],
) -> Result<TreasuryUserPositionWithPendingDeposits> {
Ok(TreasuryUserPositionWithPendingDeposits::decode(data)?)
}
pub fn encode_treasury_user_position_with_pending_deposits(
position: &TreasuryUserPositionWithPendingDeposits,
) -> Result<Vec<u8>> {
Ok(position.encode()?)
}
pub fn decode_treasury_user_position_account(
data: &[u8],
) -> Result<TreasuryUserPositionWithPendingDeposits> {
decode_treasury_user_position_with_pending_deposits(data)
}
pub async fn fetch_maybe_treasury_user_position_account<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
) -> Result<Option<TreasuryUserPositionWithPendingDeposits>> {
TreasuryUserPositionWithPendingDeposits::fetch_maybe(rpc, address).await
}
pub async fn fetch_treasury_user_position_account<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
) -> Result<TreasuryUserPositionWithPendingDeposits> {
TreasuryUserPositionWithPendingDeposits::fetch(rpc, address).await
}
pub async fn fetch_all_maybe_treasury_user_position_accounts<R: Rpc + ?Sized>(
rpc: &R,
addresses: &[Pubkey],
) -> Result<Vec<Option<TreasuryUserPositionWithPendingDeposits>>> {
TreasuryUserPositionWithPendingDeposits::fetch_all_maybe(rpc, addresses).await
}
pub async fn fetch_all_treasury_user_position_accounts<R: Rpc + ?Sized>(
rpc: &R,
addresses: &[Pubkey],
) -> Result<Vec<TreasuryUserPositionWithPendingDeposits>> {
TreasuryUserPositionWithPendingDeposits::fetch_all(rpc, addresses).await
}
pub async fn fetch_treasury_user_position_with_pending_deposits<R: Rpc + ?Sized>(
rpc: &R,
address: &Pubkey,
program_id: &Pubkey,
) -> Result<TreasuryUserPositionWithPendingDeposits> {
let account = rpc
.get_account(address)
.await?
.ok_or(SdkError::AccountNotFound(*address))?;
if account.owner != *program_id {
return Err(SdkError::InvalidAccount(format!(
"Treasury user position {address} has unexpected owner {}; expected {program_id}",
account.owner
)));
}
decode_treasury_user_position_with_pending_deposits(&account.data)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::generated::treasury::AssetType;
fn grown_bytes() -> Vec<u8> {
let mut data = vec![0; 80 + 100 * 25];
data[..8].copy_from_slice(&RawUserPosition::DISCRIMINATOR);
data[8..40].fill(120);
data[40..48].copy_from_slice(&10_u64.to_le_bytes());
data[48..56].copy_from_slice(&20_u64.to_le_bytes());
data[56..72].copy_from_slice(&1_000_000_000_000_000_000_u128.to_le_bytes());
data[72..74].copy_from_slice(&51_u16.to_le_bytes());
data[74..76].copy_from_slice(&100_u16.to_le_bytes());
data[76..80].copy_from_slice(&[250, 1, 2, 255]);
for index in 0..51 {
let offset = 80 + index * 25;
data[offset..offset + 16].copy_from_slice(&(index as u128 + 1).to_le_bytes());
data[offset + 16..offset + 24]
.copy_from_slice(&(1_700_000_000 + index as i64).to_le_bytes());
data[offset + 24] = (index % 2) as u8;
}
data
}
#[test]
fn grown_position_preserves_populated_slots_and_header_bytes() {
let data = grown_bytes();
let position = TreasuryUserPositionWithPendingDeposits::decode(&data).unwrap();
assert_eq!(position.pending_deposits.len(), 51);
assert_eq!(
position.pending_deposits[50],
PendingDeposit {
amount_deposited_fp: 51,
deposit_ts: 1_700_000_050,
asset_type: AssetType::Rwa,
}
);
assert_eq!(position._padding, [1, 2, 255]);
assert_eq!(position.encode().unwrap(), data);
let raw = RawUserPosition::decode(&data).unwrap();
assert_eq!(raw.pending_deposits.len(), 50);
}
#[test]
fn rejects_truncated_capacity_header_and_invalid_deposit_tag() {
let data = grown_bytes();
for end in [0, 7, 79, 80 + 50 * 25, data.len() - 1] {
assert!(TreasuryUserPositionWithPendingDeposits::decode(&data[..end]).is_err());
}
let mut invalid = data.clone();
invalid[72..74].copy_from_slice(&101_u16.to_le_bytes());
assert!(TreasuryUserPositionWithPendingDeposits::decode(&invalid).is_err());
invalid = data;
invalid[80 + 50 * 25 + 24] = 2;
assert!(TreasuryUserPositionWithPendingDeposits::decode(&invalid).is_err());
}
#[test]
fn encoder_validates_count_and_retains_minimum_allocation() {
let mut position = TreasuryUserPositionWithPendingDeposits::decode(&grown_bytes()).unwrap();
position.pending_deposits.pop();
assert!(position.encode().is_err());
position.pending_deposit_count = 0;
position.max_pending_deposits = 0;
assert!(position.encode().is_err());
position.pending_deposits.clear();
assert_eq!(position.encode().unwrap().len(), 80 + 50 * 25);
}
}