transaction: strongly type script_witness

Just copy witness.rs from rust-bitcoin aeadac41b45a170beddbdbea8ada3d1621f09e7c,
remove the alloc/std gates, and remove the LowerHex/UpperHex impls for which we
need the private `HexPrimitive` type from bitcoin-primitives.

Also fix the witness encoder to be exact-sized; see rust-bitcoin/rust-bitcoin#6426

Author: apoelstra

Cargo.toml

@@ -74,6 +74,7 @@ match_bool = "allow" # Adds extra indentation and LOC.
 match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
 must_use_candidate = "allow" # Useful for audit but many false positives.
 similar_names = "allow" # Too many (subjectively) false positives.
+struct_field_names = "allow" # Dumb
 # Exhaustive list of pedantic clippy lints
 assigning_clones = "warn"
 bool_to_int_with_if = "warn"
@@ -168,7 +169,6 @@ stable_sort_primitive = "warn"
 str_split_at_newline = "warn"
 string_add_assign = "warn"
 struct_excessive_bools = "warn"
-struct_field_names = "warn"
 too_many_lines = "allow" # FIXME 14 triggers for this lint; probably most should be fixed
 transmute_ptr_to_ptr = "warn"
 trivially_copy_pass_by_ref = "warn"

elementsd-tests/src/taproot.rs

@@ -223,7 +223,7 @@ fn taproot_spend_test(
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![schnorr_sig.to_vec()];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec());
     } else {
         // script spend
         // try spending using leaf1
@@ -250,11 +250,9 @@ fn taproot_spend_test(
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![
-            schnorr_sig.to_vec(), // witness
-            script_ver.0.into_bytes(), // leaf script
-            ctrl_block.serialize(), // control block
-        ];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec()); // witness
+        tx.input[0].witness.script_witness.push(script_ver.0.into_bytes()); // leaf script
+        tx.input[0].witness.script_witness.push(ctrl_block.serialize()); // control block
     }
 
     let tx_hex = serialize_hex(&tx);

examples/raw_blind.rs

@@ -305,15 +305,13 @@ fn main() {
 
     // Finalize(TODO in miniscript)
     pset.inputs_mut()[0].partial_sigs.clear();
-    pset.inputs_mut()[0].final_script_witness = Some(vec![
-        inp0_sig,
-        inp0_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[0].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp0_sig);
+    wit.push(inp0_pk.to_bytes());
     pset.inputs_mut()[1].partial_sigs.clear();
-    pset.inputs_mut()[1].final_script_witness = Some(vec![
-        inp1_sig,
-        inp1_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[1].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp1_sig);
+    wit.push(inp1_pk.to_bytes());
     assert_eq!(pset, deser_pset(&tests["finalized"]));
 
     // Extracted tx

src/encode.rs

@@ -29,6 +29,27 @@ pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
 use crate::taproot::TapLeafHash;
 
+struct ByteCounter<W> {
+    inner: W,
+    count: usize,
+}
+
+impl<W> io::Write for ByteCounter<W>
+    where W: io::Write
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let res = self.inner.write(buf);
+        if let Ok(size) = res {
+            self.count += size;
+        }
+        res
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
 /// Encoding error
 #[derive(Debug)]
 pub enum Error {
@@ -63,6 +84,8 @@ pub enum Error {
     BadLockTime(crate::LockTime),
     /// `VarInt` was encoded in a non-minimal way.
     NonMinimalVarInt,
+    /// Error decoding a transaction witness.
+    Witness(crate::WitnessDecoderError),
 }
 
 impl fmt::Display for Error {
@@ -90,6 +113,7 @@ impl fmt::Display for Error {
             Error::HexVariableError(ref e) => write!(f, "Hex variable error: {}", e),
             Error::BadLockTime(ref lt) => write!(f, "Invalid locktime {}", lt),
             Error::NonMinimalVarInt => write!(f, "non-minimal varint"),
+            Self::Witness(..) => f.write_str("error decoding witness"),
         }
     }
 }
@@ -98,6 +122,7 @@ impl error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
             Error::Secp256k1zkp(ref e) => Some(e),
+            Self::Witness(ref e) => Some(e),
             _ => None,
         }
     }
@@ -240,6 +265,24 @@ impl Decodable for crate::locktime::Time {
     }
 }
 
