Accept qualified types in impl_from_* macros

Author: DanGould

src/lib.rs

@@ -1,15 +1,5 @@
 use bitcoin::address::{NetworkChecked, NetworkUnchecked};
 use bitcoin::consensus::{deserialize, serialize};
-use bitcoin::Address as BitcoinAddress;
-use bitcoin::Amount as BitcoinAmount;
-use bitcoin::FeeRate as BitcoinFeeRate;
-use bitcoin::OutPoint as BitcoinOutPoint;
-use bitcoin::ScriptBuf as BitcoinScriptBuf;
-use bitcoin::Sequence;
-use bitcoin::Transaction as BitcoinTransaction;
-pub use bitcoin::Txid as BitcoinTxid;
-use bitcoin::TxIn as BitcoinTxIn;
-use bitcoin::TxOut as BitcoinTxOut;
 
 pub use bitcoin::BlockHash;
 
@@ -28,20 +18,20 @@ mod macros;
 pub mod error;
 
 #[derive(Debug, PartialEq, Eq, uniffi::Object)]
-pub struct Address(BitcoinAddress<NetworkChecked>);
+pub struct Address(bitcoin::Address<NetworkChecked>);
 
 #[uniffi::export]
 impl Address {
     #[uniffi::constructor]
     pub fn new(address: String, network: Network) -> Result<Self, AddressParseError> {
-        let parsed_address = BitcoinAddress::from_str(&address).map_err(AddressParseError::from)?;
+        let parsed_address = bitcoin::Address::from_str(&address).map_err(AddressParseError::from)?;
         let network_checked_address = parsed_address.require_network(network.into())?;
         Ok(Address(network_checked_address))
     }
 
     #[uniffi::constructor]
     pub fn from_script(script: Arc<Script>, network: Network) -> Result<Self, FromScriptError> {
-        let address = BitcoinAddress::from_script(&script.0.clone(), Into::<bitcoin::Network>::into(network))?;
+        let address = bitcoin::Address::from_script(&script.0.clone(), Into::<bitcoin::Network>::into(network))?;
         Ok(Address(address))
     }
 
@@ -55,7 +45,7 @@ impl Address {
 
     pub fn is_valid_for_network(&self, network: Network) -> bool {
         let address_str = self.0.to_string();
-        if let Ok(unchecked_address) = address_str.parse::<BitcoinAddress<NetworkUnchecked>>() {
+        if let Ok(unchecked_address) = address_str.parse::<bitcoin::Address<NetworkUnchecked>>() {
             unchecked_address.is_valid_for_network(network.into())
         } else {
             false
@@ -69,18 +59,17 @@ impl Display for Address {
     }
 }
 
-type CheckedBitcoinAddress = BitcoinAddress<NetworkChecked>;
-impl_from_core_type!(Address, CheckedBitcoinAddress);
-impl_from_ffi_type!(Address, CheckedBitcoinAddress);
+impl_from_core_type!(Address, bitcoin::Address<NetworkChecked>);
+impl_from_ffi_type!(Address, bitcoin::Address<NetworkChecked>);
 
 #[derive(Clone, Debug, uniffi::Object)]
-pub struct FeeRate(pub BitcoinFeeRate);
+pub struct FeeRate(pub bitcoin::FeeRate);
 
 #[uniffi::export]
 impl FeeRate {
     #[uniffi::constructor]
     pub fn from_sat_per_vb(sat_per_vb: u64) -> Result<Self, FeeRateError> {
-        let fee_rate: Option<BitcoinFeeRate> = BitcoinFeeRate::from_sat_per_vb(sat_per_vb);
+        let fee_rate: Option<bitcoin::FeeRate> = bitcoin::FeeRate::from_sat_per_vb(sat_per_vb);
         match fee_rate {
             Some(fee_rate) => Ok(FeeRate(fee_rate)),
             None => Err(FeeRateError::ArithmeticOverflow),
@@ -89,7 +78,7 @@ impl FeeRate {
 
     #[uniffi::constructor]
     pub fn from_sat_per_kwu(sat_per_kwu: u64) -> Self {
-        FeeRate(BitcoinFeeRate::from_sat_per_kwu(sat_per_kwu))
+        FeeRate(bitcoin::FeeRate::from_sat_per_kwu(sat_per_kwu))
     }
 
     pub fn to_sat_per_vb_ceil(&self) -> u64 {
@@ -105,17 +94,17 @@ impl FeeRate {
     }
 }
 
-impl_from_core_type!(FeeRate, BitcoinFeeRate);
-impl_from_ffi_type!(FeeRate, BitcoinFeeRate);
+impl_from_core_type!(FeeRate, bitcoin::FeeRate);
+impl_from_ffi_type!(FeeRate, bitcoin::FeeRate);
 
 #[derive(Clone, Debug, PartialEq, Eq, uniffi::Object)]
-pub struct OutPoint(pub BitcoinOutPoint);
+pub struct OutPoint(pub bitcoin::OutPoint);
 
 #[uniffi::export]
 impl OutPoint {
     #[uniffi::constructor]
     pub fn new(txid: Arc<Txid>, vout: u32) -> Self {
-        OutPoint(BitcoinOutPoint::new(txid.0, vout))
+        OutPoint(bitcoin::OutPoint::new(txid.0, vout))
     }
 
     pub fn txid(&self) -> Arc<Txid> {
@@ -131,23 +120,23 @@ impl OutPoint {
     }
 }
 
-impl_from_core_type!(OutPoint, BitcoinOutPoint);
-impl_from_ffi_type!(OutPoint, BitcoinOutPoint);
+impl_from_core_type!(OutPoint, bitcoin::OutPoint);
+impl_from_ffi_type!(OutPoint, bitcoin::OutPoint);
 
 #[derive(Clone, Debug, PartialEq, Eq, uniffi::Object)]
-pub struct Txid(pub BitcoinTxid);
+pub struct Txid(pub bitcoin::Txid);
 
-impl_from_core_type!(Txid, BitcoinTxid);
-impl_from_ffi_type!(Txid, BitcoinTxid);
+impl_from_core_type!(Txid, bitcoin::Txid);
+impl_from_ffi_type!(Txid, bitcoin::Txid);
 
 #[derive(Clone, Debug, PartialEq, Eq, uniffi::Object)]
-pub struct Script(pub BitcoinScriptBuf);
+pub struct Script(pub bitcoin::ScriptBuf);
 
 #[uniffi::export]
 impl Script {
     #[uniffi::constructor]
     pub fn new(raw_output_script: Vec<u8>) -> Self {
-        let script: BitcoinScriptBuf = raw_output_script.into();
+        let script: bitcoin::ScriptBuf = raw_output_script.into();
         Script(script)
     }
 
@@ -156,46 +145,46 @@ impl Script {
     }
 }
 
-impl_from_core_type!(Script, BitcoinScriptBuf);
-impl_from_ffi_type!(Script, BitcoinScriptBuf);
+impl_from_core_type!(Script, bitcoin::ScriptBuf);
+impl_from_ffi_type!(Script, bitcoin::ScriptBuf);
 
 #[derive(Debug, Clone, uniffi::Record)]
 pub struct TxOut {
     pub value: Arc<Amount>,
     pub script_pubkey: Arc<Script>,
 }
 
-impl From<BitcoinTxOut> for TxOut {
-    fn from(tx_out: BitcoinTxOut) -> Self {
+impl From<bitcoin::TxOut> for TxOut {
+    fn from(tx_out: bitcoin::TxOut) -> Self {
         TxOut {
             value: Arc::new(Amount(tx_out.value)),
             script_pubkey: Arc::new(Script(tx_out.script_pubkey)),
         }
     }
 }
 
-impl From<TxOut> for BitcoinTxOut {
+impl From<TxOut> for bitcoin::TxOut {
     fn from(tx_out: TxOut) -> Self {
-        BitcoinTxOut {
+        bitcoin::TxOut {
             value: tx_out.value.0,
             script_pubkey: tx_out.script_pubkey.0.clone(),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
-pub struct Amount(pub BitcoinAmount);
+pub struct Amount(pub bitcoin::Amount);
 
 #[uniffi::export]
 impl Amount {
     #[uniffi::constructor]
     pub fn from_sat(sat: u64) -> Self {
-        Amount(BitcoinAmount::from_sat(sat))
+        Amount(bitcoin::Amount::from_sat(sat))
     }
 
     #[uniffi::constructor]
     pub fn from_btc(btc: f64) -> Result<Self, ParseAmountError> {
-        let bitcoin_amount = BitcoinAmount::from_btc(btc).map_err(ParseAmountError::from)?;
+        let bitcoin_amount = bitcoin::Amount::from_btc(btc).map_err(ParseAmountError::from)?;
         Ok(Amount(bitcoin_amount))
     }
 
@@ -208,8 +197,8 @@ impl Amount {
     }
 }
 
-impl_from_core_type!(Amount, BitcoinAmount);
-impl_from_ffi_type!(Amount, BitcoinAmount);
+impl_from_core_type!(Amount, bitcoin::Amount);
+impl_from_ffi_type!(Amount, bitcoin::Amount);
 
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
 pub struct TxIn {
@@ -219,8 +208,8 @@ pub struct TxIn {
     pub witness: Vec<Vec<u8>>,
 }
 
-impl From<BitcoinTxIn> for TxIn {
-    fn from(tx_in: BitcoinTxIn) -> Self {
+impl From<bitcoin::TxIn> for TxIn {
+    fn from(tx_in: bitcoin::TxIn) -> Self {
         TxIn {
             previous_output: Arc::new(tx_in.previous_output.into()),
             script_sig: Arc::new(tx_in.script_sig.into()),
@@ -230,8 +219,8 @@ impl From<BitcoinTxIn> for TxIn {
     }
 }
 
-impl From<&BitcoinTxIn> for TxIn {
-    fn from(tx_in: &BitcoinTxIn) -> Self {
+impl From<&bitcoin::TxIn> for TxIn {
+    fn from(tx_in: &bitcoin::TxIn) -> Self {
         TxIn {
             previous_output: Arc::new(tx_in.previous_output.into()),
             script_sig: Arc::new(tx_in.script_sig.clone().into()),
@@ -241,25 +230,25 @@ impl From<&BitcoinTxIn> for TxIn {
     }
 }
 
-impl From<TxIn> for BitcoinTxIn {
+impl From<TxIn> for bitcoin::TxIn {
     fn from(tx_in: TxIn) -> Self {
-        BitcoinTxIn {
+        bitcoin::TxIn {
             previous_output: tx_in.previous_output.0,
             script_sig: tx_in.script_sig.0.clone(),
-            sequence: Sequence(tx_in.sequence),
+            sequence: bitcoin::Sequence(tx_in.sequence),
             witness: tx_in.witness.into(),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
-pub struct Transaction(pub BitcoinTransaction);
+pub struct Transaction(pub bitcoin::Transaction);
 
 #[uniffi::export]
 impl Transaction {
     #[uniffi::constructor]
     pub fn deserialize(transaction_bytes: &[u8]) -> Result<Self, EncodeError> {
-        let transaction: BitcoinTransaction = deserialize(transaction_bytes)?;
+        let transaction: bitcoin::Transaction = deserialize(transaction_bytes)?;
         Ok(Transaction(transaction))
     }
 
@@ -322,8 +311,8 @@ impl Transaction {
     }
 }
 
-impl_from_core_type!(Transaction, BitcoinTransaction);
-impl_from_ffi_type!(Transaction, BitcoinTransaction);
+impl_from_core_type!(Transaction, bitcoin::Transaction);
+impl_from_ffi_type!(Transaction, bitcoin::Transaction);
 
 #[derive(Clone, Default, uniffi::Enum)]
 #[non_exhaustive]

src/macros.rs

@@ -1,18 +1,18 @@
 macro_rules! impl_from_core_type {
-    ($ffi_type:ident, $core_type:ident) => {
+    ($ffi_type:ty, $core_type:ty) => {
         impl From<$core_type> for $ffi_type {
             fn from(core_type: $core_type) -> Self {
-                $ffi_type(core_type)
+                Self(core_type)
             }
         }
     };
 }
 
 macro_rules! impl_from_ffi_type {
-    ($ffi_type:ident, $core_type:ident) => {
+    ($ffi_type:ty, $core_type:ty) => {
         impl From<$ffi_type> for $core_type {
             fn from(ffi_type: $ffi_type) -> Self {
-                ffi_type.0
+                ffi_type.into()
             }
         }
     };