Add DecodeScriptSegwit struct and support in DecodeScript conversion

- Add `DecodeScriptSegwit` struct to model the `segwit` field returned by the `decodescript` RPC.
- Update `DecodeScript` to include an optional `segwit` field.
- Add `raw_transactions`folder to v19.

Add DecodeScriptSegwit struct, conversions, and model support

- Add `DecodeScriptSegwit` struct to both versioned and model representations.
- Implement `into_model()` for `DecodeScriptSegwit` and update `DecodeScript` accordingly.
- Use `ScriptBuf` instead of `String` for `hex` to strongly type the field.
- Replace `String` with `Address<NetworkUnchecked>` for `p2sh_segwit` and other fields.
- Normalize and correct field comments to match Core `decodescript` RPC output.
-  Clean up formatting errors

Add DecodeScriptSegwit into_model to v17 and refactor error handling
- Add `into_model` implementation for `DecodeScriptSegwit` in v17.
- Return `segwit` in v17, as it is present in RPC output despite not being documented until v19.
- Add `DecodeScriptSegwitError` enum in v17, as `address` is sometimes `None` and error handling is needed.
- Remove duplicate `DecodeScriptSegwitError` from v23 and reuse the one from v22 via import.
- Move `descriptor` field in `DecodeScriptSegwit` model struct to match the field order in Bitcoin Core's `decodescript` RPC response.

Add model test for decode_script with P2WPKH SegWit output
Add model test for decode_script_segwit inyo model

Author: +Sharon

integration_test/tests/raw_transactions.rs

@@ -4,16 +4,21 @@
 
 #![allow(non_snake_case)] // Test names intentionally use double underscore.
 #![allow(unused_imports)] // Because of feature gated tests.
-
+use bitcoin::address::NetworkUnchecked;
 use bitcoin::consensus::encode;
+use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::hex::FromHex as _;
+use bitcoin::key::{Secp256k1, XOnlyPublicKey};
 use bitcoin::opcodes::all::*;
+use bitcoin::script::Builder;
 use bitcoin::{
-    absolute, consensus, hex, psbt, script, transaction, Amount, ScriptBuf, Transaction, TxOut,
+    absolute, consensus, hex, psbt, script, secp256k1, transaction, Address, Amount, Network,
+    PublicKey, ScriptBuf, Transaction, TxOut, WPubkeyHash, WScriptHash,
 };
 use integration_test::{Node, NodeExt as _, Wallet};
 use node::vtype::*;
 use node::{mtype, Input, Output}; // All the version specific types.
+use rand::Rng;
 
 #[test]
 #[cfg(not(feature = "v17"))] // analyzepsbt was added in v0.18.
