getblockmeta: return empty tx_meta instead of null

Author: Ximik

node/src/rpc.rs

@@ -15,32 +15,42 @@ use bdk::{
 };
 use jsonrpsee::{core::async_trait, proc_macros::rpc, server::Server, types::ErrorObjectOwned};
 use log::info;
-use protocol::{bitcoin, bitcoin::{
-    bip32::Xpriv,
-    Network::{Regtest, Testnet},
-    OutPoint,
-}, constants::ChainAnchor, hasher::{BaseHash, KeyHasher, SpaceKey}, prepare::DataSource, slabel::SLabel, validate::TxChangeSet, Bytes, FullSpaceOut, SpaceOut};
+use protocol::bitcoin::secp256k1;
+use protocol::{
+    bitcoin,
+    bitcoin::{
+        bip32::Xpriv,
+        Network::{Regtest, Testnet},
+        OutPoint,
+    },
+    constants::ChainAnchor,
+    hasher::{BaseHash, KeyHasher, SpaceKey},
+    prepare::DataSource,
+    slabel::SLabel,
+    validate::TxChangeSet,
+    Bytes, FullSpaceOut, SpaceOut,
+};
 use serde::{Deserialize, Serialize};
 use tokio::{
     select,
     sync::{broadcast, mpsc, oneshot, RwLock},
     task::JoinSet,
 };
-use protocol::bitcoin::secp256k1;
-use wallet::{bdk_wallet as bdk, bdk_wallet::template::Bip86, bitcoin::hashes::Hash, export::WalletExport, Balance, DoubleUtxo, Listing, SpacesWallet, WalletConfig, WalletDescriptors, WalletInfo, WalletOutput};
+use wallet::{
+    bdk_wallet as bdk, bdk_wallet::template::Bip86, bitcoin::hashes::Hash, export::WalletExport,
+    Balance, DoubleUtxo, Listing, SpacesWallet, WalletConfig, WalletDescriptors, WalletInfo,
+    WalletOutput,
+};
 
+use crate::wallets::ListSpacesResponse;
 use crate::{
     checker::TxChecker,
     config::ExtendedNetwork,
     node::{BlockMeta, TxEntry},
     source::BitcoinRpc,
     store::{ChainState, LiveSnapshot, RolloutEntry, Sha256},
-    wallets::{
-        AddressKind, RpcWallet, TxInfo, TxResponse, WalletCommand,
-        WalletResponse,
-    },
+    wallets::{AddressKind, RpcWallet, TxInfo, TxResponse, WalletCommand, WalletResponse},
 };
-use crate::wallets::ListSpacesResponse;
 
 pub(crate) type Responder<T> = oneshot::Sender<T>;
 
