Add u256 conversions (#5767)

## Description
Adds conversion methods from u8, u16, u32, u64, b256 to u256, and u256
to b256

Closes #4800

## Checklist

- [ ] I have linked to any relevant issues.
- [ ] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [ ] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [ ] I have requested a review from the relevant team or maintainers.

Author: SwayStar123

sway-lib-std/src/primitive_conversions.sw

@@ -6,3 +6,4 @@ pub mod u8;
 pub mod u16;
 pub mod u32;
 pub mod u64;
+pub mod u256;

sway-lib-std/src/primitive_conversions/b256.sw

@@ -1,7 +1,7 @@
 library;
 
 use ::bytes::Bytes;
-use ::convert::TryFrom;
+use ::convert::{From, TryFrom};
 use ::option::Option::{self, *};
 
 impl TryFrom<Bytes> for b256 {
@@ -17,8 +17,28 @@ impl TryFrom<Bytes> for b256 {
     }
 }
 
+impl From<u256> for b256 {
+    /// Casts a `u256` to raw `b256` data.
+    ///
+    /// # Returns
+    ///
+    /// * [b256] - The underlying raw `b256` data of the `u256`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    ///
+    /// fn foo() {
+    ///     let b256_value = b256::from(0x0000000000000000000000000000000000000000000000000000000000000000_u256);
+    /// }
+    /// ```
+    fn from(num: u256) -> Self {
+        num.as_b256()
+    }
+}
+
 #[test]
-fn test_b256_try_from() {
+fn test_b256_try_from_bytes() {
     use ::assert::assert;
 
     let mut initial_bytes = Bytes::with_capacity(32);
@@ -47,3 +67,12 @@ fn test_b256_try_from() {
     assert(second_bytes.len() == 33);
     assert(second_bytes.capacity() == 33);
 }
+
+#[test]
+fn test_b256_from_u256() {
+    use ::assert::assert;
+
+    let val = 0x0000000000000000000000000000000000000000000000000000000000000000_u256;
+    let res = b256::from(val);
+    assert(res == 0x0000000000000000000000000000000000000000000000000000000000000000);
+}

sway-lib-std/src/primitive_conversions/u256.sw

@@ -0,0 +1,181 @@
+library;
+
+use ::convert::From;
+
+/// Functions for casting between `u256` and other types.
+impl From<u8> for u256 {
+    /// Casts a `u8` to a `u256`.
+    ///
+    /// # Arguments
+    ///
+    /// * `num`: [u8] - The `u8` to be casted.
+    ///
+    /// # Returns
+    ///
+    /// * [u256] - The `u256` representation of the `u8` value.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    ///
+    /// fn foo() {
+    ///    let u256_value = u256::from(255_u8);
+    /// }
+    /// ```
+    fn from(num: u8) -> Self {
+        num.as_u256()
+    }
+}
+
+impl From<u16> for u256 {
+    /// Casts a `u16` to a `u256`.
+    ///
+    /// # Arguments
+    ///
+    /// * `num`: [u16] - The `u16` to be casted.
+    ///
+    /// # Returns
+    ///
+    /// * [u256] - The `u256` representation of the `u16` value.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    ///
+    /// fn foo() {
+    ///    let u256_value = u256::from(65535_u16);
+    /// }
+    /// ```
+    fn from(num: u16) -> Self {
+        num.as_u256()
+    }
+}
+
+impl From<u32> for u256 {
+    /// Casts a `u32` to a `u256`.
+    ///
+    /// # Arguments
+    ///
+    /// * `num`: [u32] - The `u32` to be casted.
+    ///
+    /// # Returns
+    ///
+    /// * [u256] - The `u256` representation of the `u32` value.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    ///
+    /// fn foo() {
+    ///    let u256_value = u256::from(4294967295_u32);
+    /// }
+    /// ```
+    fn from(num: u32) -> Self {
+        num.as_u256()
+    }
+}
+
+impl From<u64> for u256 {
+    /// Casts a `u64` to a `u256`.
+    ///
+    /// # Arguments
+    ///
+    /// * `num`: [u64] - The `u64` to be casted.
+    ///
+    /// # Returns
+    ///
+    /// * [u256] - The `u256` representation of the `u64` value.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    ///
+    /// fn foo() {
+    ///    let u256_value = u256::from(18446744073709551615_u64);
+    /// }
+    /// ```
+    fn from(num: u64) -> Self {
+        num.as_u256()
+    }
+}
+
+impl From<b256> for u256 {
+    /// 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
+    ///
+    /// ```sway
+    /// use std::constants::ZERO_B256;
+    ///
+    /// fn foo() {
+    ///    let u256_value = u256::from(ZERO_B256);
+    /// }
+    /// ```
+    fn from(bits: b256) -> Self {
+        bits.as_u256()
+    }
+}
+
+// TODO: Replace <u256 as From<T>> with u256::from when https://github.com/FuelLabs/sway/issues/5798 is resolved.
+#[test]
+fn test_u256_from_u8() {
+    use ::assert::assert;
+
+    let u256_value = <u256 as From<u8>>::from(255_u8);
+    assert(
+        u256_value == 0x00000000000000000000000000000000000000000000000000000000000000ff_u256,
+    );
+}
+
+#[test]
+fn test_u256_from_u16() {
+    use ::assert::assert;
+
+    let u256_value = <u256 as From<u16>>::from(65535_u16);
+    assert(
+        u256_value == 0x000000000000000000000000000000000000000000000000000000000000ffff_u256,
+    );
+}
+
+#[test]
+fn test_u256_from_u32() {
+    use ::assert::assert;
+
+    let u256_value = <u256 as From<u32>>::from(4294967295_u32);
+    assert(
+        u256_value == 0x00000000000000000000000000000000000000000000000000000000ffffffff_u256,
+    );
+}
+
+#[test]
+fn test_u256_from_u64() {
+    use ::assert::assert;
+
+    let u256_value = <u256 as From<u64>>::from(18446744073709551615_u64);
+    assert(
+        u256_value == 0x000000000000000000000000000000000000000000000000ffffffffffffffff_u256,
+    );
+}
+
+#[test]
+fn test_u256_from_b256() {
+    use ::assert::assert;
+
+    let u256_value = <u256 as From<b256>>::from(0x0000000000000000000000000000000000000000000000000000000000000000);
+    assert(
+        u256_value == 0x0000000000000000000000000000000000000000000000000000000000000000_u256,
+    );
+
+    let u256_value = <u256 as From<b256>>::from(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
+    assert(
+        u256_value == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff_u256,
+    );
+}

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-conversions/reduced_lib.config

@@ -29,4 +29,5 @@ primitive_conversions/str.sw
 primitive_conversions/u16.sw
 primitive_conversions/u32.sw
 primitive_conversions/u64.sw
+primitive_conversions/u256.sw
 primitive_conversions/u8.sw