Support save/load of parameters.

Author: Neopallium

dart-bp/src/poseidon_impls/poseidon_2/params.rs

@@ -1,9 +1,10 @@
 use crate::poseidon_impls::utils::{mat_inverse, mat_vec_mul};
 use crate::{Error, error::Result};
 use ark_ff::PrimeField;
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_std::{vec, vec::Vec};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, CanonicalSerialize, CanonicalDeserialize)]
 pub struct Poseidon2Params<F: PrimeField> {
     pub state_size: usize,
     /// sbox degree

src/bp/mod.rs

@@ -5,7 +5,8 @@ use ark_ff::{
     PrimeField,
     field_hashers::{DefaultFieldHasher, HashToField},
 };
-use ark_serialize::CanonicalSerialize;
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use ark_std::vec::Vec;
 
 use blake2::Blake2b512;
 use bounded_collections::Get;
@@ -166,6 +167,9 @@ lazy_static::lazy_static! {
     pub static ref POSEIDON_PARAMS: PoseidonParameters = PoseidonParameters::new().expect("Failed to create Poseidon parameters");
 }
 
+#[cfg(feature = "std")]
+pub fn set_dart_gens(_gens: DartBPGenerators) {}
+
 #[cfg(feature = "std")]
 pub fn dart_gens() -> &'static DartBPGenerators {
     &DART_GENS
@@ -174,17 +178,28 @@ pub fn dart_gens() -> &'static DartBPGenerators {
 #[cfg(not(feature = "std"))]
 static mut DART_GENS: Option<DartBPGenerators> = None;
 
+#[cfg(not(feature = "std"))]
+#[allow(static_mut_refs)]
+pub fn set_dart_gens(gens: DartBPGenerators) {
+    unsafe {
+        DART_GENS = Some(gens);
+    }
+}
+
 #[cfg(not(feature = "std"))]
 #[allow(static_mut_refs)]
 pub fn dart_gens() -> &'static DartBPGenerators {
     unsafe {
         if DART_GENS.is_none() {
-            DART_GENS = Some(DartBPGenerators::new(DART_GEN_DOMAIN));
+            set_dart_gens(DartBPGenerators::new(DART_GEN_DOMAIN));
         }
         DART_GENS.as_ref().unwrap()
     }
 }
 
+#[cfg(feature = "std")]
+pub fn set_poseidon_params(_params: PoseidonParameters) {}
+
 #[cfg(feature = "std")]
 pub fn poseidon_params() -> &'static PoseidonParameters {
     &POSEIDON_PARAMS
@@ -193,18 +208,28 @@ pub fn poseidon_params() -> &'static PoseidonParameters {
 #[cfg(not(feature = "std"))]
 static mut POSEIDON_PARAMS: Option<PoseidonParameters> = None;
 
+#[cfg(not(feature = "std"))]
+#[allow(static_mut_refs)]
+pub fn set_poseidon_params(params: PoseidonParameters) {
+    unsafe {
+        POSEIDON_PARAMS = Some(params);
+    }
+}
+
 #[cfg(not(feature = "std"))]
 #[allow(static_mut_refs)]
 pub fn poseidon_params() -> &'static PoseidonParameters {
     unsafe {
         if POSEIDON_PARAMS.is_none() {
-            POSEIDON_PARAMS =
-                Some(PoseidonParameters::new().expect("Failed to create Poseidon parameters"));
+            set_poseidon_params(
+                PoseidonParameters::new().expect("Failed to create Poseidon parameters"),
+            );
         }
         POSEIDON_PARAMS.as_ref().unwrap()
     }
 }
 
+#[derive(Clone, Debug, CanonicalSerialize, CanonicalDeserialize)]
 pub struct PoseidonParameters {
     pub params: Poseidon2Params<PallasScalar>,
 }

src/curve_tree/mod.rs

@@ -70,12 +70,24 @@ static mut ASSET_COMMITMENT_PARAMETERS: Option<AssetCommitmentParameters<AssetTr
 #[cfg(not(feature = "std"))]
 static mut ACCOUNT_CURVE_TREE_PARAMETERS: Option<CurveTreeParameters<AccountTreeConfig>> = None;
 
