elements_miniscript/confidential/
mod.rs

1// Miniscript
2// Written in 2022 by
3//     Andrew Poelstra <apoelstra@wpsoftware.net>
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//! Confidential Descriptors
16//!
17//! Implements ELIP ????, described at `URL`
18//!
19
20pub mod bare;
21pub mod elip151;
22pub mod slip77;
23
24use std::fmt;
25
26use bitcoin::bip32;
27use elements::secp256k1_zkp;
28
29use crate::descriptor::checksum::{self, verify_checksum};
30use crate::descriptor::{
31    ConversionError, DefiniteDescriptorKey, DescriptorSecretKey, DescriptorPublicKey,
32    DescriptorXKey, Wildcard
33};
34use crate::expression::FromTree;
35use crate::extensions::{CovExtArgs, CovenantExt, Extension, ParseableExt};
36use crate::{expression, Error, MiniscriptKey, ToPublicKey, TranslatePk, Translator};
37
38/// A description of a blinding key
39#[derive(Clone, PartialEq, Eq, Debug)]
40pub enum Key {
41    /// Blinding key is computed using SLIP77 with the given master key
42    Slip77(slip77::MasterBlindingKey),
43    /// Blinding key is given directly
44    Bare(DescriptorPublicKey),
45    /// Blinding key is given directly, as a secret key
46    View(DescriptorSecretKey),
47}
48
49impl fmt::Display for Key {
50    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
51        match self {
52            Key::Slip77(data) => write!(f, "slip77({})", data),
53            Key::Bare(pk) => fmt::Display::fmt(pk, f),
54            Key::View(sk) => {
55                if let DescriptorSecretKey::Single(sk) = sk {
56                    crate::descriptor::maybe_fmt_master_id(f, &sk.origin)?;
57                    for byte in &sk.key.inner.secret_bytes() {
58                        write!(f, "{:02x}", byte)?;
59                    }
60                    Ok(())
61                } else {
62                    fmt::Display::fmt(sk, f)
63                }
64            }
65        }
66    }
67}
68
69impl Key {
70    fn to_public_key<C: secp256k1_zkp::Signing + secp256k1_zkp::Verification>(
71        &self,
72        secp: &secp256k1_zkp::Secp256k1<C>,
73        spk: &elements::Script,
74    ) -> Result<secp256k1_zkp::PublicKey, Error> {
75        match *self {
76            Key::Slip77(ref mbk) => Ok(mbk.blinding_key(secp, spk)),
77            Key::Bare(ref pk) => {
78                if pk.is_multipath() {
79                    Err(Error::Unexpected("multipath blinding key".into()))
80                } else if pk.has_wildcard() {
81                    Err(Error::Unexpected("wildcard blinding key".into()))
82                } else {
83                    // Convert into a DefiniteDescriptorKey, note that we are deriving the xpub
84                    // since there is not wildcard.
85                    // Consider adding DescriptorPublicKey::to_definite_descriptor
86                    let pk = pk.clone().at_derivation_index(0).expect("single or xpub without wildcards");
87                    // Derive explicitly rather than relying on ToPublicKey::to_public_key,
88                    // which panics on keys with hardened derivation steps.
89                    let pk = pk.derive_public_key(secp)?;
90                    Ok(bare::tweak_key(secp, spk, &pk))
91                }
92            },
93            Key::View(ref sk) => {
94                if sk.is_multipath() {
95                    Err(Error::Unexpected("multipath blinding key".into()))
96                } else {
97                    let pk = sk.to_public(secp).expect("single or xprv");
98                    if pk.has_wildcard() {
99                        Err(Error::Unexpected("wildcard blinding key".into()))
100                    } else {
101                        let pk = pk.at_derivation_index(0).expect("single or xprv without wildcards");
102                        Ok(bare::tweak_key(secp, spk, &pk))
103                    }
104                }
105            },
106        }
107    }
108}
109
110/// A confidential descriptor
111#[derive(Clone, PartialEq, Eq, Debug)]
112pub struct Descriptor<Pk: MiniscriptKey, T: Extension = CovenantExt<CovExtArgs>> {
113    /// The blinding key
114    pub key: Key,
115    /// The script descriptor
116    pub descriptor: crate::Descriptor<Pk, T>,
117}
118
119impl<Pk: MiniscriptKey, T: Extension> Descriptor<Pk, T> {
120    /// Sanity checks for the underlying descriptor.
121    pub fn sanity_check(&self) -> Result<(), Error> {
122        self.descriptor.sanity_check()?;
123        Ok(())
124    }
125}
126
127impl<T: Extension + ParseableExt> Descriptor<DescriptorPublicKey, T> {
128    /// Replaces all wildcards (i.e. `/*`) in the descriptor and the descriptor blinding key
129    /// with a particular derivation index, turning it into a *definite* descriptor.
130    ///
131    /// # Errors
132    /// - If index ≥ 2^31
133    pub fn at_derivation_index(&self, index: u32) -> Result<Descriptor<DefiniteDescriptorKey, T>, ConversionError> {
134        let definite_key = match self.key.clone() {
135            Key::Slip77(k) => Key::Slip77(k),
136            Key::Bare(k) => Key::Bare(k.at_derivation_index(index)?.into_descriptor_public_key()),
137            Key::View(k) => Key::View(match k {
138                // Consider implementing DescriptorSecretKey::at_derivation_index
139                DescriptorSecretKey::Single(_) => k,
140                DescriptorSecretKey::XPrv(xprv) => {
141                    let derivation_path = match xprv.wildcard {
142                        Wildcard::None => xprv.derivation_path,
143                        Wildcard::Unhardened => xprv.derivation_path.into_child(
144                            bip32::ChildNumber::from_normal_idx(index)
145                                .ok()
146                                .ok_or(ConversionError::HardenedChild)?,
147                        ),
148                        Wildcard::Hardened => xprv.derivation_path.into_child(
149                            bip32::ChildNumber::from_hardened_idx(index)
150                                .ok()
151                                .ok_or(ConversionError::HardenedChild)?,
152                        ),
153                    };
154                    DescriptorSecretKey::XPrv(DescriptorXKey {
155                        origin: xprv.origin,
156                        xkey: xprv.xkey,
157                        derivation_path,
158                        wildcard: Wildcard::None,
159                    })
160                },
161                DescriptorSecretKey::MultiXPrv(_) => return Err(ConversionError::MultiKey),
162            }),
163        };
164        let definite_descriptor = self.descriptor.at_derivation_index(index)?;
165        Ok(Descriptor{
166            key: definite_key,
167            descriptor: definite_descriptor,
168        })
169    }
170}
171
172impl<Pk: MiniscriptKey, Ext: Extension> Descriptor<Pk, Ext> {
173    /// Converts a descriptor using one kind of keys to another kind of key.
174    ///
175    /// The blinding [`Key`] is preserved as-is; only the inner script descriptor's
176    /// keys are translated via the supplied [`Translator`].
177    pub fn translate_pk<Q, E, Tr>(&self, t: &mut Tr) -> Result<Descriptor<Q, Ext>, E>
178    where
179        Q: MiniscriptKey,
180        Tr: Translator<Pk, Q, E>,
181    {
182        Ok(Descriptor {
183            key: self.key.clone(),
184            descriptor: self.descriptor.translate_pk(t)?,
185        })
186    }
187}
188
189impl<Pk: MiniscriptKey + ToPublicKey, T: Extension + ParseableExt> Descriptor<Pk, T> {
190    /// Obtains the unblinded address for this descriptor.
191    pub fn unconfidential_address(
192        &self,
193        params: &'static elements::AddressParams,
194    ) -> Result<elements::Address, Error> {
195        self.descriptor.address(params)
196    }
197
198    /// Obtains the blinded address for this descriptor.
199    pub fn address<C: secp256k1_zkp::Signing + secp256k1_zkp::Verification>(
200        &self,
201        secp: &secp256k1_zkp::Secp256k1<C>,
202        params: &'static elements::AddressParams,
203    ) -> Result<elements::Address, Error> {
204        let spk = self.descriptor.script_pubkey();
205        self.descriptor
206            .blinded_address(self.key.to_public_key(secp, &spk)?, params)
207    }
208}
209
210impl<Pk: MiniscriptKey, T: Extension> fmt::Display for Descriptor<Pk, T> {
211    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
212        use fmt::Write;
213        let mut wrapped_f = checksum::Formatter::new(f);
214        write!(wrapped_f, "ct({},{:#})", self.key, self.descriptor)?;
215        wrapped_f.write_checksum_if_not_alt()
216    }
217}
218
219impl_from_str!(
220    ;T; Extension,
221    Descriptor<Pk, T>,
222    type Err = Error;,
223    fn from_str(s: &str) -> Result<Descriptor<Pk, T>, Error> {
224        let desc_str = verify_checksum(s)?;
225        let top = expression::Tree::from_str(desc_str)?;
226
227        if top.name != "ct" {
228            return Err(Error::BadDescriptor(String::from(
229                "Not a CT Descriptor",
230            )));
231        }
232        if top.args.len() != 2 {
233            return Err(Error::BadDescriptor(
234                format!("CT descriptor had {} arguments rather than 2", top.args.len())
235            ));
236        }
237
238        let keyexpr = &top.args[0];
239        Ok(Descriptor {
240            key: match (keyexpr.name, keyexpr.args.len()) {
241                ("elip151", 0) => {
242                    let d = crate::Descriptor::<DescriptorPublicKey>::from_tree(&top.args[1])?;
243                    Key::from_elip151(&d)?
244                }
245                ("slip77", 1) => Key::Slip77(expression::terminal(&keyexpr.args[0], slip77::MasterBlindingKey::from_str)?),
246                ("slip77", _) => return Err(Error::BadDescriptor(
247                    "slip77() must have exactly one argument".to_owned()
248                )),
249                _ => expression::terminal(keyexpr, |s: &str| DescriptorSecretKey::from_str_inner(s, true)).map(Key::View)
250                .or_else(|_| expression::terminal(keyexpr, DescriptorPublicKey::from_str).map(Key::Bare))?,
251            },
252            descriptor: crate::Descriptor::from_tree(&top.args[1])?,
253        })
254    }
255);
256
257#[cfg(test)]
258mod tests {
259    use std::str::FromStr;
260
261    use elements::Address;
262
263    use super::*;
264    use crate::{DefiniteDescriptorKey, NoExt};
265
266    #[test]
267    fn bare_addr_to_confidential() {
268        let secp = secp256k1_zkp::Secp256k1::new();
269
270        // taken from libwally src/test/test_confidential_addr.py
271        let mut addr = Address::from_str("Q7qcjTLsYGoMA7TjUp97R6E6AM5VKqBik6").unwrap();
272        let key = Key::Bare(
273            DescriptorPublicKey::from_str(
274                "02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623",
275            )
276            .unwrap(),
277        );
278        addr.blinding_pubkey = Some(key.to_public_key(&secp, &addr.script_pubkey()).unwrap());
279        assert_eq!(
280            addr.to_string(),
281            "VTpt7krqRQPJwqe3XQXPg2cVdEKYVFbuprTr7es7pNRMe8mndnq2iYWddxJWYowhLAwoDF8QrZ1v2EXv"
282        );
283    }
284
285    struct ConfidentialTest {
286        key: Key,
287        descriptor: crate::Descriptor<DefiniteDescriptorKey, NoExt>,
288        descriptor_str: String,
289        conf_addr: &'static str,
290        unconf_addr: &'static str,
291    }
292
293    impl ConfidentialTest {
294        fn check<C: secp256k1_zkp::Signing + secp256k1_zkp::Verification>(
295            &self,
296            secp: &secp256k1_zkp::Secp256k1<C>,
297        ) {
298            let desc: Descriptor<DefiniteDescriptorKey, NoExt> = Descriptor {
299                key: self.key.clone(),
300                descriptor: self.descriptor.clone(),
301            };
302            assert_eq!(self.descriptor_str, desc.to_string());
303            assert_eq!(desc, Descriptor::from_str(&desc.to_string()).unwrap());
304            assert_eq!(
305                self.conf_addr,
306                desc.address(secp, &elements::AddressParams::LIQUID)
307                    .unwrap()
308                    .to_string(),
309            );
310            assert_eq!(
311                self.unconf_addr,
312                desc.unconfidential_address(&elements::AddressParams::LIQUID)
313                    .unwrap()
314                    .to_string(),
315            );
316        }
317
318        #[allow(dead_code)]
319        fn output_elip_test_vector(&self, index: usize) {
320            println!(
321                "* Valid Descriptor {}: <code>{}</code>",
322                index, self.descriptor_str
323            );
324            match self.key {
325                Key::Bare(ref pk) => println!("** Blinding public key: <code>{}</code>", pk),
326                Key::View(ref sk) => println!("** Blinding private key: <code>{}</code>", sk),
327                Key::Slip77(mbk) => println!("** SLIP77 master blinding key: <code>{}</code>", mbk),
328            }
329            println!("** Confidential address: <code>{}</code>", self.conf_addr);
330            println!(
331                "** Unconfidential address: <code>{}</code>",
332                self.unconf_addr
333            );
334            println!();
335        }
336    }
337
338    #[test]
339    fn confidential_descriptor() {
340        let secp = secp256k1_zkp::Secp256k1::new();
341
342        // CT key used for bare keys
343        let ct_key = DescriptorPublicKey::from_str(
344            "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL",
345        )
346        .unwrap();
347        // Auxiliary key to create scriptpubkeys from
348        let spk_key = DefiniteDescriptorKey::from_str(
349            "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
350        )
351        .unwrap();
352
353        let single_ct_key = DescriptorPublicKey::from_str(
354            "02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623",
355        )
356        .unwrap();
357        let single_spk_key = DefiniteDescriptorKey::from_str(
358            "03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4",
359        )
360        .unwrap();
361
362        let tests = vec![
363            // Bare key, P2PKH
364            ConfidentialTest {
365                key: Key::Bare(ct_key.clone()),
366                descriptor: crate::Descriptor::new_pkh(spk_key.clone()),
367                descriptor_str: format!("ct({},elpkh({}))#y0lg3d5y", ct_key, spk_key),
368                conf_addr: "VTpvZZYdbhbyVF3Wa99eMjgXhfvu4LS26dR2FwMfNXq7FDX73HZEsZr3VvgH9EDgQnYK7sP6ACKSuMGw",
369                unconf_addr: "Q5WHLVd78iAspUNvzuULvi2F8u693pzAqe",
370            },
371            // Bare key, P2WPKH
372            ConfidentialTest {
373                key: Key::Bare(ct_key.clone()),
374                descriptor: crate::Descriptor::new_wpkh(spk_key.clone()).unwrap(),
375                descriptor_str: format!("ct({},elwpkh({}))#kt4e25qt", ct_key, spk_key),
376                conf_addr: "lq1qqg5s7xj7upzl7h4q2k2wj4vq63nvaktn0egqu09nqcr6d44p4evaqknpl78t02k2xqgdh9ltmfmpy9ssk7qfvghdsfr4mvr9c",
377                unconf_addr: "ex1qtfsllr4h4t9rqyxmjl4a5asjzcgt0qyktcafre",
378            },
379            // Bare key, P2SH-WPKH
380            ConfidentialTest {
381                key: Key::Bare(ct_key.clone()),
382                descriptor: crate::Descriptor::new_sh_wpkh(spk_key.clone()).unwrap(),
383                descriptor_str: format!("ct({},elsh(wpkh({})))#xg9r4jej", ct_key, spk_key),
384                conf_addr: "VJL8znN4XjXEUKzDaYsqdzRASGLY2KHxC4N6g5b5QvrNjXfeKp83Ci9AW2a8QzbZjpEffoy4PEywpLAZ",
385                unconf_addr: "Gq6kpy2HiNgsyQVpBsuBKAPRFiir23qKro",
386            },
387            // Bare key, P2TR
388            ConfidentialTest {
389                key: Key::Bare(ct_key.clone()),
390                descriptor: crate::Descriptor::new_tr(spk_key.clone(), None).unwrap(),
391                descriptor_str: format!("ct({},eltr({}))#c0pjjxyw", ct_key, spk_key),
392                conf_addr: "lq1pq0nsl8du3gsuk7r90sgm78259mmv6mt9d4yvj30zr3u052ufs5meuc2tuvwx7k7g9kvhhpux07vqpm3qjj8uwdj94650265ustv0xy8zrdxdfgp8g9pl",
393                unconf_addr: "ex1pv997x8r0t0yzmxtms7r8lxqqacsffr78xez6a284d2wg9k8nzr3qxa9kvf",
394            },
395            // SLIP77, P2PKH
396            ConfidentialTest {
397                key: Key::Slip77(slip77::MasterBlindingKey::from_seed(b"abcd")),
398                descriptor: crate::Descriptor::new_pkh(spk_key.clone()),
399                descriptor_str: format!("ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),elpkh({}))#hw2glz99", spk_key),
400                conf_addr: "VTq585ahVjWarEwg2nKQ9yYirmYs5F5j74CeYYA9cq1EZD9obm7hwpx6xqq3J1AY9YRaSavEMzYfr6t7",
401                unconf_addr: "Q5WHLVd78iAspUNvzuULvi2F8u693pzAqe",
402            },
403            // SLIP77, P2WPKH
404            ConfidentialTest {
405                key: Key::Slip77(slip77::MasterBlindingKey::from_seed(b"abcd")),
406                descriptor: crate::Descriptor::new_wpkh(spk_key.clone()).unwrap(),
407                descriptor_str: format!("ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),elwpkh({}))#545pl285", spk_key),
408                conf_addr: "lq1qqdx5wnttttzulcs6ujlg9pfts6mp3r4sdwg5ekdej566n5wxzk88vknpl78t02k2xqgdh9ltmfmpy9ssk7qfvr33xa22hpw23",
409                unconf_addr: "ex1qtfsllr4h4t9rqyxmjl4a5asjzcgt0qyktcafre",
410            },
411            // SLIP77, P2SH
412            ConfidentialTest {
413                key: Key::Slip77(slip77::MasterBlindingKey::from_seed(b"abcd")),
414                descriptor: crate::Descriptor::new_sh_wpkh(spk_key.clone()).unwrap(),
415                descriptor_str: format!("ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),elsh(wpkh({})))#m30vswxr", spk_key),
416                conf_addr: "VJLFGQ17aGa3WSVEVyxzDktD9SFixJjfSmqVq8xaWmR9X6gFbiF95KFwKA41PBhu3jNTxJFKTUphHL8J",
417                unconf_addr: "Gq6kpy2HiNgsyQVpBsuBKAPRFiir23qKro",
418            },
419            // SLIP77, P2TR
420            ConfidentialTest {
421                key: Key::Slip77(slip77::MasterBlindingKey::from_seed(b"abcd")),
422                descriptor: crate::Descriptor::new_tr(spk_key.clone(), None).unwrap(),
423                descriptor_str: format!("ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),eltr({}))#n3v4t5cs", spk_key),
424                conf_addr: "lq1pq26fndnz8ef6umlz6e2755sm6j5jwxv3tdt2295mr4mx6ux0uf8vcc2tuvwx7k7g9kvhhpux07vqpm3qjj8uwdj94650265ustv0xy8z8wfacw9e5a5t",
425                unconf_addr: "ex1pv997x8r0t0yzmxtms7r8lxqqacsffr78xez6a284d2wg9k8nzr3qxa9kvf",
426            },
427            // Bare, P2WPKH
428            ConfidentialTest {
429                key: Key::Bare(single_ct_key.clone()),
430                descriptor: crate::Descriptor::new_wpkh(single_spk_key).unwrap(),
431                descriptor_str: "ct(02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623,elwpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4))#h5e0p6m9".to_string(),
432                conf_addr: "lq1qq0r6pegudzm0tzpszelc34qjln4fdxawgwmgnza63wwpzdy6jrm0grmqvvk2ce5ksnxcs9ecgtnryt7xg3406y5ccl0k2glns",
433                unconf_addr: "ex1qpasxxt9vv6tgfnvgzuuy9e3j9lryg6hawrval4",
434            },
435            // Bare, P2WPKH xpub
436            ConfidentialTest {
437                key: Key::Bare(single_ct_key),
438                descriptor: crate::Descriptor::new_wpkh(spk_key.clone()).unwrap(),
439                descriptor_str: format!("ct(02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623,elwpkh({}))#x6sc2de2", spk_key),
440                conf_addr: "lq1qqwkeuelr466ue5u8e0lz3a27q4yk93qnupry5h3q4h9pjpf8vrrzvknpl78t02k2xqgdh9ltmfmpy9ssk7qfvwt93dvuvssha",
441                unconf_addr: "ex1qtfsllr4h4t9rqyxmjl4a5asjzcgt0qyktcafre",
442            },
443        ];
444
445        for test in &tests {
446            test.check(&secp);
447        }
448        // Uncomment to regenerate test vectors; to see the output, run
449        // cargo test confidential::tests::confidential_descriptor -- --nocapture
450        /*
451        for (n, test) in tests.iter().enumerate() {
452            test.output_elip_test_vector(n + 1);
453        }
454        */
455    }
456
457    #[test]
458    fn confidential_descriptor_invalid() {
459        let bad_strs = vec![
460            (
461                "ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),elsh(wpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4)))#xxxxxxxx",
462                "Invalid descriptor: Invalid checksum 'xxxxxxxx', expected 'qgjmm4as'",
463            ),
464            (
465                "ct(slip77(b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04,b2396b3ee20509cdb64fe24180a14a72dbd671728eaa49bac69d2bdecb5f5a04),elsh(wpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4)))#qs64ccxw",
466                "Invalid descriptor: slip77() must have exactly one argument",
467            ),
468            (
469                "ct(slip77,elsh(wpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4)))#8p3zmumf",
470                "Invalid descriptor: slip77() must have exactly one argument",
471            ),
472            (
473                "ct(elsh(wpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4)))#u9cwz9f3",
474                "Invalid descriptor: CT descriptor had 1 arguments rather than 2",
475            ),
476            (
477                "ct(02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623,02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623,elwpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4))#cnsp2qsc",
478                "Invalid descriptor: CT descriptor had 3 arguments rather than 2",
479            ),
480            (
481                "ct(pk(02dce16018bbbb8e36de7b394df5b5166e9adb7498be7d881a85a09aeecf76b623),elwpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4))#nvax6rau",
482                "unexpected «pk»",
483            ),
484            (
485                "ct(L3jXxwef3fpB7hcrFozcWgHeJCPSAFiZ1Ji2YJMPxceaGvy3PC1q,elwpkh(03774eec7a3d550d18e9f89414152025b3b0ad6a342b19481f702d843cff06dfc4))#gcy6hcfz",
486                "unexpected «Key too short (<66 char), doesn't match any format»",
487            ),
488        ];
489
490        /*
491        for (n, bad_str) in bad_strs.iter().enumerate() {
492            println!("* Invalid Descriptor {}", n + 1);
493            println!("** <code>{}</code>", bad_str.0);
494            println!("** Reason:");
495        }
496        */
497
498        for bad_str in bad_strs {
499            let err = Descriptor::<DefiniteDescriptorKey>::from_str(bad_str.0).unwrap_err();
500            assert_eq!(bad_str.1, err.to_string());
501        }
502    }
503
504    #[test]
505    fn view_descriptor() {
506        let secp = secp256k1_zkp::Secp256k1::new();
507
508        let view_key = DescriptorSecretKey::from_str(
509            "xprv9s21ZrQH143K28NgQ7bHCF61hy9VzwquBZvpzTwXLsbmQLRJ6iV9k2hUBRt5qzmBaSpeMj5LdcsHaXJvM7iFEivPryRcL8irN7Na9p65UUb",
510        ).unwrap();
511        let ct_key = view_key.to_public(&secp).unwrap();
512        let spk_key = DefiniteDescriptorKey::from_str(
513            "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
514        )
515        .unwrap();
516
517        // View key, P2PKH
518        let test = ConfidentialTest {
519            key: Key::View(view_key.clone()),
520            descriptor: crate::Descriptor::new_wpkh(spk_key.clone()).unwrap(),
521            descriptor_str: format!("ct({},elwpkh({}))#j95xktq7", view_key, spk_key),
522            conf_addr: "lq1qq2r0pdvcknjpwev96qu9975alzqs78cvsut5ju82t7tv8d645dgmwknpl78t02k2xqgdh9ltmfmpy9ssk7qfvtk83xqzx62q4",
523            unconf_addr: "ex1qtfsllr4h4t9rqyxmjl4a5asjzcgt0qyktcafre",
524        };
525        test.check(&secp);
526
527        // View key converted to Bare (note that addresses are the same)
528        let test = ConfidentialTest {
529            key: Key::Bare(ct_key.clone()),
530            descriptor: crate::Descriptor::new_wpkh(spk_key.clone()).unwrap(),
531            descriptor_str: format!("ct({},elwpkh({}))#elmfpmp9", ct_key, spk_key),
532            conf_addr: "lq1qq2r0pdvcknjpwev96qu9975alzqs78cvsut5ju82t7tv8d645dgmwknpl78t02k2xqgdh9ltmfmpy9ssk7qfvtk83xqzx62q4",
533            unconf_addr: "ex1qtfsllr4h4t9rqyxmjl4a5asjzcgt0qyktcafre",
534        };
535        test.check(&secp);
536    }
537
538    #[test]
539    fn view_single_key_descriptor() {
540        let secp = secp256k1_zkp::Secp256k1::new();
541        let view_key = "c25deb86fa11e49d651d7eae27c220ef930fbd86ea023eebfa73e54875647963";
542        let ct_key = "0286fc9a38e765d955e9b0bcc18fa9ae81b0c893e2dd1ef5542a9c73780a086b90";
543        let pk = "021a8fb6bd5a653b021b98a2a785725b8ddacfe3687bc043aa7f4d25d3a48d40b5";
544        let addr_conf = "lq1qq265u4g3k3m3qpyxjwpdrtnm293wuxgvs9xzmzcs2ck0mv5rx23w4d7xfsednsmmxrszfe7s9rs0c6cvf3dfytxax3utlmm46";
545        let addr_unconf = "ex1qklrycvkecdanpcpyulgz3c8udvxyck5jvsv4j5";
546
547        for desc_str in [
548            format!("ct({view_key},elwpkh({pk}))#c2kx9zll"),
549            format!("ct({ct_key},elwpkh({pk}))#m5mvyh29"),
550        ] {
551            let desc = Descriptor::<DefiniteDescriptorKey>::from_str(&desc_str).unwrap();
552            assert_eq!(desc.to_string(), desc_str);
553            assert_eq!(addr_conf, &desc.address(&secp, &elements::AddressParams::LIQUID).unwrap().to_string());
554            assert_eq!(addr_unconf, &desc.unconfidential_address(&elements::AddressParams::LIQUID).unwrap().to_string());
555        }
556    }
557
558    #[test]
559    fn view_xonly_pubkey_descriptor() {
560        // View keys are 64 hex chars, but also x-only public keys are 64 hex chars
561        let view_key = "ab16855a17319477d4283fe5c29cc7d047f81e8ffb199e20d9be1bc31a751c4c";
562        // This view key can also be interpreted as a public key
563        let _public_key = DescriptorPublicKey::from_str(view_key).unwrap();
564        // But since compressed public keys are disallowed, it must be interpreted as a view key
565        let pk = "021a8fb6bd5a653b021b98a2a785725b8ddacfe3687bc043aa7f4d25d3a48d40b5";
566        let desc_str = format!("ct({view_key},elwpkh({pk}))#n9uc7tzt");
567        let desc = Descriptor::<DefiniteDescriptorKey>::from_str(&desc_str).unwrap();
568        assert!(matches!(desc.key, Key::View(_)));
569    }
570
571    // A blinding key with a hardened derivation step cannot be derived from an xpub. This
572    // must be reported as an error rather than panicking in `ToPublicKey::to_public_key`,
573    // which unwraps the `ConversionError` returned by `derive_public_key`.
574    #[test]
575    fn descriptor_hardened_blinding_key() {
576        let secp = secp256k1_zkp::Secp256k1::new();
577        let params = &elements::AddressParams::LIQUID;
578
579        let xpub = "xpub661MyMwAqRbcEcT9W98HZP2kFzyzQQZkYnrRnrM8uD8kH8kSeFoQHq1x2iihLgC6PXGy5LrjCL66uSNhJ8pwjfx2rMUTLWuRMns2EG9xnjs";
580
581        let desc: Descriptor<DefiniteDescriptorKey, NoExt> = Descriptor {
582            key: Key::Bare(DescriptorPublicKey::from_str(&format!("{}/0h", xpub)).unwrap()),
583            descriptor: crate::Descriptor::new_wpkh(
584                DefiniteDescriptorKey::from_str(xpub).unwrap(),
585            )
586            .unwrap(),
587        };
588
589        assert_eq!(
590            desc.address(&secp, params).unwrap_err(),
591            Error::Conversion(ConversionError::HardenedChild)
592        );
593    }
594
595    // Same case, reached through `at_derivation_index` on a hardened wildcard blinding
596    // key: the wildcard is replaced by a hardened child, which the xpub cannot derive.
597    #[test]
598    fn descriptor_hardened_wildcard_blinding_key() {
599        let secp = secp256k1_zkp::Secp256k1::new();
600        let params = &elements::AddressParams::LIQUID;
601
602        let xpub = "xpub661MyMwAqRbcEcT9W98HZP2kFzyzQQZkYnrRnrM8uD8kH8kSeFoQHq1x2iihLgC6PXGy5LrjCL66uSNhJ8pwjfx2rMUTLWuRMns2EG9xnjs";
603        let desc_str = format!("ct({}/*h,elwpkh({}/*))", xpub, xpub);
604
605        let desc = Descriptor::<DescriptorPublicKey, NoExt>::from_str(&desc_str).unwrap();
606        let definite_desc = desc.at_derivation_index(1).unwrap();
607
608        assert_eq!(
609            definite_desc.address(&secp, params).unwrap_err(),
610            Error::Conversion(ConversionError::HardenedChild)
611        );
612    }
613
614    #[test]
615    fn descriptor_wildcard() {
616        let secp = secp256k1_zkp::Secp256k1::new();
617        let params = &elements::AddressParams::LIQUID;
618
619        let xprv = "xprv9s21ZrQH143K28NgQ7bHCF61hy9VzwquBZvpzTwXLsbmQLRJ6iV9k2hUBRt5qzmBaSpeMj5LdcsHaXJvM7iFEivPryRcL8irN7Na9p65UUb";
620        let xpub = "xpub661MyMwAqRbcEcT9W98HZP2kFzyzQQZkYnrRnrM8uD8kH8kSeFoQHq1x2iihLgC6PXGy5LrjCL66uSNhJ8pwjfx2rMUTLWuRMns2EG9xnjs";
621        let desc_view_str = format!("ct({}/*,elwpkh({}/*))#wk8ltq6h", xprv, xpub);
622        let desc_bare_str = format!("ct({}/*,elwpkh({}/*))#zzac2dpf", xpub, xpub);
623        let index = 1;
624        let conf_addr = "lq1qqf6690fpw2y00hv5a84zsydjgztg2089d5xnll4k4cstzn63uvgudd907qpvlvvwd5ym9gx7j0v46elf23kfxhmutc58z4k24";
625        let unconf_addr = "ex1qkjhlqqk0kx8x6zdj5r0f8k2avl54gmynyjcw4v";
626
627        let desc_view = Descriptor::<DescriptorPublicKey>::from_str(&desc_view_str).unwrap();
628        let desc_bare = Descriptor::<DescriptorPublicKey>::from_str(&desc_bare_str).unwrap();
629        let definite_desc_view = desc_view.at_derivation_index(index).unwrap();
630        let definite_desc_bare = desc_bare.at_derivation_index(index).unwrap();
631        assert_eq!(definite_desc_view.address(&secp, params).unwrap().to_string(), conf_addr.to_string());
632        assert_eq!(definite_desc_bare.address(&secp, params).unwrap().to_string(), conf_addr.to_string());
633        assert_eq!(definite_desc_view.unconfidential_address(params).unwrap().to_string(), unconf_addr.to_string());
634        assert_eq!(definite_desc_bare.unconfidential_address(params).unwrap().to_string(), unconf_addr.to_string());
635
636        // It's not possible to get an address if the blinding key has a wildcard,
637        // because the descriptor blinding key is not *definite*,
638        // but we can't enforce this with the Descriptor generic.
639        let desc_view_str = format!("ct({}/*,elwpkh({}))#ls6mx2ac", xprv, xpub);
640        let desc_view = Descriptor::<DefiniteDescriptorKey>::from_str(&desc_view_str).unwrap();
641        assert_eq!(desc_view.address(&secp, params).unwrap_err(), Error::Unexpected("wildcard blinding key".into()));
642
643        let desc_bare_str = format!("ct({}/*,elwpkh({}))#czkz0hwn", xpub, xpub);
644        let desc_bare = Descriptor::<DefiniteDescriptorKey>::from_str(&desc_bare_str).unwrap();
645        assert_eq!(desc_bare.address(&secp, params).unwrap_err(), Error::Unexpected("wildcard blinding key".into()));
646    }
647}
elements_miniscript/confidential/mod.rs

elements_miniscript/confidential/
mod.rs
