29448737091

Committed 15 Jul 2026 08:33PM UTC coverage: 86.187% (+0.2%) from 85.938%

Build # 29448737091

Build Type

Pull #1707

github

Committed by

web-flow

Commit Message

Merge bb5eb7fc2 into 1da296b10

Pull Request Pull Request #1707: Prepare release-ready C# NuGet package workflow

Coverage Stats

13758 of 15963 relevant lines covered (86.19%)

345.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.78

/payjoin/src/core/error.rs

use std::fmt::Debug;
use std::{error, fmt};

#[derive(Debug)]
pub struct ImplementationError(Box<dyn error::Error + Send + Sync>);

impl ImplementationError {
    pub fn new(e: impl error::Error + Send + Sync + 'static) -> Self {
        ImplementationError(Box::new(e))
    }
}

impl fmt::Display for ImplementationError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { std::fmt::Display::fmt(&self.0, f) }
}

impl error::Error for ImplementationError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> { Some(self.0.as_ref()) }
}

impl PartialEq for ImplementationError {
    fn eq(&self, _: &Self) -> bool { false }
}

impl Eq for ImplementationError {}

impl From<Box<dyn error::Error + Send + Sync>> for ImplementationError {
    fn from(e: Box<dyn error::Error + Send + Sync>) -> Self { ImplementationError(e) }
}

impl From<&str> for ImplementationError {
    fn from(e: &str) -> Self {
        let error = Box::<dyn error::Error + Send + Sync>::from(e);
        ImplementationError::from(error)
    }
}
/// Errors that can occur when replaying a session event log
#[cfg(feature = "v2")]
#[derive(Debug)]
pub struct ReplayError<SessionState, SessionEvent>(InternalReplayError<SessionState, SessionEvent>);

#[cfg(feature = "v2")]
impl<SessionState: Debug, SessionEvent: Debug> std::fmt::Display
    for ReplayError<SessionState, SessionEvent>
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use InternalReplayError::*;
        match &self.0 {
            NoEvents => write!(f, "No events found in session"),
            InvalidEvent(event, session) => match session {
                Some(session) => write!(f, "Invalid event ({event:?}) for session ({session:?})",),
                None => write!(f, "Invalid first event ({event:?}) for session",),
            },
            InvalidEventPayload(event, reason) =>
                write!(f, "Invalid event payload ({event:?}): {reason}"),
            Expired(time, _) => write!(f, "Session expired at {time:?}"),
            PersistenceFailure(e) => write!(f, "Persistence failure: {e}"),
        }
    }
}
#[cfg(feature = "v2")]
impl<SessionState: Debug, SessionEvent: Debug> std::error::Error
    for ReplayError<SessionState, SessionEvent>
{
}

#[cfg(feature = "v2")]
impl<SessionState: Debug, SessionEvent: Debug> From<InternalReplayError<SessionState, SessionEvent>>
    for ReplayError<SessionState, SessionEvent>
{
    fn from(e: InternalReplayError<SessionState, SessionEvent>) -> Self { ReplayError(e) }
}

#[cfg(feature = "v2")]
impl<SessionState, SessionEvent> ReplayError<SessionState, SessionEvent> {
    /// Returns `true` if the event log could not be replayed because the
    /// session has expired.
    pub fn is_expired(&self) -> bool { matches!(self.0, InternalReplayError::Expired(..)) }

    /// Returns the fallback transaction that should be broadcast when the
    /// session has expired, if one is recoverable from the event log.
    ///
    /// Returns `None` for non-expired errors, or for an expired session that
    /// never produced a fallback transaction (e.g. a receiver that expired
    /// before receiving the sender's original proposal).
    pub fn expiry_fallback_tx(&self) -> Option<&bitcoin::Transaction> {
        match &self.0 {
            InternalReplayError::Expired(_, tx) => tx.as_ref(),
            _ => None,
        }
    }
}

#[cfg(feature = "v2")]
#[derive(Debug)]
pub(crate) enum InternalReplayError<SessionState, SessionEvent> {
    /// No events in the event log
    NoEvents,
    /// Invalid initial event
    InvalidEvent(Box<SessionEvent>, Option<Box<SessionState>>),
    /// Event payload failed validation
    InvalidEventPayload(Box<SessionEvent>, String),
    /// Session is expired. Carries the recoverable fallback transaction, if any.
    Expired(crate::time::Time, Option<bitcoin::Transaction>),
    /// Application storage error
    PersistenceFailure(ImplementationError),
}

#[cfg(all(test, feature = "v2"))]
mod tests {
    use super::*;
    use crate::time::Time;

    #[test]
    fn replay_error_is_expired() {
        let expired: ReplayError<(), ()> =
            ReplayError(InternalReplayError::Expired(Time::now(), None));
        assert!(expired.is_expired());
        assert!(expired.expiry_fallback_tx().is_none());

        let other: ReplayError<(), ()> = ReplayError(InternalReplayError::NoEvents);
        assert!(!other.is_expired());
    }
}

