transaction and block: use Weight as return type for weight methods

The API change is actually only a couple LOC. The real change is that we
start using u64 arithmetic to compute weights rather than usize
arithmetic, because Weight::from_wu wants a u64.

To facilitate this we introduce the private Len64 trait which provides
lengths in u64, and use it throughout the crate. This replaces 23 casts
to usize or u64 with four.

Author: apoelstra

src/block.rs

@@ -24,7 +24,8 @@ use crate::dynafed;
 use crate::hashes::{Hash, sha256};
 use crate::Transaction;
 use crate::encode::{self, serialize, Decodable, Encodable, VarInt};
-use crate::{BlockHash, Script, TxMerkleNode};
+use crate::{BlockHash, Script, TxMerkleNode, Weight};
+use crate::Len64 as _;
 
 /// Data related to block signatures
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -365,17 +366,19 @@ impl Block {
     }
 
     /// Get the size of the block
+    #[deprecated(since = "0.26.0", note = "use Self::weight or Self::encoded_length instead")]
     pub fn size(&self) -> usize {
         // The size of the header + the size of the varint with the tx count + the txs themselves
-        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size();
-        let txs_size: usize = self.txdata.iter().map(Transaction::size).sum();
+        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len64()).size();
+        let txs_size = self.txdata.iter().map(Transaction::encoded_length).sum::<usize>();
         base_size + txs_size
     }
 
     /// Get the weight of the block
-    pub fn weight(&self) -> usize {
-        let base_weight = 4 * (serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size());
-        let txs_weight: usize = self.txdata.iter().map(Transaction::weight).sum();
+    pub fn weight(&self) -> Weight {
+        let base_weight = Weight::from_vb(self.header.encoded_len64() + VarInt(self.txdata.len64()).len64())
+            .expect("base weight does not overflow the Weight type");
+        let txs_weight = self.txdata.iter().map(Transaction::weight).sum::<Weight>();
         base_weight + txs_weight
     }
 }
@@ -454,8 +457,8 @@ mod tests {
         assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 2);
         assert_eq!(block.txdata.len(), 1);
-        assert_eq!(block.size(), serialize(&block).len());
-        assert_eq!(block.weight(), 1089);
+        assert_eq!(block.encoded_length(), serialize(&block).len());
+        assert_eq!(block.weight().to_wu(), 1089);
 
         // Block with 3 transactions ... the rangeproofs are very large :)
         let block: Block = hex_deserialize!(
@@ -666,7 +669,7 @@ mod tests {
         assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 1);
         assert_eq!(block.txdata.len(), 3);
-        assert_eq!(block.size(), serialize(&block).len());
+        assert_eq!(block.encoded_length(), serialize(&block).len());
 
         // 2-of-3 signed block from Liquid integration tests
         let block: Block = hex_deserialize!(

src/encode.rs

@@ -24,6 +24,7 @@ use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
 use crate::hashes::{sha256, Hash};
 use crate::pset;
 use crate::transaction::{Transaction, TxIn, TxOut};
+use crate::Len64 as _;
 
 pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
@@ -224,7 +225,7 @@ pub(crate) fn consensus_encode_with_size<S: crate::WriteExt>(
     data: &[u8],
     mut s: S,
 ) -> Result<usize, Error> {
-    let vi_len = VarInt(data.len() as u64).consensus_encode(&mut s)?;
+    let vi_len = VarInt(data.len64()).consensus_encode(&mut s)?;
     s.emit_slice(data)?;
     Ok(vi_len + data.len())
 }
@@ -336,7 +337,7 @@ macro_rules! impl_vec {
             #[inline]
             fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
                 let mut len = 0;
-                len += VarInt(self.len() as u64).consensus_encode(&mut s)?;
+                len += VarInt(self.len64()).consensus_encode(&mut s)?;
                 for c in self.iter() {
                     len += c.consensus_encode(&mut s)?;
                 }

src/lib.rs

@@ -98,3 +98,39 @@ pub use crate::transaction::{
     AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PegoutData, Transaction, TxIn,
     TxInWitness, TxOut, TxOutWitness,
 };
+
+/// Utility trait for producing lengths in u64, for use in weight computations.
+trait Len64 {
+    fn len64(&self) -> u64;
+}
+
+impl<T> Len64 for [T] {
+    fn len64(&self) -> u64 { self.len() as u64 }
+}
+impl<T> Len64 for &[T] {
+    fn len64(&self) -> u64 { (*self).len64() }
+}
+impl<T> Len64 for Vec<T> {
+    fn len64(&self) -> u64 { self[..].len64() }
+}
+impl Len64 for crate::script::Script {
+    fn len64(&self) -> u64 { self[..].len64() }
+}
+impl Len64 for secp256k1_zkp::RangeProof {
+    fn len64(&self) -> u64 { self.serialize().len64() }
+}
+impl Len64 for secp256k1_zkp::SurjectionProof {
+    fn len64(&self) -> u64 { self.serialize().len64() }
+}
+impl Len64 for bitcoin::VarInt {
+    fn len64(&self) -> u64 { self.size() as u64 }
+}
+impl Len64 for crate::encode::VarInt {
+    fn len64(&self) -> u64 { self.size() as u64 }
+}
+impl<T: Len64> Len64 for Option<T> {
+    fn len64(&self) -> u64 { self.as_ref().map_or(0, T::len64) }
+}
+impl<T: Len64> Len64 for Box<T> {
+    fn len64(&self) -> u64 { (**self).len64() }
+}

src/pset/raw.rs

@@ -99,24 +99,31 @@ impl fmt::Display for Key {
 
 impl Decodable for Key {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
+        use core::convert::TryFrom;
+
         let VarInt(byte_size): VarInt = Decodable::consensus_decode(&mut d)?;
 
         if byte_size == 0 {
             return Err(Error::NoMorePairs.into());
         }
+        let key_byte_size = match usize::try_from(byte_size) {
+            Ok(n) => n - 1,
+            Err(_) => return Err(encode::Error::OversizedVectorAllocation {
+                requested: usize::MAX,
+                max: MAX_VEC_SIZE,
+            }),
+        };
 
-        let key_byte_size: u64 = byte_size - 1;
-
-        if key_byte_size > MAX_VEC_SIZE as u64 {
+        if key_byte_size > MAX_VEC_SIZE {
             return Err(encode::Error::OversizedVectorAllocation {
-                requested: key_byte_size as usize,
+                requested: key_byte_size,
                 max: MAX_VEC_SIZE,
             });
         }
 
         let type_value: u8 = Decodable::consensus_decode(&mut d)?;
 
-        let mut key = Vec::with_capacity(key_byte_size as usize);
+        let mut key = Vec::with_capacity(key_byte_size);
         for _ in 0..key_byte_size {
             key.push(Decodable::consensus_decode(&mut d)?);
         }
@@ -127,8 +134,10 @@ impl Decodable for Key {
 
 impl Encodable for Key {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
+        use crate::Len64 as _;
+
         let mut len = 0;
-        len += VarInt((self.key.len() + 1) as u64).consensus_encode(&mut s)?;
+        len += VarInt(self.key.len64() + 1).consensus_encode(&mut s)?;
 
         len += self.type_value.consensus_encode(&mut s)?;
 

src/script.rs

@@ -33,6 +33,7 @@ use secp256k1_zkp::{Verification, Secp256k1};
 use crate::encode::{self, Decodable, Encodable};
 use crate::hashes::Hash;
 use crate::{hex, opcodes, ScriptHash, WScriptHash, PubkeyHash, WPubkeyHash};
+use crate::Len64 as _;
 
 use bitcoin::PublicKey;
 
@@ -780,7 +781,7 @@ impl Builder {
     #[must_use]
     pub fn push_slice(mut self, data: &[u8]) -> Builder {
         // Start with a PUSH opcode
-        match data.len() as u64 {
+        match data.len64() {
             n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => { self.0.push(n as u8); },
             n if n < 0x100 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA1.into_u8());