+impl Encodable for crate::Witness {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
+        let mut counter = ByteCounter { inner: e, count: 0 };
+        crate::encoding::encode_to_writer(self, &mut counter)?;
+        Ok(counter.count)
+    }
+}
+
+impl Decodable for crate::Witness {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        match crate::encoding::decode_from_read_unbuffered(d) {
+            Ok(wit) => Ok(wit),
+            Err(crate::encoding::ReadError::Io(e)) => Err(Error::Io(e)),
+            Err(crate::encoding::ReadError::Decode(e)) => Err(Error::Witness(e)),
+        }
+    }
+}
+
 /// A variable sized integer.
 pub struct VarInt(pub u64);
 impl Encodable for VarInt {

src/lib.rs

@@ -77,6 +77,8 @@ mod endian;
 pub mod genesis;
 
 // export everything at the top level so it can be used as `elements::Transaction` etc.
+use internals::array_vec::ArrayVec;
+
 pub use crate::address::{Address, AddressError, AddressParams};
 pub use crate::blind::{
     BlindError, ConfidentialTxOutError, CtLocation, CtLocationType, RangeProofMessage,
@@ -94,5 +96,13 @@ pub use crate::script::Script;
 pub use crate::sighash::SchnorrSighashType;
 pub use crate::transaction::{
     AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PegoutData, Sequence, Transaction, TxIn,
-    TxInWitness, TxOut, TxOutWitness,
+    TxInWitness, TxOut, TxOutWitness, Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder,
 };
+
+// Encode a compact size to a slice without allocating
+pub(crate) fn compact_size_encode(value: usize) -> ArrayVec<u8, 9> {
+    use crate::encoding::Encoder as _;
+
+    let encoder = encoding::CompactSizeEncoder::new(value);
+    ArrayVec::from_slice(encoder.current_chunk())
+}

src/pset/map/input.rs

@@ -199,7 +199,7 @@ pub struct Input {
     pub final_script_sig: Option<Script>,
     /// The finalized, fully-constructed scriptWitness with signatures and any
     /// other scripts necessary for this input to pass validation.
-    pub final_script_witness: Option<Vec<Vec<u8>>>,
+    pub final_script_witness: Option<crate::Witness>,
     /// TODO: Proof of reserves commitment
     /// RIPEMD160 hash to preimage map
     pub ripemd160_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
@@ -627,7 +627,7 @@ impl Map for Input {
             }
             PSET_IN_FINAL_SCRIPTWITNESS => {
                 impl_pset_insert_pair! {
-                    self.final_script_witness <= <raw_key: _>|<raw_value: Vec<Vec<u8>>>
+                    self.final_script_witness <= <raw_key: _>|<raw_value: crate::Witness>
                 }
             }
             PSET_IN_RIPEMD160 => {

src/pset/mod.rs

@@ -306,8 +306,7 @@ impl PartiallySignedTransaction {
                         .unwrap_or(RangeProof::EMPTY),
                     script_witness: psetin
                         .final_script_witness
-                        .as_ref()
-                        .map(Vec::to_owned)
+                        .clone()
                         .unwrap_or_default(),
                     pegin_witness: psetin
                         .pegin_witness

src/pset/serialize.rs

@@ -68,7 +68,8 @@ impl_pset_de_serialize!(crate::Sequence);
 impl_pset_de_serialize!(crate::locktime::Height);
 impl_pset_de_serialize!(crate::locktime::Time);
 impl_pset_de_serialize!([u8; 32]);
-impl_pset_de_serialize!(Vec<Vec<u8>>); // scriptWitness
+impl_pset_de_serialize!(Vec<Vec<u8>>); // peginWitness
+impl_pset_de_serialize!(crate::Witness); // scriptWitness
 impl_pset_hash_de_serialize!(Txid);
 impl_pset_hash_de_serialize!(ripemd160::Hash);
 impl_pset_hash_de_serialize!(sha256::Hash);

src/sighash.rs

@@ -831,7 +831,7 @@ impl<R: DerefMut<Target = Transaction>> SighashCache<R> {
     ///     sig_hasher.witness_mut(inp).unwrap().push(Vec::new());
     /// }
     /// ```
-    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Vec<Vec<u8>>> {
+    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut crate::Witness> {
         self.tx.input.get_mut(input_index).map(|i| &mut i.witness.script_witness)
     }
 }

src/transaction/mod.rs

@@ -15,6 +15,8 @@
 //! # Transactions
 //!
 
+mod witness;
+
 use std::{io, fmt, str, cmp};
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -35,6 +37,8 @@ use secp256k1_zkp::{
     Tweak, ZERO_TWEAK,
 };
 
+pub use self::witness::{Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder};
+
 /// Description of an asset issuance in a transaction input
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct AssetIssuance {
@@ -365,7 +369,7 @@ pub struct TxInWitness {
     /// Rangeproof for inflation keys
     pub inflation_keys_rangeproof: RangeProof,
     /// Traditional script witness
-    pub script_witness: Vec<Vec<u8>>,
+    pub script_witness: Witness,
     /// Pegin witness, basically the same thing
     pub pegin_witness: Vec<Vec<u8>>,
 }
@@ -377,7 +381,7 @@ impl TxInWitness {
         TxInWitness {
             amount_rangeproof: RangeProof::EMPTY,
             inflation_keys_rangeproof: RangeProof::EMPTY,
-            script_witness: Vec::new(),
+            script_witness: Witness::new(),
             pegin_witness: Vec::new(),
         }
     }