[feat] kv_typed: create type U32BE

rust-libs/duniter-dbs-read-ops/src/lib.rs

@@ -32,8 +32,8 @@ use dubp::documents::transaction::TransactionDocumentV10;
 use dubp::{common::prelude::BlockNumber, wallet::prelude::SourceAmount};
 use duniter_dbs::bc_v2::BcV2DbReadable;
 use duniter_dbs::{
-    kv_typed::prelude::*, BlockMetaV2, BlockNumberKeyV2, GvaV1DbReadable, HashKeyV2, PubKeyKeyV2,
-    TxDbV2, TxsMpV2DbReadable,
+    kv_typed::prelude::*, BlockMetaV2, GvaV1DbReadable, HashKeyV2, PubKeyKeyV2, TxDbV2,
+    TxsMpV2DbReadable,
 };
 use resiter::map::Map;
 use std::ops::{Bound, RangeBounds};

rust-libs/duniter-dbs-read-ops/src/uds_of_pubkey.rs

@@ -44,7 +44,7 @@ pub fn uds_of_pubkey<DB: BcV2DbReadable, R: 'static + RangeBounds<BlockNumber>>(
             Ok((vec![], SourceAmount::ZERO))
         } else {
             let first_reval = uds_reval
-                .iter(..=BlockNumberKeyV2(blocks_numbers[0]), |it| {
+                .iter(..=U32BE(blocks_numbers[0].0), |it| {
                     it.reverse().keys().next_res()
                 })?
                 .expect("corrupted db");
@@ -65,7 +65,7 @@ pub fn uds_of_pubkey<DB: BcV2DbReadable, R: 'static + RangeBounds<BlockNumber>>(
 
 fn collect_uds<BC: BackendCol, I: ExactSizeIterator<Item = BlockNumber>>(
     mut blocks_numbers: I,
-    first_reval: BlockNumberKeyV2,
+    first_reval: U32BE,
     uds_reval: TxColRo<BC, UdsRevalEvent>,
     amount_opt: Option<SourceAmount>,
 ) -> KvResult<(Vec<(BlockNumber, SourceAmount)>, SourceAmount)> {
@@ -81,7 +81,7 @@ fn collect_uds<BC: BackendCol, I: ExactSizeIterator<Item = BlockNumber>>(
         // Uds before last reval
         for (block_reval, amount_reval) in &uds_revals[1..] {
             'blocks_numbers: while let Some(block_number) = blocks_numbers.next() {
-                if block_number >= block_reval.0 {
+                if block_number.0 >= block_reval.0 {
                     current_ud = amount_reval.0;
                     uds.push((block_number, current_ud));
                     sum = sum + current_ud;

rust-libs/duniter-dbs-write-ops/src/bc.rs

@@ -20,9 +20,6 @@ mod uds;
 use crate::*;
 use duniter_dbs::bc_v2::BcV2DbWritable;
 
-// ["blocks_meta", blocks_meta, BlockNumberKeyV2, BlockMetaV2,],
-// ["identities", identities, PubKeyKeyV2, IdtyDbV2,],
-
 pub fn revert_block<B: Backend>(
     bc_db: &duniter_dbs::bc_v2::BcV2Db<B>,
     block: DubpBlockV10,
@@ -45,11 +42,11 @@ pub fn revert_block<B: Backend>(
                     )?;
                 }
                 identities::revert_identities::<B>(&block, &mut identities)?;
-                blocks_meta.remove(BlockNumberKeyV2(block.number()));
+                blocks_meta.remove(U32BE(block.number().0));
                 Ok(if block.number() == BlockNumber(0) {
                     None
                 } else {
-                    blocks_meta.get(&BlockNumberKeyV2(BlockNumber(block.number().0 - 1)))?
+                    blocks_meta.get(&U32BE(block.number().0 - 1))?
                 })
             },
         )
@@ -84,7 +81,7 @@ pub fn apply_block<B: Backend>(
     )
         .write(
             |(mut blocks_meta, mut identities, mut uds, mut uds_reval)| {
-                blocks_meta.upsert(BlockNumberKeyV2(block.number()), block_meta);
+                blocks_meta.upsert(U32BE(block.number().0), block_meta);
                 identities::update_identities::<B>(&block, &mut identities)?;
                 if let Some(dividend) = block.dividend() {
                     uds::create_uds::<B>(

rust-libs/duniter-dbs-write-ops/src/bc/uds.rs

@@ -19,9 +19,6 @@ use duniter_dbs::{
     UdIdV2,
 };
 
-// ["uds_reval", uds_reval, BlockNumberKeyV2, SourceAmountValV2,],
-// ["uds", uds, UdIdV2, (),],
-
 pub(crate) fn create_uds<B: Backend>(
     block_number: BlockNumber,
     dividend: SourceAmount,
@@ -33,7 +30,7 @@ pub(crate) fn create_uds<B: Backend>(
         .iter(.., |it| it.reverse().values().next_res())?
         .unwrap_or_else(|| SourceAmountValV2(SourceAmount::ZERO));
     if dividend > previous_ud_amount.0 {
-        uds_reval.upsert(BlockNumberKeyV2(block_number), SourceAmountValV2(dividend));
+        uds_reval.upsert(U32BE(block_number.0), SourceAmountValV2(dividend));
     }
 
     let members = identities.iter(.., |it| {
@@ -56,8 +53,8 @@ pub(crate) fn revert_uds<B: Backend>(
         .iter(.., |it| it.reverse().keys().next_res())?
         .expect("corrupted db")
         .0;
-    if block_number == previous_reval_block_number {
-        uds_reval.remove(BlockNumberKeyV2(block_number));
+    if block_number.0 == previous_reval_block_number {
+        uds_reval.remove(U32BE(block_number.0));
     }
 
     let members = identities.iter(.., |it| {

rust-libs/duniter-dbs-write-ops/src/lib.rs

@@ -39,9 +39,9 @@ use dubp::documents::{
 use dubp::wallet::prelude::*;
 use duniter_dbs::gva_v1::{TxsByIssuerEvent, TxsByRecipientEvent, TxsEvent};
 use duniter_dbs::{
-    kv_typed::prelude::*, BlockMetaV2, BlockNumberKeyV2, DuniterDbs, GvaV1Db, GvaV1DbReadable,
-    GvaV1DbWritable, HashKeyV2, PendingTxDbV2, PubKeyKeyV2, PubKeyValV2, SourceAmountValV2, TxDbV2,
-    TxsMpV2Db, TxsMpV2DbReadable, TxsMpV2DbWritable, WalletConditionsV2,
+    kv_typed::prelude::*, BlockMetaV2, DuniterDbs, GvaV1Db, GvaV1DbReadable, GvaV1DbWritable,
+    HashKeyV2, PendingTxDbV2, PubKeyKeyV2, PubKeyValV2, SourceAmountValV2, TxDbV2, TxsMpV2Db,
+    TxsMpV2DbReadable, TxsMpV2DbWritable, WalletConditionsV2,
 };
 use resiter::filter_map::FilterMap;
 use resiter::flatten::Flatten;

rust-libs/duniter-dbs/src/bc_v2.rs

@@ -18,8 +18,8 @@ use crate::*;
 db_schema!(
     BcV2,
     [
-        ["blocks_meta", BlocksMeta, BlockNumberKeyV2, BlockMetaV2],
-        ["uds_reval", UdsReval, BlockNumberKeyV2, SourceAmountValV2],
+        ["blocks_meta", BlocksMeta, U32BE, BlockMetaV2],
+        ["uds_reval", UdsReval, U32BE, SourceAmountValV2],
         ["identities", Identities, PubKeyKeyV2, IdtyDbV2],
         ["uds", Uds, UdIdV2, ()],
     ]

rust-libs/duniter-dbs/src/lib.rs

@@ -61,7 +61,7 @@ pub use crate::open_dbs::open_dbs;
 pub use bc_v1::{BcV1Db, BcV1DbReadable, BcV1DbRo, BcV1DbWritable, MainBlocksEvent, UidsEvent};
 pub use gva_v1::{GvaV1Db, GvaV1DbReadable, GvaV1DbRo, GvaV1DbWritable};
 pub use keys::all::AllKeyV1;
-pub use keys::block_number::{BlockNumberKeyV1, BlockNumberKeyV2};
+pub use keys::block_number::BlockNumberKeyV1;
 pub use keys::blockstamp::BlockstampKeyV1;
 pub use keys::hash::{HashKeyV1, HashKeyV2};
 pub use keys::pubkey::{PubKeyKeyV1, PubKeyKeyV2};

rust-libs/modules/duniter-gva/src/queries/uds.rs

@@ -83,7 +83,7 @@ impl UdsQuery {
                     it.map_ok(|(block_number, sa)| RevalUdGva {
                         amount: sa.0.amount(),
                         base: sa.0.base(),
-                        block_number: (block_number.0).0,
+                        block_number: block_number.0,
                     })
                     .collect::<KvResult<Vec<_>>>()
                 })

rust-libs/tools/kv_typed/src/as_bytes.rs

@@ -118,7 +118,7 @@ where
     }
 }
 
-macro_rules! impl_as_bytes_for_numbers {
+macro_rules! impl_as_bytes_for_le_numbers {
     ($($T:ty),*) => {$(
         impl KeyAsBytes for $T {
             fn as_bytes<T, F: FnMut(&[u8]) -> T>(&self, mut f: F) -> T {
@@ -132,7 +132,22 @@ macro_rules! impl_as_bytes_for_numbers {
         }
     )*};
 }
-
-impl_as_bytes_for_numbers!(
+impl_as_bytes_for_le_numbers!(
     usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64
 );
+
+macro_rules! impl_as_bytes_for_be_numbers {
+    ($($T:ty),*) => {$(
+        impl KeyAsBytes for $T {
+            fn as_bytes<T, F: FnMut(&[u8]) -> T>(&self, mut f: F) -> T {
+                f(&self.0.to_be_bytes()[..])
+            }
+        }
+        impl ValueAsBytes for $T {
+            fn as_bytes<T, F: FnMut(&[u8]) -> Result<T, KvError>>(&self, mut f: F) -> Result<T, KvError> {
+                f(&self.0.to_be_bytes()[..])
+            }
+        }
+    )*};
+}
+impl_as_bytes_for_be_numbers!(U32BE);

rust-libs/tools/kv_typed/src/explorer.rs

@@ -50,9 +50,23 @@ macro_rules! impl_explorable_key_for_numbers {
         }
     )*};
 }
-
 impl_explorable_key_for_numbers!(usize, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64);
 
+macro_rules! impl_explorable_key_for_be_numbers {
+    ($($T:ty),*) => {$(
+        impl ExplorableKey for $T {
+            fn from_explorer_str(source: &str) -> Result<Self, StringErr> {
+                Ok(Self(source.parse().map_err(|e| StringErr(format!("{}", e)))?))
+            }
+
+            fn to_explorer_string(&self) -> KvResult<String> {
+                Ok(format!("{}", self.0))
+            }
+        }
+    )*};
+}
+impl_explorable_key_for_be_numbers!(U32BE);
+
 pub trait ExplorableValue: Sized {
     fn from_explorer_str(source: &str) -> Result<Self, StringErr>;
     fn to_explorer_json(&self) -> KvResult<serde_json::Value>;

rust-libs/tools/kv_typed/src/from_bytes.rs

@@ -26,11 +26,23 @@ macro_rules! impl_from_bytes_for_numbers {
         }
     )*};
 }
-
 impl_from_bytes_for_numbers!(
     usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64
 );
 
+macro_rules! impl_from_bytes_for_be_numbers {
+    ($(($T:ty, $INT:ty)),*) => {$(
+        impl FromBytes for $T {
+            type Err = std::array::TryFromSliceError;
+
+            fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Err> {
+                Ok(Self(<$INT>::from_be_bytes(bytes.try_into()?)))
+            }
+        }
+    )*};
+}
+impl_from_bytes_for_be_numbers!((U32BE, u32));
+
 impl FromBytes for String {
     type Err = std::str::Utf8Error;
 

rust-libs/tools/kv_typed/src/key.rs

@@ -60,3 +60,6 @@ impl<T> Key for T where
         + Sized
 {
 }
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct U32BE(pub u32);

rust-libs/tools/kv_typed/src/lib.rs

@@ -82,7 +82,7 @@ pub mod prelude {
     pub use crate::iter::{
         keys::KvIterKeys, values::KvIterValues, EntryIter, KvIter, ResultIter, ReversableIterator,
     };
-    pub use crate::key::Key;
+    pub use crate::key::{Key, U32BE};
     pub use crate::subscription::{NewSubscribers, Subscriber, Subscribers};
     pub use crate::transactional_read::{TransactionalRead, TxColRo};
     pub use crate::transactional_write::{DbTxCollectionRw, TransactionalWrite, TxColRw};