From 5faf29d318bbcfa24770430732c6fb18c0c43f0f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Tue, 19 Sep 2023 00:09:11 +0530
Subject: [PATCH 01/19] refactor: use scoped weak enum instead of bare values
 for address type

strong enums (enum class) cannot be converted implicitly to another
type, requiring you to either use a static_cast or use to_underlying,
which is a part of C++23, which this codebase doesn't support.

the idea of scoping a weak enum into a namespace is courtesy of
https://stackoverflow.com/a/46294875/13845753
---
 src/addressindex.h | 10 ++++++++
 src/core_write.cpp |  5 ++--
 src/rpc/misc.cpp   | 12 ++++-----
 src/spentindex.h   | 13 +++++-----
 src/txmempool.cpp  | 20 +++++++--------
 src/validation.cpp | 64 +++++++++++++++++++++++-----------------------
 6 files changed, 68 insertions(+), 56 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index ea8853a947f5c..4efcbb0f50534 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -11,6 +11,16 @@
 
 #include <chrono>
 
+namespace AddressType {
+enum AddressType {
+    P2PK = 1,
+    P2PKH = 1,
+    P2SH = 2,
+
+    UNKNOWN = 0
+};
+}; /* namespace AddressType */
+
 struct CMempoolAddressDelta
 {
     std::chrono::seconds time;
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 10c82e2149a37..0714dc413cb73 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -14,6 +14,7 @@
 #include <univalue.h>
 #include <util/strencodings.h>
 
+#include <addressindex.h>
 #include <spentindex.h>
 
 #include <evo/assetlocktx.h>
@@ -215,9 +216,9 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
                     auto spentInfo = it->second;
                     in.pushKV("value", ValueFromAmount(spentInfo.satoshis));
                     in.pushKV("valueSat", spentInfo.satoshis);
-                    if (spentInfo.addressType == 1) {
+                    if (spentInfo.addressType == AddressType::P2PK) {
                         in.pushKV("address", EncodeDestination(PKHash(spentInfo.addressHash)));
-                    } else if (spentInfo.addressType == 2) {
+                    } else if (spentInfo.addressType == AddressType::P2SH) {
                         in.pushKV("address", EncodeDestination(ScriptHash(spentInfo.addressHash)));
                     }
                 }
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 56eb970fab868..c6910382ba6f8 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -595,9 +595,9 @@ static UniValue mnauth(const JSONRPCRequest& request)
 
 static bool getAddressFromIndex(const int &type, const uint160 &hash, std::string &address)
 {
-    if (type == 2) {
+    if (type == AddressType::P2SH) {
         address = EncodeDestination(ScriptHash(hash));
-    } else if (type == 1) {
+    } else if (type == AddressType::P2PK) {
         address = EncodeDestination(PKHash(hash));
     } else {
         return false;
@@ -609,12 +609,12 @@ static bool getIndexKey(const std::string& str, uint160& hashBytes, int& type)
 {
     CTxDestination dest = DecodeDestination(str);
     if (!IsValidDestination(dest)) {
-        type = 0;
+        type = AddressType::UNKNOWN;
         return false;
     }
     const PKHash *pkhash = std::get_if<PKHash>(&dest);
     const ScriptHash *scriptID = std::get_if<ScriptHash>(&dest);
-    type = pkhash ? 1 : 2;
+    type = pkhash ? AddressType::P2PK : AddressType::P2SH;
     hashBytes = pkhash ? uint160(*pkhash) : uint160(*scriptID);
     return true;
 }
@@ -623,7 +623,7 @@ static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair
 {
     if (params[0].isStr()) {
         uint160 hashBytes;
-        int type = 0;
+        int type{AddressType::UNKNOWN};
         if (!getIndexKey(params[0].get_str(), hashBytes, type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
         }
@@ -640,7 +640,7 @@ static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair
         for (std::vector<UniValue>::iterator it = values.begin(); it != values.end(); ++it) {
 
             uint160 hashBytes;
-            int type = 0;
+            int type{AddressType::UNKNOWN};
             if (!getIndexKey(it->get_str(), hashBytes, type)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
             }
diff --git a/src/spentindex.h b/src/spentindex.h
index 2de0df571d8f9..f563d651d25b5 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -6,10 +6,11 @@
 #ifndef BITCOIN_SPENTINDEX_H
 #define BITCOIN_SPENTINDEX_H
 
-#include <uint256.h>
+#include <addressindex.h>
 #include <amount.h>
 #include <script/script.h>
 #include <serialize.h>
+#include <uint256.h>
 
 struct CSpentIndexKey {
     uint256 txid;
@@ -67,7 +68,7 @@ struct CSpentIndexValue {
         inputIndex = 0;
         blockHeight = 0;
         satoshis = 0;
-        addressType = 0;
+        addressType = AddressType::UNKNOWN;
         addressHash.SetNull();
     }
 
@@ -189,7 +190,7 @@ struct CAddressUnspentKey {
     }
 
     void SetNull() {
-        type = 0;
+        type = AddressType::UNKNOWN;
         hashBytes.SetNull();
         txhash.SetNull();
         index = 0;
@@ -279,7 +280,7 @@ struct CAddressIndexKey {
     }
 
     void SetNull() {
-        type = 0;
+        type = AddressType::UNKNOWN;
         hashBytes.SetNull();
         blockHeight = 0;
         txindex = 0;
@@ -318,7 +319,7 @@ struct CAddressIndexIteratorKey {
     }
 
     void SetNull() {
-        type = 0;
+        type = AddressType::UNKNOWN;
         hashBytes.SetNull();
     }
 };
@@ -355,7 +356,7 @@ struct CAddressIndexIteratorHeightKey {
     }
 
     void SetNull() {
-        type = 0;
+        type = AddressType::UNKNOWN;
         hashBytes.SetNull();
         blockHeight = 0;
     }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 8328db1167a7d..cf8c69ba594ef 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -476,19 +476,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(2, uint160(hashBytes), txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, 1);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
-            CMempoolAddressDeltaKey key(1, uint160(hashBytes), txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, 1);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2})};
-            CMempoolAddressDeltaKey key(1, hashBytes, txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, 1);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
@@ -499,19 +499,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &out = tx.vout[k];
         if (out.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(2, uint160(hashBytes), txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, 0);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(1, uint160(hashBytes), txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, 0);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(1, hashBytes, txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, 0);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         }
@@ -567,16 +567,16 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
 
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
             addressHash = uint160(std::vector<unsigned char> (prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-            addressType = 2;
+            addressType = AddressType::P2SH;
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
             addressHash = uint160(std::vector<unsigned char> (prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-            addressType = 1;
+            addressType = AddressType::P2PKH;
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
             addressHash = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2});
-            addressType = 1;
+            addressType = AddressType::P2PK;
         } else {
             addressHash.SetNull();
-            addressType = 0;
+            addressType = AddressType::UNKNOWN;
         }
 
         CSpentIndexKey key = CSpentIndexKey(input.prevout.hash, input.prevout.n);
diff --git a/src/validation.cpp b/src/validation.cpp
index e195e0b97067f..ec9da9f259009 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1711,24 +1711,24 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                     std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
 
                     // undo receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
 
                     // undo unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(2, uint160(hashBytes), hash, k), CAddressUnspentValue()));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), hash, k), CAddressUnspentValue()));
 
                 } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
                     std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
 
                     // undo receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
 
                     // undo unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), hash, k), CAddressUnspentValue()));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), hash, k), CAddressUnspentValue()));
 
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
                     uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, hash, k, false), out.nValue));
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, hash, k), CAddressUnspentValue()));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, hash, k, false), out.nValue));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, hash, k), CAddressUnspentValue()));
                 } else {
                     continue;
                 }
@@ -1778,27 +1778,27 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                         std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
 
                         // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
 
                         // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(2, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
 
 
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
                         std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
 
                         // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
 
                         // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
 
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
                         uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2})};
                         // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
                         // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
                     } else {
                         continue;
                     }
@@ -2260,16 +2260,16 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-                        addressType = 2;
+                        addressType = AddressType::P2SH;
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-                        addressType = 1;
+                        addressType = AddressType::P2PKH;
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
                         hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
-                        addressType = 1;
+                        addressType = AddressType::P2PK;
                     } else {
                         hashBytes.SetNull();
-                        addressType = 0;
+                        addressType = AddressType::UNKNOWN;
                     }
 
                     if (fAddressIndex && addressType > 0) {
@@ -2326,24 +2326,24 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                     std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
 
                     // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
 
                     // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(2, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                 } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
                     std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
 
                     // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
 
                     // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
                     uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
                 } else {
                     continue;
                 }
@@ -4866,16 +4866,16 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
 
                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-                        addressType = 2;
+                        addressType = AddressType::P2SH;
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
                         hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-                        addressType = 1;
+                        addressType = AddressType::P2PKH;
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
                         hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
-                        addressType = 1;
+                        addressType = AddressType::P2PK;
                     } else {
                         hashBytes.SetNull();
-                        addressType = 0;
+                        addressType = AddressType::UNKNOWN;
                     }
 
                     if (fAddressIndex && addressType > 0) {
@@ -4902,24 +4902,24 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                         std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
 
                         // record receiving activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(2, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
 
                         // record unspent output
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(2, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                     } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
                         std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
 
                         // record receiving activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(1, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
 
                         // record unspent output
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
 
                     } else if (out.scriptPubKey.IsPayToPublicKey()) {
                         uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(1, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(1, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
                     } else {
                         continue;
                     }

From 5950f7ce3539c5fa7f04f19714ec28e919ad004d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 20:19:30 +0530
Subject: [PATCH 02/19] refactor: cleanup map comparison struct definitions

---
 src/addressindex.h | 22 +++++-----------------
 src/spentindex.h   | 11 ++++++-----
 2 files changed, 11 insertions(+), 22 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index 4efcbb0f50534..ac7720ba68d61 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -10,6 +10,7 @@
 #include <amount.h>
 
 #include <chrono>
+#include <tuple>
 
 namespace AddressType {
 enum AddressType {
@@ -71,23 +72,10 @@ struct CMempoolAddressDeltaKey
 struct CMempoolAddressDeltaKeyCompare
 {
     bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
-        if (a.type == b.type) {
-            if (a.addressBytes == b.addressBytes) {
-                if (a.txhash == b.txhash) {
-                    if (a.index == b.index) {
-                        return a.spending < b.spending;
-                    } else {
-                        return a.index < b.index;
-                    }
-                } else {
-                    return a.txhash < b.txhash;
-                }
-            } else {
-                return a.addressBytes < b.addressBytes;
-            }
-        } else {
-            return a.type < b.type;
-        }
+        auto to_tuple = [](const CMempoolAddressDeltaKey& obj) {
+            return std::tie(obj.type, obj.addressBytes, obj.txhash, obj.index, obj.spending);
+        };
+        return to_tuple(a) < to_tuple(b);
     }
 };
 
diff --git a/src/spentindex.h b/src/spentindex.h
index f563d651d25b5..7dce5de806896 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -12,6 +12,8 @@
 #include <serialize.h>
 #include <uint256.h>
 
+#include <tuple>
+
 struct CSpentIndexKey {
     uint256 txid;
     unsigned int outputIndex;
@@ -80,11 +82,10 @@ struct CSpentIndexValue {
 struct CSpentIndexKeyCompare
 {
     bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const {
-        if (a.txid == b.txid) {
-            return a.outputIndex < b.outputIndex;
-        } else {
-            return a.txid < b.txid;
-        }
+        auto to_tuple = [](const CSpentIndexKey& obj) {
+            return std::tie(obj.txid, obj.outputIndex);
+        };
+        return to_tuple(a) < to_tuple(b);
     }
 };
 

From 12fd3571e307e71d02a6dd17d4144fd59630cce9 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 13 Sep 2023 22:54:19 +0530
Subject: [PATCH 03/19] refactor: use boolean for transaction state, rename
 variable

there are two problems with "int spending;"
- the integer, which implies that there are gradient states when
  there is none, only boolean (vin is spent, vout is UTXO)
- the name, "spending" implies the existence of a middle state,
  there is none

a reason why int may have been used is due to needing it in the
comparison struct CMempoolAddressDeltaKeyCompare, though, using
an int isn't necessary as when used with a comparison operator,
a bool is implicitly converted to an int.

see, https://en.cppreference.com/w/cpp/language/implicit_conversion
(Integral promotion)
---
 src/addressindex.h | 10 +++++-----
 src/spentindex.h   | 10 +++++-----
 src/txmempool.cpp  | 12 ++++++------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index ac7720ba68d61..6fd3c10c51113 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -50,14 +50,14 @@ struct CMempoolAddressDeltaKey
     uint160 addressBytes;
     uint256 txhash;
     unsigned int index;
-    int spending;
+    bool is_spent;
 
-    CMempoolAddressDeltaKey(int addressType, uint160 addressHash, uint256 hash, unsigned int i, int s) {
+    CMempoolAddressDeltaKey(int addressType, uint160 addressHash, uint256 hash, unsigned int i, bool s) {
         type = addressType;
         addressBytes = addressHash;
         txhash = hash;
         index = i;
-        spending = s;
+        is_spent = s;
     }
 
     CMempoolAddressDeltaKey(int addressType, uint160 addressHash) {
@@ -65,7 +65,7 @@ struct CMempoolAddressDeltaKey
         addressBytes = addressHash;
         txhash.SetNull();
         index = 0;
-        spending = 0;
+        is_spent = false;
     }
 };
 
@@ -73,7 +73,7 @@ struct CMempoolAddressDeltaKeyCompare
 {
     bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
         auto to_tuple = [](const CMempoolAddressDeltaKey& obj) {
-            return std::tie(obj.type, obj.addressBytes, obj.txhash, obj.index, obj.spending);
+            return std::tie(obj.type, obj.addressBytes, obj.txhash, obj.index, obj.is_spent);
         };
         return to_tuple(a) < to_tuple(b);
     }
diff --git a/src/spentindex.h b/src/spentindex.h
index 7dce5de806896..bff1b478acb2d 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -236,7 +236,7 @@ struct CAddressIndexKey {
     unsigned int txindex;
     uint256 txhash;
     size_t index;
-    bool spending;
+    bool is_spent;
 
     size_t GetSerializeSize(int nType, int nVersion) const {
         return 66;
@@ -250,7 +250,7 @@ struct CAddressIndexKey {
         ser_writedata32be(s, txindex);
         txhash.Serialize(s);
         ser_writedata32(s, index);
-        char f = spending;
+        char f = is_spent;
         ser_writedata8(s, f);
     }
     template<typename Stream>
@@ -262,7 +262,7 @@ struct CAddressIndexKey {
         txhash.Unserialize(s);
         index = ser_readdata32(s);
         char f = ser_readdata8(s);
-        spending = f;
+        is_spent = f;
     }
 
     CAddressIndexKey(unsigned int addressType, uint160 addressHash, int height, int blockindex,
@@ -273,7 +273,7 @@ struct CAddressIndexKey {
         txindex = blockindex;
         txhash = txid;
         index = indexValue;
-        spending = isSpending;
+        is_spent = isSpending;
     }
 
     CAddressIndexKey() {
@@ -287,7 +287,7 @@ struct CAddressIndexKey {
         txindex = 0;
         txhash.SetNull();
         index = 0;
-        spending = false;
+        is_spent = false;
     }
 
 };
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index cf8c69ba594ef..7a80de2bd6c2a 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -476,19 +476,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, /* is_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, /* is_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2})};
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, 1);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, /* is_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
@@ -499,19 +499,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &out = tx.vout[k];
         if (out.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, /* is_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, /* is_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, 0);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, /* is_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         }

From 53977827ff488ec75383e09a2136026468d96390 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 18 Sep 2023 22:46:04 +0530
Subject: [PATCH 04/19] refactor: cleanup addressindex structs, use
 fixed-length integers

---
 src/addressindex.h | 64 ++++++++++++++++++++--------------------------
 src/rpc/misc.cpp   | 18 ++++++-------
 src/txmempool.cpp  | 14 +++++-----
 3 files changed, 44 insertions(+), 52 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index 6fd3c10c51113..86d40dbad54f1 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -1,5 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2023 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -24,56 +25,47 @@ enum AddressType {
 
 struct CMempoolAddressDelta
 {
-    std::chrono::seconds time;
-    CAmount amount;
-    uint256 prevhash;
-    unsigned int prevout;
+public:
+    std::chrono::seconds m_time;
+    CAmount m_amount;
+    uint256 m_prev_hash;
+    uint32_t m_prev_out{0};
 
-    CMempoolAddressDelta(std::chrono::seconds t, CAmount a, uint256 hash, unsigned int out) {
-        time = t;
-        amount = a;
-        prevhash = hash;
-        prevout = out;
-    }
+public:
+    CMempoolAddressDelta(std::chrono::seconds time, CAmount amount, uint256 prev_hash, uint32_t prev_out) :
+        m_time{time}, m_amount{amount}, m_prev_hash{prev_hash}, m_prev_out{prev_out} {}
 
-    CMempoolAddressDelta(std::chrono::seconds t, CAmount a) {
-        time = t;
-        amount = a;
-        prevhash.SetNull();
-        prevout = 0;
-    }
+    CMempoolAddressDelta(std::chrono::seconds time, CAmount amount) :
+        m_time{time}, m_amount{amount} {}
 };
 
 struct CMempoolAddressDeltaKey
 {
-    int type;
-    uint160 addressBytes;
-    uint256 txhash;
-    unsigned int index;
-    bool is_spent;
+public:
+    int32_t m_address_type;
+    uint160 m_address_bytes;
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+    bool m_tx_spent{false};
 
-    CMempoolAddressDeltaKey(int addressType, uint160 addressHash, uint256 hash, unsigned int i, bool s) {
-        type = addressType;
-        addressBytes = addressHash;
-        txhash = hash;
-        index = i;
-        is_spent = s;
-    }
+public:
+    CMempoolAddressDeltaKey(int32_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
+        m_address_type{address_type},
+        m_address_bytes{address_bytes},
+        m_tx_hash{tx_hash},
+        m_tx_index{tx_index},
+        m_tx_spent{tx_spent} {};
 
-    CMempoolAddressDeltaKey(int addressType, uint160 addressHash) {
-        type = addressType;
-        addressBytes = addressHash;
-        txhash.SetNull();
-        index = 0;
-        is_spent = false;
-    }
+    CMempoolAddressDeltaKey(int32_t address_type, uint160 address_bytes) :
+        m_address_type{address_type},
+        m_address_bytes{address_bytes} {};
 };
 
 struct CMempoolAddressDeltaKeyCompare
 {
     bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
         auto to_tuple = [](const CMempoolAddressDeltaKey& obj) {
-            return std::tie(obj.type, obj.addressBytes, obj.txhash, obj.index, obj.is_spent);
+            return std::tie(obj.m_address_type, obj.m_address_bytes, obj.m_tx_hash, obj.m_tx_index, obj.m_tx_spent);
         };
         return to_tuple(a) < to_tuple(b);
     }
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index c6910382ba6f8..1f535d79c6b49 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -660,7 +660,7 @@ static bool heightSort(std::pair<CAddressUnspentKey, CAddressUnspentValue> a,
 
 static bool timestampSort(std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> a,
                    std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> b) {
-    return a.second.time < b.second.time;
+    return a.second.m_time < b.second.m_time;
 }
 
 static UniValue getaddressmempool(const JSONRPCRequest& request)
@@ -715,19 +715,19 @@ static UniValue getaddressmempool(const JSONRPCRequest& request)
          it != indexes.end(); it++) {
 
         std::string address;
-        if (!getAddressFromIndex(it->first.type, it->first.addressBytes, address)) {
+        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         UniValue delta(UniValue::VOBJ);
         delta.pushKV("address", address);
-        delta.pushKV("txid", it->first.txhash.GetHex());
-        delta.pushKV("index", (int)it->first.index);
-        delta.pushKV("satoshis", it->second.amount);
-        delta.pushKV("timestamp", count_seconds(it->second.time));
-        if (it->second.amount < 0) {
-            delta.pushKV("prevtxid", it->second.prevhash.GetHex());
-            delta.pushKV("prevout", (int)it->second.prevout);
+        delta.pushKV("txid", it->first.m_tx_hash.GetHex());
+        delta.pushKV("index", (int)it->first.m_tx_index);
+        delta.pushKV("satoshis", it->second.m_amount);
+        delta.pushKV("timestamp", count_seconds(it->second.m_time));
+        if (it->second.m_amount < 0) {
+            delta.pushKV("prevtxid", it->second.m_prev_hash.GetHex());
+            delta.pushKV("prevout", (int)it->second.m_prev_out);
         }
         result.push_back(delta);
     }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 7a80de2bd6c2a..c91c9ac34f10c 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -476,19 +476,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &prevout = coin.out;
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, /* is_spent */ true);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, /* tx_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, /* is_spent */ true);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, /* tx_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2})};
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, /* is_spent */ true);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, /* tx_spent */ true);
             CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
             mapAddress.insert(std::make_pair(key, delta));
             inserted.push_back(key);
@@ -499,19 +499,19 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxOut &out = tx.vout[k];
         if (out.scriptPubKey.IsPayToScriptHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, /* is_spent */ false);
+            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, /* tx_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
             std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, /* is_spent */ false);
+            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, /* tx_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         } else if (out.scriptPubKey.IsPayToPublicKey()) {
             uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
             std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, /* is_spent */ false);
+            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, /* tx_spent */ false);
             mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
             inserted.push_back(key);
         }
