encode: introduce encoded_length utility function

Author: apoelstra

src/confidential.rs

@@ -70,15 +70,6 @@ impl Value {
         Value::Confidential(comm)
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Value::Null => 1,
-            Value::Explicit(..) => 9,
-            Value::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Value::Confidential(PedersenCommitment::from_slice(bytes)?))
@@ -145,13 +136,23 @@ impl Encodable for Value {
             Value::Confidential(commitment) => commitment.consensus_encode(&mut s),
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 9,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for PedersenCommitment {
     fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Value {
@@ -272,15 +273,6 @@ impl Asset {
         ))
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Asset::Null => 1,
-            Asset::Explicit(..) => 33,
-            Asset::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Asset::Confidential(Generator::from_slice(bytes)?))
@@ -367,13 +359,23 @@ impl Encodable for Asset {
             Asset::Confidential(generator) => generator.consensus_encode(&mut s)
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 33,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for Generator {
     fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Asset {
@@ -537,15 +539,6 @@ impl Nonce {
         SecretKey::from_slice(&shared_secret[..32]).expect("always has exactly 32 bytes")
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Nonce::Null => 1,
-            Nonce::Explicit(..) => 33,
-            Nonce::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Nonce::Confidential(
@@ -619,13 +612,23 @@ impl Encodable for Nonce {
             Nonce::Confidential(commitment) => commitment.consensus_encode(&mut s),
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 33,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for PublicKey {
     fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Nonce {

src/encode.rs

@@ -147,6 +147,22 @@ pub trait Encodable {
     /// the underlying `Write` errors. Returns the number of bytes written on
     /// success
     fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error>;
+
+    /// The length of the object, in bytes, when encoded.
+    #[inline]
+    fn encoded_length(&self) -> usize {
+        self.consensus_encode(io::sink()).expect("no errors on sink")
+    }
+
+    /// The length of the object, in bytes, when encoded.
+    ///
+    /// Convenience function to minimize the amount of explicit casting that
+    /// users need to do. No object in Bitcoin or Elements will ever approach
+    /// [`u64::MAX`] in encoded size, regardless of the range of `usize`.
+    #[inline]
+    fn encoded_len64(&self) -> u64 {
+        self.encoded_length() as u64
+    }
 }
 
 /// Data which can be encoded in a consensus-consistent way