@@ -65,7 +75,7 @@ pub enum BlockIdentifier {
 impl<'de> Deserialize<'de> for BlockIdentifier {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>
+        D: serde::Deserializer<'de>,
     {
         #[derive(Deserialize)]
         #[serde(untagged)]
@@ -74,11 +84,9 @@ impl<'de> Deserialize<'de> for BlockIdentifier {
             Number(u32),
         }
         match RawIdentifier::deserialize(deserializer)? {
-            RawIdentifier::String(s) => {
-                BlockHash::from_str(&s)
-                    .map(BlockIdentifier::Hash)
-                    .map_err(serde::de::Error::custom)
-            }
+            RawIdentifier::String(s) => BlockHash::from_str(&s)
+                .map(BlockIdentifier::Hash)
+                .map_err(serde::de::Error::custom),
             RawIdentifier::Number(n) => Ok(BlockIdentifier::Height(n)),
         }
     }
@@ -111,7 +119,7 @@ pub enum ChainStateCommand {
     },
     GetBlockMeta {
         block_identifier: BlockIdentifier,
-        resp: Responder<anyhow::Result<Option<BlockMeta>>>,
+        resp: Responder<anyhow::Result<BlockMeta>>,
     },
     EstimateBid {
         target: usize,
@@ -172,7 +180,7 @@ pub trait Rpc {
     async fn get_block_meta(
         &self,
         block_identifier: BlockIdentifier,
-    ) -> Result<Option<BlockMeta>, ErrorObjectOwned>;
+    ) -> Result<BlockMeta, ErrorObjectOwned>;
 
     #[method(name = "gettxmeta")]
     async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxEntry>, ErrorObjectOwned>;
@@ -187,7 +195,12 @@ pub trait Rpc {
     async fn verify_message(&self, msg: SignedMessage) -> Result<(), ErrorObjectOwned>;
 
     #[method(name = "walletsignmessage")]
-    async fn wallet_sign_message(&self, wallet: &str, space: &str, msg: protocol::Bytes) -> Result<SignedMessage, ErrorObjectOwned>;
+    async fn wallet_sign_message(
+        &self,
+        wallet: &str,
+        space: &str,
+        msg: protocol::Bytes,
+    ) -> Result<SignedMessage, ErrorObjectOwned>;
 
     #[method(name = "walletgetinfo")]
     async fn wallet_get_info(&self, name: &str) -> Result<WalletInfo, ErrorObjectOwned>;
@@ -239,10 +252,7 @@ pub trait Rpc {
     ) -> Result<Listing, ErrorObjectOwned>;
 
     #[method(name = "verifylisting")]
-    async fn verify_listing(
-        &self,
-        listing: Listing,
-    ) -> Result<(), ErrorObjectOwned>;
+    async fn verify_listing(&self, listing: Listing) -> Result<(), ErrorObjectOwned>;
 
     #[method(name = "walletlisttransactions")]
     async fn wallet_list_transactions(
@@ -261,8 +271,10 @@ pub trait Rpc {
     ) -> Result<TxResponse, ErrorObjectOwned>;
 
     #[method(name = "walletlistspaces")]
-    async fn wallet_list_spaces(&self, wallet: &str)
-                                -> Result<ListSpacesResponse, ErrorObjectOwned>;
+    async fn wallet_list_spaces(
+        &self,
+        wallet: &str,
+    ) -> Result<ListSpacesResponse, ErrorObjectOwned>;
 
     #[method(name = "walletlistunspent")]
     async fn wallet_list_unspent(
@@ -704,7 +716,7 @@ impl RpcServer for RpcServerImpl {
     async fn get_block_meta(
         &self,
         block_identifier: BlockIdentifier,
-    ) -> Result<Option<BlockMeta>, ErrorObjectOwned> {
+    ) -> Result<BlockMeta, ErrorObjectOwned> {
         let data = self
             .store
             .get_block_meta(block_identifier)
@@ -806,23 +818,39 @@ impl RpcServer for RpcServerImpl {
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
-    async fn wallet_buy(&self, wallet: &str, listing: Listing, fee_rate: Option<FeeRate>, skip_tx_check: bool) -> Result<TxResponse, ErrorObjectOwned> {
+    async fn wallet_buy(
+        &self,
+        wallet: &str,
+        listing: Listing,
+        fee_rate: Option<FeeRate>,
+        skip_tx_check: bool,
+    ) -> Result<TxResponse, ErrorObjectOwned> {
         self.wallet(&wallet)
             .await?
             .send_buy(listing, fee_rate, skip_tx_check)
             .await
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
-    async fn wallet_sell(&self, wallet: &str, space: String, amount: u64) -> Result<Listing, ErrorObjectOwned> {
+    async fn wallet_sell(
+        &self,
+        wallet: &str,
+        space: String,
+        amount: u64,
+    ) -> Result<Listing, ErrorObjectOwned> {
         self.wallet(&wallet)
             .await?
             .send_sell(space, amount)
             .await
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
-    async fn wallet_sign_message(&self, wallet: &str, space: &str, msg: Bytes) -> Result<SignedMessage, ErrorObjectOwned> {
+    async fn wallet_sign_message(
+        &self,
+        wallet: &str,
+        space: &str,
+        msg: Bytes,
+    ) -> Result<SignedMessage, ErrorObjectOwned> {
         self.wallet(&wallet)
             .await?
             .send_sign_message(space, msg)
@@ -930,15 +958,19 @@ impl AsyncChainState {
             BlockHash::from_str(info.get("blockhash").and_then(|t| t.as_str()).ok_or_else(
                 || anyhow!("Could not retrieve block hash for tx (is it in the mempool?)"),
             )?)?;
-        let block = Self::get_indexed_block(index, BlockIdentifier::Hash(block_hash), client, rpc, chain_state).await?;
+        let block = Self::get_indexed_block(
+            index,
+            BlockIdentifier::Hash(block_hash),
+            client,
+            rpc,
+            chain_state,
+        )
+        .await?;
 
-        if let Some(block) = block {
-            return Ok(block
-                .tx_meta
-                .into_iter()
-                .find(|tx| &tx.changeset.txid == txid));
-        }
-        Ok(None)
+        Ok(block
+            .tx_meta
+            .into_iter()
+            .find(|tx| &tx.changeset.txid == txid))
     }
 
     async fn get_indexed_block(
@@ -947,24 +979,24 @@ impl AsyncChainState {
         client: &reqwest::Client,
         rpc: &BitcoinRpc,
         chain_state: &mut LiveSnapshot,
-    ) -> Result<Option<BlockMeta>, anyhow::Error> {
+    ) -> Result<BlockMeta, anyhow::Error> {
         let index = index
             .as_mut()
             .ok_or_else(|| anyhow!("block index must be enabled"))?;
         let block_hash = match block_identifier {
             BlockIdentifier::Hash(hash) => hash,
             BlockIdentifier::Height(height) => rpc
-            .send_json(client, &rpc.get_block_hash(height))
-            .await
-            .map_err(|e| anyhow!("Could not retrieve block hash ({})", e))?
+                .send_json(client, &rpc.get_block_hash(height))
+                .await
+                .map_err(|e| anyhow!("Could not retrieve block hash ({})", e))?,
         };
         let hash = BaseHash::from_slice(block_hash.as_ref());
         let block: Option<BlockMeta> = index
             .get(hash)
             .context("Could not fetch block from index")?;
 
         if let Some(block_set) = block {
-            return Ok(Some(block_set));
+            return Ok(block_set);
         }
 
         let info: serde_json::Value = rpc
@@ -975,17 +1007,21 @@ impl AsyncChainState {
         let height = info
             .get("height")
             .and_then(|t| t.as_u64())
+            .and_then(|h| u32::try_from(h).ok())
             .ok_or_else(|| anyhow!("Could not retrieve block height"))?;
 
         let tip = chain_state.tip.read().expect("read meta").clone();
-        if height > tip.height as u64 {
+        if height > tip.height {
             return Err(anyhow!(
                 "Spaces is syncing at height {}, requested block height {}",
                 tip.height,
                 height
             ));
         }
-        Ok(None)
+        Ok(BlockMeta {
+            height,
+            tx_meta: Vec::new(),
+        })
     }
 
     pub async fn handle_command(
@@ -1032,10 +1068,18 @@ impl AsyncChainState {
                     .context("could not fetch spaceout");
                 let _ = resp.send(result);
             }
-            ChainStateCommand::GetBlockMeta { block_identifier, resp } => {
-                let res =
-                    Self::get_indexed_block(block_index, block_identifier, client, rpc, chain_state)
-                        .await;
+            ChainStateCommand::GetBlockMeta {
+                block_identifier,
+                resp,
+            } => {
+                let res = Self::get_indexed_block(
+                    block_index,
+                    block_identifier,
+                    client,
+                    rpc,
+                    chain_state,
+                )
+                .await;
                 let _ = resp.send(res);
             }
             ChainStateCommand::GetTxMeta { txid, resp } => {
@@ -1051,12 +1095,20 @@ impl AsyncChainState {
                 _ = resp.send(rollouts);
             }
             ChainStateCommand::VerifyListing { listing, resp } => {
-                _ = resp.send(SpacesWallet::verify_listing::<Sha256>(chain_state, &listing).map(|_| ()));
+                _ = resp.send(
+                    SpacesWallet::verify_listing::<Sha256>(chain_state, &listing).map(|_| ()),
+                );
             }
             ChainStateCommand::VerifyMessage { msg, resp } => {
-                _ = resp.send(SpacesWallet::verify_message::<Sha256>(
-                    chain_state, &msg.space, msg.message.as_slice(), &msg.signature
-                ).map(|_| ()));
+                _ = resp.send(
+                    SpacesWallet::verify_message::<Sha256>(
+                        chain_state,
+                        &msg.space,
+                        msg.message.as_slice(),
+                        &msg.signature,
+                    )
+                    .map(|_| ()),
+                );
             }
         }
     }
@@ -1156,10 +1208,16 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
-    pub async fn get_block_meta(&self, block_identifier: BlockIdentifier) -> anyhow::Result<Option<BlockMeta>> {
+    pub async fn get_block_meta(
+        &self,
+        block_identifier: BlockIdentifier,
+    ) -> anyhow::Result<BlockMeta> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
-            .send(ChainStateCommand::GetBlockMeta { block_identifier, resp })
+            .send(ChainStateCommand::GetBlockMeta {
+                block_identifier,
+                resp,
+            })
             .await?;
         resp_rx.await?
     }