fuel-core-txpool 0.41.10

Transaction pool that manages transactions and their dependencies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Test module for validating TxUpdateStream state transitions.

#![allow(clippy::arithmetic_side_effects)]

use fuel_core_types::services::txpool::TransactionStatus;
use test_strategy::{
    proptest,
    Arbitrary,
};

use crate::{
    tests::utils,
    tx_status_stream::{
        State,
        TxStatusMessage,
        TxUpdateStream,
    },
};

/// Represents the possible state transitions in TxUpdateStream.
#[derive(Debug, PartialEq, Eq, Clone, Arbitrary)]
pub(crate) enum StateTransitions {
    AddMsg(#[strategy(utils::tx_status_message_strategy())] TxStatusMessage),
    AddFailure,
    CloseRecv,
    Next,
}

/// Returns the new state after applying the given `transition` to the current `state`.
pub(crate) fn validate_tx_update_stream_state(
    state: State,
    transition: StateTransitions,
) -> State {
    use State::*;
    use StateTransitions::*;
    match (state, transition) {
        (
            Empty,
            AddMsg(TxStatusMessage::Status(TransactionStatus::Submitted { time })),
        ) => Initial(TransactionStatus::Submitted { time }),
        // If not Submitted, it's an early success.
        (Empty, AddMsg(TxStatusMessage::Status(s))) => EarlySuccess(s),
        (Empty, AddMsg(TxStatusMessage::FailedStatus)) => Failed,
        (Empty, AddFailure) => Failed,
        (Empty | Initial(_), Next) => Empty,
        (Initial(s1), AddMsg(TxStatusMessage::Status(s2))) => Success(s1, s2),
        (Initial(s1), AddMsg(TxStatusMessage::FailedStatus)) => LateFailed(s1),
        (Initial(s), AddFailure) => LateFailed(s),
        (_, CloseRecv) => Closed,
        (EarlySuccess(_) | Failed | SenderClosed(_), Next) => Closed,
        (LateFailed(_), Next) => Failed,
        (Success(_, s2), Next) => SenderClosed(s2),
        // Final states.
        (Closed, _) => Closed,
        (EarlySuccess(s), _) => EarlySuccess(s),
        (Success(s1, s2), _) => Success(s1, s2),
        (Failed, _) => Failed,
        (LateFailed(s), _) => LateFailed(s),
        (SenderClosed(s), _) => SenderClosed(s),
    }
}

/// Proptest for validating TxUpdateStream state transitions.
#[proptest]
fn test_tx_update_stream_state(
    #[strategy(utils::state_strategy())] state: State,
    transition: StateTransitions,
) {
    let mut stream = TxUpdateStream::with_state(state.clone());
    let new_state = validate_tx_update_stream_state(state, transition.clone());
    match transition {
        StateTransitions::AddMsg(s) => {
            stream.add_msg(s);
        }
        StateTransitions::AddFailure => {
            stream.add_failure();
        }
        StateTransitions::CloseRecv => {
            stream.close_recv();
        }
        StateTransitions::Next => {
            stream.try_next();
        }
    }

    assert_eq!(new_state, *stream.state());
}