Struct OrderRate 

pub struct OrderRate { /* private fields */ }

Order rates impose limits on what trades the smart contract is allowed to execute. For example, the smart contract will reject a payload that requests a less favorable amount of asset_to than is imposed by the minimum order rate. For Sell orders, an order rate represented by currency B an in A/B market. For Buy orders, an order rate is represented in the protocol by currency A. Note that OrderRates are always created w.r.t. currency B, then potentially inverted during payload creation. This is because, unlike the smart contract, the ME always wants order prices expressed in currency B. In either case, these rates are encoded as 64 bit integers which take the initial price ratio, multiply by 10^8, and then drop all precision after the decimal.

Implementations

impl OrderRate

pub fn to_be_bytes(&self, precision: u32) -> Result<Vec<u8>>

Serialize the OrderRate to bytes for payload creation. We always use a precision of 8 and multiplication factor of 10^8

pub fn from_be_bytes(bytes: [u8; 8]) -> Result<Self>

Create OrderRate from big endian bytes in Ethereum FillOrder payload

impl OrderRate

pub fn to_le_bytes(&self) -> Result<[u8; 8]>

Serialize the OrderRate to bytes for payload creation. We always use a precision of 8 and multiplication factor of 10^8

impl OrderRate

pub fn new(str_num: &str) -> Result<Self>

Construct a new OrderRate from a numerical string

pub fn from_bigdecimal(decimal: BigDecimal) -> Self

Create new OrderRate from bigdecimal

pub fn round(&self, precision: i64) -> Self

Round the price in the specified precision.

pub fn invert_rate(&self, precision: Option<u32>) -> Self

Invert the price to units of the other market pair. For example, if price is in terms of ETH in an ETH/USDC market, this will convert it to terms of USDC

pub fn to_bigdecimal(&self) -> BigDecimal

Return a new BigDecimal based on OrderRate

pub fn subtract_fee(&self, fee: BigDecimal) -> Self

Subtract fee from user by adjusting the order rate downwards. This will keep track of as much precision as BigDecimal is capable of. However, this method is exclusively used by the smart contract and will be reduced to an integer in scale of 10^8 before encoding

Trait Implementations

impl Clone for OrderRate

fn clone(&self) -> OrderRate

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrderRate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<OrderRate> for Rate

Enum wrappers are kind of annoying. This allows us to use .into() on a value to generate a wrapped value. For example: OrderRate::new("1").unwrap().into() => Rate::OrderRate(...)

fn from(rate: OrderRate) -> Self

Converts to this type from the input type.

impl PartialEq for OrderRate

fn eq(&self, other: &OrderRate) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for OrderRate