kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Use boost signals for callbacks from main to wallet

0.10
Pieter Wuille 11 years ago
parent
e010af7089
commit
00588c3fac
5 changed files with 77 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 115
      src/main.cpp
  2. 27
      src/main.h
  3. 2
      src/rpcrawtransaction.cpp
  4. 20
      src/wallet.cpp
  5. 9
      src/wallet.h

115
src/main.cpp
Unescape View File

@ -74,75 +74,52 @@ int64 nTransactionFee = 0;
// These functions dispatch to one or all registered wallets // These functions dispatch to one or all registered wallets
namespace {
void RegisterWallet(CWallet* pwalletIn) struct CMainSignals {
{ // Notifies listeners of updated transaction data (passing hash, transaction, and optionally the block it is found in.
{ boost::signals2::signal<void (const uint256 &, const CTransaction &, const CBlock *)> SyncTransaction;
LOCK(cs_setpwalletRegistered); // Notifies listeners of an erased transaction (currently disabled, requires transaction replacement).
setpwalletRegistered.insert(pwalletIn); boost::signals2::signal<void (const uint256 &)> EraseTransaction;
} // Notifies listeners of an updated transaction without new data (for now: a coinbase potentially becoming visible).
} boost::signals2::signal<void (const uint256 &)> UpdatedTransaction;
// Notifies listeners of a new active block chain.
void UnregisterWallet(CWallet* pwalletIn) boost::signals2::signal<void (const CBlockLocator &)> SetBestChain;
{ // Notifies listeners about an inventory item being seen on the network.
{ boost::signals2::signal<void (const uint256 &)> Inventory;
LOCK(cs_setpwalletRegistered); // Tells listeners to broadcast their data.
setpwalletRegistered.erase(pwalletIn); boost::signals2::signal<void ()> Broadcast;
} } g_signals;
}
void UnregisterAllWallets()
{
LOCK(cs_setpwalletRegistered);
setpwalletRegistered.clear();
} }
// erases transaction with the given hash from all wallets void RegisterWallet(CWalletInterface* pwalletIn) {
void static EraseFromWallets(uint256 hash) g_signals.SyncTransaction.connect(boost::bind(&CWalletInterface::SyncTransaction, pwalletIn, _1, _2, _3));
{ g_signals.EraseTransaction.connect(boost::bind(&CWalletInterface::EraseFromWallet, pwalletIn, _1));
LOCK(cs_setpwalletRegistered); g_signals.UpdatedTransaction.connect(boost::bind(&CWalletInterface::UpdatedTransaction, pwalletIn, _1));
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered) g_signals.SetBestChain.connect(boost::bind(&CWalletInterface::SetBestChain, pwalletIn, _1));
pwallet->EraseFromWallet(hash); g_signals.Inventory.connect(boost::bind(&CWalletInterface::Inventory, pwalletIn, _1));
g_signals.Broadcast.connect(boost::bind(&CWalletInterface::ResendWalletTransactions, pwalletIn));
} }
// make sure all wallets know about the given transaction, in the given block void UnregisterWallet(CWalletInterface* pwalletIn) {
void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate) g_signals.Broadcast.disconnect(boost::bind(&CWalletInterface::ResendWalletTransactions, pwalletIn));
{ g_signals.Inventory.disconnect(boost::bind(&CWalletInterface::Inventory, pwalletIn, _1));
LOCK(cs_setpwalletRegistered); g_signals.SetBestChain.disconnect(boost::bind(&CWalletInterface::SetBestChain, pwalletIn, _1));
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered) g_signals.UpdatedTransaction.disconnect(boost::bind(&CWalletInterface::UpdatedTransaction, pwalletIn, _1));
pwallet->AddToWalletIfInvolvingMe(hash, tx, pblock, fUpdate); g_signals.EraseTransaction.disconnect(boost::bind(&CWalletInterface::EraseFromWallet, pwalletIn, _1));
g_signals.SyncTransaction.disconnect(boost::bind(&CWalletInterface::SyncTransaction, pwalletIn, _1, _2, _3));
} }
// notify wallets about a new best chain void UnregisterAllWallets() {
void static SetBestChain(const CBlockLocator& loc) g_signals.Broadcast.disconnect_all_slots();
{ g_signals.Inventory.disconnect_all_slots();
LOCK(cs_setpwalletRegistered); g_signals.SetBestChain.disconnect_all_slots();
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered) g_signals.UpdatedTransaction.disconnect_all_slots();
pwallet->SetBestChain(loc); g_signals.EraseTransaction.disconnect_all_slots();
g_signals.SyncTransaction.disconnect_all_slots();
} }
// notify wallets about an updated transaction void SyncWithWallets(const uint256 &hash, const CTransaction &tx, const CBlock *pblock) {
void static UpdatedTransaction(const uint256& hashTx) g_signals.SyncTransaction(hash, tx, pblock);
{
LOCK(cs_setpwalletRegistered);
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
pwallet->UpdatedTransaction(hashTx);
}
// notify wallets about an incoming inventory (for request counts)
void static Inventory(const uint256& hash)
{
LOCK(cs_setpwalletRegistered);
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
pwallet->Inventory(hash);
}
// ask wallets to resend their transactions
void static ResendWalletTransactions()
{
LOCK(cs_setpwalletRegistered);
BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
pwallet->ResendWalletTransactions();
} }
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -913,8 +890,8 @@ bool CTxMemPool::accept(CValidationState &state, const CTransaction &tx, bool fL
///// are we sure this is ok when loading transactions or restoring block txes ///// are we sure this is ok when loading transactions or restoring block txes
// If updated, erase old tx from wallet // If updated, erase old tx from wallet
if (ptxOld) if (ptxOld)
EraseFromWallets(ptxOld->GetHash()); g_signals.EraseTransaction(ptxOld->GetHash());
SyncWithWallets(hash, tx, NULL, true); g_signals.SyncTransaction(hash, tx, NULL);
LogPrint("mempool", "CTxMemPool::accept() : accepted %s (poolsz %"PRIszu")\n", LogPrint("mempool", "CTxMemPool::accept() : accepted %s (poolsz %"PRIszu")\n",
hash.ToString().c_str(), hash.ToString().c_str(),
@ -1974,7 +1951,7 @@ bool ConnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, C
// Watch for transactions paying to me // Watch for transactions paying to me
for (unsigned int i = 0; i < block.vtx.size(); i++) for (unsigned int i = 0; i < block.vtx.size(); i++)
SyncWithWallets(block.GetTxHash(i), block.vtx[i], &block, true); g_signals.SyncTransaction(block.GetTxHash(i), block.vtx[i], &block);
return true; return true;
} }
@ -2108,7 +2085,7 @@ bool SetBestChain(CValidationState &state, CBlockIndex* pindexNew)
// Update best block in wallet (so we can detect restored wallets) // Update best block in wallet (so we can detect restored wallets)
if ((pindexNew->nHeight % 20160) == 0 || (!fIsInitialDownload && (pindexNew->nHeight % 144) == 0)) if ((pindexNew->nHeight % 20160) == 0 || (!fIsInitialDownload && (pindexNew->nHeight % 144) == 0))
::SetBestChain(chainActive.GetLocator(pindexNew)); g_signals.SetBestChain(chainActive.GetLocator(pindexNew));
// New best block // New best block
nTimeBestReceived = GetTime(); nTimeBestReceived = GetTime();
@ -2188,7 +2165,7 @@ bool AddToBlockIndex(CBlock& block, CValidationState& state, const CDiskBlockPos
CheckForkWarningConditions(); CheckForkWarningConditions();
// Notify UI to display prev block's coinbase if it was ours // Notify UI to display prev block's coinbase if it was ours
static uint256 hashPrevBestCoinBase; static uint256 hashPrevBestCoinBase;
UpdatedTransaction(hashPrevBestCoinBase); g_signals.UpdatedTransaction(hashPrevBestCoinBase);
hashPrevBestCoinBase = block.GetTxHash(0); hashPrevBestCoinBase = block.GetTxHash(0);
} else } else
CheckForkWarningConditionsOnNewFork(pindexNew); CheckForkWarningConditionsOnNewFork(pindexNew);
@ -3311,7 +3288,7 @@ void static ProcessGetData(CNode* pfrom)
} }
// Track requests for our stuff. // Track requests for our stuff.
Inventory(inv.hash); g_signals.Inventory(inv.hash);
} }
} }
@ -3573,7 +3550,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
} }
// Track requests for our stuff // Track requests for our stuff
Inventory(inv.hash); g_signals.Inventory(inv.hash);
} }
} }
@ -4193,7 +4170,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
// transactions become unconfirmed and spams other nodes. // transactions become unconfirmed and spams other nodes.
if (!fReindex && !fImporting && !IsInitialBlockDownload()) if (!fReindex && !fImporting && !IsInitialBlockDownload())
{ {
ResendWalletTransactions(); g_signals.Broadcast();
} }
// //

