Struct massa_ledger_exports::LedgerChanges

pub struct LedgerChanges(pub PreHashMap<Address, SetUpdateOrDelete<LedgerEntry, LedgerEntryUpdate>>);

represents a list of changes to multiple ledger entries

Tuple Fields

0: PreHashMap<Address, SetUpdateOrDelete<LedgerEntry, LedgerEntryUpdate>>

Implementations

impl LedgerChanges

pub fn get( &self, addr: &Address, ) -> Option<&SetUpdateOrDelete<LedgerEntry, LedgerEntryUpdate>>

Get an item from the LedgerChanges

pub fn get_bytecode_updates(&self) -> Vec<Bytecode>

Retrieves all the bytcode updates contained in the current changes

pub fn create_address(&mut self, address: &Address)

Create a new, empty address. Overwrites the address if it is already there.

pub fn get_balance_or_else<F: FnOnce() -> Option<Amount>>( &self, addr: &Address, f: F, ) -> Option<Amount>

Tries to return the balance of an entry or gets it from a function if the entry’s status is unknown.

This function is used as an optimization: if the value can be deduced unambiguously from the LedgerChanges, no need to dig further (for example in the FinalLedger).

Arguments

• addr: address for which to get the value
• f: fallback function with no arguments and returning Option<Amount>

Returns

• Some(v) if a value is present, where v is a copy of the value
• None if the value is absent
• f() if the value is unknown

pub fn get_bytecode_or_else<F: FnOnce() -> Option<Bytecode>>( &self, addr: &Address, f: F, ) -> Option<Bytecode>

Tries to return the executable bytecode of an entry or gets it from a function if the entry’s status is unknown.

This function is used as an optimization: if the value can be deduced unambiguously from the LedgerChanges, no need to dig further (for example in the FinalLedger).

Arguments

• addr: address for which to get the value
• f: fallback function with no arguments and returning Option<Vec<u8>>

Returns

• Some(v) if a value is present, where v is a copy of the value
• None if the value is absent
• f() if the value is unknown

pub fn entry_exists_or_else<F: FnOnce() -> bool>( &self, addr: &Address, f: F, ) -> bool

Tries to return whether an entry exists or gets the information from a function if the entry’s status is unknown.

This function is used as an optimization: if the result can be deduced unambiguously from the LedgerChanges, no need to dig further (for example in the FinalLedger).

Arguments

• addr: address to search for
• f: fallback function with no arguments and returning a boolean

Returns

• true if the entry exists
• false if the value is absent
• f() if the value’s existence is unknown

pub fn set_balance(&mut self, addr: Address, balance: Amount)

Set the balance of an address. If the address doesn’t exist, its ledger entry is created.

Arguments

• addr: target address
• balance: balance to set for the provided address

pub fn set_bytecode(&mut self, addr: Address, bytecode: Bytecode)

Set the executable bytecode of an address. If the address doesn’t exist, its ledger entry is created.

Parameters

• addr: target address
• bytecode: executable bytecode to assign to that address

pub fn get_data_entry_or_else<F: FnOnce() -> Option<Vec<u8>>>( &self, addr: &Address, key: &[u8], f: F, ) -> Option<Vec<u8>>

Tries to return a datastore entry for a given address, or gets it from a function if the value’s status is unknown.

This function is used as an optimization: if the result can be deduced unambiguously from the LedgerChanges, no need to dig further (for example in the FinalLedger).

Arguments

• addr: target address
• key: datastore key
• f: fallback function with no arguments and returning Option<Vec<u8>>

Returns

• Some(v) if the value was found, where v is a copy of the value
• None if the value is absent
• f() if the value is unknown

pub fn has_writes(&self, addr: &Address, key: Option<Vec<u8>>) -> bool

Tries to return whether the ledger changes contain a write for the given address and optionally if a datastore key write also exists in the address’s datastore. Notes:

• A ledger entry could be written to without any changes on the values associated, for example if the value was changed multiple times in the same slot.
• This code assumes Delete cannot be shadowed by Set operations in the same slot, which may not be the case when / if we allow full entry Delete given the current LedgerChanges::Delete handling. In that case, a rework may be necessary.

Arguments

• addr: target address
• key: optional datastore key

