Use version in heartbeat messages, add RPCs to get blocks/bmm inclusions, bump version for release

Author: Ash-L2L

Cargo.lock

@@ -16,7 +16,7 @@ authors = [
 edition = "2021"
 license-file = "LICENSE.txt"
 publish = false
-version = "0.10.12"
+version = "0.11.0"
 
 [workspace.dependencies]
 anyhow = "1.0.72"

Cargo.toml

@@ -90,6 +90,33 @@ impl RpcServer for RpcServerImpl {
         Ok(mnemonic.to_string())
     }
 
+    async fn get_block(
+        &self,
+        block_hash: thunder::types::BlockHash,
+    ) -> RpcResult<Option<thunder::types::Block>> {
+        let Some(header) = self
+            .app
+            .node
+            .try_get_header(block_hash)
+            .map_err(custom_err)?
+        else {
+            return Ok(None);
+        };
+        let body = self.app.node.get_body(block_hash).map_err(custom_err)?;
+        let block = thunder::types::Block { header, body };
+        Ok(Some(block))
+    }
+
+    async fn get_bmm_inclusions(
+        &self,
+        block_hash: thunder::types::BlockHash,
+    ) -> RpcResult<Vec<bitcoin::BlockHash>> {
+        self.app
+            .node
+            .get_bmm_inclusions(block_hash)
+            .map_err(custom_err)
+    }
+
     async fn get_new_address(&self) -> RpcResult<Address> {
         self.app
             .wallet

app/rpc_server.rs

@@ -24,6 +24,14 @@ pub enum Command {
     FormatDepositAddress { address: Address },
     /// Generate a mnemonic seed phrase
     GenerateMnemonic,
+    /// Get the block with specified block hash, if it exists
+    GetBlock {
+        block_hash: thunder::types::BlockHash,
+    },
+    /// Get mainchain blocks that commit to a specified block hash
+    GetBmmInclusions {
+        block_hash: thunder::types::BlockHash,
+    },
     /// Get a new address
     GetNewAddress,
     /// Get wallet addresses, sorted by base58 encoding
@@ -118,6 +126,15 @@ impl Cli {
             Command::FormatDepositAddress { address } => {
                 rpc_client.format_deposit_address(address).await?
             }
+            Command::GetBlock { block_hash } => {
+                let block = rpc_client.get_block(block_hash).await?;
+                serde_json::to_string_pretty(&block)?
+            }
+            Command::GetBmmInclusions { block_hash } => {
+                let bmm_inclusions =
+                    rpc_client.get_bmm_inclusions(block_hash).await?;
+                serde_json::to_string_pretty(&bmm_inclusions)?
+            }
             Command::GenerateMnemonic => rpc_client.generate_mnemonic().await?,
             Command::GetNewAddress => {
                 let address = rpc_client.get_new_address().await?;

cli/lib.rs

@@ -37,6 +37,7 @@ rayon = "1.7.0"
 rcgen = "0.13.2"
 rustls = { version = "0.23.21", default-features = false, features = ["ring"] }
 rustreexo = { workspace = true, features = ["with-serde"] }
+semver = { version = "1.0.25", features = ["serde"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 serde_with = { version = "3.4.0" }

lib/Cargo.toml

@@ -1,6 +1,7 @@
 use borsh::BorshSerialize;
 use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator as _};
 use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
 
 use crate::types::{
     Address, AuthorizedTransaction, Body, GetAddress, Transaction, Verify,
@@ -47,12 +48,21 @@ where
 }
 
 #[derive(
-    BorshSerialize, Debug, Clone, Deserialize, Eq, PartialEq, Serialize,
+    BorshSerialize,
+    Debug,
+    Clone,
+    Deserialize,
+    Eq,
+    PartialEq,
+    Serialize,
+    ToSchema,
 )]
 pub struct Authorization {
     #[borsh(serialize_with = "borsh_serialize_verifying_key")]
+    #[schema(value_type = String)]
     pub verifying_key: VerifyingKey,
     #[borsh(serialize_with = "borsh_serialize_signature")]
+    #[schema(value_type = String)]
     pub signature: Signature,
 }
 

lib/authorization.rs

@@ -23,7 +23,7 @@ use crate::{
     state::{self, State},
     types::{
         hash, proto::mainchain, AuthorizedTransaction, BlockHash, BmmResult,
-        Body, Hash, Header, Tip, Txid,
+        Body, Hash, Header, Tip, Txid, Version, VERSION,
     },
 };
 
@@ -103,11 +103,10 @@ pub struct TipInfo {
     total_work: Work,
 }
 
-#[derive(
-    BorshSerialize, Clone, Copy, Debug, Default, Deserialize, Serialize,
-)]
+#[derive(BorshSerialize, Clone, Copy, Debug, Deserialize, Serialize)]
 pub struct PeerState {
     tip_info: Option<TipInfo>,
+    version: Version,
 }
 
 /// Unique identifier for a peer state
@@ -1200,8 +1199,10 @@ impl ConnectionTask {
                             total_work,
                         })
                     };
