From 3153d05f3fe07d1b5fedca5307f44691a35b7758 Mon Sep 17 00:00:00 2001
From: DanGould <d@ngould.dev>
Date: Wed, 13 Nov 2024 13:57:42 -0500
Subject: [PATCH 1/3] Bind to uniffi using proc macros

Proc macros let rust-analyzer check that types are compatible
at rust compile time, and thus let downstream projects more easily
depend on bitcoin-ffi.

The `Network` enum is defined in the UDL file, but we need to define it
in rust with `uniffi::Enum` in order to check UniFFI bindings at rust
compile time.

"It is permitted to use this [`uniffi::Enum`] macro on a type that is
also defined in the UDL file as long as the two definitions are equal in
the names and ordering of variants and variant fields"

see: https://mozilla.github.io/uniffi-rs/latest/proc_macro/index.html#the-uniffienum-derive
---
 src/bitcoin.udl | 151 ++----------------------------------------------
 src/error.rs    |  10 ++--
 src/lib.rs      | 103 +++++++++++++++++++++++++++------
 3 files changed, 95 insertions(+), 169 deletions(-)

diff --git a/src/bitcoin.udl b/src/bitcoin.udl
index cb817d4..ba5e9c8 100644
--- a/src/bitcoin.udl
+++ b/src/bitcoin.udl
@@ -1,152 +1,9 @@
 namespace bitcoin {};
 
-// ------------------------------------------------------------------------
-// Core types
-// ------------------------------------------------------------------------
-
-interface Script {
-  constructor(sequence<u8> raw_output_script);
- 
-  sequence<u8> to_bytes();
-};
-
-interface Amount {
-  [Name=from_sat]
-  constructor(u64 from_sat);
-
-  [Name=from_btc, Throws=ParseAmountError]
-  constructor(f64 from_btc);
-
-  u64 to_sat();
-
-  f64 to_btc();
-};
-
-interface FeeRate {
-  [Name=from_sat_per_vb, Throws=FeeRateError]
-  constructor(u64 sat_per_vb);
-
-  [Name=from_sat_per_kwu]
-  constructor(u64 sat_per_kwu);
-
-  u64 to_sat_per_vb_ceil();
-
-  u64 to_sat_per_vb_floor();
-
-  u64 to_sat_per_kwu();
-};
-
-[Custom]
-typedef string Txid;
-
-[Custom]
-typedef string BlockHash;
-
-dictionary OutPoint {
-  Txid txid;
-  u32 vout;
-};
-
-dictionary TxIn {
-  OutPoint previous_output;
-  Script script_sig;
-  u32 sequence;
-  sequence<sequence<u8>> witness;
-};
-
 [NonExhaustive]
 enum Network {
-  "Bitcoin",
-  "Testnet",
-  "Signet",
-  "Regtest",
-};
-
-[Traits=(Display)]
-interface Address {
-  [Throws=AddressParseError]
-  constructor(string address, Network network);
-
-  [Name=from_script, Throws=FromScriptError]
-  constructor(Script script, Network network);
-
-  Script script_pubkey();
-
-  string to_qr_uri();
-
-  boolean is_valid_for_network(Network network);
-};
-
-dictionary TxOut {
-  Amount value;
-  Script script_pubkey;
-};
-
-interface Transaction {
-  [Name=deserialize, Throws=EncodeError]
-  constructor([ByRef] bytes transaction_bytes);
-  bytes serialize();
-  string compute_txid();
-  u64 total_size();
-  u64 vsize();
-  boolean is_coinbase();
-  boolean is_explicitly_rbf();
-  boolean is_lock_time_enabled();
-  i32 version();
-  u64 weight();
-  sequence<TxIn> input();
-  sequence<TxOut> output();
-  u32 lock_time();
-};
-
-// ------------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------------
-
-[Error]
-enum AddressParseError {
-    "Base58",
-    "Bech32",
-    "WitnessVersion",
-    "WitnessProgram",
-    "UnknownHrp",
-    "LegacyAddressTooLong",
-    "InvalidBase58PayloadLength",
-    "InvalidLegacyPrefix",
-    "NetworkValidation",
-    "OtherAddressParseErr",
-};
-
-[Error]
-interface FromScriptError {
-  UnrecognizedScript();
-  WitnessProgram(string error_message);
-  WitnessVersion(string error_message);
-  OtherFromScriptErr();
-};
-
-[Error]
-interface ParseAmountError {
-  OutOfRange();
-  TooPrecise();
-  MissingDigits();
-  InputTooLarge();
-  InvalidCharacter(string error_message);
-  OtherParseAmountErr();
-};
-
-[Error]
-interface FeeRateError {
-  ArithmeticOverflow();
-};
-
-[Error]
-interface EncodeError {
-  Io();
-  OversizedVectorAllocation();
-  InvalidChecksum(string expected, string actual);
-  NonMinimalVarInt();
-  ParseFailed();
-  UnsupportedSegwitFlag(u8 flag);
-  OtherEncodeErr();
+    "Bitcoin",
+    "Testnet",
+    "Signet",
+    "Regtest",
 };
