Struct BlockHeight 

pub struct BlockHeight(/* private fields */);

This type must be able to represent any valid Ethereum block height. It must also be Borsh serializeable, so that it can be stored in blockchain storage.

In Ethereum, the type for block height is an arbitrary precision integer - see https://github.com/ethereum/go-ethereum/blob/v1.10.26/core/types/block.go#L79.

Implementations

impl BlockHeight

pub fn next(&self) -> BlockHeight

Get the next block height.

Panic

Panics on overflow.

pub fn unchecked_add(&self, rhs: impl Into<BlockHeight>) -> BlockHeight

Unchecked epoch addition.

Panic

Panics on overflow. Care must be taken to only use this with trusted values that are known to be in a limited range (e.g. system parameters but not e.g. transaction variables).

Methods from Deref<Target = Uint256>

pub fn to_be_bytes(&self) -> [u8; 32]

pub fn to_le_bytes(&self) -> [u8; 32]

pub fn to_int256(&self) -> Option<Int256>

Converts value to a signed 256 bit integer

pub fn sqrt(&self) -> Uint256

Square root

Methods from Deref<Target = BUint<bnum::::types::U256::{constant#0}>>

pub fn bits(&self) -> u32

Returns the smallest number of bits necessary to represent self.

This is equal to the size of the type in bits minus the leading zeros of self.

Examples

use bnum::types::U256;

assert_eq!(U256::from(0b1111001010100u16).bits(), 13);
assert_eq!(U256::ZERO.bits(), 0);

pub fn bit(&self, index: u32) -> bool

Returns a boolean representing the bit in the given position (true if the bit is set). The least significant bit is at index 0, the most significant bit is at index Self::BITS - 1

Examples

use bnum::types::U256;

let n = U256::from(0b001010100101010101u32);
assert!(n.bit(0));
assert!(!n.bit(1));
assert!(!n.bit(U256::BITS - 1));

pub fn digits(&self) -> &[u64; N]

Returns the digits stored in self as an array. Digits are little endian (least significant digit first).

pub fn is_zero(&self) -> bool

Returns whether self is zero.

Examples

use bnum::types::U256;

assert!(U256::ZERO.is_zero());
assert!(!U256::ONE.is_zero());

pub fn is_one(&self) -> bool

Returns whether self is one.

Examples

use bnum::types::U256;

assert!(U256::ONE.is_one());
assert!(!U256::MAX.is_one());

pub const MIN: BUint<N>

pub const MAX: BUint<N>

pub const BITS: u32

pub const BYTES: u32

pub const ZERO: BUint<N> = Self::MIN

pub const ONE: BUint<N>

pub const TWO: BUint<N>

pub const THREE: BUint<N>

pub const FOUR: BUint<N>

pub const FIVE: BUint<N>

pub const SIX: BUint<N>

pub const SEVEN: BUint<N>

pub const EIGHT: BUint<N>

pub const NINE: BUint<N>

pub const TEN: BUint<N>

pub fn to_str_radix(&self, radix: u32) -> String

Returns the integer as a string in the given radix.

Panics

This function panics if radix is not in the range from 2 to 36 inclusive.

Examples

use bnum::types::U512;

let src = "934857djkfghhkdfgbf9345hdfkh";
let n = U512::from_str_radix(src, 36).unwrap();
assert_eq!(n.to_str_radix(36), src);

pub fn to_radix_be(&self, radix: u32) -> Vec<u8>

Returns the integer in the given base in big-endian digit order.

Panics

This function panics if radix is not in the range from 2 to 256 inclusive.

use bnum::types::U512;

let digits = &[3, 55, 60, 100, 5, 0, 5, 88];
let n = U512::from_radix_be(digits, 120).unwrap();
assert_eq!(n.to_radix_be(120), digits);

pub fn to_radix_le(&self, radix: u32) -> Vec<u8>

Returns the integer in the given base in little-endian digit order.

Panics

This function panics if radix is not in the range from 2 to 256 inclusive.

use bnum::types::U512;

let digits = &[1, 67, 88, 200, 55, 68, 87, 120, 178];
let n = U512::from_radix_le(digits, 250).unwrap();
assert_eq!(n.to_radix_le(250), digits);

Trait Implementations

impl BorshDeserialize for BlockHeight

fn deserialize_reader<R>(reader: &mut R) -> Result<BlockHeight, Error>

where R: Read,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for BlockHeight

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

impl Clone for BlockHeight

fn clone(&self) -> BlockHeight

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockHeight

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

Formats the value using the given formatter.

impl Default for BlockHeight

fn default() -> BlockHeight

Returns the “default value” for a type.

impl Deref for BlockHeight

type Target = Uint256

The resulting type after dereferencing.

fn deref(&self) -> &<BlockHeight as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for BlockHeight

fn deserialize<__D>( __deserializer: __D, ) -> Result<BlockHeight, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BlockHeight

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

Formats the value using the given formatter.

impl<'a> From<&'a BlockHeight> for &'a Uint256

fn from(_: &'a BlockHeight) -> &'a Uint256

Converts to this type from the input type.

impl From<BlockHeight> for Uint256

fn from(_: BlockHeight) -> Uint256

Converts to this type from the input type.

impl From<NonZero<u64>> for BlockHeight

fn from(value: NonZero<u64>) -> BlockHeight

Converts to this type from the input type.

impl From<Uint256> for BlockHeight

fn from(value: Uint256) -> BlockHeight

Converts to this type from the input type.

impl From<u64> for BlockHeight

fn from(value: u64) -> BlockHeight

Converts to this type from the input type.

impl Hash for BlockHeight

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for BlockHeight

fn cmp(&self, other: &BlockHeight) -> 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 PartialEq for BlockHeight

fn eq(&self, other: &BlockHeight) -> 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 PartialOrd for BlockHeight

fn partial_cmp(&self, other: &BlockHeight) -> 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 Serialize for BlockHeight

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BlockHeight

impl StructuralPartialEq for BlockHeight