Add list_transactions to ffi

also added a couple easy functions

Author: benthecarman

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

@@ -1,3 +1,163 @@
+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),
+		}
+	}
+}
+
+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,25 @@ 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())
+	}
 }

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]),