rename module to crypt_algebra (#7586)

aptos-labs · Apr 5, 2023 · aae2c55 · aae2c55
1 parent 9674c40
commit aae2c55
Show file tree

Hide file tree

Showing 10 changed files with 1,825 additions and 1,825 deletions.
diff --git a/aptos-move/framework/aptos-stdlib/doc/algebra.md b/aptos-move/framework/aptos-stdlib/doc/algebra.md
diff --git a/aptos-move/framework/aptos-stdlib/doc/crypt_algebra.md b/aptos-move/framework/aptos-stdlib/doc/crypt_algebra.md
diff --git a/...work/aptos-stdlib/doc/algebra_bls12381.md → ...ptos-stdlib/doc/crypt_algebra_bls12381.md b/...work/aptos-stdlib/doc/algebra_bls12381.md → ...ptos-stdlib/doc/crypt_algebra_bls12381.md
diff --git a/aptos-move/framework/aptos-stdlib/doc/overview.md b/aptos-move/framework/aptos-stdlib/doc/overview.md
@@ -12,15 +12,15 @@ This is the reference documentation of the Aptos standard library.
 ## Index
 
 
--  [`0x1::algebra`](algebra.md#0x1_algebra)
--  [`0x1::algebra_bls12381`](algebra_bls12381.md#0x1_algebra_bls12381)
 -  [`0x1::any`](any.md#0x1_any)
 -  [`0x1::aptos_hash`](hash.md#0x1_aptos_hash)
 -  [`0x1::big_vector`](big_vector.md#0x1_big_vector)
 -  [`0x1::bls12381`](bls12381.md#0x1_bls12381)
 -  [`0x1::capability`](capability.md#0x1_capability)
 -  [`0x1::comparator`](comparator.md#0x1_comparator)
 -  [`0x1::copyable_any`](copyable_any.md#0x1_copyable_any)
+-  [`0x1::crypt_algebra`](crypt_algebra.md#0x1_crypt_algebra)
+-  [`0x1::crypt_algebra_bls12381`](crypt_algebra_bls12381.md#0x1_crypt_algebra_bls12381)
 -  [`0x1::debug`](debug.md#0x1_debug)
 -  [`0x1::ed25519`](ed25519.md#0x1_ed25519)
 -  [`0x1::fixed_point64`](fixed_point64.md#0x1_fixed_point64)

diff --git a/...-stdlib/sources/cryptography/algebra.move → ...b/sources/cryptography/crypt_algebra.move b/...-stdlib/sources/cryptography/algebra.move → ...b/sources/cryptography/crypt_algebra.move
@@ -35,7 +35,7 @@
 /// `upcast<Gt, Fq12>()` and `downcast<Fq12, Gt>()` will be supported.
 ///
 /// See `algebra_*.move` for currently implemented algebraic structures.
-module aptos_std::algebra {
+module aptos_std::crypt_algebra {
     use std::option::{Option, some, none};
     use std::features;
 

diff --git a/...ib/sources/cryptography/algebra.spec.move → ...rces/cryptography/crypt_algebra.spec.move b/...ib/sources/cryptography/algebra.spec.move → ...rces/cryptography/crypt_algebra.spec.move
@@ -1,4 +1,4 @@
-spec aptos_std::algebra {
+spec aptos_std::crypt_algebra {
     spec add_internal<S>(handle_1: u64, handle_2: u64): u64 {
         pragma opaque;
     }

diff --git a/...ources/cryptography/algebra_bls12381.move → .../cryptography/crypt_algebra_bls12381.move b/...ources/cryptography/algebra_bls12381.move → .../cryptography/crypt_algebra_bls12381.move
@@ -53,7 +53,7 @@
 /// `G2Full`: a group constructed by the points on a curve $E'(F_{q^2}): y^2=x^3+4(u+1)$ and the point at infinity,
 /// under the elliptic curve point addition.
 /// It contains the prime-order subgroup $G_2$ used in pairing.
-module aptos_std::algebra_bls12381 {
+module aptos_std::crypt_algebra_bls12381 {
     //
     // Marker types + serialization formats begin.
     //
@@ -627,7 +627,7 @@ module aptos_std::algebra_bls12381 {
     }
 
     #[test_only]
-    use aptos_std::algebra::{zero, one, from_u64, eq, deserialize, serialize, neg, add, sub, mul, div, inv, rand_insecure, sqr, order, scalar_mul, multi_scalar_mul, double, hash_to, upcast, enable_cryptography_algebra_natives, pairing, multi_pairing, downcast, Element};
+    use aptos_std::crypt_algebra::{zero, one, from_u64, eq, deserialize, serialize, neg, add, sub, mul, div, inv, rand_insecure, sqr, order, scalar_mul, multi_scalar_mul, double, hash_to, upcast, enable_cryptography_algebra_natives, pairing, multi_pairing, downcast, Element};
 
     #[test_only]
     const FR_VAL_0_SERIALIZED_LSB: vector<u8> = x"0000000000000000000000000000000000000000000000000000000000000000";
@@ -753,7 +753,7 @@ module aptos_std::algebra_bls12381 {
     }
 
     #[test(fx = @std)]
-    #[expected_failure(abort_code = 0x010002, location = aptos_std::algebra)]
+    #[expected_failure(abort_code = 0x010002, location = aptos_std::crypt_algebra)]
     fun test_multi_pairing_should_abort_when_sizes_mismatch(fx: signer) {
         enable_cryptography_algebra_natives(&fx);
         let g1_elements = vector[rand_insecure<G1>()];
@@ -762,7 +762,7 @@ module aptos_std::algebra_bls12381 {
     }
 
     #[test(fx = @std)]
-    #[expected_failure(abort_code = 0x010002, location = aptos_std::algebra)]
+    #[expected_failure(abort_code = 0x010002, location = aptos_std::crypt_algebra)]
     fun test_multi_scalar_mul_should_abort_when_sizes_mismatch(fx: signer) {
         enable_cryptography_algebra_natives(&fx);
         let elements = vector[rand_insecure<G1>()];

diff --git a/aptos-move/framework/src/natives/cryptography/algebra/mod.rs b/aptos-move/framework/src/natives/cryptography/algebra/mod.rs
@@ -71,11 +71,11 @@ impl TryFrom<TypeTag> for Structure {
 
     fn try_from(value: TypeTag) -> Result<Self, Self::Error> {
         match value.to_string().as_str() {
-            "0x1::algebra_bls12381::Fr" => Ok(Structure::BLS12381Fr),
-            "0x1::algebra_bls12381::Fq12" => Ok(Structure::BLS12381Fq12),
-            "0x1::algebra_bls12381::G1" => Ok(Structure::BLS12381G1),
-            "0x1::algebra_bls12381::G2" => Ok(Structure::BLS12381G2),
-            "0x1::algebra_bls12381::Gt" => Ok(Structure::BLS12381Gt),
+            "0x1::crypt_algebra_bls12381::Fr" => Ok(Structure::BLS12381Fr),
+            "0x1::crypt_algebra_bls12381::Fq12" => Ok(Structure::BLS12381Fq12),
+            "0x1::crypt_algebra_bls12381::G1" => Ok(Structure::BLS12381G1),
+            "0x1::crypt_algebra_bls12381::G2" => Ok(Structure::BLS12381G2),
+            "0x1::crypt_algebra_bls12381::Gt" => Ok(Structure::BLS12381Gt),
             _ => Err(()),
         }
     }
@@ -107,20 +107,20 @@ impl TryFrom<TypeTag> for SerializationFormat {
 
     fn try_from(value: TypeTag) -> Result<Self, Self::Error> {
         match value.to_string().as_str() {
-            "0x1::algebra_bls12381::FormatFq12LscLsb" => {
+            "0x1::crypt_algebra_bls12381::FormatFq12LscLsb" => {
                 Ok(SerializationFormat::BLS12381Fq12LscLsb)
             },
-            "0x1::algebra_bls12381::FormatG1Uncompr" => {
+            "0x1::crypt_algebra_bls12381::FormatG1Uncompr" => {
                 Ok(SerializationFormat::BLS12381G1Uncompressed)
             },
-            "0x1::algebra_bls12381::FormatG1Compr" => Ok(SerializationFormat::BLS12381G1Compressed),
-            "0x1::algebra_bls12381::FormatG2Uncompr" => {
+            "0x1::crypt_algebra_bls12381::FormatG1Compr" => Ok(SerializationFormat::BLS12381G1Compressed),
+            "0x1::crypt_algebra_bls12381::FormatG2Uncompr" => {
                 Ok(SerializationFormat::BLS12381G2Uncompressed)
             },
-            "0x1::algebra_bls12381::FormatG2Compr" => Ok(SerializationFormat::BLS12381G2Compressed),
-            "0x1::algebra_bls12381::FormatGt" => Ok(SerializationFormat::BLS12381Gt),
-            "0x1::algebra_bls12381::FormatFrLsb" => Ok(SerializationFormat::BLS12381FrLsb),
-            "0x1::algebra_bls12381::FormatFrMsb" => Ok(SerializationFormat::BLS12381FrMsb),
+            "0x1::crypt_algebra_bls12381::FormatG2Compr" => Ok(SerializationFormat::BLS12381G2Compressed),
+            "0x1::crypt_algebra_bls12381::FormatGt" => Ok(SerializationFormat::BLS12381Gt),
+            "0x1::crypt_algebra_bls12381::FormatFrLsb" => Ok(SerializationFormat::BLS12381FrLsb),
+            "0x1::crypt_algebra_bls12381::FormatFrMsb" => Ok(SerializationFormat::BLS12381FrMsb),
             _ => Err(()),
         }
     }
@@ -138,10 +138,10 @@ impl TryFrom<TypeTag> for HashToStructureSuite {
 
     fn try_from(value: TypeTag) -> Result<Self, Self::Error> {
         match value.to_string().as_str() {
-            "0x1::algebra_bls12381::HashG1XmdSha256SswuRo" => {
+            "0x1::crypt_algebra_bls12381::HashG1XmdSha256SswuRo" => {
                 Ok(HashToStructureSuite::Bls12381g1XmdSha256SswuRo)
             },
-            "0x1::algebra_bls12381::HashG2XmdSha256SswuRo" => {
+            "0x1::crypt_algebra_bls12381::HashG2XmdSha256SswuRo" => {
                 Ok(HashToStructureSuite::Bls12381g2XmdSha256SswuRo)
             },
             _ => Err(()),

diff --git a/aptos-move/framework/src/natives/mod.rs b/aptos-move/framework/src/natives/mod.rs
@@ -305,7 +305,7 @@ pub fn all_natives(
         )
     );
     add_natives_from_module!(
-        "algebra",
+        "crypt_algebra",
         cryptography::algebra::make_all(
             gas_params.algebra.clone(),
             sha256_gas_params,

diff --git a/aptos-move/move-examples/groth16_example/sources/groth16.move b/aptos-move/move-examples/groth16_example/sources/groth16.move
@@ -2,7 +2,7 @@
 /// Actual proof verifiers can be constructed using the pairings supported in the generic algebra module.
 /// See the test cases in this module for an example of constructing with BLS12-381 curves.
 module groth16_example::groth16 {
-    use aptos_std::algebra::{Element, from_u64, multi_scalar_mul, eq, multi_pairing, upcast, pairing, add, zero};
+    use aptos_std::crypt_algebra::{Element, from_u64, multi_scalar_mul, eq, multi_pairing, upcast, pairing, add, zero};
 
     /// Proof verification as specified in the original paper,
     /// with the following input (in the original paper notations).
@@ -77,9 +77,9 @@ module groth16_example::groth16 {
     }
 
     #[test_only]
-    use aptos_std::algebra::{deserialize, enable_cryptography_algebra_natives};
+    use aptos_std::crypt_algebra::{deserialize, enable_cryptography_algebra_natives};
     #[test_only]
-    use aptos_std::algebra_bls12381::{Fr, FormatFrLsb, FormatG1Compr, FormatG2Compr, FormatFq12LscLsb, G1, G2, Gt, Fq12, FormatGt};
+    use aptos_std::crypt_algebra_bls12381::{Fr, FormatFrLsb, FormatG1Compr, FormatG2Compr, FormatFq12LscLsb, G1, G2, Gt, Fq12, FormatGt};
 
     #[test(fx = @std)]
     fun test_verify_proof_with_bls12381(fx: signer) {