Struct lido::state::RewardDistribution

pub struct RewardDistribution {
    pub treasury_fee: u32,
    pub validation_fee: u32,
    pub developer_fee: u32,
    pub st_sol_appreciation: u32,
}

Determines how rewards are split up among these parties, represented as the number of parts of the total. For example, if each party has 1 part, then they all get an equal share of the reward.

Fields

treasury_fee: u32

validation_fee: u32

developer_fee: u32

st_sol_appreciation: u32

Implementations

impl RewardDistribution

pub fn sum(&self) -> u64

pub fn treasury_fraction(&self) -> Rational

pub fn validation_fraction(&self) -> Rational

pub fn developer_fraction(&self) -> Rational

pub fn split_reward(
    &self,
    amount: Lamports,
    num_validators: u64
) -> Result<Fees>

Split the reward according to the distribution defined in this instance.

Fees are all rounded down, and the remainder goes to stSOL appreciation. This means that the outputs may not sum to the input, even when st_sol_appreciation is 0.

Returns the fee amounts in SOL. stSOL should be minted for those when they get distributed. This acts like a deposit: it is like the fee recipients received their fee in SOL outside of Solido, and then deposited it. The remaining SOL, which is not taken as a fee, acts as a donation to the pool, and makes the SOL value of stSOL go up. It is not included in the output, as nothing needs to be done to handle it.

Trait Implementations

impl BorshDeserialize for RewardDistribution where
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    u32: BorshDeserialize,
    u32: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSchema for RewardDistribution where
    u32: BorshSchema,
    u32: BorshSchema,
    u32: BorshSchema,
    u32: BorshSchema, 

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively(
    definitions: &mut HashMap<Declaration, Definition>
)

Recursively, using DFS, add type definitions required for this type. For primitive types this is an empty map. Type definition explains how to serialize/deserialize a type.

fn add_definition(
    declaration: String,
    definition: Definition,
    definitions: &mut HashMap<String, Definition, RandomState>
)

Helper method to add a single type definition to the map.

fn schema_container() -> BorshSchemaContainer

impl BorshSerialize for RewardDistribution where
    u32: BorshSerialize,
    u32: BorshSerialize,
    u32: BorshSerialize,
    u32: BorshSerialize, 

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl Clone for RewardDistribution

fn clone(&self) -> RewardDistribution

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RewardDistribution

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RewardDistribution

fn default() -> RewardDistribution

Returns the “default value” for a type.

impl PartialEq<RewardDistribution> for RewardDistribution

fn eq(&self, other: &RewardDistribution) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RewardDistribution) -> bool

This method tests for !=.

impl Serialize for RewardDistribution

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for RewardDistribution

impl StructuralEq for RewardDistribution

impl StructuralPartialEq for RewardDistribution