mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-03-05 14:06:27 -05:00
Merge bitcoin/bitcoin#20799: net processing: Only support version 2 compact blocks
a50e34c367[net processing] Remove redundant nodestate->m_sendcmpct check in MaybeSetPeerAsAnnouncingHeaderAndIDs() (John Newbery)bb985a7b6a[net processing] Only relay blocks by cmpctblock and cache for fast relay if segwit is enabled (John Newbery)3b6bfbce38[net processing] Rename CNodeState compact block members (John Newbery)d0e9774174[net processing] Tidy up `sendcmpct` processing (John Newbery)30c3a01874[net processing] fPreferHeaderAndIDs implies fProvidesHeaderAndIDs (John Newbery)b486f72176[net processing] Remove fWantsCmpctWitness (John Newbery)a45d53cab5[net processing] Remove fSupportsDesiredCmpctVersion (John Newbery)25edb2b7bd[net processing] Simplify `sendcmpct` processing (John Newbery)42882fc8fc[net processing] Only accept `sendcmpct` with version=2 (John Newbery)16730b64bb[net processing] Only advertise support for version 2 compact blocks (John Newbery)cba909eaf9[net] Stop testing version 1 compact blocks. (John Newbery) Pull request description: Compact blocks are used for efficient relay of blocks, either through High Bandwidth or Low Bandwidth mode. See [BIP 152](https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki) for full details. For compact block relay to work, the receiver must have a mempool containing transactions which are likely to be included in the block. The receiver uses these transactions to reconstruct the block from the short transaction ids included in the `cmpctblock` message. Compact blocks are therefore only useful for relaying blocks at or near the tip of the block chain. For older blocks, the recipient won't have the transactions in their mempool and so would need to request them using a `getblocktxn` message. In such cases, just requesting the full block is more efficient. BIP 152 supports two versions: version 1 (without witnesses) and version 2 (with witnesses). Version 2 is required to reconstruct segwit blocks. Segwit was activated in August 2017, and providing non-witness blocks to peers is no longer useful. Since the witnesses are not included, the peer would not be able to fully validate all the consensus rules on the provided block. Therefore, stop supporting version 1 compact blocks. Ignore `sendcmpct` messages with version=1, and don't advertise support by sending `sendcmpct` with version=1. Only send `sendcmpct` to peers with `NODE_WITNESS`. Respond to all requests for compact blocks or blocktxns with witness-serialized blocks and transactions. ACKs for top commit: dergoegge: ACKa50e34c367- Only changes since my last review were a rebase and some nits. MarcoFalke: re-ACKa50e34c367after rebase 👓 Tree-SHA512: 8ad73acaa374d56ee9f28ca0a9d64b8630793d22fc8c942a1ee15551d4d80f76f3ba937682f85f22ec8ca82efae98a92de75a7e2f5a97499d8f9c7e4f2833c86
This commit is contained in:
fanquake
commit
dc0ee57373
3 changed files with 138 additions and 230 deletions
|
|
@ -175,6 +175,8 @@ static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
|
|||
* based increments won't go above this, but the MAX_ADDR_TO_SEND increment following GETADDR
|
||||
* is exempt from this limit). */
|
||||
static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
|
||||
/** The compactblocks version we support. See BIP 152. */
|
||||
static constexpr uint64_t CMPCTBLOCKS_VERSION{2};
|
||||
|
||||
// Internal stuff
|
||||
namespace {
|
||||
|
|
@ -365,23 +367,12 @@ struct CNodeState {
|
|||
bool fPreferredDownload{false};
|
||||
//! Whether this peer wants invs or headers (when possible) for block announcements.
|
||||
bool fPreferHeaders{false};
|
||||
//! Whether this peer wants invs or cmpctblocks (when possible) for block announcements.
|
||||
bool fPreferHeaderAndIDs{false};
|
||||
/**
|
||||
* Whether this peer will send us cmpctblocks if we request them.
|
||||
* This is not used to gate request logic, as we really only care about fSupportsDesiredCmpctVersion,
|
||||
* but is used as a flag to "lock in" the version of compact blocks (fWantsCmpctWitness) we send.
|
||||
*/
|
||||
bool fProvidesHeaderAndIDs{false};
|
||||
/** Whether this peer wants invs or cmpctblocks (when possible) for block announcements. */
|
||||
bool m_requested_hb_cmpctblocks{false};
|
||||
/** Whether this peer will send us cmpctblocks if we request them. */
|
||||
bool m_provides_cmpctblocks{false};
|
||||
//! Whether this peer can give us witnesses
|
||||
bool fHaveWitness{false};
|
||||
//! Whether this peer wants witnesses in cmpctblocks/blocktxns
|
||||
bool fWantsCmpctWitness{false};
|
||||
/**
|
||||
* If we've announced NODE_WITNESS to this peer: whether the peer sends witnesses in cmpctblocks/blocktxns,
|
||||
* otherwise: whether this peer sends non-witnesses in cmpctblocks/blocktxns.
|
||||
*/
|
||||
bool fSupportsDesiredCmpctVersion{false};
|
||||
|
||||
/** State used to enforce CHAIN_SYNC_TIMEOUT and EXTRA_PEER_CHECK_INTERVAL logic.
|
||||
*
|
||||
|
|
@ -687,7 +678,6 @@ private:
|
|||
std::shared_ptr<const CBlock> m_most_recent_block GUARDED_BY(m_most_recent_block_mutex);
|
||||
std::shared_ptr<const CBlockHeaderAndShortTxIDs> m_most_recent_compact_block GUARDED_BY(m_most_recent_block_mutex);
|
||||
uint256 m_most_recent_block_hash GUARDED_BY(m_most_recent_block_mutex);
|
||||
bool m_most_recent_compact_block_has_witnesses GUARDED_BY(m_most_recent_block_mutex){false};
|
||||
|
||||
/** Height of the highest block announced using BIP 152 high-bandwidth mode. */
|
||||
int m_highest_fast_announce{0};
|
||||
|
|
@ -974,54 +964,52 @@ void PeerManagerImpl::MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid)
|
|||
if (m_ignore_incoming_txs) return;
|
||||
|
||||
CNodeState* nodestate = State(nodeid);
|
||||
if (!nodestate || !nodestate->fSupportsDesiredCmpctVersion) {
|
||||
// Never ask from peers who can't provide witnesses.
|
||||
if (!nodestate || !nodestate->m_provides_cmpctblocks) {
|
||||
// Don't request compact blocks if the peer has not signalled support
|
||||
return;
|
||||
}
|
||||
if (nodestate->fProvidesHeaderAndIDs) {
|
||||
int num_outbound_hb_peers = 0;
|
||||
for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin(); it != lNodesAnnouncingHeaderAndIDs.end(); it++) {
|
||||
if (*it == nodeid) {
|
||||
lNodesAnnouncingHeaderAndIDs.erase(it);
|
||||
lNodesAnnouncingHeaderAndIDs.push_back(nodeid);
|
||||
return;
|
||||
}
|
||||
CNodeState *state = State(*it);
|
||||
if (state != nullptr && !state->m_is_inbound) ++num_outbound_hb_peers;
|
||||
|
||||
int num_outbound_hb_peers = 0;
|
||||
for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin(); it != lNodesAnnouncingHeaderAndIDs.end(); it++) {
|
||||
if (*it == nodeid) {
|
||||
lNodesAnnouncingHeaderAndIDs.erase(it);
|
||||
lNodesAnnouncingHeaderAndIDs.push_back(nodeid);
|
||||
return;
|
||||
}
|
||||
if (nodestate->m_is_inbound) {
|
||||
// If we're adding an inbound HB peer, make sure we're not removing
|
||||
// our last outbound HB peer in the process.
|
||||
if (lNodesAnnouncingHeaderAndIDs.size() >= 3 && num_outbound_hb_peers == 1) {
|
||||
CNodeState *remove_node = State(lNodesAnnouncingHeaderAndIDs.front());
|
||||
if (remove_node != nullptr && !remove_node->m_is_inbound) {
|
||||
// Put the HB outbound peer in the second slot, so that it
|
||||
// doesn't get removed.
|
||||
std::swap(lNodesAnnouncingHeaderAndIDs.front(), *std::next(lNodesAnnouncingHeaderAndIDs.begin()));
|
||||
}
|
||||
}
|
||||
}
|
||||
m_connman.ForNode(nodeid, [this](CNode* pfrom) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
|
||||
AssertLockHeld(::cs_main);
|
||||
uint64_t nCMPCTBLOCKVersion = 2;
|
||||
if (lNodesAnnouncingHeaderAndIDs.size() >= 3) {
|
||||
// As per BIP152, we only get 3 of our peers to announce
|
||||
// blocks using compact encodings.
|
||||
m_connman.ForNode(lNodesAnnouncingHeaderAndIDs.front(), [this, nCMPCTBLOCKVersion](CNode* pnodeStop){
|
||||
m_connman.PushMessage(pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion()).Make(NetMsgType::SENDCMPCT, /*fAnnounceUsingCMPCTBLOCK=*/false, nCMPCTBLOCKVersion));
|
||||
// save BIP152 bandwidth state: we select peer to be low-bandwidth
|
||||
pnodeStop->m_bip152_highbandwidth_to = false;
|
||||
return true;
|
||||
});
|
||||
lNodesAnnouncingHeaderAndIDs.pop_front();
|
||||
}
|
||||
m_connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetCommonVersion()).Make(NetMsgType::SENDCMPCT, /*fAnnounceUsingCMPCTBLOCK=*/true, nCMPCTBLOCKVersion));
|
||||
// save BIP152 bandwidth state: we select peer to be high-bandwidth
|
||||
pfrom->m_bip152_highbandwidth_to = true;
|
||||
lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
|
||||
return true;
|
||||
});
|
||||
CNodeState *state = State(*it);
|
||||
if (state != nullptr && !state->m_is_inbound) ++num_outbound_hb_peers;
|
||||
}
|
||||
if (nodestate->m_is_inbound) {
|
||||
// If we're adding an inbound HB peer, make sure we're not removing
|
||||
// our last outbound HB peer in the process.
|
||||
if (lNodesAnnouncingHeaderAndIDs.size() >= 3 && num_outbound_hb_peers == 1) {
|
||||
CNodeState *remove_node = State(lNodesAnnouncingHeaderAndIDs.front());
|
||||
if (remove_node != nullptr && !remove_node->m_is_inbound) {
|
||||
// Put the HB outbound peer in the second slot, so that it
|
||||
// doesn't get removed.
|
||||
std::swap(lNodesAnnouncingHeaderAndIDs.front(), *std::next(lNodesAnnouncingHeaderAndIDs.begin()));
|
||||
}
|
||||
}
|
||||
}
|
||||
m_connman.ForNode(nodeid, [this](CNode* pfrom) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
|
||||
AssertLockHeld(::cs_main);
|
||||
if (lNodesAnnouncingHeaderAndIDs.size() >= 3) {
|
||||
// As per BIP152, we only get 3 of our peers to announce
|
||||
// blocks using compact encodings.
|
||||
m_connman.ForNode(lNodesAnnouncingHeaderAndIDs.front(), [this](CNode* pnodeStop){
|
||||
m_connman.PushMessage(pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion()).Make(NetMsgType::SENDCMPCT, /*high_bandwidth=*/false, /*version=*/CMPCTBLOCKS_VERSION));
|
||||
// save BIP152 bandwidth state: we select peer to be low-bandwidth
|
||||
pnodeStop->m_bip152_highbandwidth_to = false;
|
||||
return true;
|
||||
});
|
||||
lNodesAnnouncingHeaderAndIDs.pop_front();
|
||||
}
|
||||
m_connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetCommonVersion()).Make(NetMsgType::SENDCMPCT, /*high_bandwidth=*/true, /*version=*/CMPCTBLOCKS_VERSION));
|
||||
// save BIP152 bandwidth state: we select peer to be high-bandwidth
|
||||
pfrom->m_bip152_highbandwidth_to = true;
|
||||
lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
bool PeerManagerImpl::TipMayBeStale()
|
||||
|
|
@ -1640,7 +1628,8 @@ void PeerManagerImpl::NewPoWValidBlock(const CBlockIndex *pindex, const std::sha
|
|||
return;
|
||||
m_highest_fast_announce = pindex->nHeight;
|
||||
|
||||
bool fWitnessEnabled = DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_SEGWIT);
|
||||
if (!DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) return;
|
||||
|
||||
uint256 hashBlock(pblock->GetHash());
|
||||
const std::shared_future<CSerializedNetMsg> lazy_ser{
|
||||
std::async(std::launch::deferred, [&] { return msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock); })};
|
||||
|
|
@ -1650,10 +1639,9 @@ void PeerManagerImpl::NewPoWValidBlock(const CBlockIndex *pindex, const std::sha
|
|||
m_most_recent_block_hash = hashBlock;
|
||||
m_most_recent_block = pblock;
|
||||
m_most_recent_compact_block = pcmpctblock;
|
||||
m_most_recent_compact_block_has_witnesses = fWitnessEnabled;
|
||||
}
|
||||
|
||||
m_connman.ForEachNode([this, pindex, fWitnessEnabled, &lazy_ser, &hashBlock](CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
|
||||
m_connman.ForEachNode([this, pindex, &lazy_ser, &hashBlock](CNode* pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
|
||||
AssertLockHeld(::cs_main);
|
||||
|
||||
if (pnode->GetCommonVersion() < INVALID_CB_NO_BAN_VERSION || pnode->fDisconnect)
|
||||
|
|
@ -1662,8 +1650,7 @@ void PeerManagerImpl::NewPoWValidBlock(const CBlockIndex *pindex, const std::sha
|
|||
CNodeState &state = *State(pnode->GetId());
|
||||
// If the peer has, or we announced to them the previous block already,
|
||||
// but we don't think they have this one, go ahead and announce it
|
||||
if (state.fPreferHeaderAndIDs && (!fWitnessEnabled || state.fWantsCmpctWitness) &&
|
||||
!PeerHasHeader(&state, pindex) && PeerHasHeader(&state, pindex->pprev)) {
|
||||
if (state.m_requested_hb_cmpctblocks && !PeerHasHeader(&state, pindex) && PeerHasHeader(&state, pindex->pprev)) {
|
||||
|
||||
LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", "PeerManager::NewPoWValidBlock",
|
||||
hashBlock.ToString(), pnode->GetId());
|
||||
|
|
@ -1858,12 +1845,10 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
|
|||
{
|
||||
std::shared_ptr<const CBlock> a_recent_block;
|
||||
std::shared_ptr<const CBlockHeaderAndShortTxIDs> a_recent_compact_block;
|
||||
bool fWitnessesPresentInARecentCompactBlock;
|
||||
{
|
||||
LOCK(m_most_recent_block_mutex);
|
||||
a_recent_block = m_most_recent_block;
|
||||
a_recent_compact_block = m_most_recent_compact_block;
|
||||
fWitnessesPresentInARecentCompactBlock = m_most_recent_compact_block_has_witnesses;
|
||||
}
|
||||
|
||||
bool need_activate_chain = false;
|
||||
|
|
@ -1976,17 +1961,15 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
|
|||
// they won't have a useful mempool to match against a compact block,
|
||||
// and we don't feel like constructing the object for them, so
|
||||
// instead we respond with the full, non-compact block.
|
||||
bool fPeerWantsWitness = State(pfrom.GetId())->fWantsCmpctWitness;
|
||||
int nSendFlags = fPeerWantsWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;
|
||||
if (CanDirectFetch() && pindex->nHeight >= m_chainman.ActiveChain().Height() - MAX_CMPCTBLOCK_DEPTH) {
|
||||
if ((fPeerWantsWitness || !fWitnessesPresentInARecentCompactBlock) && a_recent_compact_block && a_recent_compact_block->header.GetHash() == pindex->GetBlockHash()) {
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, *a_recent_compact_block));
|
||||
if (a_recent_compact_block && a_recent_compact_block->header.GetHash() == pindex->GetBlockHash()) {
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::CMPCTBLOCK, *a_recent_compact_block));
|
||||
} else {
|
||||
CBlockHeaderAndShortTxIDs cmpctblock(*pblock, fPeerWantsWitness);
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock));
|
||||
CBlockHeaderAndShortTxIDs cmpctblock(*pblock, true);
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::CMPCTBLOCK, cmpctblock));
|
||||
}
|
||||
} else {
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCK, *pblock));
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, *pblock));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2145,10 +2128,9 @@ void PeerManagerImpl::SendBlockTransactions(CNode& pfrom, const CBlock& block, c
|
|||
}
|
||||
resp.txn[i] = block.vtx[req.indexes[i]];
|
||||
}
|
||||
LOCK(cs_main);
|
||||
|
||||
const CNetMsgMaker msgMaker(pfrom.GetCommonVersion());
|
||||
int nSendFlags = State(pfrom.GetId())->fWantsCmpctWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp));
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCKTXN, resp));
|
||||
}
|
||||
|
||||
void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
||||
|
|
@ -2291,7 +2273,7 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
|
|||
}
|
||||
if (vGetData.size() > 0) {
|
||||
if (!m_ignore_incoming_txs &&
|
||||
nodestate->fSupportsDesiredCmpctVersion &&
|
||||
nodestate->m_provides_cmpctblocks &&
|
||||
vGetData.size() == 1 &&
|
||||
mapBlocksInFlight.size() == 1 &&
|
||||
pindexLast->pprev->IsValid(BLOCK_VALID_CHAIN)) {
|
||||
|
|
@ -2861,16 +2843,12 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDHEADERS));
|
||||
}
|
||||
if (pfrom.GetCommonVersion() >= SHORT_IDS_BLOCKS_VERSION) {
|
||||
// Tell our peer we are willing to provide version 1 or 2 cmpctblocks
|
||||
// Tell our peer we are willing to provide version 2 cmpctblocks.
|
||||
// However, we do not request new block announcements using
|
||||
// cmpctblock messages.
|
||||
// We send this to non-NODE NETWORK peers as well, because
|
||||
// they may wish to request compact blocks from us
|
||||
bool fAnnounceUsingCMPCTBLOCK = false;
|
||||
uint64_t nCMPCTBLOCKVersion = 2;
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion));
|
||||
nCMPCTBLOCKVersion = 1;
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion));
|
||||
m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDCMPCT, /*high_bandwidth=*/false, /*version=*/CMPCTBLOCKS_VERSION));
|
||||
}
|
||||
pfrom.fSuccessfullyConnected = true;
|
||||
return;
|
||||
|
|
@ -2883,26 +2861,20 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
}
|
||||
|
||||
if (msg_type == NetMsgType::SENDCMPCT) {
|
||||
bool fAnnounceUsingCMPCTBLOCK = false;
|
||||
uint64_t nCMPCTBLOCKVersion = 0;
|
||||
vRecv >> fAnnounceUsingCMPCTBLOCK >> nCMPCTBLOCKVersion;
|
||||
if (nCMPCTBLOCKVersion == 1 || nCMPCTBLOCKVersion == 2) {
|
||||
LOCK(cs_main);
|
||||
// fProvidesHeaderAndIDs is used to "lock in" version of compact blocks we send (fWantsCmpctWitness)
|
||||
if (!State(pfrom.GetId())->fProvidesHeaderAndIDs) {
|
||||
State(pfrom.GetId())->fProvidesHeaderAndIDs = true;
|
||||
State(pfrom.GetId())->fWantsCmpctWitness = nCMPCTBLOCKVersion == 2;
|
||||
}
|
||||
if (State(pfrom.GetId())->fWantsCmpctWitness == (nCMPCTBLOCKVersion == 2)) { // ignore later version announces
|
||||
State(pfrom.GetId())->fPreferHeaderAndIDs = fAnnounceUsingCMPCTBLOCK;
|
||||
// save whether peer selects us as BIP152 high-bandwidth peer
|
||||
// (receiving sendcmpct(1) signals high-bandwidth, sendcmpct(0) low-bandwidth)
|
||||
pfrom.m_bip152_highbandwidth_from = fAnnounceUsingCMPCTBLOCK;
|
||||
}
|
||||
if (!State(pfrom.GetId())->fSupportsDesiredCmpctVersion) {
|
||||
State(pfrom.GetId())->fSupportsDesiredCmpctVersion = (nCMPCTBLOCKVersion == 2);
|
||||
}
|
||||
}
|
||||
bool sendcmpct_hb{false};
|
||||
uint64_t sendcmpct_version{0};
|
||||
vRecv >> sendcmpct_hb >> sendcmpct_version;
|
||||
|
||||
// Only support compact block relay with witnesses
|
||||
if (sendcmpct_version != CMPCTBLOCKS_VERSION) return;
|
||||
|
||||
LOCK(cs_main);
|
||||
CNodeState* nodestate = State(pfrom.GetId());
|
||||
nodestate->m_provides_cmpctblocks = true;
|
||||
nodestate->m_requested_hb_cmpctblocks = sendcmpct_hb;
|
||||
// save whether peer selects us as BIP152 high-bandwidth peer
|
||||
// (receiving sendcmpct(1) signals high-bandwidth, sendcmpct(0) low-bandwidth)
|
||||
pfrom.m_bip152_highbandwidth_from = sendcmpct_hb;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -3251,9 +3223,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
// expensive disk reads, because it will require the peer to
|
||||
// actually receive all the data read from disk over the network.
|
||||
LogPrint(BCLog::NET, "Peer %d sent us a getblocktxn for a block > %i deep\n", pfrom.GetId(), MAX_BLOCKTXN_DEPTH);
|
||||
CInv inv;
|
||||
WITH_LOCK(cs_main, inv.type = State(pfrom.GetId())->fWantsCmpctWitness ? MSG_WITNESS_BLOCK : MSG_BLOCK);
|
||||
inv.hash = req.blockhash;
|
||||
CInv inv{MSG_WITNESS_BLOCK, req.blockhash};
|
||||
WITH_LOCK(peer->m_getdata_requests_mutex, peer->m_getdata_requests.push_back(inv));
|
||||
// The message processing loop will go around again (without pausing) and we'll respond then
|
||||
return;
|
||||
|
|
@ -3628,12 +3598,6 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
return;
|
||||
}
|
||||
|
||||
if (DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_SEGWIT) && !nodestate->fSupportsDesiredCmpctVersion) {
|
||||
// Don't bother trying to process compact blocks from v1 peers
|
||||
// after segwit activates.
|
||||
return;
|
||||
}
|
||||
|
||||
// We want to be a bit conservative just to be extra careful about DoS
|
||||
// possibilities in compact block processing...
|
||||
if (pindex->nHeight <= m_chainman.ActiveChain().Height() + 2) {
|
||||
|
|
@ -4723,7 +4687,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
|
|||
LOCK(peer->m_block_inv_mutex);
|
||||
std::vector<CBlock> vHeaders;
|
||||
bool fRevertToInv = ((!state.fPreferHeaders &&
|
||||
(!state.fPreferHeaderAndIDs || peer->m_blocks_for_headers_relay.size() > 1)) ||
|
||||
(!state.m_requested_hb_cmpctblocks || peer->m_blocks_for_headers_relay.size() > 1)) ||
|
||||
peer->m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE);
|
||||
const CBlockIndex *pBestIndex = nullptr; // last header queued for delivery
|
||||
ProcessBlockAvailability(pto->GetId()); // ensure pindexBestKnownBlock is up-to-date
|
||||
|
|
@ -4776,24 +4740,17 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
|
|||
}
|
||||
}
|
||||
if (!fRevertToInv && !vHeaders.empty()) {
|
||||
if (vHeaders.size() == 1 && state.fPreferHeaderAndIDs) {
|
||||
if (vHeaders.size() == 1 && state.m_requested_hb_cmpctblocks) {
|
||||
// We only send up to 1 block as header-and-ids, as otherwise
|
||||
// probably means we're doing an initial-ish-sync or they're slow
|
||||
LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", __func__,
|
||||
vHeaders.front().GetHash().ToString(), pto->GetId());
|
||||
|
||||
int nSendFlags = state.fWantsCmpctWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;
|
||||
|
||||
bool fGotBlockFromCache = false;
|
||||
{
|
||||
LOCK(m_most_recent_block_mutex);
|
||||
if (m_most_recent_block_hash == pBestIndex->GetBlockHash()) {
|
||||
if (state.fWantsCmpctWitness || !m_most_recent_compact_block_has_witnesses)
|
||||
m_connman.PushMessage(pto, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, *m_most_recent_compact_block));
|
||||
else {
|
||||
CBlockHeaderAndShortTxIDs cmpctblock(*m_most_recent_block, state.fWantsCmpctWitness);
|
||||
m_connman.PushMessage(pto, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock));
|
||||
}
|
||||
m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::CMPCTBLOCK, *m_most_recent_compact_block));
|
||||
fGotBlockFromCache = true;
|
||||
}
|
||||
}
|
||||
|
|
@ -4801,8 +4758,8 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
|
|||
CBlock block;
|
||||
bool ret = ReadBlockFromDisk(block, pBestIndex, consensusParams);
|
||||
assert(ret);
|
||||
CBlockHeaderAndShortTxIDs cmpctblock(block, state.fWantsCmpctWitness);
|
||||
m_connman.PushMessage(pto, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock));
|
||||
CBlockHeaderAndShortTxIDs cmpctblock(block, true);
|
||||
m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::CMPCTBLOCK, cmpctblock));
|
||||
}
|
||||
state.pindexBestHeaderSent = pBestIndex;
|
||||
} else if (state.fPreferHeaders) {
|
||||
|
|
|
|||
|
|
@ -2,11 +2,7 @@
|
|||
# Copyright (c) 2016-2021 The Bitcoin Core developers
|
||||
# Distributed under the MIT software license, see the accompanying
|
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
"""Test compact blocks (BIP 152).
|
||||
|
||||
Version 1 compact blocks are pre-segwit (txids)
|
||||
Version 2 compact blocks are post-segwit (wtxids)
|
||||
"""
|
||||
"""Test compact blocks (BIP 152)."""
|
||||
import random
|
||||
|
||||
from test_framework.blocktools import (
|
||||
|
|
@ -31,7 +27,6 @@ from test_framework.messages import (
|
|||
MSG_BLOCK,
|
||||
MSG_CMPCT_BLOCK,
|
||||
MSG_WITNESS_FLAG,
|
||||
NODE_NETWORK,
|
||||
P2PHeaderAndShortIDs,
|
||||
PrefilledTransaction,
|
||||
calculate_shortid,
|
||||
|
|
@ -70,7 +65,7 @@ from test_framework.wallet import MiniWallet
|
|||
|
||||
# TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
|
||||
class TestP2PConn(P2PInterface):
|
||||
def __init__(self, cmpct_version):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.last_sendcmpct = []
|
||||
self.block_announced = False
|
||||
|
|
@ -78,7 +73,6 @@ class TestP2PConn(P2PInterface):
|
|||
# This is for synchronizing the p2p message traffic,
|
||||
# so we can eg wait until a particular block is announced.
|
||||
self.announced_blockhashes = set()
|
||||
self.cmpct_version = cmpct_version
|
||||
|
||||
def on_sendcmpct(self, message):
|
||||
self.last_sendcmpct.append(message)
|
||||
|
|
@ -185,15 +179,13 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Test "sendcmpct" (between peers preferring the same version):
|
||||
# - No compact block announcements unless sendcmpct is sent.
|
||||
# - If sendcmpct is sent with version > preferred_version, the message is ignored.
|
||||
# - If sendcmpct is sent with version = 1, the message is ignored.
|
||||
# - If sendcmpct is sent with version > 2, the message is ignored.
|
||||
# - If sendcmpct is sent with boolean 0, then block announcements are not
|
||||
# made with compact blocks.
|
||||
# - If sendcmpct is then sent with boolean 1, then new block announcements
|
||||
# are made with compact blocks.
|
||||
# If old_node is passed in, request compact blocks with version=preferred-1
|
||||
# and verify that it receives block announcements via compact block.
|
||||
def test_sendcmpct(self, test_node, old_node=None):
|
||||
preferred_version = test_node.cmpct_version
|
||||
def test_sendcmpct(self, test_node):
|
||||
node = self.nodes[0]
|
||||
|
||||
# Make sure we get a SENDCMPCT message from our peer
|
||||
|
|
@ -201,10 +193,8 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
return (len(test_node.last_sendcmpct) > 0)
|
||||
test_node.wait_until(received_sendcmpct, timeout=30)
|
||||
with p2p_lock:
|
||||
# Check that the first version received is the preferred one
|
||||
assert_equal(test_node.last_sendcmpct[0].version, preferred_version)
|
||||
# And that we receive versions down to 1.
|
||||
assert_equal(test_node.last_sendcmpct[-1].version, 1)
|
||||
# Check that version 2 is received.
|
||||
assert_equal(test_node.last_sendcmpct[0].version, 2)
|
||||
test_node.last_sendcmpct = []
|
||||
|
||||
tip = int(node.getbestblockhash(), 16)
|
||||
|
|
@ -232,22 +222,29 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Before each test, sync the headers chain.
|
||||
test_node.request_headers_and_sync(locator=[tip])
|
||||
|
||||
# Now try a SENDCMPCT message with too-low version
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=True, version=1))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
|
||||
|
||||
# Headers sync before next test.
|
||||
test_node.request_headers_and_sync(locator=[tip])
|
||||
|
||||
# Now try a SENDCMPCT message with too-high version
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=True, version=preferred_version+1))
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=True, version=3))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
|
||||
|
||||
# Headers sync before next test.
|
||||
test_node.request_headers_and_sync(locator=[tip])
|
||||
|
||||
# Now try a SENDCMPCT message with valid version, but announce=False
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=preferred_version))
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message)
|
||||
|
||||
# Headers sync before next test.
|
||||
test_node.request_headers_and_sync(locator=[tip])
|
||||
|
||||
# Finally, try a SENDCMPCT message with announce=True
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=True, version=preferred_version))
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=True, version=2))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
||||
# Try one more time (no headers sync should be needed!)
|
||||
|
|
@ -257,22 +254,14 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_node.send_and_ping(msg_sendheaders())
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
||||
# Try one more time, after sending a version-1, announce=false message.
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=preferred_version-1))
|
||||
# Try one more time, after sending a version=1, announce=false message.
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=1))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
||||
# Now turn off announcements
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=preferred_version))
|
||||
test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
|
||||
check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message and "headers" in p.last_message)
|
||||
|
||||
if old_node is not None:
|
||||
# Verify that a peer using an older protocol version can receive
|
||||
# announcements from this node.
|
||||
old_node.send_and_ping(msg_sendcmpct(announce=True, version=preferred_version-1))
|
||||
# Header sync
|
||||
old_node.request_headers_and_sync(locator=[tip])
|
||||
check_announcement_of_new_block(node, old_node, lambda p: "cmpctblock" in p.last_message)
|
||||
|
||||
# This test actually causes bitcoind to (reasonably!) disconnect us, so do this last.
|
||||
def test_invalid_cmpctblock_message(self):
|
||||
self.generate(self.nodes[0], COINBASE_MATURITY + 1)
|
||||
|
|
@ -289,8 +278,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Compare the generated shortids to what we expect based on BIP 152, given
|
||||
# bitcoind's choice of nonce.
|
||||
def test_compactblock_construction(self, test_node, use_witness_address=True):
|
||||
version = test_node.cmpct_version
|
||||
def test_compactblock_construction(self, test_node):
|
||||
node = self.nodes[0]
|
||||
# Generate a bunch of transactions.
|
||||
self.generate(node, COINBASE_MATURITY + 1)
|
||||
|
|
@ -303,8 +291,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
if not tx.wit.is_null():
|
||||
segwit_tx_generated = True
|
||||
|
||||
if use_witness_address:
|
||||
assert segwit_tx_generated # check that our test is not broken
|
||||
assert segwit_tx_generated # check that our test is not broken
|
||||
|
||||
# Wait until we've seen the block announcement for the resulting tip
|
||||
tip = int(node.getbestblockhash(), 16)
|
||||
|
|
@ -331,7 +318,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
with p2p_lock:
|
||||
# Convert the on-the-wire representation to absolute indexes
|
||||
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
|
||||
self.check_compactblock_construction_from_block(version, header_and_shortids, block_hash, block)
|
||||
self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
|
||||
|
||||
# Now fetch the compact block using a normal non-announce getdata
|
||||
test_node.clear_block_announcement()
|
||||
|
|
@ -345,9 +332,9 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
with p2p_lock:
|
||||
# Convert the on-the-wire representation to absolute indexes
|
||||
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
|
||||
self.check_compactblock_construction_from_block(version, header_and_shortids, block_hash, block)
|
||||
self.check_compactblock_construction_from_block(header_and_shortids, block_hash, block)
|
||||
|
||||
def check_compactblock_construction_from_block(self, version, header_and_shortids, block_hash, block):
|
||||
def check_compactblock_construction_from_block(self, header_and_shortids, block_hash, block):
|
||||
# Check that we got the right block!
|
||||
header_and_shortids.header.calc_sha256()
|
||||
assert_equal(header_and_shortids.header.sha256, block_hash)
|
||||
|
|
@ -364,11 +351,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# And this checks the witness
|
||||
wtxid = entry.tx.calc_sha256(True)
|
||||
if version == 2:
|
||||
assert_equal(wtxid, block.vtx[entry.index].calc_sha256(True))
|
||||
else:
|
||||
# Shouldn't have received a witness
|
||||
assert entry.tx.wit.is_null()
|
||||
assert_equal(wtxid, block.vtx[entry.index].calc_sha256(True))
|
||||
|
||||
# Check that the cmpctblock message announced all the transactions.
|
||||
assert_equal(len(header_and_shortids.prefilled_txn) + len(header_and_shortids.shortids), len(block.vtx))
|
||||
|
|
@ -384,9 +367,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Already checked prefilled transactions above
|
||||
header_and_shortids.prefilled_txn.pop(0)
|
||||
else:
|
||||
tx_hash = block.vtx[index].sha256
|
||||
if version == 2:
|
||||
tx_hash = block.vtx[index].calc_sha256(True)
|
||||
tx_hash = block.vtx[index].calc_sha256(True)
|
||||
shortid = calculate_shortid(k0, k1, tx_hash)
|
||||
assert_equal(shortid, header_and_shortids.shortids[0])
|
||||
header_and_shortids.shortids.pop(0)
|
||||
|
|
@ -395,16 +376,12 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Test that bitcoind requests compact blocks when we announce new blocks
|
||||
# via header or inv, and that responding to getblocktxn causes the block
|
||||
# to be successfully reconstructed.
|
||||
# Post-segwit: upgraded nodes would only make this request of cb-version-2,
|
||||
# NODE_WITNESS peers. Unupgraded nodes would still make this request of
|
||||
# any cb-version-1-supporting peer.
|
||||
def test_compactblock_requests(self, test_node, segwit=True):
|
||||
version = test_node.cmpct_version
|
||||
def test_compactblock_requests(self, test_node):
|
||||
node = self.nodes[0]
|
||||
# Try announcing a block with an inv or header, expect a compactblock
|
||||
# request
|
||||
for announce in ["inv", "header"]:
|
||||
block = self.build_block_on_tip(node, segwit=segwit)
|
||||
block = self.build_block_on_tip(node, segwit=True)
|
||||
|
||||
if announce == "inv":
|
||||
test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)]))
|
||||
|
|
@ -420,9 +397,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
comp_block.header = CBlockHeader(block)
|
||||
comp_block.nonce = 0
|
||||
[k0, k1] = comp_block.get_siphash_keys()
|
||||
coinbase_hash = block.vtx[0].sha256
|
||||
if version == 2:
|
||||
coinbase_hash = block.vtx[0].calc_sha256(True)
|
||||
coinbase_hash = block.vtx[0].calc_sha256(True)
|
||||
comp_block.shortids = [calculate_shortid(k0, k1, coinbase_hash)]
|
||||
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
|
||||
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
|
||||
|
|
@ -433,10 +408,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert_equal(absolute_indexes, [0]) # should be a coinbase request
|
||||
|
||||
# Send the coinbase, and verify that the tip advances.
|
||||
if version == 2:
|
||||
msg = msg_blocktxn()
|
||||
else:
|
||||
msg = msg_no_witness_blocktxn()
|
||||
msg = msg_blocktxn()
|
||||
msg.block_transactions.blockhash = block.sha256
|
||||
msg.block_transactions.transactions = [block.vtx[0]]
|
||||
test_node.send_and_ping(msg)
|
||||
|
|
@ -462,9 +434,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# node needs, and that responding to them causes the block to be
|
||||
# reconstructed.
|
||||
def test_getblocktxn_requests(self, test_node):
|
||||
version = test_node.cmpct_version
|
||||
node = self.nodes[0]
|
||||
with_witness = (version == 2)
|
||||
|
||||
def test_getblocktxn_response(compact_block, peer, expected_result):
|
||||
msg = msg_cmpctblock(compact_block.to_p2p())
|
||||
|
|
@ -485,13 +455,12 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
block = self.build_block_with_transactions(node, utxo, 5)
|
||||
self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
|
||||
comp_block = HeaderAndShortIDs()
|
||||
comp_block.initialize_from_block(block, use_witness=with_witness)
|
||||
comp_block.initialize_from_block(block, use_witness=True)
|
||||
|
||||
test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])
|
||||
|
||||
msg_bt = msg_no_witness_blocktxn()
|
||||
if with_witness:
|
||||
msg_bt = msg_blocktxn() # serialize with witnesses
|
||||
msg_bt = msg_blocktxn() # serialize with witnesses
|
||||
msg_bt.block_transactions = BlockTransactions(block.sha256, block.vtx[1:])
|
||||
test_tip_after_message(node, test_node, msg_bt, block.sha256)
|
||||
|
||||
|
|
@ -500,7 +469,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
|
||||
|
||||
# Now try interspersing the prefilled transactions
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 1, 5], use_witness=with_witness)
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 1, 5], use_witness=True)
|
||||
test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
|
||||
msg_bt.block_transactions = BlockTransactions(block.sha256, block.vtx[2:5])
|
||||
test_tip_after_message(node, test_node, msg_bt, block.sha256)
|
||||
|
|
@ -514,7 +483,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Prefill 4 out of the 6 transactions, and verify that only the one
|
||||
# that was not in the mempool is requested.
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 2, 3, 4], use_witness=with_witness)
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 2, 3, 4], use_witness=True)
|
||||
test_getblocktxn_response(comp_block, test_node, [5])
|
||||
|
||||
msg_bt.block_transactions = BlockTransactions(block.sha256, [block.vtx[5]])
|
||||
|
|
@ -538,7 +507,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_node.last_message.pop("getblocktxn", None)
|
||||
|
||||
# Send compact block
|
||||
comp_block.initialize_from_block(block, prefill_list=[0], use_witness=with_witness)
|
||||
comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
|
||||
test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
|
||||
with p2p_lock:
|
||||
# Shouldn't have gotten a request for any transaction
|
||||
|
|
@ -547,7 +516,6 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# Incorrectly responding to a getblocktxn shouldn't cause the block to be
|
||||
# permanently failed.
|
||||
def test_incorrect_blocktxn_response(self, test_node):
|
||||
version = test_node.cmpct_version
|
||||
node = self.nodes[0]
|
||||
utxo = self.utxos.pop(0)
|
||||
|
||||
|
|
@ -564,7 +532,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Send compact block
|
||||
comp_block = HeaderAndShortIDs()
|
||||
comp_block.initialize_from_block(block, prefill_list=[0], use_witness=(version == 2))
|
||||
comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
|
||||
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
|
||||
absolute_indexes = []
|
||||
with p2p_lock:
|
||||
|
|
@ -580,9 +548,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# different peer provide the block further down, so that we're still
|
||||
# verifying that the block isn't marked bad permanently. This is good
|
||||
# enough for now.
|
||||
msg = msg_no_witness_blocktxn()
|
||||
if version == 2:
|
||||
msg = msg_blocktxn()
|
||||
msg = msg_blocktxn()
|
||||
msg.block_transactions = BlockTransactions(block.sha256, [block.vtx[5]] + block.vtx[7:])
|
||||
test_node.send_and_ping(msg)
|
||||
|
||||
|
|
@ -595,14 +561,10 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
test_node.last_message["getdata"].inv[0].type == MSG_BLOCK | MSG_WITNESS_FLAG
|
||||
|
||||
# Deliver the block
|
||||
if version == 2:
|
||||
test_node.send_and_ping(msg_block(block))
|
||||
else:
|
||||
test_node.send_and_ping(msg_no_witness_block(block))
|
||||
test_node.send_and_ping(msg_block(block))
|
||||
assert_equal(int(node.getbestblockhash(), 16), block.sha256)
|
||||
|
||||
def test_getblocktxn_handler(self, test_node):
|
||||
version = test_node.cmpct_version
|
||||
node = self.nodes[0]
|
||||
# bitcoind will not send blocktxn responses for blocks whose height is
|
||||
# more than 10 blocks deep.
|
||||
|
|
@ -628,12 +590,8 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
tx = test_node.last_message["blocktxn"].block_transactions.transactions.pop(0)
|
||||
tx.calc_sha256()
|
||||
assert_equal(tx.sha256, block.vtx[index].sha256)
|
||||
if version == 1:
|
||||
# Witnesses should have been stripped
|
||||
assert tx.wit.is_null()
|
||||
else:
|
||||
# Check that the witness matches
|
||||
assert_equal(tx.calc_sha256(True), block.vtx[index].calc_sha256(True))
|
||||
# Check that the witness matches
|
||||
assert_equal(tx.calc_sha256(True), block.vtx[index].calc_sha256(True))
|
||||
test_node.last_message.pop("blocktxn", None)
|
||||
current_height -= 1
|
||||
|
||||
|
|
@ -727,7 +685,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
# Test that we don't get disconnected if we relay a compact block with valid header,
|
||||
# but invalid transactions.
|
||||
def test_invalid_tx_in_compactblock(self, test_node, use_segwit=True):
|
||||
def test_invalid_tx_in_compactblock(self, test_node):
|
||||
node = self.nodes[0]
|
||||
assert len(self.utxos)
|
||||
utxo = self.utxos[0]
|
||||
|
|
@ -735,17 +693,15 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
block = self.build_block_with_transactions(node, utxo, 5)
|
||||
del block.vtx[3]
|
||||
block.hashMerkleRoot = block.calc_merkle_root()
|
||||
if use_segwit:
|
||||
# If we're testing with segwit, also drop the coinbase witness,
|
||||
# but include the witness commitment.
|
||||
add_witness_commitment(block)
|
||||
block.vtx[0].wit.vtxinwit = []
|
||||
# Drop the coinbase witness but include the witness commitment.
|
||||
add_witness_commitment(block)
|
||||
block.vtx[0].wit.vtxinwit = []
|
||||
block.solve()
|
||||
|
||||
# Now send the compact block with all transactions prefilled, and
|
||||
# verify that we don't get disconnected.
|
||||
comp_block = HeaderAndShortIDs()
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4], use_witness=use_segwit)
|
||||
comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4], use_witness=True)
|
||||
msg = msg_cmpctblock(comp_block.to_p2p())
|
||||
test_node.send_and_ping(msg)
|
||||
|
||||
|
|
@ -759,7 +715,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
node = self.nodes[0]
|
||||
tip = node.getbestblockhash()
|
||||
peer.get_headers(locator=[int(tip, 16)], hashstop=0)
|
||||
peer.send_and_ping(msg_sendcmpct(announce=True, version=peer.cmpct_version))
|
||||
peer.send_and_ping(msg_sendcmpct(announce=True, version=2))
|
||||
|
||||
def test_compactblock_reconstruction_multiple_peers(self, stalling_peer, delivery_peer):
|
||||
node = self.nodes[0]
|
||||
|
|
@ -813,7 +769,7 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
def test_highbandwidth_mode_states_via_getpeerinfo(self):
|
||||
# create new p2p connection for a fresh state w/o any prior sendcmpct messages sent
|
||||
hb_test_node = self.nodes[0].add_p2p_connection(TestP2PConn(cmpct_version=2))
|
||||
hb_test_node = self.nodes[0].add_p2p_connection(TestP2PConn())
|
||||
|
||||
# assert the RPC getpeerinfo boolean fields `bip152_hb_{to, from}`
|
||||
# match the given parameters for the last peer of a given node
|
||||
|
|
@ -843,9 +799,8 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
self.wallet = MiniWallet(self.nodes[0])
|
||||
|
||||
# Setup the p2p connections
|
||||
self.segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn(cmpct_version=2))
|
||||
self.old_node = self.nodes[0].add_p2p_connection(TestP2PConn(cmpct_version=1), services=NODE_NETWORK)
|
||||
self.additional_segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn(cmpct_version=2))
|
||||
self.segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
|
||||
self.additional_segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
|
||||
|
||||
# We will need UTXOs to construct transactions in later tests.
|
||||
self.make_utxos()
|
||||
|
|
@ -853,11 +808,10 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
assert softfork_active(self.nodes[0], "segwit")
|
||||
|
||||
self.log.info("Testing SENDCMPCT p2p message... ")
|
||||
self.test_sendcmpct(self.segwit_node, old_node=self.old_node)
|
||||
self.test_sendcmpct(self.segwit_node)
|
||||
self.test_sendcmpct(self.additional_segwit_node)
|
||||
|
||||
self.log.info("Testing compactblock construction...")
|
||||
self.test_compactblock_construction(self.old_node)
|
||||
self.test_compactblock_construction(self.segwit_node)
|
||||
|
||||
self.log.info("Testing compactblock requests (segwit node)... ")
|
||||
|
|
@ -868,11 +822,9 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
|
||||
self.log.info("Testing getblocktxn handler (segwit node should return witnesses)...")
|
||||
self.test_getblocktxn_handler(self.segwit_node)
|
||||
self.test_getblocktxn_handler(self.old_node)
|
||||
|
||||
self.log.info("Testing compactblock requests/announcements not at chain tip...")
|
||||
self.test_compactblocks_not_at_tip(self.segwit_node)
|
||||
self.test_compactblocks_not_at_tip(self.old_node)
|
||||
|
||||
self.log.info("Testing handling of incorrect blocktxn responses...")
|
||||
self.test_incorrect_blocktxn_response(self.segwit_node)
|
||||
|
|
@ -885,13 +837,12 @@ class CompactBlocksTest(BitcoinTestFramework):
|
|||
# (Post-segwit activation, blocks won't propagate from node0 to node1
|
||||
# automatically, so don't bother testing a block announced to node0.)
|
||||
self.log.info("Testing end-to-end block relay...")
|
||||
self.request_cb_announcements(self.old_node)
|
||||
self.request_cb_announcements(self.segwit_node)
|
||||
self.test_end_to_end_block_relay([self.segwit_node, self.old_node])
|
||||
self.request_cb_announcements(self.additional_segwit_node)
|
||||
self.test_end_to_end_block_relay([self.segwit_node, self.additional_segwit_node])
|
||||
|
||||
self.log.info("Testing handling of invalid compact blocks...")
|
||||
self.test_invalid_tx_in_compactblock(self.segwit_node)
|
||||
self.test_invalid_tx_in_compactblock(self.old_node)
|
||||
|
||||
self.log.info("Testing invalid index in cmpctblock message...")
|
||||
self.test_invalid_cmpctblock_message()
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ class P2PCompactBlocksBlocksOnly(BitcoinTestFramework):
|
|||
p2p_conn_high_bw = self.nodes[1].add_p2p_connection(P2PInterface())
|
||||
p2p_conn_low_bw = self.nodes[3].add_p2p_connection(P2PInterface())
|
||||
for conn in [p2p_conn_blocksonly, p2p_conn_high_bw, p2p_conn_low_bw]:
|
||||
assert_equal(conn.message_count['sendcmpct'], 2)
|
||||
assert_equal(conn.message_count['sendcmpct'], 1)
|
||||
conn.send_and_ping(msg_sendcmpct(announce=False, version=2))
|
||||
|
||||
# Nodes:
|
||||
|
|
@ -74,14 +74,14 @@ class P2PCompactBlocksBlocksOnly(BitcoinTestFramework):
|
|||
# receiving a new valid block at the tip.
|
||||
p2p_conn_blocksonly.send_and_ping(msg_block(block0))
|
||||
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block0.sha256)
|
||||
assert_equal(p2p_conn_blocksonly.message_count['sendcmpct'], 2)
|
||||
assert_equal(p2p_conn_blocksonly.message_count['sendcmpct'], 1)
|
||||
assert_equal(p2p_conn_blocksonly.last_message['sendcmpct'].announce, False)
|
||||
|
||||
# A normal node participating in transaction relay should request BIP152
|
||||
# high bandwidth mode upon receiving a new valid block at the tip.
|
||||
p2p_conn_high_bw.send_and_ping(msg_block(block0))
|
||||
assert_equal(int(self.nodes[1].getbestblockhash(), 16), block0.sha256)
|
||||
p2p_conn_high_bw.wait_until(lambda: p2p_conn_high_bw.message_count['sendcmpct'] == 3)
|
||||
p2p_conn_high_bw.wait_until(lambda: p2p_conn_high_bw.message_count['sendcmpct'] == 2)
|
||||
assert_equal(p2p_conn_high_bw.last_message['sendcmpct'].announce, True)
|
||||
|
||||
# Don't send a block from the p2p_conn_low_bw so the low bandwidth node
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue