chore: rename bca->bda & externalize bda-types

dbs-reader/Cargo.toml

@@ -17,13 +17,13 @@ mock = ["mockall"]
 [dependencies]
 anyhow = "1.0.34"
 arrayvec = { version = "0.7", features = ["serde"] }
-duniter-bca-types = { path = "../bca/types" }
 duniter-core = { git = "https://git.duniter.org/nodes/rust/duniter-core" }
 duniter-gva-db = { path = "../db" }
-dubp = { version = "0.54.1", features = ["duniter"] }
+dubp = { version = "0.55.1", features = ["duniter"] }
 flate2 = { version = "1.0", features = ["zlib-ng-compat"], default-features = false }
 mockall = { version = "0.9.1", optional = true }
 resiter = "0.4.0"
+rand = "0.8"
 
 [dev-dependencies]
 duniter-core = { git = "https://git.duniter.org/nodes/rust/duniter-core", features = ["mem"] }

dbs-reader/src/lib.rs

@@ -34,15 +34,15 @@ pub mod uds_of_pubkey;
 pub mod utxos;
 
 pub use crate::pagination::{PageInfo, PagedData};
-pub use duniter_bca_types::MAX_FIRST_UTXOS;
+pub use dubp::bda_types::MAX_FIRST_UTXOS;
 
 use crate::pagination::{has_next_page, has_previous_page};
 use arrayvec::ArrayVec;
+use dubp::bda_types::utxo::Utxo;
 use dubp::common::crypto::keys::ed25519::PublicKey;
 use dubp::documents::transaction::TransactionDocumentV10;
 use dubp::{block::DubpBlockV10, common::crypto::hashs::Hash};
 use dubp::{common::prelude::BlockNumber, wallet::prelude::*};