@@ -526,7 +526,7 @@ bool CTxMemPool::getAddressIndex(std::vector<std::pair<uint160, int> > &addresse
     LOCK(cs);
     for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
         addressDeltaMap::iterator ait = mapAddress.lower_bound(CMempoolAddressDeltaKey((*it).second, (*it).first));
-        while (ait != mapAddress.end() && (*ait).first.addressBytes == (*it).first && (*ait).first.type == (*it).second) {
+        while (ait != mapAddress.end() && (*ait).first.m_address_bytes == (*it).first && (*ait).first.m_address_type == (*it).second) {
             results.push_back(*ait);
             ait++;
         }

From 98e61857fec4acbc69234e68525f42208f1397d1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 13 Sep 2023 21:55:32 +0530
Subject: [PATCH 05/19] refactor: add separators between members, functions and
 serialization

---
 src/spentindex.h | 226 +++++++++++++++++++++++++++--------------------
 1 file changed, 131 insertions(+), 95 deletions(-)

diff --git a/src/spentindex.h b/src/spentindex.h
index bff1b478acb2d..9e36144950fda 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -15,14 +15,11 @@
 #include <tuple>
 
 struct CSpentIndexKey {
+public:
     uint256 txid;
     unsigned int outputIndex;
 
-    SERIALIZE_METHODS(CSpentIndexKey, obj)
-    {
-        READWRITE(obj.txid, obj.outputIndex);
-    }
-
+public:
     CSpentIndexKey(uint256 t, unsigned int i) {
         txid = t;
         outputIndex = i;
@@ -37,9 +34,15 @@ struct CSpentIndexKey {
         outputIndex = 0;
     }
 
+public:
+    SERIALIZE_METHODS(CSpentIndexKey, obj)
+    {
+        READWRITE(obj.txid, obj.outputIndex);
+    }
 };
 
 struct CSpentIndexValue {
+public:
     uint256 txid;
     unsigned int inputIndex;
     int blockHeight;
@@ -47,11 +50,7 @@ struct CSpentIndexValue {
     int addressType;
     uint160 addressHash;
 
-    SERIALIZE_METHODS(CSpentIndexValue, obj)
-    {
-        READWRITE(obj.txid, obj.inputIndex, obj.blockHeight, obj.satoshis, obj.addressType, obj.addressHash);
-    }
-
+public:
     CSpentIndexValue(uint256 t, unsigned int i, int h, CAmount s, int type, uint160 a) {
         txid = t;
         inputIndex = i;
@@ -77,6 +76,12 @@ struct CSpentIndexValue {
     bool IsNull() const {
         return txid.IsNull();
     }
+
+public:
+    SERIALIZE_METHODS(CSpentIndexValue, obj)
+    {
+        READWRITE(obj.txid, obj.inputIndex, obj.blockHeight, obj.satoshis, obj.addressType, obj.addressHash);
+    }
 };
 
 struct CSpentIndexKeyCompare
@@ -95,20 +100,10 @@ struct CSpentIndexTxInfo
 };
 
 struct CTimestampIndexIteratorKey {
+public:
     unsigned int timestamp;
 
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 4;
-    }
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, timestamp);
-    }
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        timestamp = ser_readdata32be(s);
-    }
-
+public:
     CTimestampIndexIteratorKey(unsigned int time) {
         timestamp = time;
     }
@@ -120,26 +115,29 @@ struct CTimestampIndexIteratorKey {
     void SetNull() {
         timestamp = 0;
     }
-};
-
-struct CTimestampIndexKey {
-    unsigned int timestamp;
-    uint256 blockHash;
 
+public:
     size_t GetSerializeSize(int nType, int nVersion) const {
-        return 36;
+        return 4;
     }
+
     template<typename Stream>
     void Serialize(Stream& s) const {
         ser_writedata32be(s, timestamp);
-        blockHash.Serialize(s);
     }
+
     template<typename Stream>
     void Unserialize(Stream& s) {
         timestamp = ser_readdata32be(s);
-        blockHash.Unserialize(s);
     }
+};
+
+struct CTimestampIndexKey {
+public:
+    unsigned int timestamp;
+    uint256 blockHash;
 
+public:
     CTimestampIndexKey(unsigned int time, uint256 hash) {
         timestamp = time;
         blockHash = hash;
@@ -153,32 +151,33 @@ struct CTimestampIndexKey {
         timestamp = 0;
         blockHash.SetNull();
     }
-};
-
-struct CAddressUnspentKey {
-    unsigned int type;
-    uint160 hashBytes;
-    uint256 txhash;
-    size_t index;
 
+public:
     size_t GetSerializeSize(int nType, int nVersion) const {
-        return 57;
+        return 36;
     }
+
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
+        ser_writedata32be(s, timestamp);
+        blockHash.Serialize(s);
     }
+
     template<typename Stream>
     void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
+        timestamp = ser_readdata32be(s);
+        blockHash.Unserialize(s);
     }
+};
+
+struct CAddressUnspentKey {
+public:
+    unsigned int type;
+    uint160 hashBytes;
+    uint256 txhash;
+    size_t index;
 
+public:
     CAddressUnspentKey(unsigned int addressType, uint160 addressHash, uint256 txid, size_t indexValue) {
         type = addressType;
         hashBytes = addressHash;
@@ -196,18 +195,36 @@ struct CAddressUnspentKey {
         txhash.SetNull();
         index = 0;
     }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 57;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, type);
+        hashBytes.Serialize(s);
+        txhash.Serialize(s);
+        ser_writedata32(s, index);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        type = ser_readdata8(s);
+        hashBytes.Unserialize(s);
+        txhash.Unserialize(s);
+        index = ser_readdata32(s);
+    }
 };
 
 struct CAddressUnspentValue {
+public:
     CAmount satoshis;
     CScript script;
     int blockHeight;
 
-    SERIALIZE_METHODS(CAddressUnspentValue, obj)
-    {
-        READWRITE(obj.satoshis, obj.script, obj.blockHeight);
-    }
-
+public:
     CAddressUnspentValue(CAmount sats, CScript scriptPubKey, int height) {
         satoshis = sats;
         script = scriptPubKey;
@@ -227,9 +244,16 @@ struct CAddressUnspentValue {
     bool IsNull() const {
         return (satoshis == -1);
     }
+
+public:
+    SERIALIZE_METHODS(CAddressUnspentValue, obj)
+    {
+        READWRITE(obj.satoshis, obj.script, obj.blockHeight);
+    }
 };
 
 struct CAddressIndexKey {
+public:
     unsigned int type;
     uint160 hashBytes;
     int blockHeight;
@@ -238,33 +262,7 @@ struct CAddressIndexKey {
     size_t index;
     bool is_spent;
 
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 66;
-    }
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        // Heights are stored big-endian for key sorting in LevelDB
-        ser_writedata32be(s, blockHeight);
-        ser_writedata32be(s, txindex);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
-        char f = is_spent;
-        ser_writedata8(s, f);
-    }
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
-        txindex = ser_readdata32be(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
-        char f = ser_readdata8(s);
-        is_spent = f;
-    }
-
+public:
     CAddressIndexKey(unsigned int addressType, uint160 addressHash, int height, int blockindex,
                      uint256 txid, size_t indexValue, bool isSpending) {
         type = addressType;
@@ -290,26 +288,43 @@ struct CAddressIndexKey {
         is_spent = false;
     }
 
-};
-
-struct CAddressIndexIteratorKey {
-    unsigned int type;
-    uint160 hashBytes;
-
+public:
     size_t GetSerializeSize(int nType, int nVersion) const {
-        return 21;
+        return 66;
     }
+
     template<typename Stream>
     void Serialize(Stream& s) const {
         ser_writedata8(s, type);
         hashBytes.Serialize(s);
+        // Heights are stored big-endian for key sorting in LevelDB
+        ser_writedata32be(s, blockHeight);
+        ser_writedata32be(s, txindex);
+        txhash.Serialize(s);
+        ser_writedata32(s, index);
+        char f = is_spent;
+        ser_writedata8(s, f);
     }
+
     template<typename Stream>
     void Unserialize(Stream& s) {
         type = ser_readdata8(s);
         hashBytes.Unserialize(s);
+        blockHeight = ser_readdata32be(s);
+        txindex = ser_readdata32be(s);
+        txhash.Unserialize(s);
+        index = ser_readdata32(s);
+        char f = ser_readdata8(s);
+        is_spent = f;
     }
+};
+
+struct CAddressIndexIteratorKey {
+public:
+    unsigned int type;
+    uint160 hashBytes;
 
+public:
     CAddressIndexIteratorKey(unsigned int addressType, uint160 addressHash) {
         type = addressType;
         hashBytes = addressHash;
@@ -323,29 +338,32 @@ struct CAddressIndexIteratorKey {
         type = AddressType::UNKNOWN;
         hashBytes.SetNull();
     }
-};
-
-struct CAddressIndexIteratorHeightKey {
-    unsigned int type;
-    uint160 hashBytes;
-    int blockHeight;
 
+public:
     size_t GetSerializeSize(int nType, int nVersion) const {
-        return 25;
+        return 21;
     }
+
     template<typename Stream>
     void Serialize(Stream& s) const {
         ser_writedata8(s, type);
         hashBytes.Serialize(s);
-        ser_writedata32be(s, blockHeight);
     }
+
     template<typename Stream>
     void Unserialize(Stream& s) {
         type = ser_readdata8(s);
         hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
     }
+};
 
+struct CAddressIndexIteratorHeightKey {
+public:
+    unsigned int type;
+    uint160 hashBytes;
+    int blockHeight;
+
+public:
     CAddressIndexIteratorHeightKey(unsigned int addressType, uint160 addressHash, int height) {
         type = addressType;
         hashBytes = addressHash;
@@ -361,7 +379,25 @@ struct CAddressIndexIteratorHeightKey {
         hashBytes.SetNull();
         blockHeight = 0;
     }
-};
 
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 25;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, type);
+        hashBytes.Serialize(s);
+        ser_writedata32be(s, blockHeight);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        type = ser_readdata8(s);
+        hashBytes.Unserialize(s);
+        blockHeight = ser_readdata32be(s);
+    }
+};
 
 #endif // BITCOIN_SPENTINDEX_H

From 5c34da06759bc24b34dd95959f407b478e3aeeb1 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 18 Sep 2023 22:47:33 +0530
Subject: [PATCH 06/19] refactor: cleanup spentindex structs, use fixed-length
 integers

---
 src/core_write.cpp |  18 +--
 src/rpc/misc.cpp   |  36 +++---
 src/spentindex.h   | 306 +++++++++++++++++++++------------------------
 src/txdb.cpp       |  10 +-
 4 files changed, 176 insertions(+), 194 deletions(-)

diff --git a/src/core_write.cpp b/src/core_write.cpp
index 0714dc413cb73..c6c329479d844 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -214,12 +214,12 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
                 auto it = ptxSpentInfo->mSpentInfo.find(spentKey);
                 if (it != ptxSpentInfo->mSpentInfo.end()) {
                     auto spentInfo = it->second;
-                    in.pushKV("value", ValueFromAmount(spentInfo.satoshis));
-                    in.pushKV("valueSat", spentInfo.satoshis);
-                    if (spentInfo.addressType == AddressType::P2PK) {
-                        in.pushKV("address", EncodeDestination(PKHash(spentInfo.addressHash)));
-                    } else if (spentInfo.addressType == AddressType::P2SH) {
-                        in.pushKV("address", EncodeDestination(ScriptHash(spentInfo.addressHash)));
+                    in.pushKV("value", ValueFromAmount(spentInfo.m_amount));
+                    in.pushKV("valueSat", spentInfo.m_amount);
+                    if (spentInfo.m_address_type == AddressType::P2PK) {
+                        in.pushKV("address", EncodeDestination(PKHash(spentInfo.m_address_bytes)));
+                    } else if (spentInfo.m_address_type == AddressType::P2SH) {
+                        in.pushKV("address", EncodeDestination(ScriptHash(spentInfo.m_address_bytes)));
                     }
                 }
             }
@@ -249,9 +249,9 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
             auto it = ptxSpentInfo->mSpentInfo.find(spentKey);
             if (it != ptxSpentInfo->mSpentInfo.end()) {
                 auto spentInfo = it->second;
-                out.pushKV("spentTxId", spentInfo.txid.GetHex());
-                out.pushKV("spentIndex", (int)spentInfo.inputIndex);
-                out.pushKV("spentHeight", spentInfo.blockHeight);
+                out.pushKV("spentTxId", spentInfo.m_tx_hash.GetHex());
+                out.pushKV("spentIndex", (int)spentInfo.m_tx_index);
+                out.pushKV("spentHeight", spentInfo.m_block_height);
             }
         }
         vout.push_back(out);
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 1f535d79c6b49..b56d7a5291da6 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -655,7 +655,7 @@ static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair
 
 static bool heightSort(std::pair<CAddressUnspentKey, CAddressUnspentValue> a,
                 std::pair<CAddressUnspentKey, CAddressUnspentValue> b) {
-    return a.second.blockHeight < b.second.blockHeight;
+    return a.second.m_block_height < b.second.m_block_height;
 }
 
 static bool timestampSort(std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> a,
@@ -786,16 +786,16 @@ static UniValue getaddressutxos(const JSONRPCRequest& request)
     for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++) {
         UniValue output(UniValue::VOBJ);
         std::string address;
-        if (!getAddressFromIndex(it->first.type, it->first.hashBytes, address)) {
+        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         output.pushKV("address", address);
-        output.pushKV("txid", it->first.txhash.GetHex());
-        output.pushKV("outputIndex", (int)it->first.index);
-        output.pushKV("script", HexStr(it->second.script));
-        output.pushKV("satoshis", it->second.satoshis);
-        output.pushKV("height", it->second.blockHeight);
+        output.pushKV("txid", it->first.m_tx_hash.GetHex());
+        output.pushKV("outputIndex", (int)it->first.m_tx_index);
+        output.pushKV("script", HexStr(it->second.m_tx_script));
+        output.pushKV("satoshis", it->second.m_amount);
+        output.pushKV("height", it->second.m_block_height);
         result.push_back(output);
     }
 
@@ -871,16 +871,16 @@ static UniValue getaddressdeltas(const JSONRPCRequest& request)
 
     for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
         std::string address;
-        if (!getAddressFromIndex(it->first.type, it->first.hashBytes, address)) {
+        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         UniValue delta(UniValue::VOBJ);
         delta.pushKV("satoshis", it->second);
-        delta.pushKV("txid", it->first.txhash.GetHex());
-        delta.pushKV("index", (int)it->first.index);
-        delta.pushKV("blockindex", (int)it->first.txindex);
-        delta.pushKV("height", it->first.blockHeight);
+        delta.pushKV("txid", it->first.m_tx_hash.GetHex());
+        delta.pushKV("index", (int)it->first.m_tx_index);
+        delta.pushKV("blockindex", (int)it->first.m_block_tx_pos);
+        delta.pushKV("height", it->first.m_block_height);
         delta.pushKV("address", address);
         result.push_back(delta);
     }
@@ -939,7 +939,7 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
         if (it->second > 0) {
             received += it->second;
         }
-        if (it->first.txindex == 0 && nHeight - it->first.blockHeight < COINBASE_MATURITY) {
+        if (it->first.m_block_tx_pos == 0 && nHeight - it->first.m_block_height < COINBASE_MATURITY) {
             balance_immature += it->second;
         } else {
             balance_spendable += it->second;
@@ -1013,8 +1013,8 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
     UniValue result(UniValue::VARR);
 
     for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
-        int height = it->first.blockHeight;
-        std::string txid = it->first.txhash.GetHex();
+        int height = it->first.m_block_height;
+        std::string txid = it->first.m_tx_hash.GetHex();
 
         if (addresses.size() > 1) {
             txids.insert(std::make_pair(height, txid));
@@ -1078,9 +1078,9 @@ static UniValue getspentinfo(const JSONRPCRequest& request)
     }
 
     UniValue obj(UniValue::VOBJ);
-    obj.pushKV("txid", value.txid.GetHex());
-    obj.pushKV("index", (int)value.inputIndex);
-    obj.pushKV("height", value.blockHeight);
+    obj.pushKV("txid", value.m_tx_hash.GetHex());
+    obj.pushKV("index", (int)value.m_tx_index);
+    obj.pushKV("height", value.m_block_height);
 
     return obj;
 }
diff --git a/src/spentindex.h b/src/spentindex.h
index 9e36144950fda..57cc4fce2f102 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -1,5 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2023 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -16,71 +17,69 @@
 
 struct CSpentIndexKey {
 public:
-    uint256 txid;
-    unsigned int outputIndex;
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
 
 public:
-    CSpentIndexKey(uint256 t, unsigned int i) {
-        txid = t;
-        outputIndex = i;
-    }
-
     CSpentIndexKey() {
         SetNull();
     }
 
+    CSpentIndexKey(uint256 txout_hash, uint32_t txout_index) :
+        m_tx_hash{txout_hash}, m_tx_index{txout_index} {};
+
     void SetNull() {
-        txid.SetNull();
-        outputIndex = 0;
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
     }
 
 public:
     SERIALIZE_METHODS(CSpentIndexKey, obj)
     {
-        READWRITE(obj.txid, obj.outputIndex);
+        READWRITE(obj.m_tx_hash, obj.m_tx_index);
     }
 };
 
 struct CSpentIndexValue {
 public:
-    uint256 txid;
-    unsigned int inputIndex;
-    int blockHeight;
-    CAmount satoshis;
-    int addressType;
-    uint160 addressHash;
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+    int32_t m_block_height{0};
+    CAmount m_amount{0};
+    int32_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
 
 public:
-    CSpentIndexValue(uint256 t, unsigned int i, int h, CAmount s, int type, uint160 a) {
-        txid = t;
-        inputIndex = i;
-        blockHeight = h;
-        satoshis = s;
-        addressType = type;
-        addressHash = a;
-    }
-
     CSpentIndexValue() {
         SetNull();
     }
 
+    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, int32_t address_type,
+                     uint160 address_bytes) :
+        m_tx_hash{txin_hash},
+        m_tx_index{txin_index},
+        m_block_height{block_height},
+        m_amount{amount},
+        m_address_type{address_type},
+        m_address_bytes{address_bytes} {};
+
     void SetNull() {
-        txid.SetNull();
-        inputIndex = 0;
-        blockHeight = 0;
-        satoshis = 0;
-        addressType = AddressType::UNKNOWN;
-        addressHash.SetNull();
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+        m_block_height = 0;
+        m_amount = 0;
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
     }
 
     bool IsNull() const {
-        return txid.IsNull();
+        return m_tx_hash.IsNull();
     }
 
 public:
     SERIALIZE_METHODS(CSpentIndexValue, obj)
     {
-        READWRITE(obj.txid, obj.inputIndex, obj.blockHeight, obj.satoshis, obj.addressType, obj.addressHash);
+        READWRITE(obj.m_tx_hash, obj.m_tx_index, obj.m_block_height, obj.m_amount, obj.m_address_type, obj.m_address_bytes);
     }
 };
 
@@ -88,7 +87,7 @@ struct CSpentIndexKeyCompare
 {
     bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const {
         auto to_tuple = [](const CSpentIndexKey& obj) {
-            return std::tie(obj.txid, obj.outputIndex);
+            return std::tie(obj.m_tx_hash, obj.m_tx_index);
         };
         return to_tuple(a) < to_tuple(b);
     }
@@ -101,19 +100,17 @@ struct CSpentIndexTxInfo
 
 struct CTimestampIndexIteratorKey {
 public:
-    unsigned int timestamp;
+    uint32_t m_time;
 
 public:
-    CTimestampIndexIteratorKey(unsigned int time) {
-        timestamp = time;
-    }
-
     CTimestampIndexIteratorKey() {
         SetNull();
     }
 
+    CTimestampIndexIteratorKey(uint32_t time) : m_time{time} {};
+
     void SetNull() {
-        timestamp = 0;
+        m_time = 0;
     }
 
 public:
@@ -123,33 +120,31 @@ struct CTimestampIndexIteratorKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata32be(s, timestamp);
+        ser_writedata32be(s, m_time);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        timestamp = ser_readdata32be(s);
+        m_time = ser_readdata32be(s);
     }
 };
 
 struct CTimestampIndexKey {
 public:
-    unsigned int timestamp;
-    uint256 blockHash;
+    uint32_t m_block_time;
+    uint256 m_block_hash;
 
 public:
-    CTimestampIndexKey(unsigned int time, uint256 hash) {
-        timestamp = time;
-        blockHash = hash;
-    }
-
     CTimestampIndexKey() {
         SetNull();
     }
 
+    CTimestampIndexKey(uint32_t block_time, uint256 block_hash) :
+        m_block_time{block_time}, m_block_hash{block_hash} {};
+
     void SetNull() {
-        timestamp = 0;
-        blockHash.SetNull();
+        m_block_time = 0;
+        m_block_hash.SetNull();
     }
 
 public:
@@ -159,41 +154,37 @@ struct CTimestampIndexKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata32be(s, timestamp);
-        blockHash.Serialize(s);
+        ser_writedata32be(s, m_block_time);
+        m_block_hash.Serialize(s);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        timestamp = ser_readdata32be(s);
-        blockHash.Unserialize(s);
+        m_block_time = ser_readdata32be(s);
+        m_block_hash.Unserialize(s);
     }
 };
 
 struct CAddressUnspentKey {
 public:
-    unsigned int type;
-    uint160 hashBytes;
-    uint256 txhash;
-    size_t index;
+    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    uint256 m_tx_hash;
+    size_t m_tx_index{0};
 
 public:
-    CAddressUnspentKey(unsigned int addressType, uint160 addressHash, uint256 txid, size_t indexValue) {
-        type = addressType;
-        hashBytes = addressHash;
-        txhash = txid;
-        index = indexValue;
-    }
-
     CAddressUnspentKey() {
         SetNull();
     }
 
+    CAddressUnspentKey(uint32_t address_type, uint160 address_bytes, uint256 tx_hash, size_t tx_index) :
+        m_address_type{address_type}, m_address_bytes{address_bytes}, m_tx_hash{tx_hash}, m_tx_index{tx_index} {};
+
     void SetNull() {
-        type = AddressType::UNKNOWN;
-        hashBytes.SetNull();
-        txhash.SetNull();
-        index = 0;
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
     }
 
 public:
@@ -203,89 +194,85 @@ struct CAddressUnspentKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
+        m_tx_hash.Serialize(s);
+        ser_writedata32(s, m_tx_index);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+        m_tx_hash.Unserialize(s);
+        m_tx_index = ser_readdata32(s);
     }
 };
 
 struct CAddressUnspentValue {
 public:
-    CAmount satoshis;
-    CScript script;
-    int blockHeight;
+    CAmount m_amount{-1};
+    CScript m_tx_script;
+    int32_t m_block_height;
 
 public:
-    CAddressUnspentValue(CAmount sats, CScript scriptPubKey, int height) {
-        satoshis = sats;
-        script = scriptPubKey;
-        blockHeight = height;
-    }
-
     CAddressUnspentValue() {
         SetNull();
     }
 
+    CAddressUnspentValue(CAmount amount, CScript tx_script, int32_t block_height) :
+        m_amount{amount}, m_tx_script{tx_script}, m_block_height{block_height} {};
+
     void SetNull() {
-        satoshis = -1;
-        script.clear();
-        blockHeight = 0;
+        m_amount = -1;
+        m_tx_script.clear();
+        m_block_height = 0;
     }
 
     bool IsNull() const {
-        return (satoshis == -1);
+        return (m_amount == -1);
     }
 
 public:
     SERIALIZE_METHODS(CAddressUnspentValue, obj)
     {
-        READWRITE(obj.satoshis, obj.script, obj.blockHeight);
+        READWRITE(obj.m_amount, obj.m_tx_script, obj.m_block_height);
     }
 };
 
 struct CAddressIndexKey {
 public:
-    unsigned int type;
-    uint160 hashBytes;
-    int blockHeight;
-    unsigned int txindex;
-    uint256 txhash;
-    size_t index;
-    bool is_spent;
+    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    int32_t m_block_height{0};
+    uint32_t m_block_tx_pos{0};
+    uint256 m_tx_hash;
+    size_t m_tx_index{0};
+    bool m_tx_spent{false};
 
 public:
-    CAddressIndexKey(unsigned int addressType, uint160 addressHash, int height, int blockindex,
-                     uint256 txid, size_t indexValue, bool isSpending) {
-        type = addressType;
-        hashBytes = addressHash;
-        blockHeight = height;
-        txindex = blockindex;
-        txhash = txid;
-        index = indexValue;
-        is_spent = isSpending;
-    }
-
     CAddressIndexKey() {
         SetNull();
     }
 
+    CAddressIndexKey(uint32_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
+                     size_t tx_index, bool tx_spent) :
+        m_address_type{address_type},
+        m_address_bytes{address_bytes},
+        m_block_height{block_height},
+        m_block_tx_pos{block_tx_pos},
+        m_tx_hash{tx_hash},
+        m_tx_index{tx_index},
+        m_tx_spent{tx_spent} {};
+
     void SetNull() {
-        type = AddressType::UNKNOWN;
-        hashBytes.SetNull();
-        blockHeight = 0;
-        txindex = 0;
-        txhash.SetNull();
-        index = 0;
-        is_spent = false;
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_block_height = 0;
+        m_block_tx_pos = 0;
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+        m_tx_spent = false;
     }
 
 public:
@@ -295,48 +282,46 @@ struct CAddressIndexKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
         // Heights are stored big-endian for key sorting in LevelDB
-        ser_writedata32be(s, blockHeight);
-        ser_writedata32be(s, txindex);
-        txhash.Serialize(s);
-        ser_writedata32(s, index);
-        char f = is_spent;
+        ser_writedata32be(s, m_block_height);
+        ser_writedata32be(s, m_block_tx_pos);
+        m_tx_hash.Serialize(s);
+        ser_writedata32(s, m_tx_index);
+        char f = m_tx_spent;
         ser_writedata8(s, f);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
-        txindex = ser_readdata32be(s);
-        txhash.Unserialize(s);
-        index = ser_readdata32(s);
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+        m_block_height = ser_readdata32be(s);
+        m_block_tx_pos = ser_readdata32be(s);
+        m_tx_hash.Unserialize(s);
+        m_tx_index = ser_readdata32(s);
         char f = ser_readdata8(s);
-        is_spent = f;
+        m_tx_spent = f;
     }
 };
 
 struct CAddressIndexIteratorKey {
 public:
-    unsigned int type;
-    uint160 hashBytes;
+    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
 
 public:
-    CAddressIndexIteratorKey(unsigned int addressType, uint160 addressHash) {
-        type = addressType;
-        hashBytes = addressHash;
-    }
-
     CAddressIndexIteratorKey() {
         SetNull();
     }
 
+    CAddressIndexIteratorKey(uint32_t address_type, uint160 address_bytes) :
+        m_address_type{address_type}, m_address_bytes{address_bytes} {};
+
     void SetNull() {
-        type = AddressType::UNKNOWN;
-        hashBytes.SetNull();
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
     }
 
 public:
@@ -346,38 +331,35 @@ struct CAddressIndexIteratorKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
     }
 };
 
 struct CAddressIndexIteratorHeightKey {
 public:
-    unsigned int type;
-    uint160 hashBytes;
-    int blockHeight;
+    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    int32_t m_block_height{0};
 
 public:
-    CAddressIndexIteratorHeightKey(unsigned int addressType, uint160 addressHash, int height) {
-        type = addressType;
-        hashBytes = addressHash;
-        blockHeight = height;
-    }
-
     CAddressIndexIteratorHeightKey() {
         SetNull();
     }
 
+    CAddressIndexIteratorHeightKey(uint32_t address_type, uint160 address_bytes, int32_t block_height) :
+        m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
+
     void SetNull() {
-        type = AddressType::UNKNOWN;
-        hashBytes.SetNull();
-        blockHeight = 0;
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_block_height = 0;
     }
 
 public:
@@ -387,16 +369,16 @@ struct CAddressIndexIteratorHeightKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, type);
-        hashBytes.Serialize(s);
-        ser_writedata32be(s, blockHeight);
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
+        ser_writedata32be(s, m_block_height);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        type = ser_readdata8(s);
-        hashBytes.Unserialize(s);
-        blockHeight = ser_readdata32be(s);
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+        m_block_height = ser_readdata32be(s);
     }
 };
 
diff --git a/src/txdb.cpp b/src/txdb.cpp
index d2c731ef12083..1fc8094f47d31 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -275,7 +275,7 @@ bool CBlockTreeDB::ReadAddressUnspentIndex(uint160 addressHash, int type,
 
     while (pcursor->Valid()) {
         std::pair<char,CAddressUnspentKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSUNSPENTINDEX && key.second.hashBytes == addressHash) {
+        if (pcursor->GetKey(key) && key.first == DB_ADDRESSUNSPENTINDEX && key.second.m_address_bytes == addressHash) {
             CAddressUnspentValue nValue;
             if (pcursor->GetValue(nValue)) {
                 unspentOutputs.push_back(std::make_pair(key.second, nValue));
@@ -319,8 +319,8 @@ bool CBlockTreeDB::ReadAddressIndex(uint160 addressHash, int type,
 
     while (pcursor->Valid()) {
         std::pair<char,CAddressIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSINDEX && key.second.hashBytes == addressHash) {
-            if (end > 0 && key.second.blockHeight > end) {
+        if (pcursor->GetKey(key) && key.first == DB_ADDRESSINDEX && key.second.m_address_bytes == addressHash) {
+            if (end > 0 && key.second.m_block_height > end) {
                 break;
             }
             CAmount nValue;
@@ -359,8 +359,8 @@ bool CBlockTreeDB::ReadTimestampIndex(const unsigned int &high, const unsigned i
 
     while (pcursor->Valid()) {
         std::pair<char, CTimestampIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_TIMESTAMPINDEX && key.second.timestamp <= high) {
-            hashes.push_back(key.second.blockHash);
+        if (pcursor->GetKey(key) && key.first == DB_TIMESTAMPINDEX && key.second.m_block_time <= high) {
+            hashes.push_back(key.second.m_block_hash);
             pcursor->Next();
         } else {
             break;

From 6a5e74eff4b2f526a61ac8db54752bc1e4377148 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 13 Sep 2023 22:22:54 +0530
Subject: [PATCH 07/19] refactor: use uint8_t for m_address_type

m_address_type is (de)serialized using ser_writedata8, making the maximum
numbers of bits read or written to, 8. AddressType does not have values
below 0, therefore the data type is changed to better reflect the way
it is stored.
---
 src/addressindex.h |  6 +++---
 src/spentindex.h   | 20 ++++++++++----------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index 86d40dbad54f1..4dac5eb74fa65 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -42,21 +42,21 @@ struct CMempoolAddressDelta
 struct CMempoolAddressDeltaKey
 {
 public:
-    int32_t m_address_type;
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     uint256 m_tx_hash;
     uint32_t m_tx_index{0};
     bool m_tx_spent{false};
 
 public:
-    CMempoolAddressDeltaKey(int32_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
+    CMempoolAddressDeltaKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
         m_tx_hash{tx_hash},
         m_tx_index{tx_index},
         m_tx_spent{tx_spent} {};
 
-    CMempoolAddressDeltaKey(int32_t address_type, uint160 address_bytes) :
+    CMempoolAddressDeltaKey(uint8_t address_type, uint160 address_bytes) :
         m_address_type{address_type},
         m_address_bytes{address_bytes} {};
 };
diff --git a/src/spentindex.h b/src/spentindex.h
index 57cc4fce2f102..627a8ceda351a 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -46,7 +46,7 @@ struct CSpentIndexValue {
     uint32_t m_tx_index{0};
     int32_t m_block_height{0};
     CAmount m_amount{0};
-    int32_t m_address_type{AddressType::UNKNOWN};
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
 
 public:
@@ -54,7 +54,7 @@ struct CSpentIndexValue {
         SetNull();
     }
 
-    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, int32_t address_type,
+    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, uint8_t address_type,
                      uint160 address_bytes) :
         m_tx_hash{txin_hash},
         m_tx_index{txin_index},
@@ -167,7 +167,7 @@ struct CTimestampIndexKey {
 
 struct CAddressUnspentKey {
 public:
-    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     uint256 m_tx_hash;
     size_t m_tx_index{0};
@@ -177,7 +177,7 @@ struct CAddressUnspentKey {
         SetNull();
     }
 
-    CAddressUnspentKey(uint32_t address_type, uint160 address_bytes, uint256 tx_hash, size_t tx_index) :
+    CAddressUnspentKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, size_t tx_index) :
         m_address_type{address_type}, m_address_bytes{address_bytes}, m_tx_hash{tx_hash}, m_tx_index{tx_index} {};
 
     void SetNull() {
@@ -242,7 +242,7 @@ struct CAddressUnspentValue {
 
 struct CAddressIndexKey {
 public:
-    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     int32_t m_block_height{0};
     uint32_t m_block_tx_pos{0};
@@ -255,7 +255,7 @@ struct CAddressIndexKey {
         SetNull();
     }
 
-    CAddressIndexKey(uint32_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
+    CAddressIndexKey(uint8_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
                      size_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
@@ -308,7 +308,7 @@ struct CAddressIndexKey {
 
 struct CAddressIndexIteratorKey {
 public:
-    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
 
 public:
@@ -316,7 +316,7 @@ struct CAddressIndexIteratorKey {
         SetNull();
     }
 
-    CAddressIndexIteratorKey(uint32_t address_type, uint160 address_bytes) :
+    CAddressIndexIteratorKey(uint8_t address_type, uint160 address_bytes) :
         m_address_type{address_type}, m_address_bytes{address_bytes} {};
 
     void SetNull() {
@@ -344,7 +344,7 @@ struct CAddressIndexIteratorKey {
 
 struct CAddressIndexIteratorHeightKey {
 public:
-    uint32_t m_address_type{AddressType::UNKNOWN};
+    uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     int32_t m_block_height{0};
 
@@ -353,7 +353,7 @@ struct CAddressIndexIteratorHeightKey {
         SetNull();
     }
 
-    CAddressIndexIteratorHeightKey(uint32_t address_type, uint160 address_bytes, int32_t block_height) :
+    CAddressIndexIteratorHeightKey(uint8_t address_type, uint160 address_bytes, int32_t block_height) :
         m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
 
     void SetNull() {

From fc2d193d07c30c8b7a42ded557a50632157fa379 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Wed, 13 Sep 2023 22:58:06 +0530
Subject: [PATCH 08/19] refactor: remove size_t usage in spentindex structs

the size of size_t is platform-dependent, (de)serialization is done
assuming the the value is 32 bits. changed to uint32_t as index value
cannot be less than zero.
---
 src/spentindex.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/spentindex.h b/src/spentindex.h
index 627a8ceda351a..bdabee9c367f7 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -170,14 +170,14 @@ struct CAddressUnspentKey {
     uint8_t m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     uint256 m_tx_hash;
-    size_t m_tx_index{0};
+    uint32_t m_tx_index{0};
 
 public:
     CAddressUnspentKey() {
         SetNull();
     }
 
-    CAddressUnspentKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, size_t tx_index) :
+    CAddressUnspentKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index) :
         m_address_type{address_type}, m_address_bytes{address_bytes}, m_tx_hash{tx_hash}, m_tx_index{tx_index} {};
 
     void SetNull() {
@@ -247,7 +247,7 @@ struct CAddressIndexKey {
     int32_t m_block_height{0};
     uint32_t m_block_tx_pos{0};
     uint256 m_tx_hash;
-    size_t m_tx_index{0};
+    uint32_t m_tx_index{0};
     bool m_tx_spent{false};
 
 public:
@@ -256,7 +256,7 @@ struct CAddressIndexKey {
     }
 
     CAddressIndexKey(uint8_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
-                     size_t tx_index, bool tx_spent) :
+                     uint32_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
         m_block_height{block_height},

From ce3b5acae41497ec928286e1eb8ec0f1526aabe3 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 14 Sep 2023 15:10:35 +0530
Subject: [PATCH 09/19] docs: add BitPay copyright to file headers

---
 src/addressindex.h | 1 +
 src/spentindex.h   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/addressindex.h b/src/addressindex.h
index 4dac5eb74fa65..a00b6e5b70f8e 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -1,5 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016 BitPay, Inc.
 // Copyright (c) 2023 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
diff --git a/src/spentindex.h b/src/spentindex.h
index bdabee9c367f7..b7b5a60aa42be 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -1,5 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016 BitPay, Inc.
 // Copyright (c) 2023 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

From cc2efac4b4766ebe5525c49b8f97ea3fad078152 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Thu, 14 Sep 2023 22:24:58 +0530
Subject: [PATCH 10/19] refactor: move timestamp index out of spentindex

---
 src/Makefile.am      |  1 +
 src/spentindex.h     | 67 -------------------------------------
 src/timestampindex.h | 80 ++++++++++++++++++++++++++++++++++++++++++++
 src/txdb.h           |  1 +
 4 files changed, 82 insertions(+), 67 deletions(-)
 create mode 100644 src/timestampindex.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 9145ad2380c52..02c80d3e57a1e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -297,6 +297,7 @@ BITCOIN_CORE_H = \
   support/events.h \
   support/lockedpool.h \
   sync.h \
+  timestampindex.h \
   threadsafety.h \
   threadinterrupt.h \
   timedata.h \
diff --git a/src/spentindex.h b/src/spentindex.h
index b7b5a60aa42be..3c03d66e955ba 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -99,73 +99,6 @@ struct CSpentIndexTxInfo
     std::map<CSpentIndexKey, CSpentIndexValue, CSpentIndexKeyCompare> mSpentInfo;
 };
 
-struct CTimestampIndexIteratorKey {
-public:
-    uint32_t m_time;
-
-public:
-    CTimestampIndexIteratorKey() {
-        SetNull();
-    }
-
-    CTimestampIndexIteratorKey(uint32_t time) : m_time{time} {};
-
-    void SetNull() {
-        m_time = 0;
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 4;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, m_time);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_time = ser_readdata32be(s);
-    }
-};
-
-struct CTimestampIndexKey {
-public:
-    uint32_t m_block_time;
-    uint256 m_block_hash;
-
-public:
-    CTimestampIndexKey() {
-        SetNull();
-    }
-
-    CTimestampIndexKey(uint32_t block_time, uint256 block_hash) :
-        m_block_time{block_time}, m_block_hash{block_hash} {};
-
-    void SetNull() {
-        m_block_time = 0;
-        m_block_hash.SetNull();
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 36;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, m_block_time);
-        m_block_hash.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_block_time = ser_readdata32be(s);
-        m_block_hash.Unserialize(s);
-    }
-};
-
 struct CAddressUnspentKey {
 public:
     uint8_t m_address_type{AddressType::UNKNOWN};
diff --git a/src/timestampindex.h b/src/timestampindex.h
new file mode 100644
index 0000000000000..a1e300bfda938
--- /dev/null
+++ b/src/timestampindex.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016 BitPay, Inc.
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TIMESTAMPINDEX_H
+#define BITCOIN_TIMESTAMPINDEX_H
+
+#include <uint256.h>
+
+struct CTimestampIndexIteratorKey {
+public:
+    uint32_t m_time;
+
+public:
+    CTimestampIndexIteratorKey() {
+        SetNull();
+    }
+
+    CTimestampIndexIteratorKey(uint32_t time) : m_time{time} {};
+
+    void SetNull() {
+        m_time = 0;
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 4;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata32be(s, m_time);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        m_time = ser_readdata32be(s);
+    }
+};
+
+struct CTimestampIndexKey {
+public:
+    uint32_t m_block_time;
+    uint256 m_block_hash;
+
+public:
+    CTimestampIndexKey() {
+        SetNull();
+    }
+
+    CTimestampIndexKey(uint32_t block_time, uint256 block_hash) :
+        m_block_time{block_time}, m_block_hash{block_hash} {};
+
+    void SetNull() {
+        m_block_time = 0;
+        m_block_hash.SetNull();
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 36;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata32be(s, m_block_time);
+        m_block_hash.Serialize(s);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        m_block_time = ser_readdata32be(s);
+        m_block_hash.Unserialize(s);
+    }
+};
+
+#endif // BITCOIN_TIMESTAMPINDEX_H
diff --git a/src/txdb.h b/src/txdb.h
index bac6c8bb58bdf..9b73e4780b564 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -11,6 +11,7 @@
 #include <chain.h>
 #include <primitives/block.h>
 #include <spentindex.h>
+#include <timestampindex.h>
 
 #include <memory>
 #include <string>

From 0cc321cd8cb6301e6fd1a26aa00cd2da131a4479 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 20:25:34 +0530
Subject: [PATCH 11/19] refactor: move CAddressIndex* out of spentindex

---
 src/addressindex.h | 142 +++++++++++++++++++++++++++++++++++++++++++++
 src/spentindex.h   | 142 ---------------------------------------------
 2 files changed, 142 insertions(+), 142 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index a00b6e5b70f8e..ed3225e3c19f9 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -72,4 +72,146 @@ struct CMempoolAddressDeltaKeyCompare
     }
 };
 
+struct CAddressIndexKey {
+public:
+    uint8_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    int32_t m_block_height{0};
+    uint32_t m_block_tx_pos{0};
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+    bool m_tx_spent{false};
+
+public:
+    CAddressIndexKey() {
+        SetNull();
+    }
+
+    CAddressIndexKey(uint8_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
+                     uint32_t tx_index, bool tx_spent) :
+        m_address_type{address_type},
+        m_address_bytes{address_bytes},
+        m_block_height{block_height},
+        m_block_tx_pos{block_tx_pos},
+        m_tx_hash{tx_hash},
+        m_tx_index{tx_index},
+        m_tx_spent{tx_spent} {};
+
+    void SetNull() {
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_block_height = 0;
+        m_block_tx_pos = 0;
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+        m_tx_spent = false;
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 66;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
+        // Heights are stored big-endian for key sorting in LevelDB
+        ser_writedata32be(s, m_block_height);
+        ser_writedata32be(s, m_block_tx_pos);
+        m_tx_hash.Serialize(s);
+        ser_writedata32(s, m_tx_index);
+        char f = m_tx_spent;
+        ser_writedata8(s, f);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+        m_block_height = ser_readdata32be(s);
+        m_block_tx_pos = ser_readdata32be(s);
+        m_tx_hash.Unserialize(s);
+        m_tx_index = ser_readdata32(s);
+        char f = ser_readdata8(s);
+        m_tx_spent = f;
+    }
+};
+
+struct CAddressIndexIteratorKey {
+public:
+    uint8_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+
+public:
+    CAddressIndexIteratorKey() {
+        SetNull();
+    }
+
+    CAddressIndexIteratorKey(uint8_t address_type, uint160 address_bytes) :
+        m_address_type{address_type}, m_address_bytes{address_bytes} {};
+
+    void SetNull() {
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 21;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+    }
+};
+
+struct CAddressIndexIteratorHeightKey {
+public:
+    uint8_t m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    int32_t m_block_height{0};
+
+public:
+    CAddressIndexIteratorHeightKey() {
+        SetNull();
+    }
+
+    CAddressIndexIteratorHeightKey(uint8_t address_type, uint160 address_bytes, int32_t block_height) :
+        m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
+
+    void SetNull() {
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_block_height = 0;
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const {
+        return 25;
+    }
+
+    template<typename Stream>
+    void Serialize(Stream& s) const {
+        ser_writedata8(s, m_address_type);
+        m_address_bytes.Serialize(s);
+        ser_writedata32be(s, m_block_height);
+    }
+
+    template<typename Stream>
+    void Unserialize(Stream& s) {
+        m_address_type = ser_readdata8(s);
+        m_address_bytes.Unserialize(s);
+        m_block_height = ser_readdata32be(s);
+    }
+};
+
 #endif // BITCOIN_ADDRESSINDEX_H
diff --git a/src/spentindex.h b/src/spentindex.h
index 3c03d66e955ba..7bf4e58b071e1 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -174,146 +174,4 @@ struct CAddressUnspentValue {
     }
 };
 
-struct CAddressIndexKey {
-public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
-    uint160 m_address_bytes;
-    int32_t m_block_height{0};
-    uint32_t m_block_tx_pos{0};
-    uint256 m_tx_hash;
-    uint32_t m_tx_index{0};
-    bool m_tx_spent{false};
-
-public:
-    CAddressIndexKey() {
-        SetNull();
-    }
-
-    CAddressIndexKey(uint8_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
-                     uint32_t tx_index, bool tx_spent) :
-        m_address_type{address_type},
-        m_address_bytes{address_bytes},
-        m_block_height{block_height},
-        m_block_tx_pos{block_tx_pos},
-        m_tx_hash{tx_hash},
-        m_tx_index{tx_index},
-        m_tx_spent{tx_spent} {};
-
-    void SetNull() {
-        m_address_type = AddressType::UNKNOWN;
-        m_address_bytes.SetNull();
-        m_block_height = 0;
-        m_block_tx_pos = 0;
-        m_tx_hash.SetNull();
-        m_tx_index = 0;
-        m_tx_spent = false;
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 66;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
-        m_address_bytes.Serialize(s);
-        // Heights are stored big-endian for key sorting in LevelDB
-        ser_writedata32be(s, m_block_height);
-        ser_writedata32be(s, m_block_tx_pos);
-        m_tx_hash.Serialize(s);
-        ser_writedata32(s, m_tx_index);
-        char f = m_tx_spent;
-        ser_writedata8(s, f);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
-        m_address_bytes.Unserialize(s);
-        m_block_height = ser_readdata32be(s);
-        m_block_tx_pos = ser_readdata32be(s);
-        m_tx_hash.Unserialize(s);
-        m_tx_index = ser_readdata32(s);
-        char f = ser_readdata8(s);
-        m_tx_spent = f;
-    }
-};
-
-struct CAddressIndexIteratorKey {
-public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
-    uint160 m_address_bytes;
-
-public:
-    CAddressIndexIteratorKey() {
-        SetNull();
-    }
-
-    CAddressIndexIteratorKey(uint8_t address_type, uint160 address_bytes) :
-        m_address_type{address_type}, m_address_bytes{address_bytes} {};
-
-    void SetNull() {
-        m_address_type = AddressType::UNKNOWN;
-        m_address_bytes.SetNull();
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 21;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
-        m_address_bytes.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
-        m_address_bytes.Unserialize(s);
-    }
-};
-
-struct CAddressIndexIteratorHeightKey {
-public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
-    uint160 m_address_bytes;
-    int32_t m_block_height{0};
-
-public:
-    CAddressIndexIteratorHeightKey() {
-        SetNull();
-    }
-
-    CAddressIndexIteratorHeightKey(uint8_t address_type, uint160 address_bytes, int32_t block_height) :
-        m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
-
-    void SetNull() {
-        m_address_type = AddressType::UNKNOWN;
-        m_address_bytes.SetNull();
-        m_block_height = 0;
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 25;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
-        m_address_bytes.Serialize(s);
-        ser_writedata32be(s, m_block_height);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
-        m_address_bytes.Unserialize(s);
-        m_block_height = ser_readdata32be(s);
-    }
-};
-
 #endif // BITCOIN_SPENTINDEX_H

From 51203a83dc7dbc256e0aade7b07a1e568539a376 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 20:28:55 +0530
Subject: [PATCH 12/19] refactor: use static_cast for (de)serializing bool

---
 src/addressindex.h | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index ed3225e3c19f9..0141f2971c74a 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -121,8 +121,7 @@ struct CAddressIndexKey {
         ser_writedata32be(s, m_block_tx_pos);
         m_tx_hash.Serialize(s);
         ser_writedata32(s, m_tx_index);
-        char f = m_tx_spent;
-        ser_writedata8(s, f);
+        ser_writedata8(s, static_cast<uint8_t>(m_tx_spent));
     }
 
     template<typename Stream>
@@ -133,8 +132,7 @@ struct CAddressIndexKey {
         m_block_tx_pos = ser_readdata32be(s);
         m_tx_hash.Unserialize(s);
         m_tx_index = ser_readdata32(s);
-        char f = ser_readdata8(s);
-        m_tx_spent = f;
+        m_tx_spent = static_cast<bool>(ser_readdata8(s));
     }
 };
 

From b29ef2eb4a264e56d9c4bdd9f2e3c3caee4aedd9 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Fri, 15 Sep 2023 00:29:48 +0530
Subject: [PATCH 13/19] refactor: deduplicate scriptPubKey trimming, index
 operations

---
 src/addressindex.h |  15 ++++
 src/txmempool.cpp  |  86 ++++++++++----------
 src/validation.cpp | 199 ++++++++++++++++++++-------------------------
 3 files changed, 149 insertions(+), 151 deletions(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index 0141f2971c74a..6c9e3fc92b043 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -212,4 +212,19 @@ struct CAddressIndexIteratorHeightKey {
     }
 };
 
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2PK(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 1, input.end() - 1);
+};
+
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2PKH(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 3, input.begin() + 23);
+};
+
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2SH(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 2, input.begin() + 22);
+};
+
 #endif // BITCOIN_ADDRESSINDEX_H
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index c91c9ac34f10c..a822663be49c3 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -474,47 +474,51 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const CTxIn input = tx.vin[j];
         const Coin& coin = view.AccessCoin(input.prevout);
         const CTxOut &prevout = coin.out;
+
+        uint8_t address_type{0};
+        uint160 address_bytes;
+
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
-            std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, j, /* tx_spent */ true);
-            CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
-            mapAddress.insert(std::make_pair(key, delta));
-            inserted.push_back(key);
+            address_type  = AddressType::P2SH;
+            address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-            std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, j, /* tx_spent */ true);
-            CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
-            mapAddress.insert(std::make_pair(key, delta));
-            inserted.push_back(key);
+            address_type  = AddressType::P2PKH;
+            address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2})};
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, j, /* tx_spent */ true);
-            CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
-            mapAddress.insert(std::make_pair(key, delta));
-            inserted.push_back(key);
+            address_type  = AddressType::P2PK;
+            address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
+        } else {
+            continue;
         }
+
+        CMempoolAddressDeltaKey key(address_type, address_bytes, txhash, j, /* tx_spent */ true);
+        CMempoolAddressDelta delta(entry.GetTime(), prevout.nValue * -1, input.prevout.hash, input.prevout.n);
+        mapAddress.insert(std::make_pair(key, delta));
+        inserted.push_back(key);
     }
 
     for (unsigned int k = 0; k < tx.vout.size(); k++) {
         const CTxOut &out = tx.vout[k];
+
+        uint8_t address_type{0};
+        uint160 address_bytes;
+
         if (out.scriptPubKey.IsPayToScriptHash()) {
-            std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-            CMempoolAddressDeltaKey key(AddressType::P2SH, uint160(hashBytes), txhash, k, /* tx_spent */ false);
-            mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
-            inserted.push_back(key);
+            address_type  = AddressType::P2SH;
+            address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
         } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-            std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
-            std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PKH, uint160(hashBytes), txhash, k, /* tx_spent */ false);
-            mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
-            inserted.push_back(key);
+            address_type  = AddressType::P2PKH;
+            address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
         } else if (out.scriptPubKey.IsPayToPublicKey()) {
-            uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
-            std::pair<addressDeltaMap::iterator,bool> ret;
-            CMempoolAddressDeltaKey key(AddressType::P2PK, hashBytes, txhash, k, /* tx_spent */ false);
-            mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
-            inserted.push_back(key);
+            address_type  = AddressType::P2PK;
+            address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
+        } else {
+            continue;
         }
+
+        CMempoolAddressDeltaKey key(address_type, address_bytes, txhash, k, /* tx_spent */ false);
+        mapAddress.insert(std::make_pair(key, CMempoolAddressDelta(entry.GetTime(), out.nValue)));
+        inserted.push_back(key);
     }
 
     mapAddressInserted.insert(std::make_pair(txhash, inserted));
@@ -562,29 +566,29 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
         const CTxIn input = tx.vin[j];
         const Coin& coin = view.AccessCoin(input.prevout);
         const CTxOut &prevout = coin.out;
-        uint160 addressHash;
-        int addressType;
+
+        uint8_t address_type{0};
+        uint160 address_bytes;
 
         if (prevout.scriptPubKey.IsPayToScriptHash()) {
-            addressHash = uint160(std::vector<unsigned char> (prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-            addressType = AddressType::P2SH;
+            address_type  = AddressType::P2SH;
+            address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
         } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-            addressHash = uint160(std::vector<unsigned char> (prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-            addressType = AddressType::P2PKH;
+            address_type  = AddressType::P2PKH;
+            address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
         } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            addressHash = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size() - 2});
-            addressType = AddressType::P2PK;
+            address_type  = AddressType::P2PK;
+            address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
         } else {
-            addressHash.SetNull();
-            addressType = AddressType::UNKNOWN;
+            address_type  = AddressType::UNKNOWN;
+            address_bytes.SetNull();
         }
 
         CSpentIndexKey key = CSpentIndexKey(input.prevout.hash, input.prevout.n);
-        CSpentIndexValue value = CSpentIndexValue(txhash, j, -1, prevout.nValue, addressType, addressHash);
+        CSpentIndexValue value = CSpentIndexValue(txhash, j, -1, prevout.nValue, address_type, address_bytes);
 
         mapSpent.insert(std::make_pair(key, value));
         inserted.push_back(key);
-
     }
 
     mapSpentInserted.insert(make_pair(txhash, inserted));
diff --git a/src/validation.cpp b/src/validation.cpp
index ec9da9f259009..5a71856956103 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1703,38 +1703,31 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         bool is_coinbase = tx.IsCoinBase();
 
         if (fAddressIndex) {
-
             for (unsigned int k = tx.vout.size(); k-- > 0;) {
                 const CTxOut &out = tx.vout[k];
 
-                if (out.scriptPubKey.IsPayToScriptHash()) {
-                    std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-
-                    // undo receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
-
-                    // undo unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), hash, k), CAddressUnspentValue()));
+                uint8_t address_type{0};
+                uint160 address_bytes;
 
+                if (out.scriptPubKey.IsPayToScriptHash()) {
+                    address_type  = AddressType::P2SH;
+                    address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
                 } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                    std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
-
-                    // undo receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, hash, k, false), out.nValue));
-
-                    // undo unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), hash, k), CAddressUnspentValue()));
-
+                    address_type  = AddressType::P2PKH;
+                    address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size() - 2})};
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, hash, k, false), out.nValue));
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, hash, k), CAddressUnspentValue()));
+                    address_type  = AddressType::P2PK;
+                    address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
                 } else {
                     continue;
                 }
 
