miniscript: Descriptor field accessors

Author: loop-ghost5rty

src/runtime/mod.rs

@@ -252,6 +252,7 @@ impl FieldAccess for Value {
             Value::Array(x) => x.get_field(field),
             Value::Psbt(x) => x.get_field(field),
             Value::Transaction(x) => x.get_field(field),
+            Value::Descriptor(x) => x.get_field(field),
             Value::TapInfo(x) => x.get_field(field),
             _ => None,
         }

src/stdlib/miniscript.rs

@@ -1,12 +1,12 @@
 use std::convert::{TryFrom, TryInto};
 use std::{fmt, sync::Arc};
 
-use miniscript::descriptor::{ShInner, WshInner};
+use miniscript::descriptor::{DescriptorType, ShInner, WshInner};
 use miniscript::{ScriptContext, Threshold};
 
 use crate::runtime::scope::{Mutable, ScopeRef};
-use crate::runtime::{Array, Error, Evaluate, ExprRepr, Result, Value};
-use crate::stdlib::btc::WshScript;
+use crate::runtime::{Array, Error, Evaluate, ExprRepr, FieldAccess, Result, Value};
+use crate::stdlib::{btc::WshScript, taproot::tap_scripts_to_val};
 use crate::util::{DescriptorExt, DescriptorSecretKeyExt, MiniscriptExt};
 use crate::{ast, DescriptorDpk as Descriptor, MiniscriptDpk as Miniscript, PolicyDpk as Policy};
 
@@ -245,6 +245,39 @@ pub mod fns {
     }
 }
 
