Fix incorrect calculation of sidechain wealth

Author: Ash-L2L

lib/state/mod.rs

@@ -582,7 +582,7 @@ impl State {
                         .ok_or(AmountOverflowError)?;
                 }
                 if let InPoint::Withdrawal { .. } = spent_output.inpoint {
-                    total_withdrawal_stxo_value = total_deposit_stxo_value
+                    total_withdrawal_stxo_value = total_withdrawal_stxo_value
                         .checked_add(spent_output.output.get_value())
                         .ok_or(AmountOverflowError)?;
                 }
@@ -692,28 +692,38 @@ mod tests {
         types::{
             Address, AuthorizedTransaction, BitName, BitcoinOutputContent,
             FilledOutput, FilledOutputContent, FilledTransaction, Hash,
-            MutableBitNameData, OutPoint, OutPointKey, Output, OutputContent,
-            Transaction, TxData, Txid, VerifyingKey,
+            InPoint, MutableBitNameData, OutPoint, OutPointKey, Output,
+            OutputContent, SpentOutput, Transaction, TxData, Txid,
+            VerifyingKey,
         },
     };
 
-    /// Open a fresh state in a unique temporary directory.
-    fn new_state(dir_name_suffix: &str) -> (sneed::Env, State) {
-        let dir_name = if dir_name_suffix.is_empty() {
-            format!("plain_bitnames_{}", std::process::id())
-        } else {
-            format!("plain_bitnames_{dir_name_suffix}_{}", std::process::id())
-        };
-        let path = std::env::temp_dir().join(dir_name);
-        let _remove_result = std::fs::remove_dir_all(&path);
-        std::fs::create_dir_all(&path).unwrap();
-        let env = {
-            let mut opts = heed::EnvOpenOptions::new();
-            opts.map_size(10 * 1024 * 1024).max_dbs(State::NUM_DBS);
-            unsafe { sneed::Env::open(&opts, &path) }.unwrap()
-        };
-        let state = State::new(&env).unwrap();
-        (env, state)
+    fn temp_env_path(test_name: &str) -> anyhow::Result<std::path::PathBuf> {
+        let mut path = std::env::temp_dir();
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)?
+            .as_nanos();
+        path.push(format!(
+            "bitnames-{test_name}-{}-{nanos}",
+            std::process::id()
+        ));
+        Ok(path)
+    }
+
+    // open a fresh state-backed env in a unique temp dir
+    fn temp_env(test_name: &str) -> anyhow::Result<sneed::Env> {
+        let path = temp_env_path(test_name)?;
+        std::fs::create_dir_all(&path)?;
+        let mut opts = heed::EnvOpenOptions::new();
+        opts.map_size(16 * 1024 * 1024).max_dbs(State::NUM_DBS);
+        let res = unsafe { sneed::Env::open(&opts, &path) }?;
+        Ok(res)
+    }
+
+    fn fresh_state(test_name: &str) -> anyhow::Result<(sneed::Env, State)> {
+        let env = temp_env(test_name)?;
+        let state = State::new(&env)?;
+        Ok((env, state))
     }
 
     /// Fund `address` with a single bitcoin UTXO of `value` sats, returning its
