#![allow(clippy::assign_op_pattern)]
#![allow(clippy::ptr_offset_with_cast)]
#![allow(clippy::manual_range_contains)]
use crate::{
MathError, Rate, TryAdd, TryDiv, TryMul, TrySub, BIPS_SCALER, HALF_WAD, PERCENT_SCALER, SCALE,
WAD,
};
use arrayref::{array_mut_ref, array_ref};
use solana_program::program_error::ProgramError;
use solana_program::program_pack::{Pack, Sealed};
use std::{convert::TryFrom, fmt};
use uint::construct_uint;
construct_uint! {
pub struct U192(3);
}
#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
pub struct Decimal(pub U192);
impl Decimal {
pub fn one() -> Self {
Self(Self::wad())
}
pub fn zero() -> Self {
Self(U192::zero())
}
fn wad() -> U192 {
U192::from(WAD)
}
fn half_wad() -> U192 {
U192::from(HALF_WAD)
}
pub fn from_percent(percent: u8) -> Self {
Self(U192::from(percent as u64 * PERCENT_SCALER))
}
pub fn from_bips(percent: u64) -> Self {
Self(U192::from(percent * BIPS_SCALER))
}
#[allow(clippy::wrong_self_convention)]
pub fn to_scaled_val(&self) -> Result<u128, ProgramError> {
Ok(u128::try_from(self.0).map_err(|_| MathError::UnableToRoundU128)?)
}
pub fn from_scaled_val(scaled_val: u128) -> Self {
Self(U192::from(scaled_val))
}
pub fn try_round_u64(&self) -> Result<u64, ProgramError> {
let rounded_val = Self::half_wad()
.checked_add(self.0)
.ok_or(MathError::AddOverflow)?
.checked_div(Self::wad())
.ok_or(MathError::DividedByZero)?;
Ok(u64::try_from(rounded_val).map_err(|_| MathError::UnableToRoundU64)?)
}
pub fn try_ceil_u64(&self) -> Result<u64, ProgramError> {
let ceil_val = Self::wad()
.checked_sub(U192::from(1u64))
.ok_or(MathError::SubUnderflow)?
.checked_add(self.0)
.ok_or(MathError::AddOverflow)?
.checked_div(Self::wad())
.ok_or(MathError::DividedByZero)?;
Ok(u64::try_from(ceil_val).map_err(|_| MathError::UnableToRoundU64)?)
}
pub fn try_floor_u64(&self) -> Result<u64, ProgramError> {
let ceil_val = self
.0
.checked_div(Self::wad())
.ok_or(MathError::DividedByZero)?;
Ok(u64::try_from(ceil_val).map_err(|_| MathError::UnableToRoundU64)?)
}
}
impl fmt::Display for Decimal {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut scaled_val = self.0.to_string();
if scaled_val.len() <= SCALE {
scaled_val.insert_str(0, &vec!["0"; SCALE - scaled_val.len()].join(""));
scaled_val.insert_str(0, "0.");
} else {
scaled_val.insert(scaled_val.len() - SCALE, '.');
}
f.write_str(&scaled_val)
}
}
impl From<u64> for Decimal {
fn from(val: u64) -> Self {
Self(Self::wad() * U192::from(val))
}
}
impl From<u128> for Decimal {
fn from(val: u128) -> Self {
Self(Self::wad() * U192::from(val))
}
}
impl From<Rate> for Decimal {
fn from(val: Rate) -> Self {
Self(U192::from(val.to_scaled_val()))
}
}
impl TryAdd for Decimal {
fn try_add(self, rhs: Self) -> Result<Self, ProgramError> {
Ok(Self(
self.0.checked_add(rhs.0).ok_or(MathError::AddOverflow)?,
))
}
}
impl TrySub for Decimal {
fn try_sub(self, rhs: Self) -> Result<Self, ProgramError> {
Ok(Self(
self.0.checked_sub(rhs.0).ok_or(MathError::MulOverflow)?,
))
}
}
impl TryDiv<u64> for Decimal {
fn try_div(self, rhs: u64) -> Result<Self, ProgramError> {
Ok(Self(
self.0
.checked_div(U192::from(rhs))
.ok_or(MathError::DividedByZero)?,
))
}
}
impl TryDiv<Rate> for Decimal {
fn try_div(self, rhs: Rate) -> Result<Self, ProgramError> {
self.try_div(Self::from(rhs))
}
}
impl TryDiv<Decimal> for Decimal {
fn try_div(self, rhs: Self) -> Result<Self, ProgramError> {
Ok(Self(
self.0
.checked_mul(Self::wad())
.ok_or(MathError::MulOverflow)?
.checked_div(rhs.0)
.ok_or(MathError::DividedByZero)?,
))
}
}
impl TryMul<u64> for Decimal {
fn try_mul(self, rhs: u64) -> Result<Self, ProgramError> {
Ok(Self(
self.0
.checked_mul(U192::from(rhs))
.ok_or(MathError::MulOverflow)?,
))
}
}
impl TryMul<Rate> for Decimal {
fn try_mul(self, rhs: Rate) -> Result<Self, ProgramError> {
self.try_mul(Self::from(rhs))
}
}
impl TryMul<Decimal> for Decimal {
fn try_mul(self, rhs: Self) -> Result<Self, ProgramError> {
Ok(Self(
self.0
.checked_mul(rhs.0)
.ok_or(MathError::MulOverflow)?
.checked_div(Self::wad())
.ok_or(MathError::DividedByZero)?,
))
}
}
impl Sealed for Decimal {}
impl Pack for Decimal {
const LEN: usize = 16;
fn pack_into_slice(&self, dst: &mut [u8]) {
let output = array_mut_ref![dst, 0, Decimal::LEN];
*output = self
.to_scaled_val()
.expect("Decimal cannot be packed")
.to_le_bytes();
}
fn unpack_from_slice(src: &[u8]) -> Result<Self, ProgramError> {
let input = array_ref![src, 0, Decimal::LEN];
Ok(Decimal::from_scaled_val(u128::from_le_bytes(*input)))
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::SCALE;
#[test]
fn test_scaler() {
assert_eq!(U192::exp10(SCALE), Decimal::wad());
}
}