fuel-core 0.48.0

Fuel client library is aggregation of all fuels service. It contains the all business logic of the fuel protocol.
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

use crate::{
    database::OnChainIterableKeyValueView,
    service::adapters::ChainStateInfoProvider,
};
use fuel_core_gas_price_service::{
    common::{
        fuel_core_storage_adapter::{
            GasPriceSettings,
            GasPriceSettingsProvider,
        },
        utils::{
            Error as GasPriceError,
            Result as GasPriceResult,
        },
    },
    ports::{
        GasPriceData,
        L2Data,
    },
    v1::metadata::V1AlgorithmConfig,
};
use fuel_core_storage::{
    Result as StorageResult,
    transactional::HistoricalView,
};
use fuel_core_types::{
    blockchain::{
        block::Block,
        header::ConsensusParametersVersion,
    },
    fuel_tx::Transaction,
    fuel_types::BlockHeight,
};

use crate::{
    database::{
        Database,
        database_description::gas_price::GasPriceDatabase,
    },
    service::{
        Config,
        config::GasPriceConfig,
    },
};

#[cfg(test)]
mod tests;

impl L2Data for OnChainIterableKeyValueView {
    fn latest_height(&self) -> StorageResult<BlockHeight> {
        self.latest_height()
    }

    fn get_block(
        &self,
        height: &BlockHeight,
    ) -> StorageResult<Option<Block<Transaction>>> {
        self.get_full_block(height)
    }
}

impl GasPriceData for Database<GasPriceDatabase> {
    fn latest_height(&self) -> Option<BlockHeight> {
        HistoricalView::latest_height(self)
    }
}

impl From<Config> for V1AlgorithmConfig {
    fn from(value: Config) -> Self {
        let GasPriceConfig {
            starting_exec_gas_price,
            exec_gas_price_change_percent,
            min_exec_gas_price,
            exec_gas_price_threshold_percent,
            da_committer_url: _,
            da_poll_interval,
            da_gas_price_factor,
            starting_recorded_height,
            min_da_gas_price,
            max_da_gas_price,
            max_da_gas_price_change_percent,
            da_gas_price_p_component,
            da_gas_price_d_component,
            gas_price_metrics,
            activity_normal_range_size,
            activity_capped_range_size,
            activity_decrease_range_size,
            block_activity_threshold,
        } = value.gas_price_config;
        V1AlgorithmConfig {
            new_exec_gas_price: starting_exec_gas_price.max(min_exec_gas_price),
            min_exec_gas_price,
            exec_gas_price_change_percent,
            l2_block_fullness_threshold_percent: exec_gas_price_threshold_percent,
            min_da_gas_price,
            max_da_gas_price,
            max_da_gas_price_change_percent,
            da_p_component: da_gas_price_p_component,
            da_d_component: da_gas_price_d_component,
            normal_range_size: activity_normal_range_size,
            capped_range_size: activity_capped_range_size,
            decrease_range_size: activity_decrease_range_size,
            block_activity_threshold,
            da_poll_interval,
            gas_price_factor: da_gas_price_factor,
            starting_recorded_height: starting_recorded_height.map(BlockHeight::from),
            record_metrics: gas_price_metrics,
        }
    }
}

impl GasPriceSettingsProvider for ChainStateInfoProvider {
    fn settings(
        &self,
        param_version: &ConsensusParametersVersion,
    ) -> GasPriceResult<GasPriceSettings> {
        self.shared_state
            .get_consensus_parameters(param_version)
            .map(|params| GasPriceSettings {
                gas_price_factor: params.fee_params().gas_price_factor(),
                block_gas_limit: params.block_gas_limit(),
            })
            .map_err(|err| GasPriceError::CouldNotFetchMetadata {
                source_error: err.into(),
            })
    }
}