@@ -782,8 +792,9 @@ mod tests {
     /// spent UTXOs silently skips the unauthorized input, allowing any UTXO to
     /// be spent without a signature.
     #[test]
-    fn validate_transaction_rejects_missing_authorization() {
-        let (env, state) = new_state("auth_count");
+    fn validate_transaction_rejects_missing_authorization() -> anyhow::Result<()>
+    {
+        let (env, state) = fresh_state("auth_count")?;
         let signing_key = SigningKey::from_bytes(&[1u8; 32]);
         let verifying_key: VerifyingKey = signing_key.verifying_key().into();
         let address = authorization::get_address(&verifying_key);
@@ -804,11 +815,11 @@ mod tests {
             transaction: transaction.clone(),
             authorizations: Vec::new(),
         };
-        let rotxn = env.read_txn().unwrap();
+        let rotxn = env.read_txn()?;
         let err = state
             .validate_transaction(&rotxn, &unauthorized)
             .expect_err("tx with no authorizations must be rejected");
-        assert!(
+        anyhow::ensure!(
             matches!(
                 err,
                 Error::WrongNumberOfAuthorizations {
@@ -821,21 +832,22 @@ mod tests {
 
         // The same transaction with a valid authorization is accepted.
         let authorized =
-            authorization::authorize(&[(address, &signing_key)], transaction)
-                .unwrap();
+            authorization::authorize(&[(address, &signing_key)], transaction)?;
         state
             .validate_transaction(&rotxn, &authorized)
             .expect("correctly authorized tx should validate");
+        Ok(())
     }
 
     /// A registration whose spent reservation does not commit to the
     /// registered name must be rejected. Otherwise it passes validation and
     /// later panics in `apply_registration`, which fails to find the
     /// reservation to burn.
     #[test]
-    fn validate_bitnames_rejects_registration_without_matching_reservation() {
-        let (env, state) = new_state("registration");
-        let rotxn = env.read_txn().unwrap();
+    fn validate_bitnames_rejects_registration_without_matching_reservation()
+    -> anyhow::Result<()> {
+        let (env, state) = fresh_state("registration")?;
+        let rotxn = env.read_txn()?;
         let name_hash = BitName([7; 32]);
         let revealed_nonce: Hash = [3; 32];
         let implied_commitment: Hash =
@@ -849,7 +861,7 @@ mod tests {
         let err = state.validate_bitnames(&rotxn, &tx).expect_err(
             "registration without a matching reservation must be rejected",
         );
-        assert!(
+        anyhow::ensure!(
             matches!(
                 err,
                 Error::BitName(
@@ -864,5 +876,91 @@ mod tests {
         state.validate_bitnames(&rotxn, &tx).expect(
             "registration burning the matching reservation should validate",
         );
+        Ok(())
+    }
+
+    #[test]
+    fn sidechain_wealth() -> anyhow::Result<()> {
+        use std::str::FromStr;
+
+        use bitcoin::hashes::Hash as _;
+
+        let value_output = |sats: u64| FilledOutput {
+            address: Address::ALL_ZEROS,
+            content: FilledOutputContent::Bitcoin(BitcoinOutputContent(
+                bitcoin::Amount::from_sat(sats),
+            )),
+            memo: Vec::new(),
+        };
+        let (env, state) = fresh_state("sidechain-wealth")?;
+        {
+            let mut rwtxn = env.write_txn()?;
+
+            // One unspent DEPOSIT UTXO: 50 sats.
+            let deposit_utxo_op = OutPoint::Deposit(bitcoin::OutPoint {
+                txid: bitcoin::Txid::from_str(
+                    "0000000000000000000000000000000000000000000000000000000000000001",
+                )?,
+                vout: 0,
+            });
+            state.utxos.put(
+                &mut rwtxn,
+                &OutPointKey::from(&deposit_utxo_op),
+                &value_output(50),
+            )?;
+
+            // Two spent DEPOSIT STXOs: 100 + 100 sats.
+            for (i, sats) in [(2u8, 100u64), (3u8, 100u64)] {
+                let op = OutPoint::Deposit(bitcoin::OutPoint {
+                    txid: bitcoin::Txid::from_byte_array([i; 32]),
+                    vout: 0,
+                });
+                let stxo = SpentOutput {
+                    output: value_output(sats),
+                    inpoint: InPoint::Regular {
+                        txid: [i; 32].into(),
+                        vin: 0,
+                    },
+                };
+                state
+                    .stxos
+                    .put(&mut rwtxn, &OutPointKey::from(&op), &stxo)?;
+            }
+
+            // Two WITHDRAWAL STXOs: 10 + 10 sats
+            for (i, sats) in [(4u8, 10u64), (5u8, 10u64)] {
+                let op = OutPoint::Regular {
+                    txid: [i; 32].into(),
+                    vout: 0,
+                };
+                let stxo = SpentOutput {
+                    output: value_output(sats),
+                    inpoint: InPoint::Withdrawal {
+                        m6id: crate::types::M6id(
+                            bitcoin::Txid::from_byte_array([i; 32]),
+                        ),
+                    },
+                };
+                state
+                    .stxos
+                    .put(&mut rwtxn, &OutPointKey::from(&op), &stxo)?;
+            }
+
+            rwtxn.commit()?;
+        }
+
+        let rotxn = env.read_txn()?;
+        let sidechain_wealth = state.sidechain_wealth(&rotxn)?;
+
+        // Correct value: deposit UTXO 50 + deposit STXOs 200 - withdrawal
+        // STXOs 20 = 230 sats.
+        let expected_sidechain_wealth = bitcoin::Amount::from_sat(230);
+        anyhow::ensure!(
+            sidechain_wealth == expected_sidechain_wealth,
+            "Expected sidechain wealth ({}), but computed ({})",
+            expected_sidechain_wealth,
+            sidechain_wealth,
+        );
+        Ok(())
     }
 }

lib/state/two_way_peg_data.rs

@@ -1317,7 +1317,6 @@ mod tests {
             merkle_root,
             prev_side_hash: None,
             prev_main_hash: main0,
-            roots: Vec::new(),
         };
         {
             let mut rwtxn = env.write_txn().unwrap();
@@ -1334,7 +1333,6 @@ mod tests {
             merkle_root,
             prev_side_hash: Some(genesis.hash()),
             prev_main_hash: main1,
-            roots: Vec::new(),
         };
         let deposit_outpoint = bitcoin::OutPoint {
             txid: bitcoin::Txid::from_byte_array([2; 32]),
@@ -1351,11 +1349,14 @@ mod tests {
                     events: vec![BlockEvent::Deposit(Deposit {
                         tx_index: 0,
                         outpoint: deposit_outpoint,
-                        output: Output {
+                        output: FilledOutput {
                             address: Address::ALL_ZEROS,
-                            content: OutputContent::Value(
-                                bitcoin::Amount::from_sat(1000),
+                            content: FilledOutputContent::Bitcoin(
+                                BitcoinOutputContent(
+                                    bitcoin::Amount::from_sat(1000),
+                                ),
                             ),
+                            memo: Vec::new(),
                         },
                     })],
                 },