cryptonote::BlockchainLMDB Class Reference

#include <db_lmdb.h>

Inheritance diagram for cryptonote::BlockchainLMDB:

Collaboration diagram for cryptonote::BlockchainLMDB:

Public Member Functions
	BlockchainLMDB (bool batch_transactions=true)
	~BlockchainLMDB ()
virtual void	open (const std::string &filename, const int mdb_flags=0)
	open a db, or create it if necessary.
virtual void	close ()
	close the BlockchainDB
virtual void	sync ()
	sync the BlockchainDB with disk
virtual void	safesyncmode (const bool onoff)
	toggle safe syncs for the DB
virtual void	reset ()
	Remove everything from the BlockchainDB.
virtual std::vector< std::string >	get_filenames () const
	get all files used by the BlockchainDB (if any)
virtual bool	remove_data_file (const std::string &folder) const
	remove file(s) storing the database
virtual std::string	get_db_name () const
	gets the name of the folder the BlockchainDB's file(s) should be in
virtual bool	lock ()
	acquires the BlockchainDB lock
virtual void	unlock ()
	This function releases the BlockchainDB lock.
virtual bool	block_exists (const crypto::hash &h, uint64_t *height=NULL) const
	checks if a block exists
virtual uint64_t	get_block_height (const crypto::hash &h) const
	gets the height of the block with a given hash
virtual block_header	get_block_header (const crypto::hash &h) const
	fetch a block header
virtual cryptonote::blobdata	get_block_blob (const crypto::hash &h) const
	fetches the block with the given hash
virtual cryptonote::blobdata	get_block_blob_from_height (const uint64_t &height) const
	fetch a block blob by height
virtual std::vector< uint64_t >	get_block_cumulative_rct_outputs (const std::vector< uint64_t > &heights) const
	fetch a block's cumulative number of rct outputs
virtual uint64_t	get_block_timestamp (const uint64_t &height) const
	fetch a block's timestamp
virtual uint64_t	get_top_block_timestamp () const
	fetch the top block's timestamp
virtual size_t	get_block_weight (const uint64_t &height) const
	fetch a block's weight
virtual std::vector< uint64_t >	get_block_weights (uint64_t start_height, size_t count) const
	fetch the last N blocks' weights
virtual void	set_block_cumulative_difficulty (uint64_t height, difficulty_type diff)
	sets a block's cumulative difficulty
virtual difficulty_type	get_block_cumulative_difficulty (const uint64_t &height) const
	fetch a block's cumulative difficulty
virtual difficulty_type	get_block_difficulty (const uint64_t &height) const
	fetch a block's difficulty
virtual uint64_t	get_block_already_generated_coins (const uint64_t &height) const
	fetch a block's already generated coins
virtual uint64_t	get_block_long_term_weight (const uint64_t &height) const
	fetch a block's long term weight
virtual std::vector< uint64_t >	get_long_term_block_weights (uint64_t start_height, size_t count) const
	fetch the last N blocks' long term weights
virtual crypto::hash	get_block_hash_from_height (const uint64_t &height) const
	fetch a block's hash
virtual std::vector< block >	get_blocks_range (const uint64_t &h1, const uint64_t &h2) const
	fetch a list of blocks
virtual std::vector< crypto::hash >	get_hashes_range (const uint64_t &h1, const uint64_t &h2) const
	fetch a list of block hashes
virtual crypto::hash	top_block_hash (uint64_t *block_height=NULL) const
	fetch the top block's hash
virtual block	get_top_block () const
	fetch the top block
virtual uint64_t	height () const
	fetch the current blockchain height
virtual bool	tx_exists (const crypto::hash &h) const
	check if a transaction with a given hash exists
virtual bool	tx_exists (const crypto::hash &h, uint64_t &tx_index) const
virtual uint64_t	get_tx_unlock_time (const crypto::hash &h) const
	fetch a transaction's unlock time/height
virtual bool	get_tx_blob (const crypto::hash &h, cryptonote::blobdata &tx) const
	fetches the transaction blob with the given hash
virtual bool	get_pruned_tx_blob (const crypto::hash &h, cryptonote::blobdata &tx) const
	fetches the pruned transaction blob with the given hash
virtual bool	get_prunable_tx_blob (const crypto::hash &h, cryptonote::blobdata &tx) const
	fetches the prunable transaction blob with the given hash
virtual bool	get_prunable_tx_hash (const crypto::hash &tx_hash, crypto::hash &prunable_hash) const
	fetches the prunable transaction hash
virtual uint64_t	get_tx_count () const
	fetches the total number of transactions ever
virtual std::vector< transaction >	get_tx_list (const std::vector< crypto::hash > &hlist) const
	fetches a list of transactions based on their hashes
virtual uint64_t	get_tx_block_height (const crypto::hash &h) const
	fetches the height of a transaction's block
virtual uint64_t	get_num_outputs (const uint64_t &amount) const
	fetches the number of outputs of a given amount
virtual output_data_t	get_output_key (const uint64_t &amount, const uint64_t &index, bool include_commitmemt) const
	get some of an output's data
virtual void	get_output_key (const epee::span< const uint64_t > &amounts, const std::vector< uint64_t > &offsets, std::vector< output_data_t > &outputs, bool allow_partial=false) const
	gets outputs' data
virtual tx_out_index	get_output_tx_and_index_from_global (const uint64_t &index) const
	gets an output's tx hash and index
virtual void	get_output_tx_and_index_from_global (const std::vector< uint64_t > &global_indices, std::vector< tx_out_index > &tx_out_indices) const
virtual tx_out_index	get_output_tx_and_index (const uint64_t &amount, const uint64_t &index) const
	gets an output's tx hash and index
virtual void	get_output_tx_and_index (const uint64_t &amount, const std::vector< uint64_t > &offsets, std::vector< tx_out_index > &indices) const
	gets some outputs' tx hashes and indices
virtual std::vector< std::vector< uint64_t > >	get_tx_amount_output_indices (const uint64_t tx_id, size_t n_txes) const
	gets output indices (amount-specific) for a transaction's outputs
virtual bool	has_key_image (const crypto::key_image &img) const
	check if a key image is stored as spent
virtual void	add_txpool_tx (const crypto::hash &txid, const cryptonote::blobdata &blob, const txpool_tx_meta_t &meta)
	add a txpool transaction
virtual void	update_txpool_tx (const crypto::hash &txid, const txpool_tx_meta_t &meta)
	update a txpool transaction's metadata
virtual uint64_t	get_txpool_tx_count (bool include_unrelayed_txes=true) const
	get the number of transactions in the txpool
virtual bool	txpool_has_tx (const crypto::hash &txid) const
	check whether a txid is in the txpool
virtual void	remove_txpool_tx (const crypto::hash &txid)
	remove a txpool transaction
virtual bool	get_txpool_tx_meta (const crypto::hash &txid, txpool_tx_meta_t &meta) const
	get a txpool transaction's metadata
virtual bool	get_txpool_tx_blob (const crypto::hash &txid, cryptonote::blobdata &bd) const
	get a txpool transaction's blob
virtual cryptonote::blobdata	get_txpool_tx_blob (const crypto::hash &txid) const
	get a txpool transaction's blob
virtual uint32_t	get_blockchain_pruning_seed () const
	get the blockchain pruning seed
virtual bool	prune_blockchain (uint32_t pruning_seed=0)
	prunes the blockchain
virtual bool	update_pruning ()
	prunes recent blockchain changes as needed, iff pruning is enabled
virtual bool	check_pruning ()
	checks pruning was done correctly, iff enabled
virtual bool	for_all_txpool_txes (std::function< bool(const crypto::hash &, const txpool_tx_meta_t &, const cryptonote::blobdata *)> f, bool include_blob=false, bool include_unrelayed_txes=true) const
	runs a function over all txpool transactions
virtual bool	for_all_key_images (std::function< bool(const crypto::key_image &)>) const
	runs a function over all key images stored
virtual bool	for_blocks_range (const uint64_t &h1, const uint64_t &h2, std::function< bool(uint64_t, const crypto::hash &, const cryptonote::block &)>) const
	runs a function over a range of blocks
virtual bool	for_all_transactions (std::function< bool(const crypto::hash &, const cryptonote::transaction &)>, bool pruned) const
	runs a function over all transactions stored
virtual bool	for_all_outputs (std::function< bool(uint64_t amount, const crypto::hash &tx_hash, uint64_t height, size_t tx_idx)> f) const
	runs a function over all outputs stored
virtual bool	for_all_outputs (uint64_t amount, const std::function< bool(uint64_t height)> &f) const
virtual uint64_t	add_block (const std::pair< block, blobdata > &blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type &cumulative_difficulty, const uint64_t &coins_generated, const std::vector< std::pair< transaction, blobdata > > &txs)
	handles the addition of a new block to BlockchainDB
virtual void	set_batch_transactions (bool batch_transactions)
	sets whether or not to batch transactions
virtual bool	batch_start (uint64_t batch_num_blocks=0, uint64_t batch_bytes=0)
	tells the BlockchainDB to start a new "batch" of blocks
virtual void	batch_commit ()
virtual void	batch_stop ()
	ends a batch transaction
virtual void	batch_abort ()
	aborts a batch transaction
virtual void	block_wtxn_start ()
virtual void	block_wtxn_stop ()
virtual void	block_wtxn_abort ()
virtual bool	block_rtxn_start () const
virtual void	block_rtxn_stop () const
virtual void	block_rtxn_abort () const
bool	block_rtxn_start (MDB_txn **mtxn, mdb_txn_cursors **mcur) const
virtual void	pop_block (block &blk, std::vector< transaction > &txs)
	pops the top block off the blockchain
virtual bool	can_thread_bulk_indices () const
std::map< uint64_t, std::tuple< uint64_t, uint64_t, uint64_t > >	get_output_histogram (const std::vector< uint64_t > &amounts, bool unlocked, uint64_t recent_cutoff, uint64_t min_count) const
	return a histogram of outputs on the blockchain
bool	get_output_distribution (uint64_t amount, uint64_t from_height, uint64_t to_height, std::vector< uint64_t > &distribution, uint64_t &base) const
virtual std::vector< address_outputs >	get_addr_output_all (const crypto::public_key &combined_key)
virtual std::vector< address_outputs >	get_addr_output_batch (const crypto::public_key &combined_key, uint64_t start_db_index=0, uint64_t batch_size=100, bool desc=false)
virtual std::vector< address_txs >	get_addr_tx_all (const crypto::public_key &combined_key)
virtual std::vector< address_txs >	get_addr_tx_batch (const crypto::public_key &combined_key, uint64_t start_db_index=0, uint64_t batch_size=100, bool desc=false)
virtual uint64_t	get_balance (const crypto::public_key &combined_key)
virtual tx_input_t	get_tx_input (const crypto::hash tx_hash, const uint32_t relative_out_index)
Public Member Functions inherited from cryptonote::BlockchainDB
	BlockchainDB ()
	An empty constructor.
virtual	~BlockchainDB ()
	An empty destructor.
void	reset_stats ()
	reset profiling stats
void	show_stats ()
	show profiling stats
bool	is_open () const
	Gets the current open/ready state of the BlockchainDB.
virtual void	set_hard_fork (HardFork *hf)
virtual block	get_block (const crypto::hash &h) const
	fetches the block with the given hash
virtual block	get_block_from_height (const uint64_t &height) const
	fetch a block by height
virtual transaction	get_tx (const crypto::hash &h) const
	fetches the transaction with the given hash
virtual transaction	get_pruned_tx (const crypto::hash &h) const
	fetches the transaction base with the given hash
virtual bool	get_tx (const crypto::hash &h, transaction &tx) const
	fetches the transaction with the given hash
virtual bool	get_pruned_tx (const crypto::hash &h, transaction &tx) const
	fetches the transaction base with the given hash
virtual uint64_t	get_indexing_base () const
	return index of the first element (should be hidden, but isn't)
void	set_auto_remove_logs (bool auto_remove)
	set whether or not to automatically remove logs

Static Public Member Functions
static int	compare_uint64 (const MDB_val *a, const MDB_val *b)
static int	compare_hash32 (const MDB_val *a, const MDB_val *b)
static int	compare_string (const MDB_val *a, const MDB_val *b)
static int	compare_data (const MDB_val *a, const MDB_val *b)
static int	compare_publickey (const MDB_val *a, const MDB_val *b)
Static Public Member Functions inherited from cryptonote::BlockchainDB
static void	init_options (boost::program_options::options_description &desc)
	init command line options

Additional Inherited Members
Public Attributes inherited from cryptonote::BlockchainDB
bool	m_open
	Whether or not the BlockchainDB is open/ready for use.
epee::critical_section	m_synchronization_lock
	A lock, currently for when BlockchainLMDB needs to resize the backing db file.
Protected Member Functions inherited from cryptonote::BlockchainDB
void	add_transaction (const crypto::hash &blk_hash, const std::pair< transaction, blobdata > &tx, const crypto::hash *tx_hash_ptr=NULL, const crypto::hash *tx_prunable_hash_ptr=NULL)
	helper function for add_transactions, to add each individual transaction
Protected Attributes inherited from cryptonote::BlockchainDB
uint64_t	time_tx_exists = 0
	a performance metric
uint64_t	time_commit1 = 0
	a performance metric
bool	m_auto_remove_logs = true
	whether or not to automatically remove old logs
HardFork *	m_hardfork

Detailed Description

Definition at line 194 of file db_lmdb.h.

Constructor & Destructor Documentation

BlockchainLMDB()

cryptonote::BlockchainLMDB::BlockchainLMDB

(

bool

batch_transactions = true

)

Definition at line 1338 of file db_lmdb.cpp.

                                                     : BlockchainDB()
{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  // initialize folder to something "safe" just in case
  // someone accidentally misuses this class...
  m_folder = "thishsouldnotexistbecauseitisgibberish";
 
  m_batch_transactions = batch_transactions;
  m_write_txn = nullptr;
  m_write_batch_txn = nullptr;
  m_batch_active = false;
  m_cum_size = 0;
  m_cum_count = 0;
 
  // reset may also need changing when initialize things here
 
  m_hardfork = nullptr;
}

Here is the call graph for this function:

~BlockchainLMDB()

cryptonote::BlockchainLMDB::~BlockchainLMDB

(

)

Definition at line 1324 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
 
  // batch transaction shouldn't be active at this point. If it is, consider it aborted.
  if (m_batch_active)
  {
    try { batch_abort(); }
    catch (...) { /* ignore */ }
  }
  if (m_open)
    close();
}

Here is the call graph for this function:

Member Function Documentation

add_block()

uint64_t cryptonote::BlockchainLMDB::add_block ( const std::pair< block, blobdata > & blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type & cumulative_difficulty, const uint64_t & coins_generated, const std::vector< std::pair< transaction, blobdata > > & txs )

virtual

handles the addition of a new block to BlockchainDB

This function organizes block addition and calls various functions as necessary.

NOTE: subclass implementations of this (or the functions it calls) need to handle undoing any partially-added blocks in the event of a failure.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Parameters

blk	the block to be added
block_weight	the size of the block (transactions and all)
long_term_block_weight	the long term weight of the block (transactions and all)
cumulative_difficulty	the accumulated difficulty after this block
coins_generated	the number of coins generated total after this block
txs	the transactions in the block

Returns

the height of the chain post-addition

Reimplemented from cryptonote::BlockchainDB.