27
src/main.h
Unescape View File

@ -17,7 +17,6 @@
#include <list> #include <list>
class CWallet;
class CBlock; class CBlock;
class CBlockIndex; class CBlockIndex;
class CKeyItem; class CKeyItem;
@ -81,8 +80,6 @@ extern uint64 nLastBlockTx;
extern uint64 nLastBlockSize; extern uint64 nLastBlockSize;
extern const std::string strMessageMagic; extern const std::string strMessageMagic;
extern int64 nTimeBestReceived; extern int64 nTimeBestReceived;
extern CCriticalSection cs_setpwalletRegistered;
extern std::set<CWallet*> setpwalletRegistered;
extern bool fImporting; extern bool fImporting;
extern bool fReindex; extern bool fReindex;
extern bool fBenchmark; extern bool fBenchmark;
@ -108,17 +105,18 @@ class CCoinsView;
class CCoinsViewCache; class CCoinsViewCache;
class CScriptCheck; class CScriptCheck;
class CValidationState; class CValidationState;
class CWalletInterface;
struct CBlockTemplate; struct CBlockTemplate;
/** Register a wallet to receive updates from core */ /** Register a wallet to receive updates from core */
void RegisterWallet(CWallet* pwalletIn); void RegisterWallet(CWalletInterface* pwalletIn);
/** Unregister a wallet from core */ /** Unregister a wallet from core */
void UnregisterWallet(CWallet* pwalletIn); void UnregisterWallet(CWalletInterface* pwalletIn);
/** Unregister all wallets from core */ /** Unregister all wallets from core */
void UnregisterAllWallets(); void UnregisterAllWallets();
/** Push an updated transaction to all registered wallets */ /** Push an updated transaction to all registered wallets */
void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false); void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL);
/** Register with a network node to receive its signals */ /** Register with a network node to receive its signals */
void RegisterNodeSignals(CNodeSignals& nodeSignals); void RegisterNodeSignals(CNodeSignals& nodeSignals);
@ -190,9 +188,6 @@ bool AbortNode(const std::string &msg);
bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
struct CDiskBlockPos struct CDiskBlockPos
{ {
int nFile; int nFile;
@ -1256,4 +1251,18 @@ public:
) )
}; };
class CWalletInterface {
protected:
virtual void SyncTransaction(const uint256 &hash, const CTransaction &tx, const CBlock *pblock) =0;
virtual void EraseFromWallet(const uint256 &hash) =0;
virtual void SetBestChain(const CBlockLocator &locator) =0;
virtual void UpdatedTransaction(const uint256 &hash) =0;
virtual void Inventory(const uint256 &hash) =0;
virtual void ResendWalletTransactions() =0;
friend void ::RegisterWallet(CWalletInterface*);
friend void ::UnregisterWallet(CWalletInterface*);
friend void ::UnregisterAllWallets();
};
#endif #endif

