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 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

Author: +Sharon

integration_test/tests/raw_transactions.rs

@@ -214,6 +214,51 @@ fn raw_transactions__decode_script__modelled() {
     }
 }
 
+#[test]
+fn raw_transactions__decode_script_segwit__modelled() {
+    use bitcoin::{Address, Network};
+    use bitcoin::address::NetworkUnchecked;
+    let node = Node::with_wallet(Wallet::Default, &["-txindex"]);
+     // Ensure wallet is loaded (ignore if already loaded)
+    node.client.load_wallet("default").ok();
+    node.fund_wallet();
+    // Get the address from the RPC result
+    let address_unc = node
+        .client
+        .get_new_address(None, None)
+        .expect("getnewaddress")
+        .address()
+        .expect("valid address string");
+    // address_unc is already Address<NetworkUnchecked>
+    // Convert to Address<Network> for script_pubkey
+    let address = address_unc
+        .require_network(Network::Regtest)
+        .expect("must be regtest");
+    let script = address.script_pubkey();
+    let hex = script.to_hex_string();
+    // Decode and model
+    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
+        .expect("Expected DecodeScriptSegwit present for P2WPKH");
+    // Assertions
+    assert!(segwit.asm.contains("OP_"));
+    assert_eq!(segwit.hex, script);
+    assert_eq!(segwit.type_, "witness_v0_keyhash");
+    // Convert `Address<Network>` back to unchecked for comparison
+    let address_unc_check = address.into_unchecked();
+
+    assert!(
+        segwit.addresses.iter().any(|a| a == &address_unc_check),
+        "Expected address {:?} in segwit.addresses: {:?}",
+        address_unc_check,
+        segwit.addresses
+    );
+}
+
 // Script builder code copied from rust-bitcoin script unit tests.
 fn arbitrary_p2pkh_script() -> ScriptBuf {
     let pubkey_hash = <[u8; 20]>::from_hex("16e1ae70ff0fa102905d4af297f6912bda6cce19").unwrap();

types/src/model/mod.rs

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

types/src/model/raw_transactions.rs

@@ -116,8 +116,31 @@ 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>,
+    /// Address of the P2SH script wrapping this witness redeem script.
+    pub p2sh_segwit: Option<Address<NetworkUnchecked>>,
+}
+/// 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

@@ -178,6 +178,8 @@ 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 {
@@ -188,6 +190,7 @@ impl fmt::Display for DecodeScriptError {
             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),
         }
     }
 }
@@ -201,6 +204,34 @@ impl std::error::Error for DecodeScriptError {
             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;
@@ -310,6 +311,38 @@ impl DecodeScript {
             addresses,
             p2sh,
             p2sh_segwit: self.p2sh_segwit,
+            segwit: self.segwit.map(|s| s.into_model()).transpose().map_err(E::Segwit)?,
+        })
+    }
+}
+
+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,
         })
     }
 }

types/src/v17/raw_transactions/mod.rs

@@ -9,6 +9,8 @@ mod into;
 
 use std::collections::HashMap;
 
+use bitcoin::address::{Address, NetworkUnchecked};
+use bitcoin::ScriptBuf;
 use serde::{Deserialize, Serialize};
 
 use crate::ScriptSig;