-use duniter_bca_types::utxo::Utxo;
 use duniter_core::dbs::{databases::network_v1::NetworkV1DbReadable, FileBackend};
 use duniter_core::dbs::{
     databases::{
@@ -56,6 +56,7 @@ use duniter_core::dbs::{
     kv_typed::prelude::*, HashKeyV2, PubKeyKeyV2, SourceAmountValV2, UtxoIdDbV2,
 };
 use duniter_gva_db::{GvaIdtyDbV1, GvaTxDbV1, GvaUtxoIdDbV1, GvaV1DbReadable, GvaV1DbRo};
+use rand::seq::SliceRandom;
 use resiter::filter::Filter;
 use resiter::filter_map::FilterMap;
 use resiter::flatten::Flatten;
@@ -134,6 +135,11 @@ pub trait DbsReader {
         bc_db: &BcDb,
         current_block_meta: &BlockMetaV2,
     ) -> anyhow::Result<Vec<BlockMetaV2>>;
+    fn get_some_peers<DB: 'static + NetworkV1DbReadable>(
+        &self,
+        dunp_db: &DB,
+        n: usize,
+    ) -> KvResult<Vec<duniter_core::dbs::PeerCardDbV1>>;
     fn get_txs_history_bc_received(
         &self,
         from: Option<u64>,
@@ -281,6 +287,14 @@ impl DbsReader for DbsReaderImpl {
         self.get_current_frame_(bc_db, current_block_meta)
     }
 
+    fn get_some_peers<DB: 'static + NetworkV1DbReadable>(
+        &self,
+        dunp_db: &DB,
+        n: usize,
+    ) -> KvResult<Vec<duniter_core::dbs::PeerCardDbV1>> {
+        self.get_some_peers_(dunp_db, n)
+    }
+
     fn get_txs_history_bc_received(
         &self,
         from: Option<u64>,

dbs-reader/src/network.rs

@@ -31,8 +31,8 @@ impl DbsReaderImpl {
         }
         network_db.peers_old().iter(.., |it| {
             it.values()
-                .map_ok(|peer| {
-                    peer.endpoints.into_iter().filter(|endpoint| {
+                .map_ok(|peer_db| {
+                    peer_db.peer.endpoints.into_iter().filter(|endpoint| {
                         api_list
                             .iter()
                             .any(|api| endpoint.starts_with(api.as_str()))
@@ -42,6 +42,24 @@ impl DbsReaderImpl {
                 .collect::<Result<Vec<String>, _>>()
         })
     }
+    pub(super) fn get_some_peers_<DB: NetworkV1DbReadable>(
+        &self,
+        dunp_db: &DB,
+        n: usize,
+    ) -> KvResult<Vec<PeerCardDbV1>> {
+        let peers: Vec<PeerCardDbV1> = dunp_db
+            .peers_old()
+            .iter(.., |it| it.values().collect::<KvResult<_>>())?;
+
+        if n == 0 {
+            Ok(peers)
+        } else {
+            Ok(peers
+                .choose_multiple(&mut rand::thread_rng(), n)
+                .cloned()
+                .collect())
+        }
+    }
     pub(super) fn peers_and_heads_<DB: NetworkV1DbReadable>(
         &self,
         dunp_db: &DB,
@@ -49,11 +67,12 @@ impl DbsReaderImpl {
         Ok(dunp_db.peers_old().iter(.., |it| {
             it.values()
                 .filter_map(|peer_res| {
-                    if let Ok(peer) = peer_res {
-                        let k_min = duniter_core::dbs::DunpNodeIdV1Db::new(0, peer.pubkey);
-                        let k_max = duniter_core::dbs::DunpNodeIdV1Db::new(u32::MAX, peer.pubkey);
+                    if let Ok(peer_db) = peer_res {
+                        let k_min = duniter_core::dbs::DunpNodeIdV1Db::new(0, peer_db.peer.pubkey);
+                        let k_max =
+                            duniter_core::dbs::DunpNodeIdV1Db::new(u32::MAX, peer_db.peer.pubkey);
                         Some((
-                            peer,
+                            peer_db,
                             dunp_db.heads_old().iter(k_min..k_max, |it| {
                                 it.values().filter_map(|head| head.ok()).collect()
                             }),
@@ -70,9 +89,10 @@ impl DbsReaderImpl {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use dubp::crypto::keys::PublicKey as _;
+    use dubp::{crypto::keys::PublicKey as _, peer::PeerV10};
     use duniter_core::dbs::databases::network_v1::NetworkV1DbWritable;
     use duniter_core::dbs::PeerCardDbV1;
+    use smallvec::smallvec;
 
     #[test]
     fn test_empty_endpoints() -> KvResult<()> {
@@ -105,7 +125,10 @@ mod tests {
         let db_reader = DbsReaderImpl::mem();
         let pk = PublicKey::default();
         let peer = PeerCardDbV1 {
-            endpoints: vec![dummy_endpoint.to_owned()],
+            peer: PeerV10 {
+                endpoints: smallvec![dummy_endpoint.to_owned()],
+                ..Default::default()
+            },
             ..Default::default()
         };
 
@@ -130,7 +153,10 @@ mod tests {
         let db_reader = DbsReaderImpl::mem();
         let pk = PublicKey::default();
         let peer = PeerCardDbV1 {
-            endpoints: vec![dummy_endpoint.to_owned()],
+            peer: PeerV10 {
+                endpoints: smallvec![dummy_endpoint.to_owned()],
+                ..Default::default()
+            },
             ..Default::default()
         };
 
@@ -156,9 +182,12 @@ mod tests {
         dunp_db.peers_old_write().upsert(
             PubKeyKeyV2(pubkey),
             PeerCardDbV1 {
+                peer: PeerV10 {
                     pubkey,
                     ..Default::default()
                 },
+                ..Default::default()
+            },
         )?;
         dunp_db.heads_old_write().upsert(
             duniter_core::dbs::DunpNodeIdV1Db::new(42, pubkey),
@@ -177,9 +206,12 @@ mod tests {
             db_reader.peers_and_heads(&dunp_db)?,
             vec![(
                 PeerCardDbV1 {
+                    peer: PeerV10 {
                         pubkey,
                         ..Default::default()
                     },
+                    ..Default::default()
+                },
                 vec![
                     DunpHeadDbV1::default(),
                     DunpHeadDbV1 {

gql/Cargo.toml

@@ -10,8 +10,7 @@ anyhow = "1.0.33"
 arrayvec = { version = "0.7", features = ["serde"] }
 async-graphql = { version = "2.8", features = ["log"] }
 async-trait = "0.1.41"
-dubp = { version = "0.54.1", features = ["duniter"] }
-duniter-bca-types = { path = "../bca/types" }
+dubp = { version = "0.55.1", features = ["duniter"] }
 duniter-core = { git = "https://git.duniter.org/nodes/rust/duniter-core" }
 duniter-gva-db = { path = "../db" }
 duniter-gva-dbs-reader = { path = "../dbs-reader" }

gql/src/entities/network.rs

@@ -28,16 +28,16 @@ pub struct PeerCardGva {
     pub member: bool,
 }
 impl From<duniter_core::dbs::PeerCardDbV1> for PeerCardGva {
-    fn from(peer: duniter_core::dbs::PeerCardDbV1) -> Self {
+    fn from(peer_db: duniter_core::dbs::PeerCardDbV1) -> Self {
         Self {
-            version: peer.version,
-            currency: peer.currency,
-            pubkey: peer.pubkey.to_base58(),
-            blockstamp: peer.blockstamp.to_string(),
-            endpoints: peer.endpoints,
-            status: if peer.status { "UP" } else { "DOWN" }.to_owned(),
-            signature: peer.signature.to_base64(),
-            member: peer.member,
+            version: 10,
+            currency: peer_db.peer.currency,
+            pubkey: peer_db.peer.pubkey.to_base58(),
+            blockstamp: peer_db.peer.blockstamp.to_string(),
+            endpoints: peer_db.peer.endpoints.to_vec(),
+            status: if peer_db.status { "UP" } else { "DOWN" }.to_owned(),
+            signature: peer_db.peer.signature.to_base64(),
+            member: peer_db.member,
         }
     }
 }

gql/src/lib.rs

@@ -54,6 +54,7 @@ use crate::tests::AsyncAccessor;
 use crate::tests::DbsReaderImpl;
 use async_graphql::connection::{Connection, Edge, EmptyFields};
 use async_graphql::validators::{IntGreaterThan, IntRange, ListMaxLength, ListMinLength};
+use dubp::bda_types::MAX_FIRST_UTXOS;
 use dubp::common::crypto::keys::{ed25519::PublicKey, PublicKey as _};
 use dubp::common::prelude::*;
 use dubp::crypto::hashs::Hash;
@@ -61,7 +62,6 @@ use dubp::documents::prelude::*;
 use dubp::documents::transaction::{TransactionDocumentTrait, TransactionDocumentV10};
 use dubp::documents_parser::prelude::*;
 use dubp::wallet::prelude::*;
-use duniter_bca_types::MAX_FIRST_UTXOS;
 use duniter_core::dbs::databases::txs_mp_v2::TxsMpV2DbReadable;
 use duniter_core::dbs::prelude::*;
 use duniter_core::dbs::{kv_typed::prelude::*, FileBackend};

indexer/Cargo.toml

@@ -17,7 +17,7 @@ bincode = "1.3"
 duniter-core = { git = "https://git.duniter.org/nodes/rust/duniter-core" }
 duniter-gva-db = { path = "../db" }
 duniter-gva-dbs-reader = { path = "../dbs-reader" }
-dubp = { version = "0.54.1", features = ["duniter"] }
+dubp = { version = "0.55.1", features = ["duniter"] }
 flate2 = { version = "1.0", features = ["zlib-ng-compat"], default-features = false }
 log = "0.4"
 once_cell = "1.7"

src/lib.rs

@@ -243,9 +243,9 @@ impl GvaModule {
     ) {
         log::info!("GvaServer::start: conf={:?}", conf);
 
-        // Create BcaExecutor and GvaSchema
+        // Create BdaExecutor and GvaSchema
         let self_pubkey = self_keypair.public_key();
-        duniter_bca::set_bca_executor(
+        duniter_bda::set_bda_executor(
             currency.clone(),
             AsyncAccessor::new(),
             dbs_pool.clone(),

src/warp_.rs

@@ -228,7 +228,7 @@ async fn process_bincode_batch_queries(
     is_whitelisted: bool,
 ) -> Result<ServerResponse, warp::Rejection> {
     Ok(ServerResponse::Bincode(
-        duniter_bca::execute(body_reader, is_whitelisted).await,
+        duniter_bda::execute(body_reader, is_whitelisted).await,
     ))
 }