@@ -201,18 +206,56 @@ fn raw_transactions__decode_script__modelled() {
     let node = Node::with_wallet(Wallet::Default, &["-txindex"]);
     node.fund_wallet();
 
-    let p2pkh = arbitrary_p2pkh_script();
-    let multi = arbitrary_multisig_script();
-
-    for script in &[p2pkh, multi] {
+    let test_cases: Vec<(&str, ScriptBuf, Option<&str>)> = vec![
+        ("p2pkh", arbitrary_p2pkh_script(), Some("pubkeyhash")),
+        ("multisig", arbitrary_multisig_script(), Some("multisig")),
+        ("p2sh", arbitrary_p2sh_script(), Some("scripthash")),
+        ("bare", arbitrary_bare_script(), Some("nonstandard")),
+        ("p2wpkh", arbitrary_p2wpkh_script(), Some("witness_v0_keyhash")),
+        ("p2wsh", arbitrary_p2wsh_script(), Some("witness_v0_scripthash")),
+        ("p2tr", arbitrary_p2tr_script(), Some("witness_v1_taproot")),
+    ];
+
+    for (label, script, expected_type) in test_cases {
         let hex = script.to_hex_string();
 
         let json: DecodeScript = node.client.decode_script(&hex).expect("decodescript");
         let model: Result<mtype::DecodeScript, DecodeScriptError> = json.into_model();
-        model.unwrap();
+        let decoded = model.expect("DecodeScript into model");
+
+        println!("Decoded script ({label}): {:?}", decoded);
+
+        if let Some(expected) = expected_type {
+            assert_eq!(decoded.type_, expected, "Unexpected script type for {label}");
+        } else {
+            println!("Skipping type check for {}", label);
+        }
+
+        // Address should be present for standard scripts
+        if expected_type != Some("nonstandard") {
+            let has_any_address = !decoded.addresses.is_empty() || decoded.address.is_some();
+            assert!(has_any_address, "Expected at least one address for {label}");
+        }
     }
 }
+fn arbitrary_p2sh_script() -> ScriptBuf {
+    let redeem_script = arbitrary_multisig_script(); // or arbitrary_p2pkh_script()
+    let redeem_script_hash = hash160::Hash::hash(redeem_script.as_bytes());
 
+    script::Builder::new()
+        .push_opcode(bitcoin::opcodes::all::OP_HASH160)
+        .push_slice(redeem_script_hash.as_byte_array()) // [u8; 20]
+        .push_opcode(bitcoin::opcodes::all::OP_EQUAL)
+        .into_script()
+}
+fn arbitrary_bare_script() -> ScriptBuf {
+    script::Builder::new().push_opcode(OP_RETURN).push_slice(b"hello").into_script()
+}
+fn arbitrary_pubkey() -> PublicKey {
+    let secp = Secp256k1::new();
+    let secret_key = secp256k1::SecretKey::from_slice(&[1u8; 32]).unwrap();
+    PublicKey::new(secp256k1::PublicKey::from_secret_key(&secp, &secret_key))
+}
 // Script builder code copied from rust-bitcoin script unit tests.
 fn arbitrary_p2pkh_script() -> ScriptBuf {
     let pubkey_hash = <[u8; 20]>::from_hex("16e1ae70ff0fa102905d4af297f6912bda6cce19").unwrap();
@@ -225,7 +268,6 @@ fn arbitrary_p2pkh_script() -> ScriptBuf {
         .push_opcode(OP_CHECKSIG)
         .into_script()
 }
-
 fn arbitrary_multisig_script() -> ScriptBuf {
     let pk1 =
         <[u8; 33]>::from_hex("022afc20bf379bc96a2f4e9e63ffceb8652b2b6a097f63fbee6ecec2a49a48010e")
@@ -244,6 +286,89 @@ fn arbitrary_multisig_script() -> ScriptBuf {
         .push_opcode(OP_CHECKMULTISIG)
         .into_script()
 }
+fn arbitrary_p2wpkh_script() -> ScriptBuf {
+    let pubkey = arbitrary_pubkey();
+    let pubkey_hash = hash160::Hash::hash(&pubkey.to_bytes());
+
+    // P2WPKH: 0 <20-byte pubkey hash>
+    Builder::new().push_int(0).push_slice(pubkey_hash.as_byte_array()).into_script()
+}
+
+fn arbitrary_p2wsh_script() -> ScriptBuf {
+    let redeem_script = arbitrary_multisig_script(); // any witness script
+    let script_hash = sha256::Hash::hash(redeem_script.as_bytes());
+
+    // P2WSH: 0 <32-byte script hash>
+    Builder::new().push_int(0).push_slice(script_hash.as_byte_array()).into_script()
+}
+
+fn arbitrary_p2tr_script() -> ScriptBuf {
+    let secp = Secp256k1::new();
+    let sk = secp256k1::SecretKey::from_slice(&[2u8; 32]).unwrap();
+    let internal_key = secp256k1::PublicKey::from_secret_key(&secp, &sk);
+    let x_only = XOnlyPublicKey::from(internal_key);
+
+    // Taproot output script: OP_1 <x-only pubkey>
+    Builder::new().push_int(1).push_slice(&x_only.serialize()).into_script()
+}
+
+#[test]
+fn raw_transactions__decode_script_segwit__modelled() {
+    let node = Node::with_wallet(Wallet::Default, &["-txindex"]);
+    node.client.load_wallet("default").ok(); // Ensure wallet is loaded
+    node.fund_wallet();
+
+    // Get a new address and script
+    let address_unc = node
+        .client
+        .get_new_address(None, None)
+        .expect("getnewaddress")
+        .address()
+        .expect("valid address string");
+
+    let address = address_unc.require_network(Network::Regtest).expect("must be regtest");
+
+    assert!(address.is_segwit(), "Expected SegWit address but got {:?}", address);
+
+    let script = address.script_pubkey();
+    let hex = script.to_hex_string();
+
+    // Decode script
+    let json = node.client.decode_script(&hex).expect("decodescript");
+    let model: Result<mtype::DecodeScript, DecodeScriptError> = json.into_model();
+    let decoded = model.expect("DecodeScript into model");
+
+    let segwit = decoded.segwit.as_ref().expect("Expected segwit field to be present");
+
+    assert_eq!(segwit.hex, script, "Segwit hex does not match script");
+
+    // Extract the type field
+    let script_type =
+        decoded.segwit.as_ref().map(|s| s.type_.as_str()).unwrap_or_else(|| decoded.type_.as_str());
+
+    assert_eq!(script_type, "witness_v0_keyhash", "Expected script type to be witness_v0_keyhash");
+
+    // Compare hex from segwit
+    let decoded_hex = decoded
+        .segwit
+        .as_ref()
+        .map(|s| &s.hex)
+        .unwrap_or_else(|| panic!("Expected segwit hex to be present"));
+
+    assert_eq!(*decoded_hex, script, "Script hex does not match");
+
+    // Compare addresses from segwit or fallback
+    let address_unc_check = address.into_unchecked();
+    let segwit_addresses =
+        decoded.segwit.as_ref().map(|s| &s.addresses).unwrap_or(&decoded.addresses);
+
+    assert!(
+        segwit_addresses.iter().any(|a| a == &address_unc_check),
+        "Expected address {:?} in segwit.addresses or top-level addresses: {:?}",
+        address_unc_check,
+        segwit_addresses
+    );
+}
 
 #[test]
 fn raw_transactions__finalize_psbt__modelled() {

types/src/model/mod.rs

@@ -45,10 +45,11 @@ pub use self::{
     raw_transactions::{
         AnalyzePsbt, AnalyzePsbtInput, AnalyzePsbtInputMissing, CombinePsbt, CombineRawTransaction,
         ConvertToPsbt, CreatePsbt, CreateRawTransaction, DecodePsbt, DecodeRawTransaction,
-        DecodeScript, DescriptorProcessPsbt, FinalizePsbt, FundRawTransaction, GetRawTransaction,
-        GetRawTransactionVerbose, JoinPsbts, MempoolAcceptance, MempoolAcceptanceFees,
-        SendRawTransaction, SignFail, SignRawTransaction, SignRawTransactionWithKey, SubmitPackage,
-        SubmitPackageTxResult, SubmitPackageTxResultFees, TestMempoolAccept, UtxoUpdatePsbt,
+        DecodeScript, DecodeScriptSegwit, DescriptorProcessPsbt, FinalizePsbt, FundRawTransaction,
+        GetRawTransaction, GetRawTransactionVerbose, JoinPsbts, MempoolAcceptance,
+        MempoolAcceptanceFees, SendRawTransaction, SignFail, SignRawTransaction,
+        SignRawTransactionWithKey, SubmitPackage, SubmitPackageTxResult, SubmitPackageTxResultFees,
+        TestMempoolAccept, UtxoUpdatePsbt,
     },
     util::{
         CreateMultisig, DeriveAddresses, DeriveAddressesMultipath, EstimateSmartFee,

types/src/model/raw_transactions.rs

@@ -105,8 +105,29 @@ pub struct DecodeScript {
     pub addresses: Vec<Address<NetworkUnchecked>>,
     /// Address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH).
     pub p2sh: Option<Address<NetworkUnchecked>>,
-    /// Address of the P2SH script wrapping this witness redeem script
-    pub p2sh_segwit: Option<String>,
+    /// Result of a witness output script wrapping this redeem script (not returned for types that should not be wrapped).
+    pub segwit: Option<DecodeScriptSegwit>,
+}
+/// Models the `segwit` field returned by the `decodescript` RPC.
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct DecodeScriptSegwit {
+    /// Disassembly of the script.
+    pub asm: String,
+    /// The raw output script bytes, hex-encoded.
+    pub hex: ScriptBuf,
+    /// The output type (e.g. nonstandard, anchor, pubkey, pubkeyhash, scripthash, multisig, nulldata, witness_v0_scripthash, witness_v0_keyhash, witness_v1_taproot, witness_unknown).
+    pub type_: String,
+    /// Bitcoin address (only if a well-defined address exists)v22 and later only.
+    pub address: Option<Address<NetworkUnchecked>>,
+    /// The required signatures.
+    pub required_signatures: Option<u64>,
+    /// List of bitcoin addresses.
+    pub addresses: Vec<Address<NetworkUnchecked>>,
+    /// Inferred descriptor for the script. v23 and later only.
+    pub descriptor: Option<String>,
+    /// Address of the P2SH script wrapping this witness redeem script.
+    pub p2sh_segwit: Option<Address<NetworkUnchecked>>,
 }
 
 /// Models the result of JSON-RPC method `descriptorprocesspsbt`.

types/src/v17/raw_transactions/error.rs

@@ -167,26 +167,58 @@ pub enum DecodeScriptError {
     Addresses(address::ParseError),
     /// Conversion of the transaction `p2sh` field failed.
     P2sh(address::ParseError),
+    /// Conversion of the transaction `segwit` field failed.
+    Segwit(DecodeScriptSegwitError),
 }
 
 impl fmt::Display for DecodeScriptError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use DecodeScriptError as E;
         match *self {
-            Self::Hex(ref e) => write_err!(f, "conversion of the `hex` field failed"; e),
-            Self::Addresses(ref e) =>
-                write_err!(f, "conversion of the `addresses` field failed"; e),
-            Self::P2sh(ref e) => write_err!(f, "conversion of the `p2sh` field failed"; e),
+            E::Hex(ref e) => write_err!(f, "conversion of the `hex` field failed"; e),
+            E::Addresses(ref e) => write_err!(f, "conversion of the `addresses` field failed"; e),
+            E::P2sh(ref e) => write_err!(f, "conversion of the `p2sh` field failed"; e),
+            E::Segwit(ref e) => write_err!(f, "conversion of the `segwit` field failed"; e),
         }
     }
 }
 
 #[cfg(feature = "std")]
 impl std::error::Error for DecodeScriptError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecodeScriptError as E;
         match *self {
-            Self::Hex(ref e) => Some(e),
-            Self::Addresses(ref e) => Some(e),
-            Self::P2sh(ref e) => Some(e),
+            E::Hex(ref e) => Some(e),
+            E::Addresses(ref e) => Some(e),
+            E::P2sh(ref e) => Some(e),
+            E::Segwit(ref e) => Some(e),
+        }
+    }
+}
+
+/// Error when converting a `DecodeScriptSegwit` type into the model type.
+#[derive(Debug)]
+pub enum DecodeScriptSegwitError {
+    /// Conversion of the transaction `addresses` field failed.
+    Addresses(address::ParseError),
+}
+
+impl fmt::Display for DecodeScriptSegwitError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use DecodeScriptSegwitError as E;
+        match *self {
+            E::Addresses(ref e) =>
+                write_err!(f, "conversion of the `addresses` field in `segwit` failed"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DecodeScriptSegwitError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecodeScriptSegwitError as E;
+        match *self {
+            E::Addresses(ref e) => Some(e),
         }
     }
 }

types/src/v17/raw_transactions/into.rs

@@ -11,10 +11,11 @@ use bitcoin::{
 use super::{
     CombinePsbt, CombineRawTransaction, ConvertToPsbt, CreatePsbt, CreateRawTransaction,
     DecodePsbt, DecodePsbtError, DecodeRawTransaction, DecodeScript, DecodeScriptError,
-    FinalizePsbt, FinalizePsbtError, FundRawTransaction, FundRawTransactionError,
-    GetRawTransaction, GetRawTransactionVerbose, GetRawTransactionVerboseError, MempoolAcceptance,
-    PsbtInput, PsbtInputError, PsbtOutput, PsbtOutputError, SendRawTransaction, SignFail,
-    SignFailError, SignRawTransaction, SignRawTransactionError, TestMempoolAccept,
+    DecodeScriptSegwit, DecodeScriptSegwitError, FinalizePsbt, FinalizePsbtError,
+    FundRawTransaction, FundRawTransactionError, GetRawTransaction, GetRawTransactionVerbose,
+    GetRawTransactionVerboseError, MempoolAcceptance, PsbtInput, PsbtInputError, PsbtOutput,
+    PsbtOutputError, SendRawTransaction, SignFail, SignFailError, SignRawTransaction,
+    SignRawTransactionError, TestMempoolAccept,
 };
 use crate::model;
 use crate::psbt::RawTransactionError;
@@ -309,7 +310,38 @@ impl DecodeScript {
             required_signatures: self.required_signatures,
             addresses,
             p2sh,
-            p2sh_segwit: self.p2sh_segwit,
+            segwit: None,
+        })
+    }
+}
+#[allow(dead_code)]
+impl DecodeScriptSegwit {
+    /// Converts version specific type to a version nonspecific, more strongly typed type.
+    pub fn into_model(self) -> Result<model::DecodeScriptSegwit, DecodeScriptSegwitError> {
+        use DecodeScriptSegwitError as E;
+
+        // Convert `Option<Vec<String>>` to `Vec<Address<NetworkUnchecked>>`
+        let addresses = match self.addresses {
+            Some(addrs) => addrs
+                .into_iter()
+                .map(|s| s.parse::<Address<_>>())
+                .collect::<Result<_, _>>()
+                .map_err(E::Addresses)?,
+            None => vec![],
+        };
+
+        let required_signatures = self.required_signatures;
+        let p2sh_segwit = self.p2sh_segwit;
+
+        Ok(model::DecodeScriptSegwit {
+            asm: self.asm,
+            hex: self.hex,
+            descriptor: None,
+            address: None,
+            type_: self.type_,
+            required_signatures,
+            addresses,
+            p2sh_segwit,
         })
     }
 }