From d18516e391094a523878bbecbad27c067f705c02 Mon Sep 17 00:00:00 2001
From: timemarkovqtum <time.markov@qtum.com>
Date: Mon, 4 Mar 2024 16:27:08 +0100
Subject: [PATCH] Port rpc node

---
 src/Makefile.am             |   6 +
 src/key_io.cpp              |  38 +++
 src/key_io.h                |   1 +
 src/qtum/qtumstate.cpp      |   2 +-
 src/qtum/storageresults.cpp |   1 +
 src/qtum/storageresults.h   |   2 +-
 src/rpc/node.cpp            | 554 +++++++++++++++++++++++++++++++++++-
 src/txmempool.h             |  85 +++++-
 src/validation.cpp          |  53 ++++
 src/validation.h            |  36 +++
 10 files changed, 773 insertions(+), 5 deletions(-)

diff --git a/src/Makefile.am b/src/Makefile.am
index 6e41d3693c..b1fce17fc2 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -383,7 +383,10 @@ BITCOIN_CORE_H = \
   zmq/zmqrpc.h \
   zmq/zmqutil.h \
   qtum/posutils.h \
+  qtum/qtumstate.h \
   qtum/qtumtransaction.h \
+  qtum/qtumDGP.h \
+  qtum/storageresults.h \
   qtum/qtumutils.h \
   qtum/qtumtoken.h \
   qtum/qtumledger.h \
@@ -489,6 +492,8 @@ libbitcoin_node_a_SOURCES = \
   validation.cpp \
   validationinterface.cpp \
   versionbits.cpp \
+  qtum/qtumstate.cpp \
+  qtum/storageresults.cpp \
   qtum/qtumledger.cpp \
   $(BITCOIN_CORE_H)
 
@@ -733,6 +738,7 @@ libbitcoin_common_a_SOURCES = \
   script/solver.cpp \
   warnings.cpp \
   qtum/qtumutils.cpp \
+  qtum/qtumDGP.cpp \
   qtum/qtumtoken.cpp \
   qtum/delegationutils.cpp \
   util/contractabi.cpp \
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 5bcbb8a069..5b0b6e009a 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -310,3 +310,41 @@ bool IsValidDestinationString(const std::string& str)
 {
     return IsValidDestinationString(str, Params());
 }
+bool DecodeIndexKey(const std::string &str, uint256 &hashBytes, int &type)
+{
+    CTxDestination dest = DecodeDestination(str);
+    if (IsValidDestination(dest))
+    {
+        if(std::holds_alternative<PKHash>(dest))
+        {
+            PKHash keyID = std::get<PKHash>(dest);
+            memcpy(hashBytes.data(), &keyID, 20);
+            type = 1;
+            return true;
+        }
+
+        if(std::holds_alternative<ScriptHash>(dest))
+        {
+            ScriptHash scriptID = std::get<ScriptHash>(dest);
+            memcpy(hashBytes.data(), &scriptID, 20);
+            type = 2;
+            return true;
+        }
+
+        if (std::holds_alternative<WitnessV0ScriptHash>(dest)) {
+            WitnessV0ScriptHash witnessV0ScriptID = std::get<WitnessV0ScriptHash>(dest);
+            memcpy(hashBytes.data(), &witnessV0ScriptID, 32);
+            type = 3;
+            return true;
+        }
+
+        if (std::holds_alternative<WitnessV0KeyHash>(dest)) {
+            const WitnessV0KeyHash witnessV0KeyID = std::get<WitnessV0KeyHash>(dest);
+            memcpy(hashBytes.data(), &witnessV0KeyID, 20);
+            type = 4;
+            return true;
+        }
+    }
+
+    return false;
+}
diff --git a/src/key_io.h b/src/key_io.h
index e387273e54..3156ad6a9b 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -26,5 +26,6 @@ CTxDestination DecodeDestination(const std::string& str);
 CTxDestination DecodeDestination(const std::string& str, std::string& error_msg, std::vector<int>* error_locations = nullptr);
 bool IsValidDestinationString(const std::string& str);
 bool IsValidDestinationString(const std::string& str, const CChainParams& params);
+bool DecodeIndexKey(const std::string& str, uint256& hashBytes, int& type);
 
 #endif // BITCOIN_KEY_IO_H