Definition at line 4484 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  uint64_t m_height = height();
 
  if (m_height % 1024 == 0)
  {
    // for batch mode, DB resize check is done at start of batch transaction
    if (! m_batch_active && need_resize())
    {
      LOG_PRINT_L0("LMDB memory map needs to be resized, doing that now.");
      do_resize();
    }
  }
 
  try
  {
    BlockchainDB::add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, txs);
  }
  catch (const DB_ERROR_TXN_START& e)
  {
    throw;
  }
 
  return ++m_height;
}

Here is the call graph for this function:

add_txpool_tx()

void cryptonote::BlockchainLMDB::add_txpool_tx ( const crypto::hash & txid, const cryptonote::blobdata & blob, const txpool_tx_meta_t & details )

virtual

add a txpool transaction

Parameters

details

the details of the transaction to add

Implements cryptonote::BlockchainDB.

Definition at line 2415 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  mdb_txn_cursors *m_cursors = &m_wcursors;
 
  CURSOR(txpool_meta)
  CURSOR(txpool_blob)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  MDB_val v = {sizeof(meta), (void *)&meta};
  if (auto result = mdb_cursor_put(m_cur_txpool_meta, &k, &v, MDB_NODUPDATA)) {
    if (result == MDB_KEYEXIST)
      throw1(DB_ERROR("Attempting to add txpool tx metadata that's already in the db"));
    else
      throw1(DB_ERROR(lmdb_error("Error adding txpool tx metadata to db transaction: ", result).c_str()));
  }
  MDB_val_sized(blob_val, blob);
  if (auto result = mdb_cursor_put(m_cur_txpool_blob, &k, &blob_val, MDB_NODUPDATA)) {
    if (result == MDB_KEYEXIST)
      throw1(DB_ERROR("Attempting to add txpool tx blob that's already in the db"));
    else
      throw1(DB_ERROR(lmdb_error("Error adding txpool tx blob to db transaction: ", result).c_str()));
  }
}

Here is the call graph for this function:

batch_abort()

void cryptonote::BlockchainLMDB::batch_abort ( )

virtual

aborts a batch transaction

If the subclass implements batching, this function should abort the batch it is currently on.

If no batch is in-progress, this function should throw a DB_ERROR. This exception may change in the future if it is deemed necessary to have a more granular exception type for this scenario.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 4320 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (! m_batch_transactions)
    throw0(DB_ERROR("batch transactions not enabled"));
  if (! m_batch_active)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_write_batch_txn == nullptr)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_writer != boost::this_thread::get_id())
    throw1(DB_ERROR("batch transaction owned by other thread"));
  check_open();
  // for destruction of batch transaction
  m_write_txn = nullptr;
  // explicitly call in case mdb_env_close() (BlockchainLMDB::close()) called before BlockchainLMDB destructor called.
  m_write_batch_txn->abort();
  delete m_write_batch_txn;
  m_write_batch_txn = nullptr;
  m_batch_active = false;
  memset(&m_wcursors, 0, sizeof(m_wcursors));
  LOG_PRINT_L3("batch transaction: aborted");
}

Here is the caller graph for this function:

batch_commit()

void cryptonote::BlockchainLMDB::batch_commit ( )

virtual

Definition at line 4254 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (! m_batch_transactions)
    throw0(DB_ERROR("batch transactions not enabled"));
  if (! m_batch_active)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_write_batch_txn == nullptr)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_writer != boost::this_thread::get_id())
    throw1(DB_ERROR("batch transaction owned by other thread"));
 
  check_open();
 
  LOG_PRINT_L3("batch transaction: committing...");
  TIME_MEASURE_START(time1);
  m_write_txn->commit();
  TIME_MEASURE_FINISH(time1);
  time_commit1 += time1;
  LOG_PRINT_L3("batch transaction: committed");
 
  m_write_txn = nullptr;
  delete m_write_batch_txn;
  m_write_batch_txn = nullptr;
  memset(&m_wcursors, 0, sizeof(m_wcursors));
}

batch_start()

bool cryptonote::BlockchainLMDB::batch_start ( uint64_t batch_num_blocks = 0, uint64_t batch_bytes = 0 )

virtual

tells the BlockchainDB to start a new "batch" of blocks

If the subclass implements a batching method of caching blocks in RAM to be added to a backing store in groups, it should start a batch which will end either when <batch_num_blocks> has been added or batch_stop() has been called. In either case, it should end the batch and write to its backing store.

If a batch is already in-progress, this function must return false. If a batch was started by this call, it must return true.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Parameters

batch_num_blocks

number of blocks to batch together

Returns

true if we started the batch, false if already started

Implements cryptonote::BlockchainDB.

Definition at line 4211 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (! m_batch_transactions)
    throw0(DB_ERROR("batch transactions not enabled"));
  if (m_batch_active)
    return false;
  if (m_write_batch_txn != nullptr)
    return false;
  if (m_write_txn)
    throw0(DB_ERROR("batch transaction attempted, but m_write_txn already in use"));
  check_open();
 
  m_writer = boost::this_thread::get_id();
  check_and_resize_for_batch(batch_num_blocks, batch_bytes);
 
  m_write_batch_txn = new mdb_txn_safe();
 
  // NOTE: need to make sure it's destroyed properly when done
  if (auto mdb_res = lmdb_txn_begin(m_env, NULL, 0, *m_write_batch_txn))
  {
    delete m_write_batch_txn;
    m_write_batch_txn = nullptr;
    throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", mdb_res).c_str()));
  }
  // indicates this transaction is for batch transactions, but not whether it's
  // active
  m_write_batch_txn->m_batch_txn = true;
  m_write_txn = m_write_batch_txn;
 
  m_batch_active = true;
  memset(&m_wcursors, 0, sizeof(m_wcursors));
  if (m_tinfo.get())
  {
    if (m_tinfo->m_ti_rflags.m_rf_txn)
      mdb_txn_reset(m_tinfo->m_ti_rtxn);
    memset(&m_tinfo->m_ti_rflags, 0, sizeof(m_tinfo->m_ti_rflags));
  }
 
  LOG_PRINT_L3("batch transaction: begin");
  return true;
}

Here is the call graph for this function:

batch_stop()

void cryptonote::BlockchainLMDB::batch_stop ( )

virtual

ends a batch transaction

If the subclass implements batching, this function should store the batch it is currently on and mark it finished.

If no batch is in-progress, this function should throw a DB_ERROR. This exception may change in the future if it is deemed necessary to have a more granular exception type for this scenario.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 4291 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (! m_batch_transactions)
    throw0(DB_ERROR("batch transactions not enabled"));
  if (! m_batch_active)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_write_batch_txn == nullptr)
    throw1(DB_ERROR("batch transaction not in progress"));
  if (m_writer != boost::this_thread::get_id())
    throw1(DB_ERROR("batch transaction owned by other thread"));
  check_open();
  LOG_PRINT_L3("batch transaction: committing...");
  TIME_MEASURE_START(time1);
  try
  {
    m_write_txn->commit();
    TIME_MEASURE_FINISH(time1);
    time_commit1 += time1;
    cleanup_batch();
  }
  catch (const std::exception &e)
  {
    cleanup_batch();
    throw;
  }
  LOG_PRINT_L3("batch transaction: end");
}

block_exists()

bool cryptonote::BlockchainLMDB::block_exists ( const crypto::hash & h, uint64_t * height = NULL ) const

virtual

checks if a block exists

Parameters

h	the hash of the requested block
height	if non NULL, returns the block's height if found

Returns

true of the block exists, otherwise false

Implements cryptonote::BlockchainDB.

Definition at line 2993 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_heights);
 
  bool ret = false;
  MDB_val_set(key, h);
  auto get_result = mdb_cursor_get(m_cur_block_heights, (MDB_val *)&zerokval, &key, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    LOG_PRINT_L3("Block with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
  }
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch block index from hash", get_result).c_str()));
  else
  {
    if (height)
    {
      const blk_height *bhp = (const blk_height *)key.mv_data;
      *height = bhp->bh_height;
    }
    ret = true;
  }
 
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

block_rtxn_abort()

void cryptonote::BlockchainLMDB::block_rtxn_abort ( ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4477 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  mdb_txn_reset(m_tinfo->m_ti_rtxn);
  memset(&m_tinfo->m_ti_rflags, 0, sizeof(m_tinfo->m_ti_rflags));
}

Here is the call graph for this function:

block_rtxn_start() [1/2]

bool cryptonote::BlockchainLMDB::block_rtxn_start ( ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4399 of file db_lmdb.cpp.

{
  MDB_txn *mtxn;
  mdb_txn_cursors *mcur;
  return block_rtxn_start(&mtxn, &mcur);
}

Here is the call graph for this function:

Here is the caller graph for this function:

block_rtxn_start() [2/2]

bool cryptonote::BlockchainLMDB::block_rtxn_start	(	MDB_txn **	mtxn,
		mdb_txn_cursors **	mcur ) const

Definition at line 4355 of file db_lmdb.cpp.

{
  bool ret = false;
  mdb_threadinfo *tinfo;
  if (m_write_txn && m_writer == boost::this_thread::get_id()) {
    *mtxn = m_write_txn->m_txn;
    *mcur = (mdb_txn_cursors *)&m_wcursors;
    return ret;
  }
  /* Check for existing info and force reset if env doesn't match -
   * only happens if env was opened/closed multiple times in same process
   */
  if (!(tinfo = m_tinfo.get()) || mdb_txn_env(tinfo->m_ti_rtxn) != m_env)
  {
    tinfo = new mdb_threadinfo;
    m_tinfo.reset(tinfo);
    memset(&tinfo->m_ti_rcursors, 0, sizeof(tinfo->m_ti_rcursors));
    memset(&tinfo->m_ti_rflags, 0, sizeof(tinfo->m_ti_rflags));
    if (auto mdb_res = lmdb_txn_begin(m_env, NULL, MDB_RDONLY, &tinfo->m_ti_rtxn))
      throw0(DB_ERROR_TXN_START(lmdb_error("Failed to create a read transaction for the db: ", mdb_res).c_str()));
    ret = true;
  } else if (!tinfo->m_ti_rflags.m_rf_txn)
  {
    if (auto mdb_res = lmdb_txn_renew(tinfo->m_ti_rtxn))
      throw0(DB_ERROR_TXN_START(lmdb_error("Failed to renew a read transaction for the db: ", mdb_res).c_str()));
    ret = true;
  }
  if (ret)
    tinfo->m_ti_rflags.m_rf_txn = true;
  *mtxn = tinfo->m_ti_rtxn;
  *mcur = &tinfo->m_ti_rcursors;
 
  if (ret)
    LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  return ret;
}

Here is the call graph for this function:

block_rtxn_stop()

void cryptonote::BlockchainLMDB::block_rtxn_stop ( ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4392 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  mdb_txn_reset(m_tinfo->m_ti_rtxn);
  memset(&m_tinfo->m_ti_rflags, 0, sizeof(m_tinfo->m_ti_rflags));
}

Here is the call graph for this function:

block_wtxn_abort()

void cryptonote::BlockchainLMDB::block_wtxn_abort ( )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4461 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (!m_write_txn)
    throw0(DB_ERROR_TXN_START((std::string("Attempted to abort write txn when no such txn exists in ")+__FUNCTION__).c_str()));
  if (m_writer != boost::this_thread::get_id())
    throw0(DB_ERROR_TXN_START((std::string("Attempted to abort write txn from the wrong thread in ")+__FUNCTION__).c_str()));
 
  if (! m_batch_active)
  {
    delete m_write_txn;
    m_write_txn = nullptr;
    memset(&m_wcursors, 0, sizeof(m_wcursors));
  }
}

Here is the caller graph for this function:

block_wtxn_start()

void cryptonote::BlockchainLMDB::block_wtxn_start ( )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4406 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  // Distinguish the exceptions here from exceptions that would be thrown while
  // using the txn and committing it.
  //
  // If an exception is thrown in this setup, we don't want the caller to catch
  // it and proceed as if there were an existing write txn, such as trying to
  // call block_txn_abort(). It also indicates a serious issue which will
  // probably be thrown up another layer.
  if (! m_batch_active && m_write_txn)
    throw0(DB_ERROR_TXN_START((std::string("Attempted to start new write txn when write txn already exists in ")+__FUNCTION__).c_str()));
  if (! m_batch_active)
  {
    m_writer = boost::this_thread::get_id();
    m_write_txn = new mdb_txn_safe();
    if (auto mdb_res = lmdb_txn_begin(m_env, NULL, 0, *m_write_txn))
    {
      delete m_write_txn;
      m_write_txn = nullptr;
      throw0(DB_ERROR_TXN_START(lmdb_error("Failed to create a transaction for the db: ", mdb_res).c_str()));
    }
    memset(&m_wcursors, 0, sizeof(m_wcursors));
    if (m_tinfo.get())
    {
      if (m_tinfo->m_ti_rflags.m_rf_txn)
        mdb_txn_reset(m_tinfo->m_ti_rtxn);
      memset(&m_tinfo->m_ti_rflags, 0, sizeof(m_tinfo->m_ti_rflags));
    }
  } else if (m_writer != boost::this_thread::get_id())
    throw0(DB_ERROR_TXN_START((std::string("Attempted to start new write txn when batch txn already exists in ")+__FUNCTION__).c_str()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

block_wtxn_stop()

void cryptonote::BlockchainLMDB::block_wtxn_stop ( )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4439 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (!m_write_txn)
    throw0(DB_ERROR_TXN_START((std::string("Attempted to stop write txn when no such txn exists in ")+__FUNCTION__).c_str()));
  if (m_writer != boost::this_thread::get_id())
    throw0(DB_ERROR_TXN_START((std::string("Attempted to stop write txn from the wrong thread in ")+__FUNCTION__).c_str()));
  {
    if (! m_batch_active)
    {
      TIME_MEASURE_START(time1);
      m_write_txn->commit();
      TIME_MEASURE_FINISH(time1);
      time_commit1 += time1;
 
      delete m_write_txn;
      m_write_txn = nullptr;
      memset(&m_wcursors, 0, sizeof(m_wcursors));
    }
  }
}

Here is the caller graph for this function:

can_thread_bulk_indices()

virtual bool cryptonote::BlockchainLMDB::can_thread_bulk_indices ( ) const

inlinevirtual

Implements cryptonote::BlockchainDB.

Definition at line 342 of file db_lmdb.h.

{ return true; }

check_pruning()

bool cryptonote::BlockchainLMDB::check_pruning ( )

virtual

checks pruning was done correctly, iff enabled

Returns

success iff true

Implements cryptonote::BlockchainDB.

Definition at line 2936 of file db_lmdb.cpp.

{
  return prune_worker(prune_mode_check, 0);
}

close()

void cryptonote::BlockchainLMDB::close ( )

virtual

close the BlockchainDB

At minimum, this call ensures that further use of the BlockchainDB instance will not have effect. In any case where it is necessary to do so, a subclass implementing this will sync with disk.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 1624 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if (m_batch_active)
  {
    LOG_PRINT_L3("close() first calling batch_abort() due to active batch transaction");
    batch_abort();
  }
  this->sync();
  m_tinfo.reset();
 
  // FIXME: not yet thread safe!!!  Use with care.
  mdb_env_close(m_env);
  m_open = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compare_data()

int cryptonote::BlockchainLMDB::compare_data ( const MDB_val * a, const MDB_val * b )

static

Definition at line 172 of file db_lmdb.cpp.

{
  size_t size = std::max(a->mv_size, b->mv_size);
 
  uint8_t *va = (uint8_t*) a->mv_data;
  uint8_t *vb = (uint8_t*) b->mv_data;
  for (size_t n = 0; n < size; ++n)
  {
    if (va[n] == vb[n])
      continue;
    return va[n] < vb[n] ? -1 : 1;
  }
 
  return 0;
}

Here is the caller graph for this function:

compare_hash32()

int cryptonote::BlockchainLMDB::compare_hash32 ( const MDB_val * a, const MDB_val * b )

static

Definition at line 151 of file db_lmdb.cpp.

{
  uint32_t *va = (uint32_t*) a->mv_data;
  uint32_t *vb = (uint32_t*) b->mv_data;
  for (int n = 7; n >= 0; n--)
  {
    if (va[n] == vb[n])
      continue;
    return va[n] < vb[n] ? -1 : 1;
  }
 
  return 0;
}

Here is the caller graph for this function:

compare_publickey()

int cryptonote::BlockchainLMDB::compare_publickey ( const MDB_val * a, const MDB_val * b )

static

Definition at line 188 of file db_lmdb.cpp.

{
  uint8_t *va = (uint8_t*) a->mv_data;
  uint8_t *vb = (uint8_t*) b->mv_data;
  for (int n = 0; n < 32; ++n)
  {
    if (va[n] == vb[n])
      continue;
    return va[n] < vb[n] ? -1 : 1;
  }
 
  return 0;
}

Here is the caller graph for this function:

compare_string()

int cryptonote::BlockchainLMDB::compare_string ( const MDB_val * a, const MDB_val * b )

static

Definition at line 165 of file db_lmdb.cpp.

{
  const char *va = (const char*) a->mv_data;
  const char *vb = (const char*) b->mv_data;
  return strcmp(va, vb);
}

Here is the caller graph for this function:

compare_uint64()

int cryptonote::BlockchainLMDB::compare_uint64 ( const MDB_val * a, const MDB_val * b )

static

Definition at line 143 of file db_lmdb.cpp.

{
  uint64_t va, vb;
  memcpy(&va, a->mv_data, sizeof(va));
  memcpy(&vb, b->mv_data, sizeof(vb));
  return (va < vb) ? -1 : va > vb;
}

Here is the call graph for this function:

Here is the caller graph for this function:

for_all_key_images()

bool cryptonote::BlockchainLMDB::for_all_key_images ( std::function< bool(const crypto::key_image &)> ) const

virtual

runs a function over all key images stored

The subclass should run the passed function for each key image it has stored, passing the key image as its parameter.

If any call to the function returns false, the subclass should return false. Otherwise, the subclass returns true.

Parameters

std::function

fn the function to run

Returns

false if the function returns false for any key image, otherwise true

Implements cryptonote::BlockchainDB.

Definition at line 3989 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(spent_keys);
 
  MDB_val k, v;
  bool fret = true;
 
  k = zerokval;
  MDB_cursor_op op = MDB_FIRST;
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_spent_keys, &k, &v, op);
    op = MDB_NEXT;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret < 0)
      throw0(DB_ERROR("Failed to enumerate key images"));
    const crypto::key_image k_image = *(const crypto::key_image*)v.mv_data;
    if (!f(k_image)) {
      fret = false;
      break;
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return fret;
}

