Struct jormungandr::blockcfg::Ledger

pub struct Ledger {

    pub(crate) utxos: Ledger<Address>,
    pub(crate) oldutxos: Ledger<Addr>,
    pub(crate) accounts: Ledger<Identifier, ()>,
    pub(crate) settings: Settings,
    pub(crate) updates: UpdateState,
    pub(crate) multisig: Ledger,
    pub(crate) delegation: PoolsState,
    pub(crate) static_params: Arc<LedgerStaticParameters, Global>,
    pub(crate) date: BlockDate,
    pub(crate) chain_length: ChainLength,
    pub(crate) era: TimeEra,
    pub(crate) pots: Pots,
    pub(crate) leaders_log: LeadersParticipationRecord,
    pub(crate) votes: VotePlanLedger,
    pub(crate) governance: Governance,
    pub(crate) token_totals: TokenTotals,
}

Overall ledger structure.

This represent a given state related to utxo/old utxo/accounts/… at a given point in time.

The ledger can be easily and cheaply cloned despite containing reference to a lot of data (millions of utxos, thousands of accounts, ..)

Fields

utxos: Ledger<Address>

oldutxos: Ledger<Addr>

accounts: Ledger<Identifier, ()>

settings: Settings

updates: UpdateState

multisig: Ledger

delegation: PoolsState

static_params: Arc<LedgerStaticParameters, Global>

date: BlockDate

chain_length: ChainLength

era: TimeEra

pots: Pots

leaders_log: LeadersParticipationRecord

votes: VotePlanLedger

governance: Governance

token_totals: TokenTotals

Implementations

impl Ledger

pub fn stats(&self) -> Vec<String, Global>

pub fn info_eq(&self, other: &Ledger) -> Vec<String, Global>

impl Ledger

pub fn iter(&self) -> LedgerIterator<'_>

impl Ledger

pub fn new<'a, I>( block0_initial_hash: Hash, contents: I ) -> Result<Ledger, Error>where I: IntoIterator<Item = &'a Fragment>,

pub fn can_distribute_reward(&self) -> bool

pub fn apply_protocol_changes(&self) -> Result<Ledger, Error>

pub fn distribute_rewards( &self, distribution: &StakeDistribution, rewards_info_params: RewardsInfoParameters ) -> Result<(Ledger, EpochRewardsInfo), Error>

This need to be called before the first block of a new epoch

• Reset the leaders log
• Distribute the contribution (rewards + fees) to pools and their delegatees

pub fn begin_block( &self, chain_length: ChainLength, block_date: BlockDate ) -> Result<ApplyBlockLedger, Error>

pub fn apply_block( &self, contents: &Contents, metadata: &HeaderContentEvalContext ) -> Result<Ledger, Error>

Try to apply messages to a State, and return the new State if successful

pub fn apply_fragment( &self, content: &Fragment, block_date: BlockDate ) -> Result<Ledger, Error>

Try to apply a message to the State, and return the new State if successful

this does not advance the state to the new state but apply a simple fragment of block to the current context.

