also support Fp, Fp2

jayz22 · jayz22 · commit af6745205c78 · 2025-05-15T12:42:53.000-04:00
diff --git a/soroban-sdk-macros/src/map_type.rs b/soroban-sdk-macros/src/map_type.rs
@@ -8,8 +8,12 @@ use syn::{
     Type, TypePath, TypeTuple,
 };
 
-const G1_SERIALIZED_SIZE: u32 = 96; // Must match soroban_sdk::crypto::bls21_381::G1_SERIALIZED_SIZE.
-const G2_SERIALIZED_SIZE: u32 = 192; // Must match soroban_sdk::crypto::bls21_381::G2_SERIALIZED_SIZE.
+// These constants' values must match the definitions of the constants with the
+// same names in soroban_sdk::crypto::bls12_381.
+pub const FP_SERIALIZED_SIZE: u32 = 48;
+pub const FP2_SERIALIZED_SIZE: u32 = FP_SERIALIZED_SIZE * 2;
+pub const G1_SERIALIZED_SIZE: u32 = FP_SERIALIZED_SIZE * 2;
+pub const G2_SERIALIZED_SIZE: u32 = FP2_SERIALIZED_SIZE * 2;
 
 #[allow(clippy::too_many_lines)]
 pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
@@ -40,9 +44,9 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                     "Address" => Ok(ScSpecTypeDef::Address),
                     "Timepoint" => Ok(ScSpecTypeDef::Timepoint),
                     "Duration" => Ok(ScSpecTypeDef::Duration),
-                    // The BLS types `G1Affine`, `G2Affine`, and `Fr` are represented in
-                    // the contract's interface by their underlying data types: I.e.
-                    // G1Affine/G2Affine => BytesN<N>, Fr => U256. This approach
+                    // The BLS types defined below are represented in the contract's
+                    // interface by their underlying data types, i.e.
+                    // Fp/Fp2/G1Affine/G2Affine => BytesN<N>, Fr => U256. This approach
                     // simplifies integration with contract development tooling, as it
                     // avoids introducing new spec types for these BLS constructs.
                     //
