@bitgo/wasm-utxo 1.27.0 → 1.29.0

package/dist/esm/js/wasm/wasm_utxo.d.ts

@@ -146,6 +146,20 @@ export class BitGoPsbt {
    * Get the unsigned transaction ID
    */
   unsigned_txid(): string;
+  /**
+   * Check if an input is a MuSig2 keypath input.
+   *
+   * MuSig2 inputs require special handling: nonces must be generated first with
+   * `generate_musig2_nonces()`, then signed with `sign_musig2_input()`.
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to check (0-based)
+   *
+   * # Returns
+   * - `true` if the input is a MuSig2 keypath input
+   * - `false` otherwise (or if input_index is out of bounds)
+   */
+  is_musig2_input(input_index: number): boolean;
   /**
    * Sign a single input with an extended private key (xpriv)
    *
@@ -208,6 +222,45 @@ export class BitGoPsbt {
    * The index of the newly added output
    */
   add_wallet_output(chain: number, index: number, value: bigint, wallet_keys: WasmRootWalletKeys): number;
+  /**
+   * Sign a single MuSig2 keypath input.
+   *
+   * This uses the FirstRound state generated by `generate_musig2_nonces()`.
+   * Each FirstRound can only be used once (nonce reuse is a security risk).
+   *
+   * For non-MuSig2 inputs, returns an error (use `sign_wallet_input` instead).
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to sign (0-based)
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(())` if signing was successful
+   * - `Err(WasmUtxoError)` if signing fails, no FirstRound exists, or not a MuSig2 input
+   */
+  sign_musig2_input(input_index: number, xpriv: WasmBIP32): void;
+  /**
+   * Sign a single non-MuSig2 wallet input using save/restore pattern.
+   *
+   * For MuSig2 inputs, returns an error (use `sign_musig2_input` instead).
+   * For ECDSA inputs, this uses a save/restore pattern: clones the PSBT,
+   * signs all inputs on the clone, then copies only the target input's
+   * signatures back.
+   *
+   * **Important:** This is NOT faster than `sign_all_wallet_inputs()` for ECDSA inputs.
+   * The underlying library signs all inputs regardless. This method just ensures
+   * that only the specified input gets signatures added to the PSBT.
+   * Use `sign_all_wallet_inputs()` when signing multiple inputs with the same key.
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to sign (0-based)
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(())` if the input was signed
+   * - `Err(WasmUtxoError)` if signing fails or input is MuSig2
+   */
+  sign_wallet_input(input_index: number, xpriv: WasmBIP32): void;
   /**
    * Sign a single input with a raw private key
    *
@@ -266,6 +319,24 @@ export class BitGoPsbt {
    * - `Err(WasmUtxoError)` if any input failed to finalize
    */
   finalize_all_inputs(): void;
+  /**
+   * Sign all non-MuSig2 inputs with an extended private key (xpriv) in a single pass.
+   *
+   * This is more efficient than calling `sign_with_xpriv` for each input individually.
+   * The underlying miniscript library's `sign` method signs all matching inputs at once.
+   *
+   * **Note:** MuSig2 inputs are skipped by this method because they require FirstRound
+   * state from nonce generation. After calling this method, sign MuSig2 inputs
+   * individually using `sign_with_xpriv`.
+   *
+   * # Arguments
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(JsValue)` with an array of input indices that were signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_all_with_xpriv(xpriv: WasmBIP32): any;
   /**
    * Add a PayGo attestation to a PSBT output
    *
@@ -325,6 +396,41 @@ export class BitGoPsbt {
    * generated for security. Custom session_id is only allowed on testnets for testing purposes.
    */
   generate_musig2_nonces(xpriv: WasmBIP32, session_id_bytes?: Uint8Array | null): void;
+  /**
+   * Sign all MuSig2 keypath inputs in a single pass with optimized sighash computation.
+   *
+   * This is more efficient than calling `sign_musig2_input()` for each input because
+   * it reuses the SighashCache across all inputs, avoiding redundant computation of
+   * sha_prevouts, sha_amounts, sha_scriptpubkeys, sha_sequences, and sha_outputs.
+   *
+   * Each MuSig2 input requires a FirstRound from `generate_musig2_nonces()`.
+   * FirstRounds that have already been consumed (signed) are skipped.
+   *
+   * # Arguments
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(JsValue)` with an array of input indices that were signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_all_musig2_inputs(xpriv: WasmBIP32): any;
+  /**
+   * Sign all non-MuSig2 wallet inputs in a single efficient pass.
+   *
+   * This signs all ECDSA (P2SH, P2SH-P2WSH, P2WSH) and Taproot script path (P2TR)
+   * inputs that match the provided xpriv. MuSig2 keypath inputs are skipped.
+   *
+   * This is the most efficient way to sign wallet inputs. After calling this,
+   * sign any MuSig2 inputs using `sign_all_musig2_inputs()` or `sign_musig2_input()`.
+   *
+   * # Arguments
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(JsValue)` with an array of input indices that were signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_all_wallet_inputs(xpriv: WasmBIP32): any;
   /**
    * Add an output to the PSBT by address
    *
@@ -411,12 +517,79 @@ export class BitGoPsbt {
    * Returns error if block height is before Overwinter activation
    */
   static create_empty_zcash_at_height(network: string, wallet_keys: WasmRootWalletKeys, block_height: number, version?: number | null, lock_time?: number | null, version_group_id?: number | null, expiry_height?: number | null): BitGoPsbt;
+  /**
+   * Sign a single input with an extended private key, using save/restore for ECDSA inputs.
+   *
+   * For MuSig2 inputs, this returns an error (use sign_with_xpriv which handles FirstRound).
+   * For ECDSA inputs, this clones the PSBT, signs all, then copies only the target
+   * input's signatures back.
+   *
+   * **Important:** This is NOT faster than `sign_all_with_xpriv` for ECDSA inputs.
+   * The underlying miniscript library signs all inputs regardless. This method
+   * just prevents signatures from being added to other inputs.
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to sign (0-based)
+   * - `xpriv`: The extended private key as a WasmBIP32 instance
+   *
+   * # Returns
+   * - `Ok(())` if the input was signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_single_input_with_xpriv(input_index: number, xpriv: WasmBIP32): void;
+  /**
+   * Sign all replay protection inputs with a raw private key.
+   *
+   * This iterates through all inputs looking for P2SH-P2PK (replay protection) inputs
+   * that match the provided public key and signs them.
+   *
+   * # Arguments
+   * - `ecpair`: The ECPair containing the private key
+   *
+   * # Returns
+   * - `Ok(JsValue)` with an array of input indices that were signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_replay_protection_inputs(ecpair: WasmECPair): any;
   /**
    * Parse outputs with wallet keys to identify which outputs belong to a wallet
    *
    * Note: This method does NOT validate wallet inputs. It only parses outputs.
    */
   parse_outputs_with_wallet_keys(wallet_keys: WasmRootWalletKeys, paygo_pubkeys?: WasmECPair[] | null): any;
+  /**
+   * Sign a single input with a raw private key, using save/restore for regular inputs.
+   *
+   * For replay protection inputs (P2SH-P2PK), this uses direct signing which is
+   * already single-input. For regular inputs, this clones the PSBT, signs all,
+   * then copies only the target input's signatures back.
+   *
+   * **Important:** This is NOT faster than signing all inputs for regular (non-RP) inputs.
+   * The underlying miniscript library signs all inputs regardless.
+   *
+   * # Arguments
+   * - `input_index`: The index of the input to sign (0-based)
+   * - `ecpair`: The ECPair containing the private key
+   *
+   * # Returns
+   * - `Ok(())` if the input was signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_single_input_with_privkey(input_index: number, ecpair: WasmECPair): void;
+  /**
+   * Sign all replay protection inputs with a raw private key.
+   *
+   * This iterates through all inputs looking for P2SH-P2PK (replay protection) inputs
+   * that match the provided public key and signs them.
+   *
+   * # Arguments
+   * - `ecpair`: The ECPair containing the private key
+   *
+   * # Returns
+   * - `Ok(JsValue)` with an array of input indices that were signed
+   * - `Err(WasmUtxoError)` if signing fails
+   */
+  sign_all_replay_protection_inputs(ecpair: WasmECPair): any;
   /**
    * Parse transaction with wallet keys to identify wallet inputs/outputs
    */
@@ -504,6 +677,16 @@ export class FixedScriptWalletNamespace {
    * - Dogecoin only supports legacy scripts (p2sh)
    */
   static supports_script_type(coin: string, script_type: string): boolean;
+  /**
+   * Create an OP_RETURN output script with optional data
+   *
+   * # Arguments
+   * * `data` - Optional data bytes to include in the OP_RETURN script
+   *
+   * # Returns
+   * The OP_RETURN script as bytes
+   */
+  static create_op_return_script(data?: Uint8Array | null): Uint8Array;
   static address_with_network_str(keys: WasmRootWalletKeys, chain: number, index: number, network: string, address_format?: string | null): string;
   static output_script_with_network_str(keys: WasmRootWalletKeys, chain: number, index: number, network: string): Uint8Array;
   static address(keys: WasmRootWalletKeys, chain: number, index: number, network: any, address_format?: string | null): string;

package/dist/esm/js/wasm/wasm_utxo_bg.js

@@ -738,6 +738,25 @@ export class BitGoPsbt {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Check if an input is a MuSig2 keypath input.
+     *
+     * MuSig2 inputs require special handling: nonces must be generated first with
+     * `generate_musig2_nonces()`, then signed with `sign_musig2_input()`.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to check (0-based)
+     *
+     * # Returns
+     * - `true` if the input is a MuSig2 keypath input
+     * - `false` otherwise (or if input_index is out of bounds)
+     * @param {number} input_index
+     * @returns {boolean}
+     */
+    is_musig2_input(input_index) {
+        const ret = wasm.bitgopsbt_is_musig2_input(this.__wbg_ptr, input_index);
+        return ret !== 0;
+    }
     /**
      * Sign a single input with an extended private key (xpriv)
      *
@@ -873,6 +892,75 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign a single MuSig2 keypath input.
+     *
+     * This uses the FirstRound state generated by `generate_musig2_nonces()`.
+     * Each FirstRound can only be used once (nonce reuse is a security risk).
+     *
+     * For non-MuSig2 inputs, returns an error (use `sign_wallet_input` instead).
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(())` if signing was successful
+     * - `Err(WasmUtxoError)` if signing fails, no FirstRound exists, or not a MuSig2 input
+     * @param {number} input_index
+     * @param {WasmBIP32} xpriv
+     */
+    sign_musig2_input(input_index, xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_musig2_input(retptr, this.__wbg_ptr, input_index, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign a single non-MuSig2 wallet input using save/restore pattern.
+     *
+     * For MuSig2 inputs, returns an error (use `sign_musig2_input` instead).
+     * For ECDSA inputs, this uses a save/restore pattern: clones the PSBT,
+     * signs all inputs on the clone, then copies only the target input's
+     * signatures back.
+     *
+     * **Important:** This is NOT faster than `sign_all_wallet_inputs()` for ECDSA inputs.
+     * The underlying library signs all inputs regardless. This method just ensures
+     * that only the specified input gets signatures added to the PSBT.
+     * Use `sign_all_wallet_inputs()` when signing multiple inputs with the same key.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(())` if the input was signed
+     * - `Err(WasmUtxoError)` if signing fails or input is MuSig2
+     * @param {number} input_index
+     * @param {WasmBIP32} xpriv
+     */
+    sign_wallet_input(input_index, xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_single_input_with_xpriv(retptr, this.__wbg_ptr, input_index, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Sign a single input with a raw private key
      *
@@ -1001,6 +1089,41 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign all non-MuSig2 inputs with an extended private key (xpriv) in a single pass.
+     *
+     * This is more efficient than calling `sign_with_xpriv` for each input individually.
+     * The underlying miniscript library's `sign` method signs all matching inputs at once.
+     *
+     * **Note:** MuSig2 inputs are skipped by this method because they require FirstRound
+     * state from nonce generation. After calling this method, sign MuSig2 inputs
+     * individually using `sign_with_xpriv`.
+     *
+     * # Arguments
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(JsValue)` with an array of input indices that were signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {WasmBIP32} xpriv
+     * @returns {any}
+     */
+    sign_all_with_xpriv(xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_all_wallet_inputs(retptr, this.__wbg_ptr, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Add a PayGo attestation to a PSBT output
      *
@@ -1110,6 +1233,75 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign all MuSig2 keypath inputs in a single pass with optimized sighash computation.
+     *
+     * This is more efficient than calling `sign_musig2_input()` for each input because
+     * it reuses the SighashCache across all inputs, avoiding redundant computation of
+     * sha_prevouts, sha_amounts, sha_scriptpubkeys, sha_sequences, and sha_outputs.
+     *
+     * Each MuSig2 input requires a FirstRound from `generate_musig2_nonces()`.
+     * FirstRounds that have already been consumed (signed) are skipped.
+     *
+     * # Arguments
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(JsValue)` with an array of input indices that were signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {WasmBIP32} xpriv
+     * @returns {any}
+     */
+    sign_all_musig2_inputs(xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_all_musig2_inputs(retptr, this.__wbg_ptr, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign all non-MuSig2 wallet inputs in a single efficient pass.
+     *
+     * This signs all ECDSA (P2SH, P2SH-P2WSH, P2WSH) and Taproot script path (P2TR)
+     * inputs that match the provided xpriv. MuSig2 keypath inputs are skipped.
+     *
+     * This is the most efficient way to sign wallet inputs. After calling this,
+     * sign any MuSig2 inputs using `sign_all_musig2_inputs()` or `sign_musig2_input()`.
+     *
+     * # Arguments
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(JsValue)` with an array of input indices that were signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {WasmBIP32} xpriv
+     * @returns {any}
+     */
+    sign_all_wallet_inputs(xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_all_wallet_inputs(retptr, this.__wbg_ptr, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Add an output to the PSBT by address
      *
@@ -1299,6 +1491,72 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign a single input with an extended private key, using save/restore for ECDSA inputs.
+     *
+     * For MuSig2 inputs, this returns an error (use sign_with_xpriv which handles FirstRound).
+     * For ECDSA inputs, this clones the PSBT, signs all, then copies only the target
+     * input's signatures back.
+     *
+     * **Important:** This is NOT faster than `sign_all_with_xpriv` for ECDSA inputs.
+     * The underlying miniscript library signs all inputs regardless. This method
+     * just prevents signatures from being added to other inputs.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `xpriv`: The extended private key as a WasmBIP32 instance
+     *
+     * # Returns
+     * - `Ok(())` if the input was signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {number} input_index
+     * @param {WasmBIP32} xpriv
+     */
+    sign_single_input_with_xpriv(input_index, xpriv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(xpriv, WasmBIP32);
+            wasm.bitgopsbt_sign_single_input_with_xpriv(retptr, this.__wbg_ptr, input_index, xpriv.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign all replay protection inputs with a raw private key.
+     *
+     * This iterates through all inputs looking for P2SH-P2PK (replay protection) inputs
+     * that match the provided public key and signs them.
+     *
+     * # Arguments
+     * - `ecpair`: The ECPair containing the private key
+     *
+     * # Returns
+     * - `Ok(JsValue)` with an array of input indices that were signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {WasmECPair} ecpair
+     * @returns {any}
+     */
+    sign_replay_protection_inputs(ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_sign_all_replay_protection_inputs(retptr, this.__wbg_ptr, ecpair.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
      *
@@ -1325,6 +1583,71 @@ export class BitGoPsbt {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sign a single input with a raw private key, using save/restore for regular inputs.
+     *
+     * For replay protection inputs (P2SH-P2PK), this uses direct signing which is
+     * already single-input. For regular inputs, this clones the PSBT, signs all,
+     * then copies only the target input's signatures back.
+     *
+     * **Important:** This is NOT faster than signing all inputs for regular (non-RP) inputs.
+     * The underlying miniscript library signs all inputs regardless.
+     *
+     * # Arguments
+     * - `input_index`: The index of the input to sign (0-based)
+     * - `ecpair`: The ECPair containing the private key
+     *
+     * # Returns
+     * - `Ok(())` if the input was signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {number} input_index
+     * @param {WasmECPair} ecpair
+     */
+    sign_single_input_with_privkey(input_index, ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_sign_single_input_with_privkey(retptr, this.__wbg_ptr, input_index, ecpair.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign all replay protection inputs with a raw private key.
+     *
+     * This iterates through all inputs looking for P2SH-P2PK (replay protection) inputs
+     * that match the provided public key and signs them.
+     *
+     * # Arguments
+     * - `ecpair`: The ECPair containing the private key
+     *
+     * # Returns
+     * - `Ok(JsValue)` with an array of input indices that were signed
+     * - `Err(WasmUtxoError)` if signing fails
+     * @param {WasmECPair} ecpair
+     * @returns {any}
+     */
+    sign_all_replay_protection_inputs(ecpair) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(ecpair, WasmECPair);
+            wasm.bitgopsbt_sign_all_replay_protection_inputs(retptr, this.__wbg_ptr, ecpair.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse transaction with wallet keys to identify wallet inputs/outputs
      * @param {WasmRootWalletKeys} wallet_keys
@@ -1579,6 +1902,37 @@ export class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Create an OP_RETURN output script with optional data
+     *
+     * # Arguments
+     * * `data` - Optional data bytes to include in the OP_RETURN script
+     *
+     * # Returns
+     * The OP_RETURN script as bytes
+     * @param {Uint8Array | null} [data]
+     * @returns {Uint8Array}
+     */
+    static create_op_return_script(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(data) ? 0 : passArray8ToWasm0(data, wasm.__wbindgen_export);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.fixedscriptwalletnamespace_create_op_return_script(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {WasmRootWalletKeys} keys
      * @param {number} chain