elements/pset/
serialize.rs

1// Rust Bitcoin Library
2// Written by
3//   The Rust Bitcoin developers
4//
5// To the extent possible under law, the author(s) have dedicated all
6// copyright and related and neighboring rights to this software to
7// the public domain worldwide. This software is distributed without
8// any warranty.
9//
10// You should have received a copy of the CC0 Public Domain Dedication
11// along with this software.
12// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
13//
14
15//! # PSET Serialization
16//!
17//! Defines traits used for (de)serializing PSET values into/from raw
18//! bytes in PSET key-value pairs.
19
20use std::convert::TryFrom;
21use std::io;
22
23use crate::confidential::{self, AssetBlindingFactor};
24use crate::encode::{
25    self, deserialize, deserialize_partial, serialize, Decodable, Encodable, VarInt,
26};
27use crate::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
28use crate::hex::ToHex;
29use crate::{AssetId, BlockHash, Script, Transaction, TxOut, Txid};
30use bitcoin;
31use bitcoin::bip32::{ChildNumber, Fingerprint, KeySource};
32use bitcoin::{key::XOnlyPublicKey, PublicKey};
33use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
34
35use super::map::{PsbtSighashType, TapTree};
36use crate::schnorr;
37use crate::taproot::{ControlBlock, LeafVersion, TapLeafHash, TapNodeHash};
38
39use crate::sighash::SchnorrSighashType;
40use crate::taproot::TaprootBuilder;
41
42/// A trait for serializing a value as raw data for insertion into PSET
43/// key-value pairs.
44pub trait Serialize {
45    /// Serialize a value as raw data.
46    fn serialize(&self) -> Vec<u8>;
47}
48
49/// A trait for deserializing a value from raw data in PSET key-value pairs.
50pub trait Deserialize: Sized {
51    /// Deserialize a value from raw data.
52    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error>;
53}
54
55/// Encode an object into a hex-encoded string
56pub fn serialize_hex<T: Serialize + ?Sized>(data: &T) -> String {
57    Serialize::serialize(data)[..].to_hex()
58}
59
60impl_pset_de_serialize!(Transaction);
61impl_pset_de_serialize!(TxOut);
62impl_pset_de_serialize!(AssetId);
63impl_pset_de_serialize!(u8);
64impl_pset_de_serialize!(u32);
65impl_pset_de_serialize!(u64);
66impl_pset_de_serialize!(crate::LockTime);
67impl_pset_de_serialize!(crate::Sequence);
68impl_pset_de_serialize!(crate::locktime::Height);
69impl_pset_de_serialize!(crate::locktime::Time);
70impl_pset_de_serialize!([u8; 32]);
71impl_pset_de_serialize!(Vec<Vec<u8>>); // scriptWitness
72impl_pset_hash_de_serialize!(Txid);
73impl_pset_hash_de_serialize!(ripemd160::Hash);
74impl_pset_hash_de_serialize!(sha256::Hash);
75impl_pset_hash_de_serialize!(hash160::Hash);
76impl_pset_hash_de_serialize!(sha256d::Hash);
77impl_pset_hash_de_serialize!(BlockHash);
78impl_pset_hash_de_serialize!(TapLeafHash);
79impl_pset_hash_de_serialize!(TapNodeHash);
80
81// required for pegin bitcoin::Transactions
82impl Deserialize for bitcoin::Transaction {
83    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
84        Ok(bitcoin::consensus::encode::deserialize(bytes)?)
85    }
86}
87impl Serialize for bitcoin::Transaction {
88    fn serialize(&self) -> Vec<u8> {
89        bitcoin::consensus::encode::serialize(self)
90    }
91}
92
93// taproot
94impl_pset_de_serialize!(Vec<TapLeafHash>);
95
96impl Serialize for VarInt {
97    fn serialize(&self) -> Vec<u8> {
98        let mut v = vec![];
99        self.consensus_encode(&mut v).expect("vec don't errors");
100        v
101    }
102}
103
104impl Deserialize for VarInt {
105    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
106        VarInt::consensus_decode(bytes)
107    }
108}
109
110impl Serialize for Tweak {
111    fn serialize(&self) -> Vec<u8> {
112        encode::serialize(self.as_ref())
113    }
114}
115
116impl Deserialize for Tweak {
117    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
118        let x = deserialize::<[u8; 32]>(bytes)?;
119        Tweak::from_slice(&x).map_err(|_| encode::Error::ParseFailed("invalid Tweak"))
120    }
121}
122
123impl Serialize for AssetBlindingFactor {
124    fn serialize(&self) -> Vec<u8> {
125        encode::serialize(self.into_inner().as_ref())
126    }
127}
128
129impl Deserialize for AssetBlindingFactor {
130    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
131        let x = deserialize::<[u8; 32]>(bytes)?;
132        AssetBlindingFactor::from_slice(&x)
133            .map_err(|_| encode::Error::ParseFailed("invalid AssetBlindingFactor"))
134    }
135}
136
137impl Serialize for Script {
138    fn serialize(&self) -> Vec<u8> {
139        self.to_bytes()
140    }
141}
142
143impl Deserialize for Script {
144    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
145        Ok(Self::from(bytes.to_vec()))
146    }
147}
148
149impl Serialize for PublicKey {
150    fn serialize(&self) -> Vec<u8> {
151        let mut buf = Vec::new();
152        self.write_into(&mut buf).expect("vecs don't error");
153        buf
154    }
155}
156
157impl Deserialize for PublicKey {
158    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
159        PublicKey::from_slice(bytes).map_err(|_| encode::Error::ParseFailed("invalid public key"))
160    }
161}
162
163impl Serialize for KeySource {
164    fn serialize(&self) -> Vec<u8> {
165        let mut rv: Vec<u8> = Vec::with_capacity(key_source_len(self));
166
167        rv.append(&mut self.0.to_bytes().to_vec());
168
169        for cnum in &self.1 {
170            rv.append(&mut serialize(&u32::from(*cnum)));
171        }
172
173        rv
174    }
175}
176
177impl Deserialize for KeySource {
178    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
179        let prefix = match <[u8; 4]>::try_from(&bytes[0..4]) {
180            Ok(prefix) => prefix,
181            Err(_) => return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into()),
182        };
183
184        let fprint: Fingerprint = Fingerprint::from(prefix);
185        let mut dpath: Vec<ChildNumber> = Vec::default();
186
187        let mut d = &bytes[4..];
188        while !d.is_empty() {
189            match u32::consensus_decode(&mut d) {
190                Ok(index) => dpath.push(index.into()),
191                Err(e) => return Err(e),
192            }
193        }
194
195        Ok((fprint, dpath.into()))
196    }
197}
198
199// partial sigs
200impl Serialize for Vec<u8> {
201    fn serialize(&self) -> Vec<u8> {
202        self.clone()
203    }
204}
205
206impl Deserialize for Vec<u8> {
207    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
208        Ok(bytes.to_vec())
209    }
210}
211
212impl Serialize for PsbtSighashType {
213    fn serialize(&self) -> Vec<u8> {
214        serialize(&self.to_u32())
215    }
216}
217
218impl Deserialize for PsbtSighashType {
219    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
220        let raw: u32 = encode::deserialize(bytes)?;
221        Ok(PsbtSighashType::from_u32(raw))
222    }
223}
224
225impl Serialize for confidential::Value {
226    fn serialize(&self) -> Vec<u8> {
227        match self {
228            confidential::Value::Null => vec![], // should never be invoked
229            confidential::Value::Explicit(x) => Serialize::serialize(x),
230            confidential::Value::Confidential(_) => encode::serialize(self), // confidential can serialized as is
231        }
232    }
233}
234
235impl Deserialize for confidential::Value {
236    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
237        match bytes.len() {
238            8 => Ok(confidential::Value::Explicit(encode::deserialize(bytes)?)),
239            _ => Ok(encode::deserialize(bytes)?),
240        }
241    }
242}
243
244impl Serialize for secp256k1_zkp::PedersenCommitment {
245    fn serialize(&self) -> Vec<u8> {
246        self.serialize().to_vec()
247    }
248}
249
250impl Deserialize for secp256k1_zkp::PedersenCommitment {
251    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
252        let comm = secp256k1_zkp::PedersenCommitment::from_slice(bytes)?;
253        Ok(comm)
254    }
255}
256
257impl Serialize for secp256k1_zkp::Generator {
258    fn serialize(&self) -> Vec<u8> {
259        self.serialize().to_vec()
260    }
261}
262
263impl Deserialize for secp256k1_zkp::Generator {
264    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
265        let comm = secp256k1_zkp::Generator::from_slice(bytes)?;
266        Ok(comm)
267    }
268}
269
270impl Serialize for confidential::Asset {
271    fn serialize(&self) -> Vec<u8> {
272        match self {
273            confidential::Asset::Null => vec![], // should never be invoked
274            confidential::Asset::Explicit(x) => Serialize::serialize(x),
275            confidential::Asset::Confidential(_) => encode::serialize(self), // confidential can serialized as is
276        }
277    }
278}
279
280impl Deserialize for confidential::Asset {
281    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
282        match bytes.len() {
283            32 => Ok(confidential::Asset::Explicit(encode::deserialize(bytes)?)),
284            _ => Ok(encode::deserialize(bytes)?),
285        }
286    }
287}
288
289impl Serialize for Box<RangeProof> {
290    fn serialize(&self) -> Vec<u8> {
291        RangeProof::serialize(self)
292    }
293}
294
295impl Deserialize for Box<RangeProof> {
296    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
297        let prf = RangeProof::from_slice(bytes)
298            .map_err(|_| encode::Error::ParseFailed("Invalid Rangeproof"))?;
299        Ok(Box::new(prf))
300    }
301}
302
303impl Serialize for Box<SurjectionProof> {
304    fn serialize(&self) -> Vec<u8> {
305        SurjectionProof::serialize(self)
306    }
307}
308
309impl Deserialize for Box<SurjectionProof> {
310    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
311        let prf = SurjectionProof::from_slice(bytes)
312            .map_err(|_| encode::Error::ParseFailed("Invalid SurjectionProof"))?;
313        Ok(Box::new(prf))
314    }
315}
316
317// Taproot related ser/deser
318impl Serialize for XOnlyPublicKey {
319    fn serialize(&self) -> Vec<u8> {
320        XOnlyPublicKey::serialize(self).to_vec()
321    }
322}
323
324impl Deserialize for XOnlyPublicKey {
325    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
326        XOnlyPublicKey::from_slice(bytes)
327            .map_err(|_| encode::Error::ParseFailed("Invalid xonly public key"))
328    }
329}
330
331impl Serialize for schnorr::SchnorrSig {
332    fn serialize(&self) -> Vec<u8> {
333        self.to_vec()
334    }
335}
336
337impl Deserialize for schnorr::SchnorrSig {
338    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
339        match bytes.len() {
340            65 => {
341                let hash_ty = SchnorrSighashType::from_u8(bytes[64])
342                    .ok_or(encode::Error::ParseFailed("Invalid Sighash type"))?;
343                let sig = secp256k1_zkp::schnorr::Signature::from_slice(&bytes[..64])
344                    .map_err(|_| encode::Error::ParseFailed("Invalid Schnorr signature"))?;
345                Ok(schnorr::SchnorrSig { sig, hash_ty })
346            }
347            64 => {
348                let sig = secp256k1_zkp::schnorr::Signature::from_slice(&bytes[..64])
349                    .map_err(|_| encode::Error::ParseFailed("Invalid Schnorr signature"))?;
350                Ok(schnorr::SchnorrSig {
351                    sig,
352                    hash_ty: SchnorrSighashType::Default,
353                })
354            }
355            _ => Err(encode::Error::ParseFailed("Invalid Schnorr signature len")),
356        }
357    }
358}
359
360impl Serialize for (XOnlyPublicKey, TapLeafHash) {
361    fn serialize(&self) -> Vec<u8> {
362        let ser_pk = self.0.serialize();
363        let mut buf = Vec::with_capacity(ser_pk.len() + TapLeafHash::LEN);
364        buf.extend(&ser_pk);
365        buf.extend(&self.1.to_byte_array());
366        buf
367    }
368}
369
370impl Deserialize for (XOnlyPublicKey, TapLeafHash) {
371    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
372        if bytes.len() < 32 {
373            return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
374        }
375        let a: XOnlyPublicKey = Deserialize::deserialize(&bytes[..32])?;
376        let b: TapLeafHash = Deserialize::deserialize(&bytes[32..])?;
377        Ok((a, b))
378    }
379}
380
381impl Serialize for ControlBlock {
382    fn serialize(&self) -> Vec<u8> {
383        ControlBlock::serialize(self)
384    }
385}
386
387impl Deserialize for ControlBlock {
388    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
389        Self::from_slice(bytes).map_err(|_| encode::Error::ParseFailed("Invalid control block"))
390    }
391}
392
393// Versioned Script
394impl Serialize for (Script, LeafVersion) {
395    fn serialize(&self) -> Vec<u8> {
396        let mut buf = Vec::with_capacity(self.0.len() + 1);
397        buf.extend(self.0.as_bytes());
398        buf.push(self.1.as_u8());
399        buf
400    }
401}
402
403impl Deserialize for (Script, LeafVersion) {
404    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
405        if bytes.is_empty() {
406            return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
407        }
408        // The last byte is LeafVersion.
409        let script = Script::deserialize(&bytes[..bytes.len() - 1])?;
410        let leaf_ver = LeafVersion::from_u8(bytes[bytes.len() - 1])
411            .map_err(|_| encode::Error::ParseFailed("invalid leaf version"))?;
412        Ok((script, leaf_ver))
413    }
414}
415
416impl Serialize for (Vec<TapLeafHash>, KeySource) {
417    fn serialize(&self) -> Vec<u8> {
418        let mut buf = Vec::with_capacity(32 * self.0.len() + key_source_len(&self.1));
419        self.0
420            .consensus_encode(&mut buf)
421            .expect("Vecs don't error allocation");
422        // TODO: Add support for writing into a writer for key-source
423        buf.extend(self.1.serialize());
424        buf
425    }
426}
427
428impl Deserialize for (Vec<TapLeafHash>, KeySource) {
429    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
430        let (leafhash_vec, consumed) = deserialize_partial::<Vec<TapLeafHash>>(bytes)?;
431        let key_source = KeySource::deserialize(&bytes[consumed..])?;
432        Ok((leafhash_vec, key_source))
433    }
434}
435
436impl Serialize for TapTree {
437    fn serialize(&self) -> Vec<u8> {
438        match (self.0.branch().len(), self.0.branch().last()) {
439            (1, Some(Some(root))) => {
440                let mut buf = Vec::new();
441                for leaf_info in &root.leaves {
442                    // # Cast Safety:
443                    //
444                    // TaprootMerkleBranch can only have len atmost 128(TAPROOT_CONTROL_MAX_NODE_COUNT).
445                    // safe to cast from usize to u8
446                    buf.push(leaf_info.merkle_branch.as_inner().len() as u8);
447                    buf.push(leaf_info.ver.as_u8());
448                    leaf_info
449                        .script
450                        .consensus_encode(&mut buf)
451                        .expect("Vecs dont err");
452                }
453                buf
454            }
455            // This should be unreachable as we Taptree is already finalized
456            _ => unreachable!(),
457        }
458    }
459}
460
461impl Deserialize for TapTree {
462    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
463        let mut builder = TaprootBuilder::new();
464        let mut bytes_iter = bytes.iter();
465        while let Some(depth) = bytes_iter.next() {
466            let version = bytes_iter
467                .next()
468                .ok_or(encode::Error::ParseFailed("Invalid Taproot Builder"))?;
469            let (script, consumed) = deserialize_partial::<Script>(bytes_iter.as_slice())?;
470            if consumed > 0 {
471                bytes_iter.nth(consumed - 1);
472            }
473
474            let leaf_version = LeafVersion::from_u8(*version)
475                .map_err(|_| encode::Error::ParseFailed("Leaf Version Error"))?;
476            builder = builder
477                .add_leaf_with_ver(usize::from(*depth), script, leaf_version)
478                .map_err(|_| encode::Error::ParseFailed("Tree not in DFS order"))?;
479        }
480        if builder.is_complete() {
481            Ok(TapTree(builder))
482        } else {
483            Err(encode::Error::ParseFailed("Incomplete taproot Tree"))
484        }
485    }
486}
487
488// Helper function to compute key source len
489fn key_source_len(key_source: &KeySource) -> usize {
490    4 + 4 * (key_source.1).as_ref().len()
491}
elements/pset/serialize.rs

elements/pset/
serialize.rs