-            }
+                // undo receiving activity
+                addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, hash, k, false), out.nValue));
 
+                // undo unspent index
+                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, hash, k), CAddressUnspentValue()));
+            }
         }
 
         // Check that all outputs are available and match the outputs in the block itself
@@ -1774,36 +1767,29 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                 if (fAddressIndex) {
                     const Coin &coin = view.AccessCoin(tx.vin[j].prevout);
                     const CTxOut &prevout = coin.out;
-                    if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22);
-
-                        // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
-
-                        // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
 
+                    uint8_t address_type{0};
+                    uint160 address_bytes;
 
+                    if (prevout.scriptPubKey.IsPayToScriptHash()) {
+                        address_type  = AddressType::P2SH;
+                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        std::vector<unsigned char> hashBytes(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23);
-
-                        // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
-
-                        // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
-
+                        address_type  = AddressType::P2PKH;
+                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        uint160 hashBytes{Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2})};
-                        // undo spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
-                        // restore unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
+                        address_type  = AddressType::P2PK;
+                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
                     } else {
                         continue;
                     }
-                }
 
+                    // undo spending activity
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
+
+                    // restore unspent index
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
+                }
             }
             // At this point, all of txundo.vprevout should have been moved out.
         }
@@ -2255,40 +2241,40 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                     const CTxIn input = tx.vin[j];
                     const Coin& coin = view.AccessCoin(tx.vin[j].prevout);
                     const CTxOut &prevout = coin.out;
