multiliquid-svm-sdk 0.1.2

Unsigned transaction builders, account codecs, and quoting for Multiliquid on Solana
Documentation
//! Realloc-aware treasury user positions and read-only account fetchers.
//!
//! The generated ABI retains the original fixed array of 50 deposits. This
//! module reads every populated slot, including those in reallocated storage.

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],
    /// Populated deposits, not unused allocated slots. Encoding also accepts
    /// spare entries up to `max_pending_deposits`, matching the npm codec.
    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)?;
        }
        // Zero bytes encode the npm codec's empty RWA deposit.
        data.resize(size, 0);
        Ok(data)
    }

    /// Like generated account fetchers, this does not impose a program owner.
    /// Use `fetch_treasury_user_position_with_pending_deposits` for that check.
    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);
    }
}