Struct BigUint 

pub struct BigUint<M: ManagedTypeApi> { /* private fields */ }

A big, unsigned number.

Guaranteed to never be negative by construction and guarded operations.

Implementations

impl<M: ManagedTypeApi> BigUint<M>

pub unsafe fn new_unchecked(bi: BigInt<M>) -> Self

Creates a new BigUint from a BigInt without checking invariants.

Safety

The value needs to be >= 0, otherwise the invariant is broken and subtle bugs can appear.

pub unsafe fn new_uninit() -> Self

Creates a new object, without initializing it.

Safety

The value needs to be initialized after creation, otherwise the VM will halt the first time the value is attempted to be read.

pub fn as_big_int(&self) -> &BigInt<M>

pub fn into_big_int(self) -> BigInt<M>

pub fn into_non_zero(self) -> Option<NonZeroBigUint<M>>

Converts this BigUint into a NonZeroBigUint, returning Some if the value is non-zero, or None if it is zero.

Returns

• Some(NonZeroBigUint) if the value is non-zero.
• None if the value is zero.

Example

let big = BigUint::from(5u32);
let non_zero = big.into_non_zero();
assert!(non_zero.is_some());

pub fn into_non_zero_or_panic(self) -> NonZeroBigUint<M>

Converts this BigUint into a NonZeroBigUint, panicking if the value is zero.

Panics

Panics if the value is zero.

Example

let big = BigUint::from(5u32);
let non_zero = big.into_non_zero_or_panic();
// Succeeds if value is non-zero, panics otherwise

impl<M: ManagedTypeApi> BigUint<M>

pub fn to_alloc(&self) -> BigUint

impl<M: ManagedTypeApi> BigUint<M>

More conversions here.

pub fn zero() -> Self

pub fn zero_ref() -> ManagedRef<'static, M, BigUint<M>>

pub fn to_u64(&self) -> Option<u64>

pub fn overwrite_u64(&mut self, value: u64)

pub fn from_bytes_be(bytes: &[u8]) -> Self

pub fn to_bytes_be(&self) -> BoxedBytes

pub fn from_bytes_be_buffer(managed_buffer: &ManagedBuffer<M>) -> Self

pub fn to_bytes_be_buffer(&self) -> ManagedBuffer<M>

impl<M: ManagedTypeApi> BigUint<M>

pub fn sqrt(&self) -> Self

pub fn pow(&self, exp: u32) -> Self

pub fn log2_floor(&self) -> Option<u32>

The whole part of the base-2 logarithm.

Obtained by counting the significant bits. More specifically, the log2 floor is the position of the most significant bit minus one.

Will return None for the number zero (the logarithm in this case would approach -inf).

pub fn into_proportion(self, part: u64, total: u64) -> Self

Calculates proportion of this value, consuming self.

Arguments

• part - The numerator value (e.g., 1000 for 1% when total is 100000)
• total - The denominator value for the ratio calculation (e.g., 100 for percentage, 100000 for basis points)

Returns

The proportional amount as BigUint (self * part / total)

Notes

Both part and total must be at most i64::MAX. Values exceeding this limit will cause an error.

Example

let amount = BigUint::from(1000u32);
let result = amount.into_proportion(5u32, 100u32); // 5/100 of 1000 = 50

pub fn proportion(&self, part: u64, total: u64) -> Self

Calculates proportion of this value.

Arguments

• part - The numerator value (e.g., 1000 for 1% when total is 100000)
• total - The denominator value for the ratio calculation (e.g., 100 for percentage, 100000 for basis points)

Returns

The proportional amount as BigUint (self * part / total)

Notes

Both part and total must be at most i64::MAX. Values exceeding this limit will cause an error.

Example

let amount = BigUint::from(1000u32);
let result = amount.proportion(5u32, 100u32); // 5/100 of 1000 = 50

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

Natural logarithm of a number.

Returns None for 0.

impl<M: ManagedTypeApi> BigUint<M>

pub fn to_display(&self) -> ManagedBuffer<M>

Creates to a managed buffer containing the textual representation of the number.

Trait Implementations

impl<'a, 'b, M: ManagedTypeApi> Add<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: &BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<'b, M: ManagedTypeApi> Add<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: &BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<'b, M: ManagedTypeApi> Add<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<'a, M: ManagedTypeApi> Add<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u32) -> BigUint<M>

Performs the + operation.

impl<M: ManagedTypeApi> Add<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u32) -> BigUint<M>

Performs the + operation.

