Returns whether a b256 is set to zero.

Returns

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

Examples

fn foo() {
    let zero_b256 = b256::zero();
    assert(zero_b256.is_zero());
}

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

Returns

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

Examples

fn foo() {
    let x = b256::new(0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);

    let bytes = x.to_le_bytes();

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

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

Arguments

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

Returns

• [b256] - The resulting b256 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 = b256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);

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

Returns

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

Examples

fn foo() {
    let x: b256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
    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;
    }
}

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

Arguments

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

Returns

• [b256] - The resulting b256 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 = b256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
}

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

Returns

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

Examples

fn foo() {
    let x: b256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
    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;
    }
}

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

Arguments

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

Returns

• [b256] - The resulting b256 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 = b256::from_le_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
}

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

Returns

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

Examples

fn foo() {
    let x: b256 = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
    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;
    }
}

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

Arguments

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

Returns

• [b256] - The resulting b256 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 = b256::from_be_bytes(bytes);

    assert(x == 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20);
}

Attempts conversion from a B512 to a b256.

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 b256 representation of the B512 value.

Examples

use std::b512::B512;

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

Casts a u256 to raw b256 data.

Returns

• [b256] - The underlying raw b256 data of the u256.

Examples

fn foo() {
    let b256_value = b256::from(0x0000000000000000000000000000000000000000000000000000000000000000_u256);
}

Converts a U128 to a b256.

Arguments

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

Returns

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

Examples

use std::u128::U128;

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

Casts a tuple of 4 u64 values to a b256.

Arguments

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

Returns

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

Examples

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

Casts a ContractId to raw b256 data.

Returns

• [b256] - The underlying raw b256 data of the ContractId.

Examples

fn foo() {
    let contract_id = ContractId::from(b256::zero());
    let b256_data: b256 = contract_id.into();
    assert(b256_data == b256::zero());
}

Casts an AssetId to raw b256 data.

Returns

• [b256] - The underlying raw b256 data of the AssetId.

Examples

fn foo() {
    let asset_id = AssetId::b256::zero();
    let b256_data: b256 = asset_id.into();
    assert(b256_data == b256::zero());
}

Casts an Address to raw b256 data.

Returns

• [b256] - The underlying raw b256 data of the Address.

Examples

fn foo() {
    let address = Address::zero();
    let b256_data: b256 = address.into();
    assert(b256_data == b256::zero());
}

Casts an EvmAddress to raw b256 data.

Returns

• [b256] - The underlying raw b256 data of the EvmAddress.

Examples

use std::evm::EvmAddress;

fn foo() {
    let evm_address = EvmAddress::zero();
    let b256_data: b256 = evm_address.into();
    assert(b256_data == b256::zero());
}