2
src/rpcrawtransaction.cpp
Unescape View File

@ -560,7 +560,7 @@ Value sendrawtransaction(const Array& params, bool fHelp)
// Not in block, but already in the memory pool; will drop // Not in block, but already in the memory pool; will drop
// through to re-relay it. // through to re-relay it.
} else { } else {
SyncWithWallets(hashTx, tx, NULL, true); SyncWithWallets(hashTx, tx, NULL);
} }
RelayTransaction(tx, hashTx); RelayTransaction(tx, hashTx);

20
src/wallet.cpp
Unescape View File

@ -505,7 +505,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn)
// Add a transaction to the wallet, or update it. // Add a transaction to the wallet, or update it.
// pblock is optional, but should be provided if the transaction is known to be in a block. // pblock is optional, but should be provided if the transaction is known to be in a block.
// If fUpdate is true, existing transactions will be updated. // If fUpdate is true, existing transactions will be updated.
bool CWallet::AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate, bool fFindBlock) bool CWallet::AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate)
{ {
{ {
LOCK(cs_wallet); LOCK(cs_wallet);
@ -525,16 +525,20 @@ bool CWallet::AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction&
return false; return false;
} }
bool CWallet::EraseFromWallet(uint256 hash) void CWallet::SyncTransaction(const uint256 &hash, const CTransaction& tx, const CBlock* pblock) {
AddToWalletIfInvolvingMe(hash, tx, pblock, true);
}
void CWallet::EraseFromWallet(const uint256 &hash)
{ {
if (!fFileBacked) if (!fFileBacked)
return false; return;
{ {
LOCK(cs_wallet); LOCK(cs_wallet);
if (mapWallet.erase(hash)) if (mapWallet.erase(hash))
CWalletDB(strWalletFile).EraseTx(hash); CWalletDB(strWalletFile).EraseTx(hash);
} }
return true; return;
} }
@ -1496,14 +1500,6 @@ bool CWallet::SetDefaultKey(const CPubKey &vchPubKey)
return true; return true;
} }
bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut)
{
if (!pwallet->fFileBacked)
return false;
strWalletFileOut = pwallet->strWalletFile;
return true;
}
// //
// Mark old keypool keys as used, // Mark old keypool keys as used,
// and generate all new keys // and generate all new keys

