1use super::{tag::Tag, test_helpers, varint, *};
6use bitcoin::{
7 NetworkKind, PrivateKey, PublicKey, XOnlyPublicKey,
8 bip32::{ChildNumber, DerivationPath, Fingerprint, Xpriv, Xpub},
9 hashes::{
10 Hash, hash160::Hash as Hash160, ripemd160::Hash as Ripemd160, sha256::Hash as Sha256,
11 sha256d,
12 },
13 secp256k1::{Secp256k1, SecretKey, constants::SECRET_KEY_SIZE},
14};
15use miniscript::{
16 AbsLockTime, BareCtx, Legacy, Miniscript, RelLockTime, ScriptContext, Segwitv0, Tap, Threshold,
17 descriptor::{
18 Bare, DerivPaths, Descriptor, DescriptorMultiXKey, DescriptorPublicKey,
19 DescriptorSecretKey, DescriptorXKey, KeyMap, Pkh, Sh, SinglePriv, SinglePub, SinglePubKey,
20 SortedMultiVec, TapTree, Tr, Wildcard, Wpkh, Wsh,
21 },
22 hash256::Hash as Hash256,
23 miniscript::decode::Terminal,
24};
25
26use std::error;
27use std::fmt;
28use std::sync::Arc;
29
30#[derive(Debug, PartialEq)]
32pub enum Error {
33 MissingBytes,
35 UnrecognizedTag(usize),
37 InvalidTag(usize),
39 InvalidMiniscript(usize, String),
41 InvalidVarInt(usize, String),
43 MissingDerivPaths(usize),
45 InvalidPayload(usize, String),
47 PayloadTooLarge(usize, usize),
49}
50
51impl fmt::Display for Error {
52 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
53 match self {
54 Self::MissingBytes => write!(f, "missing bytes"),
55 Self::UnrecognizedTag(idx) => write!(f, "unrecognized tag (index: {idx})"),
56 Self::InvalidTag(idx) => write!(f, "invalid tag (index: {idx})"),
57 Self::InvalidMiniscript(idx, err) => {
58 write!(f, "invalid miniscript (index: {idx}, error: {err})")
59 }
60 Self::InvalidVarInt(idx, err) => {
61 write!(f, "invalid varint (index: {idx}, error: {err})")
62 }
63 Self::MissingDerivPaths(idx) => write!(f, "missing derivation paths (index: {idx})"),
64 Self::InvalidPayload(idx, err) => {
65 write!(f, "invalid payload (payload index: {idx}, error: {err})")
66 }
67 Self::PayloadTooLarge(expected, actual) => {
68 write!(
69 f,
70 "payload too large (expected {expected} bytes, found {actual} bytes)"
71 )
72 }
73 }
74 }
75}
76
77impl error::Error for Error {}
78
79pub fn decode_template(
82 input: &[u8],
83) -> Result<(Descriptor<DescriptorPublicKey>, KeyMap, usize), Error> {
84 let mut index = 0;
85 let mut key_map = KeyMap::new();
86 let descriptor = Descriptor::from_template(input, &mut index, &[], &mut 0, &mut key_map)?;
87
88 Ok((descriptor, key_map, index))
89}
90
91pub fn decode_with_payload(
94 input: &[u8],
95 payload: &[u8],
96) -> Result<(Descriptor<DescriptorPublicKey>, KeyMap), Error> {
97 let mut payload_index = 0;
98 let mut key_map = KeyMap::new();
99 let descriptor =
100 Descriptor::from_template(input, &mut 0, payload, &mut payload_index, &mut key_map)?;
101
102 if payload_index < payload.len() {
103 return Err(Error::PayloadTooLarge(payload_index, payload.len()));
104 }
105
106 Ok((descriptor, key_map))
107}
108
109trait FromTemplate: Sized {
110 fn from_template(
111 input: &[u8],
112 index: &mut usize,
113 payload: &[u8],
114 payload_index: &mut usize,
115 key_map: &mut KeyMap,
116 ) -> Result<Self, Error>;
117}
118
119trait FromPayload: Sized {
120 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error>;
121}
122
123trait FromCompressablePayload: Sized {
124 fn from_payload(
125 compressed: bool,
126 payload: &[u8],
127 payload_index: &mut usize,
128 ) -> Result<Self, Error>;
129}
130
131impl FromTemplate for Descriptor<DescriptorPublicKey> {
132 fn from_template(
133 input: &[u8],
134 index: &mut usize,
135 payload: &[u8],
136 payload_index: &mut usize,
137 key_map: &mut KeyMap,
138 ) -> Result<Self, Error> {
139 if *index >= input.len() {
140 return Err(Error::MissingBytes);
141 }
142
143 let current_index = *index;
144 let descriptor = match Tag::from(input[current_index]) {
145 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index)),
146 Tag::Sh => Descriptor::Sh(Sh::<DescriptorPublicKey>::from_template(
147 input,
148 index,
149 payload,
150 payload_index,
151 key_map,
152 )?),
153 Tag::Wsh => Descriptor::Wsh(Wsh::<DescriptorPublicKey>::from_template(
154 input,
155 index,
156 payload,
157 payload_index,
158 key_map,
159 )?),
160 Tag::Tr => Descriptor::Tr(Tr::<DescriptorPublicKey>::from_template(
161 input,
162 index,
163 payload,
164 payload_index,
165 key_map,
166 )?),
167 Tag::Wpkh => Descriptor::Wpkh(Wpkh::<DescriptorPublicKey>::from_template(
168 input,
169 index,
170 payload,
171 payload_index,
172 key_map,
173 )?),
174 Tag::Pkh => Descriptor::Pkh(Pkh::<DescriptorPublicKey>::from_template(
175 input,
176 index,
177 payload,
178 payload_index,
179 key_map,
180 )?),
181 Tag::Bare => Descriptor::Bare(Bare::<DescriptorPublicKey>::from_template(
182 input,
183 index,
184 payload,
185 payload_index,
186 key_map,
187 )?),
188 _ => return Err(Error::InvalidTag(current_index)),
189 };
190
191 Ok(descriptor)
192 }
193}
194
195impl FromTemplate for Sh<DescriptorPublicKey> {
196 fn from_template(
197 input: &[u8],
198 index: &mut usize,
199 payload: &[u8],
200 payload_index: &mut usize,
201 key_map: &mut KeyMap,
202 ) -> Result<Self, Error> {
203 let current_index = *index;
204 *index += 1;
205
206 if current_index + 1 >= input.len() {
207 return Err(Error::MissingBytes);
208 }
209
210 let sh = match Tag::from(input[current_index + 1]) {
211 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index + 1)),
212 Tag::SortedMulti => {
213 let sorted_multi = SortedMultiVec::<DescriptorPublicKey, Legacy>::from_template(
214 input,
215 index,
216 payload,
217 payload_index,
218 key_map,
219 )?;
220 Sh::new_sortedmulti(sorted_multi.k(), sorted_multi.pks().to_vec())
221 }
222 Tag::Wsh => Ok(Sh::new_with_wsh(Wsh::<DescriptorPublicKey>::from_template(
223 input,
224 index,
225 payload,
226 payload_index,
227 key_map,
228 )?)),
229 Tag::Wpkh => Ok(Sh::new_with_wpkh(
230 Wpkh::<DescriptorPublicKey>::from_template(
231 input,
232 index,
233 payload,
234 payload_index,
235 key_map,
236 )?,
237 )),
238 _ => Sh::new(Miniscript::<DescriptorPublicKey, Legacy>::from_template(
239 input,
240 index,
241 payload,
242 payload_index,
243 key_map,
244 )?),
245 };
246
247 match sh {
248 Ok(sh) => Ok(sh),
249 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
250 }
251 }
252}
253
254impl FromTemplate for Wsh<DescriptorPublicKey> {
255 fn from_template(
256 input: &[u8],
257 index: &mut usize,
258 payload: &[u8],
259 payload_index: &mut usize,
260 key_map: &mut KeyMap,
261 ) -> Result<Self, Error> {
262 let current_index = *index;
263 *index += 1;
264
265 if current_index + 1 >= input.len() {
266 return Err(Error::MissingBytes);
267 }
268
269 let wsh = match Tag::from(input[current_index + 1]) {
270 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index + 1)),
271 Tag::SortedMulti => {
272 let sorted_multi = SortedMultiVec::<DescriptorPublicKey, Segwitv0>::from_template(
273 input,
274 index,
275 payload,
276 payload_index,
277 key_map,
278 )?;
279 Wsh::new_sortedmulti(sorted_multi.k(), sorted_multi.pks().to_vec())
280 }
281 _ => Wsh::new(Miniscript::<DescriptorPublicKey, Segwitv0>::from_template(
282 input,
283 index,
284 payload,
285 payload_index,
286 key_map,
287 )?),
288 };
289
290 match wsh {
291 Ok(wsh) => Ok(wsh),
292 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
293 }
294 }
295}
296
297impl FromTemplate for Tr<DescriptorPublicKey> {
298 fn from_template(
299 input: &[u8],
300 index: &mut usize,
301 payload: &[u8],
302 payload_index: &mut usize,
303 key_map: &mut KeyMap,
304 ) -> Result<Self, Error> {
305 let current_index = *index;
306 *index += 1;
307
308 if current_index + 1 >= input.len() {
309 return Err(Error::MissingBytes);
310 }
311
312 let internal_key =
313 DescriptorPublicKey::from_template(input, index, payload, payload_index, key_map)?;
314
315 let tree = if *index < input.len() && Tag::from(input[*index]) == Tag::TapTree {
316 Some(TapTree::<DescriptorPublicKey>::from_template(
317 input,
318 index,
319 payload,
320 payload_index,
321 key_map,
322 )?)
323 } else {
324 None
325 };
326
327 match Tr::new(internal_key, tree) {
328 Ok(tr) => Ok(tr),
329 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
330 }
331 }
332}
333
334impl FromTemplate for Wpkh<DescriptorPublicKey> {
335 fn from_template(
336 input: &[u8],
337 index: &mut usize,
338 payload: &[u8],
339 payload_index: &mut usize,
340 key_map: &mut KeyMap,
341 ) -> Result<Self, Error> {
342 let current_index = *index;
343 *index += 1;
344
345 match Wpkh::new(DescriptorPublicKey::from_template(
346 input,
347 index,
348 payload,
349 payload_index,
350 key_map,
351 )?) {
352 Ok(wpkh) => Ok(wpkh),
353 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
354 }
355 }
356}
357
358impl FromTemplate for Pkh<DescriptorPublicKey> {
359 fn from_template(
360 input: &[u8],
361 index: &mut usize,
362 payload: &[u8],
363 payload_index: &mut usize,
364 key_map: &mut KeyMap,
365 ) -> Result<Self, Error> {
366 let current_index = *index;
367 *index += 1;
368
369 match Pkh::new(DescriptorPublicKey::from_template(
370 input,
371 index,
372 payload,
373 payload_index,
374 key_map,
375 )?) {
376 Ok(pkh) => Ok(pkh),
377 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
378 }
379 }
380}
381
382impl FromTemplate for Bare<DescriptorPublicKey> {
383 fn from_template(
384 input: &[u8],
385 index: &mut usize,
386 payload: &[u8],
387 payload_index: &mut usize,
388 key_map: &mut KeyMap,
389 ) -> Result<Self, Error> {
390 let current_index = *index;
391 *index += 1;
392
393 let ms = Miniscript::<DescriptorPublicKey, BareCtx>::from_template(
394 input,
395 index,
396 payload,
397 payload_index,
398 key_map,
399 )?;
400 let bare = Bare::new(ms);
401 match bare {
402 Ok(bare) => Ok(bare),
403 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
404 }
405 }
406}
407
408impl FromTemplate for TapTree<DescriptorPublicKey> {
409 fn from_template(
410 input: &[u8],
411 index: &mut usize,
412 payload: &[u8],
413 payload_index: &mut usize,
414 key_map: &mut KeyMap,
415 ) -> Result<Self, Error> {
416 let current_index = *index;
417 *index += 1;
418
419 if current_index + 1 >= input.len() {
420 return Err(Error::MissingBytes);
421 }
422
423 if Tag::from(input[current_index + 1]) == Tag::TapTree {
424 let left = TapTree::<DescriptorPublicKey>::from_template(
426 input,
427 index,
428 payload,
429 payload_index,
430 key_map,
431 )?;
432
433 if *index < input.len() && Tag::from(input[*index]) == Tag::TapTree {
434 let right = TapTree::<DescriptorPublicKey>::from_template(
435 input,
436 index,
437 payload,
438 payload_index,
439 key_map,
440 )?;
441
442 Ok(Self::combine(left, right))
443 } else {
444 Err(Error::MissingBytes)
445 }
446 } else {
447 let ms = Miniscript::<DescriptorPublicKey, Tap>::from_template(
449 input,
450 index,
451 payload,
452 payload_index,
453 key_map,
454 )?;
455
456 Ok(TapTree::Leaf(Arc::new(ms)))
457 }
458 }
459}
460
461impl<Ctx: ScriptContext> FromTemplate for SortedMultiVec<DescriptorPublicKey, Ctx> {
462 fn from_template(
463 input: &[u8],
464 index: &mut usize,
465 payload: &[u8],
466 payload_index: &mut usize,
467 key_map: &mut KeyMap,
468 ) -> Result<Self, Error> {
469 let current_index = *index;
470 *index += 1;
471
472 if current_index + 1 >= input.len() {
473 return Err(Error::MissingBytes);
474 }
475
476 let (k, size_k) = varint::decode(&input[(current_index + 1)..])
477 .map_err(|e| Error::InvalidVarInt(current_index + 1, e.to_string()))?;
478 let (n, size_n) = varint::decode(&input[(current_index + 1 + size_k)..])
479 .map_err(|e| Error::InvalidVarInt(current_index + 1 + size_k, e.to_string()))?;
480
481 if k > usize::MAX as u128 {
482 return Err(Error::InvalidVarInt(current_index + 1, "overflow".into()));
483 }
484
485 *index += size_k + size_n;
486
487 let mut pks = Vec::new();
488 for _ in 0..n {
489 let pk =
490 DescriptorPublicKey::from_template(input, index, payload, payload_index, key_map)?;
491 pks.push(pk);
492 }
493
494 match SortedMultiVec::<DescriptorPublicKey, Ctx>::new(k as usize, pks) {
495 Ok(sorted_multi) => Ok(sorted_multi),
496 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
497 }
498 }
499}
500
501impl<Ctx: ScriptContext> FromTemplate for Miniscript<DescriptorPublicKey, Ctx> {
502 fn from_template(
503 input: &[u8],
504 index: &mut usize,
505 payload: &[u8],
506 payload_index: &mut usize,
507 key_map: &mut KeyMap,
508 ) -> Result<Self, Error> {
509 let current_index = *index;
510 let ast = Terminal::<DescriptorPublicKey, Ctx>::from_template(
511 input,
512 index,
513 payload,
514 payload_index,
515 key_map,
516 )?;
517 match Self::from_ast(ast) {
518 Ok(ms) => Ok(ms),
519 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
520 }
521 }
522}
523
524impl<Ctx: ScriptContext> FromTemplate for Terminal<DescriptorPublicKey, Ctx> {
525 fn from_template(
526 input: &[u8],
527 index: &mut usize,
528 payload: &[u8],
529 payload_index: &mut usize,
530 key_map: &mut KeyMap,
531 ) -> Result<Self, Error> {
532 if *index >= input.len() {
533 return Err(Error::MissingBytes);
534 }
535
536 let current_index = *index;
537 *index += 1;
538
539 let terminal = match Tag::from(input[current_index]) {
540 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index)),
541 Tag::True => Self::True,
542 Tag::False => Self::False,
543 Tag::PkK => Self::PkK(DescriptorPublicKey::from_template(
544 input,
545 index,
546 payload,
547 payload_index,
548 key_map,
549 )?),
550 Tag::PkH => Self::PkH(DescriptorPublicKey::from_template(
551 input,
552 index,
553 payload,
554 payload_index,
555 key_map,
556 )?),
557 Tag::RawPkH => Self::RawPkH(Hash160::from_payload(payload, payload_index)?),
558 Tag::After => Self::After(AbsLockTime::from_payload(payload, payload_index)?),
559 Tag::Older => Self::Older(RelLockTime::from_payload(payload, payload_index)?),
560 Tag::Sha256 => Self::Sha256(Sha256::from_payload(payload, payload_index)?),
561 Tag::Hash256 => Self::Hash256(Hash256::from_payload(payload, payload_index)?),
562 Tag::Ripemd160 => Self::Ripemd160(Ripemd160::from_payload(payload, payload_index)?),
563 Tag::Hash160 => Self::Hash160(Hash160::from_payload(payload, payload_index)?),
564 Tag::Alt => Self::Alt(
565 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
566 input,
567 index,
568 payload,
569 payload_index,
570 key_map,
571 )?
572 .into(),
573 ),
574 Tag::Swap => Self::Swap(
575 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
576 input,
577 index,
578 payload,
579 payload_index,
580 key_map,
581 )?
582 .into(),
583 ),
584 Tag::Check => Self::Check(
585 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
586 input,
587 index,
588 payload,
589 payload_index,
590 key_map,
591 )?
592 .into(),
593 ),
594 Tag::DupIf => Self::DupIf(
595 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
596 input,
597 index,
598 payload,
599 payload_index,
600 key_map,
601 )?
602 .into(),
603 ),
604 Tag::Verify => Self::Verify(
605 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
606 input,
607 index,
608 payload,
609 payload_index,
610 key_map,
611 )?
612 .into(),
613 ),
614 Tag::NonZero => Self::NonZero(
615 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
616 input,
617 index,
618 payload,
619 payload_index,
620 key_map,
621 )?
622 .into(),
623 ),
624 Tag::ZeroNotEqual => Self::ZeroNotEqual(
625 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
626 input,
627 index,
628 payload,
629 payload_index,
630 key_map,
631 )?
632 .into(),
633 ),
634 Tag::AndV => Self::AndV(
635 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
636 input,
637 index,
638 payload,
639 payload_index,
640 key_map,
641 )?
642 .into(),
643 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
644 input,
645 index,
646 payload,
647 payload_index,
648 key_map,
649 )?
650 .into(),
651 ),
652 Tag::AndB => Self::AndB(
653 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
654 input,
655 index,
656 payload,
657 payload_index,
658 key_map,
659 )?
660 .into(),
661 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
662 input,
663 index,
664 payload,
665 payload_index,
666 key_map,
667 )?
668 .into(),
669 ),
670 Tag::AndOr => Self::AndOr(
671 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
672 input,
673 index,
674 payload,
675 payload_index,
676 key_map,
677 )?
678 .into(),
679 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
680 input,
681 index,
682 payload,
683 payload_index,
684 key_map,
685 )?
686 .into(),
687 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
688 input,
689 index,
690 payload,
691 payload_index,
692 key_map,
693 )?
694 .into(),
695 ),
696 Tag::OrB => Self::OrB(
697 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
698 input,
699 index,
700 payload,
701 payload_index,
702 key_map,
703 )?
704 .into(),
705 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
706 input,
707 index,
708 payload,
709 payload_index,
710 key_map,
711 )?
712 .into(),
713 ),
714 Tag::OrC => Self::OrC(
715 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
716 input,
717 index,
718 payload,
719 payload_index,
720 key_map,
721 )?
722 .into(),
723 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
724 input,
725 index,
726 payload,
727 payload_index,
728 key_map,
729 )?
730 .into(),
731 ),
732 Tag::OrD => Self::OrD(
733 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
734 input,
735 index,
736 payload,
737 payload_index,
738 key_map,
739 )?
740 .into(),
741 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
742 input,
743 index,
744 payload,
745 payload_index,
746 key_map,
747 )?
748 .into(),
749 ),
750 Tag::OrI => Self::OrI(
751 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
752 input,
753 index,
754 payload,
755 payload_index,
756 key_map,
757 )?
758 .into(),
759 Miniscript::<DescriptorPublicKey, Ctx>::from_template(
760 input,
761 index,
762 payload,
763 payload_index,
764 key_map,
765 )?
766 .into(),
767 ),
768 Tag::Thresh => Self::Thresh(
769 Threshold::<Arc<Miniscript<DescriptorPublicKey, Ctx>>, 0>::from_template(
770 input,
771 index,
772 payload,
773 payload_index,
774 key_map,
775 )?,
776 ),
777 Tag::Multi => Self::Multi(Threshold::<DescriptorPublicKey, 20>::from_template(
778 input,
779 index,
780 payload,
781 payload_index,
782 key_map,
783 )?),
784 Tag::MultiA => Self::MultiA(Threshold::<DescriptorPublicKey, 125000>::from_template(
785 input,
786 index,
787 payload,
788 payload_index,
789 key_map,
790 )?),
791 _ => return Err(Error::InvalidTag(current_index)),
792 };
793
794 Ok(terminal)
795 }
796}
797
798impl<T: FromTemplate> FromTemplate for Arc<T> {
799 fn from_template(
800 input: &[u8],
801 index: &mut usize,
802 payload: &[u8],
803 payload_index: &mut usize,
804 key_map: &mut KeyMap,
805 ) -> Result<Self, Error> {
806 Ok(Arc::new(T::from_template(
807 input,
808 index,
809 payload,
810 payload_index,
811 key_map,
812 )?))
813 }
814}
815
816impl<T: FromTemplate, const MAX: usize> FromTemplate for Threshold<T, MAX> {
817 fn from_template(
818 input: &[u8],
819 index: &mut usize,
820 payload: &[u8],
821 payload_index: &mut usize,
822 key_map: &mut KeyMap,
823 ) -> Result<Self, Error> {
824 if *index >= input.len() {
825 return Err(Error::MissingBytes);
826 }
827
828 let current_index = *index;
829 let (k, size_k) = varint::decode(&input[*index..])
830 .map_err(|e| Error::InvalidVarInt(*index, e.to_string()))?;
831 let (n, size_n) = varint::decode(&input[(*index + size_k)..])
832 .map_err(|e| Error::InvalidVarInt(*index + size_k, e.to_string()))?;
833
834 if k > usize::MAX as u128 {
835 return Err(Error::InvalidVarInt(*index, "overflow".into()));
836 }
837
838 *index += size_k + size_n;
839
840 let mut ts = Vec::new();
841 for _ in 0..n {
842 let t = T::from_template(input, index, payload, payload_index, key_map)?;
843 ts.push(t);
844 }
845
846 match Threshold::<T, MAX>::new(k as usize, ts) {
847 Ok(thresh) => Ok(thresh),
848 Err(err) => Err(Error::InvalidMiniscript(current_index, err.to_string())),
849 }
850 }
851}
852
853impl FromTemplate for DescriptorPublicKey {
854 fn from_template(
855 input: &[u8],
856 index: &mut usize,
857 payload: &[u8],
858 payload_index: &mut usize,
859 key_map: &mut KeyMap,
860 ) -> Result<Self, Error> {
861 if *index + 1 >= input.len() {
862 return Err(Error::MissingBytes);
863 }
864
865 let tag = Tag::from(input[*index]);
867 match tag {
868 Tag::XPriv
869 | Tag::MultiXPriv
870 | Tag::CompressedSinglePriv
871 | Tag::UncompressedSinglePriv => {
872 let secret_key = DescriptorSecretKey::from_template(
873 input,
874 index,
875 payload,
876 payload_index,
877 key_map,
878 )?;
879
880 let secp = Secp256k1::new();
882 let public_key = secret_key.to_public(&secp).unwrap_or(
883 test_helpers::create_dpk_single_compressed_no_origin(1 + key_map.len() as u32),
886 );
887
888 key_map.insert(public_key.clone(), secret_key);
890
891 return Ok(public_key);
892 }
893 _ => {}
894 }
895
896 let current_index = *index;
897 *index += 2;
898
899 let origin = match Tag::from(input[current_index + 1]) {
900 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index + 1)),
901 Tag::Origin => {
902 let fingerprint_dummy = Fingerprint::from_payload(payload, payload_index)?;
903 let derivation_path =
904 DerivationPath::from_template(input, index, payload, payload_index, key_map)?;
905
906 Some((fingerprint_dummy, derivation_path))
907 }
908 Tag::NoOrigin => None,
909 _ => return Err(Error::InvalidTag(current_index + 1)),
910 };
911
912 let template = match Tag::from(input[current_index]) {
913 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index)),
914 Tag::UncompressedFullKey => DescriptorPublicKey::Single(SinglePub {
915 key: SinglePubKey::FullKey(PublicKey::from_payload(false, payload, payload_index)?),
916 origin,
917 }),
918 Tag::CompressedFullKey => DescriptorPublicKey::Single(SinglePub {
919 key: SinglePubKey::FullKey(PublicKey::from_payload(true, payload, payload_index)?),
920 origin,
921 }),
922 Tag::XOnly => DescriptorPublicKey::Single(SinglePub {
923 key: SinglePubKey::XOnly(XOnlyPublicKey::from_payload(payload, payload_index)?),
924 origin,
925 }),
926 Tag::XPub => DescriptorPublicKey::XPub(DescriptorXKey {
927 origin,
928 xkey: Xpub::from_payload(payload, payload_index)?,
929 derivation_path: DerivationPath::from_template(
930 input,
931 index,
932 payload,
933 payload_index,
934 key_map,
935 )?,
936 wildcard: Wildcard::from_template(input, index, payload, payload_index, key_map)?,
937 }),
938 Tag::MultiXPub => DescriptorPublicKey::MultiXPub(DescriptorMultiXKey {
939 origin,
940 xkey: Xpub::from_payload(payload, payload_index)?,
941 derivation_paths: DerivPaths::from_template(
942 input,
943 index,
944 payload,
945 payload_index,
946 key_map,
947 )?,
948 wildcard: Wildcard::from_template(input, index, payload, payload_index, key_map)?,
949 }),
950 _ => return Err(Error::InvalidTag(current_index)),
951 };
952
953 Ok(template)
954 }
955}
956
957impl FromTemplate for DescriptorSecretKey {
958 fn from_template(
959 input: &[u8],
960 index: &mut usize,
961 payload: &[u8],
962 payload_index: &mut usize,
963 key_map: &mut KeyMap,
964 ) -> Result<Self, Error> {
965 if *index + 1 >= input.len() {
966 return Err(Error::MissingBytes);
967 }
968
969 let current_index = *index;
970 *index += 2;
971
972 let origin = match Tag::from(input[current_index + 1]) {
973 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index + 1)),
974 Tag::Origin => {
975 let fingerprint = Fingerprint::from_payload(payload, payload_index)?;
976 let derivation_path =
977 DerivationPath::from_template(input, index, payload, payload_index, key_map)?;
978
979 Some((fingerprint, derivation_path))
980 }
981 Tag::NoOrigin => None,
982 _ => return Err(Error::InvalidTag(current_index + 1)),
983 };
984
985 let secret_key = match Tag::from(input[current_index]) {
986 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index)),
987 Tag::CompressedSinglePriv => DescriptorSecretKey::Single(SinglePriv {
988 key: PrivateKey::from_payload(true, payload, payload_index)?,
989 origin,
990 }),
991 Tag::UncompressedSinglePriv => DescriptorSecretKey::Single(SinglePriv {
992 key: PrivateKey::from_payload(false, payload, payload_index)?,
993 origin,
994 }),
995 Tag::XPriv => DescriptorSecretKey::XPrv(DescriptorXKey {
996 origin,
997 xkey: Xpriv::from_payload(payload, payload_index)?,
998 derivation_path: DerivationPath::from_template(
999 input,
1000 index,
1001 payload,
1002 payload_index,
1003 key_map,
1004 )?,
1005 wildcard: Wildcard::from_template(input, index, payload, payload_index, key_map)?,
1006 }),
1007 Tag::MultiXPriv => DescriptorSecretKey::MultiXPrv(DescriptorMultiXKey {
1008 origin,
1009 xkey: Xpriv::from_payload(payload, payload_index)?,
1010 derivation_paths: DerivPaths::from_template(
1011 input,
1012 index,
1013 payload,
1014 payload_index,
1015 key_map,
1016 )?,
1017 wildcard: Wildcard::from_template(input, index, payload, payload_index, key_map)?,
1018 }),
1019 _ => return Err(Error::InvalidTag(current_index)),
1020 };
1021
1022 Ok(secret_key)
1023 }
1024}
1025
1026impl FromCompressablePayload for PrivateKey {
1027 fn from_payload(
1028 compressed: bool,
1029 payload: &[u8],
1030 payload_index: &mut usize,
1031 ) -> Result<Self, Error> {
1032 if payload.is_empty() {
1033 if compressed {
1034 return Ok(PrivateKey::new(dummy::sk(), NetworkKind::Main));
1035 } else {
1036 return Ok(PrivateKey::new_uncompressed(dummy::sk(), NetworkKind::Main));
1037 };
1038 }
1039
1040 let current_index = *payload_index;
1041 *payload_index += SECRET_KEY_SIZE;
1042
1043 if *payload_index > payload.len() {
1044 return Err(Error::MissingBytes);
1045 }
1046
1047 let sk = SecretKey::from_slice(&payload[current_index..current_index + SECRET_KEY_SIZE])
1048 .map_err(|e| Error::InvalidPayload(current_index, e.to_string()))?;
1049
1050 if compressed {
1051 Ok(PrivateKey::new(sk, NetworkKind::Main))
1052 } else {
1053 Ok(PrivateKey::new_uncompressed(sk, NetworkKind::Main))
1054 }
1055 }
1056}
1057
1058impl FromPayload for Xpriv {
1059 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1060 if payload.is_empty() {
1061 return Ok(dummy::xpriv());
1062 }
1063
1064 let current_index = *payload_index;
1065 *payload_index += 78;
1066
1067 if *payload_index > payload.len() {
1068 return Err(Error::MissingBytes);
1069 }
1070
1071 match Self::decode(&payload[current_index..current_index + 78]) {
1072 Ok(xpriv) => Ok(xpriv),
1073 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1074 }
1075 }
1076}
1077
1078impl FromPayload for Fingerprint {
1079 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1080 if payload.is_empty() {
1081 return Ok(dummy::fp());
1082 }
1083
1084 let current_index = *payload_index;
1085 *payload_index += 4;
1086
1087 if *payload_index > payload.len() {
1088 return Err(Error::MissingBytes);
1089 }
1090
1091 let mut data = [0u8; 4];
1092 data.copy_from_slice(&payload[current_index..current_index + 4]);
1093
1094 Ok(Fingerprint::from(data))
1095 }
1096}
1097
1098impl FromCompressablePayload for PublicKey {
1099 fn from_payload(
1100 compressed: bool,
1101 payload: &[u8],
1102 payload_index: &mut usize,
1103 ) -> Result<Self, Error> {
1104 if payload.is_empty() {
1105 return Ok(PublicKey {
1106 inner: dummy::pk(),
1107 compressed,
1108 });
1109 }
1110
1111 let size = if compressed { 33 } else { 65 };
1112
1113 let current_index = *payload_index;
1114 *payload_index += size;
1115
1116 if *payload_index > payload.len() {
1117 return Err(Error::MissingBytes);
1118 }
1119
1120 match Self::from_slice(&payload[current_index..current_index + size]) {
1121 Ok(pk) => Ok(pk),
1122 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1123 }
1124 }
1125}
1126
1127impl FromPayload for XOnlyPublicKey {
1128 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1129 if payload.is_empty() {
1130 return Ok(XOnlyPublicKey::from(dummy::pk()));
1131 }
1132
1133 let current_index = *payload_index;
1134 *payload_index += 32;
1135
1136 if *payload_index > payload.len() {
1137 return Err(Error::MissingBytes);
1138 }
1139
1140 match Self::from_slice(&payload[current_index..current_index + 32]) {
1141 Ok(x_only) => Ok(x_only),
1142 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1143 }
1144 }
1145}
1146
1147impl FromPayload for Xpub {
1148 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1149 if payload.is_empty() {
1150 return Ok(dummy::xpub());
1151 }
1152
1153 let current_index = *payload_index;
1154 *payload_index += 78;
1155
1156 if *payload_index > payload.len() {
1157 return Err(Error::MissingBytes);
1158 }
1159
1160 match Self::decode(&payload[current_index..current_index + 78]) {
1161 Ok(xpub) => Ok(xpub),
1162 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1163 }
1164 }
1165}
1166
1167impl FromTemplate for DerivationPath {
1168 fn from_template(
1169 input: &[u8],
1170 index: &mut usize,
1171 payload: &[u8],
1172 payload_index: &mut usize,
1173 key_map: &mut KeyMap,
1174 ) -> Result<Self, Error> {
1175 if *index >= input.len() {
1176 return Err(Error::MissingBytes);
1177 }
1178
1179 let (len, size) = varint::decode(&input[*index..])
1180 .map_err(|e| Error::InvalidVarInt(*index, e.to_string()))?;
1181
1182 *index += size;
1183
1184 let mut numbers = Vec::new();
1185 for _ in 0..len {
1186 numbers.push(ChildNumber::from_template(
1187 input,
1188 index,
1189 payload,
1190 payload_index,
1191 key_map,
1192 )?);
1193 }
1194
1195 Ok(DerivationPath::from(numbers))
1196 }
1197}
1198
1199impl FromTemplate for ChildNumber {
1200 fn from_template(
1201 input: &[u8],
1202 index: &mut usize,
1203 _payload: &[u8],
1204 _payload_index: &mut usize,
1205 _key_map: &mut KeyMap,
1206 ) -> Result<Self, Error> {
1207 if *index >= input.len() {
1208 return Err(Error::MissingBytes);
1209 }
1210
1211 let (value, size) = varint::decode(&input[*index..])
1212 .map_err(|e| Error::InvalidVarInt(*index, e.to_string()))?;
1213
1214 *index += size;
1215
1216 if value >> 1 > u32::MAX.into() {
1217 return Err(Error::InvalidVarInt(*index, "overflow".into()));
1218 }
1219
1220 let child_index = (value >> 1) as u32;
1221 let number = if value & 1 == 1 {
1222 ChildNumber::Hardened { index: child_index }
1223 } else {
1224 ChildNumber::Normal { index: child_index }
1225 };
1226
1227 Ok(number)
1228 }
1229}
1230
1231impl FromTemplate for DerivPaths {
1232 fn from_template(
1233 input: &[u8],
1234 index: &mut usize,
1235 payload: &[u8],
1236 payload_index: &mut usize,
1237 key_map: &mut KeyMap,
1238 ) -> Result<Self, Error> {
1239 if *index >= input.len() {
1240 return Err(Error::MissingBytes);
1241 }
1242
1243 let (len, size) = varint::decode(&input[*index..])
1244 .map_err(|e| Error::InvalidVarInt(*index, e.to_string()))?;
1245
1246 let current_index = *index;
1247 *index += size;
1248
1249 let mut paths = Vec::new();
1250 for _ in 0..len {
1251 paths.push(DerivationPath::from_template(
1252 input,
1253 index,
1254 payload,
1255 payload_index,
1256 key_map,
1257 )?);
1258 }
1259
1260 if let Some(deriv_paths) = DerivPaths::new(paths) {
1261 Ok(deriv_paths)
1262 } else {
1263 Err(Error::MissingDerivPaths(current_index))
1264 }
1265 }
1266}
1267
1268impl FromTemplate for Wildcard {
1269 fn from_template(
1270 input: &[u8],
1271 index: &mut usize,
1272 _payload: &[u8],
1273 _payload_index: &mut usize,
1274 _key_map: &mut KeyMap,
1275 ) -> Result<Self, Error> {
1276 if *index >= input.len() {
1277 return Err(Error::MissingBytes);
1278 }
1279
1280 let current_index = *index;
1281 *index += 1;
1282
1283 let wildcard = match Tag::from(input[current_index]) {
1284 Tag::Unrecognized => return Err(Error::UnrecognizedTag(current_index)),
1285 Tag::NoWildcard => Wildcard::None,
1286 Tag::UnhardenedWildcard => Wildcard::Unhardened,
1287 Tag::HardenedWildcard => Wildcard::Hardened,
1288 _ => return Err(Error::InvalidTag(current_index)),
1289 };
1290
1291 Ok(wildcard)
1292 }
1293}
1294
1295impl FromPayload for AbsLockTime {
1296 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1297 if payload.is_empty() {
1298 return Ok(dummy::after());
1299 }
1300
1301 if *payload_index >= payload.len() {
1302 return Err(Error::MissingBytes);
1303 }
1304
1305 let current_index = *payload_index;
1306 let (after, size) = varint::decode(&payload[current_index..])
1307 .map_err(|e| Error::InvalidPayload(current_index, e.to_string()))?;
1308
1309 *payload_index += size;
1310
1311 if after > u32::MAX.into() {
1312 return Err(Error::InvalidPayload(current_index, "overflow".into()));
1313 }
1314
1315 match Self::from_consensus(after as u32) {
1316 Ok(after) => Ok(after),
1317 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1318 }
1319 }
1320}
1321
1322impl FromPayload for RelLockTime {
1323 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1324 if payload.is_empty() {
1325 return Ok(dummy::older());
1326 }
1327
1328 if *payload_index >= payload.len() {
1329 return Err(Error::MissingBytes);
1330 }
1331
1332 let current_index = *payload_index;
1333 let (older, size) = varint::decode(&payload[current_index..])
1334 .map_err(|e| Error::InvalidPayload(current_index, e.to_string()))?;
1335
1336 *payload_index += size;
1337
1338 if older > u32::MAX.into() {
1339 return Err(Error::InvalidPayload(current_index, "overflow".into()));
1340 }
1341
1342 match Self::from_consensus(older as u32) {
1343 Ok(older) => Ok(older),
1344 Err(err) => Err(Error::InvalidPayload(current_index, err.to_string())),
1345 }
1346 }
1347}
1348
1349impl FromPayload for Hash160 {
1350 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1351 if payload.is_empty() {
1352 return Ok(dummy::hash160());
1353 }
1354
1355 let current_index = *payload_index;
1356 *payload_index += 20;
1357
1358 if *payload_index > payload.len() {
1359 return Err(Error::MissingBytes);
1360 }
1361
1362 let mut bytes = [0u8; 20];
1363 bytes.copy_from_slice(&payload[current_index..current_index + 20]);
1364
1365 Ok(Self::from_byte_array(bytes))
1366 }
1367}
1368
1369impl FromPayload for Ripemd160 {
1370 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1371 if payload.is_empty() {
1372 return Ok(dummy::ripemd160());
1373 }
1374
1375 let current_index = *payload_index;
1376 *payload_index += 20;
1377
1378 if *payload_index > payload.len() {
1379 return Err(Error::MissingBytes);
1380 }
1381
1382 let mut bytes = [0u8; 20];
1383 bytes.copy_from_slice(&payload[current_index..current_index + 20]);
1384
1385 Ok(Self::from_byte_array(bytes))
1386 }
1387}
1388
1389impl FromPayload for Sha256 {
1390 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1391 if payload.is_empty() {
1392 return Ok(dummy::sha256());
1393 }
1394
1395 let current_index = *payload_index;
1396 *payload_index += 32;
1397
1398 if *payload_index > payload.len() {
1399 return Err(Error::MissingBytes);
1400 }
1401
1402 let mut bytes = [0u8; 32];
1403 bytes.copy_from_slice(&payload[current_index..current_index + 32]);
1404
1405 Ok(Self::from_byte_array(bytes))
1406 }
1407}
1408
1409impl FromPayload for Hash256 {
1410 fn from_payload(payload: &[u8], payload_index: &mut usize) -> Result<Self, Error> {
1411 if payload.is_empty() {
1412 return Ok(dummy::hash256());
1413 }
1414
1415 let current_index = *payload_index;
1416 *payload_index += 32;
1417
1418 if *payload_index > payload.len() {
1419 return Err(Error::MissingBytes);
1420 }
1421
1422 let mut bytes = [0u8; 32];
1423 bytes.copy_from_slice(&payload[current_index..current_index + 32]);
1424
1425 Ok(Self::from_raw_hash(sha256d::Hash::from_byte_array(bytes)))
1426 }
1427}
1428
1429#[cfg(test)]
1430mod tests {
1431 use super::*;
1432 use crate::{dummy, test_helpers::*};
1433 use std::str::FromStr;
1434
1435 type TerminalBare = Terminal<DescriptorPublicKey, BareCtx>;
1437 type TerminalLeg = Terminal<DescriptorPublicKey, Legacy>;
1438 type TerminalSw0 = Terminal<DescriptorPublicKey, Segwitv0>;
1439 type TerminalTap = Terminal<DescriptorPublicKey, Tap>;
1440
1441 type MsBare = Miniscript<DescriptorPublicKey, BareCtx>;
1442 type MsLeg = Miniscript<DescriptorPublicKey, Legacy>;
1443 type MsSw0 = Miniscript<DescriptorPublicKey, Segwitv0>;
1444 type MsTap = Miniscript<DescriptorPublicKey, Tap>;
1445
1446 #[test]
1447 fn test_wildcard() {
1448 assert_eq!(
1449 Wildcard::None,
1450 Wildcard::from_template(
1451 &template_of(Wildcard::None),
1452 &mut 0,
1453 &[],
1454 &mut 0,
1455 &mut KeyMap::new()
1456 )
1457 .unwrap()
1458 );
1459 assert_eq!(
1460 Wildcard::Unhardened,
1461 Wildcard::from_template(
1462 &template_of(Wildcard::Unhardened),
1463 &mut 0,
1464 &[],
1465 &mut 0,
1466 &mut KeyMap::new()
1467 )
1468 .unwrap()
1469 );
1470 assert_eq!(
1471 Wildcard::Hardened,
1472 Wildcard::from_template(
1473 &template_of(Wildcard::Hardened),
1474 &mut 0,
1475 &[],
1476 &mut 0,
1477 &mut KeyMap::new()
1478 )
1479 .unwrap()
1480 );
1481 }
1482
1483 #[test]
1484 fn test_derivation_path() {
1485 let dp_empty = DerivationPath::master();
1487 assert_eq!(
1488 dp_empty.clone(),
1489 DerivationPath::from_template(
1490 &template_of(dp_empty),
1491 &mut 0,
1492 &[],
1493 &mut 0,
1494 &mut KeyMap::new()
1495 )
1496 .unwrap()
1497 );
1498
1499 let dp_0 = dp_from_str("m/0");
1501 assert_eq!(
1502 dp_0.clone(),
1503 DerivationPath::from_template(
1504 &template_of(dp_0),
1505 &mut 0,
1506 &[],
1507 &mut 0,
1508 &mut KeyMap::new()
1509 )
1510 .unwrap()
1511 );
1512
1513 let dp_1h = dp_from_str("m/1'");
1515 assert_eq!(
1516 dp_1h.clone(),
1517 DerivationPath::from_template(
1518 &template_of(dp_1h),
1519 &mut 0,
1520 &[],
1521 &mut 0,
1522 &mut KeyMap::new()
1523 )
1524 .unwrap()
1525 );
1526
1527 let dp_complex = dp_from_str("m/42/23h/0/1h");
1529 assert_eq!(
1530 dp_complex.clone(),
1531 DerivationPath::from_template(
1532 &template_of(dp_complex),
1533 &mut 0,
1534 &[],
1535 &mut 0,
1536 &mut KeyMap::new()
1537 )
1538 .unwrap()
1539 );
1540 }
1541
1542 #[test]
1543 fn test_deriv_paths() {
1544 let dp1_str = "m/0";
1546 let deriv_paths_one = DerivPaths::new(vec![dp_from_str(dp1_str)]).unwrap();
1547 assert_eq!(
1548 deriv_paths_one.clone(),
1549 DerivPaths::from_template(
1550 &template_of(deriv_paths_one),
1551 &mut 0,
1552 &[],
1553 &mut 0,
1554 &mut KeyMap::new()
1555 )
1556 .unwrap()
1557 );
1558
1559 let dp2_str = "m/1h";
1561 let deriv_paths_multi =
1562 DerivPaths::new(vec![dp_from_str(dp1_str), dp_from_str(dp2_str)]).unwrap();
1563 assert_eq!(
1564 deriv_paths_multi.clone(),
1565 DerivPaths::from_template(
1566 &template_of(deriv_paths_multi),
1567 &mut 0,
1568 &[],
1569 &mut 0,
1570 &mut KeyMap::new()
1571 )
1572 .unwrap()
1573 );
1574 }
1575
1576 #[test]
1577 fn test_descriptor_public_key() {
1578 let (_, dpk1) = create_dpk_single_full(true, None, 2);
1580 assert_eq!(
1581 create_dpk_single_full(true, None, 1).1,
1582 DescriptorPublicKey::from_template(
1583 &template_of(dpk1.clone()),
1584 &mut 0,
1585 &[],
1586 &mut 0,
1587 &mut KeyMap::new()
1588 )
1589 .unwrap()
1590 );
1591 assert_eq!(
1592 dpk1.clone(),
1593 DescriptorPublicKey::from_template(
1594 &template_of(dpk1.clone()),
1595 &mut 0,
1596 &payload_of(dpk1.clone()),
1597 &mut 0,
1598 &mut KeyMap::new()
1599 )
1600 .unwrap()
1601 );
1602
1603 let (_, dpk2) = create_dpk_single_full(false, None, 2);
1605 assert_eq!(
1606 create_dpk_single_full(false, None, 1).1,
1607 DescriptorPublicKey::from_template(
1608 &template_of(dpk2.clone()),
1609 &mut 0,
1610 &[],
1611 &mut 0,
1612 &mut KeyMap::new()
1613 )
1614 .unwrap()
1615 );
1616 assert_eq!(
1617 dpk2.clone(),
1618 DescriptorPublicKey::from_template(
1619 &template_of(dpk2.clone()),
1620 &mut 0,
1621 &payload_of(dpk2.clone()),
1622 &mut 0,
1623 &mut KeyMap::new()
1624 )
1625 .unwrap()
1626 );
1627
1628 let (_, dpk_xonly) = create_dpk_xonly_no_origin(2);
1630 assert_eq!(
1631 create_dpk_xonly_no_origin(1).1,
1632 DescriptorPublicKey::from_template(
1633 &template_of(dpk_xonly.clone()),
1634 &mut 0,
1635 &[],
1636 &mut 0,
1637 &mut KeyMap::new()
1638 )
1639 .unwrap()
1640 );
1641 assert_eq!(
1642 dpk_xonly.clone(),
1643 DescriptorPublicKey::from_template(
1644 &template_of(dpk_xonly.clone()),
1645 &mut 0,
1646 &payload_of(dpk_xonly.clone()),
1647 &mut 0,
1648 &mut KeyMap::new()
1649 )
1650 .unwrap()
1651 );
1652
1653 let origin_fp = fp_from_str("12345678");
1655 let origin_path = dp_from_str("m/84h/0h/0h");
1656 let (_, dpk3) = create_dpk_single_full(true, Some((origin_fp, origin_path.clone())), 3);
1657 assert_eq!(
1658 create_dpk_single_full(true, Some((dummy::fp(), origin_path.clone())), 1).1,
1659 DescriptorPublicKey::from_template(
1660 &template_of(dpk3.clone()),
1661 &mut 0,
1662 &[],
1663 &mut 0,
1664 &mut KeyMap::new()
1665 )
1666 .unwrap()
1667 );
1668 assert_eq!(
1669 dpk3.clone(),
1670 DescriptorPublicKey::from_template(
1671 &template_of(dpk3.clone()),
1672 &mut 0,
1673 &payload_of(dpk3.clone()),
1674 &mut 0,
1675 &mut KeyMap::new()
1676 )
1677 .unwrap()
1678 );
1679
1680 let xpub_path_str = "m/0/0";
1682 let xpub = Xpub::from_str("xpub6DYotmPf2kXFYhJMFDpfydjiXG1RzmH1V7Fnn2Z38DgN2oSYruczMyTFZZPz6yXq47Re8anhXWGj4yMzPTA3bjPDdpA96TLUbMehrH3sBna").unwrap();
1683 let (_, dpk_xpub1) = create_dpk_xpub(None, xpub_path_str, xpub, Wildcard::None);
1684 assert_eq!(
1685 create_dpk_xpub(None, xpub_path_str, dummy::xpub(), Wildcard::None).1,
1686 DescriptorPublicKey::from_template(
1687 &template_of(dpk_xpub1.clone()),
1688 &mut 0,
1689 &[],
1690 &mut 0,
1691 &mut KeyMap::new()
1692 )
1693 .unwrap()
1694 );
1695 assert_eq!(
1696 dpk_xpub1.clone(),
1697 DescriptorPublicKey::from_template(
1698 &template_of(dpk_xpub1.clone()),
1699 &mut 0,
1700 &payload_of(dpk_xpub1.clone()),
1701 &mut 0,
1702 &mut KeyMap::new()
1703 )
1704 .unwrap()
1705 );
1706
1707 let (_, dpk_xpub2) = create_dpk_xpub(
1709 Some((origin_fp, origin_path.clone())),
1710 "m/1",
1711 xpub,
1712 Wildcard::Unhardened,
1713 );
1714 let (_, expected_dpk_xpub2) = create_dpk_xpub(
1715 Some((dummy::fp(), origin_path.clone())),
1716 "m/1",
1717 dummy::xpub(),
1718 Wildcard::Unhardened,
1719 );
1720 assert_eq!(
1721 expected_dpk_xpub2,
1722 DescriptorPublicKey::from_template(
1723 &template_of(dpk_xpub2.clone()),
1724 &mut 0,
1725 &[],
1726 &mut 0,
1727 &mut KeyMap::new()
1728 )
1729 .unwrap()
1730 );
1731 assert_eq!(
1732 dpk_xpub2.clone(),
1733 DescriptorPublicKey::from_template(
1734 &template_of(dpk_xpub2.clone()),
1735 &mut 0,
1736 &payload_of(dpk_xpub2.clone()),
1737 &mut 0,
1738 &mut KeyMap::new()
1739 )
1740 .unwrap()
1741 );
1742
1743 let multixpub_paths_str = ["m/0/0", "m/0/1"];
1745 let (_, dpk_multixpub1) =
1746 create_dpk_multixpub(None, &multixpub_paths_str, xpub, Wildcard::Hardened);
1747 assert_eq!(
1748 create_dpk_multixpub(
1749 None,
1750 &multixpub_paths_str,
1751 dummy::xpub(),
1752 Wildcard::Hardened
1753 )
1754 .1,
1755 DescriptorPublicKey::from_template(
1756 &template_of(dpk_multixpub1.clone()),
1757 &mut 0,
1758 &[],
1759 &mut 0,
1760 &mut KeyMap::new()
1761 )
1762 .unwrap()
1763 );
1764 assert_eq!(
1765 dpk_multixpub1.clone(),
1766 DescriptorPublicKey::from_template(
1767 &template_of(dpk_multixpub1.clone()),
1768 &mut 0,
1769 &payload_of(dpk_multixpub1.clone()),
1770 &mut 0,
1771 &mut KeyMap::new()
1772 )
1773 .unwrap()
1774 );
1775 }
1776
1777 #[test]
1778 fn test_descriptor_secret_key() {
1779 let secp = Secp256k1::new();
1780
1781 let (_, dsk1) = create_dsk_single(true, None, 2);
1783 assert_eq!(
1784 create_dpk_single_full(true, None, 1).1,
1785 DescriptorPublicKey::from_template(
1786 &template_of(dsk1.clone()),
1787 &mut 0,
1788 &[],
1789 &mut 0,
1790 &mut KeyMap::new()
1791 )
1792 .unwrap()
1793 );
1794 let dpk1 = dsk1.to_public(&secp).unwrap();
1795 let mut km = KeyMap::new();
1796 assert_eq!(
1797 dpk1.clone(),
1798 DescriptorPublicKey::from_template(
1799 &template_of(dsk1.clone()),
1800 &mut 0,
1801 &payload_of(dsk1.clone()),
1802 &mut 0,
1803 &mut km
1804 )
1805 .unwrap()
1806 );
1807 assert_eq!(&dsk1.clone(), km.get(&dpk1).unwrap());
1808
1809 let (_, dsk2) = create_dsk_single(false, None, 2);
1811 assert_eq!(
1812 create_dpk_single_full(false, None, 1).1,
1813 DescriptorPublicKey::from_template(
1814 &template_of(dsk2.clone()),
1815 &mut 0,
1816 &[],
1817 &mut 0,
1818 &mut KeyMap::new()
1819 )
1820 .unwrap()
1821 );
1822 let dpk2 = dsk2.to_public(&secp).unwrap();
1823 let mut km = KeyMap::new();
1824 assert_eq!(
1825 dpk2.clone(),
1826 DescriptorPublicKey::from_template(
1827 &template_of(dsk2.clone()),
1828 &mut 0,
1829 &payload_of(dsk2.clone()),
1830 &mut 0,
1831 &mut km
1832 )
1833 .unwrap()
1834 );
1835 assert_eq!(&dsk2.clone(), km.get(&dpk2).unwrap());
1836
1837 let origin_fp = fp_from_str("12345678");
1839 let origin_path = dp_from_str("m/84h/0h/0h");
1840 let (_, dsk3) = create_dsk_single(true, Some((origin_fp, origin_path.clone())), 3);
1841 assert_eq!(
1842 create_dpk_single_full(true, Some((dummy::fp(), origin_path.clone())), 1).1,
1843 DescriptorPublicKey::from_template(
1844 &template_of(dsk3.clone()),
1845 &mut 0,
1846 &[],
1847 &mut 0,
1848 &mut KeyMap::new()
1849 )
1850 .unwrap()
1851 );
1852 let dpk3 = dsk3.to_public(&secp).unwrap();
1853 let mut km = KeyMap::new();
1854 assert_eq!(
1855 dpk3.clone(),
1856 DescriptorPublicKey::from_template(
1857 &template_of(dsk3.clone()),
1858 &mut 0,
1859 &payload_of(dsk3.clone()),
1860 &mut 0,
1861 &mut km
1862 )
1863 .unwrap()
1864 );
1865 assert_eq!(&dsk3.clone(), km.get(&dpk3).unwrap());
1866
1867 let xpriv_path_str = "m/0/0";
1869 let xpriv = Xpriv::new_master(NetworkKind::Main, &[1u8; 32]).unwrap();
1870 let (_, dsk_xpriv1) = create_dsk_xpriv(None, xpriv_path_str, xpriv, Wildcard::None);
1871 assert_eq!(
1872 create_dpk_xpub(None, xpriv_path_str, dummy::xpub(), Wildcard::None).1,
1873 DescriptorPublicKey::from_template(
1874 &template_of(dsk_xpriv1.clone()),
1875 &mut 0,
1876 &[],
1877 &mut 0,
1878 &mut KeyMap::new()
1879 )
1880 .unwrap()
1881 );
1882 let dpk_xpub1 = dsk_xpriv1.to_public(&secp).unwrap();
1883 let mut km = KeyMap::new();
1884 assert_eq!(
1885 dpk_xpub1.clone(),
1886 DescriptorPublicKey::from_template(
1887 &template_of(dsk_xpriv1.clone()),
1888 &mut 0,
1889 &payload_of(dsk_xpriv1.clone()),
1890 &mut 0,
1891 &mut km
1892 )
1893 .unwrap()
1894 );
1895 assert_eq!(&dsk_xpriv1.clone(), km.get(&dpk_xpub1).unwrap());
1896
1897 let (_, dsk_xpriv2) = create_dsk_xpriv(
1899 Some((origin_fp, origin_path.clone())),
1900 "m/1",
1901 xpriv,
1902 Wildcard::Unhardened,
1903 );
1904 assert_eq!(
1905 create_dpk_xpub(
1906 Some((dummy::fp(), origin_path.clone())),
1907 "m/1",
1908 dummy::xpub(),
1909 Wildcard::Unhardened
1910 )
1911 .1,
1912 DescriptorPublicKey::from_template(
1913 &template_of(dsk_xpriv2.clone()),
1914 &mut 0,
1915 &[],
1916 &mut 0,
1917 &mut KeyMap::new()
1918 )
1919 .unwrap()
1920 );
1921 let dpk_xpub2 = dsk_xpriv2.to_public(&secp).unwrap();
1922 let mut km = KeyMap::new();
1923 assert_eq!(
1924 dpk_xpub2.clone(),
1925 DescriptorPublicKey::from_template(
1926 &template_of(dsk_xpriv2.clone()),
1927 &mut 0,
1928 &payload_of(dsk_xpriv2.clone()),
1929 &mut 0,
1930 &mut km
1931 )
1932 .unwrap()
1933 );
1934 assert_eq!(&dsk_xpriv2.clone(), km.get(&dpk_xpub2).unwrap());
1935
1936 let multixpriv_paths_str = ["m/0/0", "m/0/1"];
1938 let (_, dsk_multixpriv1) =
1939 create_dsk_multixpriv(None, &multixpriv_paths_str, xpriv, Wildcard::Hardened);
1940 assert_eq!(
1941 create_dpk_single_compressed_no_origin(1),
1942 DescriptorPublicKey::from_template(
1943 &template_of(dsk_multixpriv1.clone()),
1944 &mut 0,
1945 &[],
1946 &mut 0,
1947 &mut KeyMap::new()
1948 )
1949 .unwrap()
1950 );
1951 let dpk_multixpub1 = create_dpk_single_compressed_no_origin(2);
1952 assert_eq!(
1953 dpk_multixpub1.clone(),
1954 DescriptorPublicKey::from_template(
1955 &template_of(dsk_multixpriv1.clone()),
1956 &mut 0,
1957 &payload_of(dsk_multixpriv1.clone()),
1958 &mut 0,
1959 &mut km
1960 )
1961 .unwrap()
1962 );
1963 assert_eq!(&dsk_multixpriv1.clone(), km.get(&dpk_multixpub1).unwrap());
1964 }
1965
1966 #[test]
1967 fn test_miniscript_terminals() {
1968 let pk = create_dpk_single_compressed_no_origin(1);
1969
1970 let ms_true = MsSw0::TRUE;
1971 assert_eq!(
1972 ms_true.clone(),
1973 MsSw0::from_template(
1974 &template_of(ms_true),
1975 &mut 0,
1976 &[],
1977 &mut 0,
1978 &mut KeyMap::new()
1979 )
1980 .unwrap()
1981 );
1982
1983 let ms_false = MsSw0::FALSE;
1984 assert_eq!(
1985 ms_false.clone(),
1986 MsSw0::from_template(
1987 &template_of(ms_false),
1988 &mut 0,
1989 &[],
1990 &mut 0,
1991 &mut KeyMap::new()
1992 )
1993 .unwrap()
1994 );
1995
1996 let ms_pkk = MsSw0::from_ast(TerminalSw0::PkK(pk.clone())).unwrap();
1997 assert_eq!(
1998 ms_pkk.clone(),
1999 MsSw0::from_template(
2000 &template_of(ms_pkk),
2001 &mut 0,
2002 &[],
2003 &mut 0,
2004 &mut KeyMap::new()
2005 )
2006 .unwrap()
2007 );
2008
2009 let ms_pkh = MsSw0::from_ast(TerminalSw0::PkH(pk.clone())).unwrap();
2010 assert_eq!(
2011 ms_pkh.clone(),
2012 MsSw0::from_template(
2013 &template_of(ms_pkh),
2014 &mut 0,
2015 &[],
2016 &mut 0,
2017 &mut KeyMap::new()
2018 )
2019 .unwrap()
2020 );
2021
2022 let hash160 = Hash160::from_slice(&[1u8; 20]).unwrap();
2024 let ms_raw_pkh = MsSw0::from_ast(TerminalSw0::RawPkH(hash160)).unwrap();
2025 assert_eq!(
2026 MsSw0::from_ast(TerminalSw0::RawPkH(dummy::hash160())).unwrap(),
2027 MsSw0::from_template(
2028 &template_of(ms_raw_pkh.clone()),
2029 &mut 0,
2030 &[],
2031 &mut 0,
2032 &mut KeyMap::new()
2033 )
2034 .unwrap()
2035 );
2036 assert_eq!(
2037 ms_raw_pkh.clone(),
2038 MsSw0::from_template(
2039 &template_of(ms_raw_pkh.clone()),
2040 &mut 0,
2041 &payload_of(ms_raw_pkh.clone()),
2042 &mut 0,
2043 &mut KeyMap::new()
2044 )
2045 .unwrap()
2046 );
2047
2048 let ms_hash160 = MsSw0::from_ast(TerminalSw0::Hash160(hash160)).unwrap();
2049 assert_eq!(
2050 MsSw0::from_ast(TerminalSw0::Hash160(dummy::hash160())).unwrap(),
2051 MsSw0::from_template(
2052 &template_of(ms_hash160.clone()),
2053 &mut 0,
2054 &[],
2055 &mut 0,
2056 &mut KeyMap::new()
2057 )
2058 .unwrap()
2059 );
2060 assert_eq!(
2061 ms_hash160.clone(),
2062 MsSw0::from_template(
2063 &template_of(ms_hash160.clone()),
2064 &mut 0,
2065 &payload_of(ms_hash160.clone()),
2066 &mut 0,
2067 &mut KeyMap::new()
2068 )
2069 .unwrap()
2070 );
2071
2072 let after = AbsLockTime::from_consensus(50000).unwrap();
2073 let ms_after = MsSw0::from_ast(TerminalSw0::After(after)).unwrap();
2074 assert_eq!(
2075 MsSw0::from_ast(TerminalSw0::After(dummy::after())).unwrap(),
2076 MsSw0::from_template(
2077 &template_of(ms_after.clone()),
2078 &mut 0,
2079 &[],
2080 &mut 0,
2081 &mut KeyMap::new()
2082 )
2083 .unwrap()
2084 );
2085 assert_eq!(
2086 ms_after.clone(),
2087 MsSw0::from_template(
2088 &template_of(ms_after.clone()),
2089 &mut 0,
2090 &payload_of(ms_after.clone()),
2091 &mut 0,
2092 &mut KeyMap::new()
2093 )
2094 .unwrap()
2095 );
2096
2097 let older = RelLockTime::from_consensus(50000).unwrap();
2098 let ms_older = MsSw0::from_ast(TerminalSw0::Older(older)).unwrap();
2099 assert_eq!(
2100 MsSw0::from_ast(TerminalSw0::Older(dummy::older())).unwrap(),
2101 MsSw0::from_template(
2102 &template_of(ms_older.clone()),
2103 &mut 0,
2104 &[],
2105 &mut 0,
2106 &mut KeyMap::new()
2107 )
2108 .unwrap()
2109 );
2110 assert_eq!(
2111 ms_older.clone(),
2112 MsSw0::from_template(
2113 &template_of(ms_older.clone()),
2114 &mut 0,
2115 &payload_of(ms_older.clone()),
2116 &mut 0,
2117 &mut KeyMap::new()
2118 )
2119 .unwrap()
2120 );
2121
2122 let sha256 = Sha256::from_slice(&[1u8; 32]).unwrap();
2123 let ms_sha256 = MsSw0::from_ast(TerminalSw0::Sha256(sha256)).unwrap();
2124 assert_eq!(
2125 MsSw0::from_ast(TerminalSw0::Sha256(dummy::sha256())).unwrap(),
2126 MsSw0::from_template(
2127 &template_of(ms_sha256.clone()),
2128 &mut 0,
2129 &[],
2130 &mut 0,
2131 &mut KeyMap::new()
2132 )
2133 .unwrap()
2134 );
2135 assert_eq!(
2136 ms_sha256.clone(),
2137 MsSw0::from_template(
2138 &template_of(ms_sha256.clone()),
2139 &mut 0,
2140 &payload_of(ms_sha256.clone()),
2141 &mut 0,
2142 &mut KeyMap::new()
2143 )
2144 .unwrap()
2145 );
2146
2147 let hash256 = Hash256::from_raw_hash(sha256d::Hash::from_slice(&[1u8; 32]).unwrap());
2148 let ms_hash256 = MsSw0::from_ast(TerminalSw0::Hash256(hash256)).unwrap();
2149 assert_eq!(
2150 MsSw0::from_ast(TerminalSw0::Hash256(dummy::hash256())).unwrap(),
2151 MsSw0::from_template(
2152 &template_of(ms_hash256.clone()),
2153 &mut 0,
2154 &[],
2155 &mut 0,
2156 &mut KeyMap::new()
2157 )
2158 .unwrap()
2159 );
2160 assert_eq!(
2161 ms_hash256.clone(),
2162 MsSw0::from_template(
2163 &template_of(ms_hash256.clone()),
2164 &mut 0,
2165 &payload_of(ms_hash256.clone()),
2166 &mut 0,
2167 &mut KeyMap::new()
2168 )
2169 .unwrap()
2170 );
2171
2172 let ripemd160 = Ripemd160::from_slice(&[1u8; 20]).unwrap();
2173 let ms_ripemd160 = MsSw0::from_ast(TerminalSw0::Ripemd160(ripemd160)).unwrap();
2174 assert_eq!(
2175 MsSw0::from_ast(TerminalSw0::Ripemd160(dummy::ripemd160())).unwrap(),
2176 MsSw0::from_template(
2177 &template_of(ms_ripemd160.clone()),
2178 &mut 0,
2179 &[],
2180 &mut 0,
2181 &mut KeyMap::new()
2182 )
2183 .unwrap()
2184 );
2185 assert_eq!(
2186 ms_ripemd160.clone(),
2187 MsSw0::from_template(
2188 &template_of(ms_ripemd160.clone()),
2189 &mut 0,
2190 &payload_of(ms_ripemd160.clone()),
2191 &mut 0,
2192 &mut KeyMap::new()
2193 )
2194 .unwrap()
2195 );
2196
2197 let k = 1;
2198 let pk1 = create_dpk_single_compressed_no_origin(1);
2199 let pk2 = create_dpk_single_compressed_no_origin(2);
2200
2201 let pks = vec![pk1.clone(), pk2.clone()];
2203 let pks_expected = vec![pk1.clone(), pk1.clone()];
2204 let multi = TerminalSw0::Multi(Threshold::new(k, pks.clone()).unwrap());
2205 let multi_expected = TerminalSw0::Multi(Threshold::new(k, pks_expected.clone()).unwrap());
2206 assert_eq!(
2207 multi_expected.clone(),
2208 TerminalSw0::from_template(
2209 &template_of(multi.clone()),
2210 &mut 0,
2211 &[],
2212 &mut 0,
2213 &mut KeyMap::new()
2214 )
2215 .unwrap()
2216 );
2217 assert_eq!(
2218 multi.clone(),
2219 TerminalSw0::from_template(
2220 &template_of(multi.clone()),
2221 &mut 0,
2222 &payload_of(multi.clone()),
2223 &mut 0,
2224 &mut KeyMap::new()
2225 )
2226 .unwrap()
2227 );
2228
2229 let multi_a = TerminalTap::MultiA(Threshold::new(k, pks.clone()).unwrap());
2231 let multi_a_expected =
2232 TerminalTap::MultiA(Threshold::new(k, pks_expected.clone()).unwrap());
2233 assert_eq!(
2234 multi_a_expected,
2235 TerminalTap::from_template(
2236 &template_of(multi_a.clone()),
2237 &mut 0,
2238 &[],
2239 &mut 0,
2240 &mut KeyMap::new()
2241 )
2242 .unwrap()
2243 );
2244 assert_eq!(
2245 multi_a.clone(),
2246 TerminalTap::from_template(
2247 &template_of(multi_a.clone()),
2248 &mut 0,
2249 &payload_of(multi_a.clone()),
2250 &mut 0,
2251 &mut KeyMap::new()
2252 )
2253 .unwrap()
2254 );
2255 }
2256
2257 #[test]
2258 fn test_miniscript_ops() {
2259 let pk = create_dpk_single_compressed_no_origin(1);
2260 let ms_true = Arc::new(MsSw0::TRUE);
2261 let ms_false = Arc::new(MsSw0::FALSE);
2262 let ms_hash160 = Arc::new(MsSw0::from_ast(TerminalSw0::Hash160(dummy::hash160())).unwrap());
2263 let pk_k = TerminalSw0::PkK(pk);
2264 let ms_pk_k = Arc::new(MsSw0::from_ast(pk_k.clone()).unwrap());
2265
2266 let ms_alt = MsSw0::from_ast(TerminalSw0::Alt(ms_true.clone())).unwrap();
2268 assert_eq!(
2269 ms_alt.clone(),
2270 MsSw0::from_template(
2271 &template_of(ms_alt),
2272 &mut 0,
2273 &[],
2274 &mut 0,
2275 &mut KeyMap::new()
2276 )
2277 .unwrap()
2278 );
2279
2280 let ms_swap = MsSw0::from_ast(TerminalSw0::Swap(ms_hash160.clone())).unwrap();
2281 assert_eq!(
2282 ms_swap.clone(),
2283 MsSw0::from_template(
2284 &template_of(ms_swap.clone()),
2285 &mut 0,
2286 &[],
2287 &mut 0,
2288 &mut KeyMap::new()
2289 )
2290 .unwrap()
2291 );
2292
2293 let ms_check = MsSw0::from_ast(TerminalSw0::Check(ms_pk_k.clone())).unwrap();
2294 assert_eq!(
2295 ms_check.clone(),
2296 MsSw0::from_template(
2297 &template_of(ms_check),
2298 &mut 0,
2299 &[],
2300 &mut 0,
2301 &mut KeyMap::new()
2302 )
2303 .unwrap()
2304 );
2305
2306 let ms_verify = MsSw0::from_ast(TerminalSw0::Verify(ms_true.clone())).unwrap();
2307 assert_eq!(
2308 ms_verify.clone(),
2309 MsSw0::from_template(
2310 &template_of(ms_verify.clone()),
2311 &mut 0,
2312 &[],
2313 &mut 0,
2314 &mut KeyMap::new()
2315 )
2316 .unwrap()
2317 );
2318
2319 let ms_dupif = MsSw0::from_ast(TerminalSw0::DupIf(ms_verify.clone().into())).unwrap();
2320 assert_eq!(
2321 ms_dupif.clone(),
2322 MsSw0::from_template(
2323 &template_of(ms_dupif),
2324 &mut 0,
2325 &[],
2326 &mut 0,
2327 &mut KeyMap::new()
2328 )
2329 .unwrap()
2330 );
2331
2332 let ms_zerone = MsSw0::from_ast(TerminalSw0::ZeroNotEqual(ms_true.clone())).unwrap();
2333 assert_eq!(
2334 ms_zerone.clone(),
2335 MsSw0::from_template(
2336 &template_of(ms_zerone),
2337 &mut 0,
2338 &[],
2339 &mut 0,
2340 &mut KeyMap::new()
2341 )
2342 .unwrap()
2343 );
2344
2345 let ms_andv =
2347 MsSw0::from_ast(TerminalSw0::AndV(ms_verify.clone().into(), ms_true.clone())).unwrap();
2348 assert_eq!(
2349 ms_andv.clone(),
2350 MsSw0::from_template(
2351 &template_of(ms_andv),
2352 &mut 0,
2353 &[],
2354 &mut 0,
2355 &mut KeyMap::new()
2356 )
2357 .unwrap()
2358 );
2359
2360 let ms_andb =
2361 MsSw0::from_ast(TerminalSw0::AndB(ms_true.clone(), ms_swap.clone().into())).unwrap();
2362 assert_eq!(
2363 ms_andb.clone(),
2364 MsSw0::from_template(
2365 &template_of(ms_andb),
2366 &mut 0,
2367 &[],
2368 &mut 0,
2369 &mut KeyMap::new()
2370 )
2371 .unwrap()
2372 );
2373
2374 let ms_orb =
2375 MsSw0::from_ast(TerminalSw0::OrB(ms_false.clone(), ms_swap.clone().into())).unwrap();
2376 assert_eq!(
2377 ms_orb.clone(),
2378 MsSw0::from_template(
2379 &template_of(ms_orb),
2380 &mut 0,
2381 &[],
2382 &mut 0,
2383 &mut KeyMap::new()
2384 )
2385 .unwrap()
2386 );
2387
2388 let ms_orc =
2389 MsSw0::from_ast(TerminalSw0::OrC(ms_false.clone(), ms_verify.clone().into())).unwrap();
2390 assert_eq!(
2391 ms_orc.clone(),
2392 MsSw0::from_template(
2393 &template_of(ms_orc),
2394 &mut 0,
2395 &[],
2396 &mut 0,
2397 &mut KeyMap::new()
2398 )
2399 .unwrap()
2400 );
2401
2402 let ms_ord = MsSw0::from_ast(TerminalSw0::OrD(ms_false.clone(), ms_true.clone())).unwrap();
2403 assert_eq!(
2404 ms_ord.clone(),
2405 MsSw0::from_template(
2406 &template_of(ms_ord),
2407 &mut 0,
2408 &[],
2409 &mut 0,
2410 &mut KeyMap::new()
2411 )
2412 .unwrap()
2413 );
2414
2415 let ms_ori = MsSw0::from_ast(TerminalSw0::OrI(ms_true.clone(), ms_false.clone())).unwrap();
2416 assert_eq!(
2417 ms_ori.clone(),
2418 MsSw0::from_template(
2419 &template_of(ms_ori),
2420 &mut 0,
2421 &[],
2422 &mut 0,
2423 &mut KeyMap::new()
2424 )
2425 .unwrap()
2426 );
2427
2428 let ms_andor = MsSw0::from_ast(TerminalSw0::AndOr(
2430 ms_false.clone(),
2431 ms_true.clone(),
2432 ms_true.clone(),
2433 ))
2434 .unwrap();
2435 assert_eq!(
2436 ms_andor.clone(),
2437 MsSw0::from_template(
2438 &template_of(ms_andor),
2439 &mut 0,
2440 &[],
2441 &mut 0,
2442 &mut KeyMap::new()
2443 )
2444 .unwrap()
2445 );
2446
2447 let k = 1;
2448
2449 let subs = vec![ms_false.clone(), ms_swap.clone().into()];
2451 let thresh = MsSw0::from_ast(TerminalSw0::Thresh(
2452 Threshold::new(k, subs.clone()).unwrap(),
2453 ))
2454 .unwrap();
2455 assert_eq!(
2456 thresh.clone(),
2457 MsSw0::from_template(
2458 &template_of(thresh),
2459 &mut 0,
2460 &[],
2461 &mut 0,
2462 &mut KeyMap::new()
2463 )
2464 .unwrap()
2465 );
2466 }
2467
2468 #[test]
2469 fn test_sorted_multi() {
2470 let pk1 = create_dpk_single_compressed_no_origin(1);
2471 let pk2 = create_dpk_single_compressed_no_origin(2);
2472 let pk3 = create_dpk_single_compressed_no_origin(3);
2473
2474 type SortedMultiSw0 = SortedMultiVec<DescriptorPublicKey, Segwitv0>;
2475
2476 let k = 2;
2477 let pks = vec![pk1.clone(), pk2.clone(), pk3.clone()];
2478 let expected_pks = vec![pk1.clone(), pk1.clone(), pk1.clone()];
2479 let sorted_multi = SortedMultiSw0::new(k, pks.clone()).unwrap();
2480 let expected_sorted_multi = SortedMultiSw0::new(k, expected_pks.clone()).unwrap();
2481 assert_eq!(
2482 expected_sorted_multi.clone(),
2483 SortedMultiSw0::from_template(
2484 &template_of(sorted_multi),
2485 &mut 0,
2486 &[],
2487 &mut 0,
2488 &mut KeyMap::new()
2489 )
2490 .unwrap()
2491 );
2492 }
2493
2494 #[test]
2495 fn test_taptree() {
2496 let pk1 = create_dpk_xonly_no_origin(1).1;
2497 let pk2 = create_dpk_xonly_no_origin(2).1;
2498 let ms_leaf1 = Arc::new(MsTap::from_ast(TerminalTap::PkK(pk1.clone())).unwrap());
2499 let ms_leaf2 = Arc::new(MsTap::from_ast(TerminalTap::PkK(pk2.clone())).unwrap());
2500
2501 let tap_leaf = TapTree::Leaf(ms_leaf1.clone());
2503 assert_eq!(
2504 tap_leaf.clone(),
2505 TapTree::from_template(
2506 &template_of(tap_leaf.clone()),
2507 &mut 0,
2508 &[],
2509 &mut 0,
2510 &mut KeyMap::new()
2511 )
2512 .unwrap()
2513 );
2514
2515 let tap_leaf2 = TapTree::Leaf(ms_leaf2.clone());
2517 let tap_tree = TapTree::Tree {
2518 left: Arc::new(tap_leaf.clone()),
2519 right: Arc::new(tap_leaf2.clone()),
2520 height: 1,
2521 };
2522 let expected_tap_tree = TapTree::Tree {
2523 left: Arc::new(tap_leaf.clone()),
2524 right: Arc::new(tap_leaf.clone()),
2525 height: 1,
2526 };
2527 assert_eq!(
2528 expected_tap_tree.clone(),
2529 TapTree::from_template(
2530 &template_of(tap_tree),
2531 &mut 0,
2532 &[],
2533 &mut 0,
2534 &mut KeyMap::new()
2535 )
2536 .unwrap()
2537 );
2538 }
2539
2540 #[test]
2541 fn test_bare_pkh_wpkh() {
2542 let pk_full = create_dpk_single_compressed_no_origin(1);
2543 let ms_bare_pkk = MsBare::from_ast(TerminalBare::PkK(pk_full.clone())).unwrap();
2544 let ms_bare_check_pkk = MsBare::from_ast(TerminalBare::Check(ms_bare_pkk.into())).unwrap();
2545
2546 let bare = Bare::new(ms_bare_check_pkk.clone()).unwrap();
2548 assert_eq!(
2549 bare.clone(),
2550 Bare::from_template(&template_of(bare), &mut 0, &[], &mut 0, &mut KeyMap::new())
2551 .unwrap()
2552 );
2553
2554 let pkh = Pkh::new(pk_full.clone()).unwrap();
2556 assert_eq!(
2557 pkh.clone(),
2558 Pkh::from_template(&template_of(pkh), &mut 0, &[], &mut 0, &mut KeyMap::new()).unwrap()
2559 );
2560
2561 let wpkh = Wpkh::new(pk_full.clone()).unwrap();
2563 assert_eq!(
2564 wpkh.clone(),
2565 Wpkh::from_template(&template_of(wpkh), &mut 0, &[], &mut 0, &mut KeyMap::new())
2566 .unwrap()
2567 );
2568 }
2569
2570 #[test]
2571 fn test_sh() {
2572 let pk1 = create_dpk_single_compressed_no_origin(1);
2573 let pk2 = create_dpk_single_compressed_no_origin(2);
2574
2575 let wpkh_inner = Wpkh::new(pk1.clone()).unwrap();
2577 let sh_wpkh = Sh::new_with_wpkh(wpkh_inner.clone());
2578 assert_eq!(
2579 sh_wpkh.clone(),
2580 Sh::from_template(
2581 &template_of(sh_wpkh),
2582 &mut 0,
2583 &[],
2584 &mut 0,
2585 &mut KeyMap::new()
2586 )
2587 .unwrap()
2588 );
2589
2590 let ms_wsh = MsSw0::from_ast(TerminalSw0::True).unwrap();
2592 let wsh = Wsh::new(ms_wsh).unwrap();
2593 let sh_wsh = Sh::new_with_wsh(wsh.clone());
2594 assert_eq!(
2595 sh_wsh.clone(),
2596 Sh::from_template(
2597 &template_of(sh_wsh),
2598 &mut 0,
2599 &[],
2600 &mut 0,
2601 &mut KeyMap::new()
2602 )
2603 .unwrap()
2604 );
2605
2606 let pks = vec![pk1.clone(), pk2.clone()];
2608 let expected_pks = vec![pk1.clone(), pk1.clone()];
2609 let sh_sortedmulti = Sh::new_sortedmulti(1, pks).unwrap();
2610 let expected_sh_sortedmulti = Sh::new_sortedmulti(1, expected_pks).unwrap();
2611 assert_eq!(
2612 expected_sh_sortedmulti.clone(),
2613 Sh::from_template(
2614 &template_of(sh_sortedmulti),
2615 &mut 0,
2616 &[],
2617 &mut 0,
2618 &mut KeyMap::new()
2619 )
2620 .unwrap()
2621 );
2622
2623 let ms_sh = MsLeg::from_ast(TerminalLeg::True).unwrap();
2625 let sh_ms = Sh::new(ms_sh.clone()).unwrap();
2626 assert_eq!(
2627 sh_ms.clone(),
2628 Sh::from_template(&template_of(sh_ms), &mut 0, &[], &mut 0, &mut KeyMap::new())
2629 .unwrap()
2630 );
2631 }
2632
2633 #[test]
2634 fn test_wsh() {
2635 let pk1 = create_dpk_single_compressed_no_origin(1);
2636 let pk2 = create_dpk_single_compressed_no_origin(2);
2637
2638 let pks = vec![pk1.clone(), pk2.clone()];
2640 let expected_pks = vec![pk1.clone(), pk1.clone()];
2641 let wsh_sortedmulti = Wsh::new_sortedmulti(1, pks).unwrap();
2642 let expected_wsh_sortedmulti = Wsh::new_sortedmulti(1, expected_pks).unwrap();
2643 assert_eq!(
2644 expected_wsh_sortedmulti.clone(),
2645 Wsh::from_template(
2646 &template_of(wsh_sortedmulti),
2647 &mut 0,
2648 &[],
2649 &mut 0,
2650 &mut KeyMap::new()
2651 )
2652 .unwrap()
2653 );
2654
2655 let ms_wsh = MsSw0::from_ast(TerminalSw0::True).unwrap();
2657 let wsh_ms = Wsh::new(ms_wsh.clone()).unwrap();
2658 assert_eq!(
2659 wsh_ms.clone(),
2660 Wsh::from_template(
2661 &template_of(wsh_ms),
2662 &mut 0,
2663 &[],
2664 &mut 0,
2665 &mut KeyMap::new()
2666 )
2667 .unwrap()
2668 );
2669 }
2670
2671 #[test]
2672 fn test_tr() {
2673 let internal_key = create_dpk_xonly_no_origin(1).1;
2674
2675 let tr_no_tree = Tr::new(internal_key.clone(), None).unwrap();
2677 assert_eq!(
2678 tr_no_tree.clone(),
2679 Tr::from_template(
2680 &template_of(tr_no_tree),
2681 &mut 0,
2682 &[],
2683 &mut 0,
2684 &mut KeyMap::new()
2685 )
2686 .unwrap()
2687 );
2688
2689 let leaf_ms = MsTap::from_ast(TerminalTap::True).unwrap();
2691 let tap_tree = TapTree::Leaf(leaf_ms.into());
2692 let tr_with_tree = Tr::new(internal_key.clone(), Some(tap_tree.clone())).unwrap();
2693 assert_eq!(
2694 tr_with_tree.clone(),
2695 Tr::from_template(
2696 &template_of(tr_with_tree),
2697 &mut 0,
2698 &[],
2699 &mut 0,
2700 &mut KeyMap::new()
2701 )
2702 .unwrap()
2703 );
2704 }
2705
2706 #[test]
2707 fn test_descriptor() {
2708 let pk1 = create_dpk_single_compressed_no_origin(1);
2709 let pk2 = create_dpk_single_compressed_no_origin(1);
2710
2711 let ms_bare_pkk = MsBare::from_ast(TerminalBare::PkK(pk1.clone())).unwrap();
2712 let ms_bare_check_pkk = MsBare::from_ast(TerminalBare::Check(ms_bare_pkk.into())).unwrap();
2713 let bare = Bare::new(ms_bare_check_pkk.clone()).unwrap();
2714 let descriptor1 = Descriptor::Bare(bare);
2715
2716 let ms_bare_pkk = MsBare::from_ast(TerminalBare::PkK(pk2.clone())).unwrap();
2717 let ms_bare_check_pkk = MsBare::from_ast(TerminalBare::Check(ms_bare_pkk.into())).unwrap();
2718 let bare = Bare::new(ms_bare_check_pkk.clone()).unwrap();
2719 let descriptor2 = Descriptor::Bare(bare);
2720
2721 assert_eq!(
2722 descriptor1.clone(),
2723 Descriptor::from_template(
2724 &template_of(descriptor2.clone()),
2725 &mut 0,
2726 &[],
2727 &mut 0,
2728 &mut KeyMap::new()
2729 )
2730 .unwrap()
2731 );
2732 assert_eq!(
2733 descriptor2.clone(),
2734 Descriptor::from_template(
2735 &template_of(descriptor2.clone()),
2736 &mut 0,
2737 &payload_of(descriptor2.clone()),
2738 &mut 0,
2739 &mut KeyMap::new()
2740 )
2741 .unwrap()
2742 );
2743
2744 let pkh1 = Pkh::new(pk1.clone()).unwrap();
2745 let pkh2 = Pkh::new(pk2.clone()).unwrap();
2746 let descriptor1 = Descriptor::Pkh(pkh1);
2747 let descriptor2 = Descriptor::Pkh(pkh2);
2748
2749 assert_eq!(
2750 descriptor1.clone(),
2751 Descriptor::from_template(
2752 &template_of(descriptor2.clone()),
2753 &mut 0,
2754 &[],
2755 &mut 0,
2756 &mut KeyMap::new()
2757 )
2758 .unwrap()
2759 );
2760 assert_eq!(
2761 descriptor2.clone(),
2762 Descriptor::from_template(
2763 &template_of(descriptor2.clone()),
2764 &mut 0,
2765 &payload_of(descriptor2.clone()),
2766 &mut 0,
2767 &mut KeyMap::new()
2768 )
2769 .unwrap()
2770 );
2771
2772 let ms_sh = MsLeg::from_ast(TerminalLeg::True).unwrap();
2773 let sh_ms = Sh::new(ms_sh.clone()).unwrap();
2774 let descriptor = Descriptor::Sh(sh_ms);
2775 assert_eq!(
2776 descriptor.clone(),
2777 Descriptor::from_template(
2778 &template_of(descriptor),
2779 &mut 0,
2780 &[],
2781 &mut 0,
2782 &mut KeyMap::new()
2783 )
2784 .unwrap()
2785 );
2786
2787 let wpkh1 = Wpkh::new(pk1.clone()).unwrap();
2788 let wpkh2 = Wpkh::new(pk2.clone()).unwrap();
2789 let descriptor1 = Descriptor::Wpkh(wpkh1);
2790 let descriptor2 = Descriptor::Wpkh(wpkh2);
2791
2792 assert_eq!(
2793 descriptor1.clone(),
2794 Descriptor::from_template(
2795 &template_of(descriptor2.clone()),
2796 &mut 0,
2797 &[],
2798 &mut 0,
2799 &mut KeyMap::new()
2800 )
2801 .unwrap()
2802 );
2803 assert_eq!(
2804 descriptor2.clone(),
2805 Descriptor::from_template(
2806 &template_of(descriptor2.clone()),
2807 &mut 0,
2808 &payload_of(descriptor2.clone()),
2809 &mut 0,
2810 &mut KeyMap::new()
2811 )
2812 .unwrap()
2813 );
2814
2815 let ms_wsh = MsSw0::from_ast(TerminalSw0::True).unwrap();
2816 let wsh_ms = Wsh::new(ms_wsh.clone()).unwrap();
2817 let descriptor = Descriptor::Wsh(wsh_ms);
2818 assert_eq!(
2819 descriptor.clone(),
2820 Descriptor::from_template(
2821 &template_of(descriptor),
2822 &mut 0,
2823 &[],
2824 &mut 0,
2825 &mut KeyMap::new()
2826 )
2827 .unwrap()
2828 );
2829
2830 let tr1 = Tr::new(pk1.clone(), None).unwrap();
2831 let tr2 = Tr::new(pk1.clone(), None).unwrap();
2832 let descriptor1 = Descriptor::Tr(tr1);
2833 let descriptor2 = Descriptor::Tr(tr2);
2834
2835 assert_eq!(
2836 descriptor1.clone(),
2837 Descriptor::from_template(
2838 &template_of(descriptor2.clone()),
2839 &mut 0,
2840 &[],
2841 &mut 0,
2842 &mut KeyMap::new()
2843 )
2844 .unwrap()
2845 );
2846 assert_eq!(
2847 descriptor2.clone(),
2848 Descriptor::from_template(
2849 &template_of(descriptor2.clone()),
2850 &mut 0,
2851 &payload_of(descriptor2.clone()),
2852 &mut 0,
2853 &mut KeyMap::new()
2854 )
2855 .unwrap()
2856 );
2857 }
2858
2859 #[test]
2860 fn test_size() {
2861 let pk = create_dpk_single_compressed_no_origin(1);
2862
2863 let pkh = Pkh::new(pk.clone()).unwrap();
2864 let descriptor = Descriptor::Pkh(pkh);
2865 let mut input = template_of(descriptor.clone());
2866 let expected_size = input.len();
2867 input.extend(vec![0, 1, 2, 3]);
2868
2869 assert_eq!(
2870 decode_template(&input),
2871 Ok((descriptor, KeyMap::new(), expected_size))
2872 );
2873 }
2874
2875 #[test]
2876 fn test_decode_with_payload() {
2877 let pk = create_dpk_single_compressed_no_origin(1);
2878
2879 let pkh = Pkh::new(pk.clone()).unwrap();
2880 let descriptor = Descriptor::Pkh(pkh);
2881 let input = template_of(descriptor.clone());
2882 let payload = payload_of(descriptor.clone());
2883
2884 assert_eq!(
2885 decode_with_payload(&input, &payload),
2886 Ok((descriptor, KeyMap::new()))
2887 );
2888 }
2889}