\ No newline at end of file
diff --git a/src/error.rs b/src/error.rs
index 3303104..ded9785 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,7 +4,7 @@ use bitcoin::amount::ParseAmountError as BitcoinParseAmountError;
 use bitcoin::consensus::encode::Error as BitcoinEncodeError;
 use bitcoin::hex::DisplayHex;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, uniffi::Error)]
 pub enum AddressParseError {
     #[error("base58 address encoding error")]
     Base58,
@@ -51,13 +51,13 @@ impl From<BitcoinParseError> for AddressParseError {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, uniffi::Error)]
 pub enum FeeRateError {
     #[error("arithmetic overflow on feerate")]
     ArithmeticOverflow,
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, uniffi::Error)]
 pub enum FromScriptError {
     #[error("script is not a p2pkh, p2sh or witness program")]
     UnrecognizedScript,
@@ -88,7 +88,7 @@ impl From<BitcoinFromScriptError> for FromScriptError {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, uniffi::Error)]
 pub enum ParseAmountError {
     #[error("amount out of range")]
     OutOfRange,
@@ -125,7 +125,7 @@ impl From<BitcoinParseAmountError> for ParseAmountError {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, uniffi::Error)]
 pub enum EncodeError {
     #[error("io error")]
     Io,
diff --git a/src/lib.rs b/src/lib.rs
index b4901b9..3538ca5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,7 +10,6 @@ use bitcoin::TxIn as BitcoinTxIn;
 use bitcoin::TxOut as BitcoinTxOut;
 
 pub use bitcoin::BlockHash;
-pub use bitcoin::OutPoint;
 pub use bitcoin::Txid;
 
 use error::AddressParseError;
@@ -26,20 +25,25 @@ use std::sync::Arc;
 #[macro_use]
 mod macros;
 pub mod error;
-pub use bitcoin::Network;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
 pub struct Address(BitcoinAddress<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 network_checked_address = parsed_address.require_network(network)?;
+        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(), network)?;
+        let address = BitcoinAddress::from_script(
+            &script.0.clone(),
+            Into::<bitcoin::Network>::into(network),
+        )?;
         Ok(Address(address))
     }
 
@@ -54,7 +58,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>>() {
-            unchecked_address.is_valid_for_network(network)
+            unchecked_address.is_valid_for_network(network.into())
         } else {
             false
         }
@@ -71,10 +75,12 @@ type CheckedBitcoinAddress = BitcoinAddress<NetworkChecked>;
 impl_from_core_type!(Address, CheckedBitcoinAddress);
 impl_from_ffi_type!(Address, CheckedBitcoinAddress);
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, uniffi::Object)]
 pub struct FeeRate(pub BitcoinFeeRate);
 
+#[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);
         match fee_rate {
@@ -83,6 +89,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))
     }
@@ -103,10 +110,32 @@ impl FeeRate {
 impl_from_core_type!(FeeRate, BitcoinFeeRate);
 impl_from_ffi_type!(FeeRate, BitcoinFeeRate);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, uniffi::Record)]
+pub struct OutPoint {
+    pub txid: Txid,
+    pub vout: u32,
+}
+impl From<bitcoin::OutPoint> for OutPoint {
+    fn from(outpoint: bitcoin::OutPoint) -> Self {
+        OutPoint {
+            txid: outpoint.txid,
+            vout: outpoint.vout,
+        }
+    }
+}
+
+impl From<OutPoint> for bitcoin::OutPoint {
+    fn from(outpoint: OutPoint) -> Self {
+        bitcoin::OutPoint::new(outpoint.txid, outpoint.vout)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, uniffi::Object)]
 pub struct Script(pub BitcoinScriptBuf);
 