1	use std::fmt::Debug;
2	use std::{error, fmt};
3
4	#[derive(Debug)]
5	pub struct ImplementationError(Box<dyn error::Error + Send + Sync>);
6
7	impl ImplementationError {
8	pub fn new(e: impl error::Error + Send + Sync + 'static) -> Self {	6✔
9	ImplementationError(Box::new(e))	6✔
10	}	6✔
11	}
12
13	impl fmt::Display for ImplementationError {
14	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { std::fmt::Display::fmt(&self.0, f) }	19✔
15	}
16
17	impl error::Error for ImplementationError {
18	fn source(&self) -> Option<&(dyn error::Error + 'static)> { Some(self.0.as_ref()) }	×
19	}
20
21	impl PartialEq for ImplementationError {
22	fn eq(&self, _: &Self) -> bool { false }	×
23	}
24
25	impl Eq for ImplementationError {}
26
27	impl From<Box<dyn error::Error + Send + Sync>> for ImplementationError {
28	fn from(e: Box<dyn error::Error + Send + Sync>) -> Self { ImplementationError(e) }	48✔
29	}
30
31	impl From<&str> for ImplementationError {
32	fn from(e: &str) -> Self {	48✔
33	let error = Box::<dyn error::Error + Send + Sync>::from(e);	48✔
34	ImplementationError::from(error)	48✔
35	}	48✔
36	}
37	/// Errors that can occur when replaying a session event log
38	#[cfg(feature = "v2")]
39	#[derive(Debug)]
40	pub struct ReplayError<SessionState, SessionEvent>(InternalReplayError<SessionState, SessionEvent>);
41
42	#[cfg(feature = "v2")]
43	impl<SessionState: Debug, SessionEvent: Debug> std::fmt::Display
44	for ReplayError<SessionState, SessionEvent>
45	{
46	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	18✔
47	use InternalReplayError::*;
48	match &self.0 {	18✔
49	NoEvents => write!(f, "No events found in session"),	×
50	InvalidEvent(event, session) => match session {	8✔
51	Some(session) => write!(f, "Invalid event ({event:?}) for session ({session:?})",),	×
52	None => write!(f, "Invalid first event ({event:?}) for session",),	8✔
53	},
54	InvalidEventPayload(event, reason) =>	4✔
55	write!(f, "Invalid event payload ({event:?}): {reason}"),	4✔
56	Expired(time, _) => write!(f, "Session expired at {time:?}"),	6✔
57	PersistenceFailure(e) => write!(f, "Persistence failure: {e}"),	×
58	}
59	}	18✔
60	}
61	#[cfg(feature = "v2")]
62	impl<SessionState: Debug, SessionEvent: Debug> std::error::Error
63	for ReplayError<SessionState, SessionEvent>
64	{
65	}
66
67	#[cfg(feature = "v2")]
68	impl<SessionState: Debug, SessionEvent: Debug> From<InternalReplayError<SessionState, SessionEvent>>
69	for ReplayError<SessionState, SessionEvent>
70	{
71	fn from(e: InternalReplayError<SessionState, SessionEvent>) -> Self { ReplayError(e) }	20✔
72	}
73
74	#[cfg(feature = "v2")]
75	impl<SessionState, SessionEvent> ReplayError<SessionState, SessionEvent> {
76	/// Returns `true` if the event log could not be replayed because the
77	/// session has expired.
78	pub fn is_expired(&self) -> bool { matches!(self.0, InternalReplayError::Expired(..)) }	4✔
79
80	/// Returns the fallback transaction that should be broadcast when the
81	/// session has expired, if one is recoverable from the event log.
82	///
83	/// Returns `None` for non-expired errors, or for an expired session that
84	/// never produced a fallback transaction (e.g. a receiver that expired
85	/// before receiving the sender's original proposal).
86	pub fn expiry_fallback_tx(&self) -> Option<&bitcoin::Transaction> {	3✔
87	match &self.0 {	3✔
88	InternalReplayError::Expired(_, tx) => tx.as_ref(),	3✔
89	_ => None,	×
90	}
91	}	3✔
92	}
93
94	#[cfg(feature = "v2")]
95	#[derive(Debug)]
96	pub(crate) enum InternalReplayError<SessionState, SessionEvent> {
97	/// No events in the event log
98	NoEvents,
99	/// Invalid initial event
100	InvalidEvent(Box<SessionEvent>, Option<Box<SessionState>>),
101	/// Event payload failed validation
102	InvalidEventPayload(Box<SessionEvent>, String),
103	/// Session is expired. Carries the recoverable fallback transaction, if any.
104	Expired(crate::time::Time, Option<bitcoin::Transaction>),
105	/// Application storage error
106	PersistenceFailure(ImplementationError),
107	}
108
109	#[cfg(all(test, feature = "v2"))]
110	mod tests {
111	use super::*;
112	use crate::time::Time;
113
114	#[test]
115	fn replay_error_is_expired() {	1✔
116	let expired: ReplayError<(), ()> =	1✔
117	ReplayError(InternalReplayError::Expired(Time::now(), None));	1✔
118	assert!(expired.is_expired());	1✔
119	assert!(expired.expiry_fallback_tx().is_none());	1✔
120
121	let other: ReplayError<(), ()> = ReplayError(InternalReplayError::NoEvents);	1✔
122	assert!(!other.is_expired());	1✔
123	}	1✔
124	}

payjoin / rust-payjoin / 29448737091

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous