Struct ManagedDecimal 

pub struct ManagedDecimal<M: ManagedTypeApi, D: Decimals> { /* private fields */ }

Fixed-point decimal numbers that accept either a constant or variable number of decimals.

Negative numbers are not allowed. It is especially designed for denominated token amounts. If negative numbers are needed, use ManagedDecimalSigned instead.

Implementations

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimal<M, D>

pub fn trunc(&self) -> BigUint<M>

Returns the integer part (floor toward zero) of the decimal value.

Divides the raw fixed-point integer by the scaling factor, discarding the fractional part. For example, 1.75 with 2 decimals returns 1.

pub fn as_raw_units(&self) -> &BigUint<M>

Returns a reference to the underlying raw fixed-point integer.

The value is stored as real_value * 10^decimals. For example, a ManagedDecimal representing 1.5 with 2 decimals has a raw value of 150.

pub fn into_raw_units(&self) -> &BigUint<M>

👎Deprecated since 0.66.0:

Use as_raw_units to get a reference to the raw value, or into_raw_parts to consume the decimal and get the raw value.

Was incorrectly named into_raw_units in versions prior to 0.66.0; renamed to as_raw_units to clarify that it returns a reference and does not consume the decimal.

pub fn into_raw_parts(self) -> (BigUint<M>, D)

Consumes the decimal and returns the underlying raw fixed-point integer together with the decimals specification.

The value is stored as real_value * 10^decimals. For example, a ManagedDecimal representing 1.5 with 2 decimals has a raw value of 150.

This is the destructuring counterpart of from_raw_units.

pub fn from_raw_units(data: BigUint<M>, decimals: D) -> Self

Creates a ManagedDecimal from a raw fixed-point integer and a decimals specification.

The caller is responsible for ensuring data is already scaled by 10^decimals. For constructing from a human-readable integer value, use the From trait instead.

pub fn one(decimals: D) -> Self

Returns the multiplicative identity 1 at the given decimals precision.

The raw value is 10^decimals (the scaling factor), so that self.trunc() returns 1 and all arithmetic treats it as unity.

pub fn scale(&self) -> usize

Returns the number of decimal places.

pub fn scaling_factor(&self) -> ManagedRef<'static, M, BigUint<M>>

Returns the scaling factor 10^decimals as a static reference.

pub fn rescale<T: Decimals>(&self, scale_to: T) -> ManagedDecimal<M, T>

where M: ManagedTypeApi,

Converts this decimal to a new scale, adjusting the raw value accordingly.

Upscaling adds precision (appends trailing zeros to the raw integer); downscaling truncates the least-significant digits.

pub fn into_signed(self) -> ManagedDecimalSigned<M, D>

Converts this unsigned decimal into a signed ManagedDecimalSigned with the same scale and value.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> ManagedDecimal<M, ConstDecimals<DECIMALS>>

pub fn const_decimals_from_raw(data: BigUint<M>) -> Self

Creates a ManagedDecimal with a compile-time fixed number of decimals from a raw integer.

The caller is responsible for ensuring data is already scaled by 10^DECIMALS.

pub fn into_var_decimals(self) -> ManagedDecimal<M, NumDecimals>

Converts from constant (compile-time) number of decimals to a variable number of decimals.

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimal<M, D>

pub fn nth_root(&self, k: u32) -> Self

Integer part of the k-th root, preserving the decimal scale.

Internally pre-scales the raw data by scaling_factor^(k-1) so that after taking the integer root the decimal point lands in the correct position:

self.data = v * 10^d
  →  scaled = self.data * (10^d)^(k-1) = v * 10^(d*k)
  →  root   = floor(scaled^(1/k)) = floor(v^(1/k) * 10^d)

Returns 0 (with the same scale) when self is zero.

Panics

Panics if k is zero.

pub fn exp_approx(&self) -> ManagedDecimal<M, D>

where ManagedDecimal<M, D>: Add<Output = ManagedDecimal<M, D>>,

Approximates e^self using a 5th-order Taylor approximation.

Treats self as the exponent x and computes:

e^x ≈ 1 + x + x²/2! + x³/3! + x⁴/4! + x⁵/5!

The result has the same precision as self; all intermediate steps use [mul_half_up] / [div_half_up] to prevent rounding errors from accumulating toward zero.

Accurate for small x (i.e. when x ≪ 1). Error is O(x⁶/720).

pub fn compounded_interest_factor<Precision: Decimals>( &self, expiration: u64, precision: Precision, ) -> ManagedDecimal<M, Precision>

where ManagedDecimal<M, Precision>: Add<Output = ManagedDecimal<M, Precision>>,

Computes the continuous-compounding growth factor e^(self × expiration).

Delegates to [exp_approx] after computing x = rate * expiration; uses a 5-term Taylor series internally:

e^(rate * t) ≈ 1 + x + x²/2! + x³/3! + x⁴/4! + x⁵/5!,  where x = rate * t

Multiply a principal amount by the returned factor to apply interest. Returns 1 (at precision) when expiration == 0.

Credits

Original implementation by @mihaieremia.

impl<M: ManagedTypeApi, D1: Decimals> ManagedDecimal<M, D1>

pub fn mul_half_up<D2: Decimals, DResult: Decimals>( &self, other: &ManagedDecimal<M, D2>, precision: DResult, ) -> ManagedDecimal<M, DResult>

Multiplies two decimals with half-up rounding to a target precision.

Both operands are first rescaled to precision. The rescaled raw values are multiplied, producing a result with 2 * precision implied decimal places. That intermediate value is then rounded back to precision using the standard pre-bias trick:

rounded = (product + scale / 2) / scale

Adding scale / 2 before the integer division means that any remainder ≥ half the scale (i.e. the fractional part ≥ 0.5) causes the quotient to increment by one — equivalent to round-half-up.

Credits

Original implementation by @mihaieremia.

pub fn div_half_up<D2: Decimals, DResult: Decimals>( &self, other: &ManagedDecimal<M, D2>, precision: DResult, ) -> ManagedDecimal<M, DResult>

Divides two decimals with half-up rounding to a target precision.

Both operands are rescaled to precision. The numerator is then multiplied by scale so the division produces a result with the correct number of decimal places. The quotient is rounded using the pre-bias trick:

rounded = (numerator * scale + denominator / 2) / denominator

Adding denominator / 2 means that once the true quotient’s remainder reaches half the denominator (i.e. fractional part ≥ 0.5), integer division increments the result — equivalent to round-half-up.

Credits

Original implementation by @mihaieremia.

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimal<M, D>

pub fn ln(&self) -> Option<ManagedDecimalSigned<M, LnDecimals>>

Natural logarithm of a number.

Returns None for 0.

Even though 9 decimals are returned, only around 6 decimals are actually useful.

pub fn log2(&self) -> Option<ManagedDecimalSigned<M, LnDecimals>>

Base 2 logarithm of a number.

Returns None for 0.

Even though 9 decimals are returned, only around 6 decimals are actually useful.

impl<M: ManagedTypeApi, D1: Decimals> ManagedDecimal<M, D1>

pub fn mul_with_precision<D2: Decimals, T: Decimals>( self, other: ManagedDecimal<M, D2>, precision: T, ) -> ManagedDecimal<M, T>

Trait Implementations

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Add<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the + operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Add<ManagedDecimal<M, usize>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> Add for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, ConstDecimals<DECIMALS>>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi> Add for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> AddAssign<&ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn add_assign(&mut self, rhs: &ManagedDecimal<M, D2>)

Performs the += operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> AddAssign<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn add_assign(&mut self, rhs: ManagedDecimal<M, D2>)

Performs the += operation.

impl<M: Clone + ManagedTypeApi, D: Clone + Decimals> Clone for ManagedDecimal<M, D>

fn clone(&self) -> ManagedDecimal<M, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: ManagedTypeApi, D: Decimals> Debug for ManagedDecimal<M, D>

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

Formats the value using the given formatter.

impl<M: ManagedTypeApi, D: Decimals> Display for ManagedDecimal<M, D>

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

Formats the value using the given formatter.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Div<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the / operator.