impl<'a, M: ManagedTypeApi> Add<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u64) -> BigUint<M>

Performs the + operation.

impl<M: ManagedTypeApi> Add<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u64) -> BigUint<M>

Performs the + operation.

impl<M: ManagedTypeApi> Add for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<M: ManagedTypeApi> AddAssign<&BigUint<M>> for BigUint<M>

fn add_assign(&mut self, other: &BigUint<M>)

Performs the += operation.

impl<M: ManagedTypeApi> AddAssign<&BigUint<M>> for NonZeroBigUint<M>

fn add_assign(&mut self, other: &BigUint<M>)

Performs the += operation.

impl<M: ManagedTypeApi> AddAssign<BigUint<M>> for NonZeroBigUint<M>

fn add_assign(&mut self, other: BigUint<M>)

Performs the += operation.

impl<M: ManagedTypeApi> AddAssign<u32> for BigUint<M>

fn add_assign(&mut self, other: u32)

Performs the += operation.

impl<M: ManagedTypeApi> AddAssign<u64> for BigUint<M>

fn add_assign(&mut self, other: u64)

Performs the += operation.

impl<M: ManagedTypeApi> AddAssign for BigUint<M>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for &BigUint<Env::Api>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<Env::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<Env::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for ()

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

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

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for BigUint<Env::Api>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<Env::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<Env::Api>) -> R,

Can be used when working with references only.

impl<Env, EgldValue> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for Egld<EgldValue>

where Env: TxEnv, EgldValue: TxEgldValue<Env>,

fn annotation(&self, env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> BigUint<Env::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&BigUint<Env::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for ManagedRef<'_, Env::Api, BigUint<Env::Api>>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<Env::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<Env::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for NotPayable

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

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

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for i32

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

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

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for u128

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

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

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for u64

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

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

Can be used when working with references only.

impl<'a, 'b, M: ManagedTypeApi> BitAnd<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: &BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<'b, M: ManagedTypeApi> BitAnd<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: &BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<'b, M: ManagedTypeApi> BitAnd<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<'a, M: ManagedTypeApi> BitAnd<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> BigUint<M>

Performs the & operation.

impl<M: ManagedTypeApi> BitAnd<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> BigUint<M>

Performs the & operation.

impl<'a, M: ManagedTypeApi> BitAnd<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> BigUint<M>

Performs the & operation.

impl<M: ManagedTypeApi> BitAnd<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> BigUint<M>

Performs the & operation.

impl<M: ManagedTypeApi> BitAnd for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<M: ManagedTypeApi> BitAndAssign<&BigUint<M>> for BigUint<M>

fn bitand_assign(&mut self, other: &BigUint<M>)

Performs the &= operation.

impl<M: ManagedTypeApi> BitAndAssign<u32> for BigUint<M>

fn bitand_assign(&mut self, other: u32)

Performs the &= operation.

impl<M: ManagedTypeApi> BitAndAssign<u64> for BigUint<M>

fn bitand_assign(&mut self, other: u64)

Performs the &= operation.

impl<M: ManagedTypeApi> BitAndAssign for BigUint<M>

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<'a, 'b, M: ManagedTypeApi> BitOr<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: &BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<'b, M: ManagedTypeApi> BitOr<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: &BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<'b, M: ManagedTypeApi> BitOr<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<'a, M: ManagedTypeApi> BitOr<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> BigUint<M>

Performs the | operation.

impl<M: ManagedTypeApi> BitOr<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> BigUint<M>

Performs the | operation.

impl<'a, M: ManagedTypeApi> BitOr<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> BigUint<M>

Performs the | operation.

impl<M: ManagedTypeApi> BitOr<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> BigUint<M>

Performs the | operation.

impl<M: ManagedTypeApi> BitOr for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<M: ManagedTypeApi> BitOrAssign<&BigUint<M>> for BigUint<M>

fn bitor_assign(&mut self, other: &BigUint<M>)

Performs the |= operation.

impl<M: ManagedTypeApi> BitOrAssign<u32> for BigUint<M>

fn bitor_assign(&mut self, other: u32)

Performs the |= operation.

impl<M: ManagedTypeApi> BitOrAssign<u64> for BigUint<M>

fn bitor_assign(&mut self, other: u64)

Performs the |= operation.

impl<M: ManagedTypeApi> BitOrAssign for BigUint<M>

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<'a, 'b, M: ManagedTypeApi> BitXor<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<'b, M: ManagedTypeApi> BitXor<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<'b, M: ManagedTypeApi> BitXor<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<'a, M: ManagedTypeApi> BitXor<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> BigUint<M>

Performs the ^ operation.

impl<M: ManagedTypeApi> BitXor<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> BigUint<M>

Performs the ^ operation.

impl<'a, M: ManagedTypeApi> BitXor<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> BigUint<M>

Performs the ^ operation.

impl<M: ManagedTypeApi> BitXor<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> BigUint<M>

Performs the ^ operation.

impl<M: ManagedTypeApi> BitXor for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<M: ManagedTypeApi> BitXorAssign<&BigUint<M>> for BigUint<M>

fn bitxor_assign(&mut self, other: &BigUint<M>)

Performs the ^= operation.

impl<M: ManagedTypeApi> BitXorAssign<u32> for BigUint<M>

fn bitxor_assign(&mut self, other: u32)

Performs the ^= operation.

impl<M: ManagedTypeApi> BitXorAssign<u64> for BigUint<M>

fn bitxor_assign(&mut self, other: u64)

Performs the ^= operation.

impl<M: ManagedTypeApi> BitXorAssign for BigUint<M>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<M: ManagedTypeApi> Clone for BigUint<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: ManagedTypeApi> Debug for BigUint<M>

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

Formats the value using the given formatter.

impl<M: ManagedTypeApi> Default for BigUint<M>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, 'b, M: ManagedTypeApi> Div<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: &BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<'b, M: ManagedTypeApi> Div<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: &BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<'b, M: ManagedTypeApi> Div<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<'a, M: ManagedTypeApi> Div<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u32) -> BigUint<M>

Performs the / operation.

impl<M: ManagedTypeApi> Div<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u32) -> BigUint<M>

Performs the / operation.

impl<'a, M: ManagedTypeApi> Div<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u64) -> BigUint<M>

Performs the / operation.

impl<M: ManagedTypeApi> Div<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u64) -> BigUint<M>

Performs the / operation.

impl<M: ManagedTypeApi> Div for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<M: ManagedTypeApi> DivAssign<&BigUint<M>> for BigUint<M>

fn div_assign(&mut self, other: &BigUint<M>)

Performs the /= operation.

impl<M: ManagedTypeApi> DivAssign<&BigUint<M>> for NonZeroBigUint<M>

fn div_assign(&mut self, other: &BigUint<M>)

Performs the /= operation.

impl<M: ManagedTypeApi> DivAssign<BigUint<M>> for NonZeroBigUint<M>

fn div_assign(&mut self, other: BigUint<M>)

Performs the /= operation.

impl<M: ManagedTypeApi> DivAssign<u32> for BigUint<M>

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<M: ManagedTypeApi> DivAssign<u64> for BigUint<M>

fn div_assign(&mut self, other: u64)

Performs the /= operation.

impl<M: ManagedTypeApi> DivAssign for BigUint<M>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<M: ManagedTypeApi> From<&BigUint<M>> for BigFloat<M>

fn from(item: &BigUint<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<&BigUint> for BigUint<M>

Available on crate feature num-bigint only.

fn from(alloc_big_uint: &BigUint) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<&ManagedBuffer<M>> for BigUint<M>

fn from(item: &ManagedBuffer<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<BigUint<M>> for BigFloat<M>

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

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<BigUint<M>> for BigInt<M>

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

Converts to this type from the input type.

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> From<BigUint> for BigUint<M>

Available on crate feature num-bigint only.

fn from(alloc_big_uint: BigUint) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<ManagedBuffer<M>> for BigUint<M>

fn from(item: ManagedBuffer<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<u128> for BigUint<M>

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<u16> for BigUint<M>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<u32> for BigUint<M>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<u64> for BigUint<M>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<u8> for BigUint<M>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<usize> for BigUint<M>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi> ManagedType<M> for BigUint<M>

type OwnHandle = <M as HandleTypeInfo>::BigIntHandle

fn get_handle(&self) -> M::BigIntHandle

unsafe fn forget_into_handle(self) -> Self::OwnHandle

Forgets current object (does not run destructor), but extracts the handle.

fn transmute_from_handle_ref(handle_ref: &M::BigIntHandle) -> &Self

Implement carefully, since the underlying transmutation is an unsafe operation. For types that wrap a handle to some VM-managed data, make sure the type only contains the handle (plus ZSTs if necessary). For types that just wrap another managed type it is easier, call for the wrapped object.

fn transmute_from_handle_ref_mut(handle_ref: &mut M::BigIntHandle) -> &mut Self

fn get_raw_handle(&self) -> RawHandle

fn get_raw_handle_unchecked(&self) -> RawHandle

fn as_ref(&self) -> ManagedRef<'_, M, Self>

impl<M: ManagedTypeApi> ManagedVecItem for BigUint<M>

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> = ManagedRef<'a, M, BigUint<M>>

Reference representation of the ManagedVec item.

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 payload_size() -> usize

impl<'a, 'b, M: ManagedTypeApi> Mul<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<'b, M: ManagedTypeApi> Mul<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<'b, M: ManagedTypeApi> Mul<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<'a, M: ManagedTypeApi> Mul<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> BigUint<M>

Performs the * operation.

impl<M: ManagedTypeApi> Mul<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> BigUint<M>

Performs the * operation.

impl<'a, M: ManagedTypeApi> Mul<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> BigUint<M>

Performs the * operation.

impl<M: ManagedTypeApi> Mul<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> BigUint<M>

Performs the * operation.

impl<M: ManagedTypeApi> Mul for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<M: ManagedTypeApi> MulAssign<&BigUint<M>> for BigUint<M>

fn mul_assign(&mut self, other: &BigUint<M>)

Performs the *= operation.

impl<M: ManagedTypeApi> MulAssign<&BigUint<M>> for NonZeroBigUint<M>

fn mul_assign(&mut self, other: &BigUint<M>)

Performs the *= operation.

impl<M: ManagedTypeApi> MulAssign<BigUint<M>> for NonZeroBigUint<M>

fn mul_assign(&mut self, other: BigUint<M>)

Performs the *= operation.

impl<M: ManagedTypeApi> MulAssign<u32> for BigUint<M>

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<M: ManagedTypeApi> MulAssign<u64> for BigUint<M>

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl<M: ManagedTypeApi> MulAssign for BigUint<M>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<M: ManagedTypeApi> NestedDecode for BigUint<M>

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> NestedEncode for BigUint<M>

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> Ord for BigUint<M>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<M: ManagedTypeApi> PartialEq<i32> for BigUint<M>

fn eq(&self, other: &i32) -> 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> PartialEq<i64> for BigUint<M>

fn eq(&self, other: &i64) -> 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> PartialEq<u32> for BigUint<M>

fn eq(&self, other: &u32) -> 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> PartialEq<u64> for BigUint<M>

fn eq(&self, other: &u64) -> 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> PartialEq for BigUint<M>

fn eq(&self, other: &Self) -> 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> PartialOrd<i32> for BigUint<M>

fn partial_cmp(&self, other: &i32) -> 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> PartialOrd<i64> for BigUint<M>

fn partial_cmp(&self, other: &i64) -> 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> PartialOrd<u32> for BigUint<M>

fn partial_cmp(&self, other: &u32) -> 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> PartialOrd<u64> for BigUint<M>

fn partial_cmp(&self, other: &u64) -> 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> PartialOrd for BigUint<M>

fn partial_cmp(&self, other: &Self) -> 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<'a, 'b, M: ManagedTypeApi> Rem<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<'b, M: ManagedTypeApi> Rem<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<'b, M: ManagedTypeApi> Rem<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<'a, M: ManagedTypeApi> Rem<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> BigUint<M>

Performs the % operation.

impl<M: ManagedTypeApi> Rem<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> BigUint<M>

Performs the % operation.

impl<'a, M: ManagedTypeApi> Rem<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> BigUint<M>

Performs the % operation.

impl<M: ManagedTypeApi> Rem<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> BigUint<M>

Performs the % operation.

impl<M: ManagedTypeApi> Rem for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<M: ManagedTypeApi> RemAssign<&BigUint<M>> for BigUint<M>

fn rem_assign(&mut self, other: &BigUint<M>)

Performs the %= operation.

impl<M: ManagedTypeApi> RemAssign<&BigUint<M>> for NonZeroBigUint<M>

fn rem_assign(&mut self, other: &BigUint<M>)

Performs the %= operation.

impl<M: ManagedTypeApi> RemAssign<BigUint<M>> for NonZeroBigUint<M>

fn rem_assign(&mut self, other: BigUint<M>)

Performs the %= operation.

impl<M: ManagedTypeApi> RemAssign<u32> for BigUint<M>

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<M: ManagedTypeApi> RemAssign<u64> for BigUint<M>

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

impl<M: ManagedTypeApi> RemAssign for BigUint<M>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<M: ManagedTypeApi> SCDisplay for BigUint<M>

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

impl<'a, M: ManagedTypeApi> Shl<usize> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> BigUint<M>

Performs the << operation.

impl<M: ManagedTypeApi> Shl<usize> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> BigUint<M>

Performs the << operation.

impl<M: ManagedTypeApi> ShlAssign<usize> for BigUint<M>

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'a, M: ManagedTypeApi> Shr<usize> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> BigUint<M>

Performs the >> operation.

impl<M: ManagedTypeApi> Shr<usize> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> BigUint<M>

Performs the >> operation.

impl<M: ManagedTypeApi> ShrAssign<usize> for BigUint<M>

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<'a, 'b, M: ManagedTypeApi> Sub<&'b BigUint<M>> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<'b, M: ManagedTypeApi> Sub<&'b BigUint<M>> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<'b, M: ManagedTypeApi> Sub<BigUint<M>> for &'b BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<'a, M: ManagedTypeApi> Sub<u32> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> BigUint<M>

Performs the - operation.

impl<M: ManagedTypeApi> Sub<u32> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> BigUint<M>

Performs the - operation.

impl<'a, M: ManagedTypeApi> Sub<u64> for &'a BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> BigUint<M>

Performs the - operation.

impl<M: ManagedTypeApi> Sub<u64> for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> BigUint<M>

Performs the - operation.

impl<M: ManagedTypeApi> Sub for BigUint<M>

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<M: ManagedTypeApi> SubAssign<&BigUint<M>> for BigUint<M>

fn sub_assign(&mut self, other: &BigUint<M>)

Performs the -= operation.

impl<M: ManagedTypeApi> SubAssign<&BigUint<M>> for NonZeroBigUint<M>

fn sub_assign(&mut self, other: &BigUint<M>)

Performs the -= operation.

impl<M: ManagedTypeApi> SubAssign<BigUint<M>> for NonZeroBigUint<M>

fn sub_assign(&mut self, other: BigUint<M>)

Performs the -= operation.

impl<M: ManagedTypeApi> SubAssign<u32> for BigUint<M>

fn sub_assign(&mut self, other: u32)

Performs the -= operation.

impl<M: ManagedTypeApi> SubAssign<u64> for BigUint<M>

fn sub_assign(&mut self, other: u64)

Performs the -= operation.

impl<M: ManagedTypeApi> SubAssign for BigUint<M>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<M: ManagedTypeApi> TopDecode for BigUint<M>

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> TopEncode for BigUint<M>

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> TryFrom<BigUint<M>> for NonZeroBigUint<M>

type Error = NonZeroError

The type returned in the event of a conversion error.

fn try_from(bu: BigUint<M>) -> Result<Self, Self::Error>

Performs the conversion.

impl<M: ManagedTypeApi> TryStaticCast for BigUint<M>

fn type_eq<U>() -> bool

where U: TryStaticCast,

fn try_cast<U>(self) -> Option<U>

where U: TryStaticCast,

fn try_cast_ref<U>(&self) -> Option<&U>

where U: TryStaticCast,

impl<M: ManagedTypeApi> TypeAbi for BigUint<M>

type Unmanaged = BigUint

fn type_name() -> TypeName

fn type_name_rust() -> TypeName

fn type_names() -> TypeNames

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> Eq for BigUint<M>

impl<Env> TxEgldValue<Env> for &BigUint<Env::Api>

where Env: TxEnv,

impl<Env> TxEgldValue<Env> for BigUint<Env::Api>

where Env: TxEnv,

impl<M> TypeAbiFrom<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

impl<M: ManagedTypeApi> TypeAbiFrom<BigUint<M>> for BigUint

Available on crate feature num-bigint only.

impl<M> TypeAbiFrom<BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

impl<M: ManagedTypeApi> TypeAbiFrom<BigUint> for BigUint<M>

Available on crate feature num-bigint only.

impl<M: ManagedTypeApi> TypeAbiFrom<u128> for BigUint<M>

impl<M: ManagedTypeApi> TypeAbiFrom<u16> for BigUint<M>

impl<M: ManagedTypeApi> TypeAbiFrom<u32> for BigUint<M>

impl<M: ManagedTypeApi> TypeAbiFrom<u64> for BigUint<M>

impl<M: ManagedTypeApi> TypeAbiFrom<u8> for BigUint<M>

impl<M: ManagedTypeApi> TypeAbiFrom<usize> for BigUint<M>