multiliquid-svm-sdk 0.1.2

Unsigned transaction builders, account codecs, and quoting for Multiliquid on Solana
Documentation
//! Checked input bounds for high-level builders.
//!
//! Rust's integer argument types replace JavaScript's runtime bigint/integer
//! checks. Fallible conversion accepts signed and wider native integers so
//! negative values and values above the target width remain explicit errors.

use solana_sdk::{instruction::AccountMeta, pubkey::Pubkey};

use crate::error::{Result, SdkError};

fn unsigned(value: impl TryInto<u128>, field_name: &str) -> Result<u128> {
    value
        .try_into()
        .map_err(|_| SdkError::InvalidInput(format!("{field_name} must be non-negative")))
}

pub fn assert_u16(value: impl TryInto<u128>, field_name: &str) -> Result<u16> {
    let value = unsigned(value, field_name)?;
    u16::try_from(value)
        .map_err(|_| SdkError::InvalidInput(format!("{field_name} exceeds u16 max")))
}

/// Validate basis points with the SDK's default maximum of 9,900, or an
/// explicitly supplied maximum. The u16 bound is always checked first.
pub fn assert_bps(value: impl TryInto<u128>, field_name: &str, max: Option<u16>) -> Result<u16> {
    let normalized = assert_u16(value, field_name)?;
    let max = max.unwrap_or(9_900);
    if normalized > max {
        return Err(SdkError::InvalidInput(format!(
            "{field_name} exceeds {max} bps"
        )));
    }
    Ok(normalized)
}

pub fn assert_u64_amount(amount: impl TryInto<u128>, field_name: &str) -> Result<u64> {
    let value = unsigned(amount, field_name)?;
    u64::try_from(value)
        .map_err(|_| SdkError::InvalidInput(format!("{field_name} exceeds u64 max")))
}

pub fn assert_positive_amount(amount: impl TryInto<u128>, field_name: &str) -> Result<u64> {
    let value = assert_u64_amount(amount, field_name)?;
    if value == 0 {
        return Err(SdkError::InvalidInput(format!(
            "{field_name} must be positive"
        )));
    }
    Ok(value)
}

/// Reject explicit signers and aliases whose privileges are elevated by the runtime.
pub(crate) fn assert_no_remaining_signers(
    accounts: &[AccountMeta],
    signers: &[Pubkey],
) -> Result<()> {
    if accounts
        .iter()
        .any(|account| account.is_signer || signers.contains(&account.pubkey))
    {
        return Err(SdkError::InvalidInput(
            "Remaining accounts must not contain signers".into(),
        ));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn checked_widths_reject_underflow_and_overflow() {
        assert_eq!(assert_u16(u16::MAX, "value").unwrap(), u16::MAX);
        assert!(assert_u16(u32::from(u16::MAX) + 1, "value").is_err());
        assert!(assert_u16(-1, "value").is_err());
        assert_eq!(assert_u64_amount(u64::MAX, "amount").unwrap(), u64::MAX);
        assert!(assert_u64_amount(u128::from(u64::MAX) + 1, "amount").is_err());
        assert!(assert_u64_amount(-1_i128, "amount").is_err());
        assert_eq!(assert_u64_amount(0, "amount").unwrap(), 0);
        assert!(assert_positive_amount(0, "amount").is_err());
        assert_eq!(
            assert_positive_amount(u64::MAX, "amount").unwrap(),
            u64::MAX
        );
    }

    #[test]
    fn basis_point_limits_remain_distinct_from_math_limits() {
        assert_eq!(assert_bps(9_900, "fee", None).unwrap(), 9_900);
        assert!(assert_bps(9_901, "fee", None).is_err());
        assert_eq!(assert_bps(25, "fee", Some(25)).unwrap(), 25);
        assert!(assert_bps(26, "fee", Some(25)).is_err());
        assert_eq!(assert_bps(10_000, "fee", Some(10_000)).unwrap(), 10_000);
        assert!(assert_bps(65_536_u32, "fee", Some(u16::MAX)).is_err());
    }
}