Add list_transactions to ffi

also added a couple easy functions

Author: benthecarman

orange-sdk/src/ffi/bitcoin_payment_instructions.rs

@@ -1,7 +1,7 @@
 use crate::{impl_from_core_type, impl_into_core_type};
 use bitcoin_payment_instructions::amount::Amount as BPIAmount;
-use std::sync::Arc;
 use std::fmt::Display;
+use std::sync::Arc;
 
 #[derive(Debug, uniffi::Error)]
 pub enum AmountError {
@@ -10,12 +10,16 @@ pub enum AmountError {
 }
 
 impl Display for AmountError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            AmountError::FractionalAmountOfSats(sats) => write!(f, "Not exactly a whole number of sats: {}", sats),
-            AmountError::MoreThanTwentyOneMillionBitcoin(sats) => write!(f, "More than 21 million bitcoin: {}", sats),
-        }
-    }
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			AmountError::FractionalAmountOfSats(sats) => {
+				write!(f, "Not exactly a whole number of sats: {}", sats)
+			},
+			AmountError::MoreThanTwentyOneMillionBitcoin(sats) => {
+				write!(f, "More than 21 million bitcoin: {}", sats)
+			},
+		}
+	}
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, uniffi::Object)]

orange-sdk/src/ffi/orange/error.rs

@@ -10,13 +10,15 @@ pub enum ConfigError {
 }
 
 impl Display for ConfigError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ConfigError::InvalidEntropySize(size) => write!(f, "Invalid entropy size: {size}. Entropy must be 64 bytes."),
-            ConfigError::InvalidLspAddress(address) => write!(f, "Invalid LSP address: {address}"),
-            ConfigError::InvalidLspNodeId(node_id) => write!(f, "Invalid LSP node ID: {node_id}"),
-        }
-    }
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			ConfigError::InvalidEntropySize(size) => {
+				write!(f, "Invalid entropy size: {size}. Entropy must be 64 bytes.")
+			},
+			ConfigError::InvalidLspAddress(address) => write!(f, "Invalid LSP address: {address}"),
+			ConfigError::InvalidLspNodeId(node_id) => write!(f, "Invalid LSP node ID: {node_id}"),
+		}
+	}
 }
 
 /// Represents possible failures during wallet initialization.
