diff --git a/src/lib.rs b/src/lib.rs
index bba141c..baf44ac 100644
--- a/src/lib.rs
+++ b/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;
-use bitcoin::TxIn as BitcoinTxIn;
-use bitcoin::TxOut as BitcoinTxOut;
-pub use bitcoin::Txid as BitcoinTxid;
 
 pub use bitcoin::BlockHash;
 pub use bitcoin::Txid;
@@ -29,20 +19,21 @@ 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(
+        let address = bitcoin::Address::from_script(
             &script.0.clone(),
             Into::<bitcoin::Network>::into(network),
         )?;
@@ -59,7 +50,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
@@ -73,18 +64,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),
@@ -93,7 +83,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 {
@@ -109,11 +99,11 @@ 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 {
@@ -135,17 +125,17 @@ 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 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)
     }
 
@@ -154,8 +144,8 @@ 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 {
@@ -163,8 +153,8 @@ pub struct TxOut {
     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)),
@@ -172,9 +162,9 @@ impl From<BitcoinTxOut> for TxOut {
     }
 }
 
-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(),
         }
@@ -182,18 +172,18 @@ impl From<TxOut> for BitcoinTxOut {
 }
 
 #[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))
     }
 
@@ -206,8 +196,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 {
@@ -217,8 +207,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()),
@@ -228,8 +218,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()),
@@ -239,25 +229,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))
     }
 
@@ -320,8 +310,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]
diff --git a/src/macros.rs b/src/macros.rs
index f53a134..7816ab4 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,15 +1,15 @@
 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