Struct U256Wrapper 

pub struct U256Wrapper(pub Uint<256, 4>);

A wrapper around U256 to represent a field element in the protocol. Wrapper enables FFI interoperability.

Most inputs and outputs from the zero-knowledge proofs are U256 values. While using U256 directly is convenient and recommended when working with the proofs, particularly in Rust, it is not a user-friendly type for interactions or communications in other languages / systems.

Particularly, when sending proof inputs/outputs as JSON on HTTP requests, the values SHOULD be represented as padded hex strings from Big Endian bytes.

Tuple Fields

0: Uint<256, 4>

Implementations

impl U256Wrapper

pub fn to_hex_string(&self) -> String

Outputs a hex string representation of the U256 value padded to 32 bytes (plus two bytes for the 0x prefix).

pub fn try_from_hex_string( hex_string: &str, ) -> Result<U256Wrapper, WalletKitError>

Attempts to parse a hex string as a U256 value (wrapped).

Errors

Will return an Error::InvalidNumber if the input is not a valid hex-string-presented number up to 256 bits.

pub fn from_u64(value: u64) -> U256Wrapper

Creates a U256 value from a u64 value.

Logically this will only support values up to 64 bits. For larger values a different initialization should be used.

pub fn from_u32(value: u32) -> U256Wrapper

Creates a U256 value from a u32 value.

Logically this will only support values up to 32 bits. For larger values a different initialization should be used.

pub fn from_limbs(limbs: Vec<u64>) -> Result<U256Wrapper, WalletKitError>

Creates a U256 value from an array of 4 u64 values (little-endian). Least significant limb first.

This is the same as the U256::from_limbs method, but exposed to foreign bindings.

Errors

Will return an Error::InvalidNumber if the input is not a valid U256 value.

pub fn into_limbs(self) -> Vec<u64>

Converts the U256 value into a vector of 4 u64 values (little-endian). Least significant limb first.

Using a vector as an array cannot be lowered to foreign bindings.

Methods from Deref<Target = Uint<256, 4>>

pub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in little-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in big-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

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

Returns whether a specific bit is set.

Returns false if index exceeds the bit width of the number.

pub fn byte(&self, index: usize) -> u8

Returns a specific byte. The byte at index 0 is the least significant byte (little endian).

Panics

Panics if index is greater than or equal to the byte width of the number.

Examples

let x = uint!(0x1234567890_U64);
let bytes = [
    x.byte(0), // 0x90
    x.byte(1), // 0x78
    x.byte(2), // 0x56
    x.byte(3), // 0x34
    x.byte(4), // 0x12
    x.byte(5), // 0x00
    x.byte(6), // 0x00
    x.byte(7), // 0x00
];
assert_eq!(bytes, x.to_le_bytes());

Panics if out of range.

let x = uint!(0x1234567890_U64);
let _ = x.byte(8);

pub fn checked_byte(&self, index: usize) -> Option<u8>

Returns a specific byte, or None if index is out of range. The byte at index 0 is the least significant byte (little endian).

Examples

let x = uint!(0x1234567890_U64);
assert_eq!(x.checked_byte(0), Some(0x90));
assert_eq!(x.checked_byte(7), Some(0x00));
// Out of range
assert_eq!(x.checked_byte(8), None);

pub fn leading_zeros(&self) -> usize

Returns the number of leading zeros in the binary representation of self.

pub fn leading_ones(&self) -> usize

Returns the number of leading ones in the binary representation of self.

pub fn trailing_zeros(&self) -> usize

Returns the number of trailing zeros in the binary representation of self.

pub fn trailing_ones(&self) -> usize

Returns the number of trailing ones in the binary representation of self.

pub fn count_ones(&self) -> usize

Returns the number of ones in the binary representation of self.

pub fn count_zeros(&self) -> usize

Returns the number of zeros in the binary representation of self.

pub fn bit_len(&self) -> usize

Returns the dynamic length of this number in bits, ignoring leading zeros.

For the maximum length of the type, use Uint::BITS.

pub fn byte_len(&self) -> usize

Returns the dynamic length of this number in bytes, ignoring leading zeros.

For the maximum length of the type, use Uint::BYTES.

pub fn most_significant_bits(&self) -> (u64, usize)

Returns the most significant 64 bits of the number and the exponent.

Given return value $(\mathtt{bits}, \mathtt{exponent})$, the self can be approximated as

$$ \mathtt{self} ≈ \mathtt{bits} ⋅ 2^\mathtt{exponent} $$

If self is $<≥> 2^{63}$, then exponent will be zero and bits will have leading zeros.

pub const BYTES: usize

pub fn as_le_slice(&self) -> &[u8]

Access the underlying store as a little-endian slice of bytes.

Only available on little-endian targets.

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position.

pub fn as_le_bytes(&self) -> Cow<'_, [u8]>

Access the underlying store as a little-endian bytes.

Uses an optimized implementation on little-endian targets.

pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>

Access the underlying store as a little-endian bytes with trailing zeros removed.

Uses an optimized implementation on little-endian targets.

pub fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a little-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_le_bytes_vec(&self) -> Vec<u8>

Converts the Uint to a little-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_le_bytes can not be used because byte size is not known compile time.

pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8>

Converts the Uint to a little-endian byte vector with trailing zeros bytes removed.

pub fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a big-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_be_bytes_vec(&self) -> Vec<u8>

Converts the Uint to a big-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_be_bytes can not be used because byte size is not known compile time.

pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8>

Converts the Uint to a big-endian byte vector with leading zeros bytes removed.

pub fn copy_le_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_le_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn copy_be_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_be_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn is_zero(&self) -> bool

Returns true if the value is zero.

pub fn const_is_zero(&self) -> bool

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

pub fn const_eq(&self, other: &Uint<BITS, LIMBS>) -> bool

Returns true if self equals other.

Note that this currently might perform worse than the derived PartialEq (== operator).

pub fn to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>, T: Debug,

Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the target type.

Examples

assert_eq!(300_U12.to::<i16>(), 300_i16);
assert_eq!(300_U12.to::<U256>(), 300_U256);

pub fn wrapping_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Examples

assert_eq!(300_U12.wrapping_to::<i8>(), 44_i8);
assert_eq!(255_U32.wrapping_to::<i8>(), -1_i8);
assert_eq!(0x1337cafec0d3_U256.wrapping_to::<U32>(), 0xcafec0d3_U32);

pub fn saturating_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Examples

assert_eq!(300_U12.saturating_to::<i16>(), 300_i16);
assert_eq!(255_U32.saturating_to::<i8>(), 127);
assert_eq!(0x1337cafec0d3_U256.saturating_to::<U32>(), U32::MAX);

pub const LIMBS: usize

pub const MASK: u64

pub const BITS: usize = BITS

pub const ZERO: Uint<BITS, LIMBS>

pub const ONE: Uint<BITS, LIMBS>

pub const MIN: Uint<BITS, LIMBS> = Self::ZERO

pub const MAX: Uint<BITS, LIMBS>

pub fn as_limbs(&self) -> &[u64; LIMBS]

View the array of limbs.

Trait Implementations

impl Clone for U256Wrapper

fn clone(&self) -> U256Wrapper

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for U256Wrapper

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

Formats the value using the given formatter.

impl Deref for U256Wrapper

type Target = Uint<256, 4>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de> Deserialize<'de> for U256Wrapper

fn deserialize<D>( deserializer: D, ) -> Result<U256Wrapper, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for U256Wrapper

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

Formats the value using the given formatter.

impl From<U256Wrapper> for Uint<256, 4>

fn from(val: U256Wrapper) -> Uint<256, 4>

Converts to this type from the input type.

impl From<Uint<256, 4>> for U256Wrapper

fn from(val: Uint<256, 4>) -> U256Wrapper

Converts to this type from the input type.

impl PartialEq for U256Wrapper

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

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 Copy for U256Wrapper

impl Eq for U256Wrapper

impl StructuralPartialEq for U256Wrapper