Optimize crypto module for bytecode size and gas usage (#7151)

## Description

This PR optimizes the `std::crypto` module for bytecode size and gas
cost by using optimization techniques similar to those used in #7087,
#7092, and #7096.

The optimized public functions are listed in the below code snippet.
**The bytecode size of that code got reduced from 46104 bytes to 44288
bytes.**

We actually expect a bigger gain here. At one point in the optimization,
the bytecode size went down to 33896 bytes. Bouncing back to ~44600 is
related to the issue described in #7150. Once that issue is solved, we
expect even smaller bytcode sizes.

```sway
script;

use std::crypto::ed25519::*;
use std::crypto::point2d::*;
use std::crypto::public_key::*;
use std::crypto::scalar::*;
use std::crypto::secp256k1::*;
use std::crypto::secp256r1::*;
use std::crypto::signature::*;

use std::vm::evm::evm_address::EvmAddress;

fn main() {
    let ed25519 = std::crypto::ed25519::Ed25519::new();
    let _ = ed25519 == ed25519;

    let point2d = std::crypto::point2d::Point2D::new();
    let _ = point2d == point2d;

    let public_key = std::crypto::public_key::PublicKey::new();
    let _ = public_key == public_key;

    let _ = public_key.is_zero();

    let scalar = std::crypto::scalar::Scalar::new();
    let _ = scalar == scalar;

    let message = std::crypto::message::Message::new();

    let secp256k1 = std::crypto::secp256k1::Secp256k1::new();
    let _ = secp256k1 == secp256k1;
    let _ = secp256k1.address(message);
    let _ = secp256k1.evm_address(message);
    let _ = secp256k1.verify(public_key, message);
    let _ = secp256k1.verify_address(Address::zero(), message);
    let _ = secp256k1.verify_evm_address(EvmAddress::zero(), message);

    let secp256r1 = std::crypto::secp256r1::Secp256r1::new();
    let _ = secp256r1 == secp256r1;
    let _ = secp256r1.address(message);
    let _ = secp256r1.evm_address(message);
    let _ = secp256r1.verify(public_key, message);
    let _ = secp256r1.verify_address(Address::zero(), message);
    let _ = secp256r1.verify_evm_address(EvmAddress::zero(), message);
}
```

## Checklist

- [x] I have linked to any relevant issues.
- [x] 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).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [ ] 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.
- [x] 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).
- [x] I have requested a review from the relevant team or maintainers.

Author: ironcev

sway-lib-std/src/bytes.sw

@@ -956,6 +956,41 @@ impl Bytes {
             index: 0,
         }
     }
+
+    /// Returns true if all the bytes within the `Bytes` are zero.
+    ///
+    /// # Additional Information
+    ///
+    /// If `Bytes` is empty, this function will return `true`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let bytes = Bytes::new();
+    ///     bytes.resize(10, 0u8);
+    ///     assert(bytes.are_all_zero() == true);
+    ///
+    ///     bytes.resize(20, 42u8);
+    ///     assert(bytes.are_all_zero() == false);
+    ///
+    ///     bytes.resize(0, 42u8);
+    ///     assert(bytes.are_all_zero() == true);
+    /// }
+    /// ```
+    pub fn are_all_zero(self) -> bool {
+        let mut iter = 0;
+        while iter < self.len {
+            let item_ptr = self.buf.ptr().add_uint_offset(iter);
+            let item = item_ptr.read_byte();
+            if item != 0 {
+                return false;
+            }
+            iter += 1;
+        }
+
+        true
+    }
 }
 
 impl PartialEq for Bytes {
@@ -981,6 +1016,8 @@ impl AsRawSlice for Bytes {
     }
 }
 
+// TODO: Once const generics are available implement `From<[u8; N]>`.
+
 /// Methods for converting between the `Bytes` and the `b256` types.
 impl From<b256> for Bytes {
     fn from(b: b256) -> Self {

sway-lib-std/src/crypto/ed25519.sw

@@ -194,15 +194,10 @@ impl Into<Bytes> for Ed25519 {
 
 impl PartialEq for Ed25519 {
     fn eq(self, other: Self) -> bool {
-        let mut iter = 0;
-        while iter < 64 {
-            if self.bits[iter] != other.bits[iter] {
-                return false;
-            }
-            iter += 1;
+        asm(result, r2: self.bits, r3: other.bits, r4: 64) {
+            meq result r2 r3 r4;
+            result: bool
         }
-
-        true
     }
 }
 impl Eq for Ed25519 {}

sway-lib-std/src/crypto/message.sw

@@ -88,20 +88,7 @@ impl TryInto<b256> for Message {
 
 impl PartialEq for Message {
     fn eq(self, other: Self) -> bool {
-        if self.bytes.len() != other.bytes.len() {
-            return false;
-        }
-
-        let mut iter = 0;
-        while iter < self.bytes.len() {
-            if self.bytes.get(iter).unwrap() != other.bytes.get(iter).unwrap()
-            {
-                return false;
-            }
-            iter += 1;
-        }
-
-        true
+        self.bytes == other.bytes
     }
 }
 impl Eq for Message {}

sway-lib-std/src/crypto/point2d.sw

@@ -24,28 +24,12 @@ pub struct Point2D {
 // All points must be of length 32
 impl PartialEq for Point2D {
     fn eq(self, other: Self) -> bool {
-        if self.x.len() != 32
-            || self.y.len() != 32
-            || other.x.len() != 32
-            || other.y.len() != 32
-        {
-            return false;
-        }
-
-        let mut iter = 0;
-        while iter < 32 {
-            if self.x.get(iter).unwrap() != other.x.get(iter).unwrap() {
-                return false;
-            } else if self.y.get(iter).unwrap() != other.y.get(iter).unwrap() {
-                return false;
-            }
-
-            iter += 1;
-        }
-        true
+        self.x.len() == 32 && self.y.len() == 32 && self.x == other.x && self.y == other.y
     }
 }
-impl Eq for Point2D {}
+// Note that `Point2D` implements `PartialEq` but not `Eq`,
+// because an uninitialized `Point2D`, created by `Point2D::new`
+// is not equal to any other point, including itself.
 
 impl Point2D {
     /// Returns a new, uninitialized Point2D.
@@ -111,7 +95,13 @@ impl Point2D {
     /// }
     /// ```
     pub fn is_zero(self) -> bool {
-        self == Self::zero()
+        // Note that we could simply return `self == Self::zero()` here,
+        // but this would cause creating a new `Point2D` zero instance
+        // every time we call this function. `Self::zero()` is expensive
+        // both in terms of gas and allocated memory.
+        // In cases like calling this function in a loop, the performance
+        // impact would be significant.
+        self.x.len() == 32 && self.y.len() == 32 && self.x.are_all_zero() && self.y.are_all_zero()
     }
 
     /// Returns the minimum point.
@@ -217,6 +207,9 @@ impl From<(u256, u256)> for Point2D {
 
 impl From<[u8; 64]> for Point2D {
     fn from(bytes: [u8; 64]) -> Self {
+        // TODO: Once const generics are available directly call `From<[u8; N]>` on `Bytes`
+        //       instead of having a loop.
+        //       Use allocation free `asm` cast to convert the single array to two arrays.
         let mut x = Bytes::with_capacity(32);
         let mut y = Bytes::with_capacity(32);
 

sway-lib-std/src/crypto/public_key.sw

@@ -57,13 +57,33 @@ impl PublicKey {
     ///
     /// fn foo() -> {
     ///     let new_key = PublicKey::new();
-    ///     assert(new_key.bytes().len() == 64);
+    ///     assert(new_key.bytes().len() == 0);
     /// }
     /// ```
     pub fn bytes(self) -> Bytes {
         self.bytes
     }
 
+    /// Returns the length of the public key in bytes.
+    ///
+    /// # Returns
+    ///
+    /// * [u64] - The length of the public key.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// use std::crypto::PublicKey;
+    ///
+    /// fn foo() -> {
+    ///     let new_key = PublicKey::new();
+    ///     assert(new_key.len() == 0);
+    /// }
+    /// ```
+    pub fn len(self) -> u64 {
+        self.bytes.len()
+    }
+
     /// Returns whether the public key is the zero public key.
     ///
     /// # Returns
@@ -81,15 +101,7 @@ impl PublicKey {
     /// }
     /// ```
     pub fn is_zero(self) -> bool {
-        let mut iter = 0;
-        while iter < self.bytes.len() {
-            if self.bytes.get(iter).unwrap() != 0 {
-                return false;
-            }
-            iter += 1;
-        }
-
-        true
+        self.bytes.are_all_zero()
     }
 }
 
@@ -177,20 +189,7 @@ impl TryInto<b256> for PublicKey {
 
 impl PartialEq for PublicKey {
     fn eq(self, other: Self) -> bool {
-        if self.bytes.len() != other.bytes.len() {
-            return false;
-        }
-
-        let mut iter = 0;
-        while iter < self.bytes.len() {
-            if self.bytes.get(iter).unwrap() != other.bytes.get(iter).unwrap()
-            {
-                return false;
-            }
-            iter += 1;
-        }
-
-        true
+        self.bytes == other.bytes
     }
 }
 impl Eq for PublicKey {}

sway-lib-std/src/crypto/scalar.sw

@@ -17,23 +17,12 @@ pub struct Scalar {
 // All scalars must be of length 32
 impl PartialEq for Scalar {
     fn eq(self, other: Self) -> bool {
-        if self.bytes.len() != 32 || other.bytes.len() != 32 {
-            return false;
-        }
-
-        let mut iter = 0;
-        while iter < 32 {
-            if self.bytes.get(iter).unwrap() != other.bytes.get(iter).unwrap()
-            {
-                return false;
-            }
-
-            iter += 1;
-        }
-        true
+        self.bytes.len() == 32 && self.bytes == other.bytes
     }
 }
-impl Eq for Scalar {}
+// Note that `Scalar` implements `PartialEq` but not `Eq`,
+// because an uninitialized `Scalar`, created by `Scalar::new`
+// is not equal to any other scalar, including itself.
 
 impl Scalar {
     /// Returns a new, uninitialized Scalar.
@@ -118,7 +107,13 @@ impl Scalar {
     /// }
     /// ```
     pub fn is_zero(self) -> bool {
-        self == Self::zero()
+        // Note that we could simply return `self == Self::zero()` here,
+        // but this would cause creating a new `Scalar` zero instance
+        // every time we call this function. `Self::zero()` is expensive
+        // both in terms of gas and allocated memory.
+        // In cases like calling this function in a loop, the performance
+        // impact would be significant.
+        self.bytes.len() == 32 && self.bytes.are_all_zero()
     }
 
     /// Returns the underlying bytes of the scalar.
@@ -160,6 +155,8 @@ impl From<b256> for Scalar {
 
 impl From<[u8; 32]> for Scalar {
     fn from(bytes_array: [u8; 32]) -> Self {
+        // TODO: Once const generics are available directly call `From<[u8; N]>` on `Bytes`
+        //       instead of having a loop.
         let mut bytes = Bytes::with_capacity(32);
 
         let mut iter = 0;