Fix Betanet sync with seed coinbase encoding and commitments

Cargo.toml

@@ -28,6 +28,7 @@ hickory-resolver = { version = "0.26", default-features = false }
 http = "1.2.0"
 itertools = "0.14.0"
 jsonrpsee = { version = "0.26.0", features = ["tracing"] }
+merkle-cbt = "0.3.2"
 parking_lot = "0.12.1"
 prost = "0.14.3"
 # needs to line up with version required by frost-core

app/app.rs

@@ -523,6 +523,10 @@ impl App {
                      block connection"
                 );
             }
+            let coinbase = types::Coinbase {
+                memo: Vec::new(),
+                outputs: coinbase,
+            };
             let merkle_root = Body::compute_merkle_root(
                 &coinbase,
                 &txs.iter()
@@ -547,7 +551,7 @@ impl App {
             });
             (bribe, header, body, tx_fees)
         } else {
-            let coinbase = Vec::new();
+            let coinbase = types::Coinbase::default();
             let merkle_root = Body::compute_merkle_root(&coinbase, &[]);
             let body = Body::new(Vec::new(), coinbase);
             let header = types::Header {

app/gui/activity/block_explorer.rs

@@ -53,6 +53,7 @@ impl BlockExplorer {
                     bincode::serialize(&body).unwrap_or(vec![]).len();
                 let coinbase_value: bitcoin::Amount = body
                     .coinbase
+                    .outputs
                     .iter()
                     .map(GetBitcoinValue::get_bitcoin_value)
                     .sum();

app/gui/activity/mempool_explorer.rs

@@ -116,9 +116,9 @@ impl MempoolExplorer {
                                             format!("{}", outpoint.txid),
                                             outpoint.vout,
                                         ),
-                                        OutPoint::Coinbase { merkle_root, vout } => (
+                                        OutPoint::Coinbase { txid, vout } => (
                                             "coinbase",
-                                            format!("{merkle_root}"),
+                                            format!("{txid}"),
                                             *vout,
                                         ),
                                         OutPoint::MarketFunds {

app/gui/coins/utxo_selector.rs

@@ -196,8 +196,8 @@ pub fn show_utxo(
         OutPoint::Deposit(outpoint) => {
             ("deposit", format!("{}", outpoint.txid), outpoint.vout)
         }
-        OutPoint::Coinbase { merkle_root, vout } => {
-            ("coinbase", format!("{merkle_root}"), *vout)
+        OutPoint::Coinbase { txid, vout } => {
+            ("coinbase", format!("{txid}"), *vout)
         }
         OutPoint::MarketFunds {
             market_id,
@@ -250,8 +250,8 @@ pub fn show_unconfirmed_utxo(
         OutPoint::Deposit(outpoint) => {
             ("deposit", format!("{}", outpoint.txid), outpoint.vout)
         }
-        OutPoint::Coinbase { merkle_root, vout } => {
-            ("coinbase", format!("{merkle_root}"), *vout)
+        OutPoint::Coinbase { txid, vout } => {
+            ("coinbase", format!("{txid}"), *vout)
         }
         OutPoint::MarketFunds {
             market_id,

lib/Cargo.toml

@@ -40,6 +40,7 @@ itertools = { workspace = true }
 jsonrpsee = { workspace = true }
 libes = { workspace = true }
 libm = "0.2"
+merkle-cbt = { workspace = true }
 nalgebra = "0.33"
 ndarray = "0.15.6"
 nonempty = { version = "0.11.0", features = ["serialize"] }

lib/archive/mod.rs

@@ -115,8 +115,8 @@ impl Archive {
                 if db_version
                     < Version {
                         major: 0,
-                        minor: 15,
-                        patch: 1,
+                        minor: 18,
+                        patch: 0,
                     } =>
             {
                 return Err(Error::IncompatibleVersion {

lib/mempool.rs

@@ -1,4 +1,7 @@
-use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
+use std::{
+    collections::{BTreeSet, HashMap, HashSet, VecDeque},
+    path::PathBuf,
+};
 
 use fallible_iterator::FallibleIterator as _;
 use futures::{Stream, StreamExt};
@@ -26,6 +29,12 @@ use crate::{
 #[transitive(from(env::error::WriteTxn, EnvError))]
 #[transitive(from(rwtxn::error::Commit, RwTxnError))]
 pub enum Error {
+    #[error(
+        "Incompatible DB version ({}). Please clear the DB (`{}`) and re-sync",
+        .version,
+        .db_path.display()
+    )]
+    IncompatibleVersion { version: Version, db_path: PathBuf },
     #[error(transparent)]
     Db(#[from] DbError),
     #[error("Database env error")]
@@ -81,8 +90,22 @@ impl MemPool {
             DatabaseUnique::create(env, &mut rwtxn, "trade_order_counter")?;
         let version =
             DatabaseUnique::create(env, &mut rwtxn, "mempool_version")?;
-        if version.try_get(&rwtxn, &())?.is_none() {
-            version.put(&mut rwtxn, &(), &*VERSION)?;
+        match version.try_get(&rwtxn, &())? {
+            Some(db_version)
+                if db_version
+                    < Version {
+                        major: 0,
+                        minor: 18,
+                        patch: 0,
+                    } =>
+            {
+                return Err(Error::IncompatibleVersion {
+                    version: db_version,
+                    db_path: env.path().to_path_buf(),
+                });
+            }
+            Some(_) => (),
+            None => version.put(&mut rwtxn, &(), &*VERSION)?,
         }
         rwtxn.commit()?;
         Ok(Self {

lib/net/peer/message.rs

@@ -340,3 +340,34 @@ mod network_tests {
         assert_eq!(magics.len(), EXPECTED.len());
     }
 }
+
+#[cfg(test)]
+mod betanet_capture_tests {
+    use super::ResponseMessage;
+    use crate::types::Body;
+
+    #[test]
+    fn betanet_seed_genesis_response_matches_commitments() {
+        let bytes = include_bytes!("fixtures/betanet-genesis-response.bin");
+        let response: ResponseMessage = bincode::deserialize(bytes).unwrap();
+        assert_eq!(bincode::serialize(&response).unwrap(), bytes);
+        let ResponseMessage::Block { header, mut body } = response else {
+            panic!("expected block response");
+        };
+        assert_eq!(
+            header.hash().to_string(),
+            "bcac497706c7552b0bd6791212318ccea83b1d48d1164f54079dc482dc517bfb"
+        );
+        assert_eq!(
+            Body::compute_merkle_root(&body.coinbase, &body.transactions),
+            header.merkle_root
+        );
+        assert!(body.coinbase.memo.is_empty());
+        assert_eq!(body.coinbase.outputs.len(), 1);
+        body.coinbase.memo.push(1);
+        assert_ne!(
+            Body::compute_merkle_root(&body.coinbase, &body.transactions),
+            header.merkle_root
+        );
+    }
+}

lib/net/peer/request_queue.rs

@@ -48,8 +48,8 @@ impl ErrorRx {
         enum SourceItem {
             Error(error::channel_pool::SendMessage),
             Heartbeat(Heartbeat, channel_pool::LimiterGuard<Heartbeat>),
-            PeerResponse(PeerResponseItem),
-            Request(Request, channel_pool::LimiterGuard<Request>),
+            PeerResponse(Box<PeerResponseItem>),
+            Request(Box<Request>, channel_pool::LimiterGuard<Request>),
         }
         let (channel_pool, channel_pool_rx) = ChannelPool::new(connection);
         let channel_pool_stream = channel_pool_rx
@@ -59,7 +59,7 @@ impl ErrorRx {
                     SourceItem::Error(error)
                 }
                 futures::future::Either::Right(peer_response) => {
-                    SourceItem::PeerResponse(peer_response)
+                    SourceItem::PeerResponse(Box::new(peer_response))
                 }
             })
             .boxed();
@@ -90,7 +90,7 @@ impl ErrorRx {
                             .until_n_ready(request_cost(&request))
                             .await
                             .unwrap();
-                        SourceItem::Request(request, guard)
+                        SourceItem::Request(Box::new(request), guard)
                     }
                 }
             })
@@ -111,13 +111,13 @@ impl ErrorRx {
                     }
                 }
                 SourceItem::Request(request, guard) => {
-                    match channel_pool.send_request(request, guard) {
+                    match channel_pool.send_request(*request, guard) {
                         Ok(()) => None,
                         Err(err) => Some(err.into()),
                     }
                 }
                 SourceItem::PeerResponse(peer_response) => {
-                    match peer_response_tx.unbounded_send(peer_response) {
+                    match peer_response_tx.unbounded_send(*peer_response) {
                         Ok(()) => None,
                         Err(_err) => {
                             Some(error::request_queue::Error::PushPeerResponse)

lib/node/net_task.rs

@@ -1840,7 +1840,7 @@ mod test {
 
         let main_hash = bitcoin::BlockHash::from_byte_array([1; 32]);
         let body = Body {
-            coinbase: Vec::new(),
+            coinbase: crate::types::Coinbase::default(),
             transactions: Vec::new(),
             authorizations: Vec::new(),
             actor_proofs: Vec::new(),

lib/state/block.rs

@@ -734,7 +734,7 @@ pub fn connect_prevalidated(
         state
             .genesis_timestamp
             .put(rwtxn, &(), &mainchain_timestamp)?;
-        if let Some(first_coinbase) = body.coinbase.first() {
+        if let Some(first_coinbase) = body.coinbase.outputs.first() {
             state.reputation().set_reputation(
                 rwtxn,
                 &first_coinbase.address,
@@ -780,13 +780,13 @@ pub fn connect_prevalidated(
     }
 
     crate::validation::BlockValidator::validate_coinbase_outputs(
-        &body.coinbase,
+        &body.coinbase.outputs,
         height,
     )?;
 
-    for (vout, output) in body.coinbase.iter().enumerate() {
+    for (vout, output) in body.coinbase.outputs.iter().enumerate() {
         let outpoint = OutPoint::Coinbase {
-            merkle_root: header.merkle_root,
+            txid: header.compute_coinbase_txid(),
             vout: vout as u32,
         };
         let filled_content = match output.content.clone() {
@@ -1209,19 +1209,22 @@ pub fn disconnect_tip(
     }
 
     // 6. Revert coinbase UTXOs
-    body.coinbase.iter().enumerate().rev().try_for_each(
-        |(vout, _output)| {
+    body.coinbase
+        .outputs
+        .iter()
+        .enumerate()
+        .rev()
+        .try_for_each(|(vout, _output)| {
             let outpoint = OutPoint::Coinbase {
-                merkle_root: header.merkle_root,
+                txid: header.compute_coinbase_txid(),
                 vout: vout as u32,
             };
             if state.delete_utxo(rwtxn, &outpoint)? {
                 Ok(())
             } else {
                 Err(Error::NoUtxo { outpoint })
             }
-        },
-    )?;
+        })?;
 
     // 7. Rollback decision states (Claimed → Voting transitions)
     if height > 0 {

lib/state/error.rs

@@ -1,13 +1,15 @@
 //! State errors
 #![allow(clippy::duplicated_attributes)]
 
+use std::path::PathBuf;
+
 use sneed::{db::error as db, env::error as env, rwtxn::error as rwtxn};
 use thiserror::Error;
 use transitive::Transitive;
 
 use crate::types::{
     AmountOverflowError, AmountUnderflowError, BlockHash, M6id, MerkleRoot,
-    OutPoint, WithdrawalBundleError,
+    OutPoint, Version, WithdrawalBundleError,
 };
 
 #[derive(Debug, Error)]
@@ -63,6 +65,12 @@ impl std::error::Error for FillTxOutputContents {}
 #[transitive(from(rwtxn::Commit, rwtxn::Error))]
 #[transitive(from(rwtxn::Error, sneed::Error))]
 pub enum Error {
+    #[error(
+        "Incompatible DB version ({}). Please clear the DB (`{}`) and re-sync",
+        .version,
+        .db_path.display()
+    )]
+    IncompatibleVersion { version: Version, db_path: PathBuf },
     #[error(transparent)]
     Market(#[from] crate::state::markets::MarketError),
     #[error(transparent)]

lib/state/mod.rs

@@ -285,8 +285,22 @@ impl State {
             "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)?;
+        match version.try_get(&rwtxn, &())? {
+            Some(db_version)
+                if db_version
+                    < Version {
+                        major: 0,
+                        minor: 18,
+                        patch: 0,
+                    } =>
+            {
+                return Err(Error::IncompatibleVersion {
+                    version: db_version,
+                    db_path: env.path().to_path_buf(),
+                });
+            }
+            Some(_) => (),
+            None => version.put(&mut rwtxn, &(), &*VERSION)?,
         }
         let settlement_undo =
             DatabaseUnique::create(env, &mut rwtxn, "settlement_undo")?;

lib/state/two_way_peg_data.rs

@@ -1377,7 +1377,7 @@ mod tests {
             BatchVerificationContext::new(&mut rand::rng());
 
         let empty_body = Body {
-            coinbase: Vec::new(),
+            coinbase: crate::types::Coinbase::default(),
             transactions: Vec::new(),
             authorizations: Vec::new(),
             actor_proofs: Vec::new(),