rename values_len to num_values

len should be reserved for actual lengths, vs num for a count of
(non-byte) elements.

Author: jgriffiths

include/wally_elements.h

@@ -71,20 +71,20 @@ WALLY_CORE_API int wally_ecdh_nonce_hash(
  * Generate the final value blinding factor required for blinding a confidential transaction.
  *
  * :param values: Array of values in satoshi
- * :param values_len: Length of ``values``, also the number of elements in all three of the input arrays, which is equal
+ * :param num_values: Length of ``values``, also the number of elements in all three of the input arrays, which is equal
  *|     to ``num_inputs`` plus the number of outputs.
  * :param num_inputs: Number of elements in the input arrays that represent inputs. The number of outputs is
- *|     implicitly ``values_len`` - ``num_inputs``.
- * :param abf:  Array of bytes representing ``values_len`` asset blinding factors.
- * :param abf_len: Length of ``abf`` in bytes. Must be ``values_len`` * ``BLINDING_FACTOR_LEN``.
- * :param vbf: Array of bytes representing (``values_len`` - 1) value blinding factors.
- * :param vbf_len: Length of ``vbf`` in bytes. Must be (``values_len`` - 1) * ``BLINDING_FACTOR_LEN``.
+ *|     implicitly ``num_values`` - ``num_inputs``.
+ * :param abf:  Array of bytes representing ``num_values`` asset blinding factors.
+ * :param abf_len: Length of ``abf`` in bytes. Must be ``num_values`` * ``BLINDING_FACTOR_LEN``.
+ * :param vbf: Array of bytes representing (``num_values`` - 1) value blinding factors.
+ * :param vbf_len: Length of ``vbf`` in bytes. Must be (``num_values`` - 1) * ``BLINDING_FACTOR_LEN``.
  * :param bytes_out: Buffer to receive the final value blinding factor.
  * FIXED_SIZED_OUTPUT(len, bytes_out, BLINDING_FACTOR_LEN)
  */
 WALLY_CORE_API int wally_asset_final_vbf(
     const uint64_t *values,
-    size_t values_len,
+    size_t num_values,
     size_t num_inputs,
     const unsigned char *abf,
     size_t abf_len,

src/elements.c

@@ -101,7 +101,7 @@ int wally_asset_generator_from_bytes(const unsigned char *asset, size_t asset_le
     return WALLY_OK;
 }
 
-int wally_asset_final_vbf(const uint64_t *values, size_t values_len, size_t num_inputs,
+int wally_asset_final_vbf(const uint64_t *values, size_t num_values, size_t num_inputs,
                           const unsigned char *abf, size_t abf_len,
                           const unsigned char *vbf, size_t vbf_len,
                           unsigned char *bytes_out, size_t len)
@@ -114,36 +114,36 @@ int wally_asset_final_vbf(const uint64_t *values, size_t values_len, size_t num_
     if (!ctx)
         return WALLY_ENOMEM;
 
-    if (!values || values_len < 2u ||
-        num_inputs >= values_len ||
-        !abf || abf_len != (values_len * BLINDING_FACTOR_LEN) ||
-        !vbf || vbf_len != ((values_len - 1) * BLINDING_FACTOR_LEN) ||
+    if (!values || num_values < 2u ||
+        num_inputs >= num_values ||
+        !abf || abf_len != (num_values * BLINDING_FACTOR_LEN) ||
+        !vbf || vbf_len != ((num_values - 1) * BLINDING_FACTOR_LEN) ||
         !bytes_out || len != ASSET_TAG_LEN)
         return WALLY_EINVAL;
 
-    abf_p = wally_malloc(values_len * sizeof(unsigned char *));
-    vbf_p = wally_malloc(values_len * sizeof(unsigned char *));
+    abf_p = wally_malloc(num_values * sizeof(unsigned char *));
+    vbf_p = wally_malloc(num_values * sizeof(unsigned char *));
 
     if (!abf_p || !vbf_p) {
         ret = WALLY_ENOMEM;
         goto cleanup;
     }
 
-    for (i = 0; i < values_len; i++) {
+    for (i = 0; i < num_values; i++) {
         abf_p[i] = abf + i * BLINDING_FACTOR_LEN;
         vbf_p[i] = vbf + i * BLINDING_FACTOR_LEN;
     }
-    vbf_p[values_len - 1] = bytes_out;
+    vbf_p[num_values - 1] = bytes_out;
     wally_clear(bytes_out, len);
 
     if (secp256k1_pedersen_blind_generator_blind_sum(ctx, values, abf_p,
                                                      (unsigned char *const *)vbf_p,
-                                                     values_len, num_inputs))
+                                                     num_values, num_inputs))
         ret = WALLY_OK;
 
 cleanup:
-    clear_and_free(abf_p, values_len * sizeof(unsigned char *));
-    clear_and_free(vbf_p, values_len * sizeof(unsigned char *));
+    clear_and_free(abf_p, num_values * sizeof(unsigned char *));
+    clear_and_free(vbf_p, num_values * sizeof(unsigned char *));
     return ret;
 }
 

src/swig_java/swig.i

@@ -301,7 +301,7 @@ static jbyteArray create_jintArray(JNIEnv *jenv, const uint32_t* p, size_t len)
 %apply(uint32_t *STRING, size_t LENGTH) { (const uint32_t *child_path, size_t child_path_len) }
 %apply(uint32_t *STRING, size_t LENGTH) { (uint32_t *child_path_out, size_t child_path_out_len) }
 %apply(uint32_t *STRING, size_t LENGTH) { (const uint32_t *sighash, size_t sighash_len) }
-%apply(uint64_t *STRING, size_t LENGTH) { (const uint64_t *values, size_t values_len) }
+%apply(uint64_t *STRING, size_t LENGTH) { (const uint64_t *values, size_t num_values) }
 
 %typemap(in, numinputs=0) uint32_t *value_out (uint32_t val) {
    val = 0; $1 = ($1_ltype)&val;

src/swig_python/swig.i

@@ -384,7 +384,7 @@ static void destroy_words(PyObject *obj) { (void)obj; }
 
 %py_int_array(uint32_t, 0xffffffffull, child_path, child_path_len)
 %py_int_array(uint32_t, 0xffull, sighash, sighash_len)
-%py_int_array(uint64_t, 0xffffffffffffffffull, values, values_len)
+%py_int_array(uint64_t, 0xffffffffffffffffull, values, num_values)
 %py_int_array_out(uint32_t, 0xffffffffull, child_path_out, child_path_out_len)
 
 %py_opaque_struct(ext_key);

tools/build_wrappers.py

@@ -138,10 +138,12 @@ def add_metadata(self, m):
                 ': invalid metadata reference {}'.format(m) + ' refs: ' + str(len(args))
         args[0].add_metadata(m)
 
+
 def is_array(func, arg, n, num_args, types):
     return arg.type in types and n != num_args -1 and \
                func.args[n + 1].type == u'size_t' and \
-               func.args[n + 1].name.endswith(u'len')
+               (func.args[n + 1].name.endswith(u'len') or
+                func.args[n + 1].name.startswith(u'num_'))
 
 
 def is_buffer(func, arg, n, num_args):
@@ -494,7 +496,7 @@ def map_args(func):
                 ts_returns.append(f'{arg.name}: Ref_{arg.struct_name}')
                 continue
 
-            assert False, f'ERROR: Unknown argument type "{arg.type}"'
+            assert False, f'ERROR: {func.name}: Unknown argument type "{arg.type}" {arg.name}'
 
         return (js_args, ts_args, ts_returns)