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.

Author: +Sharon

types/src/model/mod.rs

@@ -41,7 +41,7 @@ pub use self::{
     raw_transactions::{
         AnalyzePsbt, AnalyzePsbtInput, AnalyzePsbtInputMissing, CombinePsbt, CombineRawTransaction,
         ConvertToPsbt, CreatePsbt, CreateRawTransaction, DecodePsbt, DecodeRawTransaction,
-        DecodeScript, DescriptorProcessPsbt, FinalizePsbt, FundRawTransaction, GetRawTransaction,
+        DecodeScript,DecodeScriptSegwit, DescriptorProcessPsbt, FinalizePsbt, FundRawTransaction, GetRawTransaction,
         GetRawTransactionVerbose, JoinPsbts, MempoolAcceptance, SendRawTransaction, SignFail,
         SignRawTransaction, SubmitPackage, SubmitPackageTxResult, SubmitPackageTxResultFees,
         TestMempoolAccept, UtxoUpdatePsbt,

types/src/model/raw_transactions.rs

@@ -116,8 +116,30 @@ 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>>,
+    /// Segwit data (see `DecodeScriptSegwit` for explanation).
+    pub segwit: Option<DecodeScriptSegwit>,
     /// Address of the P2SH script wrapping this witness redeem script
     pub p2sh_segwit: Option<String>,
+    
+}
+/// Models the `segwit` field returned by the `decodescript` RPC.
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct DecodeScriptSegwit {
+    /// The witness program.
+    pub asm: String,
+    /// Hex-encoded script.
+    pub hex: String,
+    /// The output type.
+    pub type_: String,
+    /// Bitcoin address (only if a well-defined address exists).
+    pub address: Option<Address<NetworkUnchecked>>,
+    /// The required signatures.
+    pub required_signatures: Option<u64>,
+    /// List of bitcoin addresses.
+    pub addresses: Vec<Address<NetworkUnchecked>>,
+    /// Address of the P2SH script wrapping this witness redeem script.
+    pub p2sh_segwit: Option<String>,
 }
 
 /// Models the result of JSON-RPC method `descriptorprocesspsbt`.

types/src/v17/raw_transactions/into.rs

@@ -310,6 +310,7 @@ impl DecodeScript {
             addresses,
             p2sh,
             p2sh_segwit: self.p2sh_segwit,
+            segwit: None,
         })
     }
 }

types/src/v22/mod.rs

@@ -253,7 +253,7 @@ pub use self::{
     blockchain::GetMempoolInfo,
     control::Logging,
     network::{Banned, GetPeerInfo, ListBanned},
-    raw_transactions::{DecodeScript, DecodeScriptError},
+    raw_transactions::{DecodeScript, DecodeScriptError,DecodeScriptSegwit,DecodeScriptSegwitError},
 };
 #[doc(inline)]
 pub use crate::{

types/src/v22/raw_transactions/error.rs

@@ -15,8 +15,11 @@ pub enum DecodeScriptError {
     Address(address::ParseError),
     /// Conversion of the transaction `addresses` field failed.
     Addresses(address::ParseError),
+    /// Conversion of the transaction `segwit` field failed.
+    Segwit(DecodeScriptSegwitError),
     /// Conversion of the transaction `p2sh` field failed.
     P2sh(address::ParseError),
+    
 }
 
 impl fmt::Display for DecodeScriptError {
@@ -27,6 +30,7 @@ impl fmt::Display for DecodeScriptError {
             E::Hex(ref e) => write_err!(f, "conversion of the `hex` field failed"; e),
             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::Segwit(ref e) => write_err!(f, "conversion of the `segwit` field failed"; e),
             E::P2sh(ref e) => write_err!(f, "conversion of the `p2sh` field failed"; e),
         }
     }
@@ -41,7 +45,49 @@ impl std::error::Error for DecodeScriptError {
             E::Hex(ref e) => Some(e),
             E::Address(ref e) => Some(e),
             E::Addresses(ref e) => Some(e),
+            E::Segwit(ref e) => Some(e),
             E::P2sh(ref e) => Some(e),
         }
     }
 }
+
+/// Error when converting a `DecodeScriptSegwit` type into the model type.
+#[derive(Debug)]
+pub enum DecodeScriptSegwitError {
+    /// An invalid or missing field in the `DecodeScriptSegwit` data.
+    InvalidField(&'static str),
+    /// 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::InvalidField(name) =>
+                write!(f, "conversion of the `segwit` field failed: invalid or missing field `{}`", name),
+            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::InvalidField(_) => None,
+            E::Address(ref e) => Some(e),
+            E::Addresses(ref e) => Some(e),
+        }
+    }
+}
+
+

types/src/v22/raw_transactions/into.rs

@@ -2,7 +2,8 @@
 
 use bitcoin::Address;
 
