diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs
index 98953e88..6a076a46 100644
--- a/bdk-ffi/src/bitcoin.rs
+++ b/bdk-ffi/src/bitcoin.rs
@@ -49,28 +49,6 @@ impl Address {
         Ok(Address(network_checked_address))
     }
 
-    /// alternative constructor
-    // fn from_script(script: Arc<Script>, network: Network) -> Result<Self, BdkError> {
-    //     BdkAddress::from_script(&script.inner, network)
-    //         .map(|a| Address { inner: a })
-    //         .map_err(|e| BdkError::Generic(e.to_string()))
-    // }
-    //
-    // fn payload(&self) -> Payload {
-    //     match &self.inner.payload.clone() {
-    //         BdkPayload::PubkeyHash(pubkey_hash) => Payload::PubkeyHash {
-    //             pubkey_hash: pubkey_hash.to_vec(),
-    //         },
-    //         BdkPayload::ScriptHash(script_hash) => Payload::ScriptHash {
-    //             script_hash: script_hash.to_vec(),
-    //         },
-    //         BdkPayload::WitnessProgram { version, program } => Payload::WitnessProgram {
-    //             version: *version,
-    //             program: program.clone(),
-    //         },
-    //     }
-    // }
-
     pub fn network(&self) -> Network {
         *self.0.network()
     }
@@ -154,18 +132,6 @@ impl Transaction {
     pub fn serialize(&self) -> Vec<u8> {
         serialize(&self.0)
     }
-
-    // fn lock_time(&self) -> u32 {
-    //     self.inner.lock_time.0
-    // }
-
-    // fn input(&self) -> Vec<TxIn> {
-    //     self.inner.input.iter().map(|x| x.into()).collect()
-    // }
-    //
-    // fn output(&self) -> Vec<TxOut> {
-    //     self.inner.output.iter().map(|x| x.into()).collect()
-    // }
 }
 
 impl From<BdkTransaction> for Transaction {
@@ -199,53 +165,11 @@ impl Psbt {
         psbt.to_string()
     }
 
-    // pub(crate) fn txid(&self) -> String {
-    //     let tx = self.inner.lock().unwrap().clone().extract_tx();
-    //     let txid = tx.txid();
-    //     txid.to_hex()
-    // }
-
     pub(crate) fn extract_tx(&self) -> Result<Arc<Transaction>, ExtractTxError> {
         let tx: BdkTransaction = self.0.lock().unwrap().clone().extract_tx()?;
         let transaction: Transaction = tx.into();
         Ok(Arc::new(transaction))
     }
-
-    // /// Combines this PartiallySignedTransaction with other PSBT as described by BIP 174.
-    // ///
-    // /// In accordance with BIP 174 this function is commutative i.e., `A.combine(B) == B.combine(A)`
-    // pub(crate) fn combine(
-    //     &self,
-    //     other: Arc<PartiallySignedTransaction>,
-    // ) -> Result<Arc<PartiallySignedTransaction>, BdkError> {
-    //     let other_psbt = other.inner.lock().unwrap().clone();
-    //     let mut original_psbt = self.inner.lock().unwrap().clone();
-    //
-    //     original_psbt.combine(other_psbt)?;
-    //     Ok(Arc::new(PartiallySignedTransaction {
-    //         inner: Mutex::new(original_psbt),
-    //     }))
-    // }
-
-    // /// The total transaction fee amount, sum of input amounts minus sum of output amounts, in Sats.
-    // /// If the PSBT is missing a TxOut for an input returns None.
-    // pub(crate) fn fee_amount(&self) -> Option<u64> {
-    //     self.inner.lock().unwrap().fee_amount()
-    // }
-
-    // /// The transaction's fee rate. This value will only be accurate if calculated AFTER the
-    // /// `PartiallySignedTransaction` is finalized and all witness/signature data is added to the
-    // /// transaction.
-    // /// If the PSBT is missing a TxOut for an input returns None.
-    // pub(crate) fn fee_rate(&self) -> Option<Arc<FeeRate>> {
-    //     self.inner.lock().unwrap().fee_rate().map(Arc::new)
-    // }
-
-    // /// Serialize the PSBT data structure as a String of JSON.
-    // pub(crate) fn json_serialize(&self) -> String {
-    //     let psbt = self.inner.lock().unwrap();
-    //     serde_json::to_string(psbt.deref()).unwrap()
-    // }
 }
 
 impl From<BdkPsbt> for Psbt {
diff --git a/bdk-ffi/src/esplora.rs b/bdk-ffi/src/esplora.rs
index 366d96a8..a5231332 100644
--- a/bdk-ffi/src/esplora.rs
+++ b/bdk-ffi/src/esplora.rs
@@ -58,6 +58,4 @@ impl EsploraClient {
             .broadcast(&bdk_transaction)
             .map_err(EsploraError::from)
     }
-
-    // pub fn estimate_fee();
 }