9
src/wallet.h
Unescape View File

@ -80,7 +80,7 @@ public:
/** A CWallet is an extension of a keystore, which also maintains a set of transactions and balances, /** A CWallet is an extension of a keystore, which also maintains a set of transactions and balances,
* and provides the ability to create new transactions. * and provides the ability to create new transactions.
*/ */
class CWallet : public CCryptoKeyStore class CWallet : public CCryptoKeyStore, public CWalletInterface
{ {
private: private:
bool SelectCoins(int64 nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const; bool SelectCoins(int64 nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const;
@ -197,8 +197,9 @@ public:
void MarkDirty(); void MarkDirty();
bool AddToWallet(const CWalletTx& wtxIn); bool AddToWallet(const CWalletTx& wtxIn);
bool AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate = false, bool fFindBlock = false); void SyncTransaction(const uint256 &hash, const CTransaction& tx, const CBlock* pblock);
bool EraseFromWallet(uint256 hash); bool AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate);
void EraseFromWallet(const uint256 &hash);
void WalletUpdateSpent(const CTransaction& prevout); void WalletUpdateSpent(const CTransaction& prevout);
int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false); int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
void ReacceptWalletTransactions(); void ReacceptWalletTransactions();
@ -887,6 +888,4 @@ private:
std::vector<char> _ssExtra; std::vector<char> _ssExtra;
}; };
bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
#endif #endif

Write Preview
Loading…
Cancel
Save