descriptor: expose WalletPolicy template + key_info accessors

The internal `template: Descriptor<KeyExpression>` and
`key_info: Vec<DescriptorPublicKey>` fields are needed by external
consumers that need to inspect a `WalletPolicy`'s placeholder structure
without consuming the policy via `into_descriptor()`.

The motivating case is multipath-shared `@N` placeholders — e.g.
`sh(multi(1,@0/**,@0/<2;3>/*))`, where the same placeholder appears at
two distinct AST positions. After `into_descriptor()` the placeholder
labels are erased and the materialized descriptor surfaces two separate
keys; the template preserves placeholder identity via the public
`KeyExpression::index` field. Encoders and other consumers that need
the `(AST position) -> (placeholder index)` mapping have no public way
to obtain it today.

Adds two read accessors on `WalletPolicy`:

- `pub fn template(&self) -> &Descriptor<KeyExpression>` — yields the
  template; iterating gives `(AST position, KeyExpression)` pairs and
  the placeholder index is `ke.index.0`.
- `pub fn key_info(&self) -> &[DescriptorPublicKey]` — yields the
  key-information vector (symmetric with the existing
  `set_key_info(&mut self, ...)`).

Re-exports `KeyExpression` and `KeyIndex` at
`miniscript::descriptor::*` so the new return type is namable from
outside the crate, and adds rustdoc to `KeyIndex` and
`KeyExpression::is_disjoint` (now reachable via the re-exports;
required by the crate's missing_docs lint).

Internal `validate()` already uses `self.template.iter_pk()` the same
way external callers will; this commit just makes the access pattern
available on the public API.

Author: bg002h

src/descriptor/mod.rs

@@ -59,7 +59,7 @@ pub use self::key::{
     NonDefiniteKeyError, SinglePriv, SinglePub, SinglePubKey, Wildcard, XKeyNetwork,
 };
 pub use self::key_map::KeyMap;
-pub use self::wallet_policy::{WalletPolicy, WalletPolicyError};
+pub use self::wallet_policy::{KeyExpression, KeyIndex, WalletPolicy, WalletPolicyError};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

src/descriptor/wallet_policy/key_expression.rs

@@ -23,10 +23,13 @@ pub struct KeyExpression {
     pub wildcard: Wildcard,
 }
 
+/// The numeric index of a BIP-388 key placeholder (the `N` in `@N`).
 #[derive(Debug, Clone, Copy, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct KeyIndex(pub u32);
 
 impl KeyExpression {
+    /// Returns `true` if the multipath derivation suffixes of `self` and
+    /// `other` share no concrete child-derivation step.
     pub fn is_disjoint(&self, other: &KeyExpression) -> bool {
         let lhs: BTreeSet<_> = self
             .derivation_paths

src/descriptor/wallet_policy/mod.rs

@@ -9,7 +9,7 @@ use crate::{Descriptor, DescriptorPublicKey, String, Translator, Vec};
 
 mod key_expression;
 
-use key_expression::{KeyExpression, KeyIndex};
+pub use key_expression::{KeyExpression, KeyIndex};
 
 /// A wallet policy as described in BIP-388
 ///
@@ -108,6 +108,26 @@ impl WalletPolicy {
         WalletPolicy::from_descriptor_unchecked(descriptor).and_then(WalletPolicy::validate)
     }
 
+    /// Returns a reference to the template descriptor.
+    ///
+    /// The template uses [`KeyExpression`] in place of concrete keys.
+    /// Each `KeyExpression` carries a public `index` field identifying
+    /// which entry in the key-information vector is referenced at that
+    /// AST position. Callers needing the
+    /// `(AST position) -> (placeholder index)` mapping can iterate
+    /// `policy.template().iter_pk()` and read `ke.index.0` for each
+    /// yielded `KeyExpression`. For the resolved descriptor with
+    /// concrete keys, see [`Self::into_descriptor`] (consumes `self`).
+    pub fn template(&self) -> &Descriptor<KeyExpression> { &self.template }
+
+    /// Returns the key-information vector.
+    ///
+    /// `key_info()[i]` is the concrete key at AST position `i`,
+    /// matching the order of `self.template().iter_pk()`. The
+    /// corresponding placeholder index is
+    /// `self.template().iter_pk().nth(i).unwrap().index.0`.
+    pub fn key_info(&self) -> &[DescriptorPublicKey] { &self.key_info }
+
     /// Convert a `WalletPolicy` into a `Descriptor<DescriptorPublicKey>` using
     /// the underlying template and key information.
     pub fn into_descriptor(self) -> Result<Descriptor<DescriptorPublicKey>, WalletPolicyError> {
@@ -377,4 +397,56 @@ mod tests {
         template_only.set_key_info(&keys).unwrap();
         assert!(template_only.clone().into_descriptor().is_ok());
     }
+
+    #[test]
+    fn template_accessor_yields_keyexpressions_with_placeholder_indices() {
+        // Template-only parse: key_info is empty until set_key_info() is called.
+        let template_only =
+            WalletPolicy::from_str("wsh(sortedmulti(2,@0/**,@1/**))").expect("parse template");
+        let indices: Vec<u32> = template_only
+            .template()
+            .iter_pk()
+            .map(|ke| ke.index.0)
+            .collect();
+        assert_eq!(indices, vec![0, 1]);
+        assert!(template_only.key_info().is_empty());
+        assert_eq!(format!("{:#}", template_only.template()), "wsh(sortedmulti(2,@0/**,@1/**))");
+    }
+
+    #[test]
+    fn template_accessor_distinguishes_ast_position_from_placeholder_index() {
+        // Multipath-shared `@0`: the same placeholder appears at two distinct
+        // AST positions. After `into_descriptor()` the placeholder labels are
+        // erased — the materialized descriptor would surface two separate
+        // (but equal) keys. The template preserves the placeholder identity
+        // via `KeyExpression::index`.
+        let policy =
+            WalletPolicy::from_str("sh(multi(1,@0/**,@0/<2;3>/*))").expect("parse template");
+        let pairs: Vec<(usize, u32)> = policy
+            .template()
+            .iter_pk()
+            .enumerate()
+            .map(|(ast_pos, ke)| (ast_pos, ke.index.0))
+            .collect();
+        assert_eq!(pairs, vec![(0, 0), (1, 0)]);
+    }
+
+    #[test]
+    fn key_info_accessor_yields_concrete_keys_in_ast_order() {
+        // Full concrete-key parse populates key_info in AST order.
+        let descriptor_str = "wsh(sortedmulti(2,[6738736c/48'/0'/0'/2']xpub6FC1fXFP1GXLX5TKtcjHGT4q89SDRehkQLtbKJ2PzWcvbBHtyDsJPLtpLtkGqYNYZdVVAjRQ5kug9CsapegmmeRutpP7PW4u4wVF9JfkDhw/<0;1>/*,[b2b1f0cf/48'/0'/0'/2']xpub6EWhjpPa6FqrcaPBuGBZRJVjzGJ1ZsMygRF26RwN932Vfkn1gyCiTbECVitBjRCkexEvetLdiqzTcYimmzYxyR1BZ79KNevgt61PDcukmC7/<0;1>/*))";
+        let policy = WalletPolicy::from_str(descriptor_str).expect("parse descriptor");
+        assert_eq!(policy.key_info().len(), 2);
+
+        // Template iter_pk yields placeholder indices in AST order; the
+        // (AST position) -> (placeholder index) mapping lets external callers
+        // reconstruct placeholder-indexed views from key_info[i].
+        let pairs: Vec<(usize, u32)> = policy
+            .template()
+            .iter_pk()
+            .enumerate()
+            .map(|(ast_pos, ke)| (ast_pos, ke.index.0))
+            .collect();
+        assert_eq!(pairs, vec![(0, 0), (1, 1)]);
+    }
 }