pub fn apply_transaction<Extra>( self, fragment_id: &Hash, tx: &TransactionSlice<'_, Extra> ) -> Result<(Ledger, Value), Error>where Extra: Payload, LinearFee: FeeAlgorithm,

Applies transaction to the account ledger by validating and verifying inputs and outputs, as well as spending the fee value from the related account id. Returns an Error if the account cannot afford the fee or if the spending counter doesn’t match.

pub fn apply_update(self, update: &UpdateProposal) -> Result<Ledger, Error>

pub fn apply_update_proposal( self, proposal_id: Hash, proposal: UpdateProposal, auth_data: &TransactionBindingAuthData<'_>, sig: SingleAccountBindingSignature, cur_date: BlockDate ) -> Result<Ledger, Error>

pub fn apply_update_vote( self, vote: &UpdateVote, auth_data: &TransactionBindingAuthData<'_>, sig: SingleAccountBindingSignature ) -> Result<Ledger, Error>

pub fn apply_vote_plan( self, tx: &TransactionSlice<'_, VotePlan>, cur_date: BlockDate, vote_plan: VotePlan, sig: VotePlanProof ) -> Result<Ledger, Error>

pub fn apply_vote_cast( self, account_id: Identifier, vote: VoteCast ) -> Result<Ledger, Error>

pub fn active_vote_plans(&self) -> Vec<VotePlanStatus, Global>

pub fn apply_vote_tally( self, tally: &VoteTally, bad: &TransactionBindingAuthData<'_>, sig: TallyProof ) -> Result<Ledger, Error>

pub fn apply_pool_registration_signcheck( self, cert: &PoolRegistration, bad: &TransactionBindingAuthData<'_>, sig: PoolSignature ) -> Result<Ledger, Error>

pub fn apply_pool_registration( self, cert: &PoolRegistration ) -> Result<Ledger, Error>

pub fn apply_pool_retirement( self, auth_cert: &PoolRetirement, bad: &TransactionBindingAuthData<'_>, sig: PoolSignature ) -> Result<Ledger, Error>

pub fn apply_pool_update( self, auth_cert: &PoolUpdate, bad: &TransactionBindingAuthData<'_>, sig: PoolSignature ) -> Result<Ledger, Error>

pub fn apply_stake_delegation( self, auth_cert: &StakeDelegation ) -> Result<Ledger, Error>

pub fn apply_owner_stake_delegation( self, account_id: &UnspecifiedAccountIdentifier, witness: &Witness, delegation: &OwnerStakeDelegation ) -> Result<Ledger, Error>

pub fn mint_token(self, mt: MintToken) -> Result<Ledger, Error>

pub fn mint_token_unchecked(self, mt: MintToken) -> Result<Ledger, Error>

pub fn get_stake_distribution(&self) -> StakeDistribution

pub fn get_static_parameters(&self) -> &LedgerStaticParameters

access the ledger static parameters

pub fn accounts(&self) -> &Ledger<Identifier, ()>

pub fn updates(&self) -> &UpdateState

pub fn token_totals(&self) -> &TokenTotals

pub fn token_distribution(&self) -> TokenDistribution<'_, ()>

pub fn consensus_version(&self) -> ConsensusType

pub fn utxo_out(&self, fragment_id: Hash, index: u8) -> Option<&Output<Address>>

pub fn utxos(&self) -> Iter<'_, Address>

pub fn chain_length(&self) -> ChainLength

pub fn settings(&self) -> &Settings

pub fn delegation(&self) -> &PoolsState

pub fn delegation_mut(&mut self) -> &mut PoolsState

pub fn date(&self) -> BlockDate

pub fn era(&self) -> &TimeEra

pub fn get_total_value(&self) -> Result<Value, Error>

pub fn remaining_rewards(&self) -> Value

pub fn treasury_value(&self) -> Value

Trait Implementations

impl Arbitrary for Ledger

fn arbitrary<G>(g: &mut G) -> Ledgerwhere G: Gen,

fn shrink(&self) -> Box<dyn Iterator<Item = Self>, Global>

impl Clone for Ledger

fn clone(&self) -> Ledger

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ledger

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

Formats the value using the given formatter.

impl DeserializeFromSlice for Ledger

fn deserialize_from_slice(codec: &mut Codec<&[u8]>) -> Result<Ledger, ReadError>

fn deserialize_validate_from_slice( codec: &mut Codec<&[u8]> ) -> Result<(), ReadError>

impl From<TestLedger> for Ledger

fn from(from: TestLedger) -> Ledger

Converts to this type from the input type.

impl PartialEq<Ledger> for Ledger

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Ledger

fn serialize<W>(&self, codec: &mut Codec<W>) -> Result<(), WriteError>where W: Write,

fn serialized_size(&self) -> usize

Default implementation, not efficient, not recommended to use it

fn serialize_as_vec(&self) -> Result<Vec<u8, Global>, WriteError>

Convenience method to serialize into a byte vector.

impl Eq for Ledger

impl StructuralEq for Ledger

impl StructuralPartialEq for Ledger