Here is the call graph for this function:

for_all_outputs() [1/2]

bool cryptonote::BlockchainLMDB::for_all_outputs ( std::function< bool(uint64_t amount, const crypto::hash &tx_hash, uint64_t height, size_t tx_idx)> f ) const

virtual

runs a function over all outputs stored

The subclass should run the passed function for each output it has stored, passing (amount, transaction_hash, tx_local_output_index) as its parameters.

If any call to the function returns false, the subclass should return false. Otherwise, the subclass returns true.

The subclass should throw DB_ERROR if any of the expected values are not found. Current implementations simply return false.

Parameters

std::function

f the function to run

Returns

false if the function returns false for any output, otherwise true

Implements cryptonote::BlockchainDB.

Definition at line 4135 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  MDB_val k;
  MDB_val v;
  bool fret = true;
 
  MDB_cursor_op op = MDB_FIRST;
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_output_amounts, &k, &v, op);
    op = MDB_NEXT;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate outputs"));
    uint64_t amount = *(const uint64_t*)k.mv_data;
    outkey *ok = (outkey *)v.mv_data;
    tx_out_index toi = get_output_tx_and_index_from_global(ok->output_id);
    if (!f(amount, toi.first, ok->data.height, toi.second)) {
      fret = false;
      break;
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return fret;
}

Here is the call graph for this function:

for_all_outputs() [2/2]

bool cryptonote::BlockchainLMDB::for_all_outputs ( uint64_t amount, const std::function< bool(uint64_t height)> & f ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4170 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  MDB_val_set(k, amount);
  MDB_val v;
  bool fret = true;
 
  MDB_cursor_op op = MDB_SET;
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_output_amounts, &k, &v, op);
    op = MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate outputs"));
    uint64_t out_amount = *(const uint64_t*)k.mv_data;
    if (amount != out_amount)
    {
      MERROR("Amount is not the expected amount");
      fret = false;
      break;
    }
    const outkey *ok = (const outkey *)v.mv_data;
    if (!f(ok->data.height)) {
      fret = false;
      break;
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return fret;
}

Here is the call graph for this function:

for_all_transactions()

bool cryptonote::BlockchainLMDB::for_all_transactions ( std::function< bool(const crypto::hash &, const cryptonote::transaction &)> , bool pruned ) const

virtual

runs a function over all transactions stored

The subclass should run the passed function for each transaction it has stored, passing (transaction_hash, transaction) as its parameters.

If any call to the function returns false, the subclass should return false. Otherwise, the subclass returns true.

The subclass should throw DB_ERROR if any of the expected values are not found. Current implementations simply return false.

Parameters

std::function	fn the function to run
bool	pruned whether to only get pruned tx data, or the whole

Returns

false if the function returns false for any transaction, otherwise true

Implements cryptonote::BlockchainDB.

Definition at line 4073 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(txs_pruned);
  RCURSOR(txs_prunable);
  RCURSOR(tx_indices);
 
  MDB_val k;
  MDB_val v;
  bool fret = true;
 
  MDB_cursor_op op = MDB_FIRST;
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_tx_indices, &k, &v, op);
    op = MDB_NEXT;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR(lmdb_error("Failed to enumerate transactions: ", ret).c_str()));
 
    txindex *ti = (txindex *)v.mv_data;
    const crypto::hash hash = ti->key;
    k.mv_data = (void *)&ti->data.tx_id;
    k.mv_size = sizeof(ti->data.tx_id);
 
    ret = mdb_cursor_get(m_cur_txs_pruned, &k, &v, MDB_SET);
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR(lmdb_error("Failed to enumerate transactions: ", ret).c_str()));
    transaction tx;
    blobdata bd;
    bd.assign(reinterpret_cast<char*>(v.mv_data), v.mv_size);
    if (pruned)
    {
      if (!parse_and_validate_tx_base_from_blob(bd, tx))
        throw0(DB_ERROR("Failed to parse tx from blob retrieved from the db"));
    }
    else
    {
      ret = mdb_cursor_get(m_cur_txs_prunable, &k, &v, MDB_SET);
      if (ret)
        throw0(DB_ERROR(lmdb_error("Failed to get prunable tx data the db: ", ret).c_str()));
      bd.append(reinterpret_cast<char*>(v.mv_data), v.mv_size);
      if (!parse_and_validate_tx_from_blob(bd, tx))
        throw0(DB_ERROR("Failed to parse tx from blob retrieved from the db"));
    }
    if (!f(hash, tx)) {
      fret = false;
      break;
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return fret;
}

Here is the call graph for this function:

for_all_txpool_txes()

bool cryptonote::BlockchainLMDB::for_all_txpool_txes ( std::function< bool(const crypto::hash &, const txpool_tx_meta_t &, const cryptonote::blobdata *)> , bool include_blob = false, bool include_unrelayed_txes = true ) const

virtual

runs a function over all txpool transactions

The subclass should run the passed function for each txpool tx it has stored, passing the tx id and metadata as its parameters.

If any call to the function returns false, the subclass should return false. Otherwise, the subclass returns true.

Parameters

std::function

fn the function to run

Returns

false if the function returns false for any transaction, otherwise true

Implements cryptonote::BlockchainDB.

Definition at line 2941 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(txpool_meta);
  RCURSOR(txpool_blob);
 
  MDB_val k;
  MDB_val v;
  bool ret = true;
 
  MDB_cursor_op op = MDB_FIRST;
  while (1)
  {
    int result = mdb_cursor_get(m_cur_txpool_meta, &k, &v, op);
    op = MDB_NEXT;
    if (result == MDB_NOTFOUND)
      break;
    if (result)
      throw0(DB_ERROR(lmdb_error("Failed to enumerate txpool tx metadata: ", result).c_str()));
    const crypto::hash txid = *(const crypto::hash*)k.mv_data;
    const txpool_tx_meta_t &meta = *(const txpool_tx_meta_t*)v.mv_data;
    if (!include_unrelayed_txes && meta.do_not_relay)
      // Skipping that tx
      continue;
    const cryptonote::blobdata *passed_bd = NULL;
    cryptonote::blobdata bd;
    if (include_blob)
    {
      MDB_val b;
      result = mdb_cursor_get(m_cur_txpool_blob, &k, &b, MDB_SET);
      if (result == MDB_NOTFOUND)
        throw0(DB_ERROR("Failed to find txpool tx blob to match metadata"));
      if (result)
        throw0(DB_ERROR(lmdb_error("Failed to enumerate txpool tx blob: ", result).c_str()));
      bd.assign(reinterpret_cast<const char*>(b.mv_data), b.mv_size);
      passed_bd = &bd;
    }
 
    if (!f(txid, meta, passed_bd)) {
      ret = false;
      break;
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return ret;
}

Here is the call graph for this function:

for_blocks_range()

bool cryptonote::BlockchainLMDB::for_blocks_range ( const uint64_t & h1, const uint64_t & h2, std::function< bool(uint64_t, const crypto::hash &, const cryptonote::block &)>  ) const

virtual

runs a function over a range of blocks

The subclass should run the passed function for each block in the specified range, passing (block_height, block_hash, block) as its parameters.

If any call to the function returns false, the subclass should return false. Otherwise, the subclass returns true.

The subclass should throw DB_ERROR if any of the expected values are not found. Current implementations simply return false.

Parameters

h1	the start height
h2	the end height
std::function	fn the function to run

Returns

false if the function returns false for any block, otherwise true

Implements cryptonote::BlockchainDB.

Definition at line 4022 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(blocks);
 
  MDB_val k;
  MDB_val v;
  bool fret = true;
 
  MDB_cursor_op op;
  if (h1)
  {
    k = MDB_val{sizeof(h1), (void*)&h1};
    op = MDB_SET;
  } else
  {
    op = MDB_FIRST;
  }
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_blocks, &k, &v, op);
    op = MDB_NEXT;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate blocks"));
    uint64_t height = *(const uint64_t*)k.mv_data;
    blobdata bd;
    bd.assign(reinterpret_cast<char*>(v.mv_data), v.mv_size);
    block b;
    if (!parse_and_validate_block_from_blob(bd, b))
      throw0(DB_ERROR("Failed to parse block from blob retrieved from the db"));
    crypto::hash hash;
    if (!get_block_hash(b, hash))
        throw0(DB_ERROR("Failed to get block hash from blob retrieved from the db"));
    if (!f(height, hash, b)) {
      fret = false;
      break;
    }
    if (height >= h2)
      break;
  }
 
  TXN_POSTFIX_RDONLY();
 
  return fret;
}

Here is the call graph for this function:

get_addr_output_all()

std::vector< address_outputs > cryptonote::BlockchainLMDB::get_addr_output_all ( const crypto::public_key & combined_key )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 2071 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(addr_outputs);
 
  int result = 0;
  std::vector<address_outputs> address_outputs;
 
  MDB_val k = {sizeof(combined_key), (void *)&combined_key};
 
  MDB_cursor_op op = MDB_SET_KEY;
  while (1) {
    MDB_val v;
    int ret = mdb_cursor_get(m_cur_addr_outputs, &k, &v, op);
    op = MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate address outputs"));
 
    const acc_outs_t res = *(const acc_outs_t *) v.mv_data;
 
    cryptonote::address_outputs addr_out;
    addr_out.out_id = res.db_index;
    addr_out.tx_hash = res.tx_hash;
    addr_out.relative_out_index = res.relative_out_index;
    addr_out.amount = res.amount;
    addr_out.spent = !check_chainstate_utxo(res.tx_hash, res.relative_out_index);
 
    address_outputs.push_back(addr_out);
 
  }
 
  TXN_POSTFIX_RDONLY();
 
  return address_outputs;
}

Here is the call graph for this function:

get_addr_output_batch()

std::vector< address_outputs > cryptonote::BlockchainLMDB::get_addr_output_batch ( const crypto::public_key & combined_key, uint64_t start_db_index = 0, uint64_t batch_size = 100, bool desc = false )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 2112 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(addr_outputs);
 
  std::vector<address_outputs> address_outputs;
 
  MDB_val k = {sizeof(combined_key), (void *)&combined_key};
  MDB_val v;
 
  MDB_cursor_op op;
  if (start_db_index)
    op = MDB_GET_BOTH;
  else
  {
    op = desc ? MDB_LAST_DUP : MDB_FIRST_DUP;
    int result = mdb_cursor_get(m_cur_addr_outputs, &k, &v, MDB_SET_KEY);
    if (result != 0 && result != MDB_NOTFOUND)
      throw1(DB_ERROR(lmdb_error("Failed to enumerate address outputs", result).c_str()));
  }
 
  std::set<std::string> tx_hashes;
  for(size_t i = 0; i < batch_size + 1; ++i) {
    if(op == MDB_GET_BOTH)
      v = MDB_val{sizeof(start_db_index), (void*)&start_db_index};
 
    int ret = mdb_cursor_get(m_cur_addr_outputs, &k, &v, op);
    op = desc ? MDB_PREV_DUP : MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate address outputs"));
 
    const acc_outs_t res = *(const acc_outs_t *) v.mv_data;
 
    std::string tx_hash_hex = epee::string_tools::pod_to_hex(res.tx_hash);
    if(tx_hashes.find(tx_hash_hex) != tx_hashes.end())
    {
      --i;
      continue;
    }
 
    cryptonote::address_outputs addr_out;
    addr_out.out_id = res.db_index;
    addr_out.tx_hash = res.tx_hash;
    addr_out.relative_out_index = res.relative_out_index;
    addr_out.amount = res.amount;
    addr_out.spent = !check_chainstate_utxo(res.tx_hash, res.relative_out_index);
 
    address_outputs.push_back(addr_out);
    tx_hashes.emplace(tx_hash_hex);
  }
 
  TXN_POSTFIX_RDONLY();
  return address_outputs;
}

Here is the call graph for this function:

get_addr_tx_all()

std::vector< address_txs > cryptonote::BlockchainLMDB::get_addr_tx_all ( const crypto::public_key & combined_key )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 2214 of file db_lmdb.cpp.

{
    LOG_PRINT_L3("BlockchainLMDB::" << __func__);
    check_open();
 
    TXN_PREFIX_RDONLY();
    RCURSOR(addr_txs);
 
    int result = 0;
    std::vector<address_txs> address_txs;
 
    MDB_val k = {sizeof(combined_key), (void *)&combined_key};
 
    MDB_cursor_op op = MDB_SET_KEY;
    while (1) {
        MDB_val v;
        int ret = mdb_cursor_get(m_cur_addr_txs, &k, &v, op);
        op = MDB_NEXT_DUP;
        if (ret == MDB_NOTFOUND)
            break;
        if (ret)
            throw0(DB_ERROR("Failed to enumerate address txs"));
 
        const acc_addr_tx_t res = *(const acc_addr_tx_t *) v.mv_data;
 
        cryptonote::address_txs addr_tx;
        addr_tx.addr_tx_id = res.db_index;
        addr_tx.tx_hash = res.tx_hash;
        address_txs.push_back(addr_tx);
    }
 
    TXN_POSTFIX_RDONLY();
    return address_txs;
}

