pset: add support for elip-101 global genesis blockhash

Author: jgriffiths

include/wally.hpp

@@ -2439,6 +2439,18 @@ inline int psbt_find_global_scalar(const PSBT& psbt, const SCALAR& scalar, size_
     return detail::check_ret(__FUNCTION__, ret);
 }
 
+template <class PSBT, class BYTES_OUT>
+inline int psbt_get_global_genesis_blockhash(const PSBT& psbt, BYTES_OUT& bytes_out, size_t* written) {
+    int ret = ::wally_psbt_get_global_genesis_blockhash(detail::get_p(psbt), bytes_out.data(), bytes_out.size(), written);
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
+template <class PSBT>
+inline int psbt_has_global_genesis_blockhash(const PSBT& psbt, size_t* written) {
+    int ret = ::wally_psbt_has_global_genesis_blockhash(detail::get_p(psbt), written);
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
 inline int psbt_input_clear_amount_rangeproof(struct wally_psbt_input* input) {
     int ret = ::wally_psbt_input_clear_amount_rangeproof(input);
     return detail::check_ret(__FUNCTION__, ret);
@@ -3050,6 +3062,12 @@ inline int psbt_output_set_value_rangeproof(const OUTPUT& output, const RANGEPRO
     return detail::check_ret(__FUNCTION__, ret);
 }
 
+template <class PSBT, class GENESIS_BLOCKHASH>
+inline int psbt_set_global_genesis_blockhash(const PSBT& psbt, const GENESIS_BLOCKHASH& genesis_blockhash) {
+    int ret = ::wally_psbt_set_global_genesis_blockhash(detail::get_p(psbt), genesis_blockhash.data(), genesis_blockhash.size());
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
 template <class PSBT>
 inline int psbt_set_global_scalars(const PSBT& psbt, const struct wally_map* map_in) {
     int ret = ::wally_psbt_set_global_scalars(detail::get_p(psbt), map_in);

include/wally_psbt.h

@@ -139,6 +139,7 @@ struct wally_psbt {
 #ifndef WALLY_ABI_NO_ELEMENTS
     struct wally_map global_scalars;
     uint32_t pset_modifiable_flags;
+    unsigned char genesis_blockhash[SHA256_LEN]; /* All zeros if not present */
 #endif /* WALLY_ABI_NO_ELEMENTS */
 };
 #endif /* SWIG */
@@ -2114,6 +2115,45 @@ WALLY_CORE_API int wally_psbt_find_global_scalar(
 WALLY_CORE_API int wally_psbt_set_pset_modifiable_flags(
     struct wally_psbt *psbt,
     uint32_t flags);
+
+/**
+ * Set the global genesis blockhash in a PSBT.
+ *
+ * :param psbt: The psbt to update. Must be a PSET.
+ * :param genesis_blockhash: The genesis blockhash.
+ * :param genesis_blockhash_len: Size of ``genesis_blockhash`` in bytes. Must be `SHA256_LEN`.
+ */
+WALLY_CORE_API int wally_psbt_set_global_genesis_blockhash(
+    struct wally_psbt *psbt,
+    const unsigned char *genesis_blockhash,
+    size_t genesis_blockhash_len);
+
+/**
+ * Determine if a PSBT contains a global genesis blockhash.
+ *
+ * :param psbt: The psbt to check. Must be a PSET.
+ * :param written: On success, set to zero if no genesis blockhash is present,
+ *|    otherwise set to one.
+ */
+WALLY_CORE_API int wally_psbt_has_global_genesis_blockhash(
+    struct wally_psbt *psbt,
+    size_t *written);
+
+/**
+ * Get the global genesis blockhash from a PSBT.
+ *
+ * :param psbt: The psbt to get the genesis blockhash from.
+ * :param bytes_out: Destination for the genesis blockhash.
+ * MAX_SIZED_OUTPUT(len, bytes_out, SHA256_LEN)
+ * :param written: Destination for the number of bytes written to ``bytes_out``.
+ *| Will be zero if the value is not present.
+ */
+WALLY_CORE_API int wally_psbt_get_global_genesis_blockhash(
+    struct wally_psbt *psbt,
+    unsigned char *bytes_out,
+    size_t len,
+    size_t *written);
+
 #endif /* WALLY_ABI_NO_ELEMENTS */
 
 /**

src/psbt.c

@@ -1348,6 +1348,47 @@ PSBT_GET(num_outputs, PSBT_0)
 PSBT_GET(fallback_locktime, PSBT_2)
 PSBT_GET(tx_version, PSBT_2)
 PSBT_GET(tx_modifiable_flags, PSBT_2)
+#ifndef WALLY_ABI_NO_ELEMENTS
+int wally_psbt_set_global_genesis_blockhash(
+    struct wally_psbt *psbt,
+    const unsigned char* genesis_blockhash, size_t genesis_blockhash_len)
+{
+    size_t is_pset;
+    if ((wally_psbt_is_elements(psbt, &is_pset)) != WALLY_OK || !is_pset ||
+        !genesis_blockhash || genesis_blockhash_len != SHA256_LEN)
+        return WALLY_EINVAL;
+    memcpy(psbt->genesis_blockhash, genesis_blockhash, genesis_blockhash_len);
+    return WALLY_OK;
+}
+
+int wally_psbt_has_global_genesis_blockhash(struct wally_psbt *psbt, size_t *written)
+{
+    size_t is_pset;
+    if (written)
+        *written = 0;
+    if ((wally_psbt_is_elements(psbt, &is_pset)) != WALLY_OK || !is_pset || !written)
+        return WALLY_EINVAL;
+    *written = !mem_is_zero(psbt->genesis_blockhash, sizeof(psbt->genesis_blockhash));
+    return WALLY_OK;
+}
+
+int wally_psbt_get_global_genesis_blockhash(struct wally_psbt *psbt,
+                                            unsigned char* bytes_out, size_t len,
+                                            size_t *written)
+{
+    size_t has_blockhash;
+    if (written)
+        *written = 0;
+     if ((wally_psbt_has_global_genesis_blockhash(psbt, &has_blockhash)) != WALLY_OK ||
+        !bytes_out || len < SHA256_LEN || !written)
+        return WALLY_EINVAL;
+    if (has_blockhash) {
+        memcpy(bytes_out, psbt->genesis_blockhash, sizeof(psbt->genesis_blockhash));
+        *written = sizeof(psbt->genesis_blockhash);
+    }
+    return WALLY_OK;
+}
+#endif /* WALLY_ABI_NO_ELEMENTS */
 
 int wally_psbt_has_fallback_locktime(const struct wally_psbt *psbt, size_t *written)
 {
@@ -2717,6 +2758,13 @@ int wally_psbt_from_bytes(const unsigned char *bytes, size_t len,
                 if ((*output)->pset_modifiable_flags & ~PSET_TXMOD_ALL_FLAGS)
                     ret = WALLY_EINVAL; /* Invalid flags */
                 break;
+            case PSET_FT(PSET_GLOBAL_GENESIS_HASH): {
+                size_t val_len;
+                const unsigned char *val_p;
+                pull_varlength_buff(cursor, max, &val_p, &val_len);
+                ret = wally_psbt_set_global_genesis_blockhash(*output, val_p, val_len);
+                break;
+            }
 #endif /* BUILD_ELEMENTS */
             default:
                 goto unknown;
@@ -3357,6 +3405,10 @@ int wally_psbt_to_bytes(const struct wally_psbt *psbt, uint32_t flags,
             push_varint(&cursor, &max, sizeof(uint8_t));
             push_u8(&cursor, &max, psbt->pset_modifiable_flags);
         }
+        if (!mem_is_zero(psbt->genesis_blockhash, sizeof(psbt->genesis_blockhash))) {
+            push_key(&cursor, &max, PSET_GLOBAL_GENESIS_HASH, true, NULL, 0);
+            push_varbuff(&cursor, &max, psbt->genesis_blockhash, sizeof(psbt->genesis_blockhash));
+        }
 #endif /* BUILD_ELEMENTS */
     }
 

src/psbt_io.h

@@ -51,7 +51,8 @@
 /* Globals: PSET */
 #define PSET_GLOBAL_SCALAR 0x00
 #define PSET_GLOBAL_TX_MODIFIABLE 0x01
-#define PSET_GLOBAL_MAX PSET_GLOBAL_TX_MODIFIABLE
+#define PSET_GLOBAL_GENESIS_HASH 0x02
+#define PSET_GLOBAL_MAX PSET_GLOBAL_GENESIS_HASH
 
 /* Global PSBT/PSET fields that can be repeated */
 #define PSBT_GLOBAL_REPEATABLE (PSBT_FT(PSBT_GLOBAL_XPUB) | \
@@ -76,7 +77,8 @@
                                    PSBT_FT(PSBT_GLOBAL_OUTPUT_COUNT) | \
                                    PSBT_FT(PSBT_GLOBAL_TX_MODIFIABLE) | \
                                    PSET_FT(PSET_GLOBAL_SCALAR) | \
-                                   PSET_FT(PSET_GLOBAL_TX_MODIFIABLE))
+                                   PSET_FT(PSET_GLOBAL_TX_MODIFIABLE) | \
+                                   PSET_FT(PSET_GLOBAL_GENESIS_HASH))
 
 /* Global PSBT/PSET fields that must *not* be present in v2 */
 #define PSBT_GLOBAL_DISALLOWED_V2 PSBT_FT(PSBT_GLOBAL_UNSIGNED_TX)

src/swig_java/swig.i

@@ -740,6 +740,7 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_struct(wally_psbt_from_tx, wally_psbt);
 %returns_void__(wally_psbt_generate_input_explicit_proofs);
 %returns_size_t(wally_psbt_get_pset_modifiable_flags);
+%returns_size_t(wally_psbt_get_global_genesis_blockhash);
 %returns_struct(wally_psbt_get_global_tx_alloc, wally_tx);
 %rename("psbt_get_global_tx") wally_psbt_get_global_tx_alloc;
 %returns_array_(wally_psbt_get_global_scalar, 3, 4, WALLY_SCALAR_OFFSET_LEN);
@@ -866,6 +867,7 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_size_t(wally_psbt_get_tx_version);
 %returns_size_t(wally_psbt_get_version);
 %returns_size_t(wally_psbt_has_fallback_locktime);
+%returns_size_t(wally_psbt_has_global_genesis_blockhash);
 %returns_size_t(wally_psbt_has_input_required_lockheight);
 %returns_size_t(wally_psbt_has_input_required_locktime);
 %returns_size_t(wally_psbt_has_input_value);
@@ -889,6 +891,7 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_void__(wally_psbt_remove_output);
 %returns_void__(wally_psbt_set_pset_modifiable_flags);
 %returns_void__(wally_psbt_set_fallback_locktime);
+%returns_void__(wally_psbt_set_global_genesis_blockhash);
 %returns_void__(wally_psbt_set_global_tx);
 %returns_void__(wally_psbt_set_global_scalars);
 %returns_void__(wally_psbt_set_input_amount);

src/swig_python/python_extra.py_in

@@ -285,6 +285,7 @@ if is_elements_build():
     explicit_rangeproof = _wrap_bin(explicit_rangeproof, ASSET_EXPLICIT_RANGEPROOF_MAX_LEN, resize=True)
     explicit_surjectionproof = _wrap_bin(explicit_surjectionproof, ASSET_EXPLICIT_SURJECTIONPROOF_LEN)
     psbt_blind = psbt_blind_alloc
+    psbt_get_global_genesis_blockhash = _wrap_bin(psbt_get_global_genesis_blockhash, SHA256_LEN, resize=True)
     psbt_get_global_scalar = _wrap_bin(psbt_get_global_scalar, WALLY_SCALAR_OFFSET_LEN)
     psbt_get_input_amount_rangeproof = _wrap_bin(psbt_get_input_amount_rangeproof, psbt_get_input_amount_rangeproof_len)
     psbt_get_input_asset = _wrap_bin(psbt_get_input_asset, psbt_get_input_asset_len)

src/test/util.py

@@ -454,6 +454,7 @@ class wally_psbt(Structure):
     ('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_global_genesis_blockhash', c_int, [POINTER(wally_psbt), c_void_p, c_size_t, c_size_t_p]),
     ('wally_psbt_get_id', c_int, [POINTER(wally_psbt), c_uint32, c_void_p, c_size_t]),
     ('wally_psbt_get_input_bip32_key_from_alloc', c_int, [POINTER(wally_psbt), c_size_t, c_size_t, c_uint32, POINTER(ext_key), POINTER(POINTER(ext_key))]),
     ('wally_psbt_get_input_scriptcode', c_int, [POINTER(wally_psbt), c_size_t, c_void_p, c_size_t, c_void_p, c_size_t, c_size_t_p]),
@@ -464,6 +465,7 @@ class wally_psbt(Structure):
     ('wally_psbt_get_length', c_int, [POINTER(wally_psbt), c_uint32, c_size_t_p]),
     ('wally_psbt_get_locktime', c_int, [POINTER(wally_psbt), c_size_t_p]),
     ('wally_psbt_get_tx_version', c_int, [POINTER(wally_psbt), c_size_t_p]),
+    ('wally_psbt_has_global_genesis_blockhash', c_int, [POINTER(wally_psbt), c_size_t_p]),
     ('wally_psbt_init_alloc', c_int, [c_uint32, c_size_t, c_size_t, c_size_t, c_uint32, POINTER(POINTER(wally_psbt))]),
     ('wally_psbt_input_add_signature', c_int, [POINTER(wally_psbt_input), c_void_p, c_size_t, c_void_p, c_size_t]),
     ('wally_psbt_input_clear_amount_rangeproof', c_int, [POINTER(wally_psbt_input)]),
@@ -617,6 +619,7 @@ class wally_psbt(Structure):
     ('wally_psbt_remove_input', c_int, [POINTER(wally_psbt), c_uint32]),
     ('wally_psbt_remove_output', c_int, [POINTER(wally_psbt), c_uint32]),
     ('wally_psbt_set_fallback_locktime', c_int, [POINTER(wally_psbt), c_uint32]),
+    ('wally_psbt_set_global_genesis_blockhash', c_int, [POINTER(wally_psbt), c_void_p, c_size_t]),
     ('wally_psbt_set_global_scalars', c_int, [POINTER(wally_psbt), POINTER(wally_map)]),
     ('wally_psbt_set_global_tx', c_int, [POINTER(wally_psbt), POINTER(wally_tx)]),
     ('wally_psbt_set_pset_modifiable_flags', c_int, [POINTER(wally_psbt), c_uint32]),

src/wasm_package/src/functions.js

@@ -285,6 +285,7 @@ export function psbt_from_bytes(bytes: Buffer|Uint8Array, flags: number): Ref_wa
 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;
 export function psbt_get_fallback_locktime(psbt: Ref_wally_psbt): number;
+export function psbt_get_global_genesis_blockhash(psbt: Ref_wally_psbt): Buffer;
 export function psbt_get_global_scalar(psbt: Ref_wally_psbt, index: number): Buffer;
 export function psbt_get_global_scalars_size(psbt: Ref_wally_psbt): number;
 export function psbt_get_global_tx(psbt: Ref_wally_psbt): Ref_wally_tx;
@@ -363,6 +364,7 @@ export function psbt_get_tx_modifiable_flags(psbt: Ref_wally_psbt): number;
 export function psbt_get_tx_version(psbt: Ref_wally_psbt): number;
 export function psbt_get_version(psbt: Ref_wally_psbt): number;
 export function psbt_has_fallback_locktime(psbt: Ref_wally_psbt): number;
+export function psbt_has_global_genesis_blockhash(psbt: Ref_wally_psbt): number;
 export function psbt_has_input_required_lockheight(psbt: Ref_wally_psbt, index: number): number;
 export function psbt_has_input_required_locktime(psbt: Ref_wally_psbt, index: number): number;
 export function psbt_has_output_amount(psbt: Ref_wally_psbt, index: number): number;
@@ -496,6 +498,7 @@ export function psbt_output_taproot_keypath_add(output: Ref_wally_psbt_output, p
 export function psbt_remove_input(psbt: Ref_wally_psbt, index: number): void;
 export function psbt_remove_output(psbt: Ref_wally_psbt, index: number): void;
 export function psbt_set_fallback_locktime(psbt: Ref_wally_psbt, locktime: number): void;
+export function psbt_set_global_genesis_blockhash(psbt: Ref_wally_psbt, genesis_blockhash: Buffer|Uint8Array): void;
 export function psbt_set_global_scalars(psbt: Ref_wally_psbt, map_in: Ref_wally_map): void;
 export function psbt_set_global_tx(psbt: Ref_wally_psbt, tx: Ref_wally_tx): void;
 export function psbt_set_input_amount(psbt: Ref_wally_psbt, index: number, amount: bigint): void;

src/wasm_package/src/index.d.ts

@@ -565,6 +565,7 @@ if [ -z "$DISABLE_ELEMENTS" ]; then
 ,'_wally_psbt_clear_output_value_rangeproof' \
 ,'_wally_psbt_find_global_scalar' \
 ,'_wally_psbt_generate_input_explicit_proofs' \
+,'_wally_psbt_get_global_genesis_blockhash' \
 ,'_wally_psbt_get_global_scalar' \
 ,'_wally_psbt_get_global_scalars_size' \
 ,'_wally_psbt_get_input_amount' \
@@ -622,6 +623,7 @@ if [ -z "$DISABLE_ELEMENTS" ]; then
 ,'_wally_psbt_get_output_value_rangeproof' \
 ,'_wally_psbt_get_output_value_rangeproof_len' \
 ,'_wally_psbt_get_pset_modifiable_flags' \
+,'_wally_psbt_has_global_genesis_blockhash' \
 ,'_wally_psbt_has_output_blinder_index' \
 ,'_wally_psbt_input_clear_amount_rangeproof' \
 ,'_wally_psbt_input_clear_asset' \
@@ -729,6 +731,7 @@ if [ -z "$DISABLE_ELEMENTS" ]; then
 ,'_wally_psbt_output_set_value_blinding_rangeproof' \
 ,'_wally_psbt_output_set_value_commitment' \
 ,'_wally_psbt_output_set_value_rangeproof' \
+,'_wally_psbt_set_global_genesis_blockhash' \
 ,'_wally_psbt_set_global_scalars' \
 ,'_wally_psbt_set_input_amount' \
 ,'_wally_psbt_set_input_amount_rangeproof' \