@@ -34,15 +36,15 @@ pub enum InitFailure {
 }
 
 impl Display for InitFailure {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            InitFailure::IoError(e) => write!(f, "I/O error: {e}"),
-            InitFailure::ConfigError(e) => write!(f, "Config error: {e}"),
-            InitFailure::LdkNodeBuildFailure(e) => write!(f, "Failed to build the LDK node: {e}"),
-            InitFailure::LdkNodeStartFailure(e) => write!(f, "Failed to start the LDK node: {e}"),
-            InitFailure::TrustedFailure => write!(f, "Failed to create the trusted wallet"),
-        }
-    }
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			InitFailure::IoError(e) => write!(f, "I/O error: {e}"),
+			InitFailure::ConfigError(e) => write!(f, "Config error: {e}"),
+			InitFailure::LdkNodeBuildFailure(e) => write!(f, "Failed to build the LDK node: {e}"),
+			InitFailure::LdkNodeStartFailure(e) => write!(f, "Failed to start the LDK node: {e}"),
+			InitFailure::TrustedFailure => write!(f, "Failed to create the trusted wallet"),
+		}
+	}
 }
 
 impl From<std::io::Error> for InitFailure {
@@ -82,12 +84,12 @@ pub enum WalletError {
 }
 
 impl Display for WalletError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            WalletError::LdkNodeFailure(e) => write!(f, "Failure from LDK node: {e}"),
-            WalletError::TrustedFailure => write!(f, "Failure from trusted wallet"),
-        }
-    }
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			WalletError::LdkNodeFailure(e) => write!(f, "Failure from LDK node: {e}"),
+			WalletError::TrustedFailure => write!(f, "Failure from trusted wallet"),
+		}
+	}
 }
 
 impl From<OrangeWalletError> for WalletError {

orange-sdk/src/ffi/orange/mod.rs

@@ -1,3 +1,154 @@
+use crate::bitcoin::hashes::Hash;
+use crate::ffi::bitcoin_payment_instructions::Amount;
+use crate::{PaymentId as OrangePaymentId, Transaction as OrangeTransaction};
+use crate::{impl_from_core_type, impl_into_core_type};
+
 pub mod config;
 pub mod error;
 pub mod wallet;
+
+/// A transaction is a record of a payment made or received. It contains information about the
+/// transaction, such as the amount, fee, and status. It is used to track the state of a payment
+/// and to provide information about the payment to the user.
+#[derive(Debug, Clone, uniffi::Object)]
+pub struct Transaction(pub crate::store::Transaction);
+
+impl_from_core_type!(OrangeTransaction, Transaction);
+impl_into_core_type!(Transaction, OrangeTransaction);
+
+#[uniffi::export]
+impl Transaction {
+	pub fn id(&self) -> PaymentId {
+		self.0.id.into()
+	}
+
+	pub fn status(&self) -> TxStatus {
+		self.0.status.into()
+	}
+
+	pub fn outbound(&self) -> bool {
+		self.0.outbound
+	}
+
+	/// The amount of the payment
+	///
+	/// None if the payment is not yet completed
+	pub fn amount(&self) -> Option<Amount> {
+		self.0.amount.map(Into::into)
+	}
+
+	/// The fee paid for the payment
+	///
+	/// None if the payment is not yet completed
+	pub fn fee(&self) -> Option<Amount> {
+		self.0.fee.map(Into::into)
+	}
+
+	/// The timestamp of the transaction
+	pub fn secs_since_epoch(&self) -> u64 {
+		self.0.time_since_epoch.as_secs()
+	}
+
+	/// The type of payment being made
+	pub fn payment_type(&self) -> PaymentType {
+		self.0.payment_type.clone().into()
+	}
+}
+
+/// A PaymentId is a unique identifier for a payment. It can be either a Lightning payment or a
+/// Trusted payment. It is used to track the state of a payment and to provide information about
+/// the payment to the user.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, uniffi::Object)]
+pub enum PaymentId {
+	Lightning([u8; 32]),
+	Trusted([u8; 32]),
+}
+
+impl From<OrangePaymentId> for PaymentId {
+	fn from(id: OrangePaymentId) -> Self {
+		match id {
+			OrangePaymentId::Lightning(hash) => Self::Lightning(hash),
+			OrangePaymentId::Trusted(hash) => Self::Trusted(hash),
+		}
+	}
+}
+
+/// The status of a transaction. This is used to track the state of a transaction
+#[derive(Debug, Clone, Copy, PartialEq, Eq, uniffi::Enum)]
+pub enum TxStatus {
+	/// A pending transaction has not yet been paid.
+	Pending,
+	/// A completed transaction has been paid.
+	Completed,
+	/// A transaction that has failed.
+	Failed,
+}
+
+impl From<crate::store::TxStatus> for TxStatus {
+	fn from(status: crate::store::TxStatus) -> Self {
+		match status {
+			crate::store::TxStatus::Pending => TxStatus::Pending,
+			crate::store::TxStatus::Completed => TxStatus::Completed,
+			crate::store::TxStatus::Failed => TxStatus::Failed,
+		}
+	}
+}
+
+/// The type of payment being made. This indicates whether the payment is incoming or outgoing,
+/// and what method is being used (Lightning, on-chain, etc.)
+#[derive(Debug, Clone, uniffi::Enum)]
+pub enum PaymentType {
+	/// An outgoing Lightning payment paying a BOLT 12 offer.
+	OutgoingLightningBolt12 {
+		/// The lightning "payment preimage" which represents proof that the payment completed.
+		/// Will be set for any completed payments.
+		payment_preimage: Option<[u8; 32]>,
+	},
+	/// An outgoing Lightning payment paying a BOLT 11 invoice.
+	OutgoingLightningBolt11 {
+		/// The lightning "payment preimage" which represents proof that the payment completed.
+		/// Will be set for any completed payments.
+		payment_preimage: Option<[u8; 32]>,
+	},
+	/// An outgoing on-chain Bitcoin payment.
+	OutgoingOnChain {
+		/// The optional transaction ID of the on-chain payment.
+		/// Will be set for any completed payments.
+		txid: Option<[u8; 32]>,
+	},
+	/// An incoming on-chain Bitcoin payment.
+	IncomingOnChain {
+		/// The optional transaction ID of the on-chain payment.
+		/// Will be set for any completed payments.
+		txid: Option<[u8; 32]>,
+	},
+	/// An incoming Lightning payment.
+	IncomingLightning {},
+	/// A payment that is internal to the trusted service.
+	TrustedInternal {},
+}
+
+impl From<crate::store::PaymentType> for PaymentType {
+	fn from(payment_type: crate::store::PaymentType) -> Self {
+		match payment_type {
+			crate::store::PaymentType::OutgoingLightningBolt12 { payment_preimage } => {
+				PaymentType::OutgoingLightningBolt12 {
+					payment_preimage: payment_preimage.map(|p| p.0),
+				}
+			},
+			crate::store::PaymentType::OutgoingLightningBolt11 { payment_preimage } => {
+				PaymentType::OutgoingLightningBolt11 {
+					payment_preimage: payment_preimage.map(|p| p.0),
+				}
+			},
+			crate::store::PaymentType::OutgoingOnChain { txid } => {
+				PaymentType::OutgoingOnChain { txid: txid.map(|t| t.to_byte_array()) }
+			},
+			crate::store::PaymentType::IncomingOnChain { txid } => {
+				PaymentType::IncomingOnChain { txid: txid.map(|t| t.to_byte_array()) }
+			},
+			crate::store::PaymentType::IncomingLightning {} => PaymentType::IncomingLightning {},
+			crate::store::PaymentType::TrustedInternal {} => PaymentType::TrustedInternal {},
+		}
+	}
+}

orange-sdk/src/ffi/orange/wallet.rs

@@ -1,4 +1,4 @@
-use crate::Balances as OrangeBalances;
+use crate::{Balances as OrangeBalances, store};
 
 use crate::Wallet as OrangeWallet;
 use crate::WalletConfig as OrangeWalletConfig;
@@ -75,4 +75,29 @@ impl Wallet {
 		let balance = self.inner.get_balance().await?;
 		Ok(balance.into())
 	}
+
+	pub async fn is_connected_to_lsp(&self) -> bool {
+		self.inner.is_connected_to_lsp()
+	}
+
+	/// Sets whether the wallet should automatically rebalance from trusted/onchain to lightning.
+	pub fn set_rebalance_enabled(&self, value: bool) {
+		self.inner.set_rebalance_enabled(value)
+	}
+
+	/// Whether the wallet should automatically rebalance from trusted/onchain to lightning.
+	pub fn get_rebalance_enabled(&self) -> bool {
+		self.inner.get_rebalance_enabled()
+	}
+
+	pub async fn list_transactions(
+		&self,
+	) -> Result<Vec<crate::ffi::orange::Transaction>, WalletError> {
+		let transactions = self.inner.list_transactions().await?;
+		Ok(transactions.into_iter().map(|tx| tx.into()).collect())
+	}
+
+	pub async fn stop(&self) {
+		self.inner.stop().await
+	}
 }

orange-sdk/src/store.rs

@@ -125,6 +125,9 @@ impl From<Transaction> for StoreTransaction {
 	}
 }
 
+/// A PaymentId is a unique identifier for a payment. It can be either a Lightning payment or a
+/// Trusted payment. It is used to track the state of a payment and to provide information about
+/// the payment to the user.
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum PaymentId {
 	Lightning([u8; 32]),