Primitive std::u256

u256
Expand description
256-bit unsigned integer

Implementations

pub fn min() -> Self

The smallest value that can be represented by this integer type.

Returns

  • [u256] - The smallest u256 value.

Examples

fn foo() {
    let val = u256::min();
    assert(val == 0x0000000000000000000000000000000000000000000000000000000000000000u256);

pub fn max() -> Self

The largest value that can be represented by this integer type,
2256 - 1.

Returns

  • [u256] - The largest u256 value.

Examples

fn foo() {
    let val = u256::max();
    assert(val == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFu256);
}

pub fn bits() -> u64

The size of this integer type in bits.

Returns

  • [u32] - The number of bits for a u256.

Examples

fn foo() {
    let bits = u256::bits();
    assert(bits == 256);
}

pub fn zero() -> Self

Returns the zero value for the u256 type.

Returns

  • [u256] -> The zero value for the u256 type.

Examples

fn foo() {
    let zero_u256 = u256::zero();
    assert(zero_u256 == 0x00u256);
}

pub fn wrapping_add(self, other: Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, other: Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, other: Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

pub fn is_zero(self) -> bool

Returns whether a u256 is set to zero.

Returns

  • [bool] -> True if the u256 is zero, otherwise false.

Examples

fn foo() {
    let zero_u256 = u256::zero();
    assert(zero_u256.is_zero());
}

pub fn as_b256(self) -> b256

Converts a u256 to a b256.

Returns

  • [b256] - The converted u256 value.

Examples

fn foo() {
    let val: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
    let result = val.as_b256();
    assert(result == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
}

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

Converts the u256 to a sequence of little-endian bytes.

Returns

  • [[u8; 32]] - An array of 32 u8 bytes that compose the u256.

Examples

fn foo() {
    let bytes = [32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8,
            22_u8, 21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8,
            12_u8, 11_u8, 10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8,
            2_u8, 1_u8];

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
}

pub fn from_le_bytes(bytes: [u8; 32]) -> Self

Converts a sequence of little-endian bytes to a u256.

Arguments

  • bytes: [[u8; 32]] - A sequence of 32 u8 bytes that represent a u256.

Returns

  • [u256] - The resulting u256 value.

Examples

fn foo() {
    let bytes = [32_u8, 31_u8, 30_u8, 29_u8, 28_u8, 27_u8, 26_u8, 25_u8, 24_u8, 23_u8,
            22_u8, 21_u8, 20_u8, 19_u8, 18_u8, 17_u8, 16_u8, 15_u8, 14_u8, 13_u8,
            12_u8, 11_u8, 10_u8, 9_u8, 8_u8, 7_u8, 6_u8, 5_u8, 4_u8, 3_u8,
            2_u8, 1_u8];

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;

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

Converts the u256 to a sequence of big-endian bytes.

Returns

  • [[u8; 32]] - An array of 32 u8 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256;
    let bytes = x.to_be_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes[i.as_u64()] == i + 1_u8);
        i += 1_u8;
    }
}

pub fn from_be_bytes(bytes: [u8; 32]) -> Self

Converts a sequence of big-endian bytes to a u256.

Arguments

  • bytes: [[u8; 32]] - A sequence of 32 u8 bytes that represent a u256.

Returns

  • [u256] - The resulting u256 value.

Examples

fn foo() {
    let bytes = [1_u8, 2_u8, 3_u8, 4_u8, 5_u8, 6_u8, 7_u8, 8_u8, 9_u8, 10_u8,
            11_u8, 12_u8, 13_u8, 14_u8, 15_u8, 16_u8, 17_u8, 18_u8, 19_u8, 20_u8,
            21_u8, 22_u8, 23_u8, 24_u8, 25_u8, 26_u8, 27_u8, 28_u8, 29_u8, 30_u8,
            31_u8, 32_u8];
    let x = u256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);
}

pub fn to_le_bytes(self) -> Bytes

Converts the u256 to a sequence of little-endian bytes.

Returns

  • [Bytes] - The 32 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256;
    let bytes = x.to_le_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes.get(i.as_u64()).unwrap() == 32_u8 - i);
        i += 1_u8;
    }
}

pub fn from_le_bytes(bytes: Bytes) -> Self

Converts a sequence of little-endian bytes to a u256.

Arguments

  • bytes: [Bytes] - The 32 bytes that compose the u256.

Returns

  • [u256] - The resulting u256 value.

Examples

fn foo() {
    let mut bytes = Bytes::with_capacity(32);
    let mut i: u8 = 0;
    while i < 32_u8 {
        bytes.push(32_u8 - i);
        i += 1_u8;
    }

    let x = u256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256);
}

pub fn to_be_bytes(self) -> Bytes

Converts the u256 to a sequence of big-endian bytes.

Returns

  • [Bytes] - The 32 bytes that compose the u256.

Examples

fn foo() {
    let x: u256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256;
    let bytes = x.to_be_bytes();

    let mut i: u8 = 0;
    while i < 32_u8 {
        assert(bytes.get(i.as_u64()).unwrap() == i + 1_u8);
        i += 1_u8;
    }
}

pub fn from_be_bytes(bytes: Bytes) -> Self

Converts a sequence of big-endian bytes to a u256.

Arguments

  • bytes: [Bytes] - The 32 bytes that compose the u256.

Returns

  • [u256] - The resulting u256 value.

