node/src/chain_spec/gtest.rs

@@ -15,14 +15,14 @@
 // along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.
 
 use super::*;
+use crate::chain_spec::gen_genesis_data::{CommonParameters, GenesisIdentity, SessionKeysProvider};
 use common_runtime::constants::*;
 use common_runtime::entities::IdtyData;
 use common_runtime::*;
-use gtest_genesis::{build_genesis, GenesisJson};
 use gtest_runtime::{
-    opaque::SessionKeys, AccountConfig, AccountId, AuthorityMembersConfig, BabeConfig,
+    opaque::SessionKeys, parameters, AccountConfig, AccountId, AuthorityMembersConfig, BabeConfig,
     BalancesConfig, CertConfig, GenesisConfig, IdentityConfig, ImOnlineId, MembershipConfig,
-    SessionConfig, SmithCertConfig, SmithMembershipConfig, SudoConfig, SystemConfig,
+    Perbill, SessionConfig, SmithCertConfig, SmithMembershipConfig, SudoConfig, SystemConfig,
     TechnicalCommitteeConfig, UniversalDividendConfig, WASM_BINARY,
 };
 use jsonrpsee::core::JsonValue;
@@ -33,9 +33,7 @@ use sc_telemetry::TelemetryEndpoints;
 use serde::Deserialize;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
