rename all SidechainDB class according to bitcoin style guide (#10)

joemphilips · CryptAxe · commit 4eb5c1db3c0a · 2017-06-01T11:03:10.000-07:00
diff --git a/src/sidechaindb.cpp b/src/sidechaindb.cpp
@@ -14,12 +14,12 @@
 #include "utilstrencodings.h"
 #include "wallet/wallet.h"
 
-SidechainDB::SidechainDB()
+CSidechainDB::CSidechainDB()
 {
     SCDB.resize(ARRAYLEN(ValidSidechains));
 }
 
-void SidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)
+void CSidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)
 {
     std::vector<SidechainDeposit> vDeposit;
     for (const CTransaction& tx : vtx) {
@@ -65,7 +65,7 @@ void SidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)
     }
 }
 
-bool SidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)
+bool CSidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)
 {
     if (vWTJoinCache.size() >= SIDECHAIN_MAX_WT)
         return false;
@@ -82,7 +82,7 @@ bool SidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)
     return false;
 }
 
-bool SidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const
+bool CSidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const
 {
     for (const SidechainDeposit& d : vDepositCache) {
         if (d == deposit)
@@ -91,7 +91,7 @@ bool SidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const
     return false;
 }
 
-bool SidechainDB::HaveWTJoinCached(const uint256& wtxid) const
+bool CSidechainDB::HaveWTJoinCached(const uint256& wtxid) const
 {
     for (const CTransaction& tx : vWTJoinCache) {
         if (tx.GetHash() == wtxid)
@@ -100,7 +100,7 @@ bool SidechainDB::HaveWTJoinCached(const uint256& wtxid) const
     return false;
 }
 
-std::vector<SidechainDeposit> SidechainDB::GetDeposits(uint8_t nSidechain) const
+std::vector<SidechainDeposit> CSidechainDB::GetDeposits(uint8_t nSidechain) const
 {
     std::vector<SidechainDeposit> vSidechainDeposit;
     for (size_t i = 0; i < vDepositCache.size(); i++) {
@@ -110,7 +110,7 @@ std::vector<SidechainDeposit> SidechainDB::GetDeposits(uint8_t nSidechain) const
     return vSidechainDeposit;
 }
 
-CTransaction SidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const
+CTransaction CSidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const
 {
     if (!HasState())
         return CTransaction();
@@ -217,7 +217,7 @@ CTransaction SidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const
     return mtx;
 }
 
-CScript SidechainDB::CreateStateScript(int nHeight) const
+CScript CSidechainDB::CreateStateScript(int nHeight) const
 {
     if (!HasState())
         return CScript();
@@ -273,7 +273,7 @@ CScript SidechainDB::CreateStateScript(int nHeight) const
     return script;
 }
 
-uint256 SidechainDB::GetSCDBHash() const
+uint256 CSidechainDB::GetSCDBHash() const
 {
     CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
     for (const SCDBIndex& index : SCDB) {
@@ -287,7 +287,7 @@ uint256 SidechainDB::GetSCDBHash() const
     return ss.GetHash();
 }
 
-bool SidechainDB::ReadStateScript(const CTransactionRef& coinbase)
+bool CSidechainDB::ReadStateScript(const CTransactionRef& coinbase)
 {
     /*
      * Only one state script of the current version is valid.
@@ -336,12 +336,12 @@ bool SidechainDB::ReadStateScript(const CTransactionRef& coinbase)
 
     // Invalid or no update script try to apply default
     if (!ApplyDefaultUpdate())
-        LogPrintf("SidechainDB::ReadStateScript: Invalid update & failed to apply default update!\n");
+        LogPrintf("CSidechainDB::ReadStateScript: Invalid update & failed to apply default update!\n");
 
     return false;
 }
 
-bool SidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore, uint256 wtxid, bool fJustCheck)
+bool CSidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore, uint256 wtxid, bool fJustCheck)
 {
     if (!SidechainNumberValid(nSidechain))
         return false;
@@ -362,7 +362,7 @@ bool SidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore,
     return (index.InsertMember(member));
 }
 
-bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransactionRef& coinbase)
+bool CSidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransactionRef& coinbase)
 {
     if (!coinbase || !coinbase->IsCoinBase())
         return false;
@@ -376,7 +376,7 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti
 
     // Apply state script
     if (!ReadStateScript(coinbase))
-        LogPrintf("SidechainDB::Update: failed to read state script\n");
+        LogPrintf("CSidechainDB::Update: failed to read state script\n");
 
     // Scan for h*(s) in coinbase outputs
     for (const CTxOut& out : coinbase->vout) {
@@ -426,7 +426,7 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti
         }
 
         if (!fValid) {
-            LogPrintf("SidechainDB::Update: h* with invalid block height ignored: %s\n", hashCritical.ToString());
+            LogPrintf("CSidechainDB::Update: h* with invalid block height ignored: %s\n", hashCritical.ToString());
             continue;
         }
 
@@ -449,17 +449,17 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti
     return true;
 }
 
-uint256 SidechainDB::GetHashBlockLastSeen()
+uint256 CSidechainDB::GetHashBlockLastSeen()
 {
     return hashBlockLastSeen;
 }
 
-std::multimap<uint256, int> SidechainDB::GetLinkingData() const
+std::multimap<uint256, int> CSidechainDB::GetLinkingData() const
 {
     return mapBMMLD;
 }
 
-bool SidechainDB::HasState() const
+bool CSidechainDB::HasState() const
 {
     // Make sure that SCDB is actually initialized
     if (SCDB.size() != ARRAYLEN(ValidSidechains))
@@ -478,7 +478,7 @@ bool SidechainDB::HasState() const
     return false;
 }
 
-std::vector<SidechainWTJoinState> SidechainDB::GetState(uint8_t nSidechain) const
+std::vector<SidechainWTJoinState> CSidechainDB::GetState(uint8_t nSidechain) const
 {
     if (!HasState() || !SidechainNumberValid(nSidechain))
         return std::vector<SidechainWTJoinState>();
@@ -491,7 +491,7 @@ std::vector<SidechainWTJoinState> SidechainDB::GetState(uint8_t nSidechain) cons
     return vState;
 }
 
-bool SidechainDB::ApplyStateScript(const CScript& script, const std::vector<std::vector<SidechainWTJoinState>>& vState, bool fJustCheck)
+bool CSidechainDB::ApplyStateScript(const CScript& script, const std::vector<std::vector<SidechainWTJoinState>>& vState, bool fJustCheck)
 {
     if (script.size() < 4)
         return false;
@@ -547,7 +547,7 @@ bool SidechainDB::ApplyStateScript(const CScript& script, const std::vector<std:
     return true;
 }
 
-bool SidechainDB::ApplyDefaultUpdate()
+bool CSidechainDB::ApplyDefaultUpdate()
 {
     if (!HasState())
         return true;
@@ -572,7 +572,7 @@ bool SidechainDB::ApplyDefaultUpdate()
     return true;
 }
 
-bool SidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid) const
+bool CSidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid) const
 {
     if (!SidechainNumberValid(nSidechain))
         return false;
@@ -589,10 +589,10 @@ bool SidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid
     return false;
 }
 
-std::string SidechainDB::ToString() const
+std::string CSidechainDB::ToString() const
 {
     std::string str;
-    str += "SidechainDB:\n";
+    str += "CSidechainDB:\n";
     for (const Sidechain& s : ValidSidechains) {
         // Print sidechain name
         str += "Sidechain: " + s.GetSidechainName() + "\n";
diff --git a/src/sidechaindb.h b/src/sidechaindb.h
@@ -19,10 +19,10 @@ struct SidechainDeposit;
 struct SidechainWTJoinState;
 struct SCDBIndex;
 
-class SidechainDB
+class CSidechainDB
 {
 public:
-    SidechainDB();
+    CSidechainDB();
 
     /** Add deposit to cache */
     void AddDeposits(const std::vector<CTransaction>& vtx);
diff --git a/src/test/sidechaindb_tests.cpp b/src/test/sidechaindb_tests.cpp
@@ -29,8 +29,8 @@ BOOST_FIXTURE_TEST_SUITE(sidechaindb_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(sidechaindb_isolated)
 {
-    // Test SidechainDB without blocks
-    SidechainDB scdb;
+    // Test CSidechainDB without blocks
+    CSidechainDB scdb;
 
     uint256 hashWTTest = GetRandHash();
     uint256 hashWTHivemind = GetRandHash();
@@ -52,7 +52,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_MultipleTauPeriods)
 {
     // Test SCDB with multiple tau periods,
     // approve multiple WT^s on the same sidechain.
-    SidechainDB scdb;
+    CSidechainDB scdb;
     const Sidechain& test = ValidSidechains[SIDECHAIN_TEST];
 
     // WT^ hash for first period
@@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_EmptyStateScript)
     // Test empty SCDB
     const Sidechain& sidechainTest = ValidSidechains[SIDECHAIN_TEST];
     CScript scriptEmptyExpected = CScript();
-    SidechainDB scdbEmpty;
+    CSidechainDB scdbEmpty;
     BOOST_CHECK(scriptEmptyExpected == scdbEmpty.CreateStateScript(sidechainTest.GetTau() - 1));
 }
 
@@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_PopulatedStateScript)
                     << SCOP_VERIFY << SCOP_SC_DELIM
                     << SCOP_VERIFY;
 
-    SidechainDB scdbPopulated;
+    CSidechainDB scdbPopulated;
 
     uint256 hashWTTest = GetRandHash();
     uint256 hashWTHivemind = GetRandHash();
@@ -138,7 +138,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_FullStateScript)
                << SCOP_SC_DELIM
                << SCOP_VERIFY << SCOP_WT_DELIM << SCOP_REJECT << SCOP_WT_DELIM << SCOP_REJECT;
 
-    SidechainDB scdbFull;
+    CSidechainDB scdbFull;
 
     uint256 hashWTTest1 = GetRandHash();
     uint256 hashWTTest2 = GetRandHash();
@@ -178,7 +178,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_CountStateScript)
                           << SCOP_REJECT << SCOP_WT_DELIM << SCOP_VERIFY
                           << SCOP_SC_DELIM
                           << SCOP_REJECT << SCOP_WT_DELIM << SCOP_VERIFY << SCOP_WT_DELIM << SCOP_REJECT;
-    SidechainDB scdbCount;
+    CSidechainDB scdbCount;
 
     uint256 hashWTTest = GetRandHash();
 
@@ -203,7 +203,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_CountStateScript)
 
 BOOST_AUTO_TEST_CASE(sidechaindb_PositionStateScript)
 {
-    // Verify that state scripts created based on known SidechainDB
+    // Verify that state scripts created based on known CSidechainDB
     // state examples are formatted as expected
     const Sidechain& sidechainTest = ValidSidechains[SIDECHAIN_TEST];
 
@@ -216,7 +216,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_PositionStateScript)
                              << SCOP_SC_DELIM
                              << SCOP_REJECT << SCOP_WT_DELIM << SCOP_REJECT << SCOP_WT_DELIM << SCOP_VERIFY;
 
-    SidechainDB scdbPosition;
+    CSidechainDB scdbPosition;
 
     uint256 hashWTTest1 = GetRandHash();
     uint256 hashWTTest2 = GetRandHash();
@@ -249,7 +249,7 @@ BOOST_AUTO_TEST_CASE(sidechaindb_PositionStateScript)
 BOOST_AUTO_TEST_CASE(bmm_checkCriticalHashValid)
 {
     // Check that valid critical hash is added to ratchet
-    SidechainDB scdb;
+    CSidechainDB scdb;
 
     // Create h* bribe script
     uint256 hashCritical = GetRandHash();
@@ -281,7 +281,7 @@ BOOST_AUTO_TEST_CASE(bmm_checkCriticalHashInvalid)
 {
     // Make sure that a invalid h* with a valid block number will
     // be rejected.
-    SidechainDB scdb;
+    CSidechainDB scdb;
 
     // Create h* bribe script
     CScript scriptPubKey;
@@ -308,7 +308,7 @@ BOOST_AUTO_TEST_CASE(bmm_checkBlockNumberValid)
 {
     // Make sure that a valid h* with a valid block number
     // will be accepted.
-    SidechainDB scdb;
+    CSidechainDB scdb;
 
     // We have to add the first h* to the ratchet so that
     // there is something to compare with.
@@ -353,7 +353,7 @@ BOOST_AUTO_TEST_CASE(bmm_checkBlockNumberInvalid)
 {
     // Try to add a valid h* with an invalid block number
     // and make sure it is skipped.
-    SidechainDB scdb;
+    CSidechainDB scdb;
 
     // We have to add the first h* to the ratchet so that
     // there is something to compare with.
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -88,7 +88,7 @@ CAmount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
 CBlockPolicyEstimator feeEstimator;
 CTxMemPool mempool(&feeEstimator);
 
-SidechainDB scdb;
+CSidechainDB scdb;
 
 static void CheckBlockIndex(const Consensus::Params& consensusParams);
 
diff --git a/src/validation.h b/src/validation.h
@@ -43,7 +43,7 @@ class CBlockPolicyEstimator;
 class CTxMemPool;
 class CValidationInterface;
 class CValidationState;
-class SidechainDB;
+class CSidechainDB;
 struct ChainTxData;
 
 struct PrecomputedTransactionData;
@@ -528,7 +528,7 @@ void DumpMempool();
 bool LoadMempool();
 
 /** Tracks validation status of sidechain WT^(s) */
-extern SidechainDB scdb;
+extern CSidechainDB scdb;
 
 /** Remove extra coinbase(s) from chainActive */
 void PruneCoinbaseCache();

Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@`
`14`	`14`	`#include "utilstrencodings.h"`
`15`	`15`	`#include "wallet/wallet.h"`
`16`	`16`
`17`		`-SidechainDB::SidechainDB()`
	`17`	`+CSidechainDB::CSidechainDB()`
`18`	`18`	`{`
`19`	`19`	`SCDB.resize(ARRAYLEN(ValidSidechains));`
`20`	`20`	`}`
`21`	`21`
`22`		`-void SidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)`
	`22`	`+void CSidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)`
`23`	`23`	`{`
`24`	`24`	`std::vector<SidechainDeposit> vDeposit;`
`25`	`25`	`for (const CTransaction& tx : vtx) {`
`@@ -65,7 +65,7 @@ void SidechainDB::AddDeposits(const std::vector<CTransaction>& vtx)`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`-bool SidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)`
	`68`	`+bool CSidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)`
`69`	`69`	`{`
`70`	`70`	`if (vWTJoinCache.size() >= SIDECHAIN_MAX_WT)`
`71`	`71`	`return false;`
`@@ -82,7 +82,7 @@ bool SidechainDB::AddWTJoin(uint8_t nSidechain, const CTransaction& tx)`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`
`85`		`-bool SidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const`
	`85`	`+bool CSidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const`
`86`	`86`	`{`
`87`	`87`	`for (const SidechainDeposit& d : vDepositCache) {`
`88`	`88`	`if (d == deposit)`
`@@ -91,7 +91,7 @@ bool SidechainDB::HaveDepositCached(const SidechainDeposit &deposit) const`
`91`	`91`	`return false;`
`92`	`92`	`}`
`93`	`93`
`94`		`-bool SidechainDB::HaveWTJoinCached(const uint256& wtxid) const`
	`94`	`+bool CSidechainDB::HaveWTJoinCached(const uint256& wtxid) const`
`95`	`95`	`{`
`96`	`96`	`for (const CTransaction& tx : vWTJoinCache) {`
`97`	`97`	`if (tx.GetHash() == wtxid)`
`@@ -100,7 +100,7 @@ bool SidechainDB::HaveWTJoinCached(const uint256& wtxid) const`
`100`	`100`	`return false;`
`101`	`101`	`}`
`102`	`102`
`103`		`-std::vector<SidechainDeposit> SidechainDB::GetDeposits(uint8_t nSidechain) const`
	`103`	`+std::vector<SidechainDeposit> CSidechainDB::GetDeposits(uint8_t nSidechain) const`
`104`	`104`	`{`
`105`	`105`	`std::vector<SidechainDeposit> vSidechainDeposit;`
`106`	`106`	`for (size_t i = 0; i < vDepositCache.size(); i++) {`
`@@ -110,7 +110,7 @@ std::vector<SidechainDeposit> SidechainDB::GetDeposits(uint8_t nSidechain) const`
`110`	`110`	`return vSidechainDeposit;`
`111`	`111`	`}`
`112`	`112`
`113`		`-CTransaction SidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const`
	`113`	`+CTransaction CSidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const`
`114`	`114`	`{`
`115`	`115`	`if (!HasState())`
`116`	`116`	`return CTransaction();`
`@@ -217,7 +217,7 @@ CTransaction SidechainDB::GetWTJoinTx(uint8_t nSidechain, int nHeight) const`
`217`	`217`	`return mtx;`
`218`	`218`	`}`
`219`	`219`
`220`		`-CScript SidechainDB::CreateStateScript(int nHeight) const`
	`220`	`+CScript CSidechainDB::CreateStateScript(int nHeight) const`
`221`	`221`	`{`
`222`	`222`	`if (!HasState())`
`223`	`223`	`return CScript();`
`@@ -273,7 +273,7 @@ CScript SidechainDB::CreateStateScript(int nHeight) const`
`273`	`273`	`return script;`
`274`	`274`	`}`
`275`	`275`
`276`		`-uint256 SidechainDB::GetSCDBHash() const`
	`276`	`+uint256 CSidechainDB::GetSCDBHash() const`
`277`	`277`	`{`
`278`	`278`	`CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);`
`279`	`279`	`for (const SCDBIndex& index : SCDB) {`
`@@ -287,7 +287,7 @@ uint256 SidechainDB::GetSCDBHash() const`
`287`	`287`	`return ss.GetHash();`
`288`	`288`	`}`
`289`	`289`
`290`		`-bool SidechainDB::ReadStateScript(const CTransactionRef& coinbase)`
	`290`	`+bool CSidechainDB::ReadStateScript(const CTransactionRef& coinbase)`
`291`	`291`	`{`
`292`	`292`	`/*`
`293`	`293`	`* Only one state script of the current version is valid.`
`@@ -336,12 +336,12 @@ bool SidechainDB::ReadStateScript(const CTransactionRef& coinbase)`
`336`	`336`
`337`	`337`	`// Invalid or no update script try to apply default`
`338`	`338`	`if (!ApplyDefaultUpdate())`
`339`		`- LogPrintf("SidechainDB::ReadStateScript: Invalid update & failed to apply default update!\n");`
	`339`	`+ LogPrintf("CSidechainDB::ReadStateScript: Invalid update & failed to apply default update!\n");`
`340`	`340`
`341`	`341`	`return false;`
`342`	`342`	`}`
`343`	`343`
`344`		`-bool SidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore, uint256 wtxid, bool fJustCheck)`
	`344`	`+bool CSidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore, uint256 wtxid, bool fJustCheck)`
`345`	`345`	`{`
`346`	`346`	`if (!SidechainNumberValid(nSidechain))`
`347`	`347`	`return false;`
`@@ -362,7 +362,7 @@ bool SidechainDB::Update(uint8_t nSidechain, uint16_t nBlocks, uint16_t nScore,`
`362`	`362`	`return (index.InsertMember(member));`
`363`	`363`	`}`
`364`	`364`
`365`		`-bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransactionRef& coinbase)`
	`365`	`+bool CSidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransactionRef& coinbase)`
`366`	`366`	`{`
`367`	`367`	`if (!coinbase \|\| !coinbase->IsCoinBase())`
`368`	`368`	`return false;`
`@@ -376,7 +376,7 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti`
`376`	`376`
`377`	`377`	`// Apply state script`
`378`	`378`	`if (!ReadStateScript(coinbase))`
`379`		`- LogPrintf("SidechainDB::Update: failed to read state script\n");`
	`379`	`+ LogPrintf("CSidechainDB::Update: failed to read state script\n");`
`380`	`380`
`381`	`381`	`// Scan for h*(s) in coinbase outputs`
`382`	`382`	`for (const CTxOut& out : coinbase->vout) {`
`@@ -426,7 +426,7 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti`
`426`	`426`	`}`
`427`	`427`
`428`	`428`	`if (!fValid) {`
`429`		`- LogPrintf("SidechainDB::Update: h* with invalid block height ignored: %s\n", hashCritical.ToString());`
	`429`	`+ LogPrintf("CSidechainDB::Update: h* with invalid block height ignored: %s\n", hashCritical.ToString());`
`430`	`430`	`continue;`
`431`	`431`	`}`
`432`	`432`
`@@ -449,17 +449,17 @@ bool SidechainDB::Update(int nHeight, const uint256& hashBlock, const CTransacti`
`449`	`449`	`return true;`
`450`	`450`	`}`
`451`	`451`
`452`		`-uint256 SidechainDB::GetHashBlockLastSeen()`
	`452`	`+uint256 CSidechainDB::GetHashBlockLastSeen()`
`453`	`453`	`{`
`454`	`454`	`return hashBlockLastSeen;`
`455`	`455`	`}`
`456`	`456`
`457`		`-std::multimap<uint256, int> SidechainDB::GetLinkingData() const`
	`457`	`+std::multimap<uint256, int> CSidechainDB::GetLinkingData() const`
`458`	`458`	`{`
`459`	`459`	`return mapBMMLD;`
`460`	`460`	`}`
`461`	`461`
`462`		`-bool SidechainDB::HasState() const`
	`462`	`+bool CSidechainDB::HasState() const`
`463`	`463`	`{`
`464`	`464`	`// Make sure that SCDB is actually initialized`
`465`	`465`	`if (SCDB.size() != ARRAYLEN(ValidSidechains))`
`@@ -478,7 +478,7 @@ bool SidechainDB::HasState() const`
`478`	`478`	`return false;`
`479`	`479`	`}`
`480`	`480`
`481`		`-std::vector<SidechainWTJoinState> SidechainDB::GetState(uint8_t nSidechain) const`
	`481`	`+std::vector<SidechainWTJoinState> CSidechainDB::GetState(uint8_t nSidechain) const`
`482`	`482`	`{`
`483`	`483`	`if (!HasState() \|\| !SidechainNumberValid(nSidechain))`
`484`	`484`	`return std::vector<SidechainWTJoinState>();`
`@@ -491,7 +491,7 @@ std::vector<SidechainWTJoinState> SidechainDB::GetState(uint8_t nSidechain) cons`
`491`	`491`	`return vState;`
`492`	`492`	`}`
`493`	`493`
`494`		`-bool SidechainDB::ApplyStateScript(const CScript& script, const std::vector<std::vector<SidechainWTJoinState>>& vState, bool fJustCheck)`
	`494`	`+bool CSidechainDB::ApplyStateScript(const CScript& script, const std::vector<std::vector<SidechainWTJoinState>>& vState, bool fJustCheck)`
`495`	`495`	`{`
`496`	`496`	`if (script.size() < 4)`
`497`	`497`	`return false;`
`@@ -547,7 +547,7 @@ bool SidechainDB::ApplyStateScript(const CScript& script, const std::vector<std:`
`547`	`547`	`return true;`
`548`	`548`	`}`
`549`	`549`
`550`		`-bool SidechainDB::ApplyDefaultUpdate()`
	`550`	`+bool CSidechainDB::ApplyDefaultUpdate()`
`551`	`551`	`{`
`552`	`552`	`if (!HasState())`
`553`	`553`	`return true;`
`@@ -572,7 +572,7 @@ bool SidechainDB::ApplyDefaultUpdate()`
`572`	`572`	`return true;`
`573`	`573`	`}`
`574`	`574`
`575`		`-bool SidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid) const`
	`575`	`+bool CSidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid) const`
`576`	`576`	`{`
`577`	`577`	`if (!SidechainNumberValid(nSidechain))`
`578`	`578`	`return false;`
`@@ -589,10 +589,10 @@ bool SidechainDB::CheckWorkScore(const uint8_t& nSidechain, const uint256& wtxid`
`589`	`589`	`return false;`
`590`	`590`	`}`
`591`	`591`
`592`		`-std::string SidechainDB::ToString() const`
	`592`	`+std::string CSidechainDB::ToString() const`
`593`	`593`	`{`
`594`	`594`	`std::string str;`
`595`		`- str += "SidechainDB:\n";`
	`595`	`+ str += "CSidechainDB:\n";`
`596`	`596`	`for (const Sidechain& s : ValidSidechains) {`
`597`	`597`	`// Print sidechain name`
`598`	`598`	`str += "Sidechain: " + s.GetSidechainName() + "\n";`