+// Descriptor fields accessors
+impl FieldAccess for Descriptor {
+    fn get_field(self, field: &Value) -> Option<Value> {
+        Some(match field.as_str()? {
+            "descriptor_type" => self.desc_type().into(),
+            "max_weight" => self.max_weight_to_satisfy().ok()?.into(),
+            "singles" => self.into_single_descriptors().ok()?.into(),
+            "is_safe" => self.sanity_check().is_ok().into(),
+            "is_multipath" => self.is_multipath().into(),
+            "is_wildcard" => self.has_wildcard().into(),
+            "is_definite" => (!self.has_wildcard() && !self.is_multipath()).into(),
+
+            // Only available for definite descriptors (non-multi-path and no underived wildcards)
+            "script_pubkey" | "scriptPubKey" => self.to_script_pubkey().ok()?.into(),
+            "explicit_script" | "explicitScript" => self.to_explicit_script().ok()?.into(),
+            // Only available for definite segwit descriptors
+            "witness_program" => self.witness_program().ok()??.into(),
+
+            // Only available for taproot descriptors (similar fields mirrored on TaprootSpendInfo)
+            "internal_key" => self.tr()?.internal_key().clone().into(),
+            // Only available for definite taproot descriptors
+            "merkle_root" => self.tap_info().ok()??.merkle_root()?.into(),
+            "output_key" => self.tap_info().ok()??.output_key().into(),
+            "output_key_parity" => self.tap_info().ok()??.output_key_parity().into(),
+            "scripts" => tap_scripts_to_val(&*self.tap_info().ok()??),
+            _ => {
+                return None;
+            }
+            // TODO address_type
+        })
+    }
+}
+
 fn into_policies(values: Vec<Value>) -> Result<Vec<Arc<Policy>>> {
     values
         .into_iter()
@@ -267,6 +300,8 @@ fn into_prob_policies(values: Vec<Value>) -> Result<Vec<(usize, Arc<Policy>)>> {
         .collect()
 }
 
+impl_simple_to_value!(DescriptorType, t, format!("{:?}", t));
+
 // Convert from Value to Miniscript types
 
 impl_simple_into_variant!(Descriptor, Descriptor, into_descriptor, NotDescriptor);

src/util.rs

@@ -1,12 +1,14 @@
 use std::fmt;
 use std::marker::PhantomData;
+use std::sync::Arc;
 
 use bitcoin::bip32::{self, ChildNumber, DerivationPath, IntoDerivationPath};
 use bitcoin::hashes::{sha256, Hash};
 use bitcoin::hex::DisplayHex;
-use bitcoin::{psbt, secp256k1, taproot, PublicKey};
+use bitcoin::taproot::TaprootSpendInfo;
+use bitcoin::{psbt, secp256k1, PublicKey};
 use miniscript::descriptor::{
-    DerivPaths, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey, Wildcard,
+    self, DerivPaths, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey, Wildcard,
 };
 use miniscript::{
     bitcoin, DefiniteDescriptorKey, Descriptor, ForEachKey, MiniscriptKey, TranslatePk, Translator,
@@ -26,18 +28,18 @@ pub trait TapInfoExt {
         bitcoin::ScriptBuf::new_witness_program(&self.witness_program())
     }
 }
-impl TapInfoExt for taproot::TaprootSpendInfo {
+impl TapInfoExt for TaprootSpendInfo {
     fn witness_program(&self) -> bitcoin::WitnessProgram {
         bitcoin::WitnessProgram::p2tr_tweaked(self.output_key())
     }
 }
 
 pub trait PsbtTaprootExt {
     /// Update PSBT fields using the TaprootSpendInfo
-    fn update_with_taproot(&mut self, tapinfo: &taproot::TaprootSpendInfo) -> Result<()>;
+    fn update_with_taproot(&mut self, tapinfo: &TaprootSpendInfo) -> Result<()>;
 }
 impl PsbtTaprootExt for psbt::Input {
-    fn update_with_taproot(&mut self, tapinfo: &taproot::TaprootSpendInfo) -> Result<()> {
+    fn update_with_taproot(&mut self, tapinfo: &TaprootSpendInfo) -> Result<()> {
         self.tap_merkle_root = tapinfo.merkle_root();
         self.tap_internal_key = Some(tapinfo.internal_key());
         self.tap_scripts = tapinfo
@@ -53,7 +55,7 @@ impl PsbtTaprootExt for psbt::Input {
     }
 }
 impl PsbtTaprootExt for psbt::Output {
-    fn update_with_taproot(&mut self, tapinfo: &taproot::TaprootSpendInfo) -> Result<()> {
+    fn update_with_taproot(&mut self, tapinfo: &TaprootSpendInfo) -> Result<()> {
         self.tap_internal_key = Some(tapinfo.internal_key());
         // `tap_key_origins` needs to be filled in manually
         // TODO autofill `tap_tree`
@@ -101,6 +103,21 @@ pub trait DescriptorExt {
     fn to_address(&self, network: bitcoin::Network) -> Result<bitcoin::Address> {
         Ok(self.derive_definite()?.address(network)?)
     }
+
+    /// Get the witness program. Errors if the descriptor contains underived wildcards or multi-path derivations.
+    fn witness_program(&self) -> Result<Option<bitcoin::WitnessProgram>> {
+        Ok(self
+            .to_address(bitcoin::Network::Bitcoin)?
+            .witness_program())
+    }
+
+    /// Get the inner Tr, if it is a Tr descriptors
+    fn tr(&self) -> Option<&descriptor::Tr<DescriptorPublicKey>>;
+
+    /// Get a TaprootSpendInfo representation of this Tr descriptor
+    /// Returna an Ok(None) for non-Taproot descriptors, or an Err for Taproot
+    /// descriptors that are not definite (contain underived wildcards).
+    fn tap_info(&self) -> Result<Option<Arc<TaprootSpendInfo>>>;
 }
 
 impl DescriptorExt for Descriptor<DescriptorPublicKey> {
@@ -115,6 +132,24 @@ impl DescriptorExt for Descriptor<DescriptorPublicKey> {
         );
         Ok(self.at_derivation_index(0).expect("index is valid"))
     }
+
+    fn tr(&self) -> Option<&descriptor::Tr<DescriptorPublicKey>> {
+        match self {
+            Descriptor::Tr(tr) => Some(tr),
+            _ => None,
+        }
+    }
+
+    fn tap_info(&self) -> Result<Option<Arc<TaprootSpendInfo>>> {
+        if matches!(self, Descriptor::Tr(_)) {
+            Ok(match self.definite()? {
+                Descriptor::Tr(tr) => Some(tr.spend_info().clone()),
+                _ => unreachable!(),
+            })
+        } else {
+            Ok(None)
+        }
+    }
 }
 
 // BIP32 derivation utilities