Here is the call graph for this function:

get_addr_tx_batch()

std::vector< address_txs > cryptonote::BlockchainLMDB::get_addr_tx_batch ( const crypto::public_key & combined_key, uint64_t start_db_index = 0, uint64_t batch_size = 100, bool desc = false )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 2249 of file db_lmdb.cpp.

{
    LOG_PRINT_L3("BlockchainLMDB::" << __func__);
    check_open();
 
    TXN_PREFIX_RDONLY();
    RCURSOR(addr_txs);
 
    std::vector<address_txs> address_txs;
 
    MDB_val k = {sizeof(combined_key), (void *)&combined_key};
    MDB_val v;
 
    MDB_cursor_op op;
    if (start_db_index)
        op = MDB_GET_BOTH;
    else
    {
        op = desc ? MDB_LAST_DUP : MDB_FIRST_DUP;
        int result = mdb_cursor_get(m_cur_addr_txs, &k, &v, MDB_SET_KEY);
        if (result != 0 && result != MDB_NOTFOUND)
            throw1(DB_ERROR(lmdb_error("Failed to enumerate address txs", result).c_str()));
    }
 
    std::set<std::string> tx_hashes;
    for(size_t i = 0; i < batch_size + 1; ++i) {
        if(op == MDB_GET_BOTH)
            v = MDB_val{sizeof(start_db_index), (void*)&start_db_index};
 
        int ret = mdb_cursor_get(m_cur_addr_txs, &k, &v, op);
        op = desc ? MDB_PREV_DUP : MDB_NEXT_DUP;
        if (ret == MDB_NOTFOUND)
            break;
        if (ret)
            throw0(DB_ERROR("Failed to enumerate address txs"));
 
        const acc_addr_tx_t res = *(const acc_addr_tx_t *) v.mv_data;
 
        cryptonote::address_txs addr_tx;
        addr_tx.addr_tx_id = res.db_index;
        addr_tx.tx_hash = res.tx_hash;
 
        address_txs.push_back(addr_tx);
    }
 
    TXN_POSTFIX_RDONLY();
    return address_txs;
}

Here is the call graph for this function:

get_balance()

uint64_t cryptonote::BlockchainLMDB::get_balance ( const crypto::public_key & combined_key )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 2298 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(addr_outputs);
 
  uint64_t balance = 0;
 
  MDB_val k = {sizeof(combined_key), (void *)&combined_key};
 
  MDB_cursor_op op = MDB_SET_KEY;
  while (1) {
    MDB_val v;
    int ret = mdb_cursor_get(m_cur_addr_outputs, &k, &v, op);
    op = MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate address outputs"));
 
    const acc_outs_t res = *(const acc_outs_t *) v.mv_data;
 
    if(check_chainstate_utxo(res.tx_hash, res.relative_out_index))
      balance += res.amount;
  }
 
  TXN_POSTFIX_RDONLY();
 
  return balance;
}

Here is the call graph for this function:

get_block_already_generated_coins()

uint64_t cryptonote::BlockchainLMDB::get_block_already_generated_coins ( const uint64_t & height ) const

virtual

fetch a block's already generated coins

The subclass should return the total coins generated as of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the already generated coins

Implements cryptonote::BlockchainDB.

Definition at line 3405 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get generated coins from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a total generated coins from the db"));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  uint64_t ret = bi->bi_coins;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

get_block_blob()

cryptonote::blobdata cryptonote::BlockchainLMDB::get_block_blob ( const crypto::hash & h ) const

virtual

fetches the block with the given hash

The subclass should return the requested block.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

h	the hash to look for

Returns

the block requested

Implements cryptonote::BlockchainDB.

Definition at line 3024 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  return get_block_blob_from_height(get_block_height(h));
}

Here is the call graph for this function:

get_block_blob_from_height()

cryptonote::blobdata cryptonote::BlockchainLMDB::get_block_blob_from_height ( const uint64_t & height ) const

virtual

fetch a block blob by height

The subclass should return the block at the given height.

If the block does not exist, that is to say if the blockchain is not that high, then the subclass should throw BLOCK_DNE

Parameters

height

the height to look for

Returns

the block blob

Implements cryptonote::BlockchainDB.

Definition at line 3062 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(blocks);
 
  MDB_val_copy<uint64_t> key(height);
  MDB_val result;
  auto get_result = mdb_cursor_get(m_cur_blocks, &key, &result, MDB_SET);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get block from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a block from the db"));
 
  blobdata bd;
  bd.assign(reinterpret_cast<char*>(result.mv_data), result.mv_size);
 
  TXN_POSTFIX_RDONLY();
 
  return bd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_cumulative_difficulty()

difficulty_type cryptonote::BlockchainLMDB::get_block_cumulative_difficulty ( const uint64_t & height ) const

virtual

fetch a block's cumulative difficulty

The subclass should return the cumulative difficulty of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the cumulative difficulty

Implements cryptonote::BlockchainDB.

Definition at line 3363 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__ << "  height: " << height);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get cumulative difficulty from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- difficulty not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a cumulative difficulty from the db"));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  difficulty_type ret = bi->bi_diff_hi;
  ret <<= 64;
  ret |= bi->bi_diff_lo;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_cumulative_rct_outputs()

std::vector< uint64_t > cryptonote::BlockchainLMDB::get_block_cumulative_rct_outputs ( const std::vector< uint64_t > & heights ) const

virtual

fetch a block's cumulative number of rct outputs

The subclass should return the numer of rct outputs in the blockchain up to the block with the given height (inclusive).

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the cumulative number of rct outputs

Implements cryptonote::BlockchainDB.

Definition at line 3111 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  std::vector<uint64_t> res;
  int result;
 
  if (heights.empty())
    return {};
  res.reserve(heights.size());
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_stat db_stats;
  if ((result = mdb_stat(m_txn, m_blocks, &db_stats)))
    throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
  for (size_t i = 0; i < heights.size(); ++i)
    if (heights[i] >= db_stats.ms_entries)
      throw0(BLOCK_DNE(std::string("Attempt to get rct distribution from height " + std::to_string(heights[i]) + " failed -- block size not in db").c_str()));
 
  MDB_val v;
 
  uint64_t prev_height = heights[0];
  uint64_t range_begin = 0, range_end = 0;
  for (uint64_t height: heights)
  {
    if (height >= range_begin && height < range_end)
    {
      // nohting to do
    }
    else
    {
      if (height == prev_height + 1)
      {
        MDB_val k2;
        result = mdb_cursor_get(m_cur_block_info, &k2, &v, MDB_NEXT_MULTIPLE);
        range_begin = ((const mdb_block_info*)v.mv_data)->bi_height;
        range_end = range_begin + v.mv_size / sizeof(mdb_block_info); // whole records please
        if (height < range_begin || height >= range_end)
          throw0(DB_ERROR(("Height " + std::to_string(height) + " not included in multuple record range: " + std::to_string(range_begin) + "-" + std::to_string(range_end)).c_str()));
      }
      else
      {
        v.mv_size = sizeof(uint64_t);
        v.mv_data = (void*)&height;
        result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
        range_begin = height;
        range_end = range_begin + 1;
      }
      if (result)
        throw0(DB_ERROR(lmdb_error("Error attempting to retrieve rct distribution from the db: ", result).c_str()));
    }
    const mdb_block_info *bi = ((const mdb_block_info *)v.mv_data) + (height - range_begin);
    res.push_back(bi->bi_cum_rct);
    prev_height = height;
  }
 
  TXN_POSTFIX_RDONLY();
  return res;
}

Here is the call graph for this function:

get_block_difficulty()

difficulty_type cryptonote::BlockchainLMDB::get_block_difficulty ( const uint64_t & height ) const

virtual

fetch a block's difficulty

The subclass should return the difficulty of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the difficulty

Implements cryptonote::BlockchainDB.

Definition at line 3388 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  difficulty_type diff1 = 0;
  difficulty_type diff2 = 0;
 
  diff1 = get_block_cumulative_difficulty(height);
  if (height != 0)
  {
    diff2 = get_block_cumulative_difficulty(height - 1);
  }
 
  return diff1 - diff2;
}

Here is the call graph for this function:

get_block_hash_from_height()

crypto::hash cryptonote::BlockchainLMDB::get_block_hash_from_height ( const uint64_t & height ) const

virtual

fetch a block's hash

The subclass should return hash of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the hash

Implements cryptonote::BlockchainDB.

Definition at line 3451 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get hash from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- hash not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("Error attempting to retrieve a block hash from the db: ", get_result).c_str()));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  crypto::hash ret = bi->bi_hash;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_header()

block_header cryptonote::BlockchainLMDB::get_block_header ( const crypto::hash & h ) const

virtual

fetch a block header

The subclass should return the block header from the block with the given hash.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

h	the hash to look for

Returns

the block header

Implements cryptonote::BlockchainDB.

Definition at line 3053 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  // block_header object is automatically cast from block object
  return get_block(h);
}

Here is the call graph for this function:

get_block_height()

uint64_t cryptonote::BlockchainLMDB::get_block_height ( const crypto::hash & h ) const

virtual

gets the height of the block with a given hash

The subclass should return the requested height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

h	the hash to look for

Returns

the height

Implements cryptonote::BlockchainDB.

Definition at line 3032 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_heights);
 
  MDB_val_set(key, h);
  auto get_result = mdb_cursor_get(m_cur_block_heights, (MDB_val *)&zerokval, &key, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
    throw1(BLOCK_DNE("Attempted to retrieve non-existent block height"));
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a block height from the db"));
 
  blk_height *bhp = (blk_height *)key.mv_data;
  uint64_t ret = bhp->bh_height;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_long_term_weight()

uint64_t cryptonote::BlockchainLMDB::get_block_long_term_weight ( const uint64_t & height ) const

virtual

fetch a block's long term weight

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the long term weight

Implements cryptonote::BlockchainDB.

Definition at line 3428 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get block long term weight from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block info not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a long term block weight from the db"));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  uint64_t ret = bi->bi_long_term_block_weight;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

get_block_timestamp()

uint64_t cryptonote::BlockchainLMDB::get_block_timestamp ( const uint64_t & height ) const

virtual

fetch a block's timestamp

The subclass should return the timestamp of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the timestamp

Implements cryptonote::BlockchainDB.

Definition at line 3088 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get timestamp from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- timestamp not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a timestamp from the db"));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  uint64_t ret = bi->bi_timestamp;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_weight()

size_t cryptonote::BlockchainLMDB::get_block_weight ( const uint64_t & height ) const

virtual

fetch a block's weight

The subclass should return the weight of the block with the given height.

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height

the height requested

Returns

the weight

Implements cryptonote::BlockchainDB.

Definition at line 3188 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(block_info);
 
  MDB_val_set(result, height);
  auto get_result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &result, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to get block size from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve a block size from the db"));
 
  mdb_block_info *bi = (mdb_block_info *)result.mv_data;
  size_t ret = bi->bi_weight;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

get_block_weights()

std::vector< uint64_t > cryptonote::BlockchainLMDB::get_block_weights ( uint64_t start_height, size_t count ) const

virtual

fetch the last N blocks' weights

If there are fewer than N blocks, the returned array will be smaller than N

Parameters

count

the number of blocks requested

Returns

the weights

Implements cryptonote::BlockchainDB.

Definition at line 3317 of file db_lmdb.cpp.

{
  return get_block_info_64bit_fields(start_height, count, offsetof(mdb_block_info, bi_weight));
}

get_blockchain_pruning_seed()

uint32_t cryptonote::BlockchainLMDB::get_blockchain_pruning_seed ( ) const

virtual

get the blockchain pruning seed

Returns

the blockchain pruning seed

Implements cryptonote::BlockchainDB.

Definition at line 2608 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(properties)
  MDB_val_str(k, "pruning_seed");
  MDB_val v;
  int result = mdb_cursor_get(m_cur_properties, &k, &v, MDB_SET);
  if (result == MDB_NOTFOUND)
    return 0;
  if (result)
    throw0(DB_ERROR(lmdb_error("Failed to retrieve pruning seed: ", result).c_str()));
  if (v.mv_size != sizeof(uint32_t))
    throw0(DB_ERROR("Failed to retrieve or create pruning seed: unexpected value size"));
  uint32_t pruning_seed;
  memcpy(&pruning_seed, v.mv_data, sizeof(pruning_seed));
  TXN_POSTFIX_RDONLY();
  return pruning_seed;
}

Here is the call graph for this function:

get_blocks_range()

std::vector< block > cryptonote::BlockchainLMDB::get_blocks_range ( const uint64_t & h1, const uint64_t & h2 ) const

virtual

fetch a list of blocks

The subclass should return a vector of blocks with heights starting at h1 and ending at h2, inclusively.

If the height range requested goes past the end of the blockchain, the subclass should throw BLOCK_DNE. (current implementations simply don't catch this exception as thrown by methods called within)

Parameters

h1	the start height
h2	the end height

Returns

a vector of blocks

Implements cryptonote::BlockchainDB.

Definition at line 3474 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  std::vector<block> v;
 
  for (uint64_t height = h1; height <= h2; ++height)
  {
    v.push_back(get_block_from_height(height));
  }
 
  return v;
}

Here is the call graph for this function:

get_db_name()

std::string cryptonote::BlockchainLMDB::get_db_name ( ) const

virtual

gets the name of the folder the BlockchainDB's file(s) should be in

The subclass implementation should return the name of the folder in which it stores files, or an empty string if there is none.

Returns

the name of the folder with the BlockchainDB's files, if any.

Implements cryptonote::BlockchainDB.

Definition at line 1755 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
 
  return std::string("lmdb");
}

get_filenames()

std::vector< std::string > cryptonote::BlockchainLMDB::get_filenames ( ) const

virtual

get all files used by the BlockchainDB (if any)

This function is largely for ease of automation, namely for unit tests.

The subclass implementation should return all filenames it uses.

Returns

a list of filenames

Implements cryptonote::BlockchainDB.

Definition at line 1724 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  std::vector<std::string> filenames;
 
  boost::filesystem::path datafile(m_folder);
  datafile /= CRYPTONOTE_BLOCKCHAINDATA_FILENAME;
  boost::filesystem::path lockfile(m_folder);
  lockfile /= CRYPTONOTE_BLOCKCHAINDATA_LOCK_FILENAME;
 
  filenames.push_back(datafile.string());
  filenames.push_back(lockfile.string());
 
  return filenames;
}

get_hashes_range()

std::vector< crypto::hash > cryptonote::BlockchainLMDB::get_hashes_range ( const uint64_t & h1, const uint64_t & h2 ) const

virtual

fetch a list of block hashes

The subclass should return a vector of block hashes from blocks with heights starting at h1 and ending at h2, inclusively.

If the height range requested goes past the end of the blockchain, the subclass should throw BLOCK_DNE. (current implementations simply don't catch this exception as thrown by methods called within)

Parameters

h1	the start height
h2	the end height

Returns

a vector of block hashes

Implements cryptonote::BlockchainDB.

Definition at line 3488 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  std::vector<crypto::hash> v;
 
  for (uint64_t height = h1; height <= h2; ++height)
  {
    v.push_back(get_block_hash_from_height(height));
  }
 
  return v;
}

Here is the call graph for this function:

get_long_term_block_weights()

std::vector< uint64_t > cryptonote::BlockchainLMDB::get_long_term_block_weights ( uint64_t start_height, size_t count ) const

virtual

fetch the last N blocks' long term weights

If there are fewer than N blocks, the returned array will be smaller than N

Parameters

count

the number of blocks requested

Returns

the weights

Implements cryptonote::BlockchainDB.

Definition at line 3322 of file db_lmdb.cpp.

{
  return get_block_info_64bit_fields(start_height, count, offsetof(mdb_block_info, bi_long_term_block_weight));
}

get_num_outputs()

uint64_t cryptonote::BlockchainLMDB::get_num_outputs ( const uint64_t & amount ) const

virtual

fetches the number of outputs of a given amount

The subclass should return a count of outputs of the given amount, or zero if there are none.

Parameters

amount

the output amount being looked up

Returns

the number of outputs of the given amount

Implements cryptonote::BlockchainDB.

Definition at line 3835 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  MDB_val_copy<uint64_t> k(amount);
  MDB_val v;
  mdb_size_t num_elems = 0;
  auto result = mdb_cursor_get(m_cur_output_amounts, &k, &v, MDB_SET);
  if (result == MDB_SUCCESS)
  {
    mdb_cursor_count(m_cur_output_amounts, &num_elems);
  }
  else if (result != MDB_NOTFOUND)
    throw0(DB_ERROR("DB error attempting to get number of outputs of an amount"));
 
  TXN_POSTFIX_RDONLY();
 
  return num_elems;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_output_distribution()

bool cryptonote::BlockchainLMDB::get_output_distribution ( uint64_t amount, uint64_t from_height, uint64_t to_height, std::vector< uint64_t > & distribution, uint64_t & base ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 4744 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  distribution.clear();
  const uint64_t db_height = height();
  if (from_height >= db_height)
    return false;
  distribution.resize(db_height - from_height, 0);
 
  bool fret = true;
  MDB_val_set(k, amount);
  MDB_val v;
  MDB_cursor_op op = MDB_SET;
  base = 0;
  while (1)
  {
    int ret = mdb_cursor_get(m_cur_output_amounts, &k, &v, op);
    op = MDB_NEXT_DUP;
    if (ret == MDB_NOTFOUND)
      break;
    if (ret)
      throw0(DB_ERROR("Failed to enumerate outputs"));
    const outkey *ok = (const outkey *)v.mv_data;
    const uint64_t height = ok->data.height;
    if (height >= from_height)
      distribution[height - from_height]++;
    else
      base++;
    if (to_height > 0 && height > to_height)
      break;
  }
 
  distribution[0] += base;
  for (size_t n = 1; n < distribution.size(); ++n)
    distribution[n] += distribution[n - 1];
  base = 0;
 
  TXN_POSTFIX_RDONLY();
 
  return true;
}

Here is the call graph for this function:

get_output_histogram()

std::map< uint64_t, std::tuple< uint64_t, uint64_t, uint64_t > > cryptonote::BlockchainLMDB::get_output_histogram ( const std::vector< uint64_t > & amounts, bool unlocked, uint64_t recent_cutoff, uint64_t min_count ) const

virtual

return a histogram of outputs on the blockchain

Parameters

amounts	optional set of amounts to lookup
unlocked	whether to restrict count to unlocked outputs
recent_cutoff	timestamp to determine which outputs are recent
min_count	return only amounts with at least that many instances

Returns

a set of amount/instances

Implements cryptonote::BlockchainDB.

Definition at line 4651 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  std::map<uint64_t, std::tuple<uint64_t, uint64_t, uint64_t>> histogram;
  MDB_val k;
  MDB_val v;
 
  if (amounts.empty())
  {
    MDB_cursor_op op = MDB_FIRST;
    while (1)
    {
      int ret = mdb_cursor_get(m_cur_output_amounts, &k, &v, op);
      op = MDB_NEXT_NODUP;
      if (ret == MDB_NOTFOUND)
        break;
      if (ret)
        throw0(DB_ERROR(lmdb_error("Failed to enumerate outputs: ", ret).c_str()));
      mdb_size_t num_elems = 0;
      mdb_cursor_count(m_cur_output_amounts, &num_elems);
      uint64_t amount = *(const uint64_t*)k.mv_data;
      if (num_elems >= min_count)
        histogram[amount] = std::make_tuple(num_elems, 0, 0);
    }
  }
  else
  {
    for (const auto &amount: amounts)
    {
      MDB_val_copy<uint64_t> k(amount);
      int ret = mdb_cursor_get(m_cur_output_amounts, &k, &v, MDB_SET);
      if (ret == MDB_NOTFOUND)
      {
        if (0 >= min_count)
          histogram[amount] = std::make_tuple(0, 0, 0);
      }
      else if (ret == MDB_SUCCESS)
      {
        mdb_size_t num_elems = 0;
        mdb_cursor_count(m_cur_output_amounts, &num_elems);
        if (num_elems >= min_count)
          histogram[amount] = std::make_tuple(num_elems, 0, 0);
      }
      else
      {
        throw0(DB_ERROR(lmdb_error("Failed to enumerate outputs: ", ret).c_str()));
      }
    }
  }
 
  if (unlocked || recent_cutoff > 0) {
    const uint64_t blockchain_height = height();
    for (std::map<uint64_t, std::tuple<uint64_t, uint64_t, uint64_t>>::iterator i = histogram.begin(); i != histogram.end(); ++i) {
      uint64_t amount = i->first;
      uint64_t num_elems = std::get<0>(i->second);
      while (num_elems > 0) {
        const tx_out_index toi = get_output_tx_and_index(amount, num_elems - 1);
        const uint64_t height = get_tx_block_height(toi.first);
        if (height + (get_hard_fork_version(height) > 7 ? ETN_DEFAULT_TX_SPENDABLE_AGE_V8 : CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE) <= blockchain_height)
          break;
        --num_elems;
      }
      // modifying second does not invalidate the iterator
      std::get<1>(i->second) = num_elems;
 
      if (recent_cutoff > 0)
      {
        uint64_t recent = 0;
        while (num_elems > 0) {
          const tx_out_index toi = get_output_tx_and_index(amount, num_elems - 1);
          const uint64_t height = get_tx_block_height(toi.first);
          const uint64_t ts = get_block_timestamp(height);
          if (ts < recent_cutoff)
            break;
          --num_elems;
          ++recent;
        }
        // modifying second does not invalidate the iterator
        std::get<2>(i->second) = recent;
      }
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  return histogram;
}

Here is the call graph for this function:

get_output_key() [1/2]

void cryptonote::BlockchainLMDB::get_output_key ( const epee::span< const uint64_t > & amounts, const std::vector< uint64_t > & offsets, std::vector< output_data_t > & outputs, bool allow_partial = false ) const

virtual

gets outputs' data

This function is a mirror of get_output_data(const uint64_t& amount, const uint64_t& index) but for a list of outputs rather than just one.

Parameters

amounts	an output amount, or as many as offsets
offsets	a list of amount-specific output indices
outputs	return-by-reference a list of outputs' metadata

Implements cryptonote::BlockchainDB.

Definition at line 4560 of file db_lmdb.cpp.

{
  if (amounts.size() != 1 && amounts.size() != offsets.size())
    throw0(DB_ERROR("Invalid sizes of amounts and offets"));
 
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  TIME_MEASURE_START(db3);
  check_open();
  outputs.clear();
  outputs.reserve(offsets.size());
 
  TXN_PREFIX_RDONLY();
 
  RCURSOR(output_amounts);
 
  for (size_t i = 0; i < offsets.size(); ++i)
  {
    const uint64_t amount = amounts.size() == 1 ? amounts[0] : amounts[i];
    MDB_val_set(k, amount);
    MDB_val_set(v, offsets[i]);
 
    auto get_result = mdb_cursor_get(m_cur_output_amounts, &k, &v, MDB_GET_BOTH);
    if (get_result == MDB_NOTFOUND)
    {
      if (allow_partial)
      {
        MDEBUG("Partial result: " << outputs.size() << "/" << offsets.size());
        break;
      }
      throw1(OUTPUT_DNE((std::string("Attempting to get output pubkey by global index (amount ") + boost::lexical_cast<std::string>(amount) + ", index " + boost::lexical_cast<std::string>(offsets[i]) + ", count " + boost::lexical_cast<std::string>(get_num_outputs(amount)) + "), but key does not exist (current height " + boost::lexical_cast<std::string>(height()) + ")").c_str()));
    }
    else if (get_result)
      throw0(DB_ERROR(lmdb_error("Error attempting to retrieve an output pubkey from the db", get_result).c_str()));
 
    if (amount == 0)
    {
      const outkey *okp = (const outkey *)v.mv_data;
      outputs.push_back(okp->data);
    }
    else
    {
      const pre_rct_outkey *okp = (const pre_rct_outkey *)v.mv_data;
      outputs.resize(outputs.size() + 1);
      output_data_t &data = outputs.back();
      memcpy(&data, &okp->data, sizeof(pre_rct_output_data_t));
      data.commitment = rct::zeroCommit(amount);
    }
  }
 
  TXN_POSTFIX_RDONLY();
 
  TIME_MEASURE_FINISH(db3);
  LOG_PRINT_L3("db3: " << db3);
}

Here is the call graph for this function:

get_output_key() [2/2]

output_data_t cryptonote::BlockchainLMDB::get_output_key ( const uint64_t & amount, const uint64_t & index, bool include_commitmemt ) const

virtual

get some of an output's data

The subclass should return the public key, unlock time, and block height for the output with the given amount and index, collected in a struct.

If the output cannot be found, the subclass should throw OUTPUT_DNE.

If any of these parts cannot be found, but some are, the subclass should throw DB_ERROR with a message stating as much.

Parameters

amount	the output amount
index	the output's index (indexed by amount)

Returns

the requested output data

Implements cryptonote::BlockchainDB.

Definition at line 3859 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_amounts);
 
  MDB_val_set(k, amount);
  MDB_val_set(v, index);
  auto get_result = mdb_cursor_get(m_cur_output_amounts, &k, &v, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
    throw1(OUTPUT_DNE(std::string("Attempting to get output pubkey by index, but key does not exist: amount " +
        std::to_string(amount) + ", index " + std::to_string(index)).c_str()));
  else if (get_result)
    throw0(DB_ERROR("Error attempting to retrieve an output pubkey from the db"));
 
  output_data_t ret;
  if (amount == 0)
  {
    const outkey *okp = (const outkey *)v.mv_data;
    ret = okp->data;
  }
  else
  {
    const pre_rct_outkey *okp = (const pre_rct_outkey *)v.mv_data;
    memcpy(&ret, &okp->data, sizeof(pre_rct_output_data_t));;
    if (include_commitmemt)
      ret.commitment = rct::zeroCommit(amount);
  }
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

get_output_tx_and_index() [1/2]

void cryptonote::BlockchainLMDB::get_output_tx_and_index ( const uint64_t & amount, const std::vector< uint64_t > & offsets, std::vector< tx_out_index > & indices ) const

virtual

gets some outputs' tx hashes and indices

This function is a mirror of get_output_tx_and_index(const uint64_t& amount, const uint64_t& index), but for a list of outputs rather than just one.

Parameters

amount	an output amount
offsets	a list of amount-specific output indices
indices	return-by-reference a list of tx hashes and output indices (as pairs)

Implements cryptonote::BlockchainDB.

Definition at line 4615 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  indices.clear();
 
  std::vector <uint64_t> tx_indices;
  tx_indices.reserve(offsets.size());
  TXN_PREFIX_RDONLY();
 
  RCURSOR(output_amounts);
 
  MDB_val_set(k, amount);
  for (const uint64_t &index : offsets)
  {
    MDB_val_set(v, index);
 
    auto get_result = mdb_cursor_get(m_cur_output_amounts, &k, &v, MDB_GET_BOTH);
    if (get_result == MDB_NOTFOUND)
      throw1(OUTPUT_DNE("Attempting to get output by index, but key does not exist"));
    else if (get_result)
      throw0(DB_ERROR(lmdb_error("Error attempting to retrieve an output from the db", get_result).c_str()));
 
    const outkey *okp = (const outkey *)v.mv_data;
    tx_indices.push_back(okp->output_id);
  }
 
  TIME_MEASURE_START(db3);
  if(tx_indices.size() > 0)
  {
    get_output_tx_and_index_from_global(tx_indices, indices);
  }
  TIME_MEASURE_FINISH(db3);
  LOG_PRINT_L3("db3: " << db3);
}

Here is the call graph for this function:

get_output_tx_and_index() [2/2]

tx_out_index cryptonote::BlockchainLMDB::get_output_tx_and_index ( const uint64_t & amount, const uint64_t & index ) const

virtual

gets an output's tx hash and index

The subclass should return the hash of the transaction which created the output with the amount and index given, as well as its index in that transaction.

Parameters

amount	an output amount
index	an output's amount-specific index

Returns

the tx hash and output index

Implements cryptonote::BlockchainDB.

Definition at line 3916 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  std::vector < uint64_t > offsets;
  std::vector<tx_out_index> indices;
  offsets.push_back(index);
  get_output_tx_and_index(amount, offsets, indices);
  if (!indices.size())
    throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
 
  return indices[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_output_tx_and_index_from_global() [1/2]

void cryptonote::BlockchainLMDB::get_output_tx_and_index_from_global ( const std::vector< uint64_t > & global_indices, std::vector< tx_out_index > & tx_out_indices ) const

virtual

Definition at line 4532 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  tx_out_indices.clear();
  tx_out_indices.reserve(global_indices.size());
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_txs);
 
  for (const uint64_t &output_id : global_indices)
  {
    MDB_val_set(v, output_id);
 
    auto get_result = mdb_cursor_get(m_cur_output_txs, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
    if (get_result == MDB_NOTFOUND)
      throw1(OUTPUT_DNE("output with given index not in db"));
    else if (get_result)
      throw0(DB_ERROR("DB error attempting to fetch output tx hash"));
 
    const outtx *ot = (const outtx *)v.mv_data;
    tx_out_indices.push_back(tx_out_index(ot->tx_hash, ot->local_index));
  }
 
  TXN_POSTFIX_RDONLY();
}

Here is the call graph for this function:

get_output_tx_and_index_from_global() [2/2]

tx_out_index cryptonote::BlockchainLMDB::get_output_tx_and_index_from_global ( const uint64_t & index ) const

virtual

gets an output's tx hash and index

The subclass should return the hash of the transaction which created the output with the global index given, as well as its index in that transaction.

Parameters

index

an output's global index

Returns

the tx hash and output index

Implements cryptonote::BlockchainDB.

