void
CNameMemPool::removeConflicts (const CTransaction& tx,
std::list<CTransaction>& removed)
{
AssertLockHeld (pool.cs);
if (!tx.IsNamecoin ())
return;
BOOST_FOREACH (const CTxOut& txout, tx.vout)
{
const CNameScript nameOp(txout.scriptPubKey);
if (nameOp.isNameOp () && nameOp.getNameOp () == OP_NAME_FIRSTUPDATE)
{
const valtype& name = nameOp.getOpName ();
const NameTxMap::const_iterator mit = mapNameRegs.find (name);
if (mit != mapNameRegs.end ())
{
const CTxMemPool::txiter mit2 = pool.mapTx.find (mit->second);
assert (mit2 != pool.mapTx.end ());
pool.removeRecursive (mit2->GetTx (), removed);
}
}
}
}
void
CNameData::fromScript (unsigned h, const COutPoint& out,
const CNameScript& script)
{
assert (script.isAnyUpdate ());
value = script.getOpValue ();
nHeight = h;
prevout = out;
addr = script.getAddress ();
}
bool CScript::IsPayToWitnessScriptHash(bool allowNames) const
{
// Extra-fast test for pay-to-witness-script-hash CScripts:
if (!allowNames)
return (this->size() == 34 &&
(*this)[0] == OP_0 &&
(*this)[1] == 0x20);
// Strip off a name prefix if present.
const CNameScript nameOp(*this);
return nameOp.getAddress().IsPayToWitnessScriptHash(false);
}
bool CScript::IsPayToScriptHash(bool allowNames) const
{
// Extra-fast test for pay-to-script-hash CScripts:
if (!allowNames)
return (this->size() == 23 &&
(*this)[0] == OP_HASH160 &&
(*this)[1] == 0x14 &&
(*this)[22] == OP_EQUAL);
// Strip off a name prefix if present.
const CNameScript nameOp(*this);
return nameOp.getAddress().IsPayToScriptHash(false);
}
CTxMemPoolEntry::CTxMemPoolEntry(const CTransaction& _tx, const CAmount& _nFee,
int64_t _nTime, double _dPriority,
unsigned int _nHeight):
tx(_tx), nFee(_nFee), nTime(_nTime), dPriority(_dPriority), nHeight(_nHeight),
nameOp()
{
nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
nModSize = tx.CalculateModifiedSize(nTxSize);
if (tx.IsNamecoin())
{
BOOST_FOREACH(const CTxOut& txout, tx.vout)
{
const CNameScript curNameOp(txout.scriptPubKey);
if (!curNameOp.isNameOp())
continue;
assert(!nameOp.isNameOp());
nameOp = curNameOp;
}
assert(nameOp.isNameOp());
}
bool
BlockAssembler::TxAllowedForNamecoin (const CTransaction& tx) const
{
if (!tx.IsNamecoin ())
return true;
bool nameOutFound = false;
CNameScript nameOpOut;
for (const auto& txOut : tx.vout)
{
const CNameScript op(txOut.scriptPubKey);
if (op.isNameOp ())
{
nameOutFound = true;
nameOpOut = op;
break;
}
}
if (nameOutFound && nameOpOut.getNameOp () == OP_NAME_FIRSTUPDATE)
{
bool nameNewFound = false;
for (const auto& txIn : tx.vin)
{
Coin coin;
if (!pcoinsTip->GetCoin (txIn.prevout, coin))
continue;
const CNameScript op(coin.out.scriptPubKey);
if (op.isNameOp () && op.getNameOp () == OP_NAME_NEW)
{
const int minHeight = coin.nHeight + MIN_FIRSTUPDATE_DEPTH;
if (minHeight > nHeight)
return false;
nameNewFound = true;
}
}
/* If the name_new is not only immature but actually unconfirmed, then
the GetCoin lookup above fails for it and we never reach the height
check. In this case, nameNewFound is false and we should not yet
include the transaction in a mined block. */
if (!nameNewFound)
return false;
}
return true;
}
UniValue
name_pending (const UniValue& params, bool fHelp)
{
if (fHelp || params.size () > 1)
throw std::runtime_error (
"name_pending (\"name\")\n"
"\nList unconfirmed name operations in the mempool.\n"
"\nIf a name is given, only check for operations on this name.\n"
"\nArguments:\n"
"1. \"name\" (string, optional) only look for this name\n"
"\nResult:\n"
"[\n"
" {\n"
" \"op\": xxxx (string) the operation being performed\n"
" \"name\": xxxx (string) the name operated on\n"
" \"value\": xxxx (string) the name's new value\n"
" \"txid\": xxxx (string) the txid corresponding to the operation\n"
" \"ismine\": xxxx (boolean) whether the name is owned by the wallet\n"
" },\n"
" ...\n"
"]\n"
+ HelpExampleCli ("name_pending", "")
+ HelpExampleCli ("name_pending", "\"d/domob\"")
+ HelpExampleRpc ("name_pending", "")
);
#ifdef ENABLE_WALLET
LOCK2 (pwalletMain ? &pwalletMain->cs_wallet : NULL, mempool.cs);
#else
LOCK (mempool.cs);
#endif
std::vector<uint256> txHashes;
if (params.size () == 0)
mempool.queryHashes (txHashes);
else
{
const std::string name = params[0].get_str ();
const valtype vchName = ValtypeFromString (name);
const uint256 txid = mempool.getTxForName (vchName);
if (!txid.IsNull ())
txHashes.push_back (txid);
}
UniValue arr(UniValue::VARR);
for (std::vector<uint256>::const_iterator i = txHashes.begin ();
i != txHashes.end (); ++i)
{
std::shared_ptr<const CTransaction> tx = mempool.get (*i);
if (!tx || !tx->IsNamecoin ())
continue;
for (const auto& txOut : tx->vout)
{
const CNameScript op(txOut.scriptPubKey);
if (!op.isNameOp () || !op.isAnyUpdate ())
continue;
const valtype vchName = op.getOpName ();
const valtype vchValue = op.getOpValue ();
const std::string name = ValtypeToString (vchName);
const std::string value = ValtypeToString (vchValue);
std::string strOp;
switch (op.getNameOp ())
{
case OP_NAME_FIRSTUPDATE:
strOp = "name_firstupdate";
break;
case OP_NAME_UPDATE:
strOp = "name_update";
break;
default:
assert (false);
}
UniValue obj(UniValue::VOBJ);
obj.push_back (Pair ("op", strOp));
obj.push_back (Pair ("name", name));
obj.push_back (Pair ("value", value));
obj.push_back (Pair ("txid", tx->GetHash ().GetHex ()));
#ifdef ENABLE_WALLET
isminetype mine = ISMINE_NO;
if (pwalletMain)
mine = IsMine (*pwalletMain, op.getAddress ());
const bool isMine = (mine & ISMINE_SPENDABLE);
obj.push_back (Pair ("ismine", isMine));
#endif
arr.push_back (obj);
}
}
return arr;
}
bool CCoinsViewDB::ValidateNameDB(CGameDB& gameDb) const
{
/* Skip for genesis block, since there is no game state available yet
(test would fail below). There's not really anything to verify
for the genesis block anyway. */
const uint256 blockHash = GetBestBlock();
if (blockHash.IsNull())
return true;
/* It seems that there are no "const iterators" for LevelDB. Since we
only need read operations on it, use a const-cast to get around
that restriction. */
boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&db)->NewIterator());
pcursor->SeekToFirst();
/* Loop over the total database and read interesting
things to memory. We later use that to check
everything against each other. */
std::set<valtype> namesTotal;
std::set<valtype> namesInDB;
std::set<valtype> namesWithHistory;
std::map<valtype, CAmount> namesInUTXO;
for (; pcursor->Valid(); pcursor->Next())
{
boost::this_thread::interruption_point();
char chType;
if (!pcursor->GetKey(chType))
continue;
switch (chType)
{
case DB_COINS:
{
CCoins coins;
if (!pcursor->GetValue(coins))
return error("%s : failed to read coins", __func__);
BOOST_FOREACH(const CTxOut& txout, coins.vout)
if (!txout.IsNull())
{
const CNameScript nameOp(txout.scriptPubKey);
if (nameOp.isNameOp() && nameOp.isAnyUpdate())
{
const valtype& name = nameOp.getOpName();
if (namesInUTXO.count(name) > 0)
return error("%s : name %s duplicated in UTXO set",
__func__, ValtypeToString(name).c_str());
namesInUTXO.insert(std::make_pair(nameOp.getOpName(),
txout.nValue));
}
}
break;
}
case DB_NAME:
{
std::pair<char, valtype> key;
if (!pcursor->GetKey(key) || key.first != DB_NAME)
return error("%s : failed to read DB_NAME key", __func__);
const valtype& name = key.second;
CNameData data;
if (!pcursor->GetValue(data))
return error("%s : failed to read name value", __func__);
if (namesTotal.count(name) > 0)
return error("%s : name %s duplicated in name index",
__func__, ValtypeToString(name).c_str());
namesTotal.insert(name);
assert(namesInDB.count(name) == 0);
if (!data.isDead ())
namesInDB.insert(name);
break;
}
case DB_NAME_HISTORY:
{
std::pair<char, valtype> key;
if (!pcursor->GetKey(key) || key.first != DB_NAME_HISTORY)
return error("%s : failed to read DB_NAME_HISTORY key",
__func__);
const valtype& name = key.second;
if (namesWithHistory.count(name) > 0)
return error("%s : name %s has duplicate history",
__func__, ValtypeToString(name).c_str());
namesWithHistory.insert(name);
break;
}
default:
break;
}
}
std::map<valtype, CAmount> namesInGame;
GameState state(Params().GetConsensus());
if (!gameDb.get(blockHash, state))
return error("%s : failed to read game state", __func__);
for (PlayerStateMap::const_iterator mi = state.players.begin();
mi != state.players.end(); ++mi)
{
const valtype cur = ValtypeFromString(mi->first);
if (namesInGame.count(cur) > 0)
return error("%s : name %s is duplicate in the game state",
__func__, mi->first.c_str());
namesInGame.insert(std::make_pair(cur, mi->second.lockedCoins));
}
/* Now verify the collected data. */
assert (namesTotal.size() >= namesInDB.size());
if (namesInGame != namesInUTXO)
return error("%s : game state and name DB mismatch", __func__);
BOOST_FOREACH(const valtype& name, namesInDB)
if (namesInUTXO.count(name) == 0)
return error("%s : name '%s' in DB but not UTXO set",
__func__, ValtypeToString(name).c_str());
BOOST_FOREACH(const PAIRTYPE(valtype, CAmount)& pair, namesInUTXO)
if (namesInDB.count(pair.first) == 0)
return error("%s : name '%s' in UTXO set but not DB",
__func__, ValtypeToString(pair.first).c_str());
if (fNameHistory)
{
BOOST_FOREACH(const valtype& name, namesWithHistory)
if (namesTotal.count(name) == 0)
return error("%s : history entry for name '%s' not in main DB",
__func__, ValtypeToString(name).c_str());
} else if (!namesWithHistory.empty ())
bool CCoinsViewDB::ValidateNameDB() const
{
const uint256 blockHash = GetBestBlock();
int nHeight;
if (blockHash.IsNull())
nHeight = 0;
else
nHeight = mapBlockIndex.find(blockHash)->second->nHeight;
/* It seems that there are no "const iterators" for LevelDB. Since we
only need read operations on it, use a const-cast to get around
that restriction. */
boost::scoped_ptr<CDBIterator> pcursor(const_cast<CDBWrapper*>(&db)->NewIterator());
pcursor->SeekToFirst();
/* Loop over the total database and read interesting
things to memory. We later use that to check
everything against each other. */
std::map<valtype, unsigned> nameHeightsIndex;
std::map<valtype, unsigned> nameHeightsData;
std::set<valtype> namesInDB;
std::set<valtype> namesInUTXO;
std::set<valtype> namesWithHistory;
for (; pcursor->Valid(); pcursor->Next())
{
boost::this_thread::interruption_point();
char chType;
if (!pcursor->GetKey(chType))
continue;
switch (chType)
{
case DB_COINS:
{
CCoins coins;
if (!pcursor->GetValue(coins))
return error("%s : failed to read coins", __func__);
BOOST_FOREACH(const CTxOut& txout, coins.vout)
if (!txout.IsNull())
{
const CNameScript nameOp(txout.scriptPubKey);
if (nameOp.isNameOp() && nameOp.isAnyUpdate())
{
const valtype& name = nameOp.getOpName();
if (namesInUTXO.count(name) > 0)
return error("%s : name %s duplicated in UTXO set",
__func__, ValtypeToString(name).c_str());
namesInUTXO.insert(nameOp.getOpName());
}
}
break;
}
case DB_NAME:
{
std::pair<char, valtype> key;
if (!pcursor->GetKey(key) || key.first != DB_NAME)
return error("%s : failed to read DB_NAME key", __func__);
const valtype& name = key.second;
CNameData data;
if (!pcursor->GetValue(data))
return error("%s : failed to read name value", __func__);
if (nameHeightsData.count(name) > 0)
return error("%s : name %s duplicated in name index",
__func__, ValtypeToString(name).c_str());
nameHeightsData.insert(std::make_pair(name, data.getHeight()));
/* Expiration is checked at height+1, because that matches
how the UTXO set is cleared in ExpireNames. */
assert(namesInDB.count(name) == 0);
if (!data.isExpired(nHeight + 1))
namesInDB.insert(name);
break;
}
case DB_NAME_HISTORY:
{
std::pair<char, valtype> key;
if (!pcursor->GetKey(key) || key.first != DB_NAME_HISTORY)
return error("%s : failed to read DB_NAME_HISTORY key",
__func__);
const valtype& name = key.second;
if (namesWithHistory.count(name) > 0)
return error("%s : name %s has duplicate history",
__func__, ValtypeToString(name).c_str());
namesWithHistory.insert(name);
break;
}
case DB_NAME_EXPIRY:
{
std::pair<char, CNameCache::ExpireEntry> key;
if (!pcursor->GetKey(key) || key.first != DB_NAME_EXPIRY)
return error("%s : failed to read DB_NAME_EXPIRY key",
__func__);
const CNameCache::ExpireEntry& entry = key.second;
const valtype& name = entry.name;
if (nameHeightsIndex.count(name) > 0)
return error("%s : name %s duplicated in expire idnex",
__func__, ValtypeToString(name).c_str());
nameHeightsIndex.insert(std::make_pair(name, entry.nHeight));
break;
}
default:
break;
}
}
/* Now verify the collected data. */
assert (nameHeightsData.size() >= namesInDB.size());
if (nameHeightsIndex != nameHeightsData)
return error("%s : name height data mismatch", __func__);
BOOST_FOREACH(const valtype& name, namesInDB)
if (namesInUTXO.count(name) == 0)
return error("%s : name '%s' in DB but not UTXO set",
__func__, ValtypeToString(name).c_str());
BOOST_FOREACH(const valtype& name, namesInUTXO)
if (namesInDB.count(name) == 0)
return error("%s : name '%s' in UTXO set but not DB",
__func__, ValtypeToString(name).c_str());
if (fNameHistory)
{
BOOST_FOREACH(const valtype& name, namesWithHistory)
if (nameHeightsData.count(name) == 0)
return error("%s : history entry for name '%s' not in main DB",
__func__, ValtypeToString(name).c_str());
} else if (!namesWithHistory.empty ())
