Merge pull request duality-solutions#359 from duality-solutions/v2.4.22-keypools

AmirAbrams · web-flow · commit 159bbb698af2 · 2019-07-16T00:02:37.000-05:00
Lower size of keypools
diff --git a/src/privatesend-client.h b/src/privatesend-client.h
@@ -33,9 +33,9 @@ static const bool DEFAULT_PRIVATESEND_MULTISESSION = false;
 
 // Warn user if mixing in gui or try to create backup if mixing in daemon mode
 // when we have only this many keys left
-static const int PRIVATESEND_KEYS_THRESHOLD_WARNING = 100;
+static const int PRIVATESEND_KEYS_THRESHOLD_WARNING = 50;
 // Stop mixing completely, it's too dangerous to continue when we have only this many keys left
-static const int PRIVATESEND_KEYS_THRESHOLD_STOP = 50;
+static const int PRIVATESEND_KEYS_THRESHOLD_STOP = 25;
 
 // The main object for accessing mixing
 extern CPrivateSendClientManager privateSendClient;
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -626,10 +626,6 @@ static bool IsCurrentForFeeEstimation()
 // Check if BDAP entry is valid
 bool ValidateBDAPInputs(const CTransactionRef& tx, CValidationState& state, const CCoinsViewCache& inputs, const CBlock& block, bool fJustCheck, int nHeight, bool bSanity)
 {
-    // Do not check while wallet is loading
-    if (!fLoaded)
-        return true;
-
     if (!CheckDomainEntryDB())
         return true;
 
@@ -1946,7 +1942,7 @@ static DisconnectResult DisconnectBlock(const CBlock& block, CValidationState& s
         uint256 hash = tx.GetHash();
         bool is_coinbase = tx.IsCoinBase();
         bool fIsBDAP = tx.nVersion == BDAP_TX_VERSION;
-        if (fIsBDAP) {
+        if (fIsBDAP && !fReindex) {
             LogPrintf("%s -- BDAP tx found. Hash %s\n", __func__, hash.ToString());
             // get BDAP object
             CScript scriptBDAPOp; 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -1441,7 +1441,40 @@ bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlockIndex
                         }
                     }
                 }
-            }
+            } // if tx.nversion END
+        else {
+            BOOST_FOREACH (const CTxOut& txout, tx.vout) {
+                CScript scriptPubKey = txout.scriptPubKey;
+                CTxDestination address1;
+                bool ReserveKey = true;
+
+                if (!ExtractDestination(scriptPubKey, address1)) {
+                        ReserveKey = false;
+                    }
+
+                CDynamicAddress address2(address1);
+                CKeyID keyID;
+
+                if (!address2.GetKeyID(keyID)) {
+                        ReserveKey = false;
+                    }
+                CKey vchSecret;
+                if (!GetKey(keyID, vchSecret)) {
+                        ReserveKey = false;
+                    }
+
+                CPubKey retrievePubKey;
+
+                if (ReserveKey) {
+                        retrievePubKey = vchSecret.GetPubKey();
+                        if (ReserveKeyForTransactions(retrievePubKey)) {
+                            TopUpKeyPoolCombo(0,true);
+                            fNeedToRescanTransactions = true;
+                        }
+                    }
+
+            } //BOOST_FOREACH END
+        }
 
             CWalletTx wtx(this, ptx);
                 
