descriptor: allow caller to fetch node features for keys

This is required e.g. to differentiate x-only keys.

Author: jgriffiths

include/wally.hpp

@@ -522,6 +522,12 @@ inline int descriptor_get_key_child_path_str_len(const DESCRIPTOR& descriptor, s
     return ret;
 }
 
+template <class DESCRIPTOR>
+inline int descriptor_get_key_features(const DESCRIPTOR& descriptor, size_t index, uint32_t* value_out) {
+    int ret = ::wally_descriptor_get_key_features(detail::get_p(descriptor), index, value_out);
+    return ret;
+}
+
 template <class DESCRIPTOR>
 inline int descriptor_get_network(const DESCRIPTOR& descriptor, uint32_t* value_out) {
     int ret = ::wally_descriptor_get_network(detail::get_p(descriptor), value_out);

include/wally_descriptor.h

@@ -202,16 +202,27 @@ WALLY_CORE_API int wally_descriptor_get_num_keys(
  * :param output: Destination for the resulting string representation.
  *|    The string returned should be freed using `wally_free_string`.
  *
- * .. note:: Keys may be BIP32 xpub/xpriv, WIF or hex pubkeys. The caller
- *|    can use `wally_descriptor_get_features` to determine which key types
- *|    are present.
- *
+ * .. note:: Keys may be BIP32 xpub/xpriv, WIF or hex pubkeys, and may be
+ *|    x-only. The caller can use `wally_descriptor_get_key_features` to
+ *|    determine the type of a given key.
  */
 WALLY_CORE_API int wally_descriptor_get_key(
     const struct wally_descriptor *descriptor,
     size_t index,
     char **output);
 
+/**
+ * Get the features of a key in a parsed output descriptor or miniscript expression.
+ *
+ * :param descriptor: Parsed output descriptor or miniscript expression.
+ * :param index: The zero-based index of the key to get.
+ * :param value_out: Destination for the resulting :ref:`miniscript-features`.
+ */
+WALLY_CORE_API int wally_descriptor_get_key_features(
+    const struct wally_descriptor *descriptor,
+    size_t index,
+    uint32_t *value_out);
+
 /**
  * Get the length of a keys child path string in a parsed output descriptor or miniscript expression.
  *

src/descriptor.c

@@ -2934,6 +2934,19 @@ int wally_descriptor_get_key(const struct wally_descriptor *descriptor,
     return WALLY_OK;
 }
 
+int wally_descriptor_get_key_features(const struct wally_descriptor *descriptor,
+                                      size_t index, uint32_t *value_out)
+{
+    const ms_node *node = descriptor_get_key(descriptor, index);
+
+    if (value_out)
+        *value_out = 0;
+    if (!node || !value_out)
+        return WALLY_EINVAL;
+    *value_out = node->flags;
+    return WALLY_OK;
+}
+
 int wally_descriptor_get_key_child_path_str_len(
     const struct wally_descriptor *descriptor, size_t index, size_t *written)
 {

src/swig_java/swig.i

@@ -564,6 +564,7 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_string(wally_descriptor_get_key);
 %returns_string(wally_descriptor_get_key_child_path_str);
 %returns_size_t(wally_descriptor_get_key_child_path_str_len);
+%returns_size_t(wally_descriptor_get_key_features);
 %returns_size_t(wally_descriptor_get_num_keys);
 %returns_size_t(wally_descriptor_get_num_paths);
 %returns_size_t(wally_descriptor_get_num_variants);

src/test/test_descriptor.py

@@ -325,24 +325,24 @@ def test_key_iteration(self):
         P = POLICY
 
         # Valid args
-        for flags, descriptor, expected, child_path in [
+        for flags, descriptor, expected, child_path, expected_features in [
             # Bip32 xpub
-            (0, f'pkh({k1})',         k1,   ''),
-            (0, f'pkh({k1}/*)',       k1,   '*'),
-            (0, f'pkh({k1}/0/1/2/*)', k1,   '0/1/2/*'),
-            (0, f'pkh({k1}/<0;1>/*)', k1,   '<0;1>/*'),
+            (0, f'pkh({k1})',         k1,   '',        0),
+            (0, f'pkh({k1}/*)',       k1,   '*',       MS_IS_RANGED),
+            (0, f'pkh({k1}/0/1/2/*)', k1,   '0/1/2/*', MS_IS_RANGED),
+            (0, f'pkh({k1}/<0;1>/*)', k1,   '<0;1>/*', MS_IS_RANGED|MS_IS_MULTIPATH),
             # Bip32 xpub (as policy)
-            (P, 'pkh(@0/*)',          k1,   '*'),
-            (P, 'pkh(@0/**)',         k1,   '<0;1>/*'),
-            (P, 'pkh(@0/<0;1>/*)',    k1,   '<0;1>/*'),
+            (P, 'pkh(@0/*)',          k1,   '*',       MS_IS_RANGED),
+            (P, 'pkh(@0/**)',         k1,   '<0;1>/*', MS_IS_RANGED|MS_IS_MULTIPATH),
+            (P, 'pkh(@0/<0;1>/*)',    k1,   '<0;1>/*', MS_IS_RANGED|MS_IS_MULTIPATH),
             # BIP32 xprv
-            (0, f'pkh({k2})',         k2,   ''),
+            (0, f'pkh({k2})',         k2,   '',        MS_IS_PRIVATE),
             # WIF
-            (0, f'pkh({wif})',        wif,  ''),
+            (0, f'pkh({wif})',        wif,  '',        MS_IS_RAW|MS_IS_PRIVATE),
             # Hex pubkey, compressed
-            (0, f'pk({pk})',          pk,   ''),
+            (0, f'pk({pk})',          pk,   '',        MS_IS_RAW),
             # Hex pubkey, uncompressed
-            (0, f'pk({pk_u})',        pk_u, ''),
+            (0, f'pk({pk_u})',        pk_u, '',        MS_IS_RAW|MS_IS_UNCOMPRESSED),
         ]:
             d = c_void_p()
             keys = policy_keys if flags & P else None
@@ -356,6 +356,8 @@ def test_key_iteration(self):
             self.assertEqual((ret, path_len), (WALLY_OK, len(child_path)))
             ret, path_str = wally_descriptor_get_key_child_path_str(d, 0)
             self.assertEqual((ret, path_str), (WALLY_OK, child_path))
+            ret, features = wally_descriptor_get_key_features(d, 0)
+            self.assertEqual((ret, features), (WALLY_OK, expected_features))
             wally_descriptor_free(d)
 
 

src/test/util.py

@@ -316,6 +316,7 @@ class wally_psbt(Structure):
     ('wally_descriptor_get_key', c_int, [c_void_p, c_size_t, c_char_p_p]),
     ('wally_descriptor_get_key_child_path_str', c_int, [c_void_p, c_size_t, c_char_p_p]),
     ('wally_descriptor_get_key_child_path_str_len', c_int, [c_void_p, c_size_t, c_size_t_p]),
+    ('wally_descriptor_get_key_features', c_int, [c_void_p, c_size_t, c_uint32_p]),
     ('wally_descriptor_get_network', c_int, [c_void_p, c_uint32_p]),
     ('wally_descriptor_get_num_keys', c_int, [c_void_p, c_uint32_p]),
     ('wally_descriptor_get_num_paths', c_int, [c_void_p, c_uint32_p]),

src/wasm_package/src/functions.js

@@ -125,6 +125,7 @@ export function descriptor_get_depth(descriptor: Ref_wally_descriptor): number;
 export function descriptor_get_features(descriptor: Ref_wally_descriptor): number;
 export function descriptor_get_key(descriptor: Ref_wally_descriptor, index: number): string;
 export function descriptor_get_key_child_path_str_len(descriptor: Ref_wally_descriptor, index: number): number;
+export function descriptor_get_key_features(descriptor: Ref_wally_descriptor, index: number): number;
 export function descriptor_get_network(descriptor: Ref_wally_descriptor): number;
 export function descriptor_get_num_keys(descriptor: Ref_wally_descriptor): number;
 export function descriptor_get_num_paths(descriptor: Ref_wally_descriptor): number;

src/wasm_package/src/index.d.ts

@@ -84,6 +84,7 @@ EXPORTED_FUNCTIONS="['_malloc','_free','_bip32_key_free' \
 ,'_wally_descriptor_get_key' \
 ,'_wally_descriptor_get_key_child_path_str' \
 ,'_wally_descriptor_get_key_child_path_str_len' \
+,'_wally_descriptor_get_key_features' \
 ,'_wally_descriptor_get_network' \
 ,'_wally_descriptor_get_num_keys' \
 ,'_wally_descriptor_get_num_paths' \