Use ENABLE_WALLET to wrap wallet fetch functions

dexX7 · dexX7 · commit 7a26c6b88edc · 2015-08-14T01:13:14.000+02:00
And slightly refine the rest:

- use const where possible
- reorder functions
diff --git a/src/omnicore/fetchwallettx.cpp b/src/omnicore/fetchwallettx.cpp
@@ -1,58 +1,92 @@
-// The fetch functions provide a sorted list of transaction hashes ordered by block, position in block and position in wallet including STO receipts
+/**
+ * @file fetchwallettx.cpp
+ *
+ * The fetch functions provide a sorted list of transaction hashes ordered by block,
+ * position in block and position in wallet including STO receipts.
+ */
+
 #include "omnicore/fetchwallettx.h"
 
+#include "omnicore/log.h"
 #include "omnicore/omnicore.h"
 #include "omnicore/pending.h"
 #include "omnicore/utilsbitcoin.h"
 
 #include "init.h"
-#include "wallet.h"
+#include "main.h"
 #include "sync.h"
+#include "tinyformat.h"
+#include "txdb.h"
+#ifdef ENABLE_WALLET
+#include "wallet.h"
+#endif
 
-#include <stdint.h>
+#include <boost/algorithm/string.hpp>
 
-#include <set>
+#include <stdint.h>
+#include <list>
 #include <map>
+#include <set>
 #include <string>
+#include <utility>
+#include <vector>
 
-#include <boost/algorithm/string.hpp>
+namespace mastercore
+{
+/**
+ * Gets the byte offset of a transaction from the transaction index.
+ */
+unsigned int GetTransactionByteOffset(const uint256& txid)
+{
+    LOCK(cs_main);
+
+    CDiskTxPos position;
+    if (pblocktree->ReadTxIndex(txid, position)) {
+        return position.nTxOffset;
+    }
 
-using namespace mastercore;
+    return 0;
+}
 
 /**
-  * Returns an ordered list of Omni transactions including STO receipts that are relevant to the wallet
-  * Ignores order in the wallet (which can be skewed by watch addresses) and utilizes block height and position within block
-  */
-std::map<std::string,uint256> FetchWalletOmniTransactions(int count, int startBlock, int endBlock)
+ * Returns an ordered list of Omni transactions including STO receipts that are relevant to the wallet.
+ *
+ * Ignores order in the wallet (which can be skewed by watch addresses) and utilizes block height and position within block.
+ */
+std::map<std::string, uint256> FetchWalletOmniTransactions(unsigned int count, int startBlock, int endBlock)
 {
-    // Iterate backwards through wallet transactions until we have count items to return:
-    std::map<std::string,uint256> mapResponse;
+    std::map<std::string, uint256> mapResponse;
+#ifdef ENABLE_WALLET
+    if (pwalletMain == NULL) {
+        return mapResponse;
+    }
     std::set<uint256> seenHashes;
     std::list<CAccountingEntry> acentries;
     CWallet::TxItems txOrdered;
     {
         LOCK(pwalletMain->cs_wallet);
         txOrdered = pwalletMain->OrderedTxItems(acentries, "*");
     }
+    // Iterate backwards through wallet transactions until we have count items to return:
     for (CWallet::TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
-        CWalletTx *const pwtx = (*it).second.first;
-        if (pwtx == 0) continue;
-        uint256 txHash = pwtx->GetHash();
+        const CWalletTx* pwtx = it->second.first;
+        if (pwtx == NULL) continue;
+        const uint256& txHash = pwtx->GetHash();
         {
             LOCK(cs_tally);
             if (!p_txlistdb->exists(txHash)) continue;
         }
-        uint256 blockHash = pwtx->hashBlock;
+        const uint256& blockHash = pwtx->hashBlock;
         if ((0 == blockHash) || (NULL == GetBlockIndex(blockHash))) continue;
-        CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
+        const CBlockIndex* pBlockIndex = GetBlockIndex(blockHash);
         if (NULL == pBlockIndex) continue;
         int blockHeight = pBlockIndex->nHeight;
         if (blockHeight < startBlock || blockHeight > endBlock) continue;
         int blockPosition = GetTransactionByteOffset(txHash);
         std::string sortKey = strprintf("%06d%010d", blockHeight, blockPosition);
         mapResponse.insert(std::make_pair(sortKey, txHash));
         seenHashes.insert(txHash);
-        if ((int)mapResponse.size() >= count) break;
+        if (mapResponse.size() >= count) break;
     }
 
     // Insert STO receipts - receiving an STO has no inbound transaction to the wallet, so we will insert these manually into the response
@@ -82,34 +116,27 @@ std::map<std::string,uint256> FetchWalletOmniTransactions(int count, int startBl
     }
 
     // Insert pending transactions (sets block as 999999 and position as wallet position)
-    for (PendingMap::iterator it = my_pending.begin(); it != my_pending.end(); ++it) {
-        uint256 txHash = it->first;
+    // TODO: resolve potential deadlock caused by cs_wallet, cs_pending
+    // LOCK(cs_pending);
+    for (PendingMap::const_iterator it = my_pending.begin(); it != my_pending.end(); ++it) {
+        const uint256& txHash = it->first;
         int blockHeight = 999999;
         if (blockHeight < startBlock || blockHeight > endBlock) continue;
         int blockPosition = 0;
         {
             LOCK(pwalletMain->cs_wallet);
             std::map<uint256, CWalletTx>::const_iterator walletIt = pwalletMain->mapWallet.find(txHash);
             if (walletIt != pwalletMain->mapWallet.end()) {
-                const CWalletTx* pendingWTx = &(*walletIt).second;
-                blockPosition = pendingWTx->nOrderPos;
+                const CWalletTx& wtx = walletIt->second;
+                blockPosition = wtx.nOrderPos;
             }
         }
         std::string sortKey = strprintf("%06d%010d", blockHeight, blockPosition);
         mapResponse.insert(std::make_pair(sortKey, txHash));
     }
-
+#endif
     return mapResponse;
 }
 
-/** Gets the byte offset of a transaction from the tx index
-  */
-uint64_t GetTransactionByteOffset(const uint256& txid)
-{
-    LOCK(cs_main);
-    CDiskTxPos position;
-    if (pblocktree->ReadTxIndex(txid, position)) {
-        return position.nTxOffset;
-    }
-    return 0;
-}
+
+} // namespace mastercore
diff --git a/src/omnicore/fetchwallettx.h b/src/omnicore/fetchwallettx.h
@@ -3,21 +3,16 @@
 
 class uint256;
 
-//#include "util.h"
-#include "txdb.h"
-
-#include <stdint.h>
 #include <map>
 #include <string>
 
-/** Gets the byte offset of a transaction from the tx index
-  */
-uint64_t GetTransactionByteOffset(const uint256& txid);
+namespace mastercore
+{
+/** Gets the byte offset of a transaction from the transaction index. */
+unsigned int GetTransactionByteOffset(const uint256& txid);
 
-/**
-  * Returns an ordered list of Omni transactions that are relevant to the wallet
-  * Ignores order in the wallet (which can be skewed by watch addresses) and utilizes block height and position within block
-  */
-std::map<std::string,uint256> FetchWalletOmniTransactions(int count, int startBlock = 0, int endBlock = 999999);
+/** Returns an ordered list of Omni transactions that are relevant to the wallet. */
+std::map<std::string, uint256> FetchWalletOmniTransactions(unsigned int count, int startBlock = 0, int endBlock = 999999);
+}
 
 #endif // OMNICORE_FETCHWALLETTX_H
