uint32_t firstTimestamp,

uint32_t firstBlockNum,

uint32_t lastTimestamp,

uint32_t lastBlockNum)

{

if (scrAddrMap_.find(scrAddr) != scrAddrMap_.end())

return;

ScrAddrObj addr(

bdvPtr_->getDB(),

&bdvPtr_->blockchain(),

scrAddr,

firstTimestamp, firstBlockNum,

lastTimestamp, lastBlockNum

);

//do not register the address with the BDM if this wallet isnt registered

//yet. All of its scrAddr will be registered with the BDM when the wallet is

if (isRegistered_)

{

if (bdvPtr_ != nullptr)

{

vector<BinaryData> saVec;

saVec.push_back(scrAddr);

if (!bdvPtr_->registerAddresses(saVec, walletID_, false))

return;

}

}

scrAddrMap_[scrAddr] = addr;

{

if (scrAddrMap_.find(scrAddr) != scrAddrMap_.end())

return;

ScrAddrObj addr = ScrAddrObj(bdvPtr_->getDB(), &bdvPtr_->blockchain(),

scrAddr, 0, 0, 0, 0);

if (isRegistered_)

{

if (bdvPtr_ != nullptr)

{

vector<BinaryData> saVec;

saVec.push_back(scrAddr);

if (!bdvPtr_->registerAddresses(saVec, walletID_, true))

return;

}

}

scrAddrMap_[scrAddr] = addr;

{

if (scrAddrMap_.find(newScrAddr.getScrAddr()) != scrAddrMap_.end())

return;

if (newScrAddr.getScrAddr().getSize() == 0)

return;

if (isRegistered_)

{

if (bdvPtr_ != nullptr)

{

vector<BinaryData> saVec;

saVec.push_back(newScrAddr.getScrAddr());

if (!bdvPtr_->registerAddresses(saVec, walletID_, false))

return;

}

}

scrAddrMap_[newScrAddr.getScrAddr()] = newScrAddr;

bool areNew)

{

vector<BinaryData> addrToReg;

for (const auto& scrAddr : scrAddrBulk)

{

if (scrAddrMap_.find(scrAddr) != scrAddrMap_.end())

continue;

if (scrAddr.getSize() == 0)

continue;

addrToReg.push_back(scrAddr);

}

if (addrToReg.size() == 0)

return;

if (isRegistered_)

{

if (bdvPtr_ != nullptr)

{

if (!bdvPtr_->registerAddresses(addrToReg, walletID_, areNew))

return;

}

}

for (const auto& scrAddr : addrToReg)

{

ScrAddrObj sca(bdvPtr_->getDB(), &bdvPtr_->blockchain(), scrAddr);

scrAddrMap_[scrAddr] = ScrAddrObj(bdvPtr_->getDB(), &bdvPtr_->blockchain(), scrAddr);

}

//should init new addresses

{

markAddressListForDeletion(scrAddrBulk);

needsRefresh();

uint32_t firstTimestamp,

uint32_t firstBlockNum)

{

addScrAddress(scrAddr, firstBlockNum, firstTimestamp);

uint32_t firstTimestamp,

uint32_t firstBlockNum,

uint32_t lastTimestamp,

uint32_t lastBlockNum)

{

addScrAddress(scrAddr, firstBlockNum, firstTimestamp,

lastBlockNum, lastTimestamp);

{

cout << "Wallet PPRINT:" << endl;

cout << "Tot: " << getFullBalance() << endl;

cout << "Spd: " << getSpendableBalance(topBlk) << endl;

cout << "Ucn: " << getUnconfirmedBalance(topBlk) << endl;

cout << "Ledger: " << endl;

for(const auto ledger : *ledgerAllAddr_)

ledger.second.pprintOneLine();

/*cout << "TxioMap:" << endl;

if(withAddr)

{

for(const auto &sa : scrAddrMap_)

{

const ScrAddrObj & addr = sa.second;

HashString scraddr = addr.getScrAddr();

cout << "\nAddress: " << scraddr.copySwapEndian().toHexStr() << endl;

cout << " Tot: " << addr.getFullBalance() << endl;

cout << " Spd: " << addr.getSpendableBalance(topBlk) << endl;

cout << " Ucn: " << addr.getUnconfirmedBalance(topBlk) << endl;

cout << " Ledger: " << endl;

const auto& saLedgers = addr.getTxLedger();

for(const auto ledger : saLedgers)

ledger.second.pprintOneLine();

cout << " TxioPtrs (Blockchain):" << endl;

map<OutPoint, TxIOPair>::iterator iter;

for(auto txio : addr.relevantTxIO_)

{

txio.second.pprintOneLine(db);

}

}

}

{

os << "\tBalance: " << getFullBalance();

os << "\tNAddr: " << getNumScrAddr();

os << "\tNLedg: " << getTxLedger().size();

// os << "\tNZC: " << getZeroConfLedger().size() << endl;

{

ledgerAllAddr_ = &LedgerEntry::EmptyLedgerMap_;

for (auto saIter = scrAddrMap_.begin();

saIter != scrAddrMap_.end(); ++saIter)

{ saIter->second.clearBlkData(); }

histPages_.reset();

uint32_t txidx,

Tx & tx,

uint32_t txoutidx,

ScrAddrObj& thisAddr)

{

TxOut txout = tx.getTxOutCopy(txoutidx);

int findIdx = txout.getScriptRef().find(thisAddr.getScrAddr());

if(findIdx > -1)

{

LOGERR << "ALERT: Found non-standard transaction referencing";

LOGERR << " an address in your wallet. There is no way";

LOGERR << " for this program to determine if you can";

LOGERR << " spend these BTC or not. Please email the";

LOGERR << " following information to [email protected]";

LOGERR << " for help identifying the transaction and how";

LOGERR << " to spend it:";

LOGERR << " Block Number: " << blknum;

LOGERR << " Tx Hash: " << tx.getThisHash().copySwapEndian().toHexStr()

<< " (BE)";

LOGERR << " TxOut Index: " << txoutidx;

LOGERR << " PubKey Hash: " << thisAddr.getScrAddr().copySwapEndian().toHexStr() << " (BE)";

LOGERR << " RawScript: ";

BinaryDataRef scr = txout.getScriptRef();

size_t sz = scr.getSize();

for(uint32_t i=0; i<sz; i+=32)

{

if( i < sz-32 )

LOGERR << " " << scr.getSliceCopy(i,sz-i).toHexStr();

else

LOGERR << " " << scr.getSliceCopy(i,32).toHexStr();

}

LOGERR << " Attempting to interpret script:";

BtcUtils::pprintScript(scr);

OutPoint outpt(tx.getThisHash(), txoutidx);

/*nonStdUnspentOutPoints_.insert(outpt);

}

uint32_t currBlk, bool ignoreAllZC) const

{

uint64_t balance = 0;

for(const auto scrAddr : scrAddrMap_)

balance += scrAddr.second.getSpendableBalance(currBlk, ignoreAllZC);

return balance;

uint32_t currBlk, bool inclAllZC) const

{

uint64_t balance = 0;

for (const auto scrAddr : scrAddrMap_)

balance += scrAddr.second.getUnconfirmedBalance(currBlk, inclAllZC);

return balance;

{

uint64_t balance = 0;

for (const auto scrAddr : scrAddrMap_)

balance += scrAddr.second.getFullBalance();

return balance;

{

const ScrAddrObj* addrPtr = getScrAddrObjByKey(addr);

if (addrPtr != nullptr)

return addrPtr->getTxioCountFromSSH();

return 0;

{

uint64_t value;

uint32_t count;

auto spentByZC = [this](const BinaryData& dbkey)->bool

{ return this->bdvPtr_->isTxOutSpentByZC(dbkey); };

while (1)

{

value = 0;

count = 0;

for (const auto& scrAddr : scrAddrMap_)

{

value += scrAddr.second.getLoadedTxOutsValue();

count += scrAddr.second.getLoadedTxOutsCount();

}

//grab at least MIN_UTXO_PER_TXN and cover for twice the requested value

if (value * 2 < val || count < MIN_UTXO_PER_TXN)

{

/***getMoreUTXOs returns true if it found more. As long as one

bool hasMore = false;

for (auto& scrAddr : scrAddrMap_)

hasMore |= scrAddr.second.getMoreUTXOs(spentByZC);

if (!hasMore)

break;

}

else

break;

}

if (value * 2 < val || count < MIN_UTXO_PER_TXN)

{

if (ignoreZC)

return;

auto isZcFromWallet = [this](const BinaryData& zcKey)->bool

{

const auto& spentSAforZCKey = bdvPtr_->getSpentSAforZCKey(zcKey);

for (const auto& spentSA : spentSAforZCKey)

{

if (this->hasScrAddress(spentSA))

return true;

}

return false;

};

for (auto& scrAddr : scrAddrMap_)

{

scrAddr.second.addZcUTXOs(bdvPtr_->getZCutxoForScrAddr(

scrAddr.second.getScrAddr()), isZcFromWallet);

}

}

{

auto spentByZC = [this](BinaryData dbkey)->bool

{ return this->bdvPtr_->isTxOutSpentByZC(dbkey); };

while (1)

{

bool hasMore = false;

for (auto& scrAddr : scrAddrMap_)

hasMore |= scrAddr.second.getMoreUTXOs(spentByZC);

if (hasMore == false)

return;

}

{

for (auto& scrAddr : scrAddrMap_)

scrAddr.second.resetTxOutHistory();

bool ignoreZC)

{

/***

prepareTxOutHistory(val, ignoreZC);

LMDBBlockDatabase *db = bdvPtr_->getDB();

//start a RO txn to grab the txouts from DB

LMDBEnv::Transaction tx;

db->beginDBTransaction(&tx, HISTORY, LMDB::ReadOnly);

vector<UnspentTxOut> utxoList;

uint32_t blk = bdvPtr_->getTopBlockHeight();

for (const auto& scrAddr : scrAddrMap_)

{

const auto& utxoMap = scrAddr.second.getPreparedTxOutList();

for (const auto& txioPair : utxoMap)

{

TxOut txout = txioPair.second.getTxOutCopy(db);

UnspentTxOut UTXO = UnspentTxOut(db, txout, blk);

utxoList.push_back(UTXO);

}

}

//Shipped a list of TxOuts, time to reset the entire TxOut history, since

//we dont know if any TxOut will be spent

resetTxOutHistory();

return utxoList;

{

cout << "Wallet Ledger: " << getFullBalance()/1e8 << endl;

for(const auto ledger : *ledgerAllAddr_)

ledger.second.pprintOneLine();

{

SCOPED_TIMER("createAddressBook");

// Collect all data into a map -- later converted to vector and sort it

map<HashString, AddressBookEntry> sentToMap;

set<HashString> allTxList;

set<HashString> perTxAddrSet;

// Go through all TxIO for this wallet, collect outgoing transactions

for (const auto scrAddr : scrAddrMap_)

{

const auto& scrAddrTxioMap = scrAddr.second.getTxIOMap();

for (const auto &tio : scrAddrTxioMap)

{

const TxIOPair & txio = tio.second;

// It's only outgoing if it has a TxIn

if (!txio.hasTxIn() || txio.hasTxInZC())

continue;

Tx thisTx = txio.getTxRefOfInput().attached(bdvPtr_->getDB()).getTxCopy();

HashString txHash = thisTx.getThisHash();

if (allTxList.count(txHash) > 0)

continue;

else

allTxList.insert(txHash);

// Iterate over all TxOut in this Tx for recipients

perTxAddrSet.clear();

for (uint32_t iout = 0; iout<thisTx.getNumTxOut(); iout++)

{

HashString scraddr = thisTx.getTxOutCopy(iout).getScrAddressStr();

// Skip this address if it's in our wallet (usually change addr)

if (hasScrAddress(scraddr) || perTxAddrSet.count(scraddr)>0)

continue;

// It's someone else's address for sure, add it to the map if necessary

if (sentToMap.count(scraddr) == 0)

sentToMap[scraddr] = AddressBookEntry(scraddr);

sentToMap[scraddr].addTx(thisTx);

perTxAddrSet.insert(scraddr);

}

}

}

vector<AddressBookEntry> outputVect;

for(const auto &entry : sentToMap)

{

outputVect.push_back(entry.second);

}

sort(outputVect.begin(), outputVect.end());

return outputVect;

HashString const & scraddr)

const

{

vector<LedgerEntry> leVec;

auto saIter = scrAddrMap_.find(scraddr);

if (ITER_IN_MAP(saIter, scrAddrMap_))

{

const auto& leMap = saIter->second.getTxLedger();

for (const auto& lePair : leMap)

leVec.push_back(lePair.second);

}

return leVec;

{

vector<LedgerEntry> leVec;

for (const auto& lePair : *ledgerAllAddr_)

leVec.push_back(lePair.second);

return leVec;

uint32_t endBlock)

{

SCOPED_TIMER("fetchWalletRegisteredScrAddrData");

for (auto saIter = scrAddrMap_.begin();

saIter != scrAddrMap_.end();

saIter++)

{

saIter->second.fetchDBScrAddrData(startBlock, endBlock);

}

{

for (auto& scrAddr : scrAddrMap_)

{

scrAddr.second.updateAfterReorg(lastValidBlockHeight);

}

{

/***

SCOPED_TIMER("rescanWalletZeroConf");

map<BinaryData, map<BinaryData, TxIOPair> > ZCtxioMap =

bdvPtr_->getNewZeroConfTxIOMap();

if (withReorg==true)

{

//scanning ZC after a reorg, Everything beyond the last valid block has

//been wiped out of RAM, thus grab the full ZC txio map. Still need a call

//to getNewZeroConfTxIOMap to clear the new ZC map

ZCtxioMap = bdvPtr_->getFullZeroConfTxIOMap();

}

auto isZcFromWallet = [this](const BinaryData& zcKey)->bool

{

const auto& spentSAforZCKey = bdvPtr_->getSpentSAforZCKey(zcKey);

for (const auto& spentSA : spentSAforZCKey)

{

if (this->hasScrAddress(spentSA))

return true;

}

return false;

};

for (auto& scrAddrTxio : ZCtxioMap)

{

map<BinaryData, ScrAddrObj>::iterator scrAddr =

scrAddrMap_.find(scrAddrTxio.first);

if (scrAddr != scrAddrMap_.end())

scrAddr->second.scanZC(scrAddrTxio.second, isZcFromWallet);

}

bool reorg, const map<BinaryData, vector<BinaryData> >& invalidatedZCKeys)

{

if (startBlock < endBlock)

{

purgeZeroConfTxIO(invalidatedZCKeys);

//new top block

if (reorg)

updateAfterReorg(startBlock);

LMDBEnv::Transaction tx;

bdvPtr_->getDB()->beginDBTransaction(&tx, HISTORY, LMDB::ReadOnly);

fetchDBScrAddrData(startBlock, endBlock);

scanWalletZeroConf(reorg);

map<BinaryData, TxIOPair> txioMap;

getTxioForRange(startBlock, UINT32_MAX, txioMap);

updateWalletLedgersFromTxio(*ledgerAllAddr_, txioMap,

startBlock, UINT32_MAX, true);

balance_ = getFullBalanceFromDB();

}

else

{

//top block didnt change, only have to check for new ZC

if (bdvPtr_->isZcEnabled())

{

scanWalletZeroConf();

map<BinaryData, TxIOPair> txioMap;

getTxioForRange(endBlock +1, UINT32_MAX, txioMap);

updateWalletLedgersFromTxio(*ledgerAllAddr_, txioMap,

endBlock +1, UINT32_MAX);

balance_ = getFullBalanceFromDB();

//return false because no new block was parsed

return false;

}

}

return true;

{

merge();

clearBlkData();

const map<BinaryData, vector<BinaryData> >& invalidatedTxIO)

{

for (auto& txioVec : invalidatedTxIO)

{

map<BinaryData, ScrAddrObj>::iterator scrAddr =

scrAddrMap_.find(txioVec.first);

if (scrAddr != scrAddrMap_.end())

scrAddr->second.purgeZC(txioVec.second);

}

bool isNew, BinaryData topScannedBlockHash)

{

//pass isNew = true for supernode too, since that's the same behavior

shared_ptr<mergeStruct> newMergeStruct(new mergeStruct());

newMergeStruct->mergeAction_ = (isNew ? MergeAction::NoRescan : MergeAction::Rescan);

newMergeStruct->mergeTopScannedBlkHash_ = topScannedBlockHash;

for (const auto& scrAddr : scrAddrVec)

{

ScrAddrObj newScrAddrObj(bdvPtr_->getDB(),

&bdvPtr_->blockchain(),

scrAddr);

newMergeStruct->scrAddrMapToMerge_.insert(make_pair(scrAddr, newScrAddrObj));

}

unique_lock<mutex> mergeLock(mergeLock_);

shared_ptr<mergeStruct> *bottomMergeData = &mergeData_;

while (bottomMergeData->get() != nullptr)

{

auto ptr = bottomMergeData->get();

bottomMergeData = &ptr->nextMergeData_;

}

*bottomMergeData = newMergeStruct;

//mark merge flag

mergeFlag_ = MergeWallet::NeedsMerging;

const vector<BinaryData>& scrAddrVecToDel)

{

shared_ptr<mergeStruct> newMergeStruct(new mergeStruct());

newMergeStruct->mergeAction_ = MergeAction::DeleteAddresses;

newMergeStruct->scrAddrVecToDelete_ = scrAddrVecToDel;

unique_lock<mutex> mergeLock(mergeLock_);

shared_ptr<mergeStruct> *bottomMergeData = &mergeData_;

while (bottomMergeData->get() != nullptr)

{

auto ptr = bottomMergeData->get();

bottomMergeData = &ptr->nextMergeData_;

}

*bottomMergeData = newMergeStruct;

//mark merge flag

mergeFlag_ = MergeWallet::NeedsMerging;

{

if (mergeFlag_ == MergeWallet::NeedsMerging)

{

unique_lock<mutex> mergeLock(mergeLock_);

shared_ptr<mergeStruct> currentMergeData = mergeData_;

while (currentMergeData.get() != nullptr)

{

mergeLock.unlock();

auto& scrAddrMapToMerge = currentMergeData->scrAddrMapToMerge_;

auto& mergeTopScannedBlkHash = currentMergeData->mergeTopScannedBlkHash_;

if (mergeData_->mergeAction_ == MergeAction::Rescan && scrAddrMapToMerge.size() > 0)

{

//compare last scanned blk hash to current main chain

Blockchain& bc = bdvPtr_->blockchain();

BlockHeader& bh = bc.getHeaderByHash(mergeTopScannedBlkHash);

uint32_t bottomBlock;

if (bh.isMainBranch())

{

//top scanned block is on main branch, make sure the scrAddrs are

//scanned to the current top

bottomBlock = bh.getBlockHeight() + 1;

}

else

{

//top scanned block is not on the main branch, undo till branch point

const Blockchain::ReorganizationState state =

bc.findReorgPointFromBlock(mergeTopScannedBlkHash);

//undo blocks up to the branch point, we'll apply the main chain

//through the regular scan

shared_ptr<ScrAddrFilter> saf(bdvPtr_->getSAF()->copy());

for (const auto& scrAddr : scrAddrMapToMerge)

saf->regScrAddrForScan(scrAddr.first, 0);

ReorgUpdater reorgOnlyUndo(state,

&bc, bdvPtr_->getDB(), bdvPtr_->config(), saf.get(), true);

bottomBlock = state.reorgBranchPoint->getBlockHeight() + 1;

}

uint32_t topBlock = bdvPtr_->blockchain().top().getBlockHeight();

if (bottomBlock < topBlock)

bdvPtr_->scanScrAddrVector(scrAddrMapToMerge, bottomBlock, topBlock);

}

//merge scrAddrMap

if (mergeData_->mergeAction_ != MergeAction::DeleteAddresses)

{

for (auto& scrAddrPair : scrAddrMapToMerge)

scrAddrMap_.insert(scrAddrPair); //no need to override existing ScrAddrObj

}

else

{

//delete the mergeData's scrAddrVec from the wallet's scrAddrMap_

auto& scrAddrVecToDelete = currentMergeData->scrAddrVecToDelete_;

for (auto& scrAddrPair : scrAddrVecToDelete)

scrAddrMap_.erase(scrAddrPair);

}

mergeLock.lock();

currentMergeData = currentMergeData->nextMergeData_;

}

//clear mergeData

mergeData_.reset();

//clear flag

mergeFlag_ = MergeWallet::NoMerge;

}

{

struct preHistory

{

uint32_t txioCount_;

vector<const BinaryData*> scrAddrs_;

preHistory(void) : txioCount_(0) {}

};

map<uint32_t, preHistory> preHistSummary;

LMDBEnv::Transaction tx;

bdvPtr_->getDB()->beginDBTransaction(&tx, HISTORY, LMDB::ReadOnly);

for (auto& scrAddrPair : scrAddrMap_)

{

scrAddrPair.second.mapHistory();

const map<uint32_t, uint32_t>& txioSum =

scrAddrPair.second.getHistSSHsummary();

//keep count of txios at each height with a vector of all related scrAddr

for (const auto& histPair : txioSum)

{

auto& preHistAtHeight = preHistSummary[histPair.first];

preHistAtHeight.txioCount_ += histPair.second;

preHistAtHeight.scrAddrs_.push_back(&scrAddrPair.first);

}

}

map<uint32_t, uint32_t> histSummary;

for (auto& preHistAtHeight : preHistSummary)

{

if (preHistAtHeight.second.scrAddrs_.size() > 1)

{

//get hgtX for height

uint8_t dupID = bdvPtr_->getDB()->getValidDupIDForHeight(preHistAtHeight.first);

const BinaryData& hgtX = DBUtils::heightAndDupToHgtx(preHistAtHeight.first, dupID);

set<BinaryData> txKeys;

//this height has several txio for several scrAddr, let's look at the

//txios in detail to reduce the total count for repeating txns.

for (auto scrAddr : preHistAtHeight.second.scrAddrs_)

{

StoredSubHistory subssh;

if (bdvPtr_->getDB()->getStoredSubHistoryAtHgtX(subssh, *scrAddr, hgtX))

{

for (auto& txioPair : subssh.txioMap_)

{

if (txioPair.second.hasTxIn())

txKeys.insert(txioPair.second.getTxRefOfInput().getDBKey());

else

txKeys.insert(txioPair.second.getTxRefOfOutput().getDBKey());

}

}

}

preHistAtHeight.second.txioCount_ = txKeys.size();

}