boxtec
/
bitcoin
mirror of https://github.com/bitcoin/bitcoin
4
1
Fork 0
Code Issues Projects Releases Wiki Activity

Use boost signals for callbacks from main to wallet

Browse Source
pull/3115/head
Pieter Wuille 11 years ago
parent e010af7089
commit 00588c3fac
5 changed files with 77 additions and 96 deletions
Show Stats Download Patch File Download Diff File

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