-                    let heartbeat_msg =
-                        Request::Heartbeat(PeerState { tip_info });
+                    let heartbeat_msg = Request::Heartbeat(PeerState {
+                        tip_info,
+                        version: *VERSION,
+                    });
                     task_set.spawn({
                         let connection = self.connection.clone();
                         let response_tx = response_tx.clone();

lib/net/peer.rs

@@ -368,27 +368,44 @@ where
         &self,
         block_hash: BlockHash,
     ) -> Result<Option<Body>, Error> {
-        let txn = self.env.read_txn()?;
-        Ok(self.archive.try_get_body(&txn, block_hash)?)
+        let rotxn = self.env.read_txn()?;
+        Ok(self.archive.try_get_body(&rotxn, block_hash)?)
     }
 
     pub fn get_body(&self, block_hash: BlockHash) -> Result<Body, Error> {
-        let txn = self.env.read_txn()?;
-        Ok(self.archive.get_body(&txn, block_hash)?)
+        let rotxn = self.env.read_txn()?;
+        Ok(self.archive.get_body(&rotxn, block_hash)?)
+    }
+
+    pub fn get_bmm_inclusions(
+        &self,
+        block_hash: BlockHash,
+    ) -> Result<Vec<bitcoin::BlockHash>, Error> {
+        let rotxn = self.env.read_txn()?;
+        let bmm_inclusions = self
+            .archive
+            .get_bmm_results(&rotxn, block_hash)?
+            .into_iter()
+            .filter_map(|(block_hash, bmm_res)| match bmm_res {
+                BmmResult::Verified => Some(block_hash),
+                BmmResult::Failed => None,
+            })
+            .collect();
+        Ok(bmm_inclusions)
     }
 
     pub fn get_all_transactions(
         &self,
     ) -> Result<Vec<AuthorizedTransaction>, Error> {
-        let txn = self.env.read_txn()?;
-        let transactions = self.mempool.take_all(&txn)?;
+        let rotxn = self.env.read_txn()?;
+        let transactions = self.mempool.take_all(&rotxn)?;
         Ok(transactions)
     }
 
     /// Get total sidechain wealth in Bitcoin
     pub fn get_sidechain_wealth(&self) -> Result<bitcoin::Amount, Error> {
-        let txn = self.env.read_txn()?;
-        Ok(self.state.sidechain_wealth(&txn)?)
+        let rotxn = self.env.read_txn()?;
+        Ok(self.state.sidechain_wealth(&rotxn)?)
     }
 
     pub fn get_transactions(

lib/node/mod.rs

@@ -63,6 +63,27 @@ impl std::fmt::Debug for BlockHash {
     }
 }
 
+impl FromStr for BlockHash {
+    type Err = hex::FromHexError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Hash::from_hex(s).map(Self)
+    }
+}
+
+impl utoipa::PartialSchema for BlockHash {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj =
+            utoipa::openapi::Object::with_type(utoipa::openapi::Type::String);
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema for BlockHash {
+    fn name() -> std::borrow::Cow<'static, str> {
+        std::borrow::Cow::Borrowed("BlockHash")
+    }
+}
+
 #[derive(
     BorshSerialize,
     Clone,

lib/types/hashes.rs

@@ -109,15 +109,25 @@ where
 }
 
 #[derive(
-    BorshSerialize, Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize,
+    BorshSerialize,
+    Clone,
+    Debug,
+    Deserialize,
+    Eq,
+    Hash,
+    PartialEq,
+    Serialize,
+    ToSchema,
 )]
 pub struct Header {
     pub merkle_root: MerkleRoot,
     pub prev_side_hash: Option<BlockHash>,
     #[borsh(serialize_with = "borsh_serialize_bitcoin_block_hash")]
+    #[schema(value_type = schema::BitcoinBlockHash)]
     pub prev_main_hash: bitcoin::BlockHash,
     /// Utreexo roots
     #[borsh(serialize_with = "borsh_serialize_utreexo_roots")]
+    #[schema(value_type = Vec<schema::UtreexoNodeHash>)]
     pub roots: Vec<BitcoinNodeHash>,
 }
 
@@ -351,3 +361,50 @@ pub struct Tip {
     #[borsh(serialize_with = "borsh_serialize_bitcoin_block_hash")]
     pub main_block_hash: bitcoin::BlockHash,
 }
+
+/// Semver-compatible version
+#[derive(
+    BorshSerialize,
+    Clone,
+    Copy,
+    Debug,
+    Deserialize,
+    Eq,
+    Hash,
+    PartialEq,
+    Serialize,
+)]
+pub struct Version {
+    pub major: u64,
+    pub minor: u64,
+    pub patch: u64,
+}
+
+impl From<semver::Version> for Version {
+    fn from(version: semver::Version) -> Self {
+        let semver::Version {
+            major,
+            minor,
+            patch,
+            pre: _,
+            build: _,
+        } = version;
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+}
+
+// Do not make this public outside of this crate, as it could break semver
+pub(crate) static VERSION: LazyLock<Version> = LazyLock::new(|| {
+    const VERSION_STR: &str = env!("CARGO_PKG_VERSION");
+    semver::Version::parse(VERSION_STR).unwrap().into()
+});
+
+#[derive(Clone, Debug, Deserialize, Serialize, ToSchema)]
+pub struct Block {
+    pub header: Header,
+    pub body: Body,
+}