Merge #250: Release 0.26.1 with some minor API extensions

05a24ad bump version to 0.26.1 (Andrew Poelstra)
2b89d5f encode: implement Encodable and Decodable for Vec<T> (Andrew Poelstra)
45a6938 export pset::error::PsetHash (Andrew Poelstra)

Pull request description:

  I want to do the dtolnay "semver trick" where I release 0.25.3 which re-exports most of the types and traits from 0.26. This will make migration easier for users since they could use elements 0.25 and 0.26 in the same crate and have compatible types. In particular ElementsProject/elements-miniscript#97 would compile without needing to update `simplicity` and `elements` at the same time.
  
  However, when doing this I identified some gaps in the API which make this harder than it should be. See the commit messages for detailed justifications.
  
  Also release 0.26.1 with these changes.


ACKs for top commit:
  RCasatta:
    utACK 05a24ad


Tree-SHA512: 447d09950586da98a1d8a13fe8dc1ce69761d2a3152b9ea243264ec874f04bc1219d42a562e0470246c266980e77d2a46d807c78ed5ca9bbcf8f4055af3ea4c6

Author: apoelstra

CHANGELOG.md

@@ -1,4 +1,10 @@
 
+# 0.26.1 - 2025-08-28
+
+* [#250](https://github.com/ElementsProject/rust-elements/pull/250) API cleanups
+  * implement `Encodable` and `Decodable` for `Vec<T>` whenever `T` is `Encodable`/`Decodable` and `'static`
+  * add missing export of error sub-type `pset::PsetHash`
+
 # 0.26.0 - 2025-08-22
 
 * [#249](https://github.com/ElementsProject/rust-elements/pull/249) docs: fix changelog links

Cargo-latest.lock

@@ -190,7 +190,7 @@ checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "elements"
-version = "0.26.0"
+version = "0.26.1"
 dependencies = [
  "bech32",
  "bincode",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "elements"
-version = "0.26.0"
+version = "0.26.1"
 authors = ["Andrew Poelstra <[email protected]>"]
 description = "Library with support for de/serialization, parsing and executing on data structures and network messages related to Elements"
 license = "CC0-1.0"

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>> {

src/pset/error.rs

@@ -26,9 +26,13 @@ use secp256k1_zkp;
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 /// Enum for marking pset hash error
 pub enum PsetHash {
+    /// Bad preimage for `RIPEMD160` hash.
     Ripemd,
+    /// Bad preimage for `SHA256` hash.
     Sha256,
+    /// Bad preimage for `RIPEMD160-SHA256` hash.
     Hash160,
+    /// Bad preimage for double-`SHA256` hash.
     Hash256,
 }
 /// Ways that a Partially Signed Transaction might fail.

src/pset/mod.rs

@@ -53,7 +53,7 @@ use crate::{
 use secp256k1_zkp::rand::{CryptoRng, RngCore};
 use secp256k1_zkp::{self, RangeProof, SecretKey, SurjectionProof};
 
-pub use self::error::{Error, PsetBlindError};
+pub use self::error::{Error, PsetBlindError, PsetHash};
 use self::map::Map;
 pub use self::map::{Global, GlobalTxData, Input, Output, PsbtSighashType, TapTree};