+#[uniffi::export]
 impl Script {
+    #[uniffi::constructor]
     pub fn new(raw_output_script: Vec<u8>) -> Self {
         let script: BitcoinScriptBuf = raw_output_script.into();
         Script(script)
@@ -120,7 +149,7 @@ impl Script {
 impl_from_core_type!(Script, BitcoinScriptBuf);
 impl_from_ffi_type!(Script, BitcoinScriptBuf);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, uniffi::Record)]
 pub struct TxOut {
     pub value: Arc<Amount>,
     pub script_pubkey: Arc<Script>,
@@ -144,14 +173,17 @@ impl From<TxOut> for BitcoinTxOut {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
 pub struct Amount(pub BitcoinAmount);
 
+#[uniffi::export]
 impl Amount {
+    #[uniffi::constructor]
     pub fn from_sat(sat: u64) -> Self {
         Amount(BitcoinAmount::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)?;
         Ok(Amount(bitcoin_amount))
@@ -169,7 +201,7 @@ impl Amount {
 impl_from_core_type!(Amount, BitcoinAmount);
 impl_from_ffi_type!(Amount, BitcoinAmount);
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
 pub struct TxIn {
     pub previous_output: OutPoint,
     pub script_sig: Arc<Script>,
@@ -180,7 +212,7 @@ pub struct TxIn {
 impl From<BitcoinTxIn> for TxIn {
     fn from(tx_in: BitcoinTxIn) -> Self {
         TxIn {
-            previous_output: tx_in.previous_output,
+            previous_output: tx_in.previous_output.into(),
             script_sig: Arc::new(tx_in.script_sig.into()),
             sequence: tx_in.sequence.0,
             witness: tx_in.witness.to_vec(),
@@ -191,7 +223,7 @@ impl From<BitcoinTxIn> for TxIn {
 impl From<&BitcoinTxIn> for TxIn {
     fn from(tx_in: &BitcoinTxIn) -> Self {
         TxIn {
-            previous_output: tx_in.previous_output,
+            previous_output: tx_in.previous_output.into(),
             script_sig: Arc::new(tx_in.script_sig.clone().into()),
             sequence: tx_in.sequence.0,
             witness: tx_in.witness.to_vec(),
@@ -202,7 +234,7 @@ impl From<&BitcoinTxIn> for TxIn {
 impl From<TxIn> for BitcoinTxIn {
     fn from(tx_in: TxIn) -> Self {
         BitcoinTxIn {
-            previous_output: tx_in.previous_output,
+            previous_output: tx_in.previous_output.into(),
             script_sig: tx_in.script_sig.0.clone(),
             sequence: Sequence(tx_in.sequence),
             witness: tx_in.witness.into(),
@@ -210,10 +242,12 @@ impl From<TxIn> for BitcoinTxIn {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
 pub struct Transaction(pub BitcoinTransaction);
 
+#[uniffi::export]
 impl Transaction {
+    #[uniffi::constructor]
     pub fn deserialize(transaction_bytes: &[u8]) -> Result<Self, EncodeError> {
         let transaction: BitcoinTransaction = deserialize(transaction_bytes)?;
         Ok(Transaction(transaction))
@@ -281,7 +315,42 @@ impl Transaction {
 impl_from_core_type!(Transaction, BitcoinTransaction);
 impl_from_ffi_type!(Transaction, BitcoinTransaction);
 
-impl_string_custom_typedef!(BlockHash);
+#[derive(Clone, Default, uniffi::Enum)]
+#[non_exhaustive]
+pub enum Network {
+    #[default]
+    Bitcoin,
+    Testnet,
+    Signet,
+    Regtest,
+}
+
+impl From<Network> for bitcoin::Network {
+    fn from(network: Network) -> Self {
+        match network {
+            Network::Bitcoin => bitcoin::Network::Bitcoin,
+            Network::Testnet => bitcoin::Network::Testnet,
+            Network::Signet => bitcoin::Network::Signet,
+            Network::Regtest => bitcoin::Network::Regtest,
+        }
+    }
+}
+
+impl From<bitcoin::Network> for Network {
+    fn from(network: bitcoin::Network) -> Self {
+        match network {
+            bitcoin::Network::Bitcoin => Network::Bitcoin,
+            bitcoin::Network::Testnet => Network::Testnet,
+            bitcoin::Network::Signet => Network::Signet,
+            bitcoin::Network::Regtest => Network::Regtest,
+            _ => unreachable!(),
+        }
+    }
+}
+
+uniffi::custom_type!(Txid, String);
 impl_string_custom_typedef!(Txid);
+uniffi::custom_type!(BlockHash, String);
+impl_string_custom_typedef!(BlockHash);
 
-uniffi::include_scaffolding!("bitcoin");
+uniffi::setup_scaffolding!("bitcoin");

From 2f072c92e33353e5ced73f31615e5029914b48de Mon Sep 17 00:00:00 2001
From: DanGould <d@ngould.dev>
Date: Wed, 13 Nov 2024 14:06:38 -0500
Subject: [PATCH 2/3] Accept qualified types in `impl_from_*` macros

---
 src/lib.rs    | 88 ++++++++++++++++++++-------------------------------
 src/macros.rs |  6 ++--
 2 files changed, 38 insertions(+), 56 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 3538ca5..4de7527 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,13 +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::ScriptBuf as BitcoinScriptBuf;
-use bitcoin::Sequence;
-use bitcoin::Transaction as BitcoinTransaction;
-use bitcoin::TxIn as BitcoinTxIn;
-use bitcoin::TxOut as BitcoinTxOut;
 
 pub use bitcoin::BlockHash;
 pub use bitcoin::Txid;
@@ -27,20 +19,21 @@ mod macros;
 pub mod error;
 
 #[derive(Debug, Clone, 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),
         )?;
@@ -57,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
@@ -71,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),
@@ -91,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 {
@@ -107,14 +99,15 @@ 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::Record)]
 pub struct OutPoint {
     pub txid: Txid,
     pub vout: u32,
 }
+
 impl From<bitcoin::OutPoint> for OutPoint {
     fn from(outpoint: bitcoin::OutPoint) -> Self {
         OutPoint {
@@ -131,13 +124,13 @@ impl From<OutPoint> for 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)
     }
 
@@ -146,8 +139,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 {
@@ -155,8 +148,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)),
@@ -164,9 +157,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(),
         }
@@ -174,18 +167,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))
     }
 
@@ -198,8 +191,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 {
@@ -209,8 +202,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: tx_in.previous_output.into(),
             script_sig: Arc::new(tx_in.script_sig.into()),
@@ -220,36 +213,25 @@ impl From<BitcoinTxIn> for TxIn {
     }
 }
 
-impl From<&BitcoinTxIn> for TxIn {
-    fn from(tx_in: &BitcoinTxIn) -> Self {
-        TxIn {
-            previous_output: tx_in.previous_output.into(),
-            script_sig: Arc::new(tx_in.script_sig.clone().into()),
-            sequence: tx_in.sequence.0,
-            witness: tx_in.witness.to_vec(),
-        }
-    }
-}
-
-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.into(),
             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))
     }
 
@@ -312,8 +294,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

From 57348c03cbff0d6e12ebd34bb3ad5015cccb4352 Mon Sep 17 00:00:00 2001
From: DanGould <d@ngould.dev>
Date: Fri, 15 Nov 2024 13:21:07 -0500
Subject: [PATCH 3/3] Define custom String type with complete macro

Separate `uniffi::custom_type` and `impl_string_custom_typedef`
calls were made to define uniffi String types. This combines them
into one macro.
---
 src/lib.rs    | 6 ++----
 src/macros.rs | 4 +++-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 4de7527..88899d2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -330,9 +330,7 @@ impl From<bitcoin::Network> for Network {
     }
 }
 
-uniffi::custom_type!(Txid, String);
-impl_string_custom_typedef!(Txid);
-uniffi::custom_type!(BlockHash, String);
-impl_string_custom_typedef!(BlockHash);
+define_custom_string_type!(Txid);
+define_custom_string_type!(BlockHash);
 
 uniffi::setup_scaffolding!("bitcoin");
diff --git a/src/macros.rs b/src/macros.rs
index 7816ab4..cfd2371 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -18,8 +18,10 @@ macro_rules! impl_from_ffi_type {
     };
 }
 
-macro_rules! impl_string_custom_typedef {
+macro_rules! define_custom_string_type {
     ($ffi_type:ident) => {
+        uniffi::custom_type!($ffi_type, String);
+
         impl UniffiCustomTypeConverter for $ffi_type {
             type Builtin = String;
             fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {