spark_cryptography/

utils.rs

// use k256::{Scalar, elliptic_curve::PrimeField};
// use num_traits::Num;

// use crate::secp256k1::{CURVE_ORDER, CURVE_RADIX};

// /// Converts a BigInt (shamir_secret_sharing::num_bigint::BigInt) to a k256 Scalar.
// pub(crate) fn int_to_k256_scalar(value: &BigInt) -> Scalar {
//     // 1) Reduce the entire BigInt modulo the secp256k1 group order.
//     let curve_order =
//         BigInt::from_str_radix(CURVE_ORDER, CURVE_RADIX).expect("invalid curve order constant");
//     let reduced_value = value % &curve_order;

//     // 2) Apply zero-padding if the array is less than 32 bytes.
//     let mut be_bytes = reduced_value.to_bytes_be().1;
//     if be_bytes.len() < 32 {
//         // zero-pad if less than 32 bytes
//         let mut padded = vec![0u8; 32];
//         padded[32 - be_bytes.len()..].copy_from_slice(&be_bytes);
//         be_bytes = padded;
//     }

//     let mut be_bytes_array = [0u8; 32];
//     be_bytes_array.copy_from_slice(&be_bytes);

//     // 3) Use from_be_bytes to get the final Scalar,
//     //    which is in [0, n-1].
//     Scalar::from_repr_vartime(be_bytes_array.into())
//         .expect("reduced_value was < n, so this scalar is valid")
// }

// #[cfg(test)]
// mod tests {
//     use num_traits::Zero;
//     use rand::Rng;

//     use super::*;

//     /// Parses the curve order into a BigInt (shamir_secret_sharing::num_bigint::BigInt).
//     fn get_curve_order_as_bigint() -> BigInt {
//         BigInt::from_str_radix(CURVE_ORDER, CURVE_RADIX).expect("invalid curve order constant")
//     }

//     #[test]
//     fn test_int_to_scalar_k256_small() {
//         // zero
//         let zero_bigint = BigInt::zero();
//         let zero_scalar = int_to_k256_scalar(&zero_bigint);

//         // convert scalar back to BigInt for checking
//         let zero_scalar_bigint = BigInt::from_bytes_be(
//             shamir_secret_sharing::num_bigint::Sign::Plus,
//             &zero_scalar.to_bytes(),
//         );

//         // ensure it's indeed zero
//         assert_eq!(zero_scalar_bigint, BigInt::zero());

//         // small BigInt, e.g. 123
//         let small = BigInt::from(123u32);
//         let small_scalar = int_to_k256_scalar(&small);
//         let small_scalar_bigint = BigInt::from_bytes_be(
//             shamir_secret_sharing::num_bigint::Sign::Plus,
//             &small_scalar.to_bytes(),
//         );
//         assert_eq!(small, small_scalar_bigint);
//         // also ensure it's < n
//         let curve_order = get_curve_order_as_bigint();
//         assert!(small_scalar_bigint < curve_order);
//     }

//     #[test]
//     fn test_int_to_scalar_k256_32_bytes() {
//         // 32 bytes => let's pick a random 256-bit number
//         let mut rng = rand::thread_rng();
//         let mut random_32 = [0u8; 32];
//         rng.fill(&mut random_32);

//         let bigint_32 =
//             BigInt::from_bytes_be(shamir_secret_sharing::num_bigint::Sign::Plus, &random_32);
//         let scalar_32 = int_to_k256_scalar(&bigint_32);
//         let scalar_32_bigint = BigInt::from_bytes_be(
//             shamir_secret_sharing::num_bigint::Sign::Plus,
//             &scalar_32.to_bytes(),
//         );

//         // Now, scalar_32_bigint should match bigint_32 % n
//         let curve_order = get_curve_order_as_bigint();
//         let expected_mod = &bigint_32 % &curve_order;
//         assert_eq!(scalar_32_bigint, expected_mod);
//         assert!(scalar_32_bigint < curve_order);
//     }

//     #[test]
//     fn test_int_to_scalar_k256_oversized() {
//         // create a 48-byte random buffer
//         let mut rng = rand::thread_rng();
//         let mut random_oversized = vec![0u8; 48];
//         rng.fill(&mut random_oversized[..]);

//         let bigint_oversized = BigInt::from_bytes_be(
//             shamir_secret_sharing::num_bigint::Sign::Plus,
//             &random_oversized,
//         );

//         let scalar_oversized = int_to_k256_scalar(&bigint_oversized);
//         let scalar_oversized_bigint = BigInt::from_bytes_be(
//             shamir_secret_sharing::num_bigint::Sign::Plus,
//             &scalar_oversized.to_bytes(),
//         );

//         // The function automatically slices to 32 bytes, then reduces mod n
//         let curve_order = get_curve_order_as_bigint();
//         assert!(scalar_oversized_bigint < curve_order, "result must be < n");

//         // Also verify equivalence to forcibly truncated 32 bytes once modded by n
//         // Basically: let truncated = last 32 bytes of random_oversized => big-int => mod n.
//         // But since from_be_bytes also does mod reduction, they should match that mod result.
//         let actual_mod = &bigint_oversized % &curve_order;
//         assert_eq!(scalar_oversized_bigint, actual_mod);
//     }

//     #[test]
//     fn test_int_to_scalar_k256_valid_range() {
//         let curve_order = get_curve_order_as_bigint();
//         // Try 10 random inputs
//         for _ in 0..10 {
//             let mut rng = rand::thread_rng();
//             let mut random_64 = vec![0u8; 64];
//             rng.fill(&mut random_64[..]);

//             let big_val =
//                 BigInt::from_bytes_be(shamir_secret_sharing::num_bigint::Sign::Plus, &random_64);
//             let result_scalar = int_to_k256_scalar(&big_val);

//             // check that the result is < n
//             let result_scalar_bigint = BigInt::from_bytes_be(
//                 shamir_secret_sharing::num_bigint::Sign::Plus,
//                 &result_scalar.to_bytes(),
//             );
//             assert!(result_scalar_bigint < curve_order);
//         }
//     }
// }