-                    uint160 hashBytes;
-                    int addressType;
+
+                    uint8_t address_type{0};
+                    uint160 address_bytes;
 
                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-                        addressType = AddressType::P2SH;
+                        address_type  = AddressType::P2SH;
+                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-                        addressType = AddressType::P2PKH;
+                        address_type  = AddressType::P2PKH;
+                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
-                        addressType = AddressType::P2PK;
+                        address_type  = AddressType::P2PK;
+                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
                     } else {
-                        hashBytes.SetNull();
-                        addressType = AddressType::UNKNOWN;
+                        address_type  = AddressType::UNKNOWN;
+                        address_bytes.SetNull();
                     }
 
-                    if (fAddressIndex && addressType > 0) {
+                    if (fAddressIndex && address_type != AddressType::UNKNOWN) {
                         // record spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(addressType, hashBytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
 
                         // remove address from unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(addressType, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
                     }
 
                     if (fSpentIndex) {
                         // add the spent index to determine the txid and input that spent an output
                         // and to find the amount and address from an input
-                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, addressType, hashBytes)));
+                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, address_type, address_bytes)));
                     }
                 }
                 nTime2_index += GetTimeMicros() - nTime2_index1;
             }
-
         }
 
         // GetTransactionSigOpCount counts 2 types of sigops:
@@ -2322,31 +2308,27 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
             for (unsigned int k = 0; k < tx.vout.size(); k++) {
                 const CTxOut &out = tx.vout[k];
 
-                if (out.scriptPubKey.IsPayToScriptHash()) {
-                    std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-
-                    // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                    // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                uint8_t address_type{0};
+                uint160 address_bytes;
 
+                if (out.scriptPubKey.IsPayToScriptHash()) {
+                    address_type  = AddressType::P2SH;
+                    address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
                 } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                    std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
-
-                    // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                    // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
-
+                    address_type  = AddressType::P2PKH;
+                    address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
                 } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                    address_type  = AddressType::P2PK;
+                    address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
                 } else {
                     continue;
                 }
+
+                // record receiving activity
+                addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, k, false), out.nValue));
+
+                // record unspent output
+                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
             }
             nTime2_index += GetTimeMicros() - nTime2_index2;
         }
@@ -4861,35 +4843,36 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                     const CTxIn input = tx->vin[j];
                     const Coin& coin = inputs.AccessCoin(tx->vin[j].prevout);
                     const CTxOut& prevout = coin.out;
-                    uint160 hashBytes;
-                    int addressType;
+
+                    uint8_t address_type{0};
+                    uint160 address_bytes;
 
                     if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+2, prevout.scriptPubKey.begin()+22));
-                        addressType = AddressType::P2SH;
+                        address_type  = AddressType::P2SH;
+                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        hashBytes = uint160(std::vector<unsigned char>(prevout.scriptPubKey.begin()+3, prevout.scriptPubKey.begin()+23));
-                        addressType = AddressType::P2PKH;
+                        address_type  = AddressType::P2PKH;
+                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
                     } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        hashBytes = Hash160(Span{prevout.scriptPubKey.data()+1, prevout.scriptPubKey.size()-2});
-                        addressType = AddressType::P2PK;
+                        address_type  = AddressType::P2PK;
+                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
                     } else {
-                        hashBytes.SetNull();
-                        addressType = AddressType::UNKNOWN;
+                        address_type  = AddressType::UNKNOWN;
+                        address_bytes.SetNull();
                     }
 
-                    if (fAddressIndex && addressType > 0) {
+                    if (fAddressIndex && address_type != AddressType::UNKNOWN) {
                         // record spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(addressType, hashBytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
+                        addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
 
                         // remove address from unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(addressType, hashBytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
+                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
                     }
 
                     if (fSpentIndex) {
                         // add the spent index to determine the txid and input that spent an output
                         // and to find the amount and address from an input
-                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, addressType, hashBytes)));
+                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, address_type, address_bytes)));
                     }
                 }
             }
@@ -4898,31 +4881,27 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                 for (size_t k = 0; k < tx->vout.size(); k++) {
                     const CTxOut& out = tx->vout[k];
 
-                    if (out.scriptPubKey.IsPayToScriptHash()) {
-                        std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);
-
-                        // record receiving activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2SH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                        // record unspent output
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2SH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                    uint8_t address_type{0};
+                    uint160 address_bytes;
 
+                    if (out.scriptPubKey.IsPayToScriptHash()) {
+                        address_type  = AddressType::P2SH;
+                        address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
                     } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                        std::vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);
-
-                        // record receiving activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PKH, uint160(hashBytes), pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                        // record unspent output
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PKH, uint160(hashBytes), txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
-
+                        address_type  = AddressType::P2PKH;
+                        address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
                     } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                        uint160 hashBytes{Hash160(Span{out.scriptPubKey.data()+1, out.scriptPubKey.size()-2})};
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(AddressType::P2PK, hashBytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(AddressType::P2PK, hashBytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
+                        address_type  = AddressType::P2PK;
+                        address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
                     } else {
                         continue;
                     }
+
+                    // record receiving activity
+                    addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, k, false), out.nValue));
+
+                    // record unspent output
+                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
                 }
             }
 

From f47021a536d690fcce77abf49dd9db9bd0e13b7a Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 02:24:01 +0530
Subject: [PATCH 14/19] refactor: remove more code duplication from
 (dis)connect operations

---
 src/Makefile.am      |  1 +
 src/addressindex.cpp | 43 ++++++++++++++++++++++++++
 src/addressindex.h   | 17 ++---------
 src/txmempool.cpp    | 36 +++-------------------
 src/validation.cpp   | 72 ++++----------------------------------------
 5 files changed, 57 insertions(+), 112 deletions(-)
 create mode 100644 src/addressindex.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index 02c80d3e57a1e..a354b9e6f5149 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -386,6 +386,7 @@ libbitcoin_server_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(MINIUPNPC_CP
 libbitcoin_server_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_server_a_SOURCES = \
   addrdb.cpp \
+  addressindex.cpp \
   addrman.cpp \
   banman.cpp \
   batchedlogger.cpp \
diff --git a/src/addressindex.cpp b/src/addressindex.cpp
new file mode 100644
index 0000000000000..1f9719c9a2624
--- /dev/null
+++ b/src/addressindex.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2016 BitPay, Inc.
+// Copyright (c) 2023 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <addressindex.h>
+
+#include <key_io.h>
+#include <hash.h>
+#include <script/script.h>
+
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2PKH(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 3, input.begin() + 23);
+};
+
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2SH(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 2, input.begin() + 22);
+};
+
+template <typename T1>
+inline std::vector<uint8_t> TrimScriptP2PK(const T1& input) {
+    return std::vector<uint8_t>(input.begin() + 1, input.end() - 1);
+};
+
+bool AddressBytesFromScript(const CScript& script, uint8_t& address_type, uint160& address_bytes) {
+    if (script.IsPayToScriptHash()) {
+        address_type  = AddressType::P2SH;
+        address_bytes = uint160(TrimScriptP2SH(script));
+    } else if (script.IsPayToPublicKeyHash()) {
+        address_type  = AddressType::P2PKH;
+        address_bytes = uint160(TrimScriptP2PKH(script));
+    } else if (script.IsPayToPublicKey()) {
+        address_type  = AddressType::P2PK;
+        address_bytes = Hash160(TrimScriptP2PK(script));
+    } else {
+        address_type  = AddressType::UNKNOWN;
+        address_bytes.SetNull();
+        return false;
+    }
+    return true;
+}
diff --git a/src/addressindex.h b/src/addressindex.h
index 6c9e3fc92b043..58c496a181ef4 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -14,6 +14,8 @@
 #include <chrono>
 #include <tuple>
 
+class CScript;
+
 namespace AddressType {
 enum AddressType {
     P2PK = 1,
@@ -212,19 +214,6 @@ struct CAddressIndexIteratorHeightKey {
     }
 };
 
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2PK(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 1, input.end() - 1);
-};
-
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2PKH(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 3, input.begin() + 23);
-};
-
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2SH(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 2, input.begin() + 22);
-};
+bool AddressBytesFromScript(const CScript& script, uint8_t& address_type, uint160& address_bytes);
 
 #endif // BITCOIN_ADDRESSINDEX_H
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index a822663be49c3..c175a6a5c8a91 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -478,16 +478,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         uint8_t address_type{0};
         uint160 address_bytes;
 
-        if (prevout.scriptPubKey.IsPayToScriptHash()) {
-            address_type  = AddressType::P2SH;
-            address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
-        } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-            address_type  = AddressType::P2PKH;
-            address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
-        } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            address_type  = AddressType::P2PK;
-            address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
-        } else {
+        if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
             continue;
         }
 
@@ -503,16 +494,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         uint8_t address_type{0};
         uint160 address_bytes;
 
-        if (out.scriptPubKey.IsPayToScriptHash()) {
-            address_type  = AddressType::P2SH;
-            address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
-        } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-            address_type  = AddressType::P2PKH;
-            address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
-        } else if (out.scriptPubKey.IsPayToPublicKey()) {
-            address_type  = AddressType::P2PK;
-            address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
-        } else {
+        if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
             continue;
         }
 
@@ -570,18 +552,8 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
         uint8_t address_type{0};
         uint160 address_bytes;
 
-        if (prevout.scriptPubKey.IsPayToScriptHash()) {
-            address_type  = AddressType::P2SH;
-            address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
-        } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-            address_type  = AddressType::P2PKH;
-            address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
-        } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-            address_type  = AddressType::P2PK;
-            address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
-        } else {
-            address_type  = AddressType::UNKNOWN;
-            address_bytes.SetNull();
+        if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
+            continue;
         }
 
         CSpentIndexKey key = CSpentIndexKey(input.prevout.hash, input.prevout.n);
diff --git a/src/validation.cpp b/src/validation.cpp
index 5a71856956103..b574d42ed6431 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1709,16 +1709,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                 uint8_t address_type{0};
                 uint160 address_bytes;
 
-                if (out.scriptPubKey.IsPayToScriptHash()) {
-                    address_type  = AddressType::P2SH;
-                    address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
-                } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                    address_type  = AddressType::P2PKH;
-                    address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
-                } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    address_type  = AddressType::P2PK;
-                    address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
-                } else {
+                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
                     continue;
                 }
 
@@ -1771,16 +1762,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                     uint8_t address_type{0};
                     uint160 address_bytes;
 
-                    if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        address_type  = AddressType::P2SH;
-                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        address_type  = AddressType::P2PKH;
-                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        address_type  = AddressType::P2PK;
-                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
-                    } else {
+                    if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
                         continue;
                     }
 
@@ -2245,19 +2227,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                     uint8_t address_type{0};
                     uint160 address_bytes;
 
-                    if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        address_type  = AddressType::P2SH;
-                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        address_type  = AddressType::P2PKH;
-                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        address_type  = AddressType::P2PK;
-                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
-                    } else {
-                        address_type  = AddressType::UNKNOWN;
-                        address_bytes.SetNull();
-                    }
+                    AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
 
                     if (fAddressIndex && address_type != AddressType::UNKNOWN) {
                         // record spending activity
@@ -2311,16 +2281,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                 uint8_t address_type{0};
                 uint160 address_bytes;
 
-                if (out.scriptPubKey.IsPayToScriptHash()) {
-                    address_type  = AddressType::P2SH;
-                    address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
-                } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                    address_type  = AddressType::P2PKH;
-                    address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
-                } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                    address_type  = AddressType::P2PK;
-                    address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
-                } else {
+                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
                     continue;
                 }
 
@@ -4847,19 +4808,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                     uint8_t address_type{0};
                     uint160 address_bytes;
 
