{

scanFrom = check_merkle(scanFrom);

if (scanFrom == INT32_MIN)

return;

scan_nocheck(scanFrom);

{

auto topBlock = blockchain_->top();

scrAddrFilter_->updateAddressMerkleInDB();

auto&& subsshSdbi = scrAddrFilter_->getSubSshSDBI();

shared_ptr<BlockHeader> sdbiblock;

//check if we need to scan anything

try

{

sdbiblock =

blockchain_->getHeaderByHash(subsshSdbi.topScannedBlkHash_);

}

catch (...)

{

sdbiblock = blockchain_->getHeaderByHeight(0);

}

if (sdbiblock->isMainBranch())

{

//this will set scanFrom to 0 before an initial scan

if ((int)sdbiblock->getBlockHeight() > scanFrom)

scanFrom = sdbiblock->getBlockHeight();

if (scanFrom > (int)topBlock->getBlockHeight() ||

scrAddrFilter_->getScrAddrMap()->size() == 0)

{

LOGINFO << "no history to scan";

topScannedBlockHash_ = topBlock->getThisHash();

return INT32_MIN;

}

}

return scanFrom;

{

if (scanFrom > (int32_t)db_->blockchain()->top()->getBlockHeight())

return;

TIMER_RESTART("scan_nocheck");

startAt_ = scanFrom;

auto topBlock = blockchain_->top();

preloadUtxos();

auto scrRefMap = scrAddrFilter_->getOutScrRefMap();

//lambdas

auto commitLambda = [this](void)

{ writeBlockData(); };

auto outputsLambda = [this](void)

{ processOutputs(); };

auto inputsLambda = [this](void)

{ processInputs(); };

//start threads

auto commit_tID = thread(commitLambda);

auto outputs_tID = thread(outputsLambda);

auto inputs_tID = thread(inputsLambda);

auto startHeight = scanFrom;

unsigned endHeight = 0;

vector<future<bool>> completedFutures;

unsigned _count = 0;

completedBatches_.store(0, memory_order_relaxed);

//loop until there are no more blocks available

try

{

unsigned firstBlockFileID = UINT32_MAX;

unsigned targetBlockFileID = UINT32_MAX;

while (startHeight <= topBlock->getBlockHeight())

{

//figure out how many blocks to pull for this batch

//batches try to grab up nBlockFilesPerBatch_ worth of block data

unsigned targetHeight = 0;

size_t targetSize = BATCH_SIZE;

size_t tallySize;

try

{

shared_ptr<BlockHeader> currentHeader =

blockchain_->getHeaderByHeight(startHeight);

firstBlockFileID = currentHeader->getBlockFileNum();

targetBlockFileID = 0;

targetHeight = startHeight;

tallySize = currentHeader->getBlockSize();

while (tallySize < targetSize)

{

currentHeader = blockchain_->getHeaderByHeight(++targetHeight);

tallySize += currentHeader->getBlockSize();

if (currentHeader->getBlockFileNum() < firstBlockFileID)

firstBlockFileID = currentHeader->getBlockFileNum();

if (currentHeader->getBlockFileNum() > targetBlockFileID)

targetBlockFileID = currentHeader->getBlockFileNum();

}

}

catch (range_error& e)

{

//if getHeaderByHeight throws before targetHeight is topBlock's height,

//something went wrong. Otherwise we just hit the end of the chain.

if (targetHeight < topBlock->getBlockHeight())

{

LOGERR << e.what();

throw e;

}

else

{

targetHeight = topBlock->getBlockHeight();

if (targetBlockFileID < topBlock->getBlockFileNum())

targetBlockFileID = topBlock->getBlockFileNum();

}

}

endHeight = targetHeight;

//create batch

auto&& batch = make_unique<ParserBatch>(

startHeight, endHeight,

firstBlockFileID, targetBlockFileID,

scrRefMap);

completedFutures.push_back(batch->completedPromise_.get_future());

batch->count_ = _count;

//post for txout parsing

outputQueue_.push_back(move(batch));

if (_count - completedBatches_.load(memory_order_relaxed) >=

writeQueueDepth_)

{

try

{

auto futIter = completedFutures.begin() +

(_count - writeQueueDepth_);

futIter->wait();

}

catch (future_error &e)

{

LOGERR << "future error";

throw e;

}

}

++_count;

startHeight = endHeight + 1;

}

}

catch (range_error&)

{

LOGERR << "failed to grab block data starting height: " << startHeight;

if (startHeight == scanFrom)

LOGERR << "no block data was scanned";

}

catch (...)

{

LOGWARN << "scanning halted unexpectedly";

//let the scan terminate

}

//mark all queues complete

outputQueue_.completed();

if (outputs_tID.joinable())

outputs_tID.join();

if (inputs_tID.joinable())

inputs_tID.join();

if (commit_tID.joinable())

commit_tID.join();

topScannedBlockHash_ = topBlock->getThisHash();

TIMER_STOP("scan_nocheck");

if (topBlock->getBlockHeight() - scanFrom > 100)

{

auto timeSpent = TIMER_READ_SEC("scan_nocheck");

LOGINFO << "scanned transaction history in " << timeSpent << "s";

}

auto timeSpent = TIMER_READ_SEC("throttling");

if (timeSpent > 5)

LOGINFO << "throttling for " << timeSpent << "s";

/*timeSpent = TIMER_READ_SEC("outputs");

{

TIMER_RESET("throttling");

TIMER_RESET("preload");

TIMER_RESET("outputs");

auto process_thread = [this](ParserBatch* batch)->void

{

this->processOutputsThread(batch);

};

map<unsigned, shared_ptr<BlockDataFileMap>> localFileMap;

auto preloadBlockDataFiles = [&](ParserBatch* batch)->void

{

if (batch == nullptr)

return;

TIMER_START("preload");

auto file_id = batch->startBlockFileID_;

while (file_id <= batch->targetBlockFileID_)

{

auto local_iter = localFileMap.find(file_id);

if (local_iter != localFileMap.end())

{

batch->fileMaps_.insert(

make_pair(file_id, local_iter->second));

}

else

{

batch->fileMaps_.insert(

make_pair(file_id, blockDataLoader_.get(file_id)));

}

++file_id;

}

localFileMap = batch->fileMaps_;

TIMER_STOP("preload");

};

//init batch

unique_ptr<ParserBatch> batch;

while (1)

{

try

{

batch = move(outputQueue_.pop_front());

break;

}

catch (StopBlockingLoop&)

{}

}

preloadBlockDataFiles(batch.get());

while (1)

{

//start processing threads

vector<thread> thr_vec;

for (unsigned i = 0; i < totalThreadCount_; i++)

thr_vec.push_back(thread(process_thread, batch.get()));

unique_ptr<ParserBatch> nextBatch;

TIMER_START("throttling");

try

{

nextBatch = move(outputQueue_.pop_front());

}

catch (StopBlockingLoop&)

{}

TIMER_STOP("throttling");

TIMER_START("outputs");

//populate the next batch's file map while the first

//batch is being processed

preloadBlockDataFiles(nextBatch.get());

//wait on threads

for (auto& thr : thr_vec)

{

if (thr.joinable())

thr.join();

}

//push first batch for input processing

inputQueue_.push_back(move(batch));

//exit loop condition

if (nextBatch == nullptr)

{

TIMER_STOP("outputs");

break;

}

//set batch for next iteration

batch = move(nextBatch);

TIMER_STOP("outputs");

}

//done with processing ouputs, there won't be anymore batches to push

//to the input queue, we can mark it complete

inputQueue_.completed();

{

TIMER_RESET("inputs");

auto process_thread = [this](ParserBatch* batch)->void

{

this->processInputsThread(batch);

};

while (1)

{

unique_ptr<ParserBatch> batch;

try

{

batch = move(inputQueue_.pop_front());

}

catch (StopBlockingLoop&)

{

//end condition

break;

}

TIMER_START("inputs");

//reset counter

batch->blockCounter_.store(batch->start_, memory_order_relaxed);

//merge utxo map from batch with global one

//this data needs copied because we still have use for the original map

for (auto& hash_map : batch->outputMap_)

{

auto hash_iter = utxoMap_.find(hash_map.first);

if (hash_iter == utxoMap_.end())

{

utxoMap_.insert(hash_map);

continue;

}

hash_iter->second.insert(

hash_map.second.begin(), hash_map.second.end());

}

//start processing threads

vector<thread> thr_vec;

for (unsigned i = 1; i < totalThreadCount_; i++)

thr_vec.push_back(thread(process_thread, batch.get()));

process_thread(batch.get());

//wait on threads

for (auto& thr : thr_vec)

{

if (thr.joinable())

thr.join();

}

//purge spent outputs from global map

for (auto& spent_txout : batch->spentOutputs_)

{

auto hash_iter = utxoMap_.find(spent_txout.parentHash_);

if (hash_iter == utxoMap_.end())

{

LOGERR << "missing utxo";

continue;

}

auto utxo_iter = hash_iter->second.find(spent_txout.txOutIndex_);

if (utxo_iter == hash_iter->second.end())

{

LOGERR << "missing utxo";

continue;

}

hash_iter->second.erase(utxo_iter);

if (hash_iter->second.size() == 0)

utxoMap_.erase(hash_iter);

}

//push for commit

commitQueue_.push_back(move(batch));

TIMER_STOP("inputs");

}

//done with processing inputs, there won't be anymore batches to push

//to the commit queue, we can mark it complete

commitQueue_.completed();

ParserBatch* batch, unsigned height)

{

//grab block file map

auto blockheader = blockchain_->getHeaderByHeight(height);

auto filenum = blockheader->getBlockFileNum();

auto mapIter = batch->fileMaps_.find(filenum);

if (mapIter == batch->fileMaps_.end())

{

LOGERR << "Missing file map for output scan, this is unexpected";

LOGERR << "Has the following block files:";

for (auto& file_pair : batch->fileMaps_)

LOGERR << " --- #" << file_pair.first;

LOGERR << "Was looking for id #" << filenum;

throw runtime_error("missing file map");

}

auto filemap = mapIter->second.get();

//find block and deserialize it

auto getID = [blockheader](const BinaryData&)->unsigned int

{

return blockheader->getThisID();

};

auto bdata = make_shared<BlockData>();

bdata->deserialize(

filemap->getPtr() + blockheader->getOffset(),

blockheader->getBlockSize(),

blockheader, getID, false, false);

return bdata;

{

map<unsigned, shared_ptr<BlockData>> blockMap;

map<BinaryData, map<unsigned, StoredTxOut>> outputMap;

map<BinaryData, map<BinaryData, StoredSubHistory>> sshMap;

while (1)

{

auto currentBlock =

batch->blockCounter_.fetch_add(1, memory_order_relaxed);

if (currentBlock > batch->end_)

break;

auto blockdata = getBlockData(batch, currentBlock);

if (!blockdata->isInitialized())

{

LOGERR << "Could not get block data for height #" << currentBlock;

return;

}

blockMap.insert(make_pair(currentBlock, blockdata));

//TODO: flag isMultisig

const auto header = blockdata->header();

//update processed height

auto topHeight = header->getBlockHeight();

auto& txns = blockdata->getTxns();

for (unsigned i = 0; i < txns.size(); i++)

{

const BCTX& txn = *(txns[i].get());

for (unsigned y = 0; y < txn.txouts_.size(); y++)

{

auto& txout = txn.txouts_[y];

BinaryRefReader brr(

txn.data_ + txout.first, txout.second);

brr.advance(8);

unsigned scriptSize = (unsigned)brr.get_var_int();

auto&& scrRef = BtcUtils::getTxOutScrAddrNoCopy(

brr.get_BinaryDataRef(scriptSize));

auto saIter = batch->scriptRefMap_->find(scrRef);

if (saIter == batch->scriptRefMap_->end())

continue;

if (saIter->second >= (int)blockdata->header()->getBlockHeight())

continue;

//if we got this far, this txout is ours

//get tx hash

auto& txHash = txn.getHash();

auto&& scrAddr = scrRef.getScrAddr();

//construct StoredTxOut

StoredTxOut stxo;

stxo.dataCopy_ = BinaryData(

txn.data_ + txout.first, txout.second);

stxo.parentHash_ = txHash;

stxo.blockHeight_ = header->getBlockHeight();

stxo.duplicateID_ = header->getDuplicateID();

stxo.txIndex_ = i;

stxo.txOutIndex_ = y;

stxo.scrAddr_ = scrAddr;

stxo.spentness_ = TXOUT_UNSPENT;

stxo.parentTxOutCount_ = txn.txouts_.size();

stxo.isCoinbase_ = txn.isCoinbase_;

auto value = stxo.getValue();

auto&& hgtx = DBUtils::heightAndDupToHgtx(

stxo.blockHeight_, stxo.duplicateID_);

auto&& txioKey = DBUtils::getBlkDataKeyNoPrefix(

stxo.blockHeight_, stxo.duplicateID_,

i, y);

//update utxos_

auto& stxoHashMap = outputMap[txHash];

stxoHashMap.insert(make_pair(y, move(stxo)));

//update ssh_

auto& ssh = sshMap[scrAddr];

auto& subssh = ssh[hgtx];

//deal with txio count in subssh at serialization

TxIOPair txio;

txio.setValue(value);

txio.setTxOut(txioKey);

txio.setFromCoinbase(txn.isCoinbase_);

subssh.txioMap_.insert(make_pair(txioKey, move(txio)));

}

}

}

//grab batch mutex and merge processed data in

unique_lock<mutex> lock(batch->mergeMutex_);

batch->blockMap_.insert(blockMap.begin(), blockMap.end());

batch->outputMap_.insert(outputMap.begin(), outputMap.end());

for (auto& ssh_pair : sshMap)

{

auto ssh_iter = batch->sshMap_.find(ssh_pair.first);

if (ssh_iter == batch->sshMap_.end())

{

batch->sshMap_.insert(move(ssh_pair));

continue;

}

for (auto& subssh_pair : ssh_pair.second)

ssh_iter->second.insert(move(subssh_pair));

}

{

map<BinaryData, map<BinaryData, StoredSubHistory>> sshMap;

vector<StoredTxOut> spentOutputs;

while (1)

{

auto currentBlock =

batch->blockCounter_.fetch_add(1, memory_order_relaxed);

if (currentBlock > batch->end_)

break;

auto blockdata_iter = batch->blockMap_.find(currentBlock);

if (blockdata_iter == batch->blockMap_.end())

{

LOGERR << "can't find block #" << currentBlock << " in batch";

throw runtime_error("missing block");

}

auto blockdata = blockdata_iter->second;

const auto header = blockdata->header();

auto& txns = blockdata->getTxns();

for (unsigned i = 0; i < txns.size(); i++)

{

const BCTX& txn = *(txns[i].get());

for (unsigned y = 0; y < txn.txins_.size(); y++)

{

auto& txin = txn.txins_[y];

BinaryDataRef outHash(

txn.data_ + txin.first, 32);

auto utxoIter = utxoMap_.find(outHash);

if (utxoIter == utxoMap_.end())

continue;

unsigned txOutId = READ_UINT32_LE(

txn.data_ + txin.first + 32);

auto idIter = utxoIter->second.find(txOutId);

if (idIter == utxoIter->second.end())

continue;

//if we got this far, this txins consumes one of our utxos

//create spent txout

auto&& hgtx = DBUtils::getBlkDataKeyNoPrefix(

header->getBlockHeight(), header->getDuplicateID());

auto&& txinkey = DBUtils::getBlkDataKeyNoPrefix(

header->getBlockHeight(), header->getDuplicateID(),

i, y);

StoredTxOut stxo = idIter->second;

stxo.spentness_ = TXOUT_SPENT;

stxo.spentByTxInKey_ = txinkey;

//set spenderHash and parentTxOutCount to count and hash tallying

//of spent txouts

stxo.spenderHash_ = txn.getHash();

stxo.parentTxOutCount_ = txn.txouts_.size();

//add to ssh_

auto& ssh = sshMap[stxo.getScrAddress()];

auto& subssh = ssh[hgtx];

//deal with txio count in subssh at serialization

TxIOPair txio;

auto&& txoutkey = stxo.getDBKey(false);

txio.setTxOut(txoutkey);

txio.setTxIn(txinkey);

txio.setValue(stxo.getValue());

subssh.txioMap_[txoutkey] = move(txio);

//add to spentTxOuts_

spentOutputs.push_back(move(stxo));

}

}

}

//merge process data into batch

unique_lock<mutex> lock(batch->mergeMutex_);

for (auto& ssh_pair : sshMap)

{

auto ssh_iter = batch->sshMap_.find(ssh_pair.first);

if (ssh_iter == batch->sshMap_.end())

{

batch->sshMap_.insert(move(ssh_pair));

continue;

}

for (auto& subssh_pair : ssh_pair.second)

{

auto txio_iter = ssh_iter->second.find(subssh_pair.first);

if (txio_iter == ssh_iter->second.end())

{

ssh_iter->second.insert(move(subssh_pair));

continue;

}

for (auto& txio_pair : subssh_pair.second.txioMap_)

{

txio_iter->second.txioMap_[txio_pair.first] =

move(txio_pair.second);

}

}

}

batch->spentOutputs_.insert(batch->spentOutputs_.end(),

spentOutputs.begin(), spentOutputs.end());

{

auto getGlobalOffsetForBlock = [&](unsigned height)->size_t

{

auto header = blockchain_->getHeaderByHeight(height);

size_t val = header->getBlockFileNum();

val *= 128 * 1024 * 1024;

val += header->getOffset();

return val;

};

ProgressCalculator calc(getGlobalOffsetForBlock(

blockchain_->top()->getBlockHeight()));

auto initVal = getGlobalOffsetForBlock(startAt_);

calc.init(initVal);

if (reportProgress_)

progress_(BDMPhase_Rescan,

calc.fractionCompleted(), UINT32_MAX,

initVal);

auto writeHintsLambda =

[&](ParserBatch* batch_ref)->void

{ processAndCommitTxHints(batch_ref); };

TIMER_RESET("write");

while (1)

{

unique_ptr<ParserBatch> batch;

try

{

batch = move(commitQueue_.pop_front());

}

catch (StopBlockingLoop&)

{

break;

}

TIMER_START("write");

//start txhint writer thread

thread writeHintsThreadId =

thread(writeHintsLambda, batch.get());

//sanity check

if (batch->blockMap_.size() == 0)

continue;

//serialize data

auto topheader = batch->blockMap_.rbegin()->second->getHeaderPtr();

if (topheader == nullptr)

{

LOGERR << "empty top block header ptr, aborting scan";

throw runtime_error("nullptr header");

}

auto topHeight = topheader->getBlockHeight();

map<BinaryData, BinaryWriter> serializedSubSSH;

map<BinaryData, BinaryWriter> serializedStxo;

{

for (auto& ssh : batch->sshMap_)

{

for (auto& subssh : ssh.second)

{

//TODO: modify subssh serialization to fit our needs

BinaryWriter subsshkey;

subsshkey.put_uint8_t(DB_PREFIX_SCRIPT);

subsshkey.put_BinaryData(ssh.first);

subsshkey.put_BinaryData(subssh.first);

auto& bw = serializedSubSSH[subsshkey.getDataRef()];

subssh.second.serializeDBValue(

bw, ARMORY_DB_BARE);

}

}

for (auto& utxomap : batch->outputMap_)

{

for (auto& utxo : utxomap.second)

{

auto& bw = serializedStxo[utxo.second.getDBKey()];

utxo.second.serializeDBValue(

bw, ARMORY_DB_BARE, true);

}

}

}

//we've serialized utxos, now let's do another pass for spent txouts

//to make sure they overwrite utxos that were found and spent within

//the same batch

for (auto& stxo : batch->spentOutputs_)

{

auto& bw = serializedStxo[stxo.getDBKey()];

if (bw.getSize() > 0)

bw.reset();

stxo.serializeDBValue(

bw, ARMORY_DB_BARE, true);

}

//write data

{

//txouts

auto&& tx = db_->beginTransaction(STXO, LMDB::ReadWrite);

for (auto& stxo : serializedStxo)

{

//TODO: dont rewrite utxos, check if they are already in DB first

db_->putValue(STXO,

stxo.first.getRef(),

stxo.second.getDataRef());

}

}

{

//subssh

auto&& tx = db_->beginTransaction(SUBSSH, LMDB::ReadWrite);

for (auto& subssh : serializedSubSSH)

{

db_->putValue(

SUBSSH,

subssh.first.getRef(),

subssh.second.getDataRef());

}

//update SUBSSH sdbi

auto&& sdbi = scrAddrFilter_->getSubSshSDBI();

sdbi.topBlkHgt_ = topheader->getBlockHeight();

sdbi.topScannedBlkHash_ = topheader->getThisHash();

scrAddrFilter_->putSubSshSDBI(sdbi);

}

//wait on writeHintsThreadId

if (writeHintsThreadId.joinable())

writeHintsThreadId.join();

if (batch->start_ != batch->end_)

{

LOGINFO << "scanned from block #" << batch->start_

<< " to #" << batch->end_;

}

else

{

LOGINFO << "scanned block #" << batch->start_;

}

size_t progVal = getGlobalOffsetForBlock(batch->end_);

calc.advance(progVal);

if (reportProgress_)

progress_(BDMPhase_Rescan,

calc.fractionCompleted(), calc.remainingSeconds(),

progVal);

topScannedBlockHash_ = topheader->getThisHash();

completedBatches_.fetch_add(1, memory_order_relaxed);

batch->completedPromise_.set_value(true);

TIMER_STOP("write");

}

{

map<BinaryData, StoredTxHints> txHints;

map<BinaryData, BinaryWriter> countAndHash;

auto addTxHint =

[&](StoredTxHints& stxh, const StoredTxOut& utxo)->void

{

auto&& utxokey = utxo.getDBKeyOfParentTx(false);

//make sure key isn't already in there

for (auto& key : stxh.dbKeyList_)

{

if (key == utxokey)

return;

}

stxh.dbKeyList_.push_back(move(utxokey));

};

auto addTxHintMap =

[&](const pair<BinaryData, map<unsigned, StoredTxOut>>& utxomap)->void

{

auto&& txHashPrefix = utxomap.first.getSliceCopy(0, 4);

StoredTxHints& stxh = txHints[txHashPrefix];

//pull txHint from DB first, don't want to override

//existing hints

if (stxh.isNull())

db_->getStoredTxHints(stxh, txHashPrefix);

for (auto& utxo : utxomap.second)

{

addTxHint(stxh, utxo.second);

}

stxh.preferredDBKey_ = stxh.dbKeyList_.front();

//count and hash

auto& stxo = utxomap.second.begin()->second;

auto& bw = countAndHash[stxo.getDBKeyOfParentTx(true)];

if (bw.getSize() != 0)

return;

bw.put_uint32_t(stxo.parentTxOutCount_);

bw.put_BinaryData(utxomap.first);

};

{

auto&& hintdbtx = db_->beginTransaction(TXHINTS, LMDB::ReadOnly);

for (auto& utxomap : batch->outputMap_)

{

addTxHintMap(utxomap);

}

map<BinaryData, map<unsigned, StoredTxOut>> spentTxOutMap;

for (auto& stxo : batch->spentOutputs_)

{

auto& stxomap = spentTxOutMap[stxo.spenderHash_];

StoredTxOut spentstxo;

spentstxo.parentHash_ = stxo.spenderHash_;

spentstxo.blockHeight_ =

DBUtils::hgtxToHeight(stxo.spentByTxInKey_.getSliceRef(0, 4));

spentstxo.duplicateID_ =

DBUtils::hgtxToDupID(stxo.spentByTxInKey_.getSliceRef(0, 4));

spentstxo.txIndex_ =

READ_UINT16_BE(stxo.spentByTxInKey_.getSliceRef(4, 2));

spentstxo.txOutIndex_ =

READ_UINT16_BE(stxo.spentByTxInKey_.getSliceRef(6, 2));

spentstxo.parentTxOutCount_ = stxo.parentTxOutCount_;

stxomap.insert(move(

make_pair(spentstxo.txOutIndex_, move(spentstxo))));

}

for (auto& stxomap : spentTxOutMap)

addTxHintMap(stxomap);

}

map<BinaryData, BinaryWriter> serializedHints;

//serialize

for (auto& txhint : txHints)

{

auto& bw = serializedHints[txhint.second.getDBKey()];

txhint.second.serializeDBValue(bw);

}

//write

{

auto&& hintdbtx = db_->beginTransaction(TXHINTS, LMDB::ReadWrite);

for (auto& txhint : serializedHints)

{

db_->putValue(TXHINTS,

txhint.first.getRef(),

txhint.second.getDataRef());

}

for (auto& cah : countAndHash)

{

db_->putValue(TXHINTS,

cah.first.getRef(),

cah.second.getDataRef());

}

}

{

//loop over all subssh entiers in SUBSSH db,

//compile balance, txio count and summary map for each address

//now also resolves unhinted tx hashes

if (force)

startHeight = 0;

if (startHeight > (int32_t)db_->blockchain()->top()->getBlockHeight())

return;