Add FFI bindings for async receive interface

Author: xstoicunicornx

payjoin-ffi/src/receive/mod.rs

@@ -711,6 +711,12 @@ pub trait CanBroadcast: Send + Sync {
     fn callback(&self, tx: Vec<u8>) -> Result<bool, ForeignError>;
 }
 
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait CanBroadcastAsync: Send + Sync {
+    async fn callback(&self, tx: Vec<u8>) -> Result<bool, ForeignError>;
+}
+
 #[uniffi::export]
 impl UncheckedOriginalPayload {
     pub fn check_broadcast_suitability(
@@ -728,6 +734,28 @@ impl UncheckedOriginalPayload {
         )))))
     }
 
+    pub async fn check_broadcast_suitability_async(
+        &self,
+        min_fee_rate: Option<u64>,
+        can_broadcast: Arc<dyn CanBroadcastAsync>,
+    ) -> Result<UncheckedOriginalPayloadTransition, FfiValidationError> {
+        let min_fee_rate = validate_fee_rate_sat_per_kwu_opt(min_fee_rate)?;
+        Ok(UncheckedOriginalPayloadTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .check_broadcast_suitability_async(min_fee_rate, |transaction| {
+                    let bytes = payjoin::bitcoin::consensus::encode::serialize(transaction);
+                    async {
+                        can_broadcast
+                            .callback(bytes)
+                            .await
+                            .map_err(|e| ImplementationError::new(e).into())
+                    }
+                })
+                .await,
+        )))))
+    }
+
     /// Call this method if the only way to initiate a Payjoin with this receiver
     /// requires manual intervention, as in most consumer wallets.
     ///
@@ -775,6 +803,12 @@ pub trait IsScriptOwned: Send + Sync {
     fn callback(&self, script: Vec<u8>) -> Result<bool, ForeignError>;
 }
 
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait IsScriptOwnedAsync: Send + Sync {
+    async fn callback(&self, script: Vec<u8>) -> Result<bool, ForeignError>;
+}
+
 #[uniffi::export]
 impl MaybeInputsOwned {
     ///The Sender’s Original PSBT
@@ -783,6 +817,7 @@ impl MaybeInputsOwned {
             &self.0.clone().extract_tx_to_schedule_broadcast(),
         )
     }
+
     pub fn check_inputs_not_owned(
         &self,
         is_owned: Arc<dyn IsScriptOwned>,
@@ -793,6 +828,26 @@ impl MaybeInputsOwned {
             }),
         ))))
     }
+
+    pub async fn check_inputs_not_owned_async(
+        &self,
+        is_owned: Arc<dyn IsScriptOwnedAsync>,
+    ) -> MaybeInputsOwnedTransition {
+        MaybeInputsOwnedTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .check_inputs_not_owned_async(&mut |input| {
+                    let bytes = input.to_bytes();
+                    async {
+                        is_owned
+                            .callback(bytes)
+                            .await
+                            .map_err(|e| ImplementationError::new(e).into())
+                    }
+                })
+                .await,
+        ))))
+    }
 }
 
 #[derive(Clone, uniffi::Object)]
@@ -830,6 +885,12 @@ pub trait IsOutputKnown: Send + Sync {
     fn callback(&self, outpoint: OutPoint) -> Result<bool, ForeignError>;
 }
 
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait IsOutputKnownAsync: Send + Sync {
+    async fn callback(&self, outpoint: OutPoint) -> Result<bool, ForeignError>;
+}
+
 #[uniffi::export]
 impl MaybeInputsSeen {
     pub fn check_no_inputs_seen_before(
@@ -844,6 +905,26 @@ impl MaybeInputsSeen {
             }),
         ))))
     }
+
+    pub async fn check_no_inputs_seen_before_async(
+        &self,
+        is_known: Arc<dyn IsOutputKnownAsync>,
+    ) -> MaybeInputsSeenTransition {
+        MaybeInputsSeenTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .check_no_inputs_seen_before_async(&mut |outpoint| {
+                    let plain_outpoint = OutPoint::from(*outpoint);
+                    async {
+                        is_known
+                            .callback(plain_outpoint)
+                            .await
+                            .map_err(|e| ImplementationError::new(e).into())
+                    }
+                })
+                .await,
+        ))))
+    }
 }
 
 /// The receiver has not yet identified which outputs belong to the receiver.
@@ -893,6 +974,26 @@ impl OutputsUnknown {
             }),
         ))))
     }
+
+    pub async fn identify_receiver_outputs_async(
+        &self,
+        is_receiver_output: Arc<dyn IsScriptOwnedAsync>,
+    ) -> OutputsUnknownTransition {
+        OutputsUnknownTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .identify_receiver_outputs_async(&mut |input| {
+                    let bytes = input.to_bytes();
+                    async {
+                        is_receiver_output
+                            .callback(bytes)
+                            .await
+                            .map_err(|e| ImplementationError::new(e).into())
+                    }
+                })
+                .await,
+        ))))
+    }
 }
 
 #[derive(uniffi::Object)]
@@ -1160,6 +1261,12 @@ pub trait ProcessPsbt: Send + Sync {
     fn callback(&self, psbt: String) -> Result<String, ForeignError>;
 }
 
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait ProcessPsbtAsync: Send + Sync {
+    async fn callback(&self, psbt: String) -> Result<String, ForeignError>;
+}
+
 #[uniffi::export]
 impl ProvisionalProposal {
     pub fn finalize_proposal(
@@ -1176,6 +1283,27 @@ impl ProvisionalProposal {
         ))))
     }
 
+    pub async fn finalize_proposal_async(
+        &self,
+        process_psbt: Arc<dyn ProcessPsbtAsync>,
+    ) -> ProvisionalProposalTransition {
+        ProvisionalProposalTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .finalize_proposal_async(|pre_processed| {
+                    let string = pre_processed.to_string();
+                    async {
+                        let psbt = process_psbt
+                            .callback(string)
+                            .await
+                            .map_err(ImplementationError::new)?;
+                        Ok(Psbt::from_str(&psbt).map_err(ImplementationError::new)?)
+                    }
+                })
+                .await,
+        ))))
+    }
+
     pub fn psbt_to_sign(&self) -> String { self.0.clone().psbt_to_sign().to_string() }
 }
 
@@ -1358,6 +1486,12 @@ pub trait TransactionExists: Send + Sync {
     fn callback(&self, txid: String) -> Result<Option<Vec<u8>>, ForeignError>;
 }
 
+#[uniffi::export(with_foreign)]
+#[async_trait::async_trait]
+pub trait TransactionExistsAsync: Send + Sync {
+    async fn callback(&self, txid: String) -> Result<Option<Vec<u8>>, ForeignError>;
+}
+
 #[allow(clippy::type_complexity)]
 #[derive(uniffi::Object)]
 pub struct MonitorTransition(
@@ -1433,6 +1567,27 @@ impl Monitor {
                 .map_err(|e| ImplementationError::new(e).into())
         })))))
     }
+
+    pub async fn monitor_async(
+        &self,
+        transaction_exists: Arc<dyn TransactionExistsAsync>,
+    ) -> MonitorTransition {
+        MonitorTransition(Arc::new(RwLock::new(Some(
+            self.0
+                .clone()
+                .check_payment_async(|txid| {
+                    let string = txid.to_string();
+                    async {
+                        transaction_exists
+                            .callback(string)
+                            .await
+                            .and_then(|buf| buf.map(try_deserialize_tx).transpose())
+                            .map_err(|e| ImplementationError::new(e).into())
+                    }
+                })
+                .await,
+        ))))
+    }
 }
 
 /// Session persister that should save and load events as JSON strings.