fn div(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D1, D2: Decimals> Div<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

where D1: Sub<D2> + Decimals, <D1 as Sub<D2>>::Output: Decimals,

type Output = ManagedDecimal<M, <D1 as Sub<D2>>::Output>

The resulting type after applying the / operator.

fn div(self, other: ManagedDecimal<M, D2>) -> Self::Output

Performs the / operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Div<ManagedDecimal<M, usize>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the / operator.

fn div(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D: Decimals> Div<usize> for ManagedDecimal<M, D>

type Output = ManagedDecimal<M, D>

The resulting type after applying the / operator.

fn div(self, other: NumDecimals) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> DivAssign<&ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn div_assign(&mut self, rhs: &ManagedDecimal<M, D2>)

Performs the /= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> DivAssign<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn div_assign(&mut self, rhs: ManagedDecimal<M, D2>)

Performs the /= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<BigUint<M>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn from(value: BigUint<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, NumDecimals>

fn from(value: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> ManagedVecItem for ManagedDecimal<M, ConstDecimals<DECIMALS>>

const SKIPS_RESERIALIZATION: bool = false

If true, then the encoding of the item is identical to the payload, and no further conversion is necessary (the underlying buffer can be used as-is during serialization). False for all managed types, but true for basic types (like u32).

type PAYLOAD = ManagedVecItemPayloadBuffer<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>

Type managing the underlying binary representation in a ManagedVec..

type Ref<'a> = Ref<'a, ManagedDecimal<M, ConstDecimals<DECIMALS>>>

Reference representation of the ManagedVec item.

unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self

Parses given bytes as a an owned object.

unsafe fn borrow_from_payload<'a>(payload: &Self::PAYLOAD) -> Self::Ref<'a>

Parses given bytes as a representation of the object, either owned, or a reference.

fn save_to_payload(self, payload: &mut Self::PAYLOAD)

Converts the object into bytes.

fn requires_drop() -> bool

Signals that vec should drop all items one by one when being itself dropped.

fn payload_size() -> usize

fn temp_decode<F, R>(payload: &Self::PAYLOAD, f: F) -> R

where F: FnOnce(&Self) -> R,

impl<M: ManagedTypeApi> ManagedVecItem for ManagedDecimal<M, NumDecimals>

const SKIPS_RESERIALIZATION: bool = false

If true, then the encoding of the item is identical to the payload, and no further conversion is necessary (the underlying buffer can be used as-is during serialization). False for all managed types, but true for basic types (like u32).

type PAYLOAD = ManagedVecItemPayloadBuffer<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>

Type managing the underlying binary representation in a ManagedVec..

type Ref<'a> = Ref<'a, ManagedDecimal<M, usize>>

Reference representation of the ManagedVec item.

unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self

Parses given bytes as a an owned object.

unsafe fn borrow_from_payload<'a>(payload: &Self::PAYLOAD) -> Self::Ref<'a>

Parses given bytes as a representation of the object, either owned, or a reference.

fn save_to_payload(self, payload: &mut Self::PAYLOAD)

Converts the object into bytes.

fn requires_drop() -> bool

Signals that vec should drop all items one by one when being itself dropped.

fn payload_size() -> usize

fn temp_decode<F, R>(payload: &Self::PAYLOAD, f: F) -> R

where F: FnOnce(&Self) -> R,

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Mul<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the * operator.

fn mul(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the * operation.

impl<M: ManagedTypeApi, D1, D2: Decimals> Mul<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

where D1: Add<D2> + Decimals, <D1 as Add<D2>>::Output: Decimals,

type Output = ManagedDecimal<M, <D1 as Add<D2>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: ManagedDecimal<M, D2>) -> Self::Output

Performs the * operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Mul<ManagedDecimal<M, usize>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the * operator.

fn mul(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the * operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> MulAssign<&ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn mul_assign(&mut self, rhs: &ManagedDecimal<M, D2>)

Performs the *= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> MulAssign<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn mul_assign(&mut self, rhs: ManagedDecimal<M, D2>)

Performs the *= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> NestedDecode for ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Self, H::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

Version of dep_decode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_decode<I>(input: &mut I) -> Result<Self, DecodeError>

where I: NestedDecodeInput,

Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation.

impl<M: ManagedTypeApi> NestedDecode for ManagedDecimal<M, NumDecimals>

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Self, H::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

Version of dep_decode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_decode<I>(input: &mut I) -> Result<Self, DecodeError>

where I: NestedDecodeInput,

Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> NestedEncode for ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn dep_encode_or_handle_err<O, H>( &self, dest: &mut O, h: H, ) -> Result<(), H::HandledErr>

where O: NestedEncodeOutput, H: EncodeErrorHandler,

Version of dep_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError>

where O: NestedEncodeOutput,

NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version.

impl<M: ManagedTypeApi> NestedEncode for ManagedDecimal<M, NumDecimals>

fn dep_encode_or_handle_err<O, H>( &self, dest: &mut O, h: H, ) -> Result<(), H::HandledErr>

where O: NestedEncodeOutput, H: EncodeErrorHandler,

Version of dep_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError>

where O: NestedEncodeOutput,

NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> PartialEq<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn eq(&self, other: &ManagedDecimal<M, D2>) -> 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<M: ManagedTypeApi, D1: Decimals, D2: Decimals> PartialOrd<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn partial_cmp(&self, other: &ManagedDecimal<M, D2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<M: ManagedTypeApi, D: Decimals> SCDisplay for ManagedDecimal<M, D>

fn fmt<F: FormatByteReceiver>(&self, f: &mut F)

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Sub<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the - operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Sub<ManagedDecimal<M, usize>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> Sub for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimal<M, ConstDecimals<DECIMALS>>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimal<M, ConstDecimals<DECIMALS>>) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi> Sub for ManagedDecimal<M, NumDecimals>

type Output = ManagedDecimal<M, usize>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimal<M, NumDecimals>) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> SubAssign<&ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn sub_assign(&mut self, rhs: &ManagedDecimal<M, D2>)

Performs the -= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> SubAssign<ManagedDecimal<M, D2>> for ManagedDecimal<M, D1>

fn sub_assign(&mut self, rhs: ManagedDecimal<M, D2>)

Performs the -= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TopDecode for ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn top_decode_or_handle_err<I, H>(input: I, h: H) -> Result<Self, H::HandledErr>

where I: TopDecodeInput, H: DecodeErrorHandler,

Version of top_decode that can handle errors as soon as they occur. For instance it can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_decode<I>(input: I) -> Result<Self, DecodeError>

where I: TopDecodeInput,

Attempt to deserialize the value from input.

impl<M: ManagedTypeApi> TopDecode for ManagedDecimal<M, NumDecimals>

fn top_decode_or_handle_err<I, H>( top_input: I, h: H, ) -> Result<Self, H::HandledErr>

where I: TopDecodeInput, H: DecodeErrorHandler,

Version of top_decode that can handle errors as soon as they occur. For instance it can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_decode<I>(input: I) -> Result<Self, DecodeError>

where I: TopDecodeInput,

Attempt to deserialize the value from input.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TopEncode for ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn top_encode_or_handle_err<O, H>( &self, output: O, h: H, ) -> Result<(), H::HandledErr>

where O: TopEncodeOutput, H: EncodeErrorHandler,

Version of top_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_encode<O>(&self, output: O) -> Result<(), EncodeError>

where O: TopEncodeOutput,

Attempt to serialize the value to output.

impl<M: ManagedTypeApi> TopEncode for ManagedDecimal<M, NumDecimals>

fn top_encode_or_handle_err<O, H>( &self, output: O, h: H, ) -> Result<(), H::HandledErr>

where O: TopEncodeOutput, H: EncodeErrorHandler,

Version of top_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_encode<O>(&self, output: O) -> Result<(), EncodeError>

where O: TopEncodeOutput,

Attempt to serialize the value to output.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TypeAbi for ManagedDecimal<M, ConstDecimals<DECIMALS>>

type Unmanaged = ManagedDecimal<M, ConstDecimals<DECIMALS>>

fn type_name() -> TypeName

The type name, as it shows up in the ABI.

fn type_name_rust() -> TypeName

The type name as it shows up in Rust code. Used for proxies.

fn type_names() -> TypeNames

fn type_name_specific() -> Option<TypeName>

Specific name to be optionally added to the ABI.

fn provide_type_descriptions<TDC: TypeDescriptionContainer>( accumulator: &mut TDC, )

A type can provide more than its own name. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait.

impl<M: ManagedTypeApi> TypeAbi for ManagedDecimal<M, NumDecimals>

type Unmanaged = ManagedDecimal<M, usize>

fn type_name() -> TypeName

The type name, as it shows up in the ABI.

fn type_name_rust() -> TypeName

The type name as it shows up in Rust code. Used for proxies.

fn type_names() -> TypeNames

fn type_name_specific() -> Option<TypeName>

Specific name to be optionally added to the ABI.

fn provide_type_descriptions<TDC: TypeDescriptionContainer>( accumulator: &mut TDC, )

A type can provide more than its own name. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TypeAbiFrom<ManagedDecimal<M, ConstDecimals<DECIMALS>>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

impl<M: ManagedTypeApi> TypeAbiFrom<ManagedDecimal<M, usize>> for ManagedDecimal<M, NumDecimals>