fuel-core-txpool 0.17.5

Transaction pool
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

use crate::ports::TxPoolDb;
use fuel_core_storage::Result as StorageResult;
use fuel_core_types::{
    blockchain::primitives::BlockHeight,
    entities::{
        coin::{
            Coin,
            CompressedCoin,
        },
        message::CompressedMessage,
    },
    fuel_tx::{
        Contract,
        ContractId,
        MessageId,
        UtxoId,
    },
};
use std::{
    collections::{
        HashMap,
        HashSet,
    },
    sync::{
        Arc,
        Mutex,
    },
};

#[derive(Default)]
pub struct Data {
    pub coins: HashMap<UtxoId, CompressedCoin>,
    pub contracts: HashMap<ContractId, Contract>,
    pub messages: HashMap<MessageId, CompressedMessage>,
    pub spent_messages: HashSet<MessageId>,
}

#[derive(Clone, Default)]
pub struct MockDb {
    pub data: Arc<Mutex<Data>>,
}

impl MockDb {
    pub fn insert_coin(&self, coin: Coin) {
        self.data
            .lock()
            .unwrap()
            .coins
            .insert(coin.utxo_id, coin.compress());
    }

    pub fn insert_message(&self, message: CompressedMessage) {
        self.data
            .lock()
            .unwrap()
            .messages
            .insert(message.id(), message);
    }

    pub fn spend_message(&self, message_id: MessageId) {
        self.data.lock().unwrap().spent_messages.insert(message_id);
    }
}

impl TxPoolDb for MockDb {
    fn utxo(&self, utxo_id: &UtxoId) -> StorageResult<Option<CompressedCoin>> {
        Ok(self
            .data
            .lock()
            .unwrap()
            .coins
            .get(utxo_id)
            .map(Clone::clone))
    }

    fn contract_exist(&self, contract_id: &ContractId) -> StorageResult<bool> {
        Ok(self
            .data
            .lock()
            .unwrap()
            .contracts
            .contains_key(contract_id))
    }

    fn message(
        &self,
        message_id: &MessageId,
    ) -> StorageResult<Option<CompressedMessage>> {
        Ok(self
            .data
            .lock()
            .unwrap()
            .messages
            .get(message_id)
            .map(Clone::clone))
    }

    fn is_message_spent(&self, message_id: &MessageId) -> StorageResult<bool> {
        Ok(self
            .data
            .lock()
            .unwrap()
            .spent_messages
            .contains(message_id))
    }

    fn current_block_height(&self) -> StorageResult<BlockHeight> {
        Ok(Default::default())
    }
}