diff --git a/bdk-ffi/src/lib.rs b/bdk-ffi/src/lib.rs
index 9c014532..7b823634 100644
--- a/bdk-ffi/src/lib.rs
+++ b/bdk-ffi/src/lib.rs
@@ -56,5 +56,3 @@ use bdk::wallet::tx_builder::ChangeSpendPolicy;
 use bdk::KeychainKind;
 
 uniffi::include_scaffolding!("bdk");
-
-// TODO: TxIn, Payload
diff --git a/bdk-ffi/src/wallet.rs b/bdk-ffi/src/wallet.rs
index d81f1a37..1ec5aba4 100644
--- a/bdk-ffi/src/wallet.rs
+++ b/bdk-ffi/src/wallet.rs
@@ -148,187 +148,6 @@ pub struct SentAndReceivedValues {
 
 pub struct Update(pub(crate) BdkUpdate);
 
-// /// A Bitcoin wallet.
-// /// The Wallet acts as a way of coherently interfacing with output descriptors and related transactions. Its main components are:
-// ///     1. Output descriptors from which it can derive addresses.
-// ///     2. A Database where it tracks transactions and utxos related to the descriptors.
-// ///     3. Signers that can contribute signatures to addresses instantiated from the descriptors.
-// impl Wallet {
-//     pub fn new(
-//         descriptor: Arc<Descriptor>,
-//         change_descriptor: Option<Arc<Descriptor>>,
-//         network: Network,
-//     ) -> Result<Self, BdkError> {
-//         let wallet = BdkWallet::new_no_persist()?;
-//         Ok(Wallet {
-//             inner: wallet,
-//         })
-//     }
-// }
-
-//     /// Return whether or not a script is part of this wallet (either internal or external).
-//     pub(crate) fn is_mine(&self, script: Arc<Script>) -> bool {
-//         self.inner.is_mine(&script.inner)
-//     }
-//
-//     /// Sync the internal database with the blockchain.
-//     // pub(crate) fn sync(
-//     //     &self,
-//     //     blockchain: &Blockchain,
-//     //     progress: Option<Box<dyn Progress>>,
-//     // ) -> Result<(), BdkError> {
-//     //     let bdk_sync_opts = BdkSyncOptions {
-//     //         progress: progress.map(|p| {
-//     //             Box::new(ProgressHolder { progress: p })
-//     //                 as Box<(dyn bdk::blockchain::Progress + 'static)>
-//     //         }),
-//     //     };
-//     //
-//     //     let blockchain = blockchain.get_blockchain();
-//     //     self.get_wallet().sync(blockchain.deref(), bdk_sync_opts)
-//     // }
-//
-//     /// Return a derived address using the external descriptor, see AddressIndex for available address index selection
-//     /// strategies. If none of the keys in the descriptor are derivable (i.e. the descriptor does not end with a * character)
-//     /// then the same address will always be returned for any AddressIndex.
-//     /// MIGRATION 1.0: The wallet needs to be mutated for this method to work... does that mean I should bring back the Mutex?
-//     ///                Is this thread-safe?
-//     pub(crate) fn get_address(&mut self, address_index: AddressIndex) -> AddressInfo {
-//         AddressInfo::from(self.inner.get_address(address_index.into()))
-//     }
-//
-//     /// Return a derived address using the internal (change) descriptor.
-//     ///
-//     /// If the wallet doesn't have an internal descriptor it will use the external descriptor.
-//     ///
-//     /// see [`AddressIndex`] for available address index selection strategies. If none of the keys
-//     /// in the descriptor are derivable (i.e. does not end with /*) then the same address will always
-//     /// be returned for any [`AddressIndex`].
-//     pub(crate) fn get_internal_address(&mut self, address_index: AddressIndex, ) -> AddressInfo {
-//         AddressInfo::from(self.inner.get_internal_address(address_index.into()))
-//     }
-//
-//     /// Return the balance, meaning the sum of this wallet’s unspent outputs’ values. Note that this method only operates
-//     /// on the internal database, which first needs to be Wallet.sync manually.
-//     pub(crate) fn get_balance(&self) -> Balance {
-//         Balance::from(self.inner.get_balance())
-//     }
-//
-//     /// Sign a transaction with all the wallet's signers, in the order specified by every signer's
-//     /// [`SignerOrdering`]. This function returns the `Result` type with an encapsulated `bool` that
-//     /// has the value true if the PSBT was finalized, or false otherwise.
-//     ///
-//     /// The [`SignOptions`] can be used to tweak the behavior of the software signers, and the way
-//     /// the transaction is finalized at the end. Note that it can't be guaranteed that *every*
-//     /// signers will follow the options, but the "software signers" (WIF keys and `xprv`) defined
-//     /// in this library will.
-//     pub(crate) fn sign(
-//         &self,
-//         psbt: &PartiallySignedTransaction,
-//         sign_options: Option<SignOptions>,
-//     ) -> Result<bool, BdkError> {
-//         let mut psbt = psbt.inner.lock().unwrap();
-//         self.inner.sign(
-//             &mut psbt,
-//             sign_options.map(SignOptions::into).unwrap_or_default(),
-//         )
-//     }
-//
-//     /// Return the list of transactions made and received by the wallet. Note that this method only operate on the internal database, which first needs to be [Wallet.sync] manually.
-//     pub(crate) fn list_transactions(
-//         &self,
-//         include_raw: bool,
-//     ) -> Result<Vec<TransactionDetails>, BdkError> {
-//         let transaction_details = self.inner.list_transactions(include_raw)?;
-//         Ok(transaction_details
-//             .into_iter()
-//             .map(TransactionDetails::from)
-//             .collect())
-//     }
-//
-//     /// Return the list of unspent outputs of this wallet. Note that this method only operates on the internal database,
-//     /// which first needs to be Wallet.sync manually.
-//     pub(crate) fn list_unspent(&self) -> Result<Vec<LocalUtxo>, BdkError> {
-//         let unspents: Vec<BdkLocalUtxo> = self.inner.list_unspent()?;
-//         Ok(unspents.into_iter().map(LocalUtxo::from).collect())
-//     }
-// }
-//
-// /// Options for a software signer
-// ///
-// /// Adjust the behavior of our software signers and the way a transaction is finalized
-// #[derive(Debug, Clone, Default)]
-// pub struct SignOptions {
-//     /// Whether the signer should trust the `witness_utxo`, if the `non_witness_utxo` hasn't been
-//     /// provided
-//     ///
-//     /// Defaults to `false` to mitigate the "SegWit bug" which should trick the wallet into
-//     /// paying a fee larger than expected.
-//     ///
-//     /// Some wallets, especially if relatively old, might not provide the `non_witness_utxo` for
-//     /// SegWit transactions in the PSBT they generate: in those cases setting this to `true`
-//     /// should correctly produce a signature, at the expense of an increased trust in the creator
-//     /// of the PSBT.
-//     ///
-//     /// For more details see: <https://blog.trezor.io/details-of-firmware-updates-for-trezor-one-version-1-9-1-and-trezor-model-t-version-2-3-1-1eba8f60f2dd>
-//     pub trust_witness_utxo: bool,
-//
-//     /// Whether the wallet should assume a specific height has been reached when trying to finalize
-//     /// a transaction
-//     ///
-//     /// The wallet will only "use" a timelock to satisfy the spending policy of an input if the
-//     /// timelock height has already been reached. This option allows overriding the "current height" to let the
-//     /// wallet use timelocks in the future to spend a coin.
-//     pub assume_height: Option<u32>,
-//
-//     /// Whether the signer should use the `sighash_type` set in the PSBT when signing, no matter
-//     /// what its value is
-//     ///
-//     /// Defaults to `false` which will only allow signing using `SIGHASH_ALL`.
-//     pub allow_all_sighashes: bool,
-//
-//     /// Whether to remove partial signatures from the PSBT inputs while finalizing PSBT.
-//     ///
-//     /// Defaults to `true` which will remove partial signatures during finalization.
-//     pub remove_partial_sigs: bool,
-//
-//     /// Whether to try finalizing the PSBT after the inputs are signed.
-//     ///
-//     /// Defaults to `true` which will try finalizing PSBT after inputs are signed.
-//     pub try_finalize: bool,
-//
-//     // Specifies which Taproot script-spend leaves we should sign for. This option is
-//     // ignored if we're signing a non-taproot PSBT.
-//     //
-//     // Defaults to All, i.e., the wallet will sign all the leaves it has a key for.
-//     // TODO pub tap_leaves_options: TapLeavesOptions,
-//     /// Whether we should try to sign a taproot transaction with the taproot internal key
-//     /// or not. This option is ignored if we're signing a non-taproot PSBT.
-//     ///
-//     /// Defaults to `true`, i.e., we always try to sign with the taproot internal key.
-//     pub sign_with_tap_internal_key: bool,
-//
-//     /// Whether we should grind ECDSA signature to ensure signing with low r
-//     /// or not.
-//     /// Defaults to `true`, i.e., we always grind ECDSA signature to sign with low r.
-//     pub allow_grinding: bool,
-// }
-//
-// impl From<SignOptions> for BdkSignOptions {
-//     fn from(sign_options: SignOptions) -> Self {
-//         BdkSignOptions {
-//             trust_witness_utxo: sign_options.trust_witness_utxo,
-//             assume_height: sign_options.assume_height,
-//             allow_all_sighashes: sign_options.allow_all_sighashes,
-//             remove_partial_sigs: sign_options.remove_partial_sigs,
-//             try_finalize: sign_options.try_finalize,
-//             tap_leaves_options: Default::default(),
-//             sign_with_tap_internal_key: sign_options.sign_with_tap_internal_key,
-//             allow_grinding: sign_options.allow_grinding,
-//         }
-//     }
-// }
-
 #[derive(Clone, Debug)]
 pub struct TxBuilder {
     pub(crate) recipients: Vec<(BdkScriptBuf, u64)>,
@@ -481,14 +300,6 @@ impl TxBuilder {
         })
     }
 
-    /// Add data as an output using OP_RETURN.
-    // pub(crate) fn add_data(&self, data: Vec<u8>) -> Arc<Self> {
-    //     Arc::new(TxBuilder {
-    //         data,
-    //         ..self.clone()
-    //     })
-    // }
-
     pub(crate) fn finish(&self, wallet: &Arc<Wallet>) -> Result<Arc<Psbt>, CreateTxError> {
         // TODO: I had to change the wallet here to be mutable. Why is that now required with the 1.0 API?
         let mut wallet = wallet.get_wallet();
@@ -533,9 +344,6 @@ impl TxBuilder {
                 }
             }
         }
-        // if !&self.data.is_empty() {
-        //     tx_builder.add_data(self.data.as_slice());
-        // }
 
         let psbt = tx_builder.finish().map_err(CreateTxError::from)?;