diff --git a/src/qtum/qtumstate.cpp b/src/qtum/qtumstate.cpp
index c352a9764b..537c34b5a5 100644
--- a/src/qtum/qtumstate.cpp
+++ b/src/qtum/qtumstate.cpp
@@ -1,5 +1,5 @@
 #include <sstream>
-#include <util/system.h>
+#include <common/system.h>
 #include <validation.h>
 #include <chainparams.h>
 #include <script/script.h>
diff --git a/src/qtum/storageresults.cpp b/src/qtum/storageresults.cpp
index 698d120a2e..dcb040c010 100644
--- a/src/qtum/storageresults.cpp
+++ b/src/qtum/storageresults.cpp
@@ -1,5 +1,6 @@
 #include <qtum/storageresults.h>
 #include <util/convert.h>
+#include <logging.h>
 
 StorageResults::StorageResults(std::string const& _path){
 	path = _path + "/resultsDB";
diff --git a/src/qtum/storageresults.h b/src/qtum/storageresults.h
index e522ab3f9e..78a43be573 100644
--- a/src/qtum/storageresults.h
+++ b/src/qtum/storageresults.h
@@ -3,7 +3,7 @@
 #include <libethereum/State.h>
 #include <libethereum/Transaction.h>
 #include <leveldb/db.h>
-#include <util/system.h>
+#include <common/system.h>
 
 using logEntriesSerialize = std::vector<std::pair<dev::Address, std::pair<dev::h256s, dev::bytes>>>;
 
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index 6b3662996c..35ac038dbc 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -22,6 +22,9 @@
 #include <univalue.h>
 #include <util/any.h>
 #include <util/check.h>
+#include <txmempool.h>
+#include <validation.h>
+#include <key_io.h>
 
 #include <stdint.h>
 #ifdef HAVE_MALLOC_INFO
@@ -268,7 +271,7 @@ static RPCHelpMan echo(const std::string& name)
                 "\nSimply echo back the input arguments. This command is for testing.\n"
                 "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n"
                 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
-                "bitcoin-cli and the GUI. There is no server-side difference.",
+                "qtum-cli and the GUI. There is no server-side difference.",
         {
             {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
             {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
@@ -319,7 +322,7 @@ static RPCHelpMan echoipc()
                 // and spawn bitcoin-echo below instead of bitcoin-node. But
                 // using bitcoin-node avoids the need to build and install a
                 // new executable just for this one test.
-                auto init = ipc->spawnProcess("bitcoin-node");
+                auto init = ipc->spawnProcess("qtum-node");
                 echo = init->makeEcho();
                 ipc->addCleanup(*echo, [init = init.release()] { delete init; });
             } else {
@@ -393,6 +396,553 @@ static RPCHelpMan getindexinfo()
     };
 }
 
+static RPCHelpMan getdgpinfo()
+{
+    return RPCHelpMan{"getdgpinfo",
+                "\nReturns an object containing DGP state info.\n",
+                {},
+                RPCResult{
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::NUM, "maxblocksize", "Current maximum block size"},
+                        {RPCResult::Type::NUM, "mingasprice", "Current minimum gas price"},
+                        {RPCResult::Type::NUM, "blockgaslimit", "Current block gas limit"},
+                    }
+                },
+                RPCExamples{
+                    HelpExampleCli("getdgpinfo", "")
+            + HelpExampleRpc("getdgpinfo", "")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+    LOCK(cs_main);
+
+    CChain& active_chain = chainman.ActiveChain();
+    QtumDGP qtumDGP(globalState.get(), chainman.ActiveChainstate());
+
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("maxblocksize", (uint64_t)qtumDGP.getBlockSize(active_chain.Height()));
+    obj.pushKV("mingasprice", (uint64_t)qtumDGP.getMinGasPrice(active_chain.Height()));
+    obj.pushKV("blockgaslimit", (uint64_t)qtumDGP.getBlockGasLimit(active_chain.Height()));
+
+    return obj;
+},
+    };
+}
+
+static RPCHelpMan getblockhashes()
+{
+    return RPCHelpMan{"getblockhashes",
+                "\nReturns array of hashes of blocks within the timestamp range provided.\n",
+                {
+                    {"high", RPCArg::Type::NUM, RPCArg::Optional::NO, "The newer block timestamp"},
+                    {"low", RPCArg::Type::NUM, RPCArg::Optional::NO, "The older block timestamp"},
+                    {"options", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "An object with options",
+                        {
+                            {"noOrphans", RPCArg::Type::BOOL, RPCArg::Default{"false"}, "Will only include blocks on the main chain"},
+                            {"logicalTimes", RPCArg::Type::BOOL, RPCArg::Default{"false"}, "Will include logical timestamps with hashes"},
+                        },
+                    },
+                },
+                {
+                    RPCResult{"if logicalTimes is set to false",
+                        RPCResult::Type::ARR, "", "",
+                        {
+                            {RPCResult::Type::STR_HEX, "", "The block hash"}
+                        },
+                    },
+                    RPCResult{"if logicalTimes is set to true",
+                        RPCResult::Type::ARR, "", "",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR_HEX, "blockhash", "The block hash"},
+                                {RPCResult::Type::NUM, "logicalts", "The logical timestamp"},
+                            }}
+                        },
+                    },
+                },
+                RPCExamples{
+                    HelpExampleCli("getblockhashes", "1231614698 1231024505")
+                    + HelpExampleCli("getblockhashes", "1231614698 1231024505 '{\"noOrphans\":false, \"logicalTimes\":true}'")
+            + HelpExampleRpc("getblockhashes", "1231614698, 1231024505")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
+    unsigned int high = request.params[0].getInt<int>();
+    unsigned int low = request.params[1].getInt<int>();
+    bool fActiveOnly = false;
+    bool fLogicalTS = false;
+
+    if (!request.params[2].isNull()) {
+        if (request.params[2].isObject()) {
+            UniValue noOrphans = request.params[2].get_obj().find_value("noOrphans");
+            UniValue returnLogical = request.params[2].get_obj().find_value("logicalTimes");
+
+            if (noOrphans.isBool())
+                fActiveOnly = noOrphans.get_bool();
+
+            if (returnLogical.isBool())
+                fLogicalTS = returnLogical.get_bool();
+        }
+    }
+
+    std::vector<std::pair<uint256, unsigned int> > blockHashes;
+    bool found = false;
+
+    found = GetTimestampIndex(high, low, fActiveOnly, blockHashes, chainman);
+
+    if (!found) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for block hashes");
+    }
+
+    UniValue result(UniValue::VARR);
+
+    for (std::vector<std::pair<uint256, unsigned int> >::const_iterator it=blockHashes.begin(); it!=blockHashes.end(); it++) {
+        if (fLogicalTS) {
+            UniValue item(UniValue::VOBJ);
+            item.pushKV("blockhash", it->first.GetHex());
+            item.pushKV("logicalts", (int)it->second);
+            result.push_back(item);
+        } else {
+            result.push_back(it->first.GetHex());
+        }
+    }
+
+    return result;
+},
+    };
+}
+
+bool getAddressesFromParams(const UniValue& params, std::vector<std::pair<uint256, int> > &addresses)
+{
+    if (params[0].isStr()) {
+        uint256 hashBytes;
+        int type = 0;
+        if (!DecodeIndexKey(params[0].get_str(), hashBytes, type)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+        }
+        addresses.push_back(std::make_pair(hashBytes, type));
+    } else if (params[0].isObject()) {
+
+        UniValue addressValues = params[0].get_obj().find_value("addresses");
+        if (!addressValues.isArray()) {
+            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) {
+
+            uint256 hashBytes;
+            int type = 0;
+            if (!DecodeIndexKey(it->get_str(), hashBytes, type)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+            }
+            addresses.push_back(std::make_pair(hashBytes, type));
+        }
+    } else {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+    }
+
+    return true;
+}
+
+bool heightSort(std::pair<CAddressUnspentKey, CAddressUnspentValue> a,
+                std::pair<CAddressUnspentKey, CAddressUnspentValue> b) {
+    return a.second.blockHeight < b.second.blockHeight;
+}
+
+bool timestampSort(std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> a,
+                   std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> b) {
+    return a.second.time < b.second.time;
+}
+
+bool getAddressFromIndex(const int &type, const uint256 &hash, std::string &address)
+{
+    if (type == 2) {
+        std::vector<unsigned char> addressBytes(hash.begin(), hash.begin() + 20);
+        address = EncodeDestination(ScriptHash(uint160(addressBytes)));
+    } else if (type == 1) {
+        std::vector<unsigned char> addressBytes(hash.begin(), hash.begin() + 20);
+        address = EncodeDestination(PKHash(uint160(addressBytes)));
+    } else if (type == 3) {
+        address = EncodeDestination(WitnessV0ScriptHash(hash));
+    } else if (type == 4) {
+        std::vector<unsigned char> addressBytes(hash.begin(), hash.begin() + 20);
+        address = EncodeDestination(WitnessV0KeyHash(uint160(addressBytes)));
+    } else {
+        return false;
+    }
+    return true;
+}
+
+static RPCHelpMan getaddressdeltas()
+{
+    return RPCHelpMan{"getaddressdeltas",
+            "\nReturns all changes for an address (requires addressindex to be enabled).\n",
+            {
+                {"argument", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Json object",
+                    {
+                        {"addresses", RPCArg::Type::ARR, RPCArg::Optional::NO, "The qtum addresses",
+                            {
+                                {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The qtum address"},
+                            }
+                        },
+                        {"start", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The start block height"},
+                        {"end", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The end block height"},
+                        {"chainInfo", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Include chain info in results, only applies if start and end specified"},
+                    }
+                }
+            },
+            {
+                RPCResult{"if chainInfo is set to false",
+                    RPCResult::Type::ARR, "", "",
+                    {
+                        {RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::NUM, "satoshis", "The difference of satoshis"},
+                            {RPCResult::Type::STR_HEX, "txid", "The related txid"},
+                            {RPCResult::Type::NUM, "index", "The related input or output index"},
+                            {RPCResult::Type::NUM, "blockindex", "The transaction index in block"},
+                            {RPCResult::Type::NUM, "height", "The block height"},
+                            {RPCResult::Type::STR, "address", "The qtum address"},
+                        }}
+                    },
+                },
+                RPCResult{"if chainInfo is set to true",
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::ARR, "deltas", "List of delta",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::NUM, "satoshis", "The difference of satoshis"},
+                                {RPCResult::Type::STR_HEX, "txid", "The related txid"},
+                                {RPCResult::Type::NUM, "index", "The related input or output index"},
+                                {RPCResult::Type::NUM, "blockindex", "The transaction index in block"},
+                                {RPCResult::Type::NUM, "height", "The block height"},
+                                {RPCResult::Type::STR, "address", "The qtum address"},
+                            }}
+                        }},
+                        {RPCResult::Type::OBJ, "start", "Start block",
+                        {
+                            {RPCResult::Type::STR_HEX, "hash", "The block hash"},
+                            {RPCResult::Type::NUM, "height", "The block height"},
+                        }},
+                        {RPCResult::Type::OBJ, "end", "End block",
+                        {
+                            {RPCResult::Type::STR_HEX, "hash", "The block hash"},
+                            {RPCResult::Type::NUM, "height", "The block height"},
+                        }},
+                    },
+                },
+            },
+            RPCExamples{
+                HelpExampleCli("getaddressdeltas", "'{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}'")
+        + HelpExampleRpc("getaddressdeltas", "{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}") +
+                HelpExampleCli("getaddressdeltas", "'{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"], \"start\": 5000, \"end\": 5500, \"chainInfo\": true}'")
+        + HelpExampleRpc("getaddressdeltas", "{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"], \"start\": 5000, \"end\": 5500, \"chainInfo\": true}")
+            },
+    [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
+    UniValue startValue = request.params[0].get_obj().find_value("start");
+    UniValue endValue = request.params[0].get_obj().find_value("end");
+
+    UniValue chainInfo = request.params[0].get_obj().find_value("chainInfo");
+    bool includeChainInfo = false;
+    if (chainInfo.isBool()) {
+        includeChainInfo = chainInfo.get_bool();
+    }
+
+    int start = 0;
+    int end = 0;
+
+    if (startValue.isNum() && endValue.isNum()) {
+        start = startValue.getInt<int>();
+        end = endValue.getInt<int>();
+        if (start <= 0 || end <= 0) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Start and end is expected to be greater than zero");
+        }
+        if (end < start) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "End value is expected to be greater than start");
+        }
+    }
+
+    std::vector<std::pair<uint256, int> > addresses;
+
+    if (!getAddressesFromParams(request.params, addresses)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+    }
+
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+
+    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+        if (start > 0 && end > 0) {
+            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, chainman.m_blockman, start, end)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
+            }
+        } else {
+            if (!GetAddressIndex((*it).first, (*it).second, addressIndex, chainman.m_blockman)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
+            }
+        }
+    }
+
+    UniValue deltas(UniValue::VARR);
+
+    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)) {
+            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("address", address);
+        deltas.push_back(delta);
+    }
+
+    UniValue result(UniValue::VOBJ);
+
+    if (includeChainInfo && start > 0 && end > 0) {
+        ChainstateManager& chainman = EnsureAnyChainman(request.context);
+        LOCK(cs_main);
+
+        CChain& active_chain = chainman.ActiveChain();
+        if (start > active_chain.Height() || end > active_chain.Height()) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Start or end is outside chain range");
+        }
+
+        CBlockIndex* startIndex = active_chain[start];
+        CBlockIndex* endIndex = active_chain[end];
+
+        UniValue startInfo(UniValue::VOBJ);
+        UniValue endInfo(UniValue::VOBJ);
+
+        startInfo.pushKV("hash", startIndex->GetBlockHash().GetHex());
+        startInfo.pushKV("height", start);
+
+        endInfo.pushKV("hash", endIndex->GetBlockHash().GetHex());
+        endInfo.pushKV("height", end);
+
+        result.pushKV("deltas", deltas);
+        result.pushKV("start", startInfo);
+        result.pushKV("end", endInfo);
+
+        return result;
+    } else {
+        return deltas;
+    }
+},
+    };
+}
+
+static RPCHelpMan getaddressbalance()
+{
+    return RPCHelpMan{"getaddressbalance",
+                "\nReturns the balance for an address(es) (requires addressindex to be enabled).\n",
+                {
+                    {"argument", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Json object",
+                        {
+                            {"addresses", RPCArg::Type::ARR, RPCArg::Optional::NO, "The qtum addresses",
+                                {
+                                    {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The qtum address"},
+                                }
+                            },
+                        }
+                    }
+                },
+                RPCResult{
+                    RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::NUM, "balance", "The current balance in satoshis"},
+                        {RPCResult::Type::NUM, "received", "The total number of satoshis received (including change)"},
+                        {RPCResult::Type::NUM, "immature", "The immature balance in satoshis"},
+                    }
+                },
+                RPCExamples{
+                    HelpExampleCli("getaddressbalance", "'{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}'")
+            + HelpExampleRpc("getaddressbalance", "{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
+    std::vector<std::pair<uint256, int> > addresses;
+
+    if (!getAddressesFromParams(request.params, addresses)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+    }
+
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+
+    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+        if (!GetAddressIndex((*it).first, (*it).second, addressIndex, chainman.m_blockman)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
+        }
+    }
+
+    CAmount balance = 0;
+    CAmount received = 0;
+    CAmount immature = 0;
+
+    LOCK(cs_main);
+    CChain& active_chain = chainman.ActiveChain();
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++) {
+        if (it->second > 0) {
+            received += it->second;
+        }
+        balance += it->second;
+        int nHeight = active_chain.Height();
+        if (it->first.txindex == 1 && ((nHeight - it->first.blockHeight) < Params().GetConsensus().CoinbaseMaturity(nHeight)))
+            immature += it->second; //immature stake outputs
+    }
+
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("balance", balance);
+    result.pushKV("received", received);
+    result.pushKV("immature", immature);
+
+    return result;
+},
+    };
+}
+
+static RPCHelpMan getaddressutxos()
+{
+    return RPCHelpMan{"getaddressutxos",
+                "\nReturns all unspent outputs for an address (requires addressindex to be enabled).\n",
+                {
+                    {"argument", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Json object",
+                        {
+                            {"addresses", RPCArg::Type::ARR, RPCArg::Optional::NO, "The qtum addresses",
+                                {
+                                    {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The qtum address"},
+                                }
+                            },
+                            {"chainInfo", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Include chain info with results"},
+                        }
+                    }
+                },
+                {
+                    RPCResult{"if chainInfo is set to false",
+                        RPCResult::Type::ARR, "", "",
+                        {
+                            {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR, "address", "The address base58check encoded"},
+                                {RPCResult::Type::STR_HEX, "txid", "The output txid"},
+                                {RPCResult::Type::NUM, "height", "The block height"},
+                                {RPCResult::Type::NUM, "outputIndex", "The output index"},
+                                {RPCResult::Type::STR_HEX, "script", "The script hex encoded"},
+                                {RPCResult::Type::NUM, "satoshis", "The number of satoshis of the output"},
+                                {RPCResult::Type::BOOL, "isStake", "Is coinstake output"},
+                            }}
+                        },
+                    },
+                    RPCResult{"if chainInfo is set to true",
+                        RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::ARR, "utxos", "List of utxo",
+                            {
+                                {RPCResult::Type::OBJ, "", "",
+                                {
+                                    {RPCResult::Type::STR, "address", "The address base58check encoded"},
+                                    {RPCResult::Type::STR_HEX, "txid", "The output txid"},
+                                    {RPCResult::Type::NUM, "height", "The block height"},
+                                    {RPCResult::Type::NUM, "outputIndex", "The output index"},
+                                    {RPCResult::Type::STR_HEX, "script", "The script hex encoded"},
+                                    {RPCResult::Type::NUM, "satoshis", "The number of satoshis of the output"},
+                                    {RPCResult::Type::BOOL, "isStake", "Is coinstake output"},
+                                }}
+                            }},
+                            {RPCResult::Type::STR_HEX, "hash", "The tip block hash"},
+                            {RPCResult::Type::NUM, "height", "The tip block height"},
+                        },
+                    },
+                },
+                RPCExamples{
+                    HelpExampleCli("getaddressutxos", "'{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}'")
+            + HelpExampleRpc("getaddressutxos", "{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"]}") +
+                    HelpExampleCli("getaddressutxos", "'{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"], \"chainInfo\": true}'")
+            + HelpExampleRpc("getaddressutxos", "{\"addresses\": [\"QD1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"], \"chainInfo\": true}")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
+    bool includeChainInfo = false;
+    if (request.params[0].isObject()) {
+        UniValue chainInfo = request.params[0].get_obj().find_value("chainInfo");
+        if (chainInfo.isBool()) {
+            includeChainInfo = chainInfo.get_bool();
+        }
+    }
+
+    std::vector<std::pair<uint256, int> > addresses;
+
+    if (!getAddressesFromParams(request.params, addresses)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
+    }
+
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+
+    for (std::vector<std::pair<uint256, int> >::iterator it = addresses.begin(); it != addresses.end(); it++) {
+        if (!GetAddressUnspent((*it).first, (*it).second, unspentOutputs, chainman.m_blockman)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
+        }
+    }
+
+    std::sort(unspentOutputs.begin(), unspentOutputs.end(), heightSort);
+
+    UniValue utxos(UniValue::VARR);
+
+    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)) {
+            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(MakeUCharSpan(it->second.script)));
+        output.pushKV("satoshis", it->second.satoshis);
+        output.pushKV("height", it->second.blockHeight);
+        output.pushKV("isStake", it->second.coinStake);
+        utxos.push_back(output);
+    }
+
+    if (includeChainInfo) {
+        UniValue result(UniValue::VOBJ);
+        result.pushKV("utxos", utxos);
+
+        ChainstateManager& chainman = EnsureAnyChainman(request.context);
+        LOCK(cs_main);
+        CChain& active_chain = chainman.ActiveChain();
+        result.pushKV("hash", active_chain.Tip()->GetBlockHash().GetHex());
+        result.pushKV("height", (int)active_chain.Height());
+        return result;
+    } else {
+        return utxos;
+    }
+},
+    };
+}
+
 void RegisterNodeRPCCommands(CRPCTable& t)
 {
     static const CRPCCommand commands[]{
diff --git a/src/txmempool.h b/src/txmempool.h
index cbeabb31fa..654bd7fcdc 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -42,13 +42,96 @@
 class CChain;
 
 /** Fake height value used in Coin to signify they are only in the memory pool (since 0.8) */
-static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
+static const uint32_t MEMPOOL_HEIGHT = 0x0FFFFFFF;
 
 /**
  * Test whether the LockPoints height and time are still valid on the current chain
  */
 bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
+//////////////////////////////////////////////////////// // qtum
+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;
+        }
+    }
+};
+
+struct CMempoolAddressDelta
+{
+    int64_t time;
+    CAmount amount;
+    uint256 prevhash;
+    unsigned int prevout;
+
+    CMempoolAddressDelta(int64_t t, CAmount a, uint256 hash, unsigned int out) {
+        time = t;
+        amount = a;
+        prevhash = hash;
+        prevout = out;
+    }
+
+    CMempoolAddressDelta(int64_t t, CAmount a) {
+        time = t;
+        amount = a;
+        prevhash.SetNull();
+        prevout = 0;
+    }
+};
+
+struct CMempoolAddressDeltaKey
+{
+    int type;
+    uint256 addressBytes;
+    uint256 txhash;
+    unsigned int index;
+    int spending;
+
+    CMempoolAddressDeltaKey(int addressType, uint256 addressHash, uint256 hash, unsigned int i, int s) {
+        type = addressType;
+        addressBytes = addressHash;
+        txhash = hash;
+        index = i;
+        spending = s;
+    }
+
+    CMempoolAddressDeltaKey(int addressType, uint256 addressHash) {
+        type = addressType;
+        addressBytes = addressHash;
+        txhash.SetNull();
+        index = 0;
+        spending = 0;
+    }
+};
+
+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;
+        }
+    }
+};
+////////////////////////////////////////////////////////
+
 // extracts a transaction hash from CTxMemPoolEntry or CTransactionRef
 struct mempoolentry_txid
 {
diff --git a/src/validation.cpp b/src/validation.cpp
index 573d36a3ab..d4d6bc6d60 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -11,6 +11,7 @@
 
 #include <arith_uint256.h>
 #include <chain.h>
+#include <chainparams.h>
 #include <checkqueue.h>
 #include <clientversion.h>
 #include <consensus/amount.h>
@@ -31,6 +32,7 @@
 #include <logging/timer.h>
 #include <node/blockstorage.h>
 #include <node/utxo_snapshot.h>
+#include <node/transaction.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
 #include <policy/settings.h>
@@ -42,6 +44,7 @@
 #include <script/script.h>
 #include <script/sigcache.h>
 #include <signet.h>
+#include <timedata.h>
 #include <tinyformat.h>
 #include <txdb.h>
 #include <txmempool.h>
@@ -61,6 +64,11 @@
 #include <validationinterface.h>
 #include <warnings.h>
 
+#include <libethcore/ABI.h>
+#include <univalue.h>
+#include <util/signstr.h>
+#include <qtum/qtumutils.h>
+
 #include <algorithm>
 #include <cassert>
 #include <chrono>
@@ -70,6 +78,7 @@
 #include <string>
 #include <tuple>
 #include <utility>
+#include <fstream>
 
 using kernel::CCoinsStats;
 using kernel::CoinStatsHashType;
@@ -105,6 +114,12 @@ const std::vector<std::string> CHECKLEVEL_DOC {
  * */
 static constexpr int PRUNE_LOCK_BUFFER{10};
 
+std::unique_ptr<QtumState> globalState;
+std::shared_ptr<dev::eth::SealEngineFace> globalSealEngine;
+std::unique_ptr<StorageResults> pstorageresult;
+bool fRecordLogOpcodes = false;
+bool fIsVMlogFile = false;
+bool fGettingValuesDGP = false;
 std::set<std::pair<COutPoint, unsigned int>> setStakeSeen;
 
 GlobalMutex g_best_block_mutex;
@@ -2151,6 +2166,10 @@ static SteadyClock::duration time_index{};
 static SteadyClock::duration time_total{};
 static int64_t num_blocks_total = 0;
 
+std::vector<ResultExecute> CallContract(const dev::Address& addrContract, std::vector<unsigned char> opcode, Chainstate& chainstate, const dev::Address& sender, uint64_t gasLimit, CAmount nAmount){
+    return {};
+}
+
 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
@@ -6036,6 +6055,40 @@ std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstat
     return {prune_start, prune_end};
 }
 
+////////////////////////////////////////////////////////////////////////////////// // qtum
+bool GetAddressIndex(uint256 addressHash, int type, std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex, node::BlockManager& blockman, int start, int end)
+{
+    if (!fAddressIndex)
+        return error("address index not enabled");
+
+    if (!blockman.m_block_tree_db->ReadAddressIndex(addressHash, type, addressIndex, start, end))
+        return error("unable to get txids for address");
+
+    return true;
+}
+
+bool GetAddressUnspent(uint256 addressHash, int type, std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs, node::BlockManager& blockman)
+{
+    if (!fAddressIndex)
+        return error("address index not enabled");
+
+    if (!blockman.m_block_tree_db->ReadAddressUnspentIndex(addressHash, type, unspentOutputs))
+        return error("unable to get txids for address");
+
+    return true;
+}
+
+bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes, ChainstateManager& chainman)
+{
+    if (!fAddressIndex)
+        return error("Timestamp index not enabled");
+
+    if (!chainman.m_blockman.m_block_tree_db->ReadTimestampIndex(high, low, fActiveOnly, hashes, chainman))
+        return error("Unable to get hashes for timestamps");
+
+    return true;
+}
+
 CAmount GetTxGasFee(const CMutableTransaction& _tx, const CTxMemPool& mempool, Chainstate& active_chainstate)
 {
     return {};
diff --git a/src/validation.h b/src/validation.h
index f00fb7d957..d62778bd98 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -47,6 +47,30 @@
 #include <utility>
 #include <vector>
 
+#include <consensus/consensus.h>
+
+/////////////////////////////////////////// qtum
+#include <qtum/qtumstate.h>
+#include <qtum/qtumDGP.h>
+#include <libethereum/ChainParams.h>
+#include <libethereum/LastBlockHashesFace.h>
+#include <libethashseal/GenesisInfo.h>
+#include <script/solver.h>
+#include <qtum/storageresults.h>
+
+
+extern std::unique_ptr<QtumState> globalState;
+extern std::shared_ptr<dev::eth::SealEngineFace> globalSealEngine;
+extern std::unique_ptr<StorageResults> pstorageresult;
+extern bool fRecordLogOpcodes;
+extern bool fIsVMlogFile;
+extern bool fGettingValuesDGP;
+
+struct EthTransactionParams;
+using valtype = std::vector<unsigned char>;
+using ExtractQtumTX = std::pair<std::vector<QtumTransaction>, std::vector<EthTransactionParams>>;
+///////////////////////////////////////////
+
 class Chainstate;
 class CTxMemPool;
 class ChainstateManager;
@@ -362,6 +386,16 @@ static_assert(std::is_nothrow_destructible_v<CScriptCheck>);
 /** Initializes the script-execution cache */
 [[nodiscard]] bool InitScriptExecutionCache(size_t max_size_bytes);
 
+///////////////////////////////////////////////////////////////// // qtum
+bool GetAddressIndex(uint256 addressHash, int type,
+                     std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex, node::BlockManager& blockman,
+                     int start = 0, int end = 0);
+
+bool GetAddressUnspent(uint256 addressHash, int type,
+                       std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs, node::BlockManager& blockman);
+
+bool GetTimestampIndex(const unsigned int &high, const unsigned int &low, const bool fActiveOnly, std::vector<std::pair<uint256, unsigned int> > &hashes, ChainstateManager& chainman);
+
 std::map<COutPoint, uint32_t> GetImmatureStakes(ChainstateManager& chainman);
 /////////////////////////////////////////////////////////////////
 
@@ -413,6 +447,8 @@ class CVerifyDB
         int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 };
 
+std::vector<ResultExecute> CallContract(const dev::Address& addrContract, std::vector<unsigned char> opcode, Chainstate& chainstate, const dev::Address& sender = dev::Address(), uint64_t gasLimit=0, CAmount nAmount=0);
+
 enum DisconnectResult
 {
     DISCONNECT_OK,      // All good.