Struct solana_ledger::blockstore::Blockstore

pub struct Blockstore {
    pub new_shreds_signals: Vec<SyncSender<bool>>,
    pub completed_slots_senders: Vec<SyncSender<Vec<Slot>>>,
    pub lowest_cleanup_slot: Arc<RwLock<u64>>,
    // some fields omitted
}

Fields

new_shreds_signals: Vec<SyncSender<bool>>

completed_slots_senders: Vec<SyncSender<Vec<Slot>>>

lowest_cleanup_slot: Arc<RwLock<u64>>

Implementations

impl Blockstore

pub fn purge_slots(&self, from_slot: Slot, to_slot: Slot, purge_type: PurgeType)

Silently deletes all blockstore column families in the range [from_slot,to_slot] Dangerous; Use with care: Does not check for integrity and does not update slot metas that refer to deleted slots Modifies multiple column families simultaneously

pub fn purge_and_compact_slots(&self, from_slot: Slot, to_slot: Slot)

pub fn purge_from_next_slots(&self, from_slot: Slot, to_slot: Slot)

Ensures that the SlotMeta::next_slots vector for all slots contain no references in the [from_slot,to_slot] range

Dangerous; Use with care

pub fn compact_storage(&self, from_slot: Slot, to_slot: Slot) -> Result<bool>

impl Blockstore

pub fn db(self) -> Arc<Database>

pub fn ledger_path(&self) -> &Path

pub fn open(ledger_path: &Path) -> Result<Blockstore>

Opens a Ledger in directory, provides “infinite” window of shreds

pub fn open_with_access_type(
    ledger_path: &Path,
    access_type: AccessType,
    recovery_mode: Option<BlockstoreRecoveryMode>,
    enforce_ulimit_nofile: bool
) -> Result<Blockstore>

pub fn open_with_signal(
    ledger_path: &Path,
    recovery_mode: Option<BlockstoreRecoveryMode>,
    enforce_ulimit_nofile: bool
) -> Result<BlockstoreSignals>

pub fn add_tree(
    &self,
    forks: Tree<Slot>,
    is_orphan: bool,
    is_slot_complete: bool,
    num_ticks: u64,
    starting_hash: Hash
)

pub fn set_no_compaction(&mut self, no_compaction: bool)

pub fn destroy(ledger_path: &Path) -> Result<()>

pub fn meta(&self, slot: Slot) -> Result<Option<SlotMeta>>

pub fn is_full(&self, slot: Slot) -> bool

pub fn erasure_meta(
    &self,
    slot: Slot,
    set_index: u64
) -> Result<Option<ErasureMeta>>

pub fn orphan(&self, slot: Slot) -> Result<Option<bool>>

pub fn max_root(&self) -> Slot

pub fn slot_meta_iterator(
    &self,
    slot: Slot
) -> Result<impl Iterator<Item = (Slot, SlotMeta)> + '_>

pub fn live_slots_iterator(
    &self,
    root: Slot
) -> impl Iterator<Item = (Slot, SlotMeta)> + '_

pub fn slot_data_iterator(
    &self,
    slot: Slot,
    index: u64
) -> Result<impl Iterator<Item = ((u64, u64), Box<[u8]>)> + '_>

pub fn slot_coding_iterator(
    &self,
    slot: Slot,
    index: u64
) -> Result<impl Iterator<Item = ((u64, u64), Box<[u8]>)> + '_>

pub fn rooted_slot_iterator(
    &self,
    slot: Slot
) -> Result<impl Iterator<Item = u64> + '_>

pub fn insert_shreds_handle_duplicate<F>(
    &self,
    shreds: Vec<Shred>,
    leader_schedule: Option<&Arc<LeaderScheduleCache>>,
    is_trusted: bool,
    handle_duplicate: &F,
    metrics: &mut BlockstoreInsertionMetrics
) -> Result<(Vec<CompletedDataSetInfo>, Vec<usize>)> where
    F: Fn(Shred), 

pub fn clear_unconfirmed_slot(&self, slot: Slot)

pub fn insert_shreds(
    &self,
    shreds: Vec<Shred>,
    leader_schedule: Option<&Arc<LeaderScheduleCache>>,
    is_trusted: bool
) -> Result<(Vec<CompletedDataSetInfo>, Vec<usize>)>

