Struct Saga 

pub struct Saga {
    pub operation_id: Uuid,
    pub operation_kind: OperationKind,
    pub state: SagaStateEnum,
    pub quote_id: Option<String>,
    pub finalization_data: Option<MeltFinalizationData>,
    pub created_at: u64,
    pub updated_at: u64,
}

Persisted saga for recovery

Fields

operation_id: Uuid

Operation ID (correlation key)

operation_kind: OperationKind

Operation kind (swap, mint, melt)

state: SagaStateEnum

Current saga state (operation-specific)

quote_id: Option<String>

Quote ID for melt operations (used for payment status lookup during recovery) None for swap operations

finalization_data: Option<MeltFinalizationData>

Exact payment result for resuming melt finalization after TX1 commits.

created_at: u64

Unix timestamp when saga was created

updated_at: u64

Unix timestamp when saga was last updated

Implementations

impl Saga

pub fn new_swap(operation_id: Uuid, state: SwapSagaState) -> Self

Create new swap saga

pub fn update_swap_state(&mut self, new_state: SwapSagaState)

Update swap saga state

pub fn new_melt( operation_id: Uuid, state: MeltSagaState, quote_id: String, ) -> Self

Create new melt saga

pub fn update_melt_state(&mut self, new_state: MeltSagaState)

Update melt saga state

pub fn set_melt_finalization_data( &mut self, finalization_data: MeltFinalizationData, )

Store exact payment data needed to resume melt finalization after TX1.

Trait Implementations

impl Clone for Saga

fn clone(&self) -> Saga

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Saga

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Saga

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Saga

impl PartialEq for Saga

fn eq(&self, other: &Saga) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Saga

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Saga