Struct snarkos_storage::ledger::Ledger

pub struct Ledger<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> {
    pub current_block_height: AtomicU32,
    pub ledger_parameters: Arc<P>,
    pub cm_merkle_tree: ArcSwap<MerkleTree<P>>,
    pub storage: S,
    pub _transaction: PhantomData<T>,
}

Fields

current_block_height: AtomicU32

ledger_parameters: Arc<P>

cm_merkle_tree: ArcSwap<MerkleTree<P>>

storage: S

_transaction: PhantomData<T>

Implementations

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn new_empty<PATH: AsRef<Path>>(
    path: Option<PATH>
) -> Result<Self, StorageError>

Create a fresh blockchain, optionally at the specified path. Warning: if specified, any existing storage at that location is removed.

pub fn open_at_path<PATH: AsRef<Path>>(path: PATH) -> Result<Self, StorageError>

Open the blockchain storage at a particular path.

pub fn open_secondary_at_path<PATH: AsRef<Path>>(
    path: PATH
) -> Result<Self, StorageError>

Open the blockchain storage at a particular path as a secondary read-only instance.

pub fn is_empty(&self) -> bool

Returns true if there are no blocks in the ledger.

pub fn get_current_block_height(&self) -> BlockHeight

Get the latest block height of the chain.

pub fn get_block_count(&self) -> BlockHeight

Get the latest number of blocks in the chain.

pub fn get_best_block_number(&self) -> Result<BlockHeight, StorageError>

Get the height of the best block on the chain.

pub fn get_peer_book(&self) -> Result<Option<Vec<u8>>, StorageError>

Get the stored old connected peers.

pub fn save_peer_book_to_storage(
    &self,
    peers_serialized: Vec<u8>
) -> Result<(), StorageError>

Store the connected peers.

pub fn catch_up_secondary(
    &self,
    update_merkle_tree: bool
) -> Result<(), StorageError>

Attempt to catch the secondary read-only storage instance with the primary instance.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn get_latest_block(&self) -> Result<Block<T>, StorageError>

Get the latest block in the chain.

pub fn get_block(
    &self,
    block_hash: &BlockHeaderHash
) -> Result<Block<T>, StorageError>

Get a block given the block hash.

pub fn get_block_from_block_number(
    &self,
    block_number: u32
) -> Result<Block<T>, StorageError>

Get a block given the block number.

pub fn get_block_hash(
    &self,
    block_number: u32
) -> Result<BlockHeaderHash, StorageError>

Get the block hash given a block number.

pub fn get_block_number(
    &self,
    block_hash: &BlockHeaderHash
) -> Result<u32, StorageError>

Get the block number given a block hash.

pub fn get_block_transactions(
    &self,
    block_hash: &BlockHeaderHash
) -> Result<DPCTransactions<T>, StorageError>

Get the list of transaction ids given a block hash.

pub fn get_child_block_hashes(
    &self,
    parent_header: &BlockHeaderHash
) -> Result<Vec<BlockHeaderHash>, StorageError>

Find the potential child block hashes given a parent block header.

pub fn already_mined(
    &self,
    block: &Block<T>
) -> Result<Option<u32>, StorageError>

Returns the block number of a conflicting block that has already been mined.

pub fn remove_block(
    &self,
    block_hash: BlockHeaderHash
) -> Result<(), StorageError>

Remove a block and it’s related data from the storage.

pub fn decommit_latest_block(&self) -> Result<BlockHeaderHash, StorageError>

De-commit the latest block and return its header hash.

pub fn remove_latest_block(&self) -> Result<(), StorageError>

Remove the latest block.

pub fn remove_latest_blocks(&self, num_blocks: u32) -> Result<(), StorageError>

Remove the latest num_blocks blocks.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn block_hash_exists(&self, block_hash: &BlockHeaderHash) -> bool

Returns true if the block for the given block header hash exists.

pub fn get_block_header(
    &self,
    block_hash: &BlockHeaderHash
) -> Result<BlockHeader, StorageError>

Get a block header given the block hash.

pub fn previous_block_hash_exists(&self, block: &Block<T>) -> bool

Returns true if the block corresponding to this block’s previous_block_hash exists.

pub fn get_latest_shared_hash(
    &self,
    block_locator_hashes: Vec<BlockHeaderHash>
) -> Result<BlockHeaderHash, StorageError>

Returns the latest shared block header hash. If the block locator hashes are for a side chain, returns the common point of fork. If the block locator hashes are for the canon chain, returns the latest block header hash.

pub fn get_block_locator_hashes(
    &self
) -> Result<Vec<BlockHeaderHash>, StorageError>

Returns a list of block locator hashes. The purpose of this method is to detect wrong branches in the caller’s canon chain.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn get_block_path(
    &self,
    block_header: &BlockHeader
) -> Result<BlockPath, StorageError>

Get the block’s path/origin.

pub fn longest_child_path(
    &self,
    block_hash: BlockHeaderHash
) -> Result<Vec<BlockHeaderHash>, StorageError>

Returns the path length and the longest path of children from the given block header

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn current_cm_index(&self) -> Result<usize, StorageError>

Get the current commitment index

pub fn current_sn_index(&self) -> Result<usize, StorageError>

Get the current serial number index

pub fn current_memo_index(&self) -> Result<usize, StorageError>

Get the current memo index

pub fn current_digest(&self) -> Result<Vec<u8>, StorageError>

Get the current ledger digest

pub fn past_digests(&self) -> Result<HashSet<Box<[u8]>>, StorageError>

Get the set of past ledger digests

pub fn get_sn_index(
    &self,
    sn_bytes: &[u8]
) -> Result<Option<usize>, StorageError>

Get serial number index.