pub fn get_data_shred(&self, slot: Slot, index: u64) -> Result<Option<Vec<u8>>>

pub fn get_data_shreds_for_slot(
    &self,
    slot: Slot,
    start_index: u64
) -> ShredResult<Vec<Shred>>

pub fn get_data_shreds(
    &self,
    slot: Slot,
    from_index: u64,
    to_index: u64,
    buffer: &mut [u8]
) -> Result<(u64, usize)>

pub fn get_coding_shred(
    &self,
    slot: Slot,
    index: u64
) -> Result<Option<Vec<u8>>>

pub fn get_coding_shreds_for_slot(
    &self,
    slot: Slot,
    start_index: u64
) -> ShredResult<Vec<Shred>>

pub fn write_entries(
    &self,
    start_slot: Slot,
    num_ticks_in_start_slot: u64,
    start_index: u32,
    ticks_per_slot: u64,
    parent: Option<u64>,
    is_full_slot: bool,
    keypair: &Arc<Keypair>,
    entries: Vec<Entry>,
    version: u16
) -> Result<usize>

pub fn get_index(&self, slot: Slot) -> Result<Option<Index>>

pub fn put_meta_bytes(&self, slot: Slot, bytes: &[u8]) -> Result<()>

Manually update the meta for a slot. Can interfere with automatic meta update and potentially break chaining. Dangerous. Use with care.

pub fn find_missing_data_indexes(
    &self,
    slot: Slot,
    first_timestamp: u64,
    start_index: u64,
    end_index: u64,
    max_missing: usize
) -> Vec<u64>

pub fn get_block_time(&self, slot: Slot) -> Result<Option<UnixTimestamp>>

pub fn cache_block_time(
    &self,
    slot: Slot,
    timestamp: UnixTimestamp
) -> Result<()>

pub fn get_first_available_block(&self) -> Result<Slot>

pub fn evm_blocks_iterator(
    &self,
    block_num: BlockNum
) -> Result<impl Iterator<Item = ((BlockNum, Option<Slot>), BlockHeader)> + '_>

Return iterator over evm blocks. There can be more than one block with same block number and different slot numbers.

pub fn get_first_available_evm_block(&self) -> Result<BlockNum>

pub fn get_last_available_evm_block(&self) -> Result<Option<BlockNum>>

pub fn get_confirmed_block_hash(&self, slot: Slot) -> Result<String>

pub fn get_confirmed_block(
    &self,
    slot: Slot,
    require_previous_blockhash: bool
) -> Result<ConfirmedBlock>

pub fn get_evm_block(&self, block_number: BlockNum) -> Result<(Block, bool)>

Returns block, and flag if that block was rooted (confirmed)

pub fn read_transaction_status(
    &self,
    index: (Signature, Slot)
) -> Result<Option<TransactionStatusMeta>>

pub fn write_transaction_status(
    &self,
    slot: Slot,
    signature: Signature,
    writable_keys: Vec<&Pubkey>,
    readonly_keys: Vec<&Pubkey>,
    status: TransactionStatusMeta
) -> Result<()>

pub fn get_transaction_status(
    &self,
    signature: Signature
) -> Result<Option<(Slot, TransactionStatusMeta)>>

Returns a transaction status if it was processed in a root

pub fn get_confirmed_transaction(
    &self,
    signature: Signature
) -> Result<Option<ConfirmedTransaction>>

Returns a complete transaction if it was processed in a root

pub fn get_confirmed_signatures_for_address(
    &self,
    pubkey: Pubkey,
    start_slot: Slot,
    end_slot: Slot
) -> Result<Vec<Signature>>

pub fn get_confirmed_signatures_for_address2(
    &self,
    address: Pubkey,
    highest_confirmed_root: Slot,
    before: Option<Signature>,
    until: Option<Signature>,
    limit: usize
) -> Result<Vec<ConfirmedTransactionStatusWithSignature>>

pub fn read_rewards(&self, index: Slot) -> Result<Option<Rewards>>

pub fn write_rewards(&self, index: Slot, rewards: Rewards) -> Result<()>

