encode: implement Encodable and Decodable for Vec<T>

Right now we have explicit impls of Vec<T> for a ton of specific types T.

This is annoying for users, who are unable to implement Vec<T> themselves
for their own types. In particular is super annoying for me trying to
do a semver trick with elements 0.25 and 0.26, since I can't reexport
the 0.26 Encodable trait since I would need to implement it for Vec<TxOut>
for the 0.25 TxOut type. (But conversely, if I retain the full trait
definition in 0.25, I can't blanket-impl this trait for all T: Encodable
because of this Vec<T> crap; so I wind up needing to explicitly implement
Encodable and Decodeable for every single type I re-export, and if I
forget any then that's a semver violation. Brutal.)

We do this is because we need a specialized impl for Vec<u8> and Rust has
no specialization. However, Kixunil pointed out on rust-bitcoin that we
can just do "runtime specialization" by checking TypeId::of::<T> and doing
the efficient thing when T is u8.

In practice, because the compiler knows T at codegen time, it will know
how the check goes and simply delete the check and the untaken branch,
so we have exactly the same result as we would if we had specialization.

This works only for T: 'static, but it turns out that all of our types
that we currently impl Encodable for Vec<T> on are 'static (and it's
hard to imagine one that wouldn't be, since all bitcoin/elements primitive
types are simple PODs).

It also seems plausible that a user could construct a Vec<u8> which the
compiler somehow doesn't realize is a Vec<u8> (e.g. if they had a
Vec<dyn Encodable> or something, in some future Rust version that
supports that). Such code will be sound and correct, but be slow because
it won't use the fast path. But I don't think this is a practical
concern because I can't even figure out how to do it..

Author: apoelstra

src/encode.rs

@@ -16,14 +16,13 @@
 //!
 
 use std::io::Cursor;
-use std::{error, fmt, io, mem};
+use std::{any, error, fmt, io, mem};
 
 use bitcoin::ScriptBuf;
 use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
 
 use crate::hashes::{sha256, Hash};
 use crate::pset;
-use crate::transaction::{Transaction, TxIn, TxOut};
 
 pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
@@ -314,47 +313,84 @@ impl Decodable for bitcoin::hashes::sha256d::Hash {
 }
 
 // Vectors
-macro_rules! impl_vec {
-    ($type: ty) => {
-        impl Encodable for Vec<$type> {
-            #[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)?;
-                for c in self.iter() {
-                    len += c.consensus_encode(&mut s)?;
-                }
-                Ok(len)
+impl<T: Encodable + any::Any> Encodable for [T] {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
+        if any::TypeId::of::<T>() == any::TypeId::of::<u8>() {
+            // SAFETY: checked that T is exactly u8, so &self, of type, &[T], is exactly &[u8]
+            let u8_slice = unsafe {
+                std::slice::from_raw_parts(self.as_ptr().cast::<u8>(), self.len())
+            };
+            consensus_encode_with_size(u8_slice, s)
+        } else {
+            let mut len = 0;
+            len += VarInt(self.len() as u64).consensus_encode(&mut s)?;
+            for c in self {
+                len += c.consensus_encode(&mut s)?;
             }
+            Ok(len)
         }
+    }
+}
 
-        impl Decodable for Vec<$type> {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                let len = VarInt::consensus_decode(&mut d)?.0;
-                let byte_size = (len as usize)
-                    .checked_mul(mem::size_of::<$type>())
-                    .ok_or(self::Error::ParseFailed("Invalid length"))?;
-                if byte_size > MAX_VEC_SIZE {
-                    return Err(self::Error::OversizedVectorAllocation {
-                        requested: byte_size,
-                        max: MAX_VEC_SIZE,
-                    });
-                }
-                let mut ret = Vec::with_capacity(len as usize);
-                for _ in 0..len {
-                    ret.push(Decodable::consensus_decode(&mut d)?);
-                }
-                Ok(ret)
+impl<T: Encodable + any::Any> Encodable for Vec<T> {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
+        self[..].consensus_encode(s)
+    }
+}
+
+impl<T: Encodable + any::Any> Encodable for Box<[T]> {
+    #[inline]
+    fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
+        self[..].consensus_encode(s)
+    }
+}
+
+impl<T: Decodable + any::Any> Decodable for Vec<T> {
+    #[inline]
+    fn consensus_decode<D: crate::ReadExt>(mut d: D) -> Result<Self, Error> {
+        if any::TypeId::of::<T>() == any::TypeId::of::<u8>() {
+            let s = VarInt::consensus_decode(&mut d)?.0 as usize;
+            if s > MAX_VEC_SIZE {
+                return Err(self::Error::OversizedVectorAllocation {
+                    requested: s,
+                    max: MAX_VEC_SIZE,
+                });
+            }
+            let mut v = vec![0; s];
+            d.read_slice(&mut v)?;
+            // SAFETY: checked that T is exactly u8, so v, of type, Vec<u8>, is exactly Vec<T>
+            unsafe {
+                Ok(std::mem::transmute::<Vec<u8>, Vec<T>>(v))
+            }
+        } else {
+            let len = VarInt::consensus_decode(&mut d)?.0;
+            let byte_size = (len as usize)
+                .checked_mul(mem::size_of::<T>())
+                .ok_or(self::Error::ParseFailed("Invalid length"))?;
+            if byte_size > MAX_VEC_SIZE {
+                return Err(self::Error::OversizedVectorAllocation {
+                    requested: byte_size,
+                    max: MAX_VEC_SIZE,
+                });
             }
+            let mut ret = Vec::with_capacity(len as usize);
+            for _ in 0..len {
+                ret.push(Decodable::consensus_decode(&mut d)?);
+            }
+            Ok(ret)
         }
-    };
+    }
+}
+
+impl<T: Decodable + any::Any> Decodable for Box<[T]> {
+    #[inline]
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        let v = Vec::<T>::consensus_decode(d)?;
+        Ok(v.into())
+    }
 }
-impl_vec!(TxIn);
-impl_vec!(TxOut);
-impl_vec!(Transaction);
-impl_vec!(TapLeafHash);
-impl_vec!(Vec<u8>); // Vec<Vec<u8>>
 
 macro_rules! impl_array {
     ( $size:literal ) => {
@@ -383,38 +419,6 @@ impl_array!(4);
 impl_array!(32);
 impl_array!(33);
 
-impl Encodable for Box<[u8]> {
-    fn consensus_encode<W: io::Write>(&self, mut w: W) -> Result<usize, Error> {
-        consensus_encode_with_size(&self[..], &mut w)
-    }
-}
-impl Decodable for Box<[u8]> {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        let v = Vec::<u8>::consensus_decode(d)?;
-        Ok(v.into())
-    }
-}
-
-impl Encodable for Vec<u8> {
-    fn consensus_encode<W: io::Write>(&self, mut w: W) -> Result<usize, Error> {
-        consensus_encode_with_size(&self[..], &mut w)
-    }
-}
-impl Decodable for Vec<u8> {
-    fn consensus_decode<D: crate::ReadExt>(mut d: D) -> Result<Self, Error> {
-        let s = VarInt::consensus_decode(&mut d)?.0 as usize;
-        if s > MAX_VEC_SIZE {
-            return Err(self::Error::OversizedVectorAllocation {
-                requested: s,
-                max: MAX_VEC_SIZE,
-            });
-        }
-        let mut v = vec![0; s];
-        d.read_slice(&mut v)?;
-        Ok(v)
-    }
-}
-
 macro_rules! impl_box_option {
     ($type: ty) => {
         impl Encodable for Option<Box<$type>> {