-use sp_core::{blake2_256, sr25519, Encode, H256};
-use sp_membership::MembershipData;
-use std::collections::BTreeMap;
+use std::{env, fs};
 
 pub type ChainSpec = sc_service::GenericChainSpec<GenesisConfig>;
 pub type AuthorityKeys = (
@@ -45,38 +43,45 @@ pub type AuthorityKeys = (
     ImOnlineId,
     AuthorityDiscoveryId,
 );
-/// Generate an authority keys.
-pub fn get_authority_keys_from_seed(s: &str) -> AuthorityKeys {
-    (
-        get_account_id_from_seed::<sr25519::Public>(s),
-        get_from_seed::<GrandpaId>(s),
-        get_from_seed::<BabeId>(s),
-        get_from_seed::<ImOnlineId>(s),
-        get_from_seed::<AuthorityDiscoveryId>(s),
-    )
-}
-/// Generate session keys
-fn get_session_keys_from_seed(s: &str) -> SessionKeys {
-    let authority_keys = get_authority_keys_from_seed(s);
-    session_keys(
-        authority_keys.1,
-        authority_keys.2,
-        authority_keys.3,
-        authority_keys.4,
-    )
+
+const TOKEN_DECIMALS: usize = 2;
+const TOKEN_SYMBOL: &str = "ĞT";
+
+#[derive(Default, Clone, Deserialize)]
+// No parameters for GTest (unlike GDev)
+struct GenesisParameters {}
+
+struct GTestSKP;
+impl SessionKeysProvider<SessionKeys> for GTestSKP {
+    fn session_keys(keys: &AuthorityKeys) -> SessionKeys {
+        let cloned = keys.clone();
+        SessionKeys {
+            grandpa: cloned.1,
+            babe: cloned.2,
+            im_online: cloned.3,
+            authority_discovery: cloned.4,
+        }
+    }
 }
-/// make session keys struct
-fn session_keys(
-    grandpa: GrandpaId,
-    babe: BabeId,
-    im_online: ImOnlineId,
-    authority_discovery: AuthorityDiscoveryId,
-) -> SessionKeys {
-    SessionKeys {
-        grandpa,
-        babe,
-        im_online,
-        authority_discovery,
+
+fn get_parameters(_: &Option<GenesisParameters>) -> CommonParameters {
+    CommonParameters {
+        currency_name: TOKEN_SYMBOL.to_string(),
+        decimals: TOKEN_DECIMALS,
+        existential_deposit: parameters::ExistentialDeposit::get(),
+        membership_period: parameters::MembershipPeriod::get(),
+        cert_period: parameters::CertPeriod::get(),
+        smith_membership_period: parameters::SmithMembershipPeriod::get(),
+        smith_certs_validity_period: parameters::SmithValidityPeriod::get(),
+        min_cert: parameters::WotMinCertForMembership::get(),
+        smith_min_cert: parameters::SmithWotMinCertForMembership::get(),
+        cert_max_by_issuer: parameters::MaxByIssuer::get(),
+        cert_validity_period: parameters::ValidityPeriod::get(),
+        c2: parameters::SquareMoneyGrowthRate::get(),
+        ud_creation_period: parameters::UdCreationPeriod::get() as u64, // TODO: cast?
+        distance_min_accessible_referees: Perbill::from_percent(80),    // TODO: generalize
+        max_depth: 5,                                                   // TODO: generalize value
+        ud_reeval_period: parameters::UdReevalPeriod::get() as u64,     // TODO: cast?
     }
 }
 
@@ -104,114 +109,47 @@ pub struct ClientSpec {
 
 /// generate development chainspec with Alice validator
 // there is some code duplication because we can not use ClientSpec
-pub fn development_chainspecs() -> Result<ChainSpec, String> {
-    let wasm_binary = WASM_BINARY.ok_or_else(|| "wasm not available".to_string())?;
-
-    // custom genesis when DUNITER_GTEST_GENESIS is set
-    if let Ok(genesis_json_path) = std::env::var("DUNITER_GTEST_GENESIS") {
-        // log
-        log::info!("loading genesis from {genesis_json_path}");
-        // open json genesis file
-        let file = std::fs::File::open(&genesis_json_path)
-            .map_err(|e| format!("Error opening gen conf file `{}`: {}", genesis_json_path, e))?;
-        // memory map the file to avoid loading it in memory
-        let bytes = unsafe {
-            memmap2::Mmap::map(&file).map_err(|e| {
-                format!("Error mmaping gen conf file `{}`: {}", genesis_json_path, e)
-            })?
-        };
-        // parse the json file
-        let genesis_data: GenesisJson = serde_json::from_slice(&bytes)
-            .map_err(|e| format!("Error parsing gen conf file: {}", e))?;
-
-        // return chainspecs
-        Ok(ChainSpec::from_genesis(
-            // Name
-            "ĞTest Development",
-            // ID
-            "gtest_dev",
-            // chain type
-            sc_service::ChainType::Development,
-            // genesis config constructor
-            move || {
-                build_genesis(
-                    // genesis data built from json
-                    genesis_data.clone(),
-                    // wasm binary
-                    wasm_binary,
-                    // replace authority by Alice
-                    Some(get_session_keys_from_seed("Alice").encode()),
-                )
-                .expect("genesis building failed")
-            },
-            // Bootnodes
-            vec![],
-            // Telemetry
-            None,
-            // Protocol ID
-            None,
-            //Fork ID
-            None,
-            // Properties
-            Some(
-                serde_json::json!({
-                    "tokenDecimals": 2,
-                    "tokenSymbol": "ĞT",
-                })
-                .as_object()
-                .expect("must be a map")
-                .clone(),
-            ),
-            // Extensions
-            None,
-        ))
-    } else {
-        // log
-        log::info!("generating genesis");
-        // generated genesis
-        Ok(ChainSpec::from_genesis(
-            // Name
-            "ĞTest Development",
-            // ID
-            "gtest_dev",
-            // chain type
-            ChainType::Development,
-            // constructor
-            move || {
-                generate_genesis(
-                    wasm_binary,
-                    // Initial authorities len
-                    1,
-                    // Initial smith members len
-                    3,
-                    // Inital identities len
-                    4,
-                    // Sudo account
-                    get_account_id_from_seed::<sr25519::Public>("Alice"),
+pub fn development_chainspecs(json_file_path: String) -> Result<ChainSpec, String> {
+    let wasm_binary = get_wasm_binary().ok_or_else(|| "wasm not available".to_string())?;
+    Ok(ChainSpec::from_genesis(
+        // Name
+        "ĞTest Development",
+        // ID
+        "gtest_dev",
+        // chain type
+        sc_service::ChainType::Development,
+        // constructor
+        move || {
+            let genesis_data =
+                gen_genesis_data::generate_genesis_data::<_, _, SessionKeys, GTestSKP>(
+                    json_file_path.clone(),
+                    get_parameters,
+                    Some("Alice".to_owned()),
                 )
-            },
-            // Bootnodes
-            vec![],
-            // Telemetry
-            None,
-            // Protocol ID
-            None,
-            //Fork ID
-            None,
-            // Properties
-            Some(
-                serde_json::json!({
-                    "tokenDecimals": 2,
-                    "tokenSymbol": "ĞT",
-                })
-                .as_object()
-                .expect("must be a map")
-                .clone(),
-            ),
-            // Extensions
-            None,
-        ))
-    }
+                .expect("Genesis Data must be buildable");
+            genesis_data_to_gtest_genesis_conf(genesis_data, wasm_binary.to_vec())
+        },
+        // Bootnodes
+        vec![],
+        // Telemetry
+        None,
+        // Protocol ID
+        None,
+        //Fork ID
+        None,
+        // Properties
+        Some(
+            serde_json::json!({
+                "tokenDecimals": TOKEN_DECIMALS,
+                "tokenSymbol": TOKEN_SYMBOL,
+            })
+            .as_object()
+            .expect("must be a map")
+            .clone(),
+        ),
+        // Extensions
+        None,
+    ))
 }
 
 // === live chainspecs ===
@@ -220,11 +158,9 @@ pub fn development_chainspecs() -> Result<ChainSpec, String> {
 // one smith must have session keys
 pub fn live_chainspecs(
     client_spec: ClientSpec,
-    genesis_data: GenesisJson,
+    json_file_path: String,
 ) -> Result<ChainSpec, String> {
-    let wasm_binary = WASM_BINARY.ok_or_else(|| "wasm not available".to_string())?;
-
-    // return chainspecs
+    let wasm_binary = get_wasm_binary().ok_or_else(|| "wasm not available".to_string())?;
     Ok(ChainSpec::from_genesis(
         // Name
         client_spec.name.as_str(),
@@ -234,15 +170,14 @@ pub fn live_chainspecs(
         client_spec.chain_type,
         // genesis config constructor
         move || {
-            build_genesis(
-                // genesis data
-                genesis_data.clone(),
-                // wasm binary
-                wasm_binary,
-                // do not replace session keys
-                None,
-            )
-            .expect("genesis building failed")
+            let genesis_data =
+                gen_genesis_data::generate_genesis_data::<_, _, SessionKeys, GTestSKP>(
+                    json_file_path.clone(),
+                    get_parameters,
+                    None,
+                )
+                .expect("Genesis Data must be buildable");
+            genesis_data_to_gtest_genesis_conf(genesis_data, wasm_binary.to_vec())
         },
         // Bootnodes
         client_spec.boot_nodes,
@@ -259,65 +194,47 @@ pub fn live_chainspecs(
     ))
 }
 
-/// generate a genesis with given number of smith and identities
-fn generate_genesis(
-    wasm_binary: &[u8],
-    initial_authorities_len: usize,
-    initial_smiths_len: usize,
-    initial_identities_len: usize,
-    root_key: AccountId,
-) -> GenesisConfig {
-    assert!(initial_identities_len <= 6);
-    assert!(initial_smiths_len <= initial_identities_len);
-    assert!(initial_authorities_len <= initial_smiths_len);
-
-    let ud = 1_000;
-    let monetary_mass = initial_identities_len as u64 * ud;
-
-    let initial_smiths = (0..initial_smiths_len)
-        .map(|i| get_authority_keys_from_seed(NAMES[i]))
-        .collect::<Vec<AuthorityKeys>>();
-    let initial_identities = (0..initial_identities_len)
-        .map(|i| {
-            (
-                IdtyName::from(NAMES[i]),
-                get_account_id_from_seed::<sr25519::Public>(NAMES[i]),
-            )
-        })
-        .collect::<BTreeMap<IdtyName, AccountId>>();
+/// custom genesis
+fn genesis_data_to_gtest_genesis_conf(
+    genesis_data: super::gen_genesis_data::GenesisData<GenesisParameters, SessionKeys>,
+    wasm_binary: Vec<u8>,
+) -> gtest_runtime::GenesisConfig {
+    let super::gen_genesis_data::GenesisData {
+        accounts,
+        treasury_balance,
+        certs_by_receiver,
+        first_ud,
+        first_ud_reeval,
+        identities,
+        initial_authorities,
+        initial_monetary_mass,
+        memberships,
+        parameters,
+        common_parameters,
+        session_keys_map,
+        smith_certs_by_receiver,
+        smith_memberships,
+        sudo_key,
+        technical_committee_members,
+        ud,
+    } = genesis_data;
 
-    GenesisConfig {
+    gtest_runtime::GenesisConfig {
         system: SystemConfig {
             // Add Wasm runtime to storage.
-            code: wasm_binary.to_vec(),
+            code: wasm_binary,
         },
         account: AccountConfig {
-            accounts: initial_identities
-                .iter()
-                .enumerate()
-                .map(|(i, (_, owner_key))| {
-                    (
-                        owner_key.clone(),
-                        GenesisAccountData {
-                            random_id: H256(blake2_256(&(i as u32, owner_key).encode())),
-                            balance: ud,
-                            is_identity: true,
-                        },
-                    )
-                })
-                .collect(),
+            accounts,
+            treasury_balance,
         },
         authority_discovery: Default::default(),
         authority_members: AuthorityMembersConfig {
-            initial_authorities: initial_smiths
-                .iter()
-                .enumerate()
-                .map(|(i, keys)| (i as u32 + 1, (keys.0.clone(), true)))
-                .collect(),
+            initial_authorities,
         },
         // Necessary to initialize TotalIssuence
         balances: BalancesConfig {
-            total_issuance: monetary_mass,
+            total_issuance: initial_monetary_mass,
         },
         babe: BabeConfig {
             authorities: Vec::with_capacity(0),
@@ -326,85 +243,77 @@ fn generate_genesis(
         grandpa: Default::default(),
         im_online: Default::default(),
         session: SessionConfig {
-            keys: initial_smiths
-                .iter()
-                .map(|x| {
-                    (
-                        x.0.clone(),
-                        x.0.clone(),
-                        session_keys(x.1.clone(), x.2.clone(), x.3.clone(), x.4.clone()),
-                    )
-                })
+            keys: session_keys_map
+                .into_iter()
+                .map(|(account_id, session_keys)| (account_id.clone(), account_id, session_keys))
                 .collect::<Vec<_>>(),
         },
-        sudo: SudoConfig {
-            // Assign network admin rights.
-            key: Some(root_key),
-        },
+        sudo: SudoConfig { key: sudo_key },
         technical_committee: TechnicalCommitteeConfig {
-            members: initial_smiths
-                .iter()
-                .map(|x| x.0.clone())
-                .collect::<Vec<_>>(),
+            members: technical_committee_members,
             ..Default::default()
         },
         identity: IdentityConfig {
-            identities: initial_identities
-                .iter()
+            identities: identities
+                .into_iter()
                 .enumerate()
-                .map(|(i, (name, owner_key))| common_runtime::GenesisIdty {
-                    index: i as u32 + 1,
-                    name: name.clone(),
-                    value: IdtyValue {
-                        data: IdtyData::new(),
-                        next_creatable_identity_on: Default::default(),
-                        old_owner_key: None,
-                        owner_key: owner_key.clone(),
-                        removable_on: 0,
-                        status: IdtyStatus::Validated,
-                    },
-                })
-                .collect(),
-        },
-        membership: MembershipConfig {
-            memberships: (1..=initial_identities.len())
-                .map(|i| {
-                    (
-                        i as u32,
-                        MembershipData {
-                            expire_on: gtest_runtime::MembershipPeriod::get(),
+                .map(
+                    |(
+                        i,
+                        GenesisIdentity {
+                            idty_index,
+                            name,
+                            owner_key,
+                            old_owner_key,
+                            active,
+                        },
+                    )| GenesisIdty {
+                        index: idty_index,
+                        name: common_runtime::IdtyName::from(name.as_str()),
+                        value: common_runtime::IdtyValue {
+                            data: IdtyData::new(),
+                            next_creatable_identity_on: 0,
+                            old_owner_key: old_owner_key.clone().map(|address| (address, 0)),
+                            owner_key,
+                            removable_on: if active { 0 } else { 2 },
+                            status: IdtyStatus::Validated,
                         },
-                    )
-                })
+                    },
+                )
                 .collect(),
         },
         cert: CertConfig {
-            apply_cert_period_at_genesis: false,
-            certs_by_receiver: clique_wot(initial_identities.len()),
-        },
-        smith_membership: SmithMembershipConfig {
-            memberships: (1..=initial_smiths_len)
-                .map(|i| {
-                    (
-                        i as u32,
-                        MembershipData {
-                            expire_on: gtest_runtime::SmithMembershipPeriod::get(),
-                        },
-                    )
-                })
-                .collect(),
+            apply_cert_period_at_genesis: true,
+            certs_by_receiver,
         },
+        membership: MembershipConfig { memberships },
         smith_cert: SmithCertConfig {
-            apply_cert_period_at_genesis: false,
-            certs_by_receiver: clique_wot(initial_smiths_len),
+            apply_cert_period_at_genesis: true,
+            certs_by_receiver: smith_certs_by_receiver,
+        },
+        smith_membership: SmithMembershipConfig {
+            memberships: smith_memberships,
         },
         universal_dividend: UniversalDividendConfig {
-            // TODO FIXME
-            first_reeval: Some(600_000),
-            first_ud: Some(6_000),
-            initial_monetary_mass: 0,
+            first_reeval: first_ud_reeval,
+            first_ud,
+            initial_monetary_mass,
             ud,
+            #[cfg(test)]
+            initial_members: vec![],
         },
         treasury: Default::default(),
     }
 }
+
+/// Get the WASM bytes either from filesytem (`WASM_FILE` env variable giving the path to the wasm blob)
+/// or else get the one compiled from source code.
+/// Goal: allow to provide the WASM built with srtool, which is reproductible.
+fn get_wasm_binary() -> Option<Vec<u8>> {
+    let wasm_bytes_from_file = if let Ok(file_path) = env::var("WASM_FILE") {
+        Some(fs::read(file_path).unwrap_or_else(|e| panic!("Could not read wasm file: {}", e)))
+    } else {
+        None
+    };
+    wasm_bytes_from_file.or_else(|| WASM_BINARY.map(|bytes| bytes.to_vec()))
+}

pallets/certification/src/lib.rs

@@ -79,6 +79,7 @@ pub mod pallet {
         type MaxByIssuer: Get<u32>;
         /// Minimum number of certifications that must be received to be able to issue
         /// certifications.
+        #[pallet::constant]
         type MinReceivedCertToBeAbleToIssueCert: Get<u32>;
         /// Handler for NewCert event
         type OnNewcert: OnNewcert<Self::IdtyIndex>;

pallets/distance/src/lib.rs

@@ -68,6 +68,7 @@ pub mod pallet {
             <Self::Currency as frame_support::traits::Currency<Self::AccountId>>::Balance,
         >;
         /// Minimum ratio of accessible referees
+        #[pallet::constant]
         type MinAccessibleReferees: Get<Perbill>;
         /// Number of session to keep a positive evaluation result
         type ResultExpiration: Get<u32>;

pallets/duniter-account/Cargo.toml

@@ -32,6 +32,8 @@ try-runtime = ['frame-support/try-runtime']
 
 [dependencies]
 # local
+pallet-quota = { path = "../quota", default-features = false }
+pallet-identity = { path = "../identity", default-features = false }
 pallet-provide-randomness = { path = "../provide-randomness", default-features = false }
 
 # crates.io
@@ -61,6 +63,11 @@ default-features = false
 git = 'https://github.com/duniter/substrate'
 branch = 'duniter-substrate-v0.9.42'
 
+[dependencies.pallet-transaction-payment]
+default-features = false
+git = 'https://github.com/duniter/substrate'
+branch = 'duniter-substrate-v0.9.42'
+
 [dependencies.pallet-treasury]
 default-features = false
 git = 'https://github.com/duniter/substrate'