pub fn get_recent_perf_samples(
    &self,
    num: usize
) -> Result<Vec<(Slot, PerfSample)>>

pub fn write_perf_sample(
    &self,
    index: Slot,
    perf_sample: &PerfSample
) -> Result<()>

pub fn write_evm_block_header(&self, block: &BlockHeader) -> Result<()>

pub fn read_evm_block_headers(
    &self,
    block_index: BlockNum
) -> Result<Vec<BlockHeader>>

Returns iterator over evm blocks. If more than one evm block have been found on same block_num, this function return multiple items.

pub fn write_evm_block_id_by_hash(
    &self,
    slot: Slot,
    hash: H256,
    id: BlockNum
) -> Result<()>

pub fn read_evm_block_id_by_hash(&self, hash: H256) -> Result<Option<BlockNum>>

pub fn read_evm_transaction(
    &self,
    index: (H256, BlockNum, Option<Slot>)
) -> Result<Option<TransactionReceipt>>

Try to search for evm transaction in next indexes:

1. When primary index = 0 and slot is Some,
2. When primary index = 1 and slot is Some,
3. When primary index = 0 and slot is None,
4. When primary index = 1 and slot is None

pub fn filter_logs(&self, filter: LogFilter) -> Result<Vec<LogWithLocation>>

pub fn find_evm_transaction(
    &self,
    hash: H256
) -> Result<Option<TransactionReceipt>>

pub fn write_evm_transaction(
    &self,
    block_num: BlockNum,
    slot_index: Slot,
    hash: H256,
    status: TransactionReceipt
) -> Result<()>

pub fn get_slot_entries(
    &self,
    slot: Slot,
    shred_start_index: u64
) -> Result<Vec<Entry>>

Returns the entry vector for the slot starting with shred_start_index

pub fn get_slot_entries_with_shred_info(
    &self,
    slot: Slot,
    start_index: u64,
    allow_dead_slots: bool
) -> Result<(Vec<Entry>, u64, bool)>

Returns the entry vector for the slot starting with shred_start_index, the number of shreds that comprise the entry vector, and whether the slot is full (consumed all shreds).

pub fn get_entries_in_data_block(
    &self,
    slot: Slot,
    start_index: u32,
    end_index: u32,
    slot_meta: Option<&SlotMeta>
) -> Result<Vec<Entry>>

pub fn get_slots_since(&self, slots: &[u64]) -> Result<HashMap<u64, Vec<u64>>>

pub fn is_root(&self, slot: Slot) -> bool

pub fn is_skipped(&self, slot: Slot) -> bool

Returns true if a slot is between the rooted slot bounds of the ledger, but has not itself been rooted. This is either because the slot was skipped, or due to a gap in ledger data, as when booting from a newer snapshot.

pub fn set_roots(&self, rooted_slots: &[u64]) -> Result<()>

pub fn is_dead(&self, slot: Slot) -> bool

pub fn set_dead_slot(&self, slot: Slot) -> Result<()>

pub fn store_duplicate_if_not_existing(
    &self,
    slot: Slot,
    shred1: Vec<u8>,
    shred2: Vec<u8>
) -> Result<()>

pub fn store_duplicate_slot(
    &self,
    slot: Slot,
    shred1: Vec<u8>,
    shred2: Vec<u8>
) -> Result<()>

pub fn get_duplicate_slot(&self, slot: u64) -> Option<DuplicateSlotProof>

pub fn is_shred_duplicate(
    &self,
    slot: u64,
    index: u32,
    new_shred: &[u8],
    is_data: bool
) -> Option<Vec<u8>>

pub fn has_duplicate_shreds_in_slot(&self, slot: Slot) -> bool

pub fn orphans_iterator(
    &self,
    slot: Slot
) -> Result<impl Iterator<Item = u64> + '_>

pub fn dead_slots_iterator(
    &self,
    slot: Slot
) -> Result<impl Iterator<Item = Slot> + '_>

pub fn last_root(&self) -> Slot

pub fn lowest_slot(&self) -> Slot

pub fn storage_size(&self) -> Result<u64>

pub fn is_primary_access(&self) -> bool