+#[cfg(feature = "std")]
+pub fn set_pallas_layer_parameters(
+    _parameters: SingleLayerProofParametersNew<PallasParameters, VestaParams>,
+) {
+}
+
 #[cfg(feature = "std")]
 pub fn get_pallas_layer_parameters()
 -> &'static SingleLayerProofParametersNew<PallasParameters, VestaParams> {
     &CURVE_TREE_PARAMETERS_PALLAS
 }
 
+#[cfg(feature = "std")]
+pub fn set_vesta_layer_parameters(
+    _parameters: SingleLayerProofParametersNew<VestaParameters, PallasParams>,
+) {
+}
+
 #[cfg(feature = "std")]
 pub fn get_vesta_layer_parameters()
 -> &'static SingleLayerProofParametersNew<VestaParameters, PallasParams> {
@@ -92,11 +104,24 @@ pub fn get_asset_commitment_parameters() -> &'static AssetCommitmentParameters<A
     &ASSET_COMMITMENT_PARAMETERS
 }
 
+#[cfg(feature = "std")]
+pub fn set_asset_commitment_parameters(_parameters: AssetCommitmentParameters<AssetTreeConfig>) {}
+
 #[cfg(feature = "std")]
 pub fn get_account_curve_tree_parameters() -> &'static CurveTreeParameters<AccountTreeConfig> {
     &ACCOUNT_CURVE_TREE_PARAMETERS
 }
 
+#[allow(static_mut_refs)]
+#[cfg(not(feature = "std"))]
+pub fn set_pallas_layer_parameters(
+    parameters: SingleLayerProofParametersNew<PallasParameters, VestaParams>,
+) {
+    unsafe {
+        CURVE_TREE_PARAMETERS_PALLAS = Some(parameters);
+    }
+}
+
 #[allow(static_mut_refs)]
 #[cfg(not(feature = "std"))]
 pub fn get_pallas_layer_parameters()
@@ -110,12 +135,22 @@ pub fn get_pallas_layer_parameters()
                 )
                 .expect("Failed to create SingleLayerParameters for Pallas"),
             );
-            CURVE_TREE_PARAMETERS_PALLAS = Some(parameters);
+            set_pallas_layer_parameters(parameters);
         }
         CURVE_TREE_PARAMETERS_PALLAS.as_ref().unwrap()
     }
 }
 
+#[allow(static_mut_refs)]
+#[cfg(not(feature = "std"))]
+pub fn set_vesta_layer_parameters(
+    parameters: SingleLayerProofParametersNew<VestaParameters, PallasParams>,
+) {
+    unsafe {
+        CURVE_TREE_PARAMETERS_VESTA = Some(parameters);
+    }
+}
+
 #[allow(static_mut_refs)]
 #[cfg(not(feature = "std"))]
 pub fn get_vesta_layer_parameters()
@@ -129,7 +164,7 @@ pub fn get_vesta_layer_parameters()
                 )
                 .expect("Failed to create SingleLayerParameters for Vesta"),
             );
-            CURVE_TREE_PARAMETERS_VESTA = Some(parameters);
+            set_vesta_layer_parameters(parameters);
         }
         CURVE_TREE_PARAMETERS_VESTA.as_ref().unwrap()
     }
@@ -147,6 +182,14 @@ pub fn get_asset_curve_tree_parameters() -> &'static CurveTreeParameters<AssetTr
     }
 }
 
+#[allow(static_mut_refs)]
+#[cfg(not(feature = "std"))]
+pub fn set_asset_commitment_parameters(parameters: AssetCommitmentParameters<AssetTreeConfig>) {
+    unsafe {
+        ASSET_COMMITMENT_PARAMETERS = Some(parameters);
+    }
+}
+
 #[allow(static_mut_refs)]
 #[cfg(not(feature = "std"))]
 pub fn get_asset_commitment_parameters() -> &'static AssetCommitmentParameters<AssetTreeConfig> {