Definition at line 3893 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(output_txs);
 
  MDB_val_set(v, output_id);
 
  auto get_result = mdb_cursor_get(m_cur_output_txs, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
    throw1(OUTPUT_DNE("output with given index not in db"));
  else if (get_result)
    throw0(DB_ERROR("DB error attempting to fetch output tx hash"));
 
  outtx *ot = (outtx *)v.mv_data;
  tx_out_index ret = tx_out_index(ot->tx_hash, ot->local_index);
 
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_prunable_tx_blob()

bool cryptonote::BlockchainLMDB::get_prunable_tx_blob ( const crypto::hash & h, cryptonote::blobdata & tx ) const

virtual

fetches the prunable transaction blob with the given hash

The subclass should return the prunable transaction stored which has the given hash.

If the transaction does not exist, or if we do not have that prunable data, the subclass should return false.

Parameters

h	the hash to look for

Returns

true iff the transaction was found and we have its prunable data

Implements cryptonote::BlockchainDB.

Definition at line 3721 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
  RCURSOR(txs_prunable);
 
  MDB_val_set(v, h);
  MDB_val result;
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == 0)
  {
    const txindex *tip = (const txindex *)v.mv_data;
    MDB_val_set(val_tx_id, tip->data.tx_id);
    get_result = mdb_cursor_get(m_cur_txs_prunable, &val_tx_id, &result, MDB_SET);
  }
  if (get_result == MDB_NOTFOUND)
    return false;
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx from hash", get_result).c_str()));
 
  bd.assign(reinterpret_cast<char*>(result.mv_data), result.mv_size);
 
  TXN_POSTFIX_RDONLY();
 
  return true;
}

Here is the call graph for this function:

get_prunable_tx_hash()

bool cryptonote::BlockchainLMDB::get_prunable_tx_hash ( const crypto::hash & tx_hash, crypto::hash & prunable_hash ) const

virtual

fetches the prunable transaction hash

The subclass should return the hash of the prunable transaction data.

If the transaction hash does not exist, the subclass should return false.

Parameters

h	the tx hash to look for

Returns

true iff the transaction was found

Implements cryptonote::BlockchainDB.

Definition at line 3751 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
  RCURSOR(txs_prunable_hash);
 
  MDB_val_set(v, tx_hash);
  MDB_val result, val_tx_prunable_hash;
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == 0)
  {
    txindex *tip = (txindex *)v.mv_data;
    MDB_val_set(val_tx_id, tip->data.tx_id);
    get_result = mdb_cursor_get(m_cur_txs_prunable_hash, &val_tx_id, &result, MDB_SET);
  }
  if (get_result == MDB_NOTFOUND)
    return false;
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx prunable hash from tx hash", get_result).c_str()));
 
  prunable_hash = *(const crypto::hash*)result.mv_data;
 
  TXN_POSTFIX_RDONLY();
 
  return true;
}

Here is the call graph for this function:

get_pruned_tx_blob()

bool cryptonote::BlockchainLMDB::get_pruned_tx_blob ( const crypto::hash & h, cryptonote::blobdata & tx ) const

virtual

fetches the pruned transaction blob with the given hash

The subclass should return the pruned transaction stored which has the given hash.

If the transaction does not exist, the subclass should return false.

Parameters

h	the hash to look for

Returns

true iff the transaction was found

Implements cryptonote::BlockchainDB.

Definition at line 3691 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
  RCURSOR(txs_pruned);
 
  MDB_val_set(v, h);
  MDB_val result;
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == 0)
  {
    txindex *tip = (txindex *)v.mv_data;
    MDB_val_set(val_tx_id, tip->data.tx_id);
    get_result = mdb_cursor_get(m_cur_txs_pruned, &val_tx_id, &result, MDB_SET);
  }
  if (get_result == MDB_NOTFOUND)
    return false;
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx from hash", get_result).c_str()));
 
  bd.assign(reinterpret_cast<char*>(result.mv_data), result.mv_size);
 
  TXN_POSTFIX_RDONLY();
 
  return true;
}

Here is the call graph for this function:

get_top_block()

block cryptonote::BlockchainLMDB::get_top_block ( ) const

virtual

fetch the top block

The subclass should return most recent block

Returns

the top block

Implements cryptonote::BlockchainDB.

Definition at line 3517 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  uint64_t m_height = height();
 
  if (m_height != 0)
  {
    return get_block_from_height(m_height - 1);
  }
 
  block b;
  return b;
}

Here is the call graph for this function:

get_top_block_timestamp()

uint64_t cryptonote::BlockchainLMDB::get_top_block_timestamp ( ) const

virtual

fetch the top block's timestamp

The subclass should return the timestamp of the most recent block.

Returns

the top block's timestamp

Implements cryptonote::BlockchainDB.

Definition at line 3173 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  uint64_t m_height = height();
 
  // if no blocks, return 0
  if (m_height == 0)
  {
    return 0;
  }
 
  return get_block_timestamp(m_height - 1);
}

Here is the call graph for this function:

get_tx_amount_output_indices()

std::vector< std::vector< uint64_t > > cryptonote::BlockchainLMDB::get_tx_amount_output_indices ( const uint64_t tx_id, size_t n_txes ) const

virtual

gets output indices (amount-specific) for a transaction's outputs

The subclass should fetch the amount-specific output indices for each output in the transaction with the given ID.

If the transaction does not exist, the subclass should throw TX_DNE.

If an output cannot be found, the subclass should throw OUTPUT_DNE.

Parameters

tx_id	a transaction ID
n_txes	how many txes to get data for, starting with tx_id

Returns

a list of amount-specific output indices

Implements cryptonote::BlockchainDB.

Definition at line 3929 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
 
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_outputs);
 
  MDB_val_set(k_tx_id, tx_id);
  MDB_val v;
  std::vector<std::vector<uint64_t>> amount_output_indices_set;
  amount_output_indices_set.reserve(n_txes);
 
  MDB_cursor_op op = MDB_SET;
  while (n_txes-- > 0)
  {
    int result = mdb_cursor_get(m_cur_tx_outputs, &k_tx_id, &v, op);
    if (result == MDB_NOTFOUND)
      LOG_PRINT_L0("WARNING: Unexpected: tx has no amount indices stored in "
          "tx_outputs, but it should have an empty entry even if it's a tx without "
          "outputs");
    else if (result)
      throw0(DB_ERROR(lmdb_error("DB error attempting to get data for tx_outputs[tx_index]", result).c_str()));
 
    op = MDB_NEXT;
 
    const uint64_t* indices = (const uint64_t*)v.mv_data;
    size_t num_outputs = v.mv_size / sizeof(uint64_t);
 
    amount_output_indices_set.resize(amount_output_indices_set.size() + 1);
    std::vector<uint64_t> &amount_output_indices = amount_output_indices_set.back();
    amount_output_indices.reserve(num_outputs);
    for (size_t i = 0; i < num_outputs; ++i)
    {
      amount_output_indices.push_back(indices[i]);
    }
  }
 
  TXN_POSTFIX_RDONLY();
  return amount_output_indices_set;
}

Here is the call graph for this function:

get_tx_blob()

bool cryptonote::BlockchainLMDB::get_tx_blob ( const crypto::hash & h, cryptonote::blobdata & tx ) const

virtual

fetches the transaction blob with the given hash

The subclass should return the transaction stored which has the given hash.

If the transaction does not exist, the subclass should return false.

Parameters

h	the hash to look for

Returns

true iff the transaction was found

Implements cryptonote::BlockchainDB.

Definition at line 3655 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
  RCURSOR(txs_pruned);
  RCURSOR(txs_prunable);
 
  MDB_val_set(v, h);
  MDB_val result0, result1;
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == 0)
  {
    txindex *tip = (txindex *)v.mv_data;
    MDB_val_set(val_tx_id, tip->data.tx_id);
    get_result = mdb_cursor_get(m_cur_txs_pruned, &val_tx_id, &result0, MDB_SET);
    if (get_result == 0)
    {
      get_result = mdb_cursor_get(m_cur_txs_prunable, &val_tx_id, &result1, MDB_SET);
    }
  }
  if (get_result == MDB_NOTFOUND)
    return false;
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx from hash", get_result).c_str()));
 
  bd.assign(reinterpret_cast<char*>(result0.mv_data), result0.mv_size);
  bd.append(reinterpret_cast<char*>(result1.mv_data), result1.mv_size);
 
  TXN_POSTFIX_RDONLY();
 
  return true;
}

Here is the call graph for this function:

get_tx_block_height()

uint64_t cryptonote::BlockchainLMDB::get_tx_block_height ( const crypto::hash & h ) const

virtual

fetches the height of a transaction's block

The subclass should attempt to return the height of the block containing the transaction with the given hash.

If the transaction cannot be found, the subclass should throw TX_DNE.

Parameters

h	the hash of the transaction

Returns

the height of the transaction's block

Implements cryptonote::BlockchainDB.

Definition at line 3812 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
 
  MDB_val_set(v, h);
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
  {
    throw1(TX_DNE(std::string("tx_data_t with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
  }
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx height from hash", get_result).c_str()));
 
  txindex *tip = (txindex *)v.mv_data;
  uint64_t ret = tip->data.block_id;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_tx_count()

uint64_t cryptonote::BlockchainLMDB::get_tx_count ( ) const

virtual

fetches the total number of transactions ever

The subclass should return a count of all the transactions from all blocks.

Returns

the number of transactions in the blockchain

Implements cryptonote::BlockchainDB.

Definition at line 3781 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  int result;
 
  MDB_stat db_stats;
  if ((result = mdb_stat(m_txn, m_txs_pruned, &db_stats)))
    throw0(DB_ERROR(lmdb_error("Failed to query m_txs_pruned: ", result).c_str()));
 
  TXN_POSTFIX_RDONLY();
 
  return db_stats.ms_entries;
}

Here is the call graph for this function:

get_tx_input()

tx_input_t cryptonote::BlockchainLMDB::get_tx_input ( const crypto::hash tx_hash, const uint32_t relative_out_index )

virtual

Implements cryptonote::BlockchainDB.

Definition at line 1973 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  std::string hex_hash;
  hex_hash = epee::string_tools::pod_to_hex(tx_hash);
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_inputs)
 
  chainstate_key_t key;
  key.tx_hash = tx_hash;
  key.relative_out_index = relative_out_index;
 
  MDB_val k = {sizeof(key), (void *)&key};
  MDB_val v;
  auto result = mdb_cursor_get(m_cur_tx_inputs, &k, &v, MDB_SET_KEY);
  if (result == MDB_NOTFOUND)
    return tx_input_t();
  if (result != 0)
    throw1(DB_ERROR(lmdb_error("Error finding tx input: ", result).c_str()));
 
  TXN_POSTFIX_RDONLY();
  return *(const tx_input_t *) v.mv_data;
}

Here is the call graph for this function:

get_tx_list()

std::vector< transaction > cryptonote::BlockchainLMDB::get_tx_list ( const std::vector< crypto::hash > & hlist ) const

virtual

fetches a list of transactions based on their hashes

The subclass should attempt to fetch each transaction referred to by the hashes passed.

Currently, if any of the transactions is not in BlockchainDB, the call to get_tx in the implementation will throw TX_DNE.

Parameters

hlist

a list of hashes

Returns

the list of transactions

Implements cryptonote::BlockchainDB.

Definition at line 3798 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  std::vector<transaction> v;
 
  for (auto& h : hlist)
  {
    v.push_back(get_tx(h));
  }
 
  return v;
}

Here is the call graph for this function:

get_tx_unlock_time()

uint64_t cryptonote::BlockchainLMDB::get_tx_unlock_time ( const crypto::hash & h ) const

virtual

fetch a transaction's unlock time/height

The subclass should return the stored unlock time for the transaction with the given hash.

If no such transaction exists, the subclass should throw TX_DNE.

Parameters

h	the hash of the requested transaction

Returns

the unlock time/height

Implements cryptonote::BlockchainDB.

Definition at line 3634 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
 
  MDB_val_set(v, h);
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  if (get_result == MDB_NOTFOUND)
    throw1(TX_DNE(lmdb_error(std::string("tx data with hash ") + epee::string_tools::pod_to_hex(h) + " not found in db: ", get_result).c_str()));
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch tx data from hash: ", get_result).c_str()));
 
  txindex *tip = (txindex *)v.mv_data;
  uint64_t ret = tip->data.unlock_time;
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

get_txpool_tx_blob() [1/2]

cryptonote::blobdata cryptonote::BlockchainLMDB::get_txpool_tx_blob ( const crypto::hash & txid ) const

virtual

get a txpool transaction's blob

Parameters

txid	the transaction id of the transation to lookup

Returns

the blob for that transaction

Implements cryptonote::BlockchainDB.

Definition at line 2600 of file db_lmdb.cpp.

{
  cryptonote::blobdata bd;
  if (!get_txpool_tx_blob(txid, bd))
    throw1(DB_ERROR("Tx not found in txpool: "));
  return bd;
}

Here is the call graph for this function:

get_txpool_tx_blob() [2/2]

bool cryptonote::BlockchainLMDB::get_txpool_tx_blob ( const crypto::hash & txid, cryptonote::blobdata & bd ) const

virtual

get a txpool transaction's blob

Parameters

txid	the transaction id of the transation to lookup
bd	the blob to return

Returns

true if the txid was in the txpool, false otherwise

Implements cryptonote::BlockchainDB.

Definition at line 2579 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(txpool_blob)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  MDB_val v;
  auto result = mdb_cursor_get(m_cur_txpool_blob, &k, &v, MDB_SET);
  if (result == MDB_NOTFOUND)
    return false;
  if (result != 0)
      throw1(DB_ERROR(lmdb_error("Error finding txpool tx blob: ", result).c_str()));
 
  bd.assign(reinterpret_cast<const char*>(v.mv_data), v.mv_size);
  TXN_POSTFIX_RDONLY();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_txpool_tx_count()

uint64_t cryptonote::BlockchainLMDB::get_txpool_tx_count ( bool include_unrelayed_txes = true ) const

virtual

get the number of transactions in the txpool

Implements cryptonote::BlockchainDB.

Definition at line 2467 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  int result;
  uint64_t num_entries = 0;
 
  TXN_PREFIX_RDONLY();
 
  if (include_unrelayed_txes)
  {
    // No filtering, we can get the number of tx the "fast" way
    MDB_stat db_stats;
    if ((result = mdb_stat(m_txn, m_txpool_meta, &db_stats)))
      throw0(DB_ERROR(lmdb_error("Failed to query m_txpool_meta: ", result).c_str()));
    num_entries = db_stats.ms_entries;
  }
  else
  {
    // Filter unrelayed tx out of the result, so we need to loop over transactions and check their meta data
    RCURSOR(txpool_meta);
    RCURSOR(txpool_blob);
 
    MDB_val k;
    MDB_val v;
    MDB_cursor_op op = MDB_FIRST;
    while (1)
    {
      result = mdb_cursor_get(m_cur_txpool_meta, &k, &v, op);
      op = MDB_NEXT;
      if (result == MDB_NOTFOUND)
        break;
      if (result)
        throw0(DB_ERROR(lmdb_error("Failed to enumerate txpool tx metadata: ", result).c_str()));
      const txpool_tx_meta_t &meta = *(const txpool_tx_meta_t*)v.mv_data;
      if (!meta.do_not_relay)
        ++num_entries;
    }
  }
  TXN_POSTFIX_RDONLY();
 
  return num_entries;
}

Here is the call graph for this function:

get_txpool_tx_meta()

bool cryptonote::BlockchainLMDB::get_txpool_tx_meta ( const crypto::hash & txid, txpool_tx_meta_t & meta ) const

virtual

get a txpool transaction's metadata

Parameters

txid	the transaction id of the transation to lookup
meta	the metadata to return

Returns

true if the tx meta was found, false otherwise

Implements cryptonote::BlockchainDB.

Definition at line 2558 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(txpool_meta)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  MDB_val v;
  auto result = mdb_cursor_get(m_cur_txpool_meta, &k, &v, MDB_SET);
  if (result == MDB_NOTFOUND)
      return false;
  if (result != 0)
      throw1(DB_ERROR(lmdb_error("Error finding txpool tx meta: ", result).c_str()));
 
  meta = *(const txpool_tx_meta_t*)v.mv_data;
  TXN_POSTFIX_RDONLY();
  return true;
}

Here is the call graph for this function:

has_key_image()

bool cryptonote::BlockchainLMDB::has_key_image ( const crypto::key_image & img ) const

virtual

check if a key image is stored as spent

Parameters

img	the key image to check for

Returns

true if the image is present, otherwise false

Implements cryptonote::BlockchainDB.

Definition at line 3972 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  bool ret;
 
  TXN_PREFIX_RDONLY();
  RCURSOR(spent_keys);
 
  MDB_val k = {sizeof(img), (void *)&img};
  ret = (mdb_cursor_get(m_cur_spent_keys, (MDB_val *)&zerokval, &k, MDB_GET_BOTH) == 0);
 
  TXN_POSTFIX_RDONLY();
  return ret;
}

Here is the call graph for this function:

height()

uint64_t cryptonote::BlockchainLMDB::height ( ) const

virtual

fetch the current blockchain height

The subclass should return the current blockchain height

Returns

the current blockchain height

Implements cryptonote::BlockchainDB.

Definition at line 3532 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  TXN_PREFIX_RDONLY();
  int result;
 
  // get current height
  MDB_stat db_stats;
  if ((result = mdb_stat(m_txn, m_blocks, &db_stats)))
    throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
  return db_stats.ms_entries;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lock()

bool cryptonote::BlockchainLMDB::lock ( )

virtual

acquires the BlockchainDB lock

This function is a stub until such a time as locking is implemented at this level.

The subclass implementation should return true unless implementing a locking scheme of some sort, in which case it should return true upon acquisition of the lock and block until then.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Returns

true, unless at a future time false makes sense (timeout, etc)

Implements cryptonote::BlockchainDB.

Definition at line 1763 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  return false;
}

open()

void cryptonote::BlockchainLMDB::open ( const std::string & filename, const int db_flags = 0 )

virtual

open a db, or create it if necessary.

This function opens an existing database or creates it if it does not exist.

The subclass implementing this will handle all file opening/creation, and is responsible for maintaining its state.

The parameter <filename> may not refer to a file name, necessarily, but could be an IP:PORT for a database which needs it, and so on. Calling it <filename> is convenient and should be descriptive enough, however.

For now, db_flags are specific to the subclass being instantiated. This is subject to change, and the db_flags parameter may be deprecated.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Parameters

filename	a string referring to the BlockchainDB to open
db_flags	flags relevant to how to open/use the BlockchainDB

Implements cryptonote::BlockchainDB.

Definition at line 1357 of file db_lmdb.cpp.

{
  int result;
  int mdb_flags = MDB_NORDAHEAD;
 
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
 
  if (m_open)
    throw0(DB_OPEN_FAILURE("Attempted to open db, but it's already open"));
 
  boost::filesystem::path direc(filename);
  if (boost::filesystem::exists(direc))
  {
    if (!boost::filesystem::is_directory(direc))
      throw0(DB_OPEN_FAILURE("LMDB needs a directory path, but a file was passed"));
  }
  else
  {
    if (!boost::filesystem::create_directories(direc))
      throw0(DB_OPEN_FAILURE(std::string("Failed to create directory ").append(filename).c_str()));
  }
 
  // check for existing LMDB files in base directory
  boost::filesystem::path old_files = direc.parent_path();
  if (boost::filesystem::exists(old_files / CRYPTONOTE_BLOCKCHAINDATA_FILENAME)
      || boost::filesystem::exists(old_files / CRYPTONOTE_BLOCKCHAINDATA_LOCK_FILENAME))
  {
    LOG_PRINT_L0("Found existing LMDB files in " << old_files.string());
    LOG_PRINT_L0("Move " << CRYPTONOTE_BLOCKCHAINDATA_FILENAME << " and/or " << CRYPTONOTE_BLOCKCHAINDATA_LOCK_FILENAME << " to " << filename << ", or delete them, and then restart");
    throw DB_ERROR("Database could not be opened");
  }
 
  boost::optional<bool> is_hdd_result = tools::is_hdd(filename.c_str());
  if (is_hdd_result)
  {
    if (is_hdd_result.value())
        MCLOG_RED(el::Level::Warning, "global", "The blockchain is on a rotating drive: this will be very slow, use an SSD if possible");
  }
 
  m_folder = filename;
 
#ifdef __OpenBSD__
  if ((mdb_flags & MDB_WRITEMAP) == 0) {
    MCLOG_RED(el::Level::Info, "global", "Running on OpenBSD: forcing WRITEMAP");
    mdb_flags |= MDB_WRITEMAP;
  }
#endif
  // set up lmdb environment
  if ((result = mdb_env_create(&m_env)))
    throw0(DB_ERROR(lmdb_error("Failed to create lmdb environment: ", result).c_str()));
  if ((result = mdb_env_set_maxdbs(m_env, 26)))
    throw0(DB_ERROR(lmdb_error("Failed to set max number of dbs: ", result).c_str()));
 
  int threads = tools::get_max_concurrency();
  if (threads > 110 &&  /* maxreaders default is 126, leave some slots for other read processes */
    (result = mdb_env_set_maxreaders(m_env, threads+16)))
    throw0(DB_ERROR(lmdb_error("Failed to set max number of readers: ", result).c_str()));
 
  size_t mapsize = DEFAULT_MAPSIZE;
 
  if (db_flags & DBF_FAST)
    mdb_flags |= MDB_NOSYNC;
  if (db_flags & DBF_FASTEST)
    mdb_flags |= MDB_NOSYNC | MDB_WRITEMAP | MDB_MAPASYNC;
  if (db_flags & DBF_RDONLY)
    mdb_flags = MDB_RDONLY;
  if (db_flags & DBF_SALVAGE)
    mdb_flags |= MDB_PREVSNAPSHOT;
 
  if (auto result = mdb_env_open(m_env, filename.c_str(), mdb_flags, 0644))
    throw0(DB_ERROR(lmdb_error("Failed to open lmdb environment: ", result).c_str()));
 
  MDB_envinfo mei;
  mdb_env_info(m_env, &mei);
  uint64_t cur_mapsize = (uint64_t)mei.me_mapsize;
 
  if (cur_mapsize < mapsize)
  {
    if (auto result = mdb_env_set_mapsize(m_env, mapsize))
      throw0(DB_ERROR(lmdb_error("Failed to set max memory map size: ", result).c_str()));
    mdb_env_info(m_env, &mei);
    cur_mapsize = (uint64_t)mei.me_mapsize;
    LOG_PRINT_L1("LMDB memory map size: " << cur_mapsize);
  }
 
  if (need_resize())
  {
    LOG_PRINT_L0("LMDB memory map needs to be resized, doing that now.");
    do_resize();
  }
 
  int txn_flags = 0;
  if (mdb_flags & MDB_RDONLY)
    txn_flags |= MDB_RDONLY;
 
  // get a read/write MDB_txn, depending on mdb_flags
  mdb_txn_safe txn;
  if (auto mdb_res = mdb_txn_begin(m_env, NULL, txn_flags, txn))
    throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", mdb_res).c_str()));
 
  // open necessary databases, and set properties as needed
  // uses macros to avoid having to change things too many places
  // also change blockchain_prune.cpp to match
  lmdb_db_open(txn, LMDB_BLOCKS, MDB_INTEGERKEY | MDB_CREATE, m_blocks, "Failed to open db handle for m_blocks");
 
  lmdb_db_open(txn, LMDB_BLOCK_INFO, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_block_info, "Failed to open db handle for m_block_info");
  lmdb_db_open(txn, LMDB_BLOCK_HEIGHTS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_block_heights, "Failed to open db handle for m_block_heights");
 
  lmdb_db_open(txn, LMDB_TXS, MDB_INTEGERKEY | MDB_CREATE, m_txs, "Failed to open db handle for m_txs");
  lmdb_db_open(txn, LMDB_TXS_PRUNED, MDB_INTEGERKEY | MDB_CREATE, m_txs_pruned, "Failed to open db handle for m_txs_pruned");
  lmdb_db_open(txn, LMDB_TXS_PRUNABLE, MDB_INTEGERKEY | MDB_CREATE, m_txs_prunable, "Failed to open db handle for m_txs_prunable");
  lmdb_db_open(txn, LMDB_TXS_PRUNABLE_HASH, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_txs_prunable_hash, "Failed to open db handle for m_txs_prunable_hash");
  if (!(mdb_flags & MDB_RDONLY))
    lmdb_db_open(txn, LMDB_TXS_PRUNABLE_TIP, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_txs_prunable_tip, "Failed to open db handle for m_txs_prunable_tip");
  lmdb_db_open(txn, LMDB_TX_INDICES, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_tx_indices, "Failed to open db handle for m_tx_indices");
  lmdb_db_open(txn, LMDB_TX_OUTPUTS, MDB_INTEGERKEY | MDB_CREATE, m_tx_outputs, "Failed to open db handle for m_tx_outputs");
 
  lmdb_db_open(txn, LMDB_OUTPUT_TXS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_output_txs, "Failed to open db handle for m_output_txs");
  lmdb_db_open(txn, LMDB_OUTPUT_AMOUNTS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_output_amounts, "Failed to open db handle for m_output_amounts");
 
  lmdb_db_open(txn, LMDB_SPENT_KEYS, MDB_INTEGERKEY | MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_spent_keys, "Failed to open db handle for m_spent_keys");
 
  lmdb_db_open(txn, LMDB_TXPOOL_META, MDB_CREATE, m_txpool_meta, "Failed to open db handle for m_txpool_meta");
  lmdb_db_open(txn, LMDB_TXPOOL_BLOB, MDB_CREATE, m_txpool_blob, "Failed to open db handle for m_txpool_blob");
 
  // this subdb is dropped on sight, so it may not be present when we open the DB.
  // Since we use MDB_CREATE, we'll get an exception if we open read-only and it does not exist.
  // So we don't open for read-only, and also not drop below. It is not used elsewhere.
  if (!(mdb_flags & MDB_RDONLY))
    lmdb_db_open(txn, LMDB_HF_STARTING_HEIGHTS, MDB_CREATE, m_hf_starting_heights, "Failed to open db handle for m_hf_starting_heights");
 
  lmdb_db_open(txn, LMDB_HF_VERSIONS, MDB_INTEGERKEY | MDB_CREATE, m_hf_versions, "Failed to open db handle for m_hf_versions");
 
  lmdb_db_open(txn, LMDB_VALIDATORS, MDB_INTEGERKEY | MDB_CREATE, m_validators, "Failed to open db handle for m_validators");
  lmdb_db_open(txn, LMDB_UTXOS, MDB_CREATE, m_utxos, "Failed to open db handle for m_utxos");
  lmdb_db_open(txn, LMDB_ADDR_OUTPUTS, MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_addr_outputs, "Failed to open db handle for m_addr_outputs");
  lmdb_db_open(txn, LMDB_ADDR_TXS, MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_addr_txs, "Failed to open db handle for m_addr_txs");
  lmdb_db_open(txn, LMDB_ADDR_TXS_OLD, MDB_CREATE | MDB_DUPSORT | MDB_DUPFIXED, m_addr_txs_old, "Failed to open db handle for m_addr_txs_old");
  if(db_flags & DBF_ADDR_TX_SALVAGE) {
    mdb_drop(txn, m_addr_txs, 0);
    mdb_drop(txn, m_addr_txs_old, 1);
  }
  lmdb_db_open(txn, LMDB_TX_INPUTS, MDB_CREATE, m_tx_inputs, "Failed to open db handle for m_tx_inputs");
  lmdb_db_open(txn, LMDB_PROPERTIES, MDB_CREATE, m_properties, "Failed to open db handle for m_properties");
 
  mdb_set_dupsort(txn, m_spent_keys, compare_hash32);
  mdb_set_dupsort(txn, m_block_heights, compare_hash32);
  mdb_set_dupsort(txn, m_tx_indices, compare_hash32);
  mdb_set_dupsort(txn, m_output_amounts, compare_uint64);
  mdb_set_dupsort(txn, m_output_txs, compare_uint64);
  mdb_set_dupsort(txn, m_block_info, compare_uint64);
  if (!(mdb_flags & MDB_RDONLY))
    mdb_set_dupsort(txn, m_txs_prunable_tip, compare_uint64);
  mdb_set_compare(txn, m_txs_prunable, compare_uint64);
  mdb_set_dupsort(txn, m_txs_prunable_hash, compare_uint64);
 
  mdb_set_compare(txn, m_utxos, compare_data);
  mdb_set_compare(txn, m_txpool_meta, compare_hash32);
  mdb_set_compare(txn, m_txpool_blob, compare_hash32);
  mdb_set_compare(txn, m_properties, compare_string);
 
  mdb_set_dupsort(txn, m_addr_outputs, compare_uint64);
  mdb_set_compare(txn, m_addr_outputs, compare_publickey);
 
  mdb_set_dupsort(txn, m_addr_txs, compare_uint64);
  mdb_set_compare(txn, m_addr_txs, compare_publickey);
 
  mdb_set_dupsort(txn, m_addr_txs_old, compare_uint64);
  mdb_set_compare(txn, m_addr_txs_old, compare_publickey);
 
  mdb_set_compare(txn, m_tx_inputs, compare_data);
 
 
  if (!(mdb_flags & MDB_RDONLY))
  {
    result = mdb_drop(txn, m_hf_starting_heights, 1);
    if (result && result != MDB_NOTFOUND)
      throw0(DB_ERROR(lmdb_error("Failed to drop m_hf_starting_heights: ", result).c_str()));
  }
 
  // get and keep current height
  MDB_stat db_stats;
  if ((result = mdb_stat(txn, m_blocks, &db_stats)))
    throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
  LOG_PRINT_L2("Setting m_height to: " << db_stats.ms_entries);
  uint64_t m_height = db_stats.ms_entries;
 
  bool compatible = true;
 
  MDB_val_str(k, "version");
  MDB_val v;
  auto get_result = mdb_get(txn, m_properties, &k, &v);
  if(get_result == MDB_SUCCESS)
  {
    const uint32_t db_version = *(const uint32_t*)v.mv_data;
    if (db_version > VERSION)
    {
      MWARNING("Existing lmdb database was made by a later version (" << db_version << "). We don't know how it will change yet.");
      compatible = false;
    }
#if VERSION > 0
    else if (db_version < VERSION)
    {
      if (mdb_flags & MDB_RDONLY)
      {
        txn.abort();
        mdb_env_close(m_env);
        m_open = false;
        MFATAL("Existing lmdb database needs to be converted, which cannot be done on a read-only database.");
        MFATAL("Please run electroneumd once to convert the database.");
        return;
      }
      // Note that there was a schema change within version 0 as well.
      // See commit e5d2680094ee15889934fe28901e4e133cda56f2 2015/07/10
      // We don't handle the old format previous to that commit.
      txn.commit();
      m_open = true;
      migrate(db_version);
      return;
    }
#endif
  }
  else
  {
    // if not found, and the DB is non-empty, this is probably
    // an "old" version 0, which we don't handle. If the DB is
    // empty it's fine.
    if (VERSION > 0 && m_height > 0)
      compatible = false;
  }
 
  if (!compatible)
  {
    txn.abort();
    mdb_env_close(m_env);
    m_open = false;
    MFATAL("Existing lmdb database is incompatible with this version.");
    MFATAL("Please delete the existing database and resync.");
    return;
  }
 
  if (!(mdb_flags & MDB_RDONLY))
  {
    // only write version on an empty DB
    if (m_height == 0)
    {
      MDB_val_str(k, "version");
      MDB_val_copy<uint32_t> v(VERSION);
      auto put_result = mdb_put(txn, m_properties, &k, &v, 0);
      if (put_result != MDB_SUCCESS)
      {
        txn.abort();
        mdb_env_close(m_env);
        m_open = false;
        MERROR("Failed to write version to database.");
        return;
      }
    }
  }
 
  // commit the transaction
  txn.commit();
 
  m_open = true;
  // from here, init should be finished
}

