psbt: add a known-length call for psbt_from_base64

Author: jgriffiths

include/wally.hpp

@@ -1214,9 +1214,15 @@ inline int psbt_free(struct wally_psbt* psbt) {
     return detail::check_ret(__FUNCTION__, ret);
 }
 
-template <class BASE64>
-inline int psbt_from_base64(const BASE64& base64, uint32_t flags, struct wally_psbt** output) {
-    int ret = ::wally_psbt_from_base64(detail::get_p(base64), flags, output);
+template <class STR_IN>
+inline int psbt_from_base64(const STR_IN& str_in, uint32_t flags, struct wally_psbt** output) {
+    int ret = ::wally_psbt_from_base64(detail::get_p(str_in), flags, output);
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
+template <class STR_IN>
+inline int psbt_from_base64_n(const STR_IN& str_in, size_t str_len, uint32_t flags, struct wally_psbt** output) {
+    int ret = ::wally_psbt_from_base64_n(detail::get_p(str_in), str_len, flags, output);
     return detail::check_ret(__FUNCTION__, ret);
 }
 

include/wally_psbt.h

@@ -2363,14 +2363,25 @@ WALLY_CORE_API int wally_psbt_to_bytes(
     size_t *written);
 
 /**
- * Create a PSBT from its serialized base64 string.
+ * Create a PSBT from a serialized base64 string.
  *
- * :param base64: Base64 string to create the PSBT from.
+ * :param str_in: Base64 string to create the PSBT from.
  * :param flags: `WALLY_PSBT_PARSE_FLAG_STRICT` or 0.
  * :param output: Destination for the resulting PSBT.
  */
 WALLY_CORE_API int wally_psbt_from_base64(
-    const char *base64,
+    const char *str_in,
+    uint32_t flags,
+    struct wally_psbt **output);
+
+/**
+ * Create a PSBT from a known-length serialized base64 string.
+ *
+ * See `wally_psbt_from_base64`.
+ */
+WALLY_CORE_API int wally_psbt_from_base64_n(
+    const char *str_in,
+    size_t str_len,
     uint32_t flags,
     struct wally_psbt **output);
 

src/psbt.c

@@ -3357,22 +3357,23 @@ int wally_psbt_to_bytes(const struct wally_psbt *psbt, uint32_t flags,
     return WALLY_OK;
 }
 
-int wally_psbt_from_base64(const char *base64, uint32_t flags, struct wally_psbt **output)
+int wally_psbt_from_base64_n(const char *str_in, size_t str_len, uint32_t flags, struct wally_psbt **output)
 {
     unsigned char *decoded;
     size_t max_len, written;
     int ret;
 
     OUTPUT_CHECK;
-    if ((ret = wally_base64_get_maximum_length(base64, 0, &max_len)) != WALLY_OK)
+    if ((ret = wally_base64_n_get_maximum_length(str_in, str_len, 0, &max_len)) != WALLY_OK)
         return ret;
 
     /* Allocate the buffer to decode into */
     if ((decoded = wally_malloc(max_len)) == NULL)
         return WALLY_ENOMEM;
 
     /* Decode the base64 psbt into binary */
-    if ((ret = wally_base64_to_bytes(base64, 0, decoded, max_len, &written)) != WALLY_OK)
+    ret = wally_base64_n_to_bytes(str_in, str_len, 0, decoded, max_len, &written);
+    if (ret != WALLY_OK)
         goto done;
 
     if (written <= sizeof(PSBT_MAGIC)) {
@@ -3392,6 +3393,12 @@ int wally_psbt_from_base64(const char *base64, uint32_t flags, struct wally_psbt
     return ret;
 }
 
+int wally_psbt_from_base64(const char *str_in, uint32_t flags, struct wally_psbt **output)
+{
+    size_t str_len = str_in ? strlen(str_in) : 0;
+    return wally_psbt_from_base64_n(str_in, str_len, flags, output);
+}
+
 int wally_psbt_to_base64(const struct wally_psbt *psbt, uint32_t flags, char **output)
 {
     unsigned char *buff;

src/swig_java/swig.i

@@ -731,6 +731,7 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_size_t(wally_psbt_find_global_scalar);
 %returns_void__(wally_psbt_free);
 %returns_struct(wally_psbt_from_base64, wally_psbt);
+%returns_struct(wally_psbt_from_base64_n, wally_psbt);
 %returns_struct(wally_psbt_from_bytes, wally_psbt);
 %returns_struct(wally_psbt_from_tx, wally_psbt);
 %returns_void__(wally_psbt_generate_input_explicit_proofs);

src/test/test_psbt.py

@@ -320,13 +320,19 @@ def test_invalid_args(self):
 
         # psbt_from_base64
         src_base64 = JSON['valid'][0]['psbt']
+        src_len = len(src_base64)
         for args in [(None,       0,    psbt),  # NULL base64
                      ('',         0,    psbt),  # Empty base64
                      (src_base64, 0xff, psbt),  # Invalid flags
                      (src_base64, 0,    None)]: # NULL dest
             self.assertEqual(WALLY_EINVAL, wally_psbt_from_base64(*args))
 
-        self.assertEqual(WALLY_OK, wally_psbt_from_base64(JSON['valid'][0]['psbt'], 0, psbt))
+        for args in [(None,       src_len, 0, psbt),   # NULL base64 string, non-0 length
+                     (src_base64, 0,       0, psbt)]:  # Non-NULL base64 string, 0 length
+            self.assertEqual(WALLY_EINVAL, wally_psbt_from_base64_n(*args))
+
+        self.assertEqual(WALLY_OK, wally_psbt_from_base64(src_base64, 0, psbt))
+        self.assertEqual(WALLY_OK, wally_psbt_from_base64_n(src_base64, src_len, 0, psbt))
 
         # psbt_clone_alloc
         clone = pointer(wally_psbt())

src/test/util.py

@@ -448,6 +448,7 @@ class wally_psbt(Structure):
     ('wally_psbt_find_input_spending_utxo', c_int, [POINTER(wally_psbt), c_void_p, c_size_t, c_uint32, c_size_t_p]),
     ('wally_psbt_free', c_int, [POINTER(wally_psbt)]),
     ('wally_psbt_from_base64', c_int, [c_char_p, c_uint32, POINTER(POINTER(wally_psbt))]),
+    ('wally_psbt_from_base64_n', c_int, [c_char_p, c_size_t, c_uint32, POINTER(POINTER(wally_psbt))]),
     ('wally_psbt_from_bytes', c_int, [c_void_p, c_size_t, c_uint32, POINTER(POINTER(wally_psbt))]),
     ('wally_psbt_from_tx', c_int, [POINTER(wally_tx), c_uint32, c_uint32, POINTER(POINTER(wally_psbt))]),
     ('wally_psbt_get_id', c_int, [POINTER(wally_psbt), c_uint32, c_void_p, c_size_t]),

src/wasm_package/src/functions.js

@@ -277,7 +277,8 @@ export function psbt_find_input_unknown(psbt: Ref_wally_psbt, index: number, key
 export function psbt_find_output_keypath(psbt: Ref_wally_psbt, index: number, key: Buffer|Uint8Array): number;
 export function psbt_find_output_unknown(psbt: Ref_wally_psbt, index: number, key: Buffer|Uint8Array): number;
 export function psbt_free(psbt: Ref_wally_psbt): void;
-export function psbt_from_base64(base64: string, flags: number): Ref_wally_psbt;
+export function psbt_from_base64(str_in: string, flags: number): Ref_wally_psbt;
+export function psbt_from_base64_n(str_in: string, str_len: number, flags: number): Ref_wally_psbt;
 export function psbt_from_bytes(bytes: Buffer|Uint8Array, flags: number): Ref_wally_psbt;
 export function psbt_from_tx(tx: Ref_wally_tx, version: number, flags: number): Ref_wally_psbt;
 export function psbt_generate_input_explicit_proofs(psbt: Ref_wally_psbt, index: number, satoshi: bigint, asset: Buffer|Uint8Array, abf: Buffer|Uint8Array, vbf: Buffer|Uint8Array, entropy: Buffer|Uint8Array): void;

src/wasm_package/src/index.d.ts

@@ -211,6 +211,7 @@ EXPORTED_FUNCTIONS="['_malloc','_free','_bip32_key_free' \
 ,'_wally_psbt_find_output_unknown' \
 ,'_wally_psbt_free' \
 ,'_wally_psbt_from_base64' \
+,'_wally_psbt_from_base64_n' \
 ,'_wally_psbt_from_bytes' \
 ,'_wally_psbt_from_tx' \
 ,'_wally_psbt_get_fallback_locktime' \