kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

WIP: Keva mempool test.

cn
Jianping Wu 6 years ago
parent
37ea895cde
commit
ceefe25a87
3 changed files with 159 additions and 202 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      src/keva/main.cpp
  2. 138
      src/test/keva_tests.cpp
  3. 2
      src/txmempool.h

7
src/keva/main.cpp
Unescape View File

@ -54,7 +54,7 @@ CKevaMemPool::addUnchecked (const uint256& hash, const CTxMemPoolEntry& entry) @@ -54,7 +54,7 @@ CKevaMemPool::addUnchecked (const uint256& hash, const CTxMemPoolEntry& entry)
listUnconfirmedNamespaces.push_back(std::make_tuple(hash, nameSpace, entry.getDisplayName()));
}
if (entry.isNamespaceKeyUpdate ()) {
if (entry.isKeyUpdate()) {
const valtype& nameSpace = entry.getNamespace();
listUnconfirmedKeyValues.push_back(std::make_tuple(hash, nameSpace, entry.getKey(), entry.getValue()));
}
@ -113,7 +113,7 @@ void CKevaMemPool::remove(const CTxMemPoolEntry& entry) @@ -113,7 +113,7 @@ void CKevaMemPool::remove(const CTxMemPoolEntry& entry)
}
}
if (entry.isNamespaceKeyUpdate()) {
if (entry.isKeyUpdate()) {
auto hash = entry.GetTx().GetHash();
for (auto iter = listUnconfirmedKeyValues.begin(); iter != listUnconfirmedKeyValues.end(); ++iter) {
if (std::get<0>(*iter) == hash) {
@ -152,6 +152,9 @@ CKevaMemPool::removeConflicts(const CTransaction& tx) @@ -152,6 +152,9 @@ CKevaMemPool::removeConflicts(const CTransaction& tx)
bool CKevaMemPool::validateNamespace(const CTransaction& tx, const valtype& nameSpace) const
{
if (tx.vin.size() == 0) {
return false;
}
valtype kevaNamespace = ToByteVector(Hash160(ToByteVector(tx.vin[0].prevout.hash)));
const std::vector<unsigned char>& ns_prefix = Params().Base58Prefix(CChainParams::KEVA_NAMESPACE);
kevaNamespace.insert(kevaNamespace.begin(), ns_prefix.begin(), ns_prefix.end());

138
src/test/keva_tests.cpp
Unescape View File

@ -63,7 +63,6 @@ BOOST_AUTO_TEST_CASE(keva_scripts) @@ -63,7 +63,6 @@ BOOST_AUTO_TEST_CASE(keva_scripts)
BOOST_CHECK(opNew.getKevaOp() == OP_KEVA_NAMESPACE);
BOOST_CHECK(opNew.getOpNamespace() == nameSpace);
//SelectParams(CBaseChainParams::MAIN);
const uint256 txId = uint256S("0x78f49add562dc33e4cd61aa45c54012509ed4a53308908dd07f5634437939273");
valtype actualNamespace;
script = CKevaScript::replaceKevaNamespace(script, txId, actualNamespace, Params());
@ -701,7 +700,7 @@ BOOST_AUTO_TEST_CASE (name_tx_verification) @@ -701,7 +700,7 @@ BOOST_AUTO_TEST_CASE (name_tx_verification)
/* ************************************************************************** */
BOOST_AUTO_TEST_CASE(name_updates_undo)
BOOST_AUTO_TEST_CASE(keva_updates_undo)
{
/* Enable name history to test this on the go. */
fNameHistory = true;
@ -777,148 +776,104 @@ BOOST_AUTO_TEST_CASE(name_updates_undo) @@ -777,148 +776,104 @@ BOOST_AUTO_TEST_CASE(name_updates_undo)
BOOST_CHECK(undo.vkevaundo.empty());
}
/* ************************************************************************** */
#if 0
/* ************************************************************************** */
BOOST_AUTO_TEST_CASE (name_mempool)
BOOST_AUTO_TEST_CASE(keva_mempool)
{
LOCK(mempool.cs);
mempool.clear();
const valtype nameReg = ValtypeFromString ("name-reg");
const valtype nameUpd = ValtypeFromString ("name-upd");
const valtype value = ValtypeFromString ("value");
const valtype nameSpace1 = ValtypeFromString ("namespace-dummy-1");
const valtype nameSpace2 = ValtypeFromString ("namespace-dummy-2");
const valtype displayName = ValtypeFromString ("display name");
const valtype keyA = ValtypeFromString ("key-a");
const valtype keyB = ValtypeFromString ("key-b");
const valtype valueA = ValtypeFromString ("value-a");
const valtype valueB = ValtypeFromString ("value-b");
const CScript addr = getTestAddress();
const valtype rand1(20, 'a');
const valtype rand2(20, 'b');
const uint160 hash1 = Hash160 (rand1);
const uint160 hash2 = Hash160 (rand2);
const valtype vchHash1(hash1.begin (), hash1.end ());
const valtype vchHash2(hash2.begin (), hash2.end ());
const CScript addr2 = (CScript (addr) << OP_RETURN);
const CScript new1
= CNameScript::buildNameNew (addr, hash1);
const CScript new1p
= CNameScript::buildNameNew (addr2, hash1);
const CScript new2
= CNameScript::buildNameNew (addr, hash2);
const CScript first1
= CNameScript::buildNameFirstupdate (addr, nameReg, value, rand1);
const CScript first2
= CNameScript::buildNameFirstupdate (addr, nameReg, value, rand2);
const CScript upd1 = CNameScript::buildNameUpdate (addr, nameUpd, valueA);
const CScript upd2 = CNameScript::buildNameUpdate (addr, nameUpd, valueB);
const CScript new1 = CKevaScript::buildKevaNamespace(addr, nameSpace1, displayName);
const CScript new2 = CKevaScript::buildKevaNamespace(addr, nameSpace2, displayName);
const CScript upd1 = CKevaScript::buildKevaPut(addr, nameSpace1, keyA, valueA);
const CScript upd2 = CKevaScript::buildKevaPut(addr, nameSpace2, keyB, valueB);
/* The constructed tx needs not be valid. We only test
the mempool acceptance and not validation. */
CMutableTransaction txNew1;
txNew1.SetNamecoin ();
txNew1.SetKevacoin();
txNew1.vout.push_back(CTxOut(COIN, new1));
CMutableTransaction txNew1p;
txNew1p.SetNamecoin ();
txNew1p.vout.push_back (CTxOut (COIN, new1p));
CMutableTransaction txNew2;
txNew2.SetNamecoin ();
txNew2.SetKevacoin();
txNew2.vout.push_back(CTxOut(COIN, new2));
CMutableTransaction txReg1;
txReg1.SetNamecoin ();
txReg1.vout.push_back (CTxOut (COIN, first1));
CMutableTransaction txReg2;
txReg2.SetNamecoin ();
txReg2.vout.push_back (CTxOut (COIN, first2));
CMutableTransaction txUpd1;
txUpd1.SetNamecoin ();
txUpd1.SetKevacoin();
txUpd1.vout.push_back(CTxOut(COIN, upd1));
CMutableTransaction txUpd2;
txUpd2.SetNamecoin ();
txUpd2.SetKevacoin();
txUpd2.vout.push_back(CTxOut(COIN, upd2));
/* Build an invalid transaction. It should not crash (assert fail)
the mempool check. */
CMutableTransaction txInvalid;
txInvalid.SetNamecoin ();
mempool.checkNameOps (txInvalid);
txInvalid.SetKevacoin();
mempool.checkKevaOps(txInvalid);
txInvalid.vout.push_back(CTxOut (COIN, new1));
txInvalid.vout.push_back(CTxOut (COIN, new2));
txInvalid.vout.push_back (CTxOut (COIN, first1));
txInvalid.vout.push_back (CTxOut (COIN, first2));
txInvalid.vout.push_back(CTxOut (COIN, upd1));
txInvalid.vout.push_back(CTxOut (COIN, upd2));
mempool.checkNameOps (txInvalid);
mempool.checkKevaOps(txInvalid);
/* For an empty mempool, all tx should be fine. */
BOOST_CHECK (!mempool.registersName (nameReg));
BOOST_CHECK (!mempool.updatesName (nameUpd));
BOOST_CHECK (mempool.checkNameOps (txNew1) && mempool.checkNameOps (txNew1p)
&& mempool.checkNameOps (txNew2));
BOOST_CHECK (mempool.checkNameOps (txReg1) && mempool.checkNameOps (txReg2));
BOOST_CHECK (mempool.checkNameOps (txUpd1) && mempool.checkNameOps (txUpd2));
/* Add name_new's with "stealing" check. */
const LockPoints lp;
const CTxMemPoolEntry entryNew1(MakeTransactionRef(txNew1), 0, 0, 100,
false, 1, lp);
const CTxMemPoolEntry entryNew2(MakeTransactionRef(txNew2), 0, 0, 100,
false, 1, lp);
BOOST_CHECK (entryNew1.isNameNew () && entryNew2.isNameNew ());
BOOST_CHECK (entryNew1.getNameNewHash () == vchHash1
&& entryNew2.getNameNewHash () == vchHash2);
mempool.addUnchecked (entryNew1.GetTx ().GetHash (), entryNew1);
mempool.addUnchecked (entryNew2.GetTx ().GetHash (), entryNew2);
BOOST_CHECK (!mempool.checkNameOps (txNew1p));
BOOST_CHECK (mempool.checkNameOps (txNew1) && mempool.checkNameOps (txNew2));
std::vector<std::tuple<valtype, valtype, uint256>> unconfirmedNamespace;
mempool.getUnconfirmedNamespaceList(unconfirmedNamespace);
BOOST_CHECK(unconfirmedNamespace.size() == 0);
/* Add a name registration. */
const CTxMemPoolEntry entryReg(MakeTransactionRef(txReg1), 0, 0, 100,
const LockPoints lp;
const CTxMemPoolEntry entryReg(MakeTransactionRef(txNew1), 0, 0, 100,
false, 1, lp);
BOOST_CHECK (entryReg.isNameRegistration () && !entryReg.isNameUpdate ());
BOOST_CHECK (entryReg.getName () == nameReg);
BOOST_CHECK(entryReg.isNamespaceRegistration() && !entryReg.isKeyUpdate());
BOOST_CHECK(entryReg.getNamespace() == nameSpace1);
mempool.addUnchecked(entryReg.GetTx().GetHash(), entryReg);
BOOST_CHECK (mempool.registersName (nameReg));
BOOST_CHECK (!mempool.updatesName (nameReg));
BOOST_CHECK (!mempool.checkNameOps (txReg2) && mempool.checkNameOps (txUpd1));
mempool.getUnconfirmedNamespaceList(unconfirmedNamespace);
BOOST_CHECK(unconfirmedNamespace.size() == 1);
BOOST_CHECK(std::get<0>(unconfirmedNamespace[0]) == nameSpace1);
/* Add a name update. */
const CTxMemPoolEntry entryUpd(MakeTransactionRef(txUpd1), 0, 0, 100,
false, 1, lp);
BOOST_CHECK (!entryUpd.isNameRegistration () && entryUpd.isNameUpdate ());
BOOST_CHECK (entryUpd.getName () == nameUpd);
BOOST_CHECK(!entryUpd.isNamespaceRegistration() && entryUpd.isKeyUpdate());
BOOST_CHECK(entryUpd.getNamespace() == nameSpace1);
mempool.addUnchecked (entryUpd.GetTx().GetHash(), entryUpd);
BOOST_CHECK (!mempool.registersName (nameUpd));
BOOST_CHECK (mempool.updatesName (nameUpd));
BOOST_CHECK (!mempool.checkNameOps (txUpd2));
/* Check getTxForName. */
BOOST_CHECK (mempool.getTxForName (nameReg) == txReg1.GetHash ());
BOOST_CHECK (mempool.getTxForName (nameUpd) == txUpd1.GetHash ());
valtype valResult;
mempool.getUnconfirmedKeyValue(nameSpace1, keyA, valResult);
BOOST_CHECK(valResult == valueA);
std::vector<std::tuple<valtype, valtype, valtype, uint256>> keyValueList;
mempool.getUnconfirmedKeyValueList(keyValueList, nameSpace1);
BOOST_CHECK(keyValueList.size() == 1);
/* Run mempool sanity check. */
#if 0
CCoinsViewCache view(pcoinsTip.get());
const CNameScript nameOp(upd1);
CNameData data;
const CKevaScript nameOp(upd1);
CKevaData data;
data.fromScript(100, COutPoint (uint256(), 0), nameOp);
view.SetName(nameUpd, data, false);
mempool.checkNames(&view);
#endif
/* Remove the transactions again. */
mempool.removeRecursive (txReg1);
BOOST_CHECK (!mempool.registersName (nameReg));
BOOST_CHECK (mempool.checkNameOps (txReg1) && mempool.checkNameOps (txReg2));
BOOST_CHECK (!mempool.checkNameOps (txUpd2));
mempool.removeRecursive(txNew1);
std::vector<std::tuple<valtype, valtype, uint256>> unconfirmedNS;
mempool.getUnconfirmedNamespaceList(unconfirmedNS);
BOOST_CHECK(unconfirmedNS.size() == 0);
#if 0
mempool.removeRecursive(txUpd1);
BOOST_CHECK(!mempool.updatesName (nameUpd));
BOOST_CHECK(mempool.checkNameOps (txUpd1) && mempool.checkNameOps (txUpd2));
@ -984,10 +939,9 @@ BOOST_AUTO_TEST_CASE (name_mempool) @@ -984,10 +939,9 @@ BOOST_AUTO_TEST_CASE (name_mempool)
}
BOOST_CHECK(!mempool.registersName (nameReg));
BOOST_CHECK(mempool.mapTx.empty());
#endif
}
/* ************************************************************************** */
#endif
BOOST_AUTO_TEST_SUITE_END()

2
src/txmempool.h
Unescape View File

@ -137,7 +137,7 @@ public: @@ -137,7 +137,7 @@ public:
return kevaOp.isKevaOp() && kevaOp.getKevaOp() == OP_KEVA_NAMESPACE;
}
inline bool isNamespaceKeyUpdate() const
inline bool isKeyUpdate() const
{
return kevaOp.isKevaOp() && kevaOp.getKevaOp() == OP_KEVA_PUT;
}

Write Preview
Loading…
Cancel
Save