Add test for rejecting registrations without a matching reservation

Author: 1440000bytes

lib/state/mod.rs

@@ -670,3 +670,103 @@ impl Watchable<()> for State {
         tokio_stream::wrappers::WatchStream::new(self.tip.watch().clone())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Error, State, error};
+    use crate::types::{
+        Address, BitName, FilledOutput, FilledOutputContent, FilledTransaction,
+        Hash, MutableBitNameData, OutPoint, Output, OutputContent, Transaction,
+        TxData, Txid,
+    };
+
+    /// Open a fresh state in a unique temporary directory.
+    fn new_state() -> (sneed::Env, State) {
+        let path = std::env::temp_dir().join(format!(
+            "plain_bitnames_registration_{}",
+            std::process::id()
+        ));
+        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)
+    }
+
+    /// Build a BitName registration that registers `name_hash` with
+    /// `revealed_nonce`, while spending a single reservation that commits to
+    /// `reservation_commitment`.
+    fn registration_tx(
+        name_hash: BitName,
+        revealed_nonce: Hash,
+        reservation_commitment: Hash,
+    ) -> FilledTransaction {
+        let address = Address([0; 20]);
+        let mut transaction = Transaction::new(
+            vec![OutPoint::Regular {
+                txid: Txid([0; 32]),
+                vout: 0,
+            }],
+            vec![Output::new(address, OutputContent::BitName)],
+        );
+        transaction.data = Some(TxData::BitNameRegistration {
+            name_hash,
+            revealed_nonce,
+            bitname_data: Box::new(MutableBitNameData::default()),
+        });
+        let reservation = FilledOutput::new(
+            address,
+            FilledOutputContent::BitNameReservation(
+                Txid([0; 32]),
+                reservation_commitment,
+            ),
+        );
+        FilledTransaction {
+            transaction,
+            spent_utxos: vec![reservation],
+        }
+    }
+
+    /// 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();
+        let rotxn = env.read_txn().unwrap();
+        let name_hash = BitName([7; 32]);
+        let revealed_nonce: Hash = [3; 32];
+        let implied_commitment: Hash =
+            blake3::keyed_hash(&revealed_nonce, &name_hash.0).into();
+
+        // The reservation commits to something other than the registered name.
+        let mismatched_commitment: Hash = [0; 32];
+        assert_ne!(mismatched_commitment, implied_commitment);
+        let tx =
+            registration_tx(name_hash, revealed_nonce, mismatched_commitment);
+        let err = state.validate_bitnames(&rotxn, &tx).expect_err(
+            "registration without a matching reservation must be rejected",
+        );
+        assert!(
+            matches!(
+                err,
+                Error::BitName(
+                    error::BitName::NoReservationForRegistration { bitname }
+                ) if bitname == name_hash
+            ),
+            "unexpected error: {err:?}"
+        );
+
+        // The same registration burning the matching reservation is accepted.
+        let tx =
+            registration_tx(name_hash, revealed_nonce, implied_commitment);
+        state.validate_bitnames(&rotxn, &tx).expect(
+            "registration burning the matching reservation should validate",
+        );
+    }
+}