Returns

• true if the address and, optionally the datastore key, exists in the ledger changes

pub fn has_data_entry_or_else<F: FnOnce() -> bool>( &self, addr: &Address, key: &[u8], f: F, ) -> bool

Tries to return whether a datastore entry exists for a given address, or gets it from a function if the datastore entry’s status is unknown.

This function is used as an optimization: if the result can be deduced unambiguously from the LedgerChanges, no need to dig further (for example in the FinalLedger).

Arguments

• addr: target address
• key: datastore key
• f: fallback function with no arguments and returning a boolean

Returns

• true if the ledger entry exists and the key is present in its datastore
• false if the ledger entry is absent, or if the key is not in its datastore
• f() if the existence of the ledger entry or datastore entry is unknown

pub fn set_data_entry(&mut self, addr: Address, key: Vec<u8>, data: Vec<u8>)

Set a datastore entry for a given address. If the address doesn’t exist, its ledger entry is created. If the datastore entry exists, its value is replaced, otherwise it is created.

Arguments

• addr: target address
• key: datastore key
• data: datastore value to set

pub fn delete_data_entry(&mut self, addr: Address, key: Vec<u8>)

Deletes a datastore entry for a given address. Does nothing if the entry is missing.

Arguments

• addr: target address
• key: datastore key

Trait Implementations

impl Applicable<LedgerChanges> for LedgerChanges

fn apply(&mut self, changes: LedgerChanges)

extends the current LedgerChanges with another one

impl Clone for LedgerChanges

fn clone(&self) -> LedgerChanges

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LedgerChanges

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

Formats the value using the given formatter.

impl Default for LedgerChanges

fn default() -> LedgerChanges

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LedgerChanges

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<LedgerChanges> for LedgerChangesDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], LedgerChanges, E>

Example

use massa_serialization::{Deserializer, Serializer, DeserializeError};
use massa_ledger_exports::{LedgerEntry,  LedgerChanges, LedgerChangesSerializer, LedgerChangesDeserializer};
use std::str::FromStr;
use std::collections::BTreeMap;
use massa_models::types::{SetUpdateOrDelete};
use massa_models::{amount::Amount, address::Address, bytecode::Bytecode};

let key = "hello world".as_bytes().to_vec();
let mut datastore = BTreeMap::new();
datastore.insert(key, vec![1, 2, 3]);
let balance = Amount::from_str("1").unwrap();
let bytecode = Bytecode(vec![1, 2, 3]);
let ledger_entry = LedgerEntry {
   balance,
   bytecode,
   datastore,
};
let mut serialized = Vec::new();
let mut changes = LedgerChanges::default();
changes.0.insert(
   Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
   SetUpdateOrDelete::Set(ledger_entry),
);
LedgerChangesSerializer::new().serialize(&changes, &mut serialized).unwrap();
let (rest, changes_deser) = LedgerChangesDeserializer::new(255, 255, 10000, 10000).deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(changes, changes_deser);

impl PartialEq for LedgerChanges

fn eq(&self, other: &LedgerChanges) -> 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 LedgerChanges

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<LedgerChanges> for LedgerChangesSerializer

fn serialize( &self, value: &LedgerChanges, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Example

use massa_serialization::Serializer;
use massa_ledger_exports::{LedgerEntry, LedgerChanges, LedgerChangesSerializer};
use std::str::FromStr;
use massa_models::types::{SetUpdateOrDelete};
use std::collections::BTreeMap;
use massa_models::{amount::Amount, address::Address, bytecode::Bytecode};

let key = "hello world".as_bytes().to_vec();
let mut datastore = BTreeMap::new();
datastore.insert(key, vec![1, 2, 3]);
let balance = Amount::from_str("1").unwrap();
let bytecode = Bytecode(vec![1, 2, 3]);
let ledger_entry = LedgerEntry {
   balance,
   bytecode,
   datastore,
};
let mut serialized = Vec::new();
let mut changes = LedgerChanges::default();
changes.0.insert(
   Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
   SetUpdateOrDelete::Set(ledger_entry),
);
LedgerChangesSerializer::new().serialize(&changes, &mut serialized).unwrap();

impl Eq for LedgerChanges

impl StructuralPartialEq for LedgerChanges