@@ -17,6 +19,7 @@ use crate::ScriptSig;
 pub use self::error::{
     DecodePsbtError, DecodeScriptError, FundRawTransactionError, GetRawTransactionVerboseError,
     PsbtInputError, PsbtOutputError, SignFailError, SignRawTransactionError, FinalizePsbtError,
+    DecodeScriptSegwitError,
 };
 // Re-export types that appear in the public API of this module.
 pub use crate::psbt::{
@@ -227,33 +230,33 @@ pub struct DecodeScript {
     pub addresses: Option<Vec<String>>,
     /// Address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH).
     pub p2sh: Option<String>,
-    /// Segwit data (see `DecodeScriptSegwit` for explanation).
+    /// Result of a witness output script wrapping this redeem script (not returned for types that should not be wrapped).
     pub segwit: Option<DecodeScriptSegwit>,
     /// Address of the P2SH script wrapping this witness redeem script
     #[serde(rename = "p2sh-segwit")]
-    pub p2sh_segwit: Option<String>,
+    pub p2sh_segwit: Option<Address<NetworkUnchecked>>,
 }
 
 /// Seemingly undocumented data returned in the `segwit` field of `DecodeScript`.
 // This seems to be the same as `DecodeScript` except the `p2sh` field is called `p2sh-segwit`.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct DecodeScriptSegwit {
-    /// Script public key.
+    /// Disassembly of the script.
     pub asm: String,
-    /// Hex encoded public key.
-    pub hex: String,
-    /// The output type.
+    /// The raw output script bytes, hex-encoded.
+    pub hex: ScriptBuf,
+    /// The type of the output script (e.g. witness_v0_keyhash or witness_v0_scripthash).
     #[serde(rename = "type")]
     pub type_: String,
     /// The required signatures.
     #[serde(rename = "reqSigs")]
     pub required_signatures: Option<u64>,
     /// List of bitcoin addresses.
     pub addresses: Option<Vec<String>>,
-    /// Address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH).
+    /// Address of the P2SH script wrapping this witness redeem script.
     #[serde(rename = "p2sh-segwit")]
-    pub p2sh_segwit: Option<String>,
+    pub p2sh_segwit: Option<Address<NetworkUnchecked>>,
 }
 
 /// Result of JSON-RPC method `finalizepsbt`.

types/src/v22/mod.rs

@@ -255,7 +255,9 @@ pub use self::{
     blockchain::GetMempoolInfo,
     control::Logging,
     network::{Banned, GetPeerInfo, ListBanned},
-    raw_transactions::{DecodeScript, DecodeScriptError},
+    raw_transactions::{
+        DecodeScript, DecodeScriptError, DecodeScriptSegwit, DecodeScriptSegwitError,
+    },
     signer::EnumerateSigners,
     wallet::{ListDescriptors, WalletDisplayAddress},
 };

types/src/v22/raw_transactions/error.rs

@@ -17,6 +17,8 @@ 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 {
@@ -28,6 +30,7 @@ impl fmt::Display for DecodeScriptError {
             E::Address(ref e) => write_err!(f, "conversion of the `address` 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),
         }
     }
 }
@@ -42,6 +45,39 @@ impl std::error::Error for DecodeScriptError {
             E::Address(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 `address` field failed.
+    Address(address::ParseError),
+    /// 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::Address(ref e) =>
+                write_err!(f, "conversion of the `address` field in `segwit` failed"; e),
+            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::Address(ref e) => Some(e),
+            E::Addresses(ref e) => Some(e),
         }
     }
 }

types/src/v22/raw_transactions/into.rs

@@ -2,7 +2,7 @@
 
 use bitcoin::Address;
 
-use super::{DecodeScript, DecodeScriptError};
+use super::{DecodeScript, DecodeScriptError, DecodeScriptSegwit, DecodeScriptSegwitError};
 use crate::model;
 
 impl DecodeScript {
@@ -32,7 +32,43 @@ impl DecodeScript {
             required_signatures: self.required_signatures,
             addresses,
             p2sh,
+            segwit: self.segwit.map(|s| s.into_model()).transpose().map_err(E::Segwit)?,
             p2sh_segwit: self.p2sh_segwit,
         })
     }
 }
+
+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;
+
+        let address = match self.address {
+            Some(addr) => Some(addr.parse::<Address<_>>().map_err(E::Address)?),
+            None => None,
+        };
+        // 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,
+            type_: self.type_,
+            address,
+            required_signatures,
+            addresses,
+            p2sh_segwit,
+        })
+    }
+}