Fix Fr scalar field to reduce modulo r on construction (#1750)

### What

`Fr` types for BN254 and BLS12-381 stored raw `U256` values without
modular reduction, causing mathematically equal field elements (e.g., 1
and r+1) to compare as not-equal via PartialEq.

The fix: apply `rem_euclid(r)` in `From<U256>` for `Fr`, and ensuring
all public construction paths produce canonical representations in [0,
r).

Also introduces modulus validation for BLS12-381 and BN254 base-field
element wrappers (Fp/Fp2) and refactor `BytesN` wrapper macros to
support validated `from_bytes`.

Author: jayz22

Cargo.lock

@@ -59,6 +59,9 @@ proptest-arbitrary-interop = "0.1.0"
 libfuzzer-sys = "0.4.7"
 expect-test = "1.4.1"
 sha2 = "0.10.7"
+ark-bn254 = { version = "0.5", default-features = false, features = ["curve"] }
+ark-bls12-381 = { version = "0.5", default-features = false, features = ["curve"] }
+ark-ff = { version = "0.5", default-features = false }
 
 [features]
 alloc = []

soroban-sdk/Cargo.toml

@@ -102,14 +102,19 @@ macro_rules! bytesn {
     };
 }
 
+/// Internal macro that generates all `BytesN` wrapper methods and trait impls
+/// *except* `from_bytes`. Types using this macro must provide their own
+/// `from_bytes(BytesN<$size>) -> Self` (e.g. to add validation).
+///
+/// This macro exists for backward compatibility: `impl_bytesn_repr` was
+/// accidentally exported via `#[macro_export]` and cannot be changed until the
+/// next protocol boundary. Once we remove the `#[macro_export]` from
+/// `impl_bytesn_repr`, this macro should be consolidated back into it.
+#[doc(hidden)]
 #[macro_export]
-macro_rules! impl_bytesn_repr {
+macro_rules! impl_bytesn_repr_without_from_bytes {
     ($elem: ident, $size: expr) => {
         impl $elem {
-            pub fn from_bytes(bytes: BytesN<$size>) -> Self {
-                Self(bytes)
-            }
-
             pub fn into_bytes(self) -> BytesN<$size> {
                 self.0
             }
@@ -127,7 +132,7 @@ macro_rules! impl_bytesn_repr {
             }
 
             pub fn from_array(env: &Env, array: &[u8; $size]) -> Self {
-                Self(<BytesN<$size>>::from_array(env, array))
+                Self::from_bytes(BytesN::from_array(env, array))
             }
 
             pub fn as_val(&self) -> &Val {
@@ -151,8 +156,8 @@ macro_rules! impl_bytesn_repr {
             type Error = ConversionError;
 
             fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error> {
-                let bytes = <BytesN<$size>>::try_from_val(env, val)?;
-                Ok($elem(bytes))
+                let bytes = BytesN::try_from_val(env, val)?;
+                Ok(Self::from_bytes(bytes))
             }
         }
 
@@ -226,6 +231,25 @@ macro_rules! impl_bytesn_repr {
     };
 }
 
+/// Generates all `BytesN` wrapper methods and trait impls including a default
+/// `from_bytes` that wraps the bytes without validation.
+///
+/// NOTE: This macro was not intended to be exported. Remove the
+/// `#[macro_export]` at the next protocol boundary, and consolidate
+/// `impl_bytesn_repr_without_from_bytes` back into this macro.
+#[macro_export]
+macro_rules! impl_bytesn_repr {
+    ($elem: ident, $size: expr) => {
+        impl $elem {
+            pub fn from_bytes(bytes: BytesN<$size>) -> Self {
+                Self(bytes)
+            }
+        }
+
+        impl_bytesn_repr_without_from_bytes!($elem, $size);
+    };
+}
+
 /// Bytes is a contiguous growable array type containing `u8`s.
 ///
 /// The array is stored in the Host and available to the Guest through the