Remove from_witness_data_size and from_non_witness_data_size

Weight::from_non_witness_data_size has an overflow bug. These methods
duplicate the functionality of `Weight::from_vb` and `Weight::from_wu`,
respectively. Furthermore, they are less discoverable than the methods
they duplicate, so they will be removed in this PR.

Author: shinghim

bitcoin/src/blockdata/transaction.rs

@@ -134,8 +134,8 @@ internal_macros::define_extension_trait! {
         /// Keep in mind that when adding a TxIn to a transaction, the total weight of the transaction
         /// might increase more than `TxIn::legacy_weight`. This happens when the new input added causes
         /// the input length `CompactSize` to increase its encoding length.
-        fn legacy_weight(&self) -> Weight {
-            Weight::from_non_witness_data_size(self.base_size().to_u64())
+        fn legacy_weight(&self) -> Option<Weight> {
+            Weight::from_vb(self.base_size().to_u64())
         }
 
         /// The weight of the TxIn when it's included in a SegWit transaction (i.e., a transaction
@@ -149,9 +149,9 @@ internal_macros::define_extension_trait! {
         /// - the new input added causes the input length `CompactSize` to increase its encoding length
         /// - the new input is the first segwit input added - this will add an additional 2WU to the
         ///   transaction weight to take into account the SegWit marker
-        fn segwit_weight(&self) -> Weight {
-            Weight::from_non_witness_data_size(self.base_size().to_u64())
-                + Weight::from_witness_data_size(self.witness.size().to_u64())
+        fn segwit_weight(&self) -> Option<Weight> {
+            Weight::from_vb(self.base_size().to_u64())
+                .map(|w| w + Weight::from_wu(self.witness.size().to_u64()))
         }
 
         /// Returns the base size of this input.
@@ -1805,7 +1805,7 @@ mod tests {
             assert_eq!(*is_segwit, tx.uses_segwit_serialization());
 
             let mut calculated_weight = empty_transaction_weight
-                + tx.inputs.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i))
+                + tx.inputs.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i).expect("valid weight"))
                 + tx.outputs.iter().fold(Weight::ZERO, |sum, o| sum + o.weight());
 
             // The empty tx uses SegWit serialization but a legacy tx does not.

fuzz/fuzz_targets/units/arbitrary_weight.rs

@@ -33,8 +33,7 @@ fn do_test(data: &[u8]) {
     }
 
     // Constructors that return a Weight
-    for constructor in
-        [Weight::from_wu, Weight::from_witness_data_size, Weight::from_non_witness_data_size]
+    for constructor in [Weight::from_wu]
     {
         if let Ok(val) = u.arbitrary() {
             constructor(val);

units/src/weight.rs

@@ -95,14 +95,6 @@ impl Weight {
         Weight::from_wu(vb * Self::WITNESS_SCALE_FACTOR)
     }
 
-    /// Constructs a new [`Weight`] from witness size.
-    pub const fn from_witness_data_size(witness_size: u64) -> Self { Weight::from_wu(witness_size) }
-
-    /// Constructs a new [`Weight`] from non-witness size.
-    pub const fn from_non_witness_data_size(non_witness_size: u64) -> Self {
-        Weight::from_wu(non_witness_size * Self::WITNESS_SCALE_FACTOR)
-    }
-
     /// Converts to kilo weight units rounding down.
     pub const fn to_kwu_floor(self) -> u64 { self.to_wu() / 1000 }
 
@@ -361,22 +353,6 @@ mod tests {
     #[should_panic = "attempt to multiply with overflow"]
     fn from_vb_unchecked_panic() { Weight::from_vb_unchecked(u64::MAX); }
 
-    #[test]
-    fn from_witness_data_size() {
-        let witness_data_size = 1;
-        let got = Weight::from_witness_data_size(witness_data_size);
-        let want = Weight::from_wu(witness_data_size);
-        assert_eq!(got, want);
-    }
-
-    #[test]
-    fn from_non_witness_data_size() {
-        let non_witness_data_size = 1;
-        let got = Weight::from_non_witness_data_size(non_witness_data_size);
-        let want = Weight::from_wu(non_witness_data_size * 4);
-        assert_eq!(got, want);
-    }
-
     #[test]
     fn to_kwu_floor() {
         assert_eq!(Weight::from_wu(5_000).to_kwu_floor(), 5);