pub fn get_cm_index(
    &self,
    cm_bytes: &[u8]
) -> Result<Option<usize>, StorageError>

Get commitment index

pub fn get_memo_index(
    &self,
    memo_bytes: &[u8]
) -> Result<Option<usize>, StorageError>

Get memo index

pub fn rebuild_merkle_tree(
    &self,
    additional_cms: Vec<(T::Commitment, usize)>
) -> Result<(), StorageError>

Build a new commitment merkle tree from the stored commitments

pub fn update_merkle_tree(
    &self,
    new_best_block_number: u32
) -> Result<(), StorageError>

Rebuild the stored merkle tree with the current stored commitments

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn insert_only(&self, block: &Block<T>) -> Result<(), StorageError>

Insert a block into storage without canonizing/committing it.

pub fn commit(&self, block: &Block<T>) -> Result<(), StorageError>

Commit/canonize a particular block.

pub fn insert_and_commit(&self, block: &Block<T>) -> Result<(), StorageError>

Insert a block into the storage and commit as part of the longest chain.

pub fn is_canon(&self, block_hash: &BlockHeaderHash) -> bool

Returns true if the block exists in the canon chain.

pub fn is_previous_block_canon(&self, block_header: &BlockHeader) -> bool

Returns true if the block corresponding to this block’s previous_block_hash is in the canon chain.

pub fn revert_for_fork(
    &self,
    side_chain_path: &SideChainPath
) -> Result<(), StorageError>

Revert the chain to the state before the fork.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn get_memory_pool(&self) -> Result<Option<Vec<u8>>, StorageError>

Get the stored memory pool transactions.

pub fn store_to_memory_pool(
    &self,
    transactions_serialized: Vec<u8>
) -> Result<(), StorageError>

Store the memory pool transactions.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn get_record_commitments(
    &self,
    limit: Option<usize>
) -> Result<Vec<Vec<u8>>, StorageError>

Get all stored record commitments of the node

pub fn get_record<R: RecordScheme>(
    &self,
    record_commitment: &[u8]
) -> Result<Option<R>, StorageError>

Get a transaction bytes given the transaction id.

pub fn store_record<R: RecordScheme>(
    &self,
    record: &R
) -> Result<(), StorageError>

Get a transaction bytes given the transaction id.

pub fn store_records<R: RecordScheme>(
    &self,
    records: &[R]
) -> Result<(), StorageError>

Get a transaction bytes given the transaction id.

pub fn delete_record<R: RecordScheme>(
    &self,
    record: R
) -> Result<(), StorageError>

Removes a record from storage.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn get_transaction_location(
    &self,
    transaction_id: &[u8]
) -> Result<Option<TransactionLocation>, StorageError>

Returns a transaction location given the transaction ID if it exists. Returns None otherwise.

pub fn get_transaction(
    &self,
    transaction_id: &[u8]
) -> Result<Option<T>, StorageError>

Returns a transaction given the transaction ID if it exists. Returns None otherwise.

pub fn get_transaction_bytes(
    &self,
    transaction_id: &[u8]
) -> Result<Vec<u8>, StorageError>

Returns a transaction in bytes given a transaction ID.

pub fn transaction_conflicts(&self, transaction: &T) -> bool

Returns true if the transaction has internal parameters that already exist in the ledger.

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> Ledger<T, P, S>

pub fn validate(&self, limit: Option<usize>, fix_mode: FixMode) -> bool

Validates the storage of the canon blocks, their child-parent relationships, and their transactions; starts at the current block height and goes down until the genesis block, making sure that the block-related data stored in the database is coherent. The optional limit restricts the number of blocks to check, as it is likely that any issues are applicable only to the last few blocks. The fix argument determines whether the validation process should also attempt to fix the issues it encounters.

Trait Implementations

impl<T: TransactionScheme, P: LoadableMerkleParameters, S: Storage> LedgerScheme for Ledger<T, P, S>

fn new(
    path: Option<&Path>,
    parameters: Arc<Self::MerkleParameters>,
    genesis_block: Self::Block
) -> Result<Self>

Instantiates a new ledger with a genesis block.

fn len(&self) -> usize

Returns the number of blocks including the genesis block

fn parameters(&self) -> &Arc<Self::MerkleParameters>

Return the parameters used to construct the ledger Merkle tree.

fn digest(&self) -> Option<Self::MerkleTreeDigest>

Return a digest of the latest ledger Merkle tree.

fn validate_digest(&self, digest: &Self::MerkleTreeDigest) -> bool

Check that st_{ts} is a valid digest for some (past) ledger state.

fn contains_cm(&self, cm: &Self::Commitment) -> bool

Returns true if the given commitment exists in the ledger.

fn contains_sn(&self, sn: &Self::SerialNumber) -> bool

Returns true if the given serial number exists in the ledger.

fn contains_memo(
    &self,
    memo: &<Self::Transaction as TransactionScheme>::Memorandum
) -> bool

Returns true if the given memo exists in the ledger.

fn prove_cm(&self, cm: &Self::Commitment) -> Result<Self::MerklePath>

Returns the Merkle path to the latest ledger digest for a given commitment, if it exists in the ledger.

fn verify_cm(
    _parameters: &Arc<Self::MerkleParameters>,
    digest: &Self::MerkleTreeDigest,
    cm: &Self::Commitment,
    witness: &Self::MerklePath
) -> bool

Returns true if the given Merkle path is a valid witness for the given ledger digest and commitment.

type Block = Block<Self::Transaction>

type Commitment = T::Commitment

type MerkleParameters = P

type MerklePath = MerklePath<Self::MerkleParameters>

type MerkleTreeDigest = MerkleTreeDigest<Self::MerkleParameters>

type SerialNumber = T::SerialNumber

type Transaction = T