Bitcoin Core 29.99.0
P2P Digital Currency
server.cpp
Go to the documentation of this file.
1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <rpc/server.h>
9
10#include <common/args.h>
11#include <common/system.h>
12#include <logging.h>
13#include <node/context.h>
15#include <rpc/server_util.h>
16#include <rpc/util.h>
17#include <sync.h>
19#include <util/strencodings.h>
20#include <util/string.h>
21#include <util/time.h>
22#include <validation.h>
23
24#include <algorithm>
25#include <cassert>
26#include <chrono>
27#include <memory>
28#include <mutex>
29#include <unordered_map>
30
32
34static std::atomic<bool> g_rpc_running{false};
35static bool fRPCInWarmup GUARDED_BY(g_rpc_warmup_mutex) = true;
36static std::string rpcWarmupStatus GUARDED_BY(g_rpc_warmup_mutex) = "RPC server started";
37static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& request, UniValue& result, bool last_handler);
38
40{
41 std::string method;
42 SteadyClock::time_point start;
43};
44
46{
48 std::list<RPCCommandExecutionInfo> active_commands GUARDED_BY(mutex);
49};
50
52
54{
55 std::list<RPCCommandExecutionInfo>::iterator it;
56 explicit RPCCommandExecution(const std::string& method)
57 {
59 it = g_rpc_server_info.active_commands.insert(g_rpc_server_info.active_commands.end(), {method, SteadyClock::now()});
60 }
62 {
64 g_rpc_server_info.active_commands.erase(it);
65 }
66};
67
68std::string CRPCTable::help(const std::string& strCommand, const JSONRPCRequest& helpreq) const
69{
70 std::string strRet;
71 std::string category;
72 std::set<intptr_t> setDone;
73 std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
74 vCommands.reserve(mapCommands.size());
75
76 for (const auto& entry : mapCommands)
77 vCommands.emplace_back(entry.second.front()->category + entry.first, entry.second.front());
78 std::ranges::sort(vCommands);
79
80 JSONRPCRequest jreq = helpreq;
82 jreq.params = UniValue();
83
84 for (const auto& [_, pcmd] : vCommands) {
85 std::string strMethod = pcmd->name;
86 if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
87 continue;
88 jreq.strMethod = strMethod;
89 try
90 {
91 UniValue unused_result;
92 if (setDone.insert(pcmd->unique_id).second)
93 pcmd->actor(jreq, unused_result, /*last_handler=*/true);
94 } catch (const HelpResult& e) {
95 std::string strHelp{e.what()};
96 if (strCommand == "")
97 {
98 if (strHelp.find('\n') != std::string::npos)
99 strHelp = strHelp.substr(0, strHelp.find('\n'));
100
101 if (category != pcmd->category)
102 {
103 if (!category.empty())
104 strRet += "\n";
105 category = pcmd->category;
106 strRet += "== " + Capitalize(category) + " ==\n";
107 }
108 }
109 strRet += strHelp + "\n";
110 }
111 }
112 if (strRet == "")
113 strRet = strprintf("help: unknown command: %s\n", strCommand);
114 strRet = strRet.substr(0,strRet.size()-1);
115 return strRet;
116}
117
119{
120 return RPCHelpMan{
121 "help",
122 "List all commands, or get help for a specified command.\n",
123 {
124 {"command", RPCArg::Type::STR, RPCArg::DefaultHint{"all commands"}, "The command to get help on"},
125 },
126 {
127 RPCResult{RPCResult::Type::STR, "", "The help text"},
129 },
130 RPCExamples{""},
131 [&](const RPCHelpMan& self, const JSONRPCRequest& jsonRequest) -> UniValue
132{
133 std::string strCommand;
134 if (jsonRequest.params.size() > 0) {
135 strCommand = jsonRequest.params[0].get_str();
136 }
137 if (strCommand == "dump_all_command_conversions") {
138 // Used for testing only, undocumented
139 return tableRPC.dumpArgMap(jsonRequest);
140 }
141
142 return tableRPC.help(strCommand, jsonRequest);
143},
144 };
145}
146
148{
149 static const std::string RESULT{CLIENT_NAME " stopping"};
150 return RPCHelpMan{
151 "stop",
152 // Also accept the hidden 'wait' integer argument (milliseconds)
153 // For instance, 'stop 1000' makes the call wait 1 second before returning
154 // to the client (intended for testing)
155 "Request a graceful shutdown of " CLIENT_NAME ".",
156 {
157 {"wait", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "how long to wait in ms", RPCArgOptions{.hidden=true}},
158 },
159 RPCResult{RPCResult::Type::STR, "", "A string with the content '" + RESULT + "'"},
160 RPCExamples{""},
161 [&](const RPCHelpMan& self, const JSONRPCRequest& jsonRequest) -> UniValue
162{
163 // Event loop will exit after current HTTP requests have been handled, so
164 // this reply will get back to the client.
165 CHECK_NONFATAL((CHECK_NONFATAL(EnsureAnyNodeContext(jsonRequest.context).shutdown_request))());
166 if (jsonRequest.params[0].isNum()) {
167 UninterruptibleSleep(std::chrono::milliseconds{jsonRequest.params[0].getInt<int>()});
168 }
169 return RESULT;
170},
171 };
172}
173
175{
176 return RPCHelpMan{
177 "uptime",
178 "Returns the total uptime of the server.\n",
179 {},
180 RPCResult{
181 RPCResult::Type::NUM, "", "The number of seconds that the server has been running"
182 },
184 HelpExampleCli("uptime", "")
185 + HelpExampleRpc("uptime", "")
186 },
187 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
188{
189 return GetTime() - GetStartupTime();
190}
191 };
192}
193
195{
196 return RPCHelpMan{
197 "getrpcinfo",
198 "Returns details of the RPC server.\n",
199 {},
200 RPCResult{
201 RPCResult::Type::OBJ, "", "",
202 {
203 {RPCResult::Type::ARR, "active_commands", "All active commands",
204 {
205 {RPCResult::Type::OBJ, "", "Information about an active command",
206 {
207 {RPCResult::Type::STR, "method", "The name of the RPC command"},
208 {RPCResult::Type::NUM, "duration", "The running time in microseconds"},
209 }},
210 }},
211 {RPCResult::Type::STR, "logpath", "The complete file path to the debug log"},
212 }
213 },
215 HelpExampleCli("getrpcinfo", "")
216 + HelpExampleRpc("getrpcinfo", "")},
217 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
218{
220 UniValue active_commands(UniValue::VARR);
221 for (const RPCCommandExecutionInfo& info : g_rpc_server_info.active_commands) {
223 entry.pushKV("method", info.method);
224 entry.pushKV("duration", int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - info.start)});
225 active_commands.push_back(std::move(entry));
226 }
227
228 UniValue result(UniValue::VOBJ);
229 result.pushKV("active_commands", std::move(active_commands));
230
231 const std::string path = LogInstance().m_file_path.utf8string();
232 UniValue log_path(UniValue::VSTR, path);
233 result.pushKV("logpath", std::move(log_path));
234
235 return result;
236}
237 };
238}
239
241 /* Overall control/query calls */
242 {"control", &getrpcinfo},
243 {"control", &help},
244 {"control", &stop},
245 {"control", &uptime},
246};
247
249{
250 for (const auto& c : vRPCCommands) {
251 appendCommand(c.name, &c);
252 }
253}
254
255void CRPCTable::appendCommand(const std::string& name, const CRPCCommand* pcmd)
256{
257 CHECK_NONFATAL(!IsRPCRunning()); // Only add commands before rpc is running
258
259 mapCommands[name].push_back(pcmd);
260}
261
262bool CRPCTable::removeCommand(const std::string& name, const CRPCCommand* pcmd)
263{
264 auto it = mapCommands.find(name);
265 if (it != mapCommands.end()) {
266 auto new_end = std::remove(it->second.begin(), it->second.end(), pcmd);
267 if (it->second.end() != new_end) {
268 it->second.erase(new_end, it->second.end());
269 return true;
270 }
271 }
272 return false;
273}
274
276{
277 LogDebug(BCLog::RPC, "Starting RPC\n");
278 g_rpc_running = true;
279}
280
282{
283 static std::once_flag g_rpc_interrupt_flag;
284 // This function could be called twice if the GUI has been started with -server=1.
285 std::call_once(g_rpc_interrupt_flag, []() {
286 LogDebug(BCLog::RPC, "Interrupting RPC\n");
287 // Interrupt e.g. running longpolls
288 g_rpc_running = false;
289 });
290}
291
293{
294 static std::once_flag g_rpc_stop_flag;
295 // This function could be called twice if the GUI has been started with -server=1.
297 std::call_once(g_rpc_stop_flag, [&]() {
298 LogDebug(BCLog::RPC, "Stopping RPC\n");
300 LogDebug(BCLog::RPC, "RPC stopped.\n");
301 });
302}
303
305{
306 return g_rpc_running;
307}
308
310{
311 if (!IsRPCRunning()) throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
312}
313
314void SetRPCWarmupStatus(const std::string& newStatus)
315{
317 rpcWarmupStatus = newStatus;
318}
319
321{
323 fRPCInWarmup = true;
324}
325
327{
329 assert(fRPCInWarmup);
330 fRPCInWarmup = false;
331}
332
333bool RPCIsInWarmup(std::string *outStatus)
334{
336 if (outStatus)
337 *outStatus = rpcWarmupStatus;
338 return fRPCInWarmup;
339}
340
341bool IsDeprecatedRPCEnabled(const std::string& method)
342{
343 const std::vector<std::string> enabled_methods = gArgs.GetArgs("-deprecatedrpc");
344
345 return find(enabled_methods.begin(), enabled_methods.end(), method) != enabled_methods.end();
346}
347
348UniValue JSONRPCExec(const JSONRPCRequest& jreq, bool catch_errors)
349{
350 UniValue result;
351 if (catch_errors) {
352 try {
353 result = tableRPC.execute(jreq);
354 } catch (UniValue& e) {
355 return JSONRPCReplyObj(NullUniValue, std::move(e), jreq.id, jreq.m_json_version);
356 } catch (const std::exception& e) {
358 }
359 } else {
360 result = tableRPC.execute(jreq);
361 }
362
363 return JSONRPCReplyObj(std::move(result), NullUniValue, jreq.id, jreq.m_json_version);
364}
365
370static inline JSONRPCRequest transformNamedArguments(const JSONRPCRequest& in, const std::vector<std::pair<std::string, bool>>& argNames)
371{
372 JSONRPCRequest out = in;
373 out.params = UniValue(UniValue::VARR);
374 // Build a map of parameters, and remove ones that have been processed, so that we can throw a focused error if
375 // there is an unknown one.
376 const std::vector<std::string>& keys = in.params.getKeys();
377 const std::vector<UniValue>& values = in.params.getValues();
378 std::unordered_map<std::string, const UniValue*> argsIn;
379 for (size_t i=0; i<keys.size(); ++i) {
380 auto [_, inserted] = argsIn.emplace(keys[i], &values[i]);
381 if (!inserted) {
382 throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + keys[i] + " specified multiple times");
383 }
384 }
385 // Process expected parameters. If any parameters were left unspecified in
386 // the request before a parameter that was specified, null values need to be
387 // inserted at the unspecified parameter positions, and the "hole" variable
388 // below tracks the number of null values that need to be inserted.
389 // The "initial_hole_size" variable stores the size of the initial hole,
390 // i.e. how many initial positional arguments were left unspecified. This is
391 // used after the for-loop to add initial positional arguments from the
392 // "args" parameter, if present.
393 int hole = 0;
394 int initial_hole_size = 0;
395 const std::string* initial_param = nullptr;
396 UniValue options{UniValue::VOBJ};
397 for (const auto& [argNamePattern, named_only]: argNames) {
398 std::vector<std::string> vargNames = SplitString(argNamePattern, '|');
399 auto fr = argsIn.end();
400 for (const std::string & argName : vargNames) {
401 fr = argsIn.find(argName);
402 if (fr != argsIn.end()) {
403 break;
404 }
405 }
406
407 // Handle named-only parameters by pushing them into a temporary options
408 // object, and then pushing the accumulated options as the next
409 // positional argument.
410 if (named_only) {
411 if (fr != argsIn.end()) {
412 if (options.exists(fr->first)) {
413 throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + fr->first + " specified multiple times");
414 }
415 options.pushKVEnd(fr->first, *fr->second);
416 argsIn.erase(fr);
417 }
418 continue;
419 }
420
421 if (!options.empty() || fr != argsIn.end()) {
422 for (int i = 0; i < hole; ++i) {
423 // Fill hole between specified parameters with JSON nulls,
424 // but not at the end (for backwards compatibility with calls
425 // that act based on number of specified parameters).
426 out.params.push_back(UniValue());
427 }
428 hole = 0;
429 if (!initial_param) initial_param = &argNamePattern;
430 } else {
431 hole += 1;
432 if (out.params.empty()) initial_hole_size = hole;
433 }
434
435 // If named input parameter "fr" is present, push it onto out.params. If
436 // options are present, push them onto out.params. If both are present,
437 // throw an error.
438 if (fr != argsIn.end()) {
439 if (!options.empty()) {
440 throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + fr->first + " conflicts with parameter " + options.getKeys().front());
441 }
442 out.params.push_back(*fr->second);
443 argsIn.erase(fr);
444 }
445 if (!options.empty()) {
446 out.params.push_back(std::move(options));
447 options = UniValue{UniValue::VOBJ};
448 }
449 }
450 // If leftover "args" param was found, use it as a source of positional
451 // arguments and add named arguments after. This is a convenience for
452 // clients that want to pass a combination of named and positional
453 // arguments as described in doc/JSON-RPC-interface.md#parameter-passing
454 auto positional_args{argsIn.extract("args")};
455 if (positional_args && positional_args.mapped()->isArray()) {
456 if (initial_hole_size < (int)positional_args.mapped()->size() && initial_param) {
457 throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + *initial_param + " specified twice both as positional and named argument");
458 }
459 // Assign positional_args to out.params and append named_args after.
460 UniValue named_args{std::move(out.params)};
461 out.params = *positional_args.mapped();
462 for (size_t i{out.params.size()}; i < named_args.size(); ++i) {
463 out.params.push_back(named_args[i]);
464 }
465 }
466 // If there are still arguments in the argsIn map, this is an error.
467 if (!argsIn.empty()) {
468 throw JSONRPCError(RPC_INVALID_PARAMETER, "Unknown named parameter " + argsIn.begin()->first);
469 }
470 // Return request with named arguments transformed to positional arguments
471 return out;
472}
473
474static bool ExecuteCommands(const std::vector<const CRPCCommand*>& commands, const JSONRPCRequest& request, UniValue& result)
475{
476 for (const auto& command : commands) {
477 if (ExecuteCommand(*command, request, result, &command == &commands.back())) {
478 return true;
479 }
480 }
481 return false;
482}
483
485{
486 // Return immediately if in warmup
487 {
489 if (fRPCInWarmup)
490 throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
491 }
492
493 // Find method
494 auto it = mapCommands.find(request.strMethod);
495 if (it != mapCommands.end()) {
496 UniValue result;
497 if (ExecuteCommands(it->second, request, result)) {
498 return result;
499 }
500 }
501 throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
502}
503
504static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& request, UniValue& result, bool last_handler)
505{
506 try {
507 RPCCommandExecution execution(request.strMethod);
508 // Execute, convert arguments to array if necessary
509 if (request.params.isObject()) {
510 return command.actor(transformNamedArguments(request, command.argNames), result, last_handler);
511 } else {
512 return command.actor(request, result, last_handler);
513 }
514 } catch (const UniValue::type_error& e) {
515 throw JSONRPCError(RPC_TYPE_ERROR, e.what());
516 } catch (const std::exception& e) {
517 throw JSONRPCError(RPC_MISC_ERROR, e.what());
518 }
519}
520
521std::vector<std::string> CRPCTable::listCommands() const
522{
523 std::vector<std::string> commandList;
524 commandList.reserve(mapCommands.size());
525 for (const auto& i : mapCommands) commandList.emplace_back(i.first);
526 return commandList;
527}
528
530{
531 JSONRPCRequest request = args_request;
533
535 for (const auto& cmd : mapCommands) {
536 UniValue result;
537 if (ExecuteCommands(cmd.second, request, result)) {
538 for (const auto& values : result.getValues()) {
539 ret.push_back(values);
540 }
541 }
542 }
543 return ret;
544}
545
ArgsManager gArgs
Definition: args.cpp:42
int ret
const auto cmd
const auto command
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
Definition: args.cpp:362
fs::path m_file_path
Definition: logging.h:230
RPC command dispatcher.
Definition: server.h:87
CRPCTable()
Definition: server.cpp:248
std::map< std::string, std::vector< const CRPCCommand * > > mapCommands
Definition: server.h:89
bool removeCommand(const std::string &name, const CRPCCommand *pcmd)
Definition: server.cpp:262
std::vector< std::string > listCommands() const
Returns a list of registered commands.
Definition: server.cpp:521
UniValue execute(const JSONRPCRequest &request) const
Execute a method.
Definition: server.cpp:484
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Definition: server.cpp:255
std::string help(const std::string &name, const JSONRPCRequest &helpreq) const
Definition: server.cpp:68
UniValue dumpArgMap(const JSONRPCRequest &request) const
Return all named arguments that need to be converted by the client from string to another JSON type.
Definition: server.cpp:529
Different type to mark Mutex at global scope.
Definition: sync.h:135
UniValue params
Definition: request.h:57
std::string strMethod
Definition: request.h:56
JSONRPCVersion m_json_version
Definition: request.h:63
enum JSONRPCRequest::Mode mode
std::optional< UniValue > id
Definition: request.h:55
void push_back(UniValue val)
Definition: univalue.cpp:104
const std::string & get_str() const
@ VOBJ
Definition: univalue.h:24
@ VSTR
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
const std::vector< UniValue > & getValues() const
const std::vector< std::string > & getKeys() const
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
bool isObject() const
Definition: univalue.h:88
int64_t GetStartupTime()
Definition: system.cpp:109
BCLog::Logger & LogInstance()
Definition: logging.cpp:26
#define LogDebug(category,...)
Definition: logging.h:381
@ RPC
Definition: logging.h:73
std::vector< std::string > SplitString(std::string_view str, char sep)
Definition: string.h:148
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
UniValue JSONRPCReplyObj(UniValue result, UniValue error, std::optional< UniValue > id, JSONRPCVersion jsonrpc_version)
Definition: request.cpp:51
void DeleteAuthCookie()
Delete RPC authentication cookie from disk.
Definition: request.cpp:167
const char * name
Definition: rest.cpp:50
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_METHOD_NOT_FOUND
Definition: protocol.h:32
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
Definition: protocol.h:41
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors.
Definition: protocol.h:58
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_IN_WARMUP
Client still warming up.
Definition: protocol.h:50
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:186
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:204
static const int64_t values[]
A selection of numbers that do not trigger int64_t overflow when added/subtracted.
bool IsDeprecatedRPCEnabled(const std::string &method)
Definition: server.cpp:341
void SetRPCWarmupFinished()
Definition: server.cpp:326
static RPCHelpMan uptime()
Definition: server.cpp:174
void StartRPC()
Definition: server.cpp:275
static RPCHelpMan getrpcinfo()
Definition: server.cpp:194
static bool ExecuteCommands(const std::vector< const CRPCCommand * > &commands, const JSONRPCRequest &request, UniValue &result)
Definition: server.cpp:474
bool RPCIsInWarmup(std::string *outStatus)
Definition: server.cpp:333
static bool ExecuteCommand(const CRPCCommand &command, const JSONRPCRequest &request, UniValue &result, bool last_handler)
Definition: server.cpp:504
void StopRPC()
Definition: server.cpp:292
static RPCHelpMan stop()
Definition: server.cpp:147
static std::atomic< bool > g_rpc_running
Definition: server.cpp:34
static JSONRPCRequest transformNamedArguments(const JSONRPCRequest &in, const std::vector< std::pair< std::string, bool > > &argNames)
Process named arguments into a vector of positional arguments, based on the passed-in specification f...
Definition: server.cpp:370
bool IsRPCRunning()
Query whether RPC is running.
Definition: server.cpp:304
void SetRPCWarmupStarting()
Definition: server.cpp:320
void InterruptRPC()
Definition: server.cpp:281
UniValue JSONRPCExec(const JSONRPCRequest &jreq, bool catch_errors)
Definition: server.cpp:348
static bool fRPCInWarmup GUARDED_BY(g_rpc_warmup_mutex)
static GlobalMutex g_rpc_warmup_mutex
Definition: server.cpp:33
static RPCHelpMan help()
Definition: server.cpp:118
static RPCServerInfo g_rpc_server_info
Definition: server.cpp:51
static const CRPCCommand vRPCCommands[]
Definition: server.cpp:240
void SetRPCWarmupStatus(const std::string &newStatus)
Set the RPC warmup status.
Definition: server.cpp:314
CRPCTable tableRPC
Definition: server.cpp:546
void RpcInterruptionPoint()
Throw JSONRPCError if RPC is not running.
Definition: server.cpp:309
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:25
std::string DefaultHint
Hint for default value.
Definition: util.h:220
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
bool hidden
For testing only.
Definition: util.h:173
RPCCommandExecution(const std::string &method)
Definition: server.cpp:56
std::list< RPCCommandExecutionInfo >::iterator it
Definition: server.cpp:55
SteadyClock::time_point start
Definition: server.cpp:42
std::string method
Definition: server.cpp:41
@ ANY
Special type to disable type checks (for testing only)
std::list< RPCCommandExecutionInfo > active_commands GUARDED_BY(mutex)
Mutex mutex
Definition: server.cpp:47
#define LOCK(cs)
Definition: sync.h:259
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
consteval auto _(util::TranslatedLiteral str)
Definition: translation.h:79
const UniValue NullUniValue
Definition: univalue.cpp:16
std::string Capitalize(std::string str)
Capitalizes the first character of the given string.
void UninterruptibleSleep(const std::chrono::microseconds &n)
Definition: time.cpp:20
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
Definition: time.cpp:77
assert(!tx.IsCoinBase())