getblockmeta: return hash

Author: Ximik

Diff for: node/src/format.rs

@@ -1,17 +1,22 @@
+use crate::rpc::ServerInfo;
+use crate::wallets::{ListSpacesResponse, TxInfo, TxResponse, WalletResponse};
 use clap::ValueEnum;
 use colored::{Color, Colorize};
 use jsonrpsee::core::Serialize;
+use protocol::{
+    bitcoin::{Amount, Network, OutPoint},
+    Covenant,
+};
 use serde::Deserialize;
 use tabled::{Table, Tabled};
-use protocol::bitcoin::{Amount, Network, OutPoint};
-use protocol::{Covenant};
 use wallet::address::SpaceAddress;
-use wallet::{Balance, DoubleUtxo, WalletInfo, WalletOutput};
 use wallet::bdk_wallet::KeychainKind;
 use wallet::bitcoin::{Address, Txid};
-use wallet::tx_event::{BidEventDetails, BidoutEventDetails, OpenEventDetails, SendEventDetails, TransferEventDetails, TxEventKind};
-use crate::rpc::ServerInfo;
-use crate::wallets::{ListSpacesResponse, TxInfo, TxResponse, WalletResponse};
+use wallet::tx_event::{
+    BidEventDetails, BidoutEventDetails, OpenEventDetails, SendEventDetails, TransferEventDetails,
+    TxEventKind,
+};
+use wallet::{Balance, DoubleUtxo, WalletInfo, WalletOutput};
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, ValueEnum, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -56,7 +61,7 @@ struct RegisteredSpaces {
     #[tabled(rename = "DAYS LEFT")]
     days_left: String,
     #[tabled(rename = "UTXO")]
-    utxo: OutPoint
+    utxo: OutPoint,
 }
 
 #[derive(Tabled)]
@@ -91,17 +96,19 @@ fn format_days_left(current_block: u32, claim_height: Option<u32>) -> String {
 pub fn print_list_bidouts(bidouts: Vec<DoubleUtxo>, format: Format) {
     match format {
         Format::Text => {
-            let all : Vec<_> = bidouts.into_iter().map(|out| Bidout {
-                txid: out.spend.outpoint.txid,
-                vout_1: out.spend.outpoint.vout,
-                vout_2: out.auction.outpoint.vout,
-                confirmed: out.confirmed,
-            }).collect();
+            let all: Vec<_> = bidouts
+                .into_iter()
+                .map(|out| Bidout {
+                    txid: out.spend.outpoint.txid,
+                    vout_1: out.spend.outpoint.vout,
+                    vout_2: out.auction.outpoint.vout,
+                    confirmed: out.confirmed,
+                })
+                .collect();
             println!("{}", ascii_table(all));
         }
         Format::Json => {
             println!("{}", serde_json::to_string_pretty(&bidouts).unwrap());
-
         }
     }
 }
@@ -117,17 +124,18 @@ pub fn print_list_transactions(txs: Vec<TxInfo>, format: Format) {
     }
 }
 
-
-
 pub fn print_list_unspent(utxos: Vec<WalletOutput>, format: Format) {
     match format {
         Format::Text => {
-            let utxos : Vec<_> = utxos.iter().map(|utxo| UnspentOutput {
-                outpoint: utxo.output.outpoint,
-                confirmed: utxo.output.chain_position.is_confirmed(),
-                value: utxo.output.txout.value,
-                external: utxo.output.keychain == KeychainKind::External,
-            }).collect();
+            let utxos: Vec<_> = utxos
+                .iter()
+                .map(|utxo| UnspentOutput {
+                    outpoint: utxo.output.outpoint,
+                    confirmed: utxo.output.chain_position.is_confirmed(),
+                    value: utxo.output.txout.value,
+                    external: utxo.output.keychain == KeychainKind::External,
+                })
+                .collect();
             println!("{}", ascii_table(utxos))
         }
         Format::Json => {
@@ -153,10 +161,7 @@ pub fn print_wallet_info(info: WalletInfo, format: Format) {
     match format {
         Format::Text => {
             println!("WALLET: {}", info.label);
-            println!("  Tip {}\n  Birthday {}",
-                     info.tip,
-                     info.start_block
-            );
+            println!("  Tip {}\n  Birthday {}", info.tip, info.start_block);
 
             println!("  Public descriptors");
             for desc in info.descriptors {
@@ -184,9 +189,18 @@ pub fn print_wallet_balance_response(balance: Balance, format: Format) {
     match format {
         Format::Text => {
             println!("Balance: {}", balance.balance.to_sat());
-            println!("  Confirmed         {:>14}", balance.details.balance.confirmed.to_sat());
-            println!("  Trusted pending   {:>14}", balance.details.balance.trusted_pending.to_sat());
-            println!("  Untrusted pending {:>14}", balance.details.balance.untrusted_pending.to_sat());
+            println!(
+                "  Confirmed         {:>14}",
+                balance.details.balance.confirmed.to_sat()
+            );
+            println!(
+                "  Trusted pending   {:>14}",
+                balance.details.balance.trusted_pending.to_sat()
+            );
+            println!(
+                "  Untrusted pending {:>14}",
+                balance.details.balance.untrusted_pending.to_sat()
+            );
             println!("  Dust & in-auction {:>14}", balance.details.dust.to_sat());
         }
         Format::Json => {
@@ -195,7 +209,11 @@ pub fn print_wallet_balance_response(balance: Balance, format: Format) {
     }
 }
 
-pub fn print_list_spaces_response(current_block: u32, response: ListSpacesResponse, format: Format) {
+pub fn print_list_spaces_response(
+    current_block: u32,
+    response: ListSpacesResponse,
+    format: Format,
+) {
     match format {
         Format::Text => {
             let mut outbids = Vec::new();
@@ -209,7 +227,11 @@ pub fn print_list_spaces_response(current_block: u32, response: ListSpacesRespon
                     days_left: "".to_string(),
                 };
                 match space.covenant {
-                    Covenant::Bid { total_burned, claim_height, .. } => {
+                    Covenant::Bid {
+                        total_burned,
+                        claim_height,
+                        ..
+                    } => {
                         outbid.last_confirmed_bid = total_burned.to_sat();
                         outbid.days_left = format_days_left(current_block, claim_height);
                     }
@@ -227,9 +249,15 @@ pub fn print_list_spaces_response(current_block: u32, response: ListSpacesRespon
                     claim_at: "--".to_string(),
                 };
                 match space.covenant {
-                    Covenant::Bid { total_burned, claim_height, .. } => {
+                    Covenant::Bid {
+                        total_burned,
+                        claim_height,
+                        ..
+                    } => {
                         winning.bid = total_burned.to_sat();
-                        winning.claim_at = claim_height.map(|h| h.to_string()).unwrap_or("--".to_string());
+                        winning.claim_at = claim_height
+                            .map(|h| h.to_string())
+                            .unwrap_or("--".to_string());
                         winning.days_left = format_days_left(current_block, claim_height);
                         if winning.days_left == "0.00" {
                             winning.days_left = "Ready to claim".to_string();
@@ -250,28 +278,36 @@ pub fn print_list_spaces_response(current_block: u32, response: ListSpacesRespon
                 match &space.covenant {
                     Covenant::Transfer { expire_height, .. } => {
                         registered.expire_at = *expire_height as _;
-                        registered.days_left = format_days_left(current_block, Some(*expire_height));
+                        registered.days_left =
+                            format_days_left(current_block, Some(*expire_height));
                     }
                     _ => {}
                 }
                 owned.push(registered);
             }
 
-
             if !outbids.is_empty() {
                 println!("⚠️ OUTBID ({} spaces): ", outbids.len().to_string().bold());
                 let table = ascii_table(outbids);
                 println!("{}", table);
             }
 
             if !winnings.is_empty() {
-                println!("{} WINNING ({} spaces):","✓".color(Color::Green), winnings.len().to_string().bold());
+                println!(
+                    "{} WINNING ({} spaces):",
+                    "✓".color(Color::Green),
+                    winnings.len().to_string().bold()
+                );
                 let table = ascii_table(winnings);
                 println!("{}", table);
             }
 
             if !owned.is_empty() {
-                println!("{} ({} spaces): ", "🔑 OWNED", owned.len().to_string().bold());
+                println!(
+                    "{} ({} spaces): ",
+                    "🔑 OWNED",
+                    owned.len().to_string().bold()
+                );
                 let table = ascii_table(owned);
                 println!("{}", table);
             }
@@ -292,13 +328,19 @@ pub fn print_wallet_response_text(network: Network, response: WalletResponse) {
 
     for tx in response.result {
         if tx.events.iter().any(|event| match event.kind {
-            TxEventKind::Open | TxEventKind::Bid | TxEventKind::Register |
-            TxEventKind::Transfer | TxEventKind::Send | TxEventKind::Renew | TxEventKind::Buy
-            => true,
+            TxEventKind::Open
+            | TxEventKind::Bid
+            | TxEventKind::Register
+            | TxEventKind::Transfer
+            | TxEventKind::Send
+            | TxEventKind::Renew
+            | TxEventKind::Buy => true,
             _ => false,
         }) {
             main_txs.push(tx);
-        } else { secondary_txs.push(tx); }
+        } else {
+            secondary_txs.push(tx);
+        }
     }
 
     for tx in main_txs {
@@ -328,7 +370,7 @@ pub fn print_error_rpc_response(code: i32, message: String, format: Format) {
 fn print_tx_response(network: Network, response: TxResponse) {
     match response.error {
         None => {
-            println!("{} Transaction {}","✓".color(Color::Green), response.txid);
+            println!("{} Transaction {}", "✓".color(Color::Green), response.txid);
         }
         Some(errors) => {
             println!("⚠️ Transaction failed to broadcast");
@@ -341,51 +383,57 @@ fn print_tx_response(network: Network, response: TxResponse) {
     }
 
     for event in response.events {
-        println!(" - {} {}", capitalize(event.kind.to_string()), event.space.unwrap_or("".to_string()));
+        println!(
+            " - {} {}",
+            capitalize(event.kind.to_string()),
+            event.space.unwrap_or("".to_string())
+        );
 
         match event.kind {
             TxEventKind::Open => {
-                let open_details: OpenEventDetails = serde_json::from_value(
-                    event.details.expect("details"))
-                    .expect("deserialize open event");
+                let open_details: OpenEventDetails =
+                    serde_json::from_value(event.details.expect("details"))
+                        .expect("deserialize open event");
 
                 println!("   Initial bid: {}", open_details.initial_bid.to_sat());
             }
             TxEventKind::Bid => {
-                let bid_details: BidEventDetails = serde_json::from_value(
-                    event.details.expect("details"))
-                    .expect("deserialize bid event");
-                println!("   New bid: {} (previous {})",
-                         bid_details.current_bid.to_sat(),
-                         bid_details.previous_bid.to_sat()
+                let bid_details: BidEventDetails =
+                    serde_json::from_value(event.details.expect("details"))
+                        .expect("deserialize bid event");
+                println!(
+                    "   New bid: {} (previous {})",
+                    bid_details.current_bid.to_sat(),
+                    bid_details.previous_bid.to_sat()
                 );
             }
             TxEventKind::Send => {
-                let send_details: SendEventDetails = serde_json::from_value(
-                    event.details.expect("details"))
-                    .expect("deserialize send event");
+                let send_details: SendEventDetails =
+                    serde_json::from_value(event.details.expect("details"))
+                        .expect("deserialize send event");
 
-                let addr = Address::from_script(send_details.recipient_script_pubkey.as_script(), network)
-                    .expect("valid address");
+                let addr =
+                    Address::from_script(send_details.recipient_script_pubkey.as_script(), network)
+                        .expect("valid address");
 
                 println!("   Amount: {}", send_details.amount.to_sat());
                 println!("   Recipient: {}", addr);
             }
             TxEventKind::Transfer => {
-                let transfer_details: TransferEventDetails = serde_json::from_value(
-                    event.details.expect("details"))
-                    .expect("deserialize transfer event");
+                let transfer_details: TransferEventDetails =
+                    serde_json::from_value(event.details.expect("details"))
+                        .expect("deserialize transfer event");
 
                 let addr = SpaceAddress(
                     Address::from_script(transfer_details.script_pubkey.as_script(), network)
-                        .expect("valid address")
+                        .expect("valid address"),
                 );
                 println!("   Recipient: {}", addr);
             }
             TxEventKind::Bidout => {
-                let bidout: BidoutEventDetails = serde_json::from_value(
-                    event.details.expect("details"))
-                    .expect("deserialize bidout event");
+                let bidout: BidoutEventDetails =
+                    serde_json::from_value(event.details.expect("details"))
+                        .expect("deserialize bidout event");
                 println!("   Count: {}", bidout.count);
             }
             _ => {}

Diff for: node/src/node.rs

@@ -44,15 +44,15 @@ pub struct BlockMeta {
     pub tx_meta: Vec<TxEntry>,
 }
 
-#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
+#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
 pub struct TxEntry {
     #[serde(flatten)]
     pub changeset: TxChangeSet,
     #[serde(skip_serializing_if = "Option::is_none", flatten)]
     pub tx: Option<TxData>,
 }
 
-#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
+#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode)]
 pub struct TxData {
     pub position: u32,
     pub raw: Bytes,

Diff for: node/src/rpc.rs

@@ -67,29 +67,18 @@ pub struct SignedMessage {
     pub signature: secp256k1::schnorr::Signature,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
 pub enum BlockIdentifier {
     Hash(BlockHash),
     Height(u32),
 }
-impl<'de> Deserialize<'de> for BlockIdentifier {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        #[derive(Deserialize)]
-        #[serde(untagged)]
-        enum RawIdentifier {
-            String(String),
-            Number(u32),
-        }
-        match RawIdentifier::deserialize(deserializer)? {
-            RawIdentifier::String(s) => BlockHash::from_str(&s)
-                .map(BlockIdentifier::Hash)
-                .map_err(serde::de::Error::custom),
-            RawIdentifier::Number(n) => Ok(BlockIdentifier::Height(n)),
-        }
-    }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BlockMetaWithHash {
+    pub hash: BlockHash,
+    pub height: u32,
+    pub tx_meta: Vec<TxEntry>,
 }
 
 pub enum ChainStateCommand {
@@ -119,7 +108,7 @@ pub enum ChainStateCommand {
     },
     GetBlockMeta {
         block_identifier: BlockIdentifier,
-        resp: Responder<anyhow::Result<BlockMeta>>,
+        resp: Responder<anyhow::Result<BlockMetaWithHash>>,
     },
     EstimateBid {
         target: usize,
@@ -180,7 +169,7 @@ pub trait Rpc {
     async fn get_block_meta(
         &self,
         block_identifier: BlockIdentifier,
-    ) -> Result<BlockMeta, ErrorObjectOwned>;
+    ) -> Result<BlockMetaWithHash, ErrorObjectOwned>;
 
     #[method(name = "gettxmeta")]
     async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxEntry>, ErrorObjectOwned>;
@@ -716,7 +705,7 @@ impl RpcServer for RpcServerImpl {
     async fn get_block_meta(
         &self,
         block_identifier: BlockIdentifier,
-    ) -> Result<BlockMeta, ErrorObjectOwned> {
+    ) -> Result<BlockMetaWithHash, ErrorObjectOwned> {
         let data = self
             .store
             .get_block_meta(block_identifier)
@@ -979,28 +968,31 @@ impl AsyncChainState {
         client: &reqwest::Client,
         rpc: &BitcoinRpc,
         chain_state: &mut LiveSnapshot,
-    ) -> Result<BlockMeta, anyhow::Error> {
+    ) -> Result<BlockMetaWithHash, anyhow::Error> {
         let index = index
             .as_mut()
             .ok_or_else(|| anyhow!("block index must be enabled"))?;
-        let block_hash = match block_identifier {
+        let 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))?,
         };
-        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(block_set);
+        if let Some(BlockMeta { height, tx_meta }) = index
+            .get(BaseHash::from_slice(hash.as_ref()))
+            .context("Could not fetch block from index")?
+        {
+            return Ok(BlockMetaWithHash {
+                hash,
+                height,
+                tx_meta,
+            });
         }
 
         let info: serde_json::Value = rpc
-            .send_json(client, &rpc.get_block_header(&block_hash))
+            .send_json(client, &rpc.get_block_header(&hash))
             .await
             .map_err(|e| anyhow!("Could not retrieve block ({})", e))?;
 
@@ -1018,7 +1010,8 @@ impl AsyncChainState {
                 height
             ));
         }
-        Ok(BlockMeta {
+        Ok(BlockMetaWithHash {
+            hash,
             height,
             tx_meta: Vec::new(),
         })
@@ -1211,7 +1204,7 @@ impl AsyncChainState {
     pub async fn get_block_meta(
         &self,
         block_identifier: BlockIdentifier,
-    ) -> anyhow::Result<BlockMeta> {
+    ) -> anyhow::Result<BlockMetaWithHash> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
             .send(ChainStateCommand::GetBlockMeta {

Diff for: protocol/src/validate.rs

@@ -17,7 +17,7 @@ use crate::{
 #[derive(Debug, Clone)]
 pub struct Validator {}
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 /// A `TxChangeSet` captures all resulting state changes.