Rename FFI error types to avoid naming conflicts (payjoin#830)

The first commit renames receive::Error to ReceiverError to avoid
conflicts in languages where Error is a reserved keyword.

The second commit renames TerminalError to TerminalErr as a workaround
to a quirk in uniffi-dart (see commit message for more detail)

Author: spacebear21

payjoin-ffi/src/receive/error.rs

@@ -9,7 +9,7 @@ use crate::uri::error::IntoUrlError;
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Error))]
-pub enum Error {
+pub enum ReceiverError {
     /// Errors that can be replied to the sender
     #[error("Replyable error: {0}")]
     ReplyToSender(Arc<ReplyableError>),
@@ -24,12 +24,14 @@ pub enum Error {
     Unexpected,
 }
 
-impl From<receive::Error> for Error {
+impl From<receive::Error> for ReceiverError {
     fn from(value: receive::Error) -> Self {
+        use ReceiverError::*;
+
         match value {
-            receive::Error::ReplyToSender(e) => Error::ReplyToSender(Arc::new(ReplyableError(e))),
-            receive::Error::V2(e) => Error::V2(Arc::new(SessionError(e))),
-            _ => Error::Unexpected,
+            receive::Error::ReplyToSender(e) => ReplyToSender(Arc::new(ReplyableError(e))),
+            receive::Error::V2(e) => V2(Arc::new(SessionError(e))),
+            _ => Unexpected,
         }
     }
 }
@@ -41,7 +43,7 @@ impl From<receive::Error> for Error {
 pub enum ReceiverPersistedError {
     /// rust-payjoin receiver error
     #[error(transparent)]
-    Receiver(Error),
+    Receiver(ReceiverError),
     /// Storage error that could occur at application storage layer
     #[error(transparent)]
     Storage(Arc<ImplementationError>),
@@ -69,21 +71,21 @@ macro_rules! impl_persisted_error_from {
                 if let Some(api_err) = err.api_error() {
                     return ReceiverPersistedError::Receiver($receiver_arm(api_err));
                 }
-                ReceiverPersistedError::Receiver(Error::Unexpected)
+                ReceiverPersistedError::Receiver(ReceiverError::Unexpected)
             }
         }
     };
 }
 
 impl_persisted_error_from!(receive::ReplyableError, |api_err: receive::ReplyableError| {
-    Error::ReplyToSender(Arc::new(api_err.into()))
+    ReceiverError::ReplyToSender(Arc::new(api_err.into()))
 });
 
 impl_persisted_error_from!(receive::Error, |api_err: receive::Error| api_err.into());
 
-impl_persisted_error_from!(payjoin::IntoUrlError, |api_err: payjoin::IntoUrlError| Error::IntoUrl(
-    Arc::new(api_err.into())
-));
+impl_persisted_error_from!(payjoin::IntoUrlError, |api_err: payjoin::IntoUrlError| {
+    ReceiverError::IntoUrl(Arc::new(api_err.into()))
+});
 
 /// The replyable error type for the payjoin receiver, representing failures need to be
 /// returned to the sender.

payjoin-ffi/src/receive/mod.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
 pub use error::{
-    Error, InputContributionError, JsonReply, OutputSubstitutionError, PsbtInputError,
+    InputContributionError, JsonReply, OutputSubstitutionError, PsbtInputError, ReceiverError,
     ReplyableError, SelectionError, SessionError,
 };
 use payjoin::bitcoin::psbt::Psbt;
@@ -157,7 +157,10 @@ pub struct InitializedTransition(
 );
 
 impl InitializedTransition {
-    pub fn save<P>(&self, persister: &P) -> Result<InitializedTransitionOutcome, ReceiverPersistedError>
+    pub fn save<P>(
+        &self,
+        persister: &P,
+    ) -> Result<InitializedTransitionOutcome, ReceiverPersistedError>
     where
         P: SessionPersister<SessionEvent = payjoin::receive::v2::SessionEvent>,
     {
@@ -209,7 +212,10 @@ impl
 }
 
 impl Initialized {
-    pub fn extract_req(&self, ohttp_relay: String) -> Result<(Request, ClientResponse), Error> {
+    pub fn extract_req(
+        &self,
+        ohttp_relay: String,
+    ) -> Result<(Request, ClientResponse), ReceiverError> {
         self.0
             .clone()
             .extract_req(ohttp_relay)
@@ -568,7 +574,9 @@ impl WantsOutputsTransition {
             .take()
             .ok_or_else(|| ImplementationError::from("Already saved or moved".to_string()))?;
 
-        let res = value.save(persister).map_err(|e| ReceiverPersistedError::Storage(Arc::new(ImplementationError::from(e.to_string()))))?;
+        let res = value.save(persister).map_err(|e| {
+            ReceiverPersistedError::Storage(Arc::new(ImplementationError::from(e.to_string())))
+        })?;
         Ok(res.into())
     }
 }
@@ -639,7 +647,9 @@ impl WantsInputsTransition {
             .take()
             .ok_or_else(|| ImplementationError::from("Already saved or moved".to_string()))?;
 
-        let res = value.save(persister).map_err(|e| ReceiverPersistedError::Storage(Arc::new(ImplementationError::from(e.to_string()))))?;
+        let res = value.save(persister).map_err(|e| {
+            ReceiverPersistedError::Storage(Arc::new(ImplementationError::from(e.to_string())))
+        })?;
         Ok(res.into())
     }
 }
@@ -833,7 +843,10 @@ impl PayjoinProposal {
     }
 
     /// Extract an OHTTP Encapsulated HTTP POST request for the Proposal PSBT
-    pub fn extract_req(&self, ohttp_relay: String) -> Result<(Request, ClientResponse), Error> {
+    pub fn extract_req(
+        &self,
+        ohttp_relay: String,
+    ) -> Result<(Request, ClientResponse), ReceiverError> {
         self.0
             .clone()
             .extract_req(ohttp_relay)

payjoin-ffi/src/receive/uni.rs

@@ -5,7 +5,7 @@ use crate::bitcoin_ffi::{Address, OutPoint, Script, TxOut};
 use crate::error::ForeignError;
 use crate::receive::error::{ReceiverPersistedError, ReceiverReplayError};
 pub use crate::receive::{
-    Error, ImplementationError, InputContributionError, JsonReply, OutputSubstitutionError,
+    ImplementationError, InputContributionError, JsonReply, OutputSubstitutionError, ReceiverError,
     ReplyableError, SelectionError, SerdeJsonError, SessionError,
 };
 use crate::{ClientResponse, OhttpKeys, OutputSubstitution, Request};
@@ -93,13 +93,13 @@ impl From<SessionHistory> for super::SessionHistory {
 }
 
 #[derive(uniffi::Object)]
-pub struct TerminalError {
+pub struct TerminalErr {
     error: String,
     reply: Option<JsonReply>,
 }
 
 #[uniffi::export]
-impl TerminalError {
+impl TerminalErr {
     pub fn error(&self) -> String { self.error.clone() }
 
     pub fn reply(&self) -> Option<Arc<JsonReply>> {
@@ -120,9 +120,9 @@ impl SessionHistory {
     }
 
     /// Terminal error from the session if present
-    pub fn terminal_error(&self) -> Option<Arc<TerminalError>> {
+    pub fn terminal_error(&self) -> Option<Arc<TerminalErr>> {
         self.0 .0.terminal_error().map(|(error, reply)| {
-            Arc::new(TerminalError { error, reply: reply.map(|reply| reply.into()) })
+            Arc::new(TerminalErr { error, reply: reply.map(|reply| reply.into()) })
         })
     }
 
@@ -166,7 +166,8 @@ pub fn replay_receiver_event_log(
     persister: Arc<dyn JsonReceiverSessionPersister>,
 ) -> Result<ReplayResult, ReceiverReplayError> {
     let adapter = CallbackPersisterAdapter::new(persister);
-    let (state, session_history) = super::replay_event_log(&adapter).map_err(ReceiverReplayError::from)?;
+    let (state, session_history) =
+        super::replay_event_log(&adapter).map_err(ReceiverReplayError::from)?;
     Ok(ReplayResult { state: state.into(), session_history: session_history.into() })
 }
 #[derive(uniffi::Object)]
@@ -275,7 +276,7 @@ impl Initialized {
     /// This identifies a session at the payjoin directory server.
     pub fn pj_uri(&self) -> crate::PjUri { self.0.pj_uri() }
 
-    pub fn extract_req(&self, ohttp_relay: String) -> Result<RequestResponse, Error> {
+    pub fn extract_req(&self, ohttp_relay: String) -> Result<RequestResponse, ReceiverError> {
         self.0
             .extract_req(ohttp_relay)
             .map(|(request, ctx)| RequestResponse { request, client_response: Arc::new(ctx) })
@@ -719,7 +720,7 @@ impl PayjoinProposal {
     pub fn psbt(&self) -> String { self.0.psbt() }
 
     /// Extract an OHTTP Encapsulated HTTP POST request for the Proposal PSBT
-    pub fn extract_req(&self, ohttp_relay: String) -> Result<RequestResponse, Error> {
+    pub fn extract_req(&self, ohttp_relay: String) -> Result<RequestResponse, ReceiverError> {
         let (req, res) = self.0.extract_req(ohttp_relay)?;
         Ok(RequestResponse { request: req, client_response: Arc::new(res) })
     }