Explicitly version storage

Ash-L2L · Ash-L2L · commit c366438b88f8 · 2025-02-27T01:33:14.000+08:00
diff --git a/lib/archive.rs b/lib/archive.rs
@@ -8,12 +8,12 @@ use fallible_iterator::{FallibleIterator, IteratorExt};
 use heed::types::SerdeBincode;
 use sneed::{
     db::{self, error::Error as DbError},
-    env, rwtxn, DatabaseUnique, EnvError, RoTxn, RwTxn, RwTxnError,
+    env, rwtxn, DatabaseUnique, EnvError, RoTxn, RwTxn, RwTxnError, UnitKey,
 };
 
 use crate::types::{
     proto::mainchain::{self, Deposit},
-    Block, BlockHash, BmmResult, Body, Header, Tip, Txid,
+    Block, BlockHash, BmmResult, Body, Header, Tip, Txid, Version, VERSION,
 };
 
 #[derive(thiserror::Error, transitive::Transitive, Debug)]
@@ -146,10 +146,11 @@ pub struct Archive {
         SerdeBincode<Txid>,
         SerdeBincode<BTreeMap<BlockHash, u32>>,
     >,
+    _version: DatabaseUnique<UnitKey, SerdeBincode<Version>>,
 }
 
 impl Archive {
-    pub const NUM_DBS: u32 = 14;
+    pub const NUM_DBS: u32 = 15;
 
     pub fn new(env: &sneed::Env) -> Result<Self, Error> {
         let mut rwtxn = env.write_txn()?;
@@ -201,6 +202,11 @@ impl Archive {
         let total_work = DatabaseUnique::create(env, &mut rwtxn, "total_work")?;
         let txid_to_inclusions =
             DatabaseUnique::create(env, &mut rwtxn, "txid_to_inclusions")?;
+        let version =
+            DatabaseUnique::create(env, &mut rwtxn, "archive_version")?;
+        if version.try_get(&rwtxn, &())?.is_none() {
+            version.put(&mut rwtxn, &(), &*VERSION)?;
+        }
         rwtxn.commit()?;
         Ok(Self {
             block_hash_to_height,
@@ -217,6 +223,7 @@ impl Archive {
             successors,
             total_work,
             txid_to_inclusions,
+            _version: version,
         })
     }
 
diff --git a/lib/mempool.rs b/lib/mempool.rs
@@ -3,11 +3,13 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use fallible_iterator::FallibleIterator as _;
 use heed::types::SerdeBincode;
 use sneed::{
-    db, env, rwtxn, DatabaseUnique, DbError, EnvError, RoTxn, RwTxn, RwTxnError,
+    db, env, rwtxn, DatabaseUnique, DbError, EnvError, RoTxn, RwTxn,
+    RwTxnError, UnitKey,
 };
 
 use crate::types::{
-    Address, AuthorizedTransaction, InPoint, OutPoint, Output, Txid,
+    Address, AuthorizedTransaction, InPoint, OutPoint, Output, Txid, Version,
+    VERSION,
 };
 
 #[derive(thiserror::Error, transitive::Transitive, Debug)]
@@ -39,10 +41,11 @@ pub struct MemPool {
     /// Associates relevant txs to each address
     address_to_txs:
         DatabaseUnique<SerdeBincode<Address>, SerdeBincode<HashSet<Txid>>>,
+    _version: DatabaseUnique<UnitKey, SerdeBincode<Version>>,
 }
 
 impl MemPool {
-    pub const NUM_DBS: u32 = 3;
+    pub const NUM_DBS: u32 = 4;
 
     pub fn new(env: &sneed::Env) -> Result<Self, Error> {
         let mut rwtxn = env.write_txn()?;
@@ -52,11 +55,17 @@ impl MemPool {
             DatabaseUnique::create(env, &mut rwtxn, "spent_utxos")?;
         let address_to_txs =
             DatabaseUnique::create(env, &mut rwtxn, "address_to_txs")?;
+        let version =
+            DatabaseUnique::create(env, &mut rwtxn, "mempool_version")?;
+        if version.try_get(&rwtxn, &())?.is_none() {
+            version.put(&mut rwtxn, &(), &*VERSION)?;
+        }
         rwtxn.commit()?;
         Ok(Self {
             transactions,
             spent_utxos,
             address_to_txs,
+            _version: version,
         })
     }
 
diff --git a/lib/net/mod.rs b/lib/net/mod.rs
@@ -9,14 +9,16 @@ use futures::{channel::mpsc, StreamExt};
 use heed::types::{SerdeBincode, Unit};
 use parking_lot::RwLock;
 use quinn::{ClientConfig, Endpoint, ServerConfig};
-use sneed::{db, env, rwtxn, DatabaseUnique, DbError, EnvError, RwTxnError};
+use sneed::{
+    db, env, rwtxn, DatabaseUnique, DbError, EnvError, RwTxnError, UnitKey,
+};
 use tokio_stream::StreamNotifyClose;
 use tracing::instrument;
 
 use crate::{
     archive::Archive,
     state::State,
-    types::{AuthorizedTransaction, Network, THIS_SIDECHAIN},
+    types::{AuthorizedTransaction, Network, Version, THIS_SIDECHAIN, VERSION},
 };
 
 mod peer;
@@ -33,6 +35,7 @@ pub use peer::{
 
 #[derive(thiserror::Error, transitive::Transitive, Debug)]
 #[transitive(from(db::error::Put))]
+#[transitive(from(db::error::TryGet))]
 #[transitive(from(env::error::CreateDb))]
 #[transitive(from(env::error::OpenDb))]
 #[transitive(from(env::error::WriteTxn))]
@@ -221,10 +224,11 @@ pub struct Net {
     peer_info_tx:
         mpsc::UnboundedSender<(SocketAddr, Option<PeerConnectionInfo>)>,
     known_peers: DatabaseUnique<SerdeBincode<SocketAddr>, Unit>,
+    _version: DatabaseUnique<UnitKey, SerdeBincode<Version>>,
 }
 
 impl Net {
-    pub const NUM_DBS: u32 = 1;
+    pub const NUM_DBS: u32 = 2;
 
     fn add_active_peer(
         &self,
@@ -335,6 +339,10 @@ impl Net {
                     known_peers
                 }
             };
+        let version = DatabaseUnique::create(env, &mut rwtxn, "net_version")?;
+        if version.try_get(&rwtxn, &())?.is_none() {
+            version.put(&mut rwtxn, &(), &*VERSION)?;
+        }
         rwtxn.commit()?;
         let (peer_info_tx, peer_info_rx) = mpsc::unbounded();
         let net = Net {
@@ -344,6 +352,7 @@ impl Net {
             active_peers,
             peer_info_tx,
             known_peers,
+            _version: version,
         };
         #[allow(clippy::let_and_return)]
         let known_peers: Vec<_> = {
diff --git a/lib/state/mod.rs b/lib/state/mod.rs
@@ -14,7 +14,8 @@ use crate::{
         Authorized, AuthorizedTransaction, BitAssetId, BlockHash, Body,
         FilledOutput, FilledTransaction, GetAddress as _, GetBitcoinValue as _,
         Header, InPoint, M6id, OutPoint, SpentOutput, Transaction, TxData,
-        Verify as _, WithdrawalBundle, WithdrawalBundleStatus,
+        Verify as _, Version, WithdrawalBundle, WithdrawalBundleStatus,
+        VERSION,
     },
     util::Watchable,
 };
@@ -99,10 +100,11 @@ pub struct State {
         SerdeBincode<u32>,
         SerdeBincode<(bitcoin::BlockHash, u32)>,
     >,
+    _version: DatabaseUnique<UnitKey, SerdeBincode<Version>>,
 }
 
 impl State {
-    pub const NUM_DBS: u32 = bitassets::Dbs::NUM_DBS + 11;
+    pub const NUM_DBS: u32 = bitassets::Dbs::NUM_DBS + 12;
 
     pub fn new(env: &sneed::Env) -> Result<Self, Error> {
         let mut rwtxn = env.write_txn()?;
@@ -133,6 +135,10 @@ impl State {
             &mut rwtxn,
             "withdrawal_bundle_event_blocks",
         )?;
+        let version = DatabaseUnique::create(env, &mut rwtxn, "state_version")?;
+        if version.try_get(&rwtxn, &())?.is_none() {
+            version.put(&mut rwtxn, &(), &*VERSION)?;
+        }
         rwtxn.commit()?;
         Ok(Self {
             tip,
@@ -147,6 +153,7 @@ impl State {
             withdrawal_bundles,
             withdrawal_bundle_event_blocks,
             deposit_blocks,
+            _version: version,
         })
     }
 
diff --git a/lib/wallet.rs b/lib/wallet.rs
@@ -15,7 +15,7 @@ use heed::{
     types::{Bytes, SerdeBincode, Str, U32, U8},
 };
 use serde::{Deserialize, Serialize};
-use sneed::{db, env, rwtxn, DbError, Env, EnvError, RwTxnError};
+use sneed::{db, env, rwtxn, DbError, Env, EnvError, RwTxnError, UnitKey};
 use thiserror::Error;
 use tokio_stream::{wrappers::WatchStream, StreamMap};
 
@@ -26,8 +26,8 @@ use crate::{
         AuthorizedTransaction, BitAssetData, BitAssetId, BitcoinOutputContent,
         DutchAuctionId, DutchAuctionParams, EncryptionPubKey, FilledOutput,
         GetBitcoinValue, Hash, InPoint, OutPoint, Output, OutputContent,
-        SpentOutput, Transaction, TxData, VerifyingKey,
-        WithdrawalOutputContent,
+        SpentOutput, Transaction, TxData, VerifyingKey, Version,
+        WithdrawalOutputContent, VERSION,
     },
     util::Watchable,
 };
@@ -144,10 +144,11 @@ pub struct Wallet {
     known_bitassets: DatabaseUnique<SerdeBincode<BitAssetId>, Str>,
     /// Map each verifying key to it's index
     vk_to_index: DatabaseUnique<SerdeBincode<VerifyingKey>, U32<BigEndian>>,
+    _version: DatabaseUnique<UnitKey, SerdeBincode<Version>>,
 }
 
 impl Wallet {
-    pub const NUM_DBS: u32 = 13;
+    pub const NUM_DBS: u32 = 14;
 
     pub fn new(path: &Path) -> Result<Self, Error> {
         std::fs::create_dir_all(path)?;
@@ -185,6 +186,10 @@ impl Wallet {
             DatabaseUnique::create(&env, &mut rwtxn, "known_bitassets")?;
         let vk_to_index =
             DatabaseUnique::create(&env, &mut rwtxn, "vk_to_index")?;
+        let version = DatabaseUnique::create(&env, &mut rwtxn, "version")?;
+        if version.try_get(&rwtxn, &())?.is_none() {
+            version.put(&mut rwtxn, &(), &*VERSION)?;
+        }
         rwtxn.commit()?;
         Ok(Self {
             env,
@@ -201,6 +206,7 @@ impl Wallet {
             bitasset_reservations,
             known_bitassets,
             vk_to_index,
+            _version: version,
         })
     }
 
@@ -1494,6 +1500,7 @@ impl Watchable<()> for Wallet {
             bitasset_reservations,
             known_bitassets,
             vk_to_index,
+            _version: _,
         } = self;
         let watchables = [
             seed.watch().clone(),