-use super::{DecodeScript, DecodeScriptError};
+use super::{DecodeScript, DecodeScriptError, DecodeScriptSegwit, DecodeScriptSegwitError}; 
+
 use crate::model;
 
 impl DecodeScript {
@@ -23,7 +24,7 @@ impl DecodeScript {
             None => vec![],
         };
         let p2sh = self.p2sh.map(|s| s.parse::<Address<_>>()).transpose().map_err(E::P2sh)?;
-
+        
         Ok(model::DecodeScript {
             script_pubkey: None,
             type_: self.type_,
@@ -32,7 +33,44 @@ 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,
+            type_: self.type_,
+            address,
+            required_signatures,
+            addresses,
+            p2sh_segwit,
         })
+           
     }
 }

types/src/v22/raw_transactions/mod.rs

@@ -9,7 +9,7 @@ mod into;
 
 use serde::{Deserialize, Serialize};
 
-pub use self::error::DecodeScriptError;
+pub use self::error::{DecodeScriptError,DecodeScriptSegwitError};
 
 /// Result of JSON-RPC method `decodescript`.
 ///
@@ -64,5 +64,5 @@ pub struct DecodeScriptSegwit {
     pub addresses: Option<Vec<String>>,
     /// Address of P2SH script wrapping this redeem script (not returned if the script is already a P2SH).
     #[serde(rename = "p2sh-segwit")]
-    pub p2sh_segtwit: Option<String>,
+    pub p2sh_segwit: Option<String>,
 }

types/src/v23/mod.rs

@@ -250,7 +250,7 @@ pub use self::{
     network::GetPeerInfo,
     raw_transactions::{
         DecodePsbt, DecodePsbtError, DecodeScript, DecodeScriptError, GlobalXpub, Proprietary,
-        PsbtInput, PsbtOutput,
+        PsbtInput, PsbtOutput,DecodeScriptSegwit,DecodeScriptSegwitError
     },
     util::CreateMultisig,
     wallet::{GetTransaction, GetTransactionError},
@@ -306,5 +306,5 @@ pub use crate::{
     },
     v20::{GenerateToDescriptor, GetTransactionDetail},
     v21::{GetNetworkInfo, UnloadWallet},
-    v22::{Banned, GetMempoolInfo, ListBanned, ScriptPubkey},
+    v22::{Banned, GetMempoolInfo, ListBanned, ScriptPubkey,},
 };

types/src/v23/raw_transactions/error.rs

@@ -265,6 +265,8 @@ pub enum DecodeScriptError {
     Address(address::ParseError),
     /// Conversion of the transaction `addresses` field failed.
     Addresses(address::ParseError),
+    /// Conversion of the transaction `segwit` field failed.
+    Segwit(DecodeScriptSegwitError),
     /// Conversion of the transaction `p2sh` field failed.
     P2sh(address::ParseError),
 }
@@ -277,6 +279,7 @@ impl fmt::Display for DecodeScriptError {
             E::Hex(ref e) => write_err!(f, "conversion of the `hex` field failed"; e),
             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::Segwit(ref e) => write_err!(f, "conversion of the `segwit` field failed"; e),
             E::P2sh(ref e) => write_err!(f, "conversion of the `p2sh` field failed"; e),
         }
     }
@@ -291,7 +294,42 @@ impl std::error::Error for DecodeScriptError {
             E::Hex(ref e) => Some(e),
             E::Address(ref e) => Some(e),
             E::Addresses(ref e) => Some(e),
+            E::Segwit(ref e) => Some(e),
             E::P2sh(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/v23/raw_transactions/into.rs

@@ -10,8 +10,10 @@ use bitcoin::{Address, Amount};
 
 use super::{
     DecodePsbt, DecodePsbtError, DecodeScript, DecodeScriptError, GlobalXpub, GlobalXpubError,
-    Proprietary, PsbtInput, PsbtInputError, PsbtOutput, PsbtOutputError,
+    Proprietary, PsbtInput, PsbtInputError, PsbtOutput, PsbtOutputError,DecodeScriptSegwit,
+    DecodeScriptSegwitError,
 };
+
 use crate::model;
 
 impl DecodePsbt {
@@ -324,8 +326,10 @@ impl DecodeScript {
                 .map_err(E::Addresses)?,
             None => vec![],
         };
-        let p2sh = self.p2sh.map(|s| s.parse::<Address<_>>()).transpose().map_err(E::P2sh)?;
 
+        
+        let p2sh = self.p2sh.map(|s| s.parse::<Address<_>>()).transpose().map_err(E::P2sh)?;
+        
         Ok(model::DecodeScript {
             script_pubkey: None,
             type_: self.type_,
@@ -334,7 +338,40 @@ 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,
+        };
+
+        let addresses = match self.addresses {
+            Some(addrs) => addrs
+                .into_iter()
+                .map(|s| s.parse::<Address<_>>())
+                .collect::<Result<_, _>>()
+                .map_err(E::Addresses)?,
+            None => vec![],
+        };
+
+        Ok(model::DecodeScriptSegwit {
+            asm: self.asm,
+            hex: self.hex,
+            type_: self.type_,
+            address,
+            required_signatures: self.required_signatures,
+            addresses,
             p2sh_segwit: self.p2sh_segwit,
         })
     }
 }
+