pinocchio 0.11.1

Create Solana programs with no external dependencies attached
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

//! Calculation of transaction fees.

use {
    super::{clock::DEFAULT_MS_PER_SLOT, Sysvar},
    crate::impl_sysvar_get,
};

/// Fee calculator for processing transactions
#[cfg_attr(feature = "copy", derive(Copy))]
#[derive(Clone, Debug)]
pub struct FeeCalculator {
    /// The current cost of a signature in lamports.
    /// This amount may increase/decrease over time based on cluster processing
    /// load.
    pub lamports_per_signature: u64,
}

impl FeeCalculator {
    /// Create a new instance of the `FeeCalculator`.
    pub fn new(lamports_per_signature: u64) -> Self {
        Self {
            lamports_per_signature,
        }
    }
}

/// Governs the fee rate for the cluster
#[cfg_attr(feature = "copy", derive(Copy))]
#[derive(Clone, Debug)]
pub struct FeeRateGovernor {
    /// The current cost of a signature
    pub lamports_per_signature: u64,
    /// The target cost of a signature
    pub target_lamports_per_signature: u64,
    /// The target number of signatures per slot
    pub target_signatures_per_slot: u64,
    /// Minimum lamports per signature
    pub min_lamports_per_signature: u64,
    /// Maximum lamports per signature
    pub max_lamports_per_signature: u64,
    /// Percentage of fees to burn (0-100)
    pub burn_percent: u8,
}

/// Default lamports per signature.
pub const DEFAULT_TARGET_LAMPORTS_PER_SIGNATURE: u64 = 10_000;

/// Default signatures per slot.
pub const DEFAULT_TARGET_SIGNATURES_PER_SLOT: u64 = 50 * DEFAULT_MS_PER_SLOT;

/// Default percentage of fees to burn.
pub const DEFAULT_BURN_PERCENT: u8 = 50;

impl Default for FeeRateGovernor {
    fn default() -> Self {
        Self {
            lamports_per_signature: 0,
            target_lamports_per_signature: DEFAULT_TARGET_LAMPORTS_PER_SIGNATURE, /* Example default value */
            target_signatures_per_slot: DEFAULT_TARGET_SIGNATURES_PER_SLOT, /* Assuming 400ms per
                                                                             * slot */
            min_lamports_per_signature: 0,
            max_lamports_per_signature: 0,
            burn_percent: DEFAULT_BURN_PERCENT,
        }
    }
}

impl FeeRateGovernor {
    /// Create a new `FeeCalculator` based on current cluster signature
    /// throughput
    pub fn create_fee_calculator(&self) -> FeeCalculator {
        FeeCalculator::new(self.lamports_per_signature)
    }

    /// Calculate unburned fee from a fee total, returns (unburned, burned)
    pub fn burn(&self, fees: u64) -> (u64, u64) {
        let burned = fees * u64::from(self.burn_percent) / 100;
        (fees - burned, burned)
    }
}

/// Fees sysvar
#[cfg_attr(feature = "copy", derive(Copy))]
#[derive(Clone, Debug)]
pub struct Fees {
    /// Fee calculator for processing transactions
    pub fee_calculator: FeeCalculator,
    /// Fee rate governor
    pub fee_rate_governor: FeeRateGovernor,
}

impl Fees {
    /// Create a new instance of the Fees sysvar
    pub fn new(fee_calculator: FeeCalculator, fee_rate_governor: FeeRateGovernor) -> Self {
        Self {
            fee_calculator,
            fee_rate_governor,
        }
    }
}

impl Sysvar for Fees {
    impl_sysvar_get!(sol_get_fees_sysvar);
}