// mapWallet
//
+CWallet::CWallet()
+{
+ SetNull();
+}
+
+CWallet::CWallet(std::string strWalletFileIn)
+{
+ SetNull();
+
+ strWalletFile = strWalletFileIn;
+ fFileBacked = true;
+}
+
+void CWallet::SetNull()
+{
+ nWalletVersion = FEATURE_BASE;
+ nWalletMaxVersion = FEATURE_BASE;
+ fFileBacked = false;
+ nMasterKeyMaxID = 0;
+ pwalletdbEncryption = NULL;
+ pwalletdbDecryption = NULL;
+ nNextResend = 0;
+ nLastResend = 0;
+ nOrderPosNext = 0;
+ nKernelsTried = 0;
+ nCoinDaysTried = 0;
+ nTimeFirstKey = 0;
+}
+
struct CompareValueOnly
{
bool operator()(const pair<int64_t, pair<const CWalletTx*, unsigned int> >& t1,
nTimeFirstKey = nCreationTime;
if (!AddKey(key))
- throw std::runtime_error("CWallet::GenerateNewKey() : AddKey failed");
+ throw runtime_error("CWallet::GenerateNewKey() : AddKey failed");
return key.GetPubKey();
}
nTimeFirstKey = nCreationTime;
if (!AddKey(mKey))
- throw std::runtime_error("CWallet::GenerateNewMalleableKey() : AddKey failed");
+ throw runtime_error("CWallet::GenerateNewMalleableKey() : AddKey failed");
return CMalleableKeyView(mKey);
}
return true;
}
-bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std::vector<unsigned char> &vchCryptedSecretH)
+bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const vector<unsigned char> &vchCryptedSecretH)
{
if (!CCryptoKeyStore::AddCryptedMalleableKey(keyView, vchCryptedSecretH))
return false;
auto mi2 = mapMalleableKeys.begin();
while (mi2 != mapMalleableKeys.end())
{
- const CSecret &vchSecretH = mi2->second;
- const CMalleableKeyView &keyView = mi2->first;
+ const auto &vchSecretH = mi2->second;
+ const auto &keyView = mi2->first;
pwalletdbDecryption->EraseCryptedMalleableKey(keyView);
pwalletdbDecryption->WriteMalleableKey(keyView, vchSecretH, mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())]);
mi2++;
return true;
}
-bool CWallet::GetPEM(const CKeyID &keyID, const std::string &fileName, const SecureString &strPassKey) const
+bool CWallet::GetPEM(const CKeyID &keyID, const string &fileName, const SecureString &strPassKey) const
{
BIO *pemOut = BIO_new_file(fileName.c_str(), "w");
if (pemOut == NULL)
return nRet;
}
-CWallet::TxItems CWallet::OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount)
+CWallet::TxItems CWallet::OrderedTxItems(list<CAccountingEntry>& acentries, string strAccount)
{
CWalletDB walletdb(strWalletFile);
for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it)
{
CWalletTx* wtx = &((*it).second);
- txOrdered.insert(make_pair(wtx->nOrderPos, TxPair(wtx, (CAccountingEntry*)0)));
+ txOrdered.insert({ wtx->nOrderPos, { wtx, (CAccountingEntry*)0 } });
}
acentries.clear();
walletdb.ListAccountCreditDebit(strAccount, acentries);
for(auto& entry : acentries)
{
- txOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry)));
+ txOrdered.insert({ entry.nOrderPos, { (CWalletTx*)0, &entry } });
}
return txOrdered;
{
LOCK(cs_wallet);
// Inserts only if not already there, returns tx inserted or tx found
- auto ret = mapWallet.insert(make_pair(hash, wtxIn));
+ auto ret = mapWallet.insert({ hash, wtxIn });
auto& wtx = (*ret.first).second;
wtx.BindWallet(this);
bool fInsertedNew = ret.second;
{
// Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
int64_t latestTolerated = latestNow + 300;
- std::list<CAccountingEntry> acentries;
+ list<CAccountingEntry> acentries;
auto txOrdered = OrderedTxItems(acentries);
for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
{
}
unsigned int& blocktime = mapBlockIndex[wtxIn.hashBlock]->nTime;
- wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
+ wtx.nTimeSmart = max(latestEntry, min(blocktime, latestNow));
}
else
printf("AddToWallet() : found %s in block %s not in index\n",
return MINE_NO;
}
+CWalletTx::CWalletTx()
+{
+ Init(NULL);
+}
+
+CWalletTx::CWalletTx(const CWallet* pwalletIn)
+{
+ Init(pwalletIn);
+}
+
+CWalletTx::CWalletTx(const CWallet* pwalletIn, const CMerkleTx& txIn) : CMerkleTx(txIn)
+{
+ Init(pwalletIn);
+}
+
+CWalletTx::CWalletTx(const CWallet* pwalletIn, const CTransaction& txIn) : CMerkleTx(txIn)
+{
+ Init(pwalletIn);
+}
+
+void CWalletTx::Init(const CWallet* pwalletIn)
+{
+ pwallet = pwalletIn;
+ vtxPrev.clear();
+ mapValue.clear();
+ vOrderForm.clear();
+ fTimeReceivedIsTxTime = false;
+ nTimeReceived = 0;
+ nTimeSmart = 0;
+ fFromMe = false;
+ strFromAccount.clear();
+ vfSpent.clear();
+ fDebitCached = false;
+ fWatchDebitCached = false;
+ fCreditCached = false;
+ fWatchCreditCached = false;
+ fAvailableCreditCached = false;
+ fAvailableWatchCreditCached = false;
+ fImmatureCreditCached = false;
+ fImmatureWatchCreditCached = false;
+ fChangeCached = false;
+ nDebitCached = 0;
+ nWatchDebitCached = 0;
+ nCreditCached = 0;
+ nWatchCreditCached = 0;
+ nAvailableCreditCached = 0;
+ nAvailableWatchCreditCached = 0;
+ nImmatureCreditCached = 0;
+ nImmatureWatchCreditCached = 0;
+ nChangeCached = 0;
+ nOrderPos = -1;
+}
+
// marks certain txout's as spent
// returns true if any update took place
-bool CWalletTx::UpdateSpent(const std::vector<char>& vfNewSpent)
+bool CWalletTx::UpdateSpent(const vector<char>& vfNewSpent)
{
bool fReturn = false;
for (unsigned int i = 0; i < vfNewSpent.size(); i++)
void CWalletTx::MarkSpent(unsigned int nOut)
{
if (nOut >= vout.size())
- throw std::runtime_error("CWalletTx::MarkSpent() : nOut out of range");
+ throw runtime_error("CWalletTx::MarkSpent() : nOut out of range");
vfSpent.resize(vout.size());
if (!vfSpent[nOut])
{
void CWalletTx::MarkUnspent(unsigned int nOut)
{
if (nOut >= vout.size())
- throw std::runtime_error("CWalletTx::MarkUnspent() : nOut out of range");
+ throw runtime_error("CWalletTx::MarkUnspent() : nOut out of range");
vfSpent.resize(vout.size());
if (vfSpent[nOut])
{
bool CWalletTx::IsSpent(unsigned int nOut) const
{
if (nOut >= vout.size())
- throw std::runtime_error("CWalletTx::IsSpent() : nOut out of range");
+ throw runtime_error("CWalletTx::IsSpent() : nOut out of range");
if (nOut >= vfSpent.size())
return false;
return (!!vfSpent[nOut]);
int64_t CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
{
if (!MoneyRange(txout.nValue))
- throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ throw runtime_error("CWallet::GetCredit() : value out of range");
return (IsMine(txout) & filter ? txout.nValue : 0);
}
int64_t CWallet::GetChange(const CTxOut& txout) const
{
if (!MoneyRange(txout.nValue))
- throw std::runtime_error("CWallet::GetChange() : value out of range");
+ throw runtime_error("CWallet::GetChange() : value out of range");
return (IsChange(txout) ? txout.nValue : 0);
}
{
nDebit += GetDebit(txin, filter);
if (!MoneyRange(nDebit))
- throw std::runtime_error("CWallet::GetDebit() : value out of range");
+ throw runtime_error("CWallet::GetDebit() : value out of range");
}
return nDebit;
}
{
nCredit += GetCredit(txout, filter);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ throw runtime_error("CWallet::GetCredit() : value out of range");
}
return nCredit;
}
{
nChange += GetChange(txout);
if (!MoneyRange(nChange))
- throw std::runtime_error("CWallet::GetChange() : value out of range");
+ throw runtime_error("CWallet::GetChange() : value out of range");
}
return nChange;
}
const CTxOut &txout = vout[i];
nCredit += pwallet->GetCredit(txout, MINE_SPENDABLE);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
+ throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
}
}
const CTxOut &txout = vout[i];
nCredit += pwallet->GetCredit(txout, MINE_WATCH_ONLY);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
+ throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
}
}
// If we are debited by the transaction, add the output as a "sent" entry
if (nDebit > 0)
- listSent.push_back(make_pair(address, txout.nValue));
+ listSent.push_back({ address, txout.nValue });
// If we are receiving the output, add it as a "received" entry
if (fIsMine & filter)
- listReceived.push_back(make_pair(address, txout.nValue));
+ listReceived.push_back({ address, txout.nValue });
}
}
return RelayWalletTransaction(txdb);
}
-std::vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime)
+vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime)
{
- std::vector<uint256> result;
+ vector<uint256> result;
LOCK(cs_wallet);
// Sort them in chronological order
// Don't rebroadcast if newer than nTime:
if (wtx.nTimeReceived > nTime)
continue;
- mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
+ mapSorted.insert({ wtx.nTimeReceived, &wtx });
}
for(auto& item : mapSorted)
{
// Rebroadcast unconfirmed txes older than 5 minutes before the last
// block was found:
- std::vector<uint256> relayed = ResendWalletTransactionsBefore(nBestBlockTime - 5*60);
+ auto relayed = ResendWalletTransactionsBefore(nBestBlockTime - 5*60);
if (!relayed.empty())
printf("CWallet::ResendWalletTransactions: rebroadcast %" PRIszu " unconfirmed transactions\n", relayed.size());
}
// List of values less than target
pair<int64_t, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
- coinLowestLarger.first = std::numeric_limits<int64_t>::max();
+ coinLowestLarger.first = numeric_limits<int64_t>::max();
coinLowestLarger.second.first = NULL;
vector<pair<int64_t, pair<const CWalletTx*,unsigned int> > > vValue;
int64_t nTotalLower = 0;
continue;
auto n = pcoin->vout[i].nValue;
- auto coin = make_pair(n,make_pair(pcoin, i));
+ auto coin = make_pair(n, make_pair(pcoin, i));
if (n == nTargetValue)
{
if(!out.fSpendable)
continue;
nValueRet += out.tx->vout[out.i].nValue;
- setCoinsRet.insert(make_pair(out.tx, out.i));
+ setCoinsRet.insert({ out.tx, out.i });
}
return (nValueRet >= nTargetValue);
}
continue;
auto n = pcoin->vout[i].nValue;
- auto coin = make_pair(n,make_pair(pcoin, i));
+ auto coin = make_pair(n, make_pair(pcoin, i));
if (n >= nTargetValue)
{
bool CWallet::CreateTransaction(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl)
{
vector< pair<CScript, int64_t> > vecSend;
- vecSend.push_back(make_pair(scriptPubKey, nValue));
+ vecSend.push_back({ scriptPubKey, nValue });
return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet, coinControl);
}
return keypool.nTime;
}
-std::map<CBitcoinAddress, int64_t> CWallet::GetAddressBalances()
+map<CBitcoinAddress, int64_t> CWallet::GetAddressBalances()
{
map<CBitcoinAddress, int64_t> balances;
}
}
-void CWallet::GetAddresses(std::map<CBitcoinAddress, int64_t> &mapAddresses) const {
+void CWallet::GetAddresses(map<CBitcoinAddress, int64_t> &mapAddresses) const {
mapAddresses.clear();
// get birth times for keys with metadata
}
else {
// multisig output affects more than one key
- std::vector<CKeyID> vAffected;
+ vector<CKeyID> vAffected;
::ExtractAffectedKeys(*this, out.scriptPubKey, vAffected);
for(auto it3 = vAffected.begin(); it3 != vAffected.end(); it3++) {
git://git.novaco.in / novacoin.git / blobdiff