@@ -158,7 +201,7 @@ pub fn get_asset_commitment_parameters() -> &'static AssetCommitmentParameters<A
                 MAX_ASSET_KEYS,
                 &tree_parameters.even_parameters.bp_gens(),
             );
-            ASSET_COMMITMENT_PARAMETERS = Some(parameters);
+            set_asset_commitment_parameters(parameters);
         }
         ASSET_COMMITMENT_PARAMETERS.as_ref().unwrap()
     }

src/error.rs

@@ -104,6 +104,10 @@ pub enum Error {
     #[error("Hex decode error")]
     HexDecodeError,
 
+    /// Scale decode error.
+    #[error("Scale decode error")]
+    DecodeError,
+
     /// Too many keys in registration proof.
     #[error("Too many keys in registration proof")]
     TooManyKeysInRegProof,

src/lib.rs

@@ -34,3 +34,74 @@ pub fn blake2_256<T: codec::Encode>(data: &T) -> [u8; 32] {
     type Blake2b256 = blake2::Blake2b<U32>;
     Blake2b256::digest(&data.encode()).into()
 }
+
+pub mod init {
+    use crate::{
+        Error,
+        curve_tree::{
+            get_asset_commitment_parameters, get_pallas_layer_parameters,
+            get_vesta_layer_parameters, set_asset_commitment_parameters,
+            set_pallas_layer_parameters, set_vesta_layer_parameters,
+        },
+        dart_gens, poseidon_params, set_dart_gens, set_poseidon_params,
+    };
+    use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+    use ark_std::vec::Vec;
+    use codec::{Decode, Encode};
+
+    pub fn init_params() -> Result<usize, Error> {
+        let mut total_size = 0;
+        // Generate the curve tree parameters.
+        let pallas_params = get_pallas_layer_parameters();
+        total_size += pallas_params.compressed_size();
+        let vesta_params = get_vesta_layer_parameters();
+        total_size += vesta_params.compressed_size();
+        let asset_commitment_params = get_asset_commitment_parameters();
+        total_size += asset_commitment_params.compressed_size();
+
+        // Save the Dart BP parameters.
+        let bp_params = dart_gens();
+        total_size += bp_params.encoded_size();
+
+        // Save the Poseidon2 parameters.
+        let poseidon_2_params = poseidon_params();
+        total_size += poseidon_2_params.compressed_size();
+
+        Ok(total_size)
+    }
+
+    pub fn save_params(mut buffer: &mut Vec<u8>) -> Result<usize, Error> {
+        // Save the curve tree parameters.
+        let pallas_params = get_pallas_layer_parameters();
+        pallas_params.serialize_compressed(&mut buffer)?;
+        let vesta_params = get_vesta_layer_parameters();
+        vesta_params.serialize_compressed(&mut buffer)?;
+        let asset_commitment_params = get_asset_commitment_parameters();
+        asset_commitment_params.serialize_compressed(&mut buffer)?;
+
+        // Save the Dart BP parameters.
+        let bp_params = dart_gens();
+        bp_params.encode_to(buffer);
+
+        // Save the Poseidon2 parameters.
+        let poseidon_2_params = poseidon_params();
+        poseidon_2_params.serialize_compressed(&mut buffer)?;
+
+        Ok(buffer.len())
+    }
+
+    pub fn load_params(mut buffer: &[u8]) -> Result<(), Error> {
+        // Load the curve tree parameters.
+        set_pallas_layer_parameters(CanonicalDeserialize::deserialize_compressed(&mut buffer)?);
+        set_vesta_layer_parameters(CanonicalDeserialize::deserialize_compressed(&mut buffer)?);
+        set_asset_commitment_parameters(CanonicalDeserialize::deserialize_compressed(&mut buffer)?);
+
+        // Load the Dart BP parameters.
+        set_dart_gens(Decode::decode(&mut buffer).map_err(|_| Error::DecodeError)?);
+
+        // Load the Poseidon2 parameters.
+        set_poseidon_params(CanonicalDeserialize::deserialize_compressed(&mut buffer)?);
+
+        Ok(())
+    }
+}