Examples

fn foo() {
    let mut bytes = Bytes::with_capacity(32);
    let mut i: u8 = 0;
    while i < 32_u8 {
        bytes.push(i + 1);
        i += 1_u8;
    }

    let x = u256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20_u256);
}

Trait Implementations

pub fn add(self, other: Self) -> Self

pub fn subtract(self, other: Self) -> Self

pub fn multiply(self, other: Self) -> Self

pub fn divide(self, other: Self) -> Self

pub fn modulo(self, other: Self) -> Self

pub fn not(self) -> Self

pub fn eq(self, other: Self) -> bool

pub fn neq(self, other: Self) -> bool

Evaluates if two values of the same type are not equal.

Additional Information

This function is inherited when eq() is implemented.

Arguments

  • other: [Self] - The value of the same type.

Returns

  • [bool] - true if the two values are not equal, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl PartialEq for MyStruct {
    fn eq(self, other: Self) -> bool {
         self.val == other.val
    }
}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 2 };
    let result = struct1 != struct2;
    assert(result);
}

pub fn gt(self, other: Self) -> bool

pub fn lt(self, other: Self) -> bool

pub fn binary_and(self, other: Self) -> Self

pub fn binary_or(self, other: Self) -> Self

pub fn binary_xor(self, other: Self) -> Self

pub fn ge(self, other: Self) -> bool

Evaluates if one value of the same type is greater or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

  • other: [Self] - The value of the same type.

Returns

  • [bool] - true if self is greater than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn gt(self, other: Self) -> bool {
        self.val > other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 >= struct2;
    assert(result);
}

pub fn le(self, other: Self) -> bool

Evaluates if one value of the same type is less or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

  • other: [Self] - The value of the same type.

Returns

  • [bool] - true if self is less than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn lt(self, other: Self) -> bool {
        self.val < other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 <= struct2;
    assert(result);
}

pub fn lsh(self, other: u64) -> Self

pub fn rsh(self, other: u64) -> Self

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

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

pub fn abi_encode(self, buffer: Buffer) -> Buffer

pub fn abi_decode(refmut buffer: BufferReader) -> u256

pub fn fmt(self, refmut f: Formatter)

pub fn clone(self) -> Self

pub fn hash(
self,
refmut state: Hasher,
)

pub fn try_from(val: B512) -> Option<Self>

Attempts conversion from a B512 to a u256.

Additional Information

If the high bits of the B512 are not zero, the conversion will fail.

Arguments

  • val: [B512] - The B512 to be converted.

Returns

  • [Option] - The u256 representation of the B512 value.

Examples

use std::b512::B512;

fn foo() {
    let b512_value = B512::new();
    let u256_value = u256::try_from(b512_value).unwrap();
}

pub fn from(num: u8) -> Self

Casts a u8 to a u256.

Arguments

  • num: [u8] - The u8 to be casted.

Returns

  • [u256] - The u256 representation of the u8 value.

Examples


fn foo() {
   let u256_value = u256::from(255_u8);
}

pub fn from(num: u16) -> Self

Casts a u16 to a u256.

Arguments

  • num: [u16] - The u16 to be casted.

Returns

  • [u256] - The u256 representation of the u16 value.

Examples


fn foo() {
   let u256_value = u256::from(65535_u16);
}

pub fn from(num: u32) -> Self

Casts a u32 to a u256.

Arguments

  • num: [u32] - The u32 to be casted.

Returns

  • [u256] - The u256 representation of the u32 value.

Examples


fn foo() {
   let u256_value = u256::from(4294967295_u32);
}

pub fn from(num: u64) -> Self

Casts a u64 to a u256.

Arguments

  • num: [u64] - The u64 to be casted.

Returns

  • [u256] - The u256 representation of the u64 value.

Examples


fn foo() {
   let u256_value = u256::from(18446744073709551615_u64);
}

pub fn from(bits: b256) -> Self

Casts raw b256 data to a u256.

Arguments

  • bits: [b256] - The raw b256 data to be casted.

Returns

  • [u256] - The u256 representation of the raw b256.

Examples

fn foo() {
   let u256_value = u256::zero();
}

pub fn from(nums: (u64, u64, u64, u64)) -> Self

Casts a tuple of 4 u64 values to a u256.

Arguments

  • nums: (u64, u64, u64, u64) - The tuple of u64 values to be casted.

Returns

  • [u256] - The u256 representation of the tuple of u64 values.

Examples


fn foo() {
   let u256_value = u256::from((1, 2, 3, 4));
}

pub fn sqrt(self) -> Self

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

Raises self to the power of exponent, using exponentiation by squaring.

Additional Information

  • If panic on overflow is disabled, and the result overflows, the return value will be 0.

Reverts

  • Reverts if the result overflows the type, if panic on overflow is enabled.

pub fn log2(self) -> Self

pub fn log(self, base: Self) -> Self

pub fn from(num: U128) -> Self

Converts a U128 to a u256.

Arguments

  • num: [U128] - The U128 to be converted.

Returns

  • [u256] - The u256 representation of the U128 value.

Examples

use std::u128::U128;

fn foo() {
   let u128_value = U128::from((18446744073709551615_u64, 18446744073709551615_u64));
   let u256_value = u256::from(u128_value);
}

pub fn try_from(scalar: Scalar) -> Option<Self>