test bitcoin-ffi #9

bitcoindevkit · Sep 9, 2024 · 9d0ccef · 9d0ccef
1 parent 014504e
commit 9d0ccef
Show file tree

Hide file tree

Showing 9 changed files with 192 additions and 299 deletions.
diff --git a/bdk-ffi/Cargo.lock b/bdk-ffi/Cargo.lock
diff --git a/bdk-ffi/Cargo.toml b/bdk-ffi/Cargo.toml
@@ -24,7 +24,8 @@ bdk_esplora = { version = "0.17.0", default-features = false, features = ["std",
 bdk_electrum = { version = "0.17.0", default-features = false, features = ["use-rustls-ring"] }
 bdk_bitcoind_rpc = { version = "0.14.0" }
 bitcoin-internals = { version = "0.2.0", features = ["alloc"] }
-bitcoin-ffi = { git = "https://github.com/bitcoindevkit/bitcoin-ffi", tag = "v0.1.2" }
+#bitcoin-ffi = { git = "https://github.com/bitcoindevkit/bitcoin-ffi", tag = "v0.1.2" }
+bitcoin-ffi = { git = "https://github.com/reez/bitcoin-ffi.git", branch = "thu" }
 
 uniffi = { version = "=0.28.0" }
 thiserror = "1.0.58"

diff --git a/bdk-ffi/src/bdk.udl b/bdk-ffi/src/bdk.udl
@@ -4,20 +4,6 @@ namespace bdk {};
 // bdk crate - error module
 // ------------------------------------------------------------------------
 
-[Error]
-interface AddressParseError {
-  Base58();
-  Bech32();
-  WitnessVersion(string error_message);
-  WitnessProgram(string error_message);
-  UnknownHrp();
-  LegacyAddressTooLong();
-  InvalidBase58PayloadLength();
-  InvalidLegacyPrefix();
-  NetworkValidation();
-  OtherAddressParseErr();
-};
-
 [Error]
 interface Bip32Error {
     CannotDeriveFromHardenedKey();
@@ -155,14 +141,6 @@ interface ExtractTxError {
   OtherExtractTxErr();
 };
 
-[Error]
-interface FromScriptError {
-  UnrecognizedScript();
-  WitnessProgram(string error_message);
-  WitnessVersion(string error_message);
-  OtherFromScriptErr();
-};
-
 [Error]
 interface LoadWithPersistError {
     Persist(string error_message);
@@ -626,21 +604,6 @@ enum WordCount {
   "Words24",
 };
 
-[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);
-};
-
 interface Transaction {
   [Throws=TransactionError]
   constructor(sequence<u8> transaction_bytes);
@@ -717,8 +680,17 @@ typedef extern Txid;
 [External="bitcoin_ffi"]
 typedef extern OutPoint;
 
+[ExternalInterface="bitcoin_ffi"]
+typedef extern Address;
+
 [ExternalInterface="bitcoin_ffi"]
 typedef extern FeeRateError;
 
 [ExternalInterface="bitcoin_ffi"]
 typedef extern ParseAmountError;
+
+[ExternalInterface="bitcoin_ffi"]
+typedef extern AddressParseError;
+
+[ExternalInterface="bitcoin_ffi"]
+typedef extern FromScriptError;
diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs
@@ -1,80 +1,75 @@
-use crate::error::{
-    AddressParseError, FromScriptError, PsbtError, PsbtParseError, TransactionError,
-};
+use crate::error::{PsbtError, PsbtParseError, TransactionError};
 
-use bitcoin_ffi::OutPoint;
 use bitcoin_ffi::Script;
+use bitcoin_ffi::OutPoint;
 
 use bdk_bitcoind_rpc::bitcoincore_rpc::jsonrpc::serde_json;
-use bdk_wallet::bitcoin::address::{NetworkChecked, NetworkUnchecked};
 use bdk_wallet::bitcoin::consensus::encode::serialize;
 use bdk_wallet::bitcoin::consensus::Decodable;
 use bdk_wallet::bitcoin::io::Cursor;
 use bdk_wallet::bitcoin::psbt::ExtractTxError;
-use bdk_wallet::bitcoin::Address as BdkAddress;
-use bdk_wallet::bitcoin::Network;
+// use bdk_wallet::bitcoin::Network;
 use bdk_wallet::bitcoin::Psbt as BdkPsbt;
 use bdk_wallet::bitcoin::Transaction as BdkTransaction;
 use bdk_wallet::bitcoin::TxIn as BdkTxIn;
 use bdk_wallet::bitcoin::TxOut as BdkTxOut;
 
-use std::fmt::Display;
 use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
-#[derive(Debug, PartialEq, Eq)]
-pub struct Address(BdkAddress<NetworkChecked>);
-
-impl Address {
-    pub fn new(address: String, network: Network) -> Result<Self, AddressParseError> {
-        let parsed_address = address.parse::<bdk_wallet::bitcoin::Address<NetworkUnchecked>>()?;
-        let network_checked_address = parsed_address.require_network(network)?;
-
-        Ok(Address(network_checked_address))
-    }
-
-    pub fn from_script(script: Arc<Script>, network: Network) -> Result<Self, FromScriptError> {
-        let address = BdkAddress::from_script(&script.0.clone(), network)?;
-
-        Ok(Address(address))
-    }
-
-    pub fn script_pubkey(&self) -> Arc<Script> {
-        Arc::new(Script(self.0.script_pubkey()))
-    }
-
-    pub fn to_qr_uri(&self) -> String {
-        self.0.to_qr_uri()
-    }
-
-    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::<BdkAddress<NetworkUnchecked>>() {
-            unchecked_address.is_valid_for_network(network)
-        } else {
-            false
-        }
-    }
-}
-
-impl Display for Address {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl From<Address> for BdkAddress {
-    fn from(address: Address) -> Self {
-        address.0
-    }
-}
-
-impl From<BdkAddress> for Address {
-    fn from(address: BdkAddress) -> Self {
-        Address(address)
-    }
-}
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct Address(BdkAddress<NetworkChecked>);
+//
+// impl Address {
+//     pub fn new(address: String, network: Network) -> Result<Self, AddressParseError> {
+//         let parsed_address = address.parse::<bdk_wallet::bitcoin::Address<NetworkUnchecked>>()?;
+//         let network_checked_address = parsed_address.require_network(network)?;
+//
+//         Ok(Address(network_checked_address))
+//     }
+//
+//     pub fn from_script(script: Arc<Script>, network: Network) -> Result<Self, FromScriptError> {
+//         let address = BdkAddress::from_script(&script.0.clone(), network)?;
+//
+//         Ok(Address(address))
+//     }
+//
+//     pub fn script_pubkey(&self) -> Arc<Script> {
+//         Arc::new(Script(self.0.script_pubkey()))
+//     }
+//
+//     pub fn to_qr_uri(&self) -> String {
+//         self.0.to_qr_uri()
+//     }
+//
+//     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::<BdkAddress<NetworkUnchecked>>() {
+//             unchecked_address.is_valid_for_network(network)
+//         } else {
+//             false
+//         }
+//     }
+// }
+//
+// impl Display for Address {
+//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//         write!(f, "{}", self.0)
+//     }
+// }
+//
+// impl From<Address> for BdkAddress {
+//     fn from(address: Address) -> Self {
+//         address.0
+//     }
+// }
+//
+// impl From<BdkAddress> for Address {
+//     fn from(address: BdkAddress) -> Self {
+//         Address(address)
+//     }
+// }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Transaction(BdkTransaction);
@@ -239,8 +234,9 @@ impl From<&BdkTxOut> for TxOut {
 
 #[cfg(test)]
 mod tests {
-    use crate::bitcoin::Address;
-    use crate::bitcoin::Network;
+    // use crate::bitcoin::Address;
+    use bitcoin_ffi::Address;
+    use bdk_wallet::bitcoin::Network;
 
     #[test]
     fn test_is_valid_for_network() {

diff --git a/bdk-ffi/src/error.rs b/bdk-ffi/src/error.rs
@@ -1,10 +1,7 @@
 use bitcoin_ffi::OutPoint;
 
-use bdk_bitcoind_rpc::bitcoincore_rpc::bitcoin::address::ParseError;
 use bdk_electrum::electrum_client::Error as BdkElectrumError;
 use bdk_esplora::esplora_client::{Error as BdkEsploraError, Error};
-use bdk_wallet::bitcoin::address::FromScriptError as BdkFromScriptError;
-use bdk_wallet::bitcoin::address::ParseError as BdkParseError;
 use bdk_wallet::bitcoin::bip32::Error as BdkBip32Error;
 use bdk_wallet::bitcoin::consensus::encode::Error as BdkEncodeError;
 use bdk_wallet::bitcoin::psbt::Error as BdkPsbtError;
@@ -30,40 +27,6 @@ use std::convert::TryInto;
 // error definitions
 // ------------------------------------------------------------------------
 
-#[derive(Debug, thiserror::Error)]
-pub enum AddressParseError {
-    #[error("base58 address encoding error")]
-    Base58,
-
-    #[error("bech32 address encoding error")]
-    Bech32,
-
-    #[error("witness version conversion/parsing error: {error_message}")]
-    WitnessVersion { error_message: String },
-
-    #[error("witness program error: {error_message}")]
-    WitnessProgram { error_message: String },
-
-    #[error("tried to parse an unknown hrp")]
-    UnknownHrp,
-
-    #[error("legacy address base58 string")]
-    LegacyAddressTooLong,
-
-    #[error("legacy address base58 data")]
-    InvalidBase58PayloadLength,
-
-    #[error("segwit address bech32 string")]
-    InvalidLegacyPrefix,
-
-    #[error("validation error")]
-    NetworkValidation,
-
-    // This error is required because the bdk::bitcoin::address::ParseError is non-exhaustive
-    #[error("other address parse error")]
-    OtherAddressParseErr,
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum Bip32Error {
     #[error("cannot derive from a hardened key")]
@@ -378,22 +341,6 @@ pub enum ExtractTxError {
     OtherExtractTxErr,
 }
 
-#[derive(Debug, thiserror::Error)]
-pub enum FromScriptError {
-    #[error("script is not a p2pkh, p2sh or witness program")]
-    UnrecognizedScript,
-
-    #[error("witness program error: {error_message}")]
-    WitnessProgram { error_message: String },
-
-    #[error("witness version construction error: {error_message}")]
-    WitnessVersion { error_message: String },
-
-    // This error is required because the bdk::bitcoin::address::FromScriptError is non-exhaustive
-    #[error("other from script error")]
-    OtherFromScriptErr,
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum RequestBuilderError {
     #[error("the request has already been consumed")]
@@ -671,29 +618,6 @@ impl From<BdkElectrumError> for ElectrumError {
     }
 }
 
-impl From<BdkParseError> for AddressParseError {
-    fn from(error: BdkParseError) -> Self {
-        match error {
-            BdkParseError::Base58(_) => AddressParseError::Base58,
-            BdkParseError::Bech32(_) => AddressParseError::Bech32,
-            BdkParseError::WitnessVersion(e) => AddressParseError::WitnessVersion {
-                error_message: e.to_string(),
-            },
-            BdkParseError::WitnessProgram(e) => AddressParseError::WitnessProgram {
-                error_message: e.to_string(),
-            },
-            ParseError::UnknownHrp(_) => AddressParseError::UnknownHrp,
-            ParseError::LegacyAddressTooLong(_) => AddressParseError::LegacyAddressTooLong,
-            ParseError::InvalidBase58PayloadLength(_) => {
-                AddressParseError::InvalidBase58PayloadLength
-            }
-            ParseError::InvalidLegacyPrefix(_) => AddressParseError::InvalidLegacyPrefix,
-            ParseError::NetworkValidation(_) => AddressParseError::NetworkValidation,
-            _ => AddressParseError::OtherAddressParseErr,
-        }
-    }
-}
-
 impl From<BdkBip32Error> for Bip32Error {
     fn from(error: BdkBip32Error) -> Self {
         match error {
@@ -1029,21 +953,6 @@ impl From<BdkExtractTxError> for ExtractTxError {
     }
 }
 
-impl From<BdkFromScriptError> for FromScriptError {
-    fn from(error: BdkFromScriptError) -> Self {
-        match error {
-            BdkFromScriptError::UnrecognizedScript => FromScriptError::UnrecognizedScript,
-            BdkFromScriptError::WitnessProgram(e) => FromScriptError::WitnessProgram {
-                error_message: e.to_string(),
-            },
-            BdkFromScriptError::WitnessVersion(e) => FromScriptError::WitnessVersion {
-                error_message: e.to_string(),
-            },
-            _ => FromScriptError::OtherFromScriptErr,
-        }
-    }
-}
-
 impl From<BdkLoadWithPersistError<chain::rusqlite::Error>> for LoadWithPersistError {
     fn from(error: BdkLoadWithPersistError<chain::rusqlite::Error>) -> Self {
         match error {

diff --git a/bdk-ffi/src/lib.rs b/bdk-ffi/src/lib.rs
@@ -8,14 +8,12 @@ mod store;
 mod types;
 mod wallet;
 
-use crate::bitcoin::Address;
 use crate::bitcoin::Psbt;
 use crate::bitcoin::Transaction;
 use crate::bitcoin::TxIn;
 use crate::bitcoin::TxOut;
 use crate::descriptor::Descriptor;
 use crate::electrum::ElectrumClient;
-use crate::error::AddressParseError;
 use crate::error::Bip32Error;
 use crate::error::Bip39Error;
 use crate::error::CalculateFeeError;
@@ -27,7 +25,6 @@ use crate::error::DescriptorKeyError;
 use crate::error::ElectrumError;
 use crate::error::EsploraError;
 use crate::error::ExtractTxError;
-use crate::error::FromScriptError;
 use crate::error::LoadWithPersistError;
 use crate::error::PersistenceError;
 use crate::error::PsbtError;
@@ -68,6 +65,7 @@ use bitcoin_ffi::FeeRate;
 use bitcoin_ffi::Network;
 use bitcoin_ffi::OutPoint;
 use bitcoin_ffi::Script;
+use bitcoin_ffi::Address;
 
 use bdk_wallet::keys::bip39::WordCount;
 use bdk_wallet::tx_builder::ChangeSpendPolicy;