riptide-amm-math 2.0.1

The Riptide program math library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

#![allow(
    unexpected_cfgs,
    unused_attributes,
    clippy::needless_range_loop,
    clippy::too_many_arguments
)]
#![cfg_attr(all(not(feature = "wasm"), not(test)), no_std)]
#![cfg_attr(feature = "wasm", allow(non_snake_case))]
#![cfg_attr(target_os = "solana", feature(cfg_boolean_literals))]

mod error;
mod guards;
mod oracle;
mod price;
mod quote;
mod token;
mod transfer_fee;

pub use error::*;
pub use guards::*;
pub use oracle::*;
pub use price::*;
pub use quote::*;
pub use token::*;
pub use transfer_fee::*;

#[cfg(feature = "wasm")]
use serde::Serializer;

// Serialize a u64 as a u128. This is so that we can use u64 value in rust
// but serialize as a bigint in wasm.
#[cfg(feature = "wasm")]
pub fn u64_serialize<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    serializer.serialize_u128(*value as u128)
}

// While `wasm_expose` doesn't automatically convert rust `u128` to js `bigint`, we have
// to proxy it through an opaque type that we define here. This is a workaround until
// `wasm_bindgen` supports `u128` abi conversion natively.

#[cfg(not(feature = "wasm"))]
pub type U128 = u128;

#[cfg(feature = "wasm")]
use core::fmt::{Debug, Formatter};

#[cfg(feature = "wasm")]
use ethnum::U256;

#[cfg(feature = "wasm")]
use wasm_bindgen::prelude::*;

#[cfg(feature = "wasm")]
#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(typescript_type = "bigint")]
    #[derive(PartialEq)]
    pub type U128;
}

#[cfg(feature = "wasm")]
impl Debug for U128 {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(f, "{:?}", JsValue::from(self))
    }
}

#[cfg(feature = "wasm")]
impl From<U128> for u128 {
    fn from(value: U128) -> u128 {
        JsValue::from(value)
            .try_into()
            .expect("Number too large to fit in u128")
    }
}

#[cfg(feature = "wasm")]
impl From<U128> for U256 {
    fn from(value: U128) -> U256 {
        let u_128: u128 = value.into();
        <U256>::from(u_128)
    }
}

#[cfg(feature = "wasm")]
impl From<u128> for U128 {
    fn from(value: u128) -> U128 {
        JsValue::from(value).unchecked_into()
    }
}

#[cfg(feature = "wasm")]
impl TryFrom<U256> for U128 {
    type Error = core::num::TryFromIntError;

    fn try_from(value: U256) -> Result<Self, Self::Error> {
        let u_128: u128 = value.try_into()?;
        Ok(U128::from(u_128))
    }
}