@@ -58,6 +62,12 @@ pub fn map_type(t: &Type, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
                     // Idiom. For more details, see the tracking issue for supporting
                     // type aliases:
                     // https://github.com/stellar/rs-soroban-sdk/issues/1063
+                    "Fp" => Ok(ScSpecTypeDef::BytesN(ScSpecTypeBytesN {
+                        n: FP_SERIALIZED_SIZE,
+                    })),
+                    "Fp2" => Ok(ScSpecTypeDef::BytesN(ScSpecTypeBytesN {
+                        n: FP2_SERIALIZED_SIZE,
+                    })),
                     "G1Affine" => Ok(ScSpecTypeDef::BytesN(ScSpecTypeBytesN {
                         n: G1_SERIALIZED_SIZE,
                     })),
diff --git a/soroban-sdk/src/tests/crypto_bls12_381.rs b/soroban-sdk/src/tests/crypto_bls12_381.rs
@@ -3,7 +3,7 @@ use soroban_sdk::{
     bytes, bytesn, contract, contractimpl,
     crypto::bls12_381::{Bls12_381, Fp, Fp2, Fr, G1Affine, G2Affine},
     env::EnvTestConfig,
-    vec, Address, Bytes, Env, Vec, U256,
+    vec, Address, Bytes, BytesN, Env, Vec, U256,
 };
 
 #[test]
@@ -243,14 +243,13 @@ pub struct Contract;
 
 #[contractimpl(crate_path = "crate")]
 impl Contract {
-    pub fn g1_mul_with(
-        env: Env,
-        contract_id: Address,
-        p: crate::BytesN<96>,
-        s: U256,
-    ) -> crate::BytesN<96> {
+    pub fn g1_mul_with(env: Env, contract_id: Address, p: BytesN<96>, s: U256) -> BytesN<96> {
         blscontract::Client::new(&env, &contract_id).g1_mul(&p, &s)
     }
+
+    pub fn verify_with(env: Env, contract_id: Address, proof: blscontract::DummyProof) -> bool {
+        blscontract::Client::new(&env, &contract_id).dummy_verify(&proof)
+    }
 }
 
 #[test]
@@ -276,4 +275,24 @@ fn test_invoke_contract() {
     let inf = G1Affine::from_bytes(bytesn!(&e, 0x400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000));
     let res = client.g1_mul_with(&bls_contract_id, &g1.as_bytes(), &zero.to_u256());
     assert_eq!(&res, inf.as_bytes());
+
+    let fp_val = Fp::from_bytes(bytesn!(&e, 0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001));
+    let fp2_val = Fp2::from_bytes(bytesn!(&e, 0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001));
+    let g1_point = G1Affine::from_bytes(bytesn!(&e, 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1));
+    let g2_point = G2Affine::from_bytes(bytesn!(&e, 0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801));
+    let fr_scalar = Fr::from_bytes(bytesn!(
+        &e,
+        0x0000000000000000000000000000000000000000000000000000000000000001
+    ));
+
+    let proof = blscontract::DummyProof {
+        fp: fp_val.to_bytes(),
+        fp2: fp2_val.to_bytes(),
+        g1: g1_point.to_bytes(),
+        g2: g2_point.to_bytes(),
+        fr: fr_scalar.to_u256(),
+    };
+
+    let res = client.verify_with(&bls_contract_id, &proof);
+    assert!(!res);
 }
diff --git a/soroban-sdk/src/testutils/arbitrary.rs b/soroban-sdk/src/testutils/arbitrary.rs
@@ -320,7 +320,10 @@ mod objects {
 
     use crate::xdr::{Int256Parts, ScVal, UInt256Parts};
     use crate::{
-        crypto::bls12_381::{Fr, G1Affine, G2Affine},
+        crypto::bls12_381::{
+            Fp, Fp2, Fr, G1Affine, G2Affine, FP2_SERIALIZED_SIZE, FP_SERIALIZED_SIZE,
+            G1_SERIALIZED_SIZE, G2_SERIALIZED_SIZE,
+        },
         Address, Bytes, BytesN, Duration, Map, String, Symbol, Timepoint, Val, Vec, I256, U256,
     };
 
@@ -682,10 +685,46 @@ mod objects {
         }
     }
 
+    // For Fp (48 bytes)
+    #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
+    pub struct ArbitraryFp {
+        bytes: [u8; FP_SERIALIZED_SIZE],
+    }
+
+    impl SorobanArbitrary for Fp {
+        type Prototype = ArbitraryFp;
+    }
+
+    impl TryFromVal<Env, ArbitraryFp> for Fp {
+        type Error = ConversionError;
+
+        fn try_from_val(env: &Env, v: &ArbitraryFp) -> Result<Self, Self::Error> {
+            Ok(Fp::from_array(env, &v.bytes))
+        }
+    }
+
+    // For Fp2 (96 bytes)
+    #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
+    pub struct ArbitraryFp2 {
+        bytes: [u8; FP2_SERIALIZED_SIZE],
+    }
+
+    impl SorobanArbitrary for Fp2 {
+        type Prototype = ArbitraryFp2;
+    }
+
+    impl TryFromVal<Env, ArbitraryFp2> for Fp2 {
+        type Error = ConversionError;
+
+        fn try_from_val(env: &Env, v: &ArbitraryFp2) -> Result<Self, Self::Error> {
+            Ok(Fp2::from_array(env, &v.bytes))
+        }
+    }
+
     // For G1Affine (96 bytes)
     #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
     pub struct ArbitraryG1Affine {
-        bytes: [u8; 96],
+        bytes: [u8; G1_SERIALIZED_SIZE],
     }
 
     impl SorobanArbitrary for G1Affine {
@@ -720,7 +759,7 @@ mod objects {
     // For G2Affine (192 bytes)
     #[derive(Arbitrary, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
     pub struct ArbitraryG2Affine {
-        bytes: [u8; 192],
+        bytes: [u8; G2_SERIALIZED_SIZE],
     }
 
     impl SorobanArbitrary for G2Affine {
diff --git a/tests/bls/src/lib.rs b/tests/bls/src/lib.rs
@@ -1,13 +1,15 @@
 #![no_std]
 use soroban_sdk::{
     contract, contractimpl, contracttype,
-    crypto::bls12_381::{Fr, G1Affine, G2Affine},
-    Env,
+    crypto::bls12_381::{Fp, Fp2, Fr, G1Affine, G2Affine},
+    log, Env,
 };
 
 #[derive(Clone)]
 #[contracttype]
 pub struct DummyProof {
+    pub fp: Fp,
+    pub fp2: Fp2,
     pub g1: G1Affine,
     pub g2: G2Affine,
     pub fr: Fr,
@@ -26,7 +28,15 @@ impl Contract {
         env.crypto().bls12_381().g2_mul(&p, &s)
     }
 
+    // A dummy proof just to run all the inputs through host functions
+    // to validate these types are compatible with contracts
     pub fn dummy_verify(env: Env, proof: DummyProof) -> bool {
+        let g1 = env.crypto().bls12_381().map_fp_to_g1(&proof.fp);
+        let in1 = env.crypto().bls12_381().g1_is_in_subgroup(&g1);
+        log!(&env, "`map_fp_to_g1` result is in subgroup: ", in1);
+        let g2 = env.crypto().bls12_381().map_fp2_to_g2(&proof.fp2);
+        let in2 = env.crypto().bls12_381().g2_is_in_subgroup(&g2);
+        log!(&env, "`map_fp2_to_g2` result is in subgroup: ", in2);
         let g1_mul = env.crypto().bls12_381().g1_mul(&proof.g1, &proof.fr);
         let g2_mul = env.crypto().bls12_381().g2_mul(&proof.g2, &proof.fr);
         let vp1 = soroban_sdk::Vec::from_array(&env, [g1_mul]);
@@ -82,6 +92,8 @@ mod test {
         let contract_id = env.register(Contract, ());
         let client = ContractClient::new(&env, &contract_id);
 
+        let fp = Fp::from_bytes(bytesn!(&env, 0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001));
+        let fp2 = Fp2::from_bytes(bytesn!(&env, 0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001));
         // Use generator points
         let g1 = G1Affine::from_bytes(bytesn!(&env, 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1));
         let g2 = G2Affine::from_bytes(bytesn!(&env, 0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb80606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801));
@@ -92,7 +104,13 @@ mod test {
             0x0000000000000000000000000000000000000000000000000000000000000001
         ));
 
-        let proof = DummyProof { g1, g2, fr };
+        let proof = DummyProof {
+            fp,
+            fp2,
+            g1,
+            g2,
+            fr,
+        };
         let res = client.dummy_verify(&proof);
         assert!(!res); // The pairing of generator points multiplied by the same scalar should not be the identity
     }