Here is the call graph for this function:

pop_block()

void cryptonote::BlockchainLMDB::pop_block ( block & blk, std::vector< transaction > & txs )

virtual

pops the top block off the blockchain

The subclass should remove the most recent block from the blockchain, along with all transactions, outputs, and other metadata created as a result of its addition to the blockchain. Most of this is handled by the concrete members of the base class provided the subclass correctly implements remove_* functions.

The subclass should return by reference the popped block and its associated transactions

Parameters

blk	return-by-reference the block which was popped
txs	return-by-reference the transactions from the popped block

Reimplemented from cryptonote::BlockchainDB.

Definition at line 4513 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  block_wtxn_start();
 
  try
  {
    BlockchainDB::pop_block(blk, txs);
    block_wtxn_stop();
  }
  catch (...)
  {
    block_wtxn_abort();
    throw;
  }
}

Here is the call graph for this function:

prune_blockchain()

bool cryptonote::BlockchainLMDB::prune_blockchain ( uint32_t pruning_seed = 0 )

virtual

prunes the blockchain

Parameters

pruning_seed

the seed to use, 0 for default (highly recommended)

Returns

success iff true

Implements cryptonote::BlockchainDB.

Definition at line 2926 of file db_lmdb.cpp.

{
  return prune_worker(prune_mode_prune, pruning_seed);
}

remove_data_file()

bool cryptonote::BlockchainLMDB::remove_data_file ( const std::string & folder ) const

virtual

remove file(s) storing the database

This function is for resetting the database (for core tests, functional tests, etc). The function reset() is not usable because it needs to open the database file first which can fail if the existing database file is in an incompatible format. As such, this function needs to be called before calling open().

Parameters

folder

The path of the folder containing the database file(s) which must not end with slash '/'.

Returns

true if the operation is succesfull

Implements cryptonote::BlockchainDB.

Definition at line 1740 of file db_lmdb.cpp.

{
  const std::string filename = folder + "/data.mdb";
  try
  {
    boost::filesystem::remove(filename);
  }
  catch (const std::exception &e)
  {
    MERROR("Failed to remove " << filename << ": " << e.what());
    return false;
  }
  return true;
}

remove_txpool_tx()

void cryptonote::BlockchainLMDB::remove_txpool_tx ( const crypto::hash & txid )

virtual

remove a txpool transaction

Parameters

txid	the transaction id of the transation to remove

Implements cryptonote::BlockchainDB.

Definition at line 2528 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  mdb_txn_cursors *m_cursors = &m_wcursors;
 
  CURSOR(txpool_meta)
  CURSOR(txpool_blob)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  auto result = mdb_cursor_get(m_cur_txpool_meta, &k, NULL, MDB_SET);
  if (result != 0 && result != MDB_NOTFOUND)
    throw1(DB_ERROR(lmdb_error("Error finding txpool tx meta to remove: ", result).c_str()));
  if (!result)
  {
    result = mdb_cursor_del(m_cur_txpool_meta, 0);
    if (result)
      throw1(DB_ERROR(lmdb_error("Error adding removal of txpool tx metadata to db transaction: ", result).c_str()));
  }
  result = mdb_cursor_get(m_cur_txpool_blob, &k, NULL, MDB_SET);
  if (result != 0 && result != MDB_NOTFOUND)
    throw1(DB_ERROR(lmdb_error("Error finding txpool tx blob to remove: ", result).c_str()));
  if (!result)
  {
    result = mdb_cursor_del(m_cur_txpool_blob, 0);
    if (result)
      throw1(DB_ERROR(lmdb_error("Error adding removal of txpool tx blob to db transaction: ", result).c_str()));
  }
}

Here is the call graph for this function:

reset()

void cryptonote::BlockchainLMDB::reset ( )

virtual

Remove everything from the BlockchainDB.

This function should completely remove all data from a BlockchainDB.

Use with caution!

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 1662 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  mdb_txn_safe txn;
  if (auto result = lmdb_txn_begin(m_env, NULL, 0, txn))
    throw0(DB_ERROR(lmdb_error("Failed to create a transaction for the db: ", result).c_str()));
 
  if (auto result = mdb_drop(txn, m_blocks, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_blocks: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_block_info, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_block_info: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_block_heights, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_block_heights: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_txs_pruned, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_txs_pruned: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_txs_prunable, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_txs_prunable: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_txs_prunable_hash, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_txs_prunable_hash: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_txs_prunable_tip, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_txs_prunable_tip: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_tx_indices, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_tx_indices: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_tx_outputs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_tx_outputs: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_output_txs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_output_txs: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_output_amounts, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_output_amounts: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_spent_keys, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_spent_keys: ", result).c_str()));
  (void)mdb_drop(txn, m_hf_starting_heights, 0); // this one is dropped in new code
  if (auto result = mdb_drop(txn, m_hf_versions, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_hf_versions: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_validators, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_validators: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_utxos, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_utxos: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_addr_outputs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_addr_outputs: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_addr_txs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_addr_txs: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_addr_txs_old, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_addr_txs_old: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_tx_inputs, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_tx_inputs: ", result).c_str()));
  if (auto result = mdb_drop(txn, m_properties, 0))
    throw0(DB_ERROR(lmdb_error("Failed to drop m_properties: ", result).c_str()));
 
  // init with current version
  MDB_val_str(k, "version");
  MDB_val_copy<uint32_t> v(VERSION);
  if (auto result = mdb_put(txn, m_properties, &k, &v, 0))
    throw0(DB_ERROR(lmdb_error("Failed to write version to database: ", result).c_str()));
 
  txn.commit();
  m_cum_size = 0;
  m_cum_count = 0;
}

Here is the call graph for this function:

safesyncmode()

void cryptonote::BlockchainLMDB::safesyncmode ( const bool onoff )

virtual

toggle safe syncs for the DB

Used to switch DBF_SAFE on or off after starting up with DBF_FAST.

Implements cryptonote::BlockchainDB.

Definition at line 1656 of file db_lmdb.cpp.

{
  MINFO("switching safe mode " << (onoff ? "on" : "off"));
  mdb_env_set_flags(m_env, MDB_NOSYNC|MDB_MAPASYNC, !onoff);
}

Here is the call graph for this function:

set_batch_transactions()

void cryptonote::BlockchainLMDB::set_batch_transactions ( bool )

virtual

sets whether or not to batch transactions

If the subclass implements batching, this function tells it to begin batching automatically.

If the subclass implements batching and has a batch in-progress, a parameter of false should disable batching and call batch_stop() to store the current batch.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Parameters

bool	batch whether or not to use batch transactions.

Implements cryptonote::BlockchainDB.

Definition at line 4343 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  if ((batch_transactions) && (m_batch_transactions))
  {
    MINFO("batch transaction mode already enabled, but asked to enable batch mode");
  }
  m_batch_transactions = batch_transactions;
  MINFO("batch transactions " << (m_batch_transactions ? "enabled" : "disabled"));
}

set_block_cumulative_difficulty()

void cryptonote::BlockchainLMDB::set_block_cumulative_difficulty ( uint64_t height, difficulty_type diff )

virtual

sets a block's cumulative difficulty

The subclass should return true if the cumulative difficulty is set successfully

If the block does not exist, the subclass should throw BLOCK_DNE

Parameters

height	the height requested
diff	the cumulative difficulty value to be set

Returns

true | false

Implements cryptonote::BlockchainDB.

Definition at line 3327 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__ << "  height: " << height);
  check_open();
  mdb_txn_cursors *m_cursors = &m_wcursors;
 
  int result;
 
  CURSOR(block_info)
 
  MDB_val_set(val_bi, height);
  result = mdb_cursor_get(m_cur_block_info, (MDB_val *)&zerokval, &val_bi, MDB_GET_BOTH);
  if (result == MDB_NOTFOUND)
  {
    throw0(BLOCK_DNE(std::string("Attempt to set cumulative difficulty from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- difficulty not in db").c_str()));
  }
  else if (result)
    throw0(DB_ERROR("Error attempting to set a cumulative difficulty"));
 
  mdb_block_info *result_bi = (mdb_block_info *)val_bi.mv_data;
 
  mdb_block_info bi;
  bi.bi_height = result_bi->bi_height;
  bi.bi_timestamp = result_bi->bi_timestamp;
  bi.bi_coins = result_bi->bi_coins;
  bi.bi_weight = result_bi->bi_weight;
  //bi.bi_diff_lo = diff; // TODO
  bi.bi_hash = result_bi->bi_hash;
 
  MDB_val_set(val, bi);
  result = mdb_cursor_put(m_cur_block_info, (MDB_val *)&val_bi, &val, MDB_CURRENT);
  if (result)
    throw0(DB_ERROR(lmdb_error("Failed to set cumulative difficulty to db transaction: ", result).c_str()));
 
}

Here is the call graph for this function:

sync()

void cryptonote::BlockchainLMDB::sync ( )

virtual

sync the BlockchainDB with disk

This function should write any changes to whatever permanent backing store the subclass uses. Example: a BlockchainDB instance which keeps the whole blockchain in RAM won't need to regularly access a disk, but should write out its state when this is called.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 1640 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  if (is_read_only())
    return;
 
  // Does nothing unless LMDB environment was opened with MDB_NOSYNC or in part
  // MDB_NOMETASYNC. Force flush to be synchronous.
  if (auto result = mdb_env_sync(m_env, true))
  {
    throw0(DB_ERROR(lmdb_error("Failed to sync database: ", result).c_str()));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

top_block_hash()

crypto::hash cryptonote::BlockchainLMDB::top_block_hash ( uint64_t * block_height = NULL ) const

virtual

fetch the top block's hash

The subclass should return the hash of the most recent block

Parameters

block_height

if non NULL, returns the height of that block (ie, the blockchain height minus 1)

Returns

the top block's hash

Implements cryptonote::BlockchainDB.

Definition at line 3502 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  uint64_t m_height = height();
  if (block_height)
    *block_height = m_height - 1;
  if (m_height != 0)
  {
    return get_block_hash_from_height(m_height - 1);
  }
 
  return null_hash;
}

Here is the call graph for this function:

tx_exists() [1/2]

bool cryptonote::BlockchainLMDB::tx_exists ( const crypto::hash & h ) const

virtual

check if a transaction with a given hash exists

The subclass should check if a transaction is stored which has the given hash and return true if so, false otherwise.

Parameters

h	the hash to check against
tx_id	(optional) returns the tx_id for the tx hash

Returns

true if the transaction exists, otherwise false

Implements cryptonote::BlockchainDB.

Definition at line 3568 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
 
  MDB_val_set(key, h);
  bool tx_found = false;
 
  TIME_MEASURE_START(time1);
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &key, MDB_GET_BOTH);
  if (get_result == 0)
    tx_found = true;
  else if (get_result != MDB_NOTFOUND)
    throw0(DB_ERROR(lmdb_error(std::string("DB error attempting to fetch transaction index from hash ") + epee::string_tools::pod_to_hex(h) + ": ", get_result).c_str()));
 
  TIME_MEASURE_FINISH(time1);
  time_tx_exists += time1;
 
  TXN_POSTFIX_RDONLY();
 
  if (! tx_found)
  {
    LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

tx_exists() [2/2]

bool cryptonote::BlockchainLMDB::tx_exists ( const crypto::hash & h, uint64_t & tx_index ) const

virtual

Implements cryptonote::BlockchainDB.

Definition at line 3600 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(tx_indices);
 
  MDB_val_set(v, h);
 
  TIME_MEASURE_START(time1);
  auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
  TIME_MEASURE_FINISH(time1);
  time_tx_exists += time1;
  if (!get_result) {
    txindex *tip = (txindex *)v.mv_data;
    tx_id = tip->data.tx_id;
  }
 
  TXN_POSTFIX_RDONLY();
 
  bool ret = false;
  if (get_result == MDB_NOTFOUND)
  {
    LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
  }
  else if (get_result)
    throw0(DB_ERROR(lmdb_error("DB error attempting to fetch transaction from hash", get_result).c_str()));
  else
    ret = true;
 
  return ret;
}

Here is the call graph for this function:

txpool_has_tx()

bool cryptonote::BlockchainLMDB::txpool_has_tx ( const crypto::hash & txid ) const

virtual

check whether a txid is in the txpool

Implements cryptonote::BlockchainDB.

Definition at line 2512 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
 
  TXN_PREFIX_RDONLY();
  RCURSOR(txpool_meta)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  auto result = mdb_cursor_get(m_cur_txpool_meta, &k, NULL, MDB_SET);
  if (result != 0 && result != MDB_NOTFOUND)
    throw1(DB_ERROR(lmdb_error("Error finding txpool tx meta: ", result).c_str()));
  TXN_POSTFIX_RDONLY();
  return result != MDB_NOTFOUND;
}

Here is the call graph for this function:

unlock()

void cryptonote::BlockchainLMDB::unlock ( )

virtual

This function releases the BlockchainDB lock.

The subclass, should it have implemented lock(), will release any lock held by the calling thread. In the case of recursive locking, it should release one instance of a lock.

If any of this cannot be done, the subclass should throw the corresponding subclass of DB_EXCEPTION

Implements cryptonote::BlockchainDB.

Definition at line 1771 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
}

update_pruning()

bool cryptonote::BlockchainLMDB::update_pruning ( )

virtual

prunes recent blockchain changes as needed, iff pruning is enabled

Returns

success iff true

Implements cryptonote::BlockchainDB.

Definition at line 2931 of file db_lmdb.cpp.

{
  return prune_worker(prune_mode_update, 0);
}

update_txpool_tx()

void cryptonote::BlockchainLMDB::update_txpool_tx ( const crypto::hash & txid, const txpool_tx_meta_t & details )

virtual

update a txpool transaction's metadata

Parameters

txid	the txid of the transaction to update
details	the details of the transaction to update

Implements cryptonote::BlockchainDB.

Definition at line 2441 of file db_lmdb.cpp.

{
  LOG_PRINT_L3("BlockchainLMDB::" << __func__);
  check_open();
  mdb_txn_cursors *m_cursors = &m_wcursors;
 
  CURSOR(txpool_meta)
  CURSOR(txpool_blob)
 
  MDB_val k = {sizeof(txid), (void *)&txid};
  MDB_val v;
  auto result = mdb_cursor_get(m_cur_txpool_meta, &k, &v, MDB_SET);
  if (result != 0)
    throw1(DB_ERROR(lmdb_error("Error finding txpool tx meta to update: ", result).c_str()));
  result = mdb_cursor_del(m_cur_txpool_meta, 0);
  if (result)
    throw1(DB_ERROR(lmdb_error("Error adding removal of txpool tx metadata to db transaction: ", result).c_str()));
  v = MDB_val({sizeof(meta), (void *)&meta});
  if ((result = mdb_cursor_put(m_cur_txpool_meta, &k, &v, MDB_NODUPDATA)) != 0) {
    if (result == MDB_KEYEXIST)
      throw1(DB_ERROR("Attempting to add txpool tx metadata that's already in the db"));
    else
      throw1(DB_ERROR(lmdb_error("Error adding txpool tx metadata to db transaction: ", result).c_str()));
  }
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/blockchain_db/lmdb/db_lmdb.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/blockchain_db/lmdb/db_lmdb.cpp