mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 03:52:49 +01:00
Merge #13424: Consistently validate txid / blockhash length and encoding in rpc calls
5eb20f81d9 Consistently use ParseHashV to validate hash inputs in rpc (Ben Woosley) Pull request description: ParseHashV validates the length and encoding of the string and throws an informative RPC error on failure, which is as good or better than these alternative calls. Note I switched ParseHashV to check string length first, because IsHex tests that the length is even, and an error like: "must be of length 64 (not 63, for X)" is much more informative than "must be hexadecimal string (not X)" in that case. Split from #13420 Tree-SHA512: f0786b41c0d7793ff76e4b2bb35547873070bbf7561d510029e8edb93f59176277efcd4d183b3185532ea69fc0bbbf3dbe9e19362e8017007ae9d51266cd78ae
This commit is contained in:
MarcoFalke
UdjinM6
parent
8eb04b2f1f
commit
2cae37806b
@ -374,7 +374,7 @@ static UniValue waitforblock(const JSONRPCRequest& request)
|
||||
}.Check(request);
|
||||
int timeout = 0;
|
||||
|
||||
uint256 hash = uint256S(request.params[0].get_str());
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
|
||||
if (!request.params[1].isNull())
|
||||
timeout = request.params[1].get_int();
|
||||
@ -634,7 +634,7 @@ static UniValue getmempoolancestors(const JSONRPCRequest& request)
|
||||
if (!request.params[1].isNull())
|
||||
fVerbose = request.params[1].get_bool();
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "parameter 1");
|
||||
uint256 hash(ParseHashV(request.params[0], "parameter 1"));
|
||||
|
||||
const CTxMemPool& mempool = EnsureMemPool(request.context);
|
||||
LOCK(mempool.cs);
|
||||
@ -698,7 +698,7 @@ static UniValue getmempooldescendants(const JSONRPCRequest& request)
|
||||
if (!request.params[1].isNull())
|
||||
fVerbose = request.params[1].get_bool();
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "parameter 1");
|
||||
uint256 hash(ParseHashV(request.params[0], "parameter 1"));
|
||||
|
||||
const CTxMemPool& mempool = EnsureMemPool(request.context);
|
||||
LOCK(mempool.cs);
|
||||
@ -749,7 +749,7 @@ static UniValue getmempoolentry(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "parameter 1");
|
||||
uint256 hash(ParseHashV(request.params[0], "parameter 1"));
|
||||
|
||||
const CTxMemPool& mempool = EnsureMemPool(request.context);
|
||||
LOCK(mempool.cs);
|
||||
@ -862,8 +862,7 @@ static UniValue getblockheader(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "hash"));
|
||||
|
||||
bool fVerbose = true;
|
||||
if (!request.params[1].isNull())
|
||||
@ -936,8 +935,7 @@ static UniValue getblockheaders(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
|
||||
const CBlockIndex* pblockindex;
|
||||
const CBlockIndex* tip;
|
||||
@ -1048,8 +1046,7 @@ static UniValue getmerkleblocks(const JSONRPCRequest& request)
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "Filter is not within size constraints");
|
||||
}
|
||||
|
||||
std::string strHash = request.params[1].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[1], "blockhash"));
|
||||
|
||||
const CBlockIndex* pblockindex = g_chainman.m_blockman.LookupBlockIndex(hash);
|
||||
if (!pblockindex) {
|
||||
@ -1154,8 +1151,7 @@ static UniValue getblock(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
|
||||
int verbosity = 1;
|
||||
if (!request.params[1].isNull()) {
|
||||
@ -1356,8 +1352,7 @@ static UniValue gettxout(const JSONRPCRequest& request)
|
||||
|
||||
UniValue ret(UniValue::VOBJ);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "txid"));
|
||||
int n = request.params[1].get_int();
|
||||
COutPoint out(hash, n);
|
||||
bool fMempool = true;
|
||||
@ -1805,8 +1800,7 @@ static UniValue preciousblock(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
CBlockIndex* pblockindex;
|
||||
|
||||
{
|
||||
@ -1841,8 +1835,7 @@ static UniValue invalidateblock(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
CValidationState state;
|
||||
|
||||
CBlockIndex* pblockindex;
|
||||
@ -1881,8 +1874,7 @@ static UniValue reconsiderblock(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
|
||||
{
|
||||
LOCK(cs_main);
|
||||
@ -1937,7 +1929,7 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
|
||||
LOCK(cs_main);
|
||||
pindex = ::ChainActive().Tip();
|
||||
} else {
|
||||
uint256 hash = uint256S(request.params[1].get_str());
|
||||
uint256 hash(ParseHashV(request.params[1], "blockhash"));
|
||||
LOCK(cs_main);
|
||||
pindex = g_chainman.m_blockman.LookupBlockIndex(hash);
|
||||
if (!pindex) {
|
||||
@ -2114,8 +2106,7 @@ static UniValue getblockstats(const JSONRPCRequest& request)
|
||||
|
||||
pindex = ::ChainActive()[height];
|
||||
} else {
|
||||
const uint256 hash = ParseHashV(request.params[0], "parameter 1");
|
||||
|
||||
const uint256 hash(ParseHashV(request.params[0], "hash_or_height"));
|
||||
pindex = g_chainman.m_blockman.LookupBlockIndex(hash);
|
||||
if (!pindex) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
||||
@ -2307,8 +2298,7 @@ static UniValue getspecialtxes(const JSONRPCRequest& request)
|
||||
|
||||
LOCK(cs_main);
|
||||
|
||||
std::string strHash = request.params[0].get_str();
|
||||
uint256 hash(uint256S(strHash));
|
||||
uint256 hash(ParseHashV(request.params[0], "blockhash"));
|
||||
|
||||
int nTxType = -1;
|
||||
if (!request.params[1].isNull()) {
|
||||
@ -2637,7 +2627,7 @@ static UniValue getblockfilter(const JSONRPCRequest& request)
|
||||
},
|
||||
}.Check(request);
|
||||
|
||||
uint256 block_hash = ParseHashV(request.params[0], "blockhash");
|
||||
uint256 block_hash(ParseHashV(request.params[0], "blockhash"));
|
||||
std::string filtertype_name = "basic";
|
||||
if (!request.params[1].isNull()) {
|
||||
filtertype_name = request.params[1].get_str();
|
||||
|
||||
@ -640,7 +640,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
|
||||
|
||||
paramIdx++;
|
||||
} else {
|
||||
uint256 collateralHash = ParseHashV(request.params[paramIdx], "collateralHash");
|
||||
uint256 collateralHash(ParseHashV(request.params[paramIdx], "collateralHash"));
|
||||
int32_t collateralIndex = ParseInt32V(request.params[paramIdx + 1], "collateralIndex");
|
||||
if (collateralHash.IsNull() || collateralIndex < 0) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid hash or index: %s-%d", collateralHash.ToString(), collateralIndex));
|
||||
@ -1405,7 +1405,7 @@ static UniValue protx_info(const JSONRPCRequest& request)
|
||||
g_txindex->BlockUntilSyncedToCurrentChain();
|
||||
}
|
||||
|
||||
uint256 proTxHash = ParseHashV(request.params[0], "proTxHash");
|
||||
uint256 proTxHash(ParseHashV(request.params[0], "proTxHash"));
|
||||
auto mnList = deterministicMNManager->GetListAtChainTip();
|
||||
auto dmn = mnList.GetMN(proTxHash);
|
||||
if (!dmn) {
|
||||
|
||||
@ -213,7 +213,7 @@ static UniValue gobject_prepare(const JSONRPCRequest& request)
|
||||
COutPoint outpoint;
|
||||
outpoint.SetNull();
|
||||
if (!request.params[5].isNull() && !request.params[6].isNull()) {
|
||||
uint256 collateralHash = ParseHashV(request.params[5], "outputHash");
|
||||
uint256 collateralHash(ParseHashV(request.params[5], "outputHash"));
|
||||
int32_t collateralIndex = ParseInt32V(request.params[6], "outputIndex");
|
||||
if (collateralHash.IsNull() || collateralIndex < 0) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid hash or index: %s-%d", collateralHash.ToString(), collateralIndex));
|
||||
@ -427,9 +427,7 @@ static UniValue gobject_vote_conf(const JSONRPCRequest& request)
|
||||
{
|
||||
gobject_vote_conf_help(request);
|
||||
|
||||
uint256 hash;
|
||||
|
||||
hash = ParseHashV(request.params[0], "Object hash");
|
||||
uint256 hash(ParseHashV(request.params[0], "Object hash"));
|
||||
std::string strVoteSignal = request.params[1].get_str();
|
||||
std::string strVoteOutcome = request.params[2].get_str();
|
||||
|
||||
@ -605,7 +603,7 @@ static UniValue gobject_vote_many(const JSONRPCRequest& request)
|
||||
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
|
||||
if (!wallet) return NullUniValue;
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "Object hash");
|
||||
uint256 hash(ParseHashV(request.params[0], "Object hash"));
|
||||
std::string strVoteSignal = request.params[1].get_str();
|
||||
std::string strVoteOutcome = request.params[2].get_str();
|
||||
|
||||
@ -664,7 +662,7 @@ static UniValue gobject_vote_alias(const JSONRPCRequest& request)
|
||||
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
|
||||
if (!wallet) return NullUniValue;
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "Object hash");
|
||||
uint256 hash(ParseHashV(request.params[0], "Object hash"));
|
||||
std::string strVoteSignal = request.params[1].get_str();
|
||||
std::string strVoteOutcome = request.params[2].get_str();
|
||||
|
||||
@ -682,7 +680,7 @@ static UniValue gobject_vote_alias(const JSONRPCRequest& request)
|
||||
|
||||
EnsureWalletIsUnlocked(wallet.get());
|
||||
|
||||
uint256 proTxHash = ParseHashV(request.params[3], "protx-hash");
|
||||
uint256 proTxHash(ParseHashV(request.params[3], "protx-hash"));
|
||||
auto dmn = deterministicMNManager->GetListAtChainTip().GetValidMN(proTxHash);
|
||||
if (!dmn) {
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid or unknown proTxHash");
|
||||
@ -850,7 +848,7 @@ static UniValue gobject_get(const JSONRPCRequest& request)
|
||||
gobject_get_help(request);
|
||||
|
||||
// COLLECT VARIABLES FROM OUR USER
|
||||
uint256 hash = ParseHashV(request.params[0], "GovObj hash");
|
||||
uint256 hash(ParseHashV(request.params[0], "GovObj hash"));
|
||||
|
||||
if (g_txindex) {
|
||||
g_txindex->BlockUntilSyncedToCurrentChain();
|
||||
@ -943,11 +941,11 @@ static UniValue gobject_getcurrentvotes(const JSONRPCRequest& request)
|
||||
|
||||
// COLLECT PARAMETERS FROM USER
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0], "Governance hash");
|
||||
uint256 hash(ParseHashV(request.params[0], "Governance hash"));
|
||||
|
||||
COutPoint mnCollateralOutpoint;
|
||||
if (!request.params[1].isNull() && !request.params[2].isNull()) {
|
||||
uint256 txid = ParseHashV(request.params[1], "Masternode Collateral hash");
|
||||
uint256 txid(ParseHashV(request.params[1], "Masternode Collateral hash"));
|
||||
std::string strVout = request.params[2].get_str();
|
||||
mnCollateralOutpoint = COutPoint(txid, LocaleIndependentAtoi<uint32_t>(strVout));
|
||||
}
|
||||
@ -1076,11 +1074,11 @@ static UniValue voteraw(const JSONRPCRequest& request)
|
||||
RPCExamples{""}
|
||||
}.Check(request);
|
||||
|
||||
uint256 hashMnCollateralTx = ParseHashV(request.params[0], "mn collateral tx hash");
|
||||
uint256 hashMnCollateralTx(ParseHashV(request.params[0], "mn collateral tx hash"));
|
||||
int nMnCollateralTxIndex = request.params[1].get_int();
|
||||
COutPoint outpoint = COutPoint(hashMnCollateralTx, nMnCollateralTxIndex);
|
||||
|
||||
uint256 hashGovObj = ParseHashV(request.params[2], "Governance hash");
|
||||
uint256 hashGovObj(ParseHashV(request.params[2], "Governance hash"));
|
||||
std::string strVoteSignal = request.params[3].get_str();
|
||||
std::string strVoteOutcome = request.params[4].get_str();
|
||||
|
||||
|
||||
@ -420,7 +420,7 @@ static UniValue masternode_payments(const JSONRPCRequest& request)
|
||||
pindex = ::ChainActive().Tip();
|
||||
} else {
|
||||
LOCK(cs_main);
|
||||
uint256 blockHash = ParseHashV(request.params[0], "blockhash");
|
||||
uint256 blockHash(ParseHashV(request.params[0], "blockhash"));
|
||||
pindex = g_chainman.m_blockman.LookupBlockIndex(blockHash);
|
||||
if (pindex == nullptr) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
||||
|
||||
@ -476,7 +476,7 @@ static UniValue prioritisetransaction(const JSONRPCRequest& request)
|
||||
|
||||
LOCK(cs_main);
|
||||
|
||||
uint256 hash = ParseHashV(request.params[0].get_str(), "txid");
|
||||
uint256 hash(ParseHashV(request.params[0].get_str(), "txid"));
|
||||
CAmount nAmount = request.params[1].get_int64();
|
||||
|
||||
EnsureMemPool(request.context).PrioritiseTransaction(hash, nAmount);
|
||||
@ -726,7 +726,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
|
||||
// Format: <hashBestChain><nTransactionsUpdatedLast>
|
||||
std::string lpstr = lpval.get_str();
|
||||
|
||||
hashWatchedChain.SetHex(lpstr.substr(0, 64));
|
||||
hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
|
||||
nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
|
||||
}
|
||||
else
|
||||
|
||||
@ -240,7 +240,7 @@ static UniValue quorum_info(const JSONRPCRequest& request)
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
|
||||
}
|
||||
|
||||
uint256 quorumHash = ParseHashV(request.params[1], "quorumHash");
|
||||
uint256 quorumHash(ParseHashV(request.params[1], "quorumHash"));
|
||||
bool includeSkShare = false;
|
||||
if (!request.params[2].isNull()) {
|
||||
includeSkShare = ParseBoolV(request.params[2], "includeSkShare");
|
||||
@ -381,7 +381,7 @@ static UniValue quorum_memberof(const JSONRPCRequest& request)
|
||||
{
|
||||
quorum_memberof_help(request);
|
||||
|
||||
uint256 protxHash = ParseHashV(request.params[0], "proTxHash");
|
||||
uint256 protxHash(ParseHashV(request.params[0], "proTxHash"));
|
||||
int scanQuorumsCount = -1;
|
||||
if (!request.params[1].isNull()) {
|
||||
scanQuorumsCount = ParseInt32V(request.params[1], "scanQuorumsCount");
|
||||
@ -530,8 +530,8 @@ static UniValue quorum_sigs_cmd(const JSONRPCRequest& request)
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
|
||||
}
|
||||
|
||||
uint256 id = ParseHashV(request.params[1], "id");
|
||||
uint256 msgHash = ParseHashV(request.params[2], "msgHash");
|
||||
uint256 id(ParseHashV(request.params[1], "id"));
|
||||
uint256 msgHash(ParseHashV(request.params[2], "msgHash"));
|
||||
|
||||
if (cmd == "quorumsign") {
|
||||
uint256 quorumHash;
|
||||
@ -590,7 +590,7 @@ static UniValue quorum_sigs_cmd(const JSONRPCRequest& request)
|
||||
return llmq_ctx.sigman->VerifyRecoveredSig(llmqType, *llmq_ctx.qman, signHeight, id, msgHash, sig, 0) ||
|
||||
llmq_ctx.sigman->VerifyRecoveredSig(llmqType, *llmq_ctx.qman, signHeight, id, msgHash, sig, signOffset);
|
||||
} else {
|
||||
uint256 quorumHash = ParseHashV(request.params[4], "quorumHash");
|
||||
uint256 quorumHash(ParseHashV(request.params[4], "quorumHash"));
|
||||
llmq::CQuorumCPtr quorum = llmq_ctx.qman->GetQuorum(llmqType, quorumHash);
|
||||
|
||||
if (!quorum) {
|
||||
@ -642,7 +642,7 @@ static UniValue quorum_selectquorum(const JSONRPCRequest& request)
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid LLMQ type");
|
||||
}
|
||||
|
||||
uint256 id = ParseHashV(request.params[1], "id");
|
||||
uint256 id(ParseHashV(request.params[1], "id"));
|
||||
|
||||
UniValue ret(UniValue::VOBJ);
|
||||
|
||||
@ -723,7 +723,7 @@ static UniValue quorum_getdata(const JSONRPCRequest& request)
|
||||
|
||||
NodeId nodeId = ParseInt64V(request.params[0], "nodeId");
|
||||
Consensus::LLMQType llmqType = static_cast<Consensus::LLMQType>(ParseInt32V(request.params[1], "llmqType"));
|
||||
uint256 quorumHash = ParseHashV(request.params[2], "quorumHash");
|
||||
uint256 quorumHash(ParseHashV(request.params[2], "quorumHash"));
|
||||
uint16_t nDataMask = static_cast<uint16_t>(ParseInt32V(request.params[3], "dataMask"));
|
||||
uint256 proTxHash;
|
||||
|
||||
@ -871,7 +871,7 @@ static UniValue verifychainlock(const JSONRPCRequest& request)
|
||||
{
|
||||
verifychainlock_help(request);
|
||||
|
||||
const uint256 nBlockHash = ParseHashV(request.params[0], "blockHash");
|
||||
const uint256 nBlockHash(ParseHashV(request.params[0], "blockHash"));
|
||||
|
||||
CBLSSignature chainLockSig;
|
||||
if (!chainLockSig.SetHexStr(request.params[1].get_str())) {
|
||||
@ -915,8 +915,8 @@ static UniValue verifyislock(const JSONRPCRequest& request)
|
||||
{
|
||||
verifyislock_help(request);
|
||||
|
||||
uint256 id = ParseHashV(request.params[0], "id");
|
||||
uint256 txid = ParseHashV(request.params[1], "txid");
|
||||
uint256 id(ParseHashV(request.params[0], "id"));
|
||||
uint256 txid(ParseHashV(request.params[1], "txid"));
|
||||
|
||||
CBLSSignature sig;
|
||||
if (!sig.SetHexStr(request.params[2].get_str())) {
|
||||
|
||||
@ -297,10 +297,7 @@ static UniValue gettxoutproof(const JSONRPCRequest& request)
|
||||
UniValue txids = request.params[0].get_array();
|
||||
for (unsigned int idx = 0; idx < txids.size(); idx++) {
|
||||
const UniValue& txid = txids[idx];
|
||||
if (txid.get_str().length() != 64 || !IsHex(txid.get_str())) {
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid txid ")+txid.get_str());
|
||||
}
|
||||
uint256 hash(uint256S(txid.get_str()));
|
||||
uint256 hash(ParseHashV(txid, "txid"));
|
||||
if (setTxids.count(hash)) {
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated txid: ")+txid.get_str());
|
||||
}
|
||||
@ -312,7 +309,7 @@ static UniValue gettxoutproof(const JSONRPCRequest& request)
|
||||
uint256 hashBlock;
|
||||
if (!request.params[1].isNull()) {
|
||||
LOCK(cs_main);
|
||||
hashBlock = uint256S(request.params[1].get_str());
|
||||
hashBlock = ParseHashV(request.params[1], "blockhash");
|
||||
pblockindex = g_chainman.m_blockman.LookupBlockIndex(hashBlock);
|
||||
if (!pblockindex) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
|
||||
|
||||
@ -88,16 +88,12 @@ CAmount AmountFromValue(const UniValue& value)
|
||||
|
||||
uint256 ParseHashV(const UniValue& v, std::string strName)
|
||||
{
|
||||
std::string strHex;
|
||||
if (v.isStr())
|
||||
strHex = v.get_str();
|
||||
std::string strHex{v.get_str()};
|
||||
if (64 != strHex.length())
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d, for '%s')", strName, 64, strHex.length(), strHex));
|
||||
if (!IsHex(strHex)) // Note: IsHex("") is false
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
|
||||
if (64 != strHex.length())
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d)", strName, 64, strHex.length()));
|
||||
uint256 result;
|
||||
result.SetHex(strHex);
|
||||
return result;
|
||||
return uint256S(strHex);
|
||||
}
|
||||
uint256 ParseHashO(const UniValue& o, std::string strKey)
|
||||
{
|
||||
|
||||
@ -358,8 +358,7 @@ UniValue removeprunedfunds(const JSONRPCRequest& request)
|
||||
|
||||
LOCK(pwallet->cs_wallet);
|
||||
|
||||
uint256 hash;
|
||||
hash.SetHex(request.params[0].get_str());
|
||||
uint256 hash(ParseHashV(request.params[0], "txid"));
|
||||
std::vector<uint256> vHash;
|
||||
vHash.push_back(hash);
|
||||
std::vector<uint256> vHashOut;
|
||||
|
||||
@ -1582,7 +1582,7 @@ static UniValue listsinceblock(const JSONRPCRequest& request)
|
||||
|
||||
uint256 blockId;
|
||||
if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
|
||||
blockId.SetHex(request.params[0].get_str());
|
||||
blockId = ParseHashV(request.params[0], "blockhash");
|
||||
height = pwallet->chain().findFork(blockId, &altheight);
|
||||
|
||||
if (!height) {
|
||||
@ -1707,8 +1707,7 @@ static UniValue gettransaction(const JSONRPCRequest& request)
|
||||
|
||||
LOCK(pwallet->cs_wallet);
|
||||
|
||||
uint256 hash;
|
||||
hash.SetHex(request.params[0].get_str());
|
||||
uint256 hash(ParseHashV(request.params[0], "txid"));
|
||||
|
||||
isminefilter filter = ISMINE_SPENDABLE;
|
||||
|
||||
@ -1772,8 +1771,7 @@ static UniValue abandontransaction(const JSONRPCRequest& request)
|
||||
|
||||
LOCK(pwallet->cs_wallet);
|
||||
|
||||
uint256 hash;
|
||||
hash.SetHex(request.params[0].get_str());
|
||||
uint256 hash(ParseHashV(request.params[0], "txid"));
|
||||
|
||||
if (!pwallet->mapWallet.count(hash)) {
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
|
||||
@ -2176,17 +2174,13 @@ static UniValue lockunspent(const JSONRPCRequest& request)
|
||||
{"vout", UniValueType(UniValue::VNUM)},
|
||||
});
|
||||
|
||||
const std::string& txid = find_value(o, "txid").get_str();
|
||||
if (!IsHex(txid)) {
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected hex txid");
|
||||
}
|
||||
|
||||
const uint256 txid(ParseHashO(o, "txid"));
|
||||
const int nOutput = find_value(o, "vout").get_int();
|
||||
if (nOutput < 0) {
|
||||
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
|
||||
}
|
||||
|
||||
const COutPoint outpt(uint256S(txid), nOutput);
|
||||
const COutPoint outpt(txid, nOutput);
|
||||
|
||||
const auto it = pwallet->mapWallet.find(outpt.hash);
|
||||
if (it == pwallet->mapWallet.end()) {
|
||||
|
||||
@ -30,7 +30,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
|
||||
assert_raises_rpc_error(-1, "prioritisetransaction", self.nodes[0].prioritisetransaction, '', 0, 0)
|
||||
|
||||
# Test `prioritisetransaction` invalid `txid`
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string", self.nodes[0].prioritisetransaction, txid='foo', fee_delta=0)
|
||||
assert_raises_rpc_error(-8, "txid must be of length 64 (not 3, for 'foo')", self.nodes[0].prioritisetransaction, txid='foo', fee_delta=0)
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000')", self.nodes[0].prioritisetransaction, txid='Zd1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000', fee_delta=0)
|
||||
|
||||
txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
|
||||
|
||||
@ -279,7 +279,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
||||
block_hash = int(node.generate(1)[0], 16)
|
||||
|
||||
# Store the raw block in our internal format.
|
||||
block = FromHex(CBlock(), node.getblock("%02x" % block_hash, False))
|
||||
block = FromHex(CBlock(), node.getblock("%064x" % block_hash, False))
|
||||
for tx in block.vtx:
|
||||
tx.calc_sha256()
|
||||
block.rehash()
|
||||
|
||||
@ -394,7 +394,7 @@ class SendHeadersTest(BitcoinTestFramework):
|
||||
|
||||
block_time += 9
|
||||
|
||||
fork_point = self.nodes[0].getblock("%02x" % new_block_hashes[0])["previousblockhash"]
|
||||
fork_point = self.nodes[0].getblock("%064x" % new_block_hashes[0])["previousblockhash"]
|
||||
fork_point = int(fork_point, 16)
|
||||
|
||||
# Use getblocks/getdata
|
||||
|
||||
@ -142,7 +142,9 @@ class BlockchainTest(BitcoinTestFramework):
|
||||
|
||||
# Test `getchaintxstats` invalid `blockhash`
|
||||
assert_raises_rpc_error(-1, "JSON value is not a string as expected", self.nodes[0].getchaintxstats, blockhash=0)
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getchaintxstats, blockhash='0')
|
||||
assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 1, for '0')", self.nodes[0].getchaintxstats, blockhash='0')
|
||||
assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].getchaintxstats, blockhash='ZZZ0000000000000000000000000000000000000000000000000000000000000')
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getchaintxstats, blockhash='0000000000000000000000000000000000000000000000000000000000000000')
|
||||
blockhash = self.nodes[0].getblockhash(200)
|
||||
self.nodes[0].invalidateblock(blockhash)
|
||||
assert_raises_rpc_error(-8, "Block is not in main chain", self.nodes[0].getchaintxstats, blockhash=blockhash)
|
||||
@ -244,7 +246,9 @@ class BlockchainTest(BitcoinTestFramework):
|
||||
def _test_getblockheader(self):
|
||||
node = self.nodes[0]
|
||||
|
||||
assert_raises_rpc_error(-5, "Block not found", node.getblockheader, "nonsense")
|
||||
assert_raises_rpc_error(-8, "hash must be of length 64 (not 8, for 'nonsense')", node.getblockheader, "nonsense")
|
||||
assert_raises_rpc_error(-8, "hash must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')", node.getblockheader, "ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
|
||||
assert_raises_rpc_error(-5, "Block not found", node.getblockheader, "0cf7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
|
||||
|
||||
besthash = node.getbestblockhash()
|
||||
secondbesthash = node.getblockhash(199)
|
||||
|
||||
@ -90,8 +90,9 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
|
||||
assert_raises_rpc_error(-3, "Expected type array", self.nodes[0].createrawtransaction, 'foo', {})
|
||||
assert_raises_rpc_error(-1, "JSON value is not an object as expected", self.nodes[0].createrawtransaction, ['foo'], {})
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string", self.nodes[0].createrawtransaction, [{}], {})
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string", self.nodes[0].createrawtransaction, [{'txid': 'foo'}], {})
|
||||
assert_raises_rpc_error(-1, "JSON value is not a string as expected", self.nodes[0].createrawtransaction, [{}], {})
|
||||
assert_raises_rpc_error(-8, "txid must be of length 64 (not 3, for 'foo')", self.nodes[0].createrawtransaction, [{'txid': 'foo'}], {})
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')", self.nodes[0].createrawtransaction, [{'txid': 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844'}], {})
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, missing vout key", self.nodes[0].createrawtransaction, [{'txid': txid}], {})
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, missing vout key", self.nodes[0].createrawtransaction, [{'txid': txid, 'vout': 'foo'}], {})
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, vout cannot be negative", self.nodes[0].createrawtransaction, [{'txid': txid, 'vout': -1}], {})
|
||||
@ -171,9 +172,10 @@ class RawTransactionsTest(BitcoinTestFramework):
|
||||
# We should not get the tx if we provide an unrelated block
|
||||
assert_raises_rpc_error(-5, "No such transaction found", self.nodes[0].getrawtransaction, tx, True, block2)
|
||||
# An invalid block hash should raise the correct errors
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be hexadecimal", self.nodes[0].getrawtransaction, tx, True, True)
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be hexadecimal", self.nodes[0].getrawtransaction, tx, True, "foobar")
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be of length 64", self.nodes[0].getrawtransaction, tx, True, "abcd1234")
|
||||
assert_raises_rpc_error(-1, "JSON value is not a string as expected", self.nodes[0].getrawtransaction, tx, True, True)
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be of length 64 (not 6, for 'foobar')", self.nodes[0].getrawtransaction, tx, True, "foobar")
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be of length 64 (not 8, for 'abcd1234')", self.nodes[0].getrawtransaction, tx, True, "abcd1234")
|
||||
assert_raises_rpc_error(-8, "parameter 3 must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].getrawtransaction, tx, True, "ZZZ0000000000000000000000000000000000000000000000000000000000000")
|
||||
assert_raises_rpc_error(-5, "Block hash not found", self.nodes[0].getrawtransaction, tx, True, "0000000000000000000000000000000000000000000000000000000000000000")
|
||||
# Undo the blocks and check in_active_chain
|
||||
self.nodes[0].invalidateblock(block1)
|
||||
|
||||
@ -69,13 +69,19 @@ class MerkleBlockTest(BitcoinTestFramework):
|
||||
txid_spent = txin_spent["txid"]
|
||||
txid_unspent = txid1 if txin_spent["txid"] != txid1 else txid2
|
||||
|
||||
# Invalid txids
|
||||
assert_raises_rpc_error(-8, "txid must be of length 64 (not 32, for '00000000000000000000000000000000')", self.nodes[2].gettxoutproof, ["00000000000000000000000000000000"], blockhash)
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[2].gettxoutproof, ["ZZZ0000000000000000000000000000000000000000000000000000000000000"], blockhash)
|
||||
# Invalid blockhashes
|
||||
assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 32, for '00000000000000000000000000000000')", self.nodes[2].gettxoutproof, [txid_spent], "00000000000000000000000000000000")
|
||||
assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[2].gettxoutproof, [txid_spent], "ZZZ0000000000000000000000000000000000000000000000000000000000000")
|
||||
# We can't find the block from a fully-spent tx
|
||||
# Doesn't apply to Dash Core - we have txindex always on
|
||||
# assert_raises_rpc_error(-5, "Transaction not yet in block", self.nodes[2].gettxoutproof, [txid_spent])
|
||||
# We can get the proof if we specify the block
|
||||
assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_spent], blockhash)), [txid_spent])
|
||||
# We can't get the proof if we specify a non-existent block
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[2].gettxoutproof, [txid_spent], "00000000000000000000000000000000")
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[2].gettxoutproof, [txid_spent], "0000000000000000000000000000000000000000000000000000000000000000")
|
||||
# We can get the proof if the transaction is unspent
|
||||
assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_unspent])), [txid_unspent])
|
||||
# We can get the proof if we provide a list of transactions and one of them is unspent. The ordering of the list should not matter.
|
||||
|
||||
@ -121,9 +121,15 @@ class WalletTest(BitcoinTestFramework):
|
||||
assert_equal([unspent_0], self.nodes[2].listlockunspent())
|
||||
self.nodes[2].lockunspent(True, [unspent_0])
|
||||
assert_equal(len(self.nodes[2].listlockunspent()), 0)
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, unknown transaction",
|
||||
assert_raises_rpc_error(-8, "txid must be of length 64 (not 34, for '0000000000000000000000000000000000')",
|
||||
self.nodes[2].lockunspent, False,
|
||||
[{"txid": "0000000000000000000000000000000000", "vout": 0}])
|
||||
assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
|
||||
self.nodes[2].lockunspent, False,
|
||||
[{"txid": "ZZZ0000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, unknown transaction",
|
||||
self.nodes[2].lockunspent, False,
|
||||
[{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
|
||||
assert_raises_rpc_error(-8, "Invalid parameter, vout index out of bounds",
|
||||
self.nodes[2].lockunspent, False,
|
||||
[{"txid": unspent_0["txid"], "vout": 999}])
|
||||
|
||||
@ -66,8 +66,10 @@ class ListSinceBlockTest(BitcoinTestFramework):
|
||||
"42759cde25462784395a337460bde75f58e73d3f08bd31fdc3507cbac856a2c4")
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].listsinceblock,
|
||||
"0000000000000000000000000000000000000000000000000000000000000000")
|
||||
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].listsinceblock,
|
||||
assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 11, for 'invalid-hex')", self.nodes[0].listsinceblock,
|
||||
"invalid-hex")
|
||||
assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'Z000000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].listsinceblock,
|
||||
"Z000000000000000000000000000000000000000000000000000000000000000")
|
||||
|
||||
def test_reorg(self):
|
||||
'''
|
||||
|
||||
Loading…
Reference in New Issue
Block a user