descriptors: add NoKey type used in parsing

Author: dr-orlovsky

descriptors/src/compiler/compile.rs

@@ -24,11 +24,16 @@
 
 use core::fmt::Display;
 use core::str::FromStr;
+use std::collections::BTreeSet;
 use std::fmt::Debug;
+use std::iter;
 
 use amplify::confinement::ConfinedVec;
 use amplify::num::u4;
-use derive::{DeriveCompr, DeriveLegacy, DeriveSet, DeriveXOnly};
+use derive::{
+    Derive, DeriveCompr, DeriveKey, DeriveLegacy, DeriveSet, DeriveXOnly, Keychain, NormalIndex,
+    XkeyDecodeError, XpubAccount,
+};
 use indexmap::{indexmap, IndexMap};
 
 use crate::compiler::{DescrAst, DescrParseError, ScriptExpr};
@@ -61,6 +66,41 @@ impl DescrExpr {
     }
 }
 
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Display)]
+#[display("")]
+pub struct NoKey;
+impl DeriveSet for NoKey {
+    type Legacy = Self;
+    type Compr = Self;
+    type XOnly = Self;
+}
+impl<K> Derive<K> for NoKey {
+    fn default_keychain(&self) -> Keychain {
+        unreachable!();
+    }
+    fn keychains(&self) -> BTreeSet<Keychain> {
+        unreachable!();
+    }
+    fn derive(
+        &self,
+        _keychain: impl Into<Keychain>,
+        _index: impl Into<NormalIndex>,
+    ) -> impl Iterator<Item = K> {
+        iter::empty()
+    }
+}
+impl<K> DeriveKey<K> for NoKey {
+    fn xpub_spec(&self) -> &XpubAccount {
+        unreachable!();
+    }
+}
+impl FromStr for NoKey {
+    type Err = XkeyDecodeError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Err(XkeyDecodeError::WrongExtendedKeyLength(s.len()))
+    }
+}
+
 pub fn check_forms<'s, K: Display + FromStr>(
     ast: ScriptExpr<'s, K>,
     ident: &str,

descriptors/src/compiler/mod.rs

@@ -26,5 +26,6 @@ mod lexer;
 mod parser;
 mod compile;
 
+pub use compile::{check_forms, NoKey};
 pub use lexer::{parse_descr_str, DescrLexerError, DescrToken};
 pub use parser::{DescrAst, DescrParseError, ScriptExpr, TreeExpr};

descriptors/src/compiler/parser.rs

@@ -34,7 +34,7 @@ use super::{parse_descr_str, DescrLexerError, DescrToken};
 impl<'s, K: Display + FromStr> ScriptExpr<'s, K>
 where K::Err: core::error::Error
 {
-    pub(super) fn from_str(s: &'s str) -> Result<Self, DescrParseError<K::Err>> {
+    pub fn from_str(s: &'s str) -> Result<Self, DescrParseError<K::Err>> {
         let tokens = parse_descr_str(s)?;
         Self::parse_tokens(s, &tokens)
     }