fuel-core-txpool 0.47.0

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use fuel_core_services::Service;
use fuel_core_types::{
    fuel_tx::{
        UniqueIdentifier,
        UtxoId,
    },
    services::transaction_status::TransactionStatus,
};

use crate::tests::universe::TestPoolUniverse;

#[tokio::test]
async fn test_tx__keep_missing_input_and_resolved_when_input_submitted() {
    let mut universe = TestPoolUniverse::default();
    universe.config.utxo_validation = true;
    let timeout = tokio::time::Duration::from_millis(10000);
    universe.config.pending_pool_tx_ttl = timeout;

    let (output, unset_input) = universe.create_output_and_input();
    let tx1 = universe.build_script_transaction(None, Some(vec![output]), 10);
    let tx1_id = tx1.id(&Default::default());
    let input = unset_input.into_input(UtxoId::new(tx1_id, 0));
    let tx2 = universe.build_script_transaction(Some(vec![input]), None, 20);
    let tx2_id = tx2.id(&Default::default());

    let service = universe.build_service(None, None);
    service.start_and_await().await.unwrap();

    // Given
    let ids = vec![tx2_id];
    service.shared.try_insert(vec![tx2.clone()]).unwrap();

    universe
        .await_expected_tx_statuses(ids, |status| {
            matches!(status, TransactionStatus::Submitted { .. })
        })
        .await
        .unwrap_err()
        .is_timeout();

    // When
    service.shared.try_insert(vec![tx1.clone()]).unwrap();

    // Then
    let ids = vec![tx1_id, tx2_id];
    universe.await_expected_tx_statuses_submitted(ids).await;

    service.stop_and_await().await.unwrap();
}

#[tokio::test]
async fn test_tx__return_error_expired() {
    let mut universe = TestPoolUniverse::default();
    universe.config.utxo_validation = true;
    let timeout = tokio::time::Duration::from_millis(100);
    universe.config.pending_pool_tx_ttl = timeout;

    // Given
    let (_, unset_input) = universe.create_output_and_input();
    let tx1 = universe.build_script_transaction(None, None, 10);
    let tx1_id = tx1.id(&Default::default());
    let input = unset_input.into_input(UtxoId::new(tx1_id, 0));
    let missing_utxoid = *input.clone().utxo_id().unwrap();
    let tx2 = universe.build_script_transaction(Some(vec![input]), None, 20);
    let tx2_id = tx2.id(&Default::default());

    let service = universe.build_service(None, None);
    service.start_and_await().await.unwrap();

    // When
    service.shared.try_insert(vec![tx2.clone()]).unwrap();

    // Then
    // The error returned is the error that the transaction was squeezed out for.
    // We don't need the user to know that pending pool exists
    let ids = vec![tx2_id];
    let squeezed_out_reason = format!(
        "Transaction input validation failed: UTXO \
        (id: {missing_utxoid}) \
        does not exist"
    );
    universe
        .await_expected_tx_statuses(ids, |status| {
            matches!(status, TransactionStatus::SqueezedOut(s)
                if s.reason == squeezed_out_reason)
        })
        .await
        .unwrap();

    service.stop_and_await().await.unwrap();
}

#[tokio::test]
async fn test_tx__directly_removed_not_enough_space() {
    let mut universe = TestPoolUniverse::default();
    universe.config.utxo_validation = true;
    universe.config.max_pending_pool_size_percentage = 1;
    universe.config.pool_limits.max_txs = 1;

    let (_, unset_input) = universe.create_output_and_input();
    let tx1 = universe.build_script_transaction(None, None, 10);
    let tx_id1 = tx1.id(&Default::default());
    let input = unset_input.into_input(UtxoId::new(tx_id1, 0));
    let missing_utxoid = *input.clone().utxo_id().unwrap();
    let tx2 = universe.build_script_transaction(Some(vec![input]), None, 20);
    let tx2_id = tx2.id(&Default::default());

    let service = universe.build_service(None, None);
    service.start_and_await().await.unwrap();

    // Given
    // When
    service.shared.try_insert(vec![tx2.clone()]).unwrap();

    // Then
    // The error returned is the error that the transaction was squeezed out for.
    // We don't need the user to know that pending pool exists
    let ids = vec![tx2_id];
    let squeezed_out_reason = format!(
        "Transaction input validation failed: UTXO \
        (id: {missing_utxoid}) \
        does not exist"
    );
    universe
        .await_expected_tx_statuses(ids, |status| {
            matches!(status, TransactionStatus::SqueezedOut(s)
                if s.reason == squeezed_out_reason)
        })
        .await
        .unwrap();

    service.stop_and_await().await.unwrap();
}