-                    if (prevout.scriptPubKey.IsPayToScriptHash()) {
-                        address_type  = AddressType::P2SH;
-                        address_bytes = uint160(TrimScriptP2SH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKeyHash()) {
-                        address_type  = AddressType::P2PKH;
-                        address_bytes = uint160(TrimScriptP2PKH(prevout.scriptPubKey));
-                    } else if (prevout.scriptPubKey.IsPayToPublicKey()) {
-                        address_type  = AddressType::P2PK;
-                        address_bytes = Hash160(TrimScriptP2PK(prevout.scriptPubKey));
-                    } else {
-                        address_type  = AddressType::UNKNOWN;
-                        address_bytes.SetNull();
-                    }
+                    AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
 
                     if (fAddressIndex && address_type != AddressType::UNKNOWN) {
                         // record spending activity
@@ -4884,16 +4833,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                     uint8_t address_type{0};
                     uint160 address_bytes;
 
-                    if (out.scriptPubKey.IsPayToScriptHash()) {
-                        address_type  = AddressType::P2SH;
-                        address_bytes = uint160(TrimScriptP2SH(out.scriptPubKey));
-                    } else if (out.scriptPubKey.IsPayToPublicKeyHash()) {
-                        address_type  = AddressType::P2PKH;
-                        address_bytes = uint160(TrimScriptP2PKH(out.scriptPubKey));
-                    } else if (out.scriptPubKey.IsPayToPublicKey()) {
-                        address_type  = AddressType::P2PK;
-                        address_bytes = Hash160(TrimScriptP2PK(out.scriptPubKey));
-                    } else {
+                    if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
                         continue;
                     }
 

From b08a6343a7c9d21ac5fda38204d426eba9bf292d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 20:46:43 +0530
Subject: [PATCH 15/19] refactor: add missing headers to
 {address,timestamp}index

---
 src/addressindex.h   | 3 ++-
 src/timestampindex.h | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/addressindex.h b/src/addressindex.h
index 58c496a181ef4..5193a92bb9f8c 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -8,8 +8,9 @@
 #ifndef BITCOIN_ADDRESSINDEX_H
 #define BITCOIN_ADDRESSINDEX_H
 
-#include <uint256.h>
 #include <amount.h>
+#include <serialize.h>
+#include <uint256.h>
 
 #include <chrono>
 #include <tuple>
diff --git a/src/timestampindex.h b/src/timestampindex.h
index a1e300bfda938..42c34ee55e1c8 100644
--- a/src/timestampindex.h
+++ b/src/timestampindex.h
@@ -8,6 +8,7 @@
 #ifndef BITCOIN_TIMESTAMPINDEX_H
 #define BITCOIN_TIMESTAMPINDEX_H
 
+#include <serialize.h>
 #include <uint256.h>
 
 struct CTimestampIndexIteratorKey {

From 109f57c83ed4092a2be2301011d3b3136a0ce3af Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 22:53:15 +0530
Subject: [PATCH 16/19] refactor: use range-based loops instead of iterators

Co-authored-by: Konstantin Akimov <knstqq@gmail.com>
---
 src/rpc/blockchain.cpp |  10 ++--
 src/rpc/misc.cpp       | 109 ++++++++++++++++++++++-------------------
 src/txmempool.cpp      |   6 +--
 3 files changed, 66 insertions(+), 59 deletions(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index f0a0bbede1dff..d0b66b3d1ecaf 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -838,8 +838,8 @@ static UniValue getblockhashes(const JSONRPCRequest& request)
     }
 
     UniValue result(UniValue::VARR);
-    for (std::vector<uint256>::const_iterator it=blockHashes.begin(); it!=blockHashes.end(); it++) {
-        result.push_back(it->GetHex());
+    for (const auto& hash : blockHashes) {
+        result.push_back(hash.GetHex());
     }
 
     return result;
@@ -1828,9 +1828,9 @@ static UniValue getchaintips(const JSONRPCRequest& request)
         }
     }
 
-    for (std::set<const CBlockIndex*>::iterator it = setOrphans.begin(); it != setOrphans.end(); ++it) {
-        if (setPrevs.erase(*it) == 0) {
-            setTips.insert(*it);
+    for (const auto& orphan : setOrphans) {
+        if (setPrevs.erase(orphan) == 0) {
+            setTips.insert(orphan);
         }
     }
 
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index b56d7a5291da6..2bf14af50ffd0 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -635,13 +635,10 @@ static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Addresses is expected to be an array");
         }
 
-        std::vector<UniValue> values = addressValues.getValues();
-
-        for (std::vector<UniValue>::iterator it = values.begin(); it != values.end(); ++it) {
-
+        for (const auto& address : addressValues.getValues()) {
             uint160 hashBytes;
             int type{AddressType::UNKNOWN};
-            if (!getIndexKey(it->get_str(), hashBytes, type)) {
+            if (!getIndexKey(address.get_str(), hashBytes, type)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
             }
             addresses.push_back(std::make_pair(hashBytes, type));
@@ -711,23 +708,24 @@ static UniValue getaddressmempool(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> >::iterator it = indexes.begin();
-         it != indexes.end(); it++) {
+    for (const auto& index : indexes) {
+        const auto& mempoolAddressDeltaKey = index.first;
+        const auto& mempoolAddressDelta = index.second;
 
         std::string address;
-        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
+        if (!getAddressFromIndex(mempoolAddressDeltaKey.m_address_type, mempoolAddressDeltaKey.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         UniValue delta(UniValue::VOBJ);
         delta.pushKV("address", address);
-        delta.pushKV("txid", it->first.m_tx_hash.GetHex());
-        delta.pushKV("index", (int)it->first.m_tx_index);
-        delta.pushKV("satoshis", it->second.m_amount);
-        delta.pushKV("timestamp", count_seconds(it->second.m_time));
-        if (it->second.m_amount < 0) {
-            delta.pushKV("prevtxid", it->second.m_prev_hash.GetHex());
-            delta.pushKV("prevout", (int)it->second.m_prev_out);
+        delta.pushKV("txid", mempoolAddressDeltaKey.m_tx_hash.GetHex());
+        delta.pushKV("index", (int)mempoolAddressDeltaKey.m_tx_index);
+        delta.pushKV("satoshis", mempoolAddressDelta.m_amount);
+        delta.pushKV("timestamp", count_seconds(mempoolAddressDelta.m_time));
+        if (mempoolAddressDelta.m_amount < 0) {
+            delta.pushKV("prevtxid", mempoolAddressDelta.m_prev_hash.GetHex());
+            delta.pushKV("prevout", (int)mempoolAddressDelta.m_prev_out);
         }
         result.push_back(delta);
     }
@@ -773,8 +771,8 @@ static UniValue getaddressutxos(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
-    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        if (!GetAddressUnspent((*it).first, (*it).second, unspentOutputs)) {
+    for (const auto& address : addresses) {
+        if (!GetAddressUnspent(address.first, address.second, unspentOutputs)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
@@ -783,19 +781,22 @@ static UniValue getaddressutxos(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++) {
+    for (const auto& unspentOutput : unspentOutputs) {
+        const auto& unspentKey = unspentOutput.first;
+        const auto& unspentValue = unspentOutput.second;
+
         UniValue output(UniValue::VOBJ);
         std::string address;
-        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
+        if (!getAddressFromIndex(unspentKey.m_address_type, unspentKey.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         output.pushKV("address", address);
-        output.pushKV("txid", it->first.m_tx_hash.GetHex());
-        output.pushKV("outputIndex", (int)it->first.m_tx_index);
-        output.pushKV("script", HexStr(it->second.m_tx_script));
-        output.pushKV("satoshis", it->second.m_amount);
-        output.pushKV("height", it->second.m_block_height);
+        output.pushKV("txid", unspentKey.m_tx_hash.GetHex());
+        output.pushKV("outputIndex", (int)unspentKey.m_tx_index);
+        output.pushKV("script", HexStr(unspentValue.m_tx_script));
+        output.pushKV("satoshis", unspentValue.m_amount);
+        output.pushKV("height", unspentValue.m_block_height);
         result.push_back(output);
     }
 
@@ -855,13 +856,13 @@ static UniValue getaddressdeltas(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
 
-    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+    for (const auto& address : addresses) {
         if (start > 0 && end > 0) {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
+            if (!GetAddressIndex(address.first, address.second, addressIndex, start, end)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         } else {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+            if (!GetAddressIndex(address.first, address.second, addressIndex)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         }
@@ -869,18 +870,20 @@ static UniValue getaddressdeltas(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
+    for (const auto& index : addressIndex) {
+        const auto& indexKey = index.first;
+        const auto& indexDelta = index.second;
         std::string address;
-        if (!getAddressFromIndex(it->first.m_address_type, it->first.m_address_bytes, address)) {
+        if (!getAddressFromIndex(indexKey.m_address_type, indexKey.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         UniValue delta(UniValue::VOBJ);
-        delta.pushKV("satoshis", it->second);
-        delta.pushKV("txid", it->first.m_tx_hash.GetHex());
-        delta.pushKV("index", (int)it->first.m_tx_index);
-        delta.pushKV("blockindex", (int)it->first.m_block_tx_pos);
-        delta.pushKV("height", it->first.m_block_height);
+        delta.pushKV("satoshis", indexDelta);
+        delta.pushKV("txid", indexKey.m_tx_hash.GetHex());
+        delta.pushKV("index", (int)indexKey.m_tx_index);
+        delta.pushKV("blockindex", (int)indexKey.m_block_tx_pos);
+        delta.pushKV("height", indexKey.m_block_height);
         delta.pushKV("address", address);
         result.push_back(delta);
     }
@@ -921,8 +924,8 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
 
-    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+    for (const auto& address : addresses) {
+        if (!GetAddressIndex(address.first, address.second, addressIndex)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
@@ -935,16 +938,18 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
     CAmount balance_immature = 0;
     CAmount received = 0;
 
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
-        if (it->second > 0) {
-            received += it->second;
+    for (const auto& index : addressIndex) {
+        const auto& indexKey = index.first;
+        const auto& indexDelta = index.second;
+        if (indexDelta > 0) {
+            received += indexDelta;
         }
-        if (it->first.m_block_tx_pos == 0 && nHeight - it->first.m_block_height < COINBASE_MATURITY) {
-            balance_immature += it->second;
+        if (indexKey.m_block_tx_pos == 0 && nHeight - indexKey.m_block_height < COINBASE_MATURITY) {
+            balance_immature += indexDelta;
         } else {
-            balance_spendable += it->second;
+            balance_spendable += indexDelta;
         }
-        balance += it->second;
+        balance += indexDelta;
     }
 
     UniValue result(UniValue::VOBJ);
@@ -997,13 +1002,13 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
 
     std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
 
-    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+    for (const auto& address : addresses) {
         if (start > 0 && end > 0) {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, start, end)) {
+            if (!GetAddressIndex(address.first, address.second, addressIndex, start, end)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         } else {
-            if (!GetAddressIndex((*it).first, (*it).second, addressIndex)) {
+            if (!GetAddressIndex(address.first, address.second, addressIndex)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
             }
         }
@@ -1012,9 +1017,11 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
     std::set<std::pair<int, std::string> > txids;
     UniValue result(UniValue::VARR);
 
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
-        int height = it->first.m_block_height;
-        std::string txid = it->first.m_tx_hash.GetHex();
+    for (const auto& index : addressIndex) {
+        const auto& indexKey = index.first;
+
+        int height = indexKey.m_block_height;
+        std::string txid = indexKey.m_tx_hash.GetHex();
 
         if (addresses.size() > 1) {
             txids.insert(std::make_pair(height, txid));
@@ -1026,8 +1033,8 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
     }
 
     if (addresses.size() > 1) {
-        for (std::set<std::pair<int, std::string> >::const_iterator it=txids.begin(); it!=txids.end(); it++) {
-            result.push_back(it->second);
+        for (const auto& tx : txids) {
+            result.push_back(tx.second);
         }
     }
 
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index c175a6a5c8a91..6ad711829b89b 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -510,9 +510,9 @@ bool CTxMemPool::getAddressIndex(std::vector<std::pair<uint160, int> > &addresse
                                  std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > &results)
 {
     LOCK(cs);
-    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
-        addressDeltaMap::iterator ait = mapAddress.lower_bound(CMempoolAddressDeltaKey((*it).second, (*it).first));
-        while (ait != mapAddress.end() && (*ait).first.m_address_bytes == (*it).first && (*ait).first.m_address_type == (*it).second) {
+    for (const auto& address : addresses) {
+        addressDeltaMap::iterator ait = mapAddress.lower_bound(CMempoolAddressDeltaKey(address.second, address.first));
+        while (ait != mapAddress.end() && (*ait).first.m_address_bytes == address.first && (*ait).first.m_address_type == address.second) {
             results.push_back(*ait);
             ait++;
         }

From c65a10f349411d0585d5e67ef1192ef39d14a42a Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 16:31:26 +0700
Subject: [PATCH 17/19] refactor: use structure binding in for loop in rpc/misc

Co-authored-by: Konstantin Akimov <knstqq@gmail.com>
---
 src/rpc/misc.cpp | 28 ++++++++--------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 2bf14af50ffd0..bdb9c5f986a3b 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -708,19 +708,16 @@ static UniValue getaddressmempool(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (const auto& index : indexes) {
-        const auto& mempoolAddressDeltaKey = index.first;
-        const auto& mempoolAddressDelta = index.second;
-
+    for (const auto& [mempoolAddressKey, mempoolAddressDelta] : indexes) {
         std::string address;
-        if (!getAddressFromIndex(mempoolAddressDeltaKey.m_address_type, mempoolAddressDeltaKey.m_address_bytes, address)) {
+        if (!getAddressFromIndex(mempoolAddressKey.m_address_type, mempoolAddressKey.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
         }
 
         UniValue delta(UniValue::VOBJ);
         delta.pushKV("address", address);
-        delta.pushKV("txid", mempoolAddressDeltaKey.m_tx_hash.GetHex());
-        delta.pushKV("index", (int)mempoolAddressDeltaKey.m_tx_index);
+        delta.pushKV("txid", mempoolAddressKey.m_tx_hash.GetHex());
+        delta.pushKV("index", (int)mempoolAddressKey.m_tx_index);
         delta.pushKV("satoshis", mempoolAddressDelta.m_amount);
         delta.pushKV("timestamp", count_seconds(mempoolAddressDelta.m_time));
         if (mempoolAddressDelta.m_amount < 0) {
@@ -781,10 +778,7 @@ static UniValue getaddressutxos(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (const auto& unspentOutput : unspentOutputs) {
-        const auto& unspentKey = unspentOutput.first;
-        const auto& unspentValue = unspentOutput.second;
-
+    for (const auto& [unspentKey, unspentValue] : unspentOutputs) {
         UniValue output(UniValue::VOBJ);
         std::string address;
         if (!getAddressFromIndex(unspentKey.m_address_type, unspentKey.m_address_bytes, address)) {
@@ -870,9 +864,7 @@ static UniValue getaddressdeltas(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (const auto& index : addressIndex) {
-        const auto& indexKey = index.first;
-        const auto& indexDelta = index.second;
+    for (const auto& [indexKey, indexDelta] : addressIndex) {
         std::string address;
         if (!getAddressFromIndex(indexKey.m_address_type, indexKey.m_address_bytes, address)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown address type");
@@ -938,9 +930,7 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
     CAmount balance_immature = 0;
     CAmount received = 0;
 
-    for (const auto& index : addressIndex) {
-        const auto& indexKey = index.first;
-        const auto& indexDelta = index.second;
+    for (const auto& [indexKey, indexDelta] : addressIndex) {
         if (indexDelta > 0) {
             received += indexDelta;
         }
@@ -1017,9 +1007,7 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
     std::set<std::pair<int, std::string> > txids;
     UniValue result(UniValue::VARR);
 
-    for (const auto& index : addressIndex) {
-        const auto& indexKey = index.first;
-
+    for (const auto& [indexKey, _]: addressIndex) {
         int height = indexKey.m_block_height;
         std::string txid = indexKey.m_tx_hash.GetHex();
 

From f011c31b1a2ba123cf034eaacff2dc9b96dbc5ff Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 15:16:15 +0700
Subject: [PATCH 18/19] refactor: make AddressType a strong enum, remove
 uint8_t for address_type

Co-authored-by: Konstantin Akimov <knstqq@gmail.com>
---
 src/addressindex.cpp |  2 +-
 src/addressindex.h   | 38 +++++++++++++++++++-------------------
 src/rpc/misc.cpp     | 21 +++++++++++----------
 src/spentindex.h     | 12 ++++++------
 src/txdb.cpp         |  4 ++--
 src/txdb.h           |  4 ++--
 src/txmempool.cpp    |  8 ++++----
 src/txmempool.h      |  2 +-
 src/validation.cpp   | 16 ++++++++--------
 src/validation.h     |  4 ++--
 10 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/src/addressindex.cpp b/src/addressindex.cpp
index 1f9719c9a2624..98459c2e3e7c2 100644
--- a/src/addressindex.cpp
+++ b/src/addressindex.cpp
@@ -24,7 +24,7 @@ inline std::vector<uint8_t> TrimScriptP2PK(const T1& input) {
     return std::vector<uint8_t>(input.begin() + 1, input.end() - 1);
 };
 
-bool AddressBytesFromScript(const CScript& script, uint8_t& address_type, uint160& address_bytes) {
+bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes) {
     if (script.IsPayToScriptHash()) {
         address_type  = AddressType::P2SH;
         address_bytes = uint160(TrimScriptP2SH(script));
diff --git a/src/addressindex.h b/src/addressindex.h
index 5193a92bb9f8c..fec8a664892a9 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -11,21 +11,21 @@
 #include <amount.h>
 #include <serialize.h>
 #include <uint256.h>
+#include <util/underlying.h>
 
 #include <chrono>
 #include <tuple>
 
 class CScript;
 
-namespace AddressType {
-enum AddressType {
+enum class AddressType : uint8_t {
     P2PK = 1,
     P2PKH = 1,
     P2SH = 2,
 
     UNKNOWN = 0
 };
-}; /* namespace AddressType */
+template<> struct is_serializable_enum<AddressType> : std::true_type {};
 
 struct CMempoolAddressDelta
 {
@@ -46,21 +46,21 @@ struct CMempoolAddressDelta
 struct CMempoolAddressDeltaKey
 {
 public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     uint256 m_tx_hash;
     uint32_t m_tx_index{0};
     bool m_tx_spent{false};
 
 public:
-    CMempoolAddressDeltaKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
+    CMempoolAddressDeltaKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
         m_tx_hash{tx_hash},
         m_tx_index{tx_index},
         m_tx_spent{tx_spent} {};
 
-    CMempoolAddressDeltaKey(uint8_t address_type, uint160 address_bytes) :
+    CMempoolAddressDeltaKey(AddressType address_type, uint160 address_bytes) :
         m_address_type{address_type},
         m_address_bytes{address_bytes} {};
 };
@@ -77,7 +77,7 @@ struct CMempoolAddressDeltaKeyCompare
 
 struct CAddressIndexKey {
 public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     int32_t m_block_height{0};
     uint32_t m_block_tx_pos{0};
@@ -90,7 +90,7 @@ struct CAddressIndexKey {
         SetNull();
     }
 
-    CAddressIndexKey(uint8_t address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
+    CAddressIndexKey(AddressType address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
                      uint32_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
@@ -117,7 +117,7 @@ struct CAddressIndexKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
+        ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
         // Heights are stored big-endian for key sorting in LevelDB
         ser_writedata32be(s, m_block_height);
@@ -129,7 +129,7 @@ struct CAddressIndexKey {
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
+        m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
         m_block_height = ser_readdata32be(s);
         m_block_tx_pos = ser_readdata32be(s);
@@ -141,7 +141,7 @@ struct CAddressIndexKey {
 
 struct CAddressIndexIteratorKey {
 public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
 
 public:
@@ -149,7 +149,7 @@ struct CAddressIndexIteratorKey {
         SetNull();
     }
 
-    CAddressIndexIteratorKey(uint8_t address_type, uint160 address_bytes) :
+    CAddressIndexIteratorKey(AddressType address_type, uint160 address_bytes) :
         m_address_type{address_type}, m_address_bytes{address_bytes} {};
 
     void SetNull() {
@@ -164,20 +164,20 @@ struct CAddressIndexIteratorKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
+        ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
+        m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
     }
 };
 
 struct CAddressIndexIteratorHeightKey {
 public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     int32_t m_block_height{0};
 
@@ -186,7 +186,7 @@ struct CAddressIndexIteratorHeightKey {
         SetNull();
     }
 
-    CAddressIndexIteratorHeightKey(uint8_t address_type, uint160 address_bytes, int32_t block_height) :
+    CAddressIndexIteratorHeightKey(AddressType address_type, uint160 address_bytes, int32_t block_height) :
         m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
 
     void SetNull() {
@@ -202,19 +202,19 @@ struct CAddressIndexIteratorHeightKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
+        ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
         ser_writedata32be(s, m_block_height);
     }
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
+        m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
         m_block_height = ser_readdata32be(s);
     }
 };
 
-bool AddressBytesFromScript(const CScript& script, uint8_t& address_type, uint160& address_bytes);
+bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes);
 
 #endif // BITCOIN_ADDRESSINDEX_H
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index bdb9c5f986a3b..7313af1859242 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -4,6 +4,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addressindex.h>
 #include <chainparams.h>
 #include <consensus/consensus.h>
 #include <evo/mnauth.h>
@@ -593,7 +594,7 @@ static UniValue mnauth(const JSONRPCRequest& request)
     return fSuccess;
 }
 
-static bool getAddressFromIndex(const int &type, const uint160 &hash, std::string &address)
+static bool getAddressFromIndex(const AddressType& type, const uint160 &hash, std::string &address)
 {
     if (type == AddressType::P2SH) {
         address = EncodeDestination(ScriptHash(hash));
@@ -605,7 +606,7 @@ static bool getAddressFromIndex(const int &type, const uint160 &hash, std::strin
     return true;
 }
 
-static bool getIndexKey(const std::string& str, uint160& hashBytes, int& type)
+static bool getIndexKey(const std::string& str, uint160& hashBytes, AddressType& type)
 {
     CTxDestination dest = DecodeDestination(str);
     if (!IsValidDestination(dest)) {
@@ -619,11 +620,11 @@ static bool getIndexKey(const std::string& str, uint160& hashBytes, int& type)
     return true;
 }
 
-static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint160, int> > &addresses)
+static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint160, AddressType> > &addresses)
 {
     if (params[0].isStr()) {
         uint160 hashBytes;
-        int type{AddressType::UNKNOWN};
+        AddressType type{AddressType::UNKNOWN};
         if (!getIndexKey(params[0].get_str(), hashBytes, type)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
         }
@@ -637,7 +638,7 @@ static bool getAddressesFromParams(const UniValue& params, std::vector<std::pair
 
         for (const auto& address : addressValues.getValues()) {
             uint160 hashBytes;
-            int type{AddressType::UNKNOWN};
+            AddressType type{AddressType::UNKNOWN};
             if (!getIndexKey(address.get_str(), hashBytes, type)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
             }
@@ -691,7 +692,7 @@ static UniValue getaddressmempool(const JSONRPCRequest& request)
         },
     }.Check(request);
 
-    std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<uint160, AddressType> > addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -760,7 +761,7 @@ static UniValue getaddressutxos(const JSONRPCRequest& request)
         },
     }.Check(request);
 
-    std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<uint160, AddressType> > addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -842,7 +843,7 @@ static UniValue getaddressdeltas(const JSONRPCRequest& request)
         }
     }
 
-    std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<uint160, AddressType> > addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -908,7 +909,7 @@ static UniValue getaddressbalance(const JSONRPCRequest& request)
         },
     }.Check(request);
 
-    std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<uint160, AddressType> > addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
@@ -973,7 +974,7 @@ static UniValue getaddresstxids(const JSONRPCRequest& request)
         },
     }.Check(request);
 
-    std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<uint160, AddressType> > addresses;
 
     if (!getAddressesFromParams(request.params, addresses)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
diff --git a/src/spentindex.h b/src/spentindex.h
index 7bf4e58b071e1..944ba638cad46 100644
--- a/src/spentindex.h
+++ b/src/spentindex.h
@@ -47,7 +47,7 @@ struct CSpentIndexValue {
     uint32_t m_tx_index{0};
     int32_t m_block_height{0};
     CAmount m_amount{0};
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
 
 public:
@@ -55,7 +55,7 @@ struct CSpentIndexValue {
         SetNull();
     }
 
-    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, uint8_t address_type,
+    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, AddressType address_type,
                      uint160 address_bytes) :
         m_tx_hash{txin_hash},
         m_tx_index{txin_index},
@@ -101,7 +101,7 @@ struct CSpentIndexTxInfo
 
 struct CAddressUnspentKey {
 public:
-    uint8_t m_address_type{AddressType::UNKNOWN};
+    AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
     uint256 m_tx_hash;
     uint32_t m_tx_index{0};
@@ -111,7 +111,7 @@ struct CAddressUnspentKey {
         SetNull();
     }
 
-    CAddressUnspentKey(uint8_t address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index) :
+    CAddressUnspentKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index) :
         m_address_type{address_type}, m_address_bytes{address_bytes}, m_tx_hash{tx_hash}, m_tx_index{tx_index} {};
 
     void SetNull() {
@@ -128,7 +128,7 @@ struct CAddressUnspentKey {
 
     template<typename Stream>
     void Serialize(Stream& s) const {
-        ser_writedata8(s, m_address_type);
+        ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
         m_tx_hash.Serialize(s);
         ser_writedata32(s, m_tx_index);
@@ -136,7 +136,7 @@ struct CAddressUnspentKey {
 
     template<typename Stream>
     void Unserialize(Stream& s) {
-        m_address_type = ser_readdata8(s);
+        m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
         m_tx_hash.Unserialize(s);
         m_tx_index = ser_readdata32(s);
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 1fc8094f47d31..1775204924f71 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -266,7 +266,7 @@ bool CBlockTreeDB::UpdateAddressUnspentIndex(const std::vector<std::pair<CAddres
     return WriteBatch(batch);
 }
 
-bool CBlockTreeDB::ReadAddressUnspentIndex(uint160 addressHash, int type,
+bool CBlockTreeDB::ReadAddressUnspentIndex(uint160 addressHash, AddressType type,
                                            std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs) {
 
     std::unique_ptr<CDBIterator> pcursor(NewIterator());
@@ -305,7 +305,7 @@ bool CBlockTreeDB::EraseAddressIndex(const std::vector<std::pair<CAddressIndexKe
     return WriteBatch(batch);
 }
 
-bool CBlockTreeDB::ReadAddressIndex(uint160 addressHash, int type,
+bool CBlockTreeDB::ReadAddressIndex(uint160 addressHash, AddressType type,
                                     std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
                                     int start, int end) {
 
diff --git a/src/txdb.h b/src/txdb.h
index 9b73e4780b564..48f440bad5e47 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -109,11 +109,11 @@ class CBlockTreeDB : public CDBWrapper
     bool ReadSpentIndex(CSpentIndexKey &key, CSpentIndexValue &value);
     bool UpdateSpentIndex(const std::vector<std::pair<CSpentIndexKey, CSpentIndexValue> >&vect);
     bool UpdateAddressUnspentIndex(const std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue > >&vect);
-    bool ReadAddressUnspentIndex(uint160 addressHash, int type,
+    bool ReadAddressUnspentIndex(uint160 addressHash, AddressType type,
                                  std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &vect);
     bool WriteAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount> > &vect);
     bool EraseAddressIndex(const std::vector<std::pair<CAddressIndexKey, CAmount> > &vect);
-    bool ReadAddressIndex(uint160 addressHash, int type,
+    bool ReadAddressIndex(uint160 addressHash, AddressType type,
                           std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
                           int start = 0, int end = 0);
     bool WriteTimestampIndex(const CTimestampIndexKey &timestampIndex);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 6ad711829b89b..ee7a2cf549bea 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -475,7 +475,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
         const Coin& coin = view.AccessCoin(input.prevout);
         const CTxOut &prevout = coin.out;
 
-        uint8_t address_type{0};
+        AddressType address_type{AddressType::UNKNOWN};
         uint160 address_bytes;
 
         if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
@@ -491,7 +491,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
     for (unsigned int k = 0; k < tx.vout.size(); k++) {
         const CTxOut &out = tx.vout[k];
 
-        uint8_t address_type{0};
+        AddressType address_type{AddressType::UNKNOWN};
         uint160 address_bytes;
 
         if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
@@ -506,7 +506,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
     mapAddressInserted.insert(std::make_pair(txhash, inserted));
 }
 
-bool CTxMemPool::getAddressIndex(std::vector<std::pair<uint160, int> > &addresses,
+bool CTxMemPool::getAddressIndex(std::vector<std::pair<uint160, AddressType> > &addresses,
                                  std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > &results)
 {
     LOCK(cs);
@@ -549,7 +549,7 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
         const Coin& coin = view.AccessCoin(input.prevout);
         const CTxOut &prevout = coin.out;
 
-        uint8_t address_type{0};
+        AddressType address_type{AddressType::UNKNOWN};
         uint160 address_bytes;
 
         if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
diff --git a/src/txmempool.h b/src/txmempool.h
index ba09ac899948c..9a8719b7aed28 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -603,7 +603,7 @@ class CTxMemPool
     void addUnchecked(const CTxMemPoolEntry& entry, setEntries& setAncestors, bool validFeeEstimate = true) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
 
     void addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewCache &view);
-    bool getAddressIndex(std::vector<std::pair<uint160, int> > &addresses,
+    bool getAddressIndex(std::vector<std::pair<uint160, AddressType> > &addresses,
                          std::vector<std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> > &results);
     bool removeAddressIndex(const uint256 txhash);
 
diff --git a/src/validation.cpp b/src/validation.cpp
index b574d42ed6431..be41201b94b92 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1037,7 +1037,7 @@ bool GetSpentIndex(CTxMemPool& mempool, CSpentIndexKey &key, CSpentIndexValue &v
     return true;
 }
 
-bool GetAddressIndex(uint160 addressHash, int type,
+bool GetAddressIndex(uint160 addressHash, AddressType type,
                      std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex, int start, int end)
 {
     if (!fAddressIndex)
@@ -1049,7 +1049,7 @@ bool GetAddressIndex(uint160 addressHash, int type,
     return true;
 }
 
-bool GetAddressUnspent(uint160 addressHash, int type,
+bool GetAddressUnspent(uint160 addressHash, AddressType type,
                        std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs)
 {
     if (!fAddressIndex)
@@ -1706,7 +1706,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
             for (unsigned int k = tx.vout.size(); k-- > 0;) {
                 const CTxOut &out = tx.vout[k];
 
-                uint8_t address_type{0};
+                AddressType address_type{AddressType::UNKNOWN};
                 uint160 address_bytes;
 
                 if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
@@ -1759,7 +1759,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                     const Coin &coin = view.AccessCoin(tx.vin[j].prevout);
                     const CTxOut &prevout = coin.out;
 
-                    uint8_t address_type{0};
+                    AddressType address_type{AddressType::UNKNOWN};
                     uint160 address_bytes;
 
                     if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
@@ -2224,7 +2224,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                     const Coin& coin = view.AccessCoin(tx.vin[j].prevout);
                     const CTxOut &prevout = coin.out;
 
-                    uint8_t address_type{0};
+                    AddressType address_type{AddressType::UNKNOWN};
                     uint160 address_bytes;
 
                     AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
@@ -2278,7 +2278,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
             for (unsigned int k = 0; k < tx.vout.size(); k++) {
                 const CTxOut &out = tx.vout[k];
 
-                uint8_t address_type{0};
+                AddressType address_type{AddressType::UNKNOWN};
                 uint160 address_bytes;
 
                 if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
@@ -4805,7 +4805,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                     const Coin& coin = inputs.AccessCoin(tx->vin[j].prevout);
                     const CTxOut& prevout = coin.out;
 
-                    uint8_t address_type{0};
+                    AddressType address_type{AddressType::UNKNOWN};
                     uint160 address_bytes;
 
                     AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
@@ -4830,7 +4830,7 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
                 for (size_t k = 0; k < tx->vout.size(); k++) {
                     const CTxOut& out = tx->vout[k];
 
-                    uint8_t address_type{0};
+                    AddressType address_type{AddressType::UNKNOWN};
                     uint160 address_bytes;
 
                     if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
diff --git a/src/validation.h b/src/validation.h
index 38029774a1937..1c69b69f48af8 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -307,10 +307,10 @@ class CScriptCheck
 
 bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, std::vector<uint256> &hashes);
 bool GetSpentIndex(CTxMemPool& mempool, CSpentIndexKey &key, CSpentIndexValue &value);
-bool GetAddressIndex(uint160 addressHash, int type,
+bool GetAddressIndex(uint160 addressHash, AddressType type,
                      std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,
                      int start = 0, int end = 0);
-bool GetAddressUnspent(uint160 addressHash, int type,
+bool GetAddressUnspent(uint160 addressHash, AddressType type,
                        std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs);
 /** Initializes the script-execution cache */
 void InitScriptExecutionCache();

From 93ddd3f7e8113c8e5dc50cbb5fdedcd70908fa16 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kittywhiskers@users.noreply.github.com>
Date: Mon, 25 Sep 2023 20:49:15 +0530
Subject: [PATCH 19/19] refactor: consolidate P2PK{H} types to P2PK_OR_P2PKH

---
 src/addressindex.cpp | 4 ++--
 src/addressindex.h   | 3 +--
 src/core_write.cpp   | 2 +-
 src/rpc/misc.cpp     | 4 ++--
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/addressindex.cpp b/src/addressindex.cpp
index 98459c2e3e7c2..e9eee7850f8cd 100644
--- a/src/addressindex.cpp
+++ b/src/addressindex.cpp
@@ -29,10 +29,10 @@ bool AddressBytesFromScript(const CScript& script, AddressType& address_type, ui
         address_type  = AddressType::P2SH;
         address_bytes = uint160(TrimScriptP2SH(script));
     } else if (script.IsPayToPublicKeyHash()) {
-        address_type  = AddressType::P2PKH;
+        address_type  = AddressType::P2PK_OR_P2PKH;
         address_bytes = uint160(TrimScriptP2PKH(script));
     } else if (script.IsPayToPublicKey()) {
-        address_type  = AddressType::P2PK;
+        address_type  = AddressType::P2PK_OR_P2PKH;
         address_bytes = Hash160(TrimScriptP2PK(script));
     } else {
         address_type  = AddressType::UNKNOWN;
diff --git a/src/addressindex.h b/src/addressindex.h
index fec8a664892a9..42f82272376c6 100644
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -19,8 +19,7 @@
 class CScript;
 
 enum class AddressType : uint8_t {
-    P2PK = 1,
-    P2PKH = 1,
+    P2PK_OR_P2PKH = 1,
     P2SH = 2,
 
     UNKNOWN = 0
diff --git a/src/core_write.cpp b/src/core_write.cpp
index c6c329479d844..65f40b0bbb4d1 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -216,7 +216,7 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
                     auto spentInfo = it->second;
                     in.pushKV("value", ValueFromAmount(spentInfo.m_amount));
                     in.pushKV("valueSat", spentInfo.m_amount);
-                    if (spentInfo.m_address_type == AddressType::P2PK) {
+                    if (spentInfo.m_address_type == AddressType::P2PK_OR_P2PKH) {
                         in.pushKV("address", EncodeDestination(PKHash(spentInfo.m_address_bytes)));
                     } else if (spentInfo.m_address_type == AddressType::P2SH) {
                         in.pushKV("address", EncodeDestination(ScriptHash(spentInfo.m_address_bytes)));
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 7313af1859242..edf09cfb134f1 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -598,7 +598,7 @@ static bool getAddressFromIndex(const AddressType& type, const uint160 &hash, st
 {
     if (type == AddressType::P2SH) {
         address = EncodeDestination(ScriptHash(hash));
-    } else if (type == AddressType::P2PK) {
+    } else if (type == AddressType::P2PK_OR_P2PKH) {
         address = EncodeDestination(PKHash(hash));
     } else {
         return false;
@@ -615,7 +615,7 @@ static bool getIndexKey(const std::string& str, uint160& hashBytes, AddressType&
     }
     const PKHash *pkhash = std::get_if<PKHash>(&dest);
     const ScriptHash *scriptID = std::get_if<ScriptHash>(&dest);
-    type = pkhash ? AddressType::P2PK : AddressType::P2SH;
+    type = pkhash ? AddressType::P2PK_OR_P2PKH : AddressType::P2SH;
     hashBytes = pkhash ? uint160(*pkhash) : uint160(*scriptID);
     return true;
 }