@@ -1595,7 +1628,7 @@ void CWallet::SyncTransaction(const CTransaction& tx, const CBlockIndex* pindex,
     fAnonymizableTallyCachedNonDenom = false;
 
     if (fNeedToUpdateKeyPools) {
-        TopUpKeyPoolCombo();
+        TopUpKeyPoolCombo(0,true);
         fNeedToUpdateKeyPools = false;
     }
 
@@ -2119,10 +2152,15 @@ CBlockIndex* CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool f
             CBlock block;
             if (ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
                 for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
-                    AddToWalletIfInvolvingMe(*block.vtx[posInBlock], pindex, posInBlock, fUpdate); 
+                    AddToWalletIfInvolvingMe(*block.vtx[posInBlock], pindex, posInBlock, fUpdate);
+
+                    if (SaveRescanIndex) {
+                        rescan_index = pindex;    
+                        SaveRescanIndex = false;
+                    }
 
                     if (fNeedToUpdateKeyPools) {
-                        TopUpKeyPoolCombo();
+                        TopUpKeyPoolCombo(0,true);
                         fNeedToUpdateKeyPools = false;
                     }
 
@@ -4581,7 +4619,7 @@ bool CWallet::SyncEdKeyPool()
 
 } //SyncEdKeyPool
 
-bool CWallet::TopUpKeyPoolCombo(unsigned int kpSize)
+bool CWallet::TopUpKeyPoolCombo(unsigned int kpSize, bool fIncreaseSize)
 {
     {
         LOCK(cs_wallet);
@@ -4593,8 +4631,9 @@ bool CWallet::TopUpKeyPoolCombo(unsigned int kpSize)
         unsigned int nTargetSize;
         if (kpSize > 0)
             nTargetSize = kpSize;
-        else
+        else {
             nTargetSize = std::max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t)0);
+        }
 
         // count amount of available keys (internal, external)
         // make sure the keypool of external and internal keys fits the user selected target (-keypool)
@@ -4603,6 +4642,11 @@ bool CWallet::TopUpKeyPoolCombo(unsigned int kpSize)
         int64_t missingExternal = std::max(std::max((int64_t)nTargetSize, (int64_t)1) - amountExternal, (int64_t)0);
         int64_t missingInternal = std::max(std::max((int64_t)nTargetSize, (int64_t)1) - amountInternal, (int64_t)0);
 
+        if (fIncreaseSize) {
+            missingExternal = missingExternal + 2;
+            missingInternal = missingInternal + 2;
+        }
+
         if (!IsHDEnabled()) {
             // don't create extra internal keys
             missingInternal = 0;
@@ -4661,6 +4705,9 @@ bool CWallet::TopUpKeyPoolCombo(unsigned int kpSize)
 
 void CWallet::UpdateKeyPoolsFromTransactions(const std::string& strOpType, const std::vector<std::vector<unsigned char>>& vvchOpParameters)
 {
+    if (vvchOpParameters.size() <= 1)
+        return;
+    
     std::vector<unsigned char> key0 = vvchOpParameters[0];
     std::vector<unsigned char> key1 = vvchOpParameters[1];
 
@@ -4748,6 +4795,7 @@ void CWallet::ReserveEdKeyForTransactions(const std::vector<unsigned char>& pubK
                 fNeedToUpdateKeyPools = true;
                 EraseIndex = true;
                 IndexToErase = nIndex;
+                ReserveKeyCount++;
             }
             it++;
         }
@@ -4763,6 +4811,50 @@ void CWallet::ReserveEdKeyForTransactions(const std::vector<unsigned char>& pubK
 
 } //ReserveEdKeyForTransactions
 
+bool CWallet::ReserveKeyForTransactions(const CPubKey pubKeyToReserve)
+{
+        bool foundPubKey = false;
+
+        CWalletDB walletdb(strWalletFile);
+        CKeyPool keypool;
+        CPubKey PubKey;
+        std::vector<int64_t> keypoolIndexes;
+        bool EraseIndex = false;
+        int64_t IndexToErase = 0;
+        int64_t nIndex = 0;
+        std::set<std::int64_t>::iterator it = setExternalKeyPool.begin();
+
+        while ((it != setExternalKeyPool.end()) && (!EraseIndex)) {
+            nIndex = *it;
+            if (!walletdb.ReadPool(nIndex, keypool)) {
+                throw std::runtime_error(std::string(__func__) + ": read failed");
+            }
+            PubKey = keypool.vchPubKey;
+
+            if(pubKeyToReserve == PubKey) {
+                foundPubKey = true;
+                KeepKey(nIndex);
+                EraseIndex = true;
+                IndexToErase = nIndex;
+                ReserveKeyCount++;
+                SaveRescanIndex = true;
+            }
+            it++;
+        }
+
+        if (EraseIndex) {
+            std::set<int64_t>::iterator eraseIndexEd = setExternalEdKeyPool.find(IndexToErase);
+            std::set<int64_t>::iterator eraseIndex = setExternalKeyPool.find(IndexToErase);
+            if (eraseIndexEd != setExternalKeyPool.end())
+                setExternalEdKeyPool.erase(eraseIndexEd);
+            if (eraseIndex != setExternalKeyPool.end())
+                setExternalKeyPool.erase(eraseIndex);
+        }
+
+        return foundPubKey;
+
+} //ReserveKeyForTransactions
+
 void CWallet::KeepKey(int64_t nIndex)
 {
     // Remove from key pool
@@ -5537,6 +5629,20 @@ CWallet* CWallet::CreateWalletFromFile(const std::string walletFile, const bool
         LogPrintf("Rescanning last %i blocks (from block %i)...\n", chainActive.Height() - pindexRescan->nHeight, pindexRescan->nHeight);
         nStart = GetTimeMillis();
         walletInstance->ScanForWalletTransactions(pindexRescan, true);
+
+        //rescan if boolean is set. go back 100 transactions from most recent transaction involving me.
+        while ((walletInstance->fNeedToRescanTransactions) && (walletInstance->ReserveKeyCount > DEFAULT_RESCAN_THRESHOLD)) {
+            //initialize values
+            walletInstance->fNeedToRescanTransactions = false;
+            walletInstance->ReserveKeyCount = 0;
+
+            CBlockIndex* computed_rescan_index = walletInstance->rescan_index;
+            if (computed_rescan_index->nHeight > 100) {
+                computed_rescan_index = chainActive[computed_rescan_index->nHeight - 100];
+            }
+            walletInstance->ScanForWalletTransactions(computed_rescan_index, true);
+        }
+        
         LogPrintf(" rescan      %15dms\n", GetTimeMillis() - nStart);
         walletInstance->SetBestChain(chainActive.GetLocator());
         CWalletDB::IncrementUpdateCounter();
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -49,7 +49,10 @@ extern unsigned int nTxConfirmTarget;
 extern bool bSpendZeroConfChange;
 extern bool fSendFreeTransactions;
 
-static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
+//Set the following 2 constants together
+static const unsigned int DEFAULT_KEYPOOL_SIZE = 200;
+static const int DEFAULT_RESCAN_THRESHOLD = 150;
+
 //! -paytxfee default
 static const CAmount DEFAULT_TRANSACTION_FEE = 0;
 //! -fallbackfee default
@@ -789,6 +792,8 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
 
     void ReserveEdKeyForTransactions(const std::vector<unsigned char>& pubKeyToReserve);   
 
+    bool ReserveKeyForTransactions(const CPubKey pubKeyToReserve);   
+
     std::array<char, 32> ConvertSecureVector32ToArray(const std::vector<unsigned char, secure_allocator<unsigned char> >& vIn);
 
     bool fFileBacked;
@@ -826,6 +831,11 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
 
     const std::string strWalletFile;
 
+    bool fNeedToRescanTransactions = false;
+    CBlockIndex* rescan_index = nullptr;
+    int ReserveKeyCount = 0;
+    bool SaveRescanIndex = false;
+
     bool WalletNeedsUpgrading()
     {
         return fNeedToUpgradeWallet;
@@ -1148,7 +1158,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     size_t EdKeypoolCountExternalKeys();
     size_t EdKeypoolCountInternalKeys();
     bool SyncEdKeyPool(); 
-    bool TopUpKeyPoolCombo(unsigned int kpSize = 0);
+    bool TopUpKeyPoolCombo(unsigned int kpSize = 0, bool fIncreaseSize = false);
     void ReserveKeysFromKeyPools(int64_t& nIndex, CKeyPool& keypool, CEdKeyPool& edkeypool, bool fInternal);
     void KeepKey(int64_t nIndex);
     void ReturnKey(int64_t nIndex, bool fInternal);
