Bitcoin ABC  0.28.12
P2P Digital Currency
protocol.h
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2019 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 #ifndef BITCOIN_PROTOCOL_H
7 #define BITCOIN_PROTOCOL_H
8 
9 #include <netaddress.h>
10 #include <serialize.h>
11 #include <streams.h>
12 #include <uint256.h>
13 #include <util/time.h>
14 
15 #include <array>
16 #include <cstdint>
17 #include <string>
18 
19 class Config;
20 
25 static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 2 * 1024 * 1024;
26 
35 public:
36  static constexpr size_t MESSAGE_START_SIZE = 4;
37  static constexpr size_t COMMAND_SIZE = 12;
38  static constexpr size_t MESSAGE_SIZE_SIZE = 4;
39  static constexpr size_t CHECKSUM_SIZE = 4;
40  static constexpr size_t MESSAGE_SIZE_OFFSET =
42  static constexpr size_t CHECKSUM_OFFSET =
44  static constexpr size_t HEADER_SIZE =
46  typedef std::array<uint8_t, MESSAGE_START_SIZE> MessageMagic;
47 
48  explicit CMessageHeader(const MessageMagic &pchMessageStartIn);
49 
56  CMessageHeader(const MessageMagic &pchMessageStartIn,
57  const char *pszCommand, unsigned int nMessageSizeIn);
58 
59  std::string GetCommand() const;
60  bool IsValid(const Config &config) const;
61  bool IsValidWithoutConfig(const MessageMagic &magic) const;
62  bool IsOversized(const Config &config) const;
63 
65  READWRITE(obj.pchMessageStart, obj.pchCommand, obj.nMessageSize,
66  obj.pchChecksum);
67  }
68 
70  std::array<char, COMMAND_SIZE> pchCommand;
71  uint32_t nMessageSize;
73 };
74 
79 namespace NetMsgType {
80 
85 extern const char *VERSION;
90 extern const char *VERACK;
95 extern const char *ADDR;
101 extern const char *ADDRV2;
108 extern const char *SENDADDRV2;
113 extern const char *INV;
117 extern const char *GETDATA;
123 extern const char *MERKLEBLOCK;
128 extern const char *GETBLOCKS;
134 extern const char *GETHEADERS;
138 extern const char *TX;
144 extern const char *HEADERS;
148 extern const char *BLOCK;
153 extern const char *GETADDR;
159 extern const char *MEMPOOL;
164 extern const char *PING;
170 extern const char *PONG;
176 extern const char *NOTFOUND;
184 extern const char *FILTERLOAD;
192 extern const char *FILTERADD;
200 extern const char *FILTERCLEAR;
206 extern const char *SENDHEADERS;
212 extern const char *FEEFILTER;
220 extern const char *SENDCMPCT;
226 extern const char *CMPCTBLOCK;
232 extern const char *GETBLOCKTXN;
238 extern const char *BLOCKTXN;
244 extern const char *GETCFILTERS;
249 extern const char *CFILTER;
257 extern const char *GETCFHEADERS;
263 extern const char *CFHEADERS;
270 extern const char *GETCFCHECKPT;
275 extern const char *CFCHECKPT;
279 extern const char *AVAHELLO;
284 extern const char *AVAPOLL;
289 extern const char *AVARESPONSE;
295 extern const char *AVAPROOF;
296 
301 extern const char *GETAVAADDR;
302 
307 extern const char *GETAVAPROOFS;
308 
313 extern const char *AVAPROOFS;
314 
319 extern const char *AVAPROOFSREQ;
320 
326 bool IsBlockLike(const std::string &strCommand);
327 }; // namespace NetMsgType
328 
330 const std::vector<std::string> &getAllNetMessageTypes();
331 
335 enum ServiceFlags : uint64_t {
336  // NOTE: When adding here, be sure to update serviceFlagToStr too
337  // Nothing
339  // NODE_NETWORK means that the node is capable of serving the complete block
340  // chain. It is currently set by all Bitcoin ABC non pruned nodes, and is
341  // unset by SPV clients or other light clients.
342  NODE_NETWORK = (1 << 0),
343  // NODE_GETUTXO means the node is capable of responding to the getutxo
344  // protocol request. Bitcoin ABC does not support this but a patch set
345  // called Bitcoin XT does. See BIP 64 for details on how this is
346  // implemented.
347  NODE_GETUTXO = (1 << 1),
348  // NODE_BLOOM means the node is capable and willing to handle bloom-filtered
349  // connections. Bitcoin ABC nodes used to support this by default, without
350  // advertising this bit, but no longer do as of protocol version 70011 (=
351  // NO_BLOOM_VERSION)
352  NODE_BLOOM = (1 << 2),
353  // Bit 4 was NODE_XTHIN, removed in v0.22.12
354 
355  // Bit 5 was NODE_BITCOIN_CASH, removed in v0.22.8
356 
357  // NODE_COMPACT_FILTERS means the node will service basic block filter
358  // requests.
359  // See BIP157 and BIP158 for details on how this is implemented.
361 
362  // NODE_NETWORK_LIMITED means the same as NODE_NETWORK with the limitation
363  // of only serving the last 288 (2 day) blocks
364  // See BIP159 for details on how this is implemented.
365  NODE_NETWORK_LIMITED = (1 << 10),
366 
367  // The last non experimental service bit, helper for looping over the flags
369 
370  // Bits 24-31 are reserved for temporary experiments. Just pick a bit that
371  // isn't getting used, or one not being used much, and notify the
372  // bitcoin-development mailing list. Remember that service bits are just
373  // unauthenticated advertisements, so your code must be robust against
374  // collisions and other cases where nodes may be advertising a service they
375  // do not actually support. Other service bits should be allocated via the
376  // BIP process.
377 
378  // NODE_AVALANCHE means the node supports Bitcoin Cash's avalanche
379  // preconsensus mechanism.
380  NODE_AVALANCHE = (1 << 24),
381 };
382 
388 std::vector<std::string> serviceFlagsToStr(const uint64_t flags);
389 
415 
420 void SetServiceFlagsIBDCache(bool status);
421 
427 static inline bool HasAllDesirableServiceFlags(ServiceFlags services) {
428  return !(GetDesirableServiceFlags(services) & (~services));
429 }
430 
435 static inline bool MayHaveUsefulAddressDB(ServiceFlags services) {
436  return (services & NODE_NETWORK) || (services & NODE_NETWORK_LIMITED);
437 }
438 
442 class CAddress : public CService {
443  static constexpr auto TIME_INIT{100000000s};
444 
464  static constexpr uint32_t DISK_VERSION_INIT{220000};
465  static constexpr uint32_t DISK_VERSION_IGNORE_MASK{
466  0b00000000'00000111'11111111'11111111};
473  static constexpr uint32_t DISK_VERSION_ADDRV2{1 << 29};
474  static_assert(
476  "DISK_VERSION_INIT must be covered by DISK_VERSION_IGNORE_MASK");
477  static_assert(
479  "DISK_VERSION_ADDRV2 must not be covered by DISK_VERSION_IGNORE_MASK");
480 
481 public:
482  CAddress() : CService{} {};
483  CAddress(CService ipIn, ServiceFlags nServicesIn)
484  : CService{ipIn}, nServices{nServicesIn} {};
485  CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time)
486  : CService{ipIn}, nTime{time}, nServices{nServicesIn} {};
487 
489  // CAddress has a distinct network serialization and a disk
490  // serialization, but it should never be hashed (except through
491  // CHashWriter in addrdb.cpp, which sets SER_DISK), and it's ambiguous
492  // what that would mean. Make sure no code relying on that is
493  // introduced:
494  assert(!(s.GetType() & SER_GETHASH));
495  bool use_v2;
496  if (s.GetType() & SER_DISK) {
497  // In the disk serialization format, the encoding (v1 or v2) is
498  // determined by a flag version that's part of the serialization
499  // itself. ADDRV2_FORMAT in the stream version only determines
500  // whether V2 is chosen/permitted at all.
501  uint32_t stored_format_version = DISK_VERSION_INIT;
502  if (s.GetVersion() & ADDRV2_FORMAT) {
503  stored_format_version |= DISK_VERSION_ADDRV2;
504  }
505  READWRITE(stored_format_version);
506  stored_format_version &=
507  ~DISK_VERSION_IGNORE_MASK; // ignore low bits
508  if (stored_format_version == 0) {
509  use_v2 = false;
510  } else if (stored_format_version == DISK_VERSION_ADDRV2 &&
511  (s.GetVersion() & ADDRV2_FORMAT)) {
512  // Only support v2 deserialization if ADDRV2_FORMAT is set.
513  use_v2 = true;
514  } else {
515  throw std::ios_base::failure(
516  "Unsupported CAddress disk format version");
517  }
518  } else {
519  // In the network serialization format, the encoding (v1 or v2) is
520  // determined directly by the value of ADDRV2_FORMAT in the stream
521  // version, as no explicitly encoded version exists in the stream.
522  assert(s.GetType() & SER_NETWORK);
523  use_v2 = s.GetVersion() & ADDRV2_FORMAT;
524  }
525 
527  // nServices is serialized as CompactSize in V2; as uint64_t in V1.
528  if (use_v2) {
529  uint64_t services_tmp;
530  SER_WRITE(obj, services_tmp = obj.nServices);
532  SER_READ(obj,
533  obj.nServices = static_cast<ServiceFlags>(services_tmp));
534  } else {
535  READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
536  }
537  // Invoke V1/V2 serializer for CService parent object.
538  OverrideStream<Stream> os(&s, s.GetType(), use_v2 ? ADDRV2_FORMAT : 0);
539  SerReadWriteMany(os, ser_action, ReadWriteAsHelper<CService>(obj));
540  }
541 
547 
548  friend bool operator==(const CAddress &a, const CAddress &b) {
549  return a.nTime == b.nTime && a.nServices == b.nServices &&
550  static_cast<const CService &>(a) ==
551  static_cast<const CService &>(b);
552  }
553 };
554 
556 const uint32_t MSG_TYPE_MASK = 0xffffffff >> 3;
557 
565  MSG_TX = 1,
567  // The following can only occur in getdata. Invs always use TX or BLOCK.
572  MSG_AVA_PROOF = 0x1f000001,
573 };
574 
580 class CInv {
581 public:
582  uint32_t type;
584 
585  CInv() : type(0), hash() {}
586  CInv(uint32_t typeIn, const uint256 &hashIn) : type(typeIn), hash(hashIn) {}
587 
588  SERIALIZE_METHODS(CInv, obj) { READWRITE(obj.type, obj.hash); }
589 
590  friend bool operator<(const CInv &a, const CInv &b) {
591  return a.type < b.type || (a.type == b.type && a.hash < b.hash);
592  }
593 
594  std::string GetCommand() const;
595  std::string ToString() const;
596 
597  uint32_t GetKind() const { return type & MSG_TYPE_MASK; }
598 
599  bool IsMsgTx() const {
600  auto k = GetKind();
601  return k == MSG_TX;
602  }
603  bool IsMsgProof() const {
604  auto k = GetKind();
605  return k == MSG_AVA_PROOF;
606  }
607  bool IsMsgBlk() const {
608  auto k = GetKind();
609  return k == MSG_BLOCK;
610  }
611  bool IsMsgFilteredBlk() const {
612  auto k = GetKind();
613  return k == MSG_FILTERED_BLOCK;
614  }
615  bool IsMsgCmpctBlk() const {
616  auto k = GetKind();
617  return k == MSG_CMPCT_BLOCK;
618  }
619 
620  bool IsGenBlkMsg() const {
621  auto k = GetKind();
622  return k == MSG_BLOCK || k == MSG_FILTERED_BLOCK ||
623  k == MSG_CMPCT_BLOCK;
624  }
625 };
626 
627 #endif // BITCOIN_PROTOCOL_H
int flags
Definition: bitcoin-tx.cpp:533
A CService with information about it as peer.
Definition: protocol.h:442
static constexpr uint32_t DISK_VERSION_IGNORE_MASK
Definition: protocol.h:465
SERIALIZE_METHODS(CAddress, obj)
Definition: protocol.h:488
CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time)
Definition: protocol.h:485
ServiceFlags nServices
Serialized as uint64_t in V1, and as CompactSize in V2.
Definition: protocol.h:546
NodeSeconds nTime
Always included in serialization, except in the network format on INIT_PROTO_VERSION.
Definition: protocol.h:544
static constexpr uint32_t DISK_VERSION_INIT
Historically, CAddress disk serialization stored the CLIENT_VERSION, optionally OR'ed with the ADDRV2...
Definition: protocol.h:464
CAddress()
Definition: protocol.h:482
friend bool operator==(const CAddress &a, const CAddress &b)
Definition: protocol.h:548
static constexpr auto TIME_INIT
Definition: protocol.h:443
CAddress(CService ipIn, ServiceFlags nServicesIn)
Definition: protocol.h:483
static constexpr uint32_t DISK_VERSION_ADDRV2
The version number written in disk serialized addresses to indicate V2 serializations.
Definition: protocol.h:473
Inv(ventory) message data.
Definition: protocol.h:580
bool IsMsgCmpctBlk() const
Definition: protocol.h:615
friend bool operator<(const CInv &a, const CInv &b)
Definition: protocol.h:590
uint32_t GetKind() const
Definition: protocol.h:597
bool IsMsgBlk() const
Definition: protocol.h:607
std::string ToString() const
Definition: protocol.cpp:238
std::string GetCommand() const
Definition: protocol.cpp:219
CInv()
Definition: protocol.h:585
uint32_t type
Definition: protocol.h:582
CInv(uint32_t typeIn, const uint256 &hashIn)
Definition: protocol.h:586
bool IsMsgTx() const
Definition: protocol.h:599
bool IsMsgFilteredBlk() const
Definition: protocol.h:611
uint256 hash
Definition: protocol.h:583
bool IsMsgProof() const
Definition: protocol.h:603
SERIALIZE_METHODS(CInv, obj)
Definition: protocol.h:588
bool IsGenBlkMsg() const
Definition: protocol.h:620
Message header.
Definition: protocol.h:34
static constexpr size_t MESSAGE_SIZE_OFFSET
Definition: protocol.h:40
static constexpr size_t CHECKSUM_OFFSET
Definition: protocol.h:42
bool IsValidWithoutConfig(const MessageMagic &magic) const
This is a transition method in order to stay compatible with older code that do not use the config.
Definition: protocol.cpp:174
bool IsValid(const Config &config) const
Definition: protocol.cpp:150
std::array< char, COMMAND_SIZE > pchCommand
Definition: protocol.h:70
static constexpr size_t CHECKSUM_SIZE
Definition: protocol.h:39
MessageMagic pchMessageStart
Definition: protocol.h:69
static constexpr size_t MESSAGE_SIZE_SIZE
Definition: protocol.h:38
bool IsOversized(const Config &config) const
Definition: protocol.cpp:191
static constexpr size_t HEADER_SIZE
Definition: protocol.h:44
uint8_t pchChecksum[CHECKSUM_SIZE]
Definition: protocol.h:72
static constexpr size_t MESSAGE_START_SIZE
Definition: protocol.h:36
std::string GetCommand() const
Definition: protocol.cpp:115
CMessageHeader(const MessageMagic &pchMessageStartIn)
Definition: protocol.cpp:87
SERIALIZE_METHODS(CMessageHeader, obj)
Definition: protocol.h:64
static constexpr size_t COMMAND_SIZE
Definition: protocol.h:37
uint32_t nMessageSize
Definition: protocol.h:71
std::array< uint8_t, MESSAGE_START_SIZE > MessageMagic
Definition: protocol.h:46
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:545
Definition: config.h:17
256-bit opaque blob.
Definition: uint256.h:127
Bitcoin protocol message types.
Definition: protocol.cpp:16
bool IsBlockLike(const std::string &strCommand)
Indicate if the message is used to transmit the content of a block.
Definition: protocol.cpp:59
const char * FILTERLOAD
The filterload message tells the receiving peer to filter all relayed transactions and requested merk...
Definition: protocol.cpp:35
const char * CFHEADERS
cfheaders is a response to a getcfheaders request containing a filter header and a vector of filter h...
Definition: protocol.cpp:47
const char * AVAPROOFSREQ
Request for missing avalanche proofs after an avaproofs message has been processed.
Definition: protocol.cpp:57
const char * CFILTER
cfilter is a response to a getcfilters request containing a single compact filter.
Definition: protocol.cpp:45
const char * BLOCK
The block message transmits a single serialized block.
Definition: protocol.cpp:29
const char * FILTERCLEAR
The filterclear message tells the receiving peer to remove a previously-set bloom filter.
Definition: protocol.cpp:37
const char * HEADERS
The headers message sends one or more block headers to a node which previously requested certain head...
Definition: protocol.cpp:28
const char * ADDRV2
The addrv2 message relays connection information for peers on the network just like the addr message,...
Definition: protocol.cpp:20
const char * SENDHEADERS
Indicates that a node prefers to receive new block announcements via a "headers" message rather than ...
Definition: protocol.cpp:38
const char * AVAPROOFS
The avaproofs message the proof short ids of all the valid proofs that we know.
Definition: protocol.cpp:56
const char * PONG
The pong message replies to a ping message, proving to the pinging node that the ponging node is stil...
Definition: protocol.cpp:33
const char * GETAVAPROOFS
The getavaproofs message requests an avaproofs message that provides the proof short ids of all the v...
Definition: protocol.cpp:55
const char * SENDCMPCT
Contains a 1-byte bool and 8-byte LE version number.
Definition: protocol.cpp:40
const char * GETADDR
The getaddr message requests an addr message from the receiving node, preferably one with lots of IP ...
Definition: protocol.cpp:30
const char * GETCFCHECKPT
getcfcheckpt requests evenly spaced compact filter headers, enabling parallelized download and valida...
Definition: protocol.cpp:48
const char * NOTFOUND
The notfound message is a reply to a getdata message which requested an object the receiving node doe...
Definition: protocol.cpp:34
const char * GETAVAADDR
The getavaaddr message requests an addr message from the receiving node, containing IP addresses of t...
Definition: protocol.cpp:54
const char * CMPCTBLOCK
Contains a CBlockHeaderAndShortTxIDs object - providing a header and list of "short txids".
Definition: protocol.cpp:41
const char * MEMPOOL
The mempool message requests the TXIDs of transactions that the receiving node has verified as valid ...
Definition: protocol.cpp:31
const char * GETCFILTERS
getcfilters requests compact filters for a range of blocks.
Definition: protocol.cpp:44
const char * TX
The tx message transmits a single transaction.
Definition: protocol.cpp:27
const char * AVAHELLO
Contains a delegation and a signature.
Definition: protocol.cpp:50
const char * FILTERADD
The filteradd message tells the receiving peer to add a single element to a previously-set bloom filt...
Definition: protocol.cpp:36
const char * ADDR
The addr (IP address) message relays connection information for peers on the network.
Definition: protocol.cpp:19
const char * VERSION
The version message provides information about the transmitting node to the receiving node at the beg...
Definition: protocol.cpp:17
const char * GETBLOCKS
The getblocks message requests an inv message that provides block header hashes starting from a parti...
Definition: protocol.cpp:25
const char * FEEFILTER
The feefilter message tells the receiving peer not to inv us any txs which do not meet the specified ...
Definition: protocol.cpp:39
const char * GETHEADERS
The getheaders message requests a headers message that provides block headers starting from a particu...
Definition: protocol.cpp:26
const char * AVARESPONSE
Contains an avalanche::Response.
Definition: protocol.cpp:52
const char * GETDATA
The getdata message requests one or more data objects from another node.
Definition: protocol.cpp:23
const char * VERACK
The verack message acknowledges a previously-received version message, informing the connecting node ...
Definition: protocol.cpp:18
const char * BLOCKTXN
Contains a BlockTransactions.
Definition: protocol.cpp:43
const char * GETCFHEADERS
getcfheaders requests a compact filter header and the filter hashes for a range of blocks,...
Definition: protocol.cpp:46
const char * SENDADDRV2
The sendaddrv2 message signals support for receiving ADDRV2 messages (BIP155).
Definition: protocol.cpp:21
const char * PING
The ping message is sent periodically to help confirm that the receiving peer is still connected.
Definition: protocol.cpp:32
const char * AVAPOLL
Contains an avalanche::Poll.
Definition: protocol.cpp:51
const char * MERKLEBLOCK
The merkleblock message is a reply to a getdata message which requested a block using the inventory t...
Definition: protocol.cpp:24
const char * AVAPROOF
Contains an avalanche::Proof.
Definition: protocol.cpp:53
const char * CFCHECKPT
cfcheckpt is a response to a getcfcheckpt request containing a vector of evenly spaced filter headers...
Definition: protocol.cpp:49
const char * GETBLOCKTXN
Contains a BlockTransactionsRequest Peer should respond with "blocktxn" message.
Definition: protocol.cpp:42
const char * INV
The inv message (inventory message) transmits one or more inventories of objects known to the transmi...
Definition: protocol.cpp:22
static constexpr int ADDRV2_FORMAT
A flag that is ORed into the protocol version to designate that addresses should be serialized in (un...
Definition: netaddress.h:33
ServiceFlags GetDesirableServiceFlags(ServiceFlags services)
Gets the set of service flags which are "desirable" for a given peer.
Definition: protocol.cpp:207
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH
Maximum length of incoming protocol messages (Currently 2MB).
Definition: protocol.h:25
const std::vector< std::string > & getAllNetMessageTypes()
Get a vector of all valid message types (see above)
Definition: protocol.cpp:246
static bool HasAllDesirableServiceFlags(ServiceFlags services)
A shortcut for (services & GetDesirableServiceFlags(services)) == GetDesirableServiceFlags(services),...
Definition: protocol.h:427
GetDataMsg
getdata / inv message types.
Definition: protocol.h:563
@ MSG_TX
Definition: protocol.h:565
@ MSG_FILTERED_BLOCK
Defined in BIP37.
Definition: protocol.h:569
@ MSG_AVA_PROOF
Definition: protocol.h:572
@ MSG_BLOCK
Definition: protocol.h:566
@ UNDEFINED
Definition: protocol.h:564
@ MSG_CMPCT_BLOCK
Defined in BIP152.
Definition: protocol.h:571
void SetServiceFlagsIBDCache(bool status)
Set the current IBD status in order to figure out the desirable service flags.
Definition: protocol.cpp:215
const uint32_t MSG_TYPE_MASK
getdata message type flags
Definition: protocol.h:556
std::vector< std::string > serviceFlagsToStr(const uint64_t flags)
Convert service flags (a bitmask of NODE_*) to human readable strings.
Definition: protocol.cpp:283
ServiceFlags
nServices flags.
Definition: protocol.h:335
@ NODE_NONE
Definition: protocol.h:338
@ NODE_GETUTXO
Definition: protocol.h:347
@ NODE_NETWORK_LIMITED
Definition: protocol.h:365
@ NODE_BLOOM
Definition: protocol.h:352
@ NODE_NETWORK
Definition: protocol.h:342
@ NODE_LAST_NON_EXPERIMENTAL_SERVICE_BIT
Definition: protocol.h:368
@ NODE_COMPACT_FILTERS
Definition: protocol.h:360
@ NODE_AVALANCHE
Definition: protocol.h:380
static bool MayHaveUsefulAddressDB(ServiceFlags services)
Checks if a peer with the given service flags may be capable of having a robust address-storage DB.
Definition: protocol.h:435
#define SER_WRITE(obj, code)
Definition: serialize.h:187
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
Definition: serialize.h:592
@ SER_DISK
Definition: serialize.h:167
@ SER_NETWORK
Definition: serialize.h:166
@ SER_GETHASH
Definition: serialize.h:168
void SerReadWriteMany(Stream &s, CSerActionSerialize ser_action, const Args &...args)
Definition: serialize.h:1237
#define SER_READ(obj, code)
Definition: serialize.h:183
#define READWRITE(...)
Definition: serialize.h:180
Formatter for integers in CompactSize format.
Definition: serialize.h:665
Serialization wrapper class for custom integers and enums.
Definition: serialize.h:624
std::chrono::time_point< NodeClock, std::chrono::seconds > NodeSeconds
Definition: time.h:25
assert(!tx.IsCoinBase())