[BUG]: P2P sync downloads full 500-block chunks without headers-first validation

オープン
#178 コメント 0 件 リアクション 0 件 担当者 0 名 GitHub で見る

メンテナーはふだん 1 日以内に返信

@anshulchikhale30-p がすでに取り組んでいます。

2026年11月8日 から。

  • #179 @anshulchikhale30-p による — マージされずにクローズ
  • #180 @anshulchikhale30-p による — オープン

評価

難易度
5/5
見積もり時間
1週間以上
初心者へのやさしさ
25/100
issue の種類
機能追加
明瞭さ
明確に書かれている
活発さ
活発
技術スタック
python

調査の方向性

Start with main.py handlers request_chain, chain_request, and chain_response, then read minichain/p2p.py and minichain/chain.py to understand current sync and validation. Run the existing test suite and inspect its sync coverage before planning the new tests named in the issue. Done means header-first sync, bounded and rate-limited body requests, peer handling for invalid data, and the stated acceptance criteria are implemented and documented in docs/sync.md.

索引モデルが issue の本文から書いたものです。

説明

bug documentation enhancement

Bug Description

MiniChain's P2P sync downloads up to 500 full blocks per request and has no headers-first phase or block locator. When a peer's tip is ahead, main.py calls request_chain(network, chain.last_block.index + 1, 500); on a fork it requests up to 50 blocks backward. This works for small local chains but is inefficient and unsafe at scale.

Current behavior:

  • request_chain broadcasts a chain_request with start_index and limit=500.
  • chain_request serves chain.chain[start_index:start_index+limit] and sends every full block (header + transactions + receipts).
  • chain_response parses all received blocks into memory and applies them one by one.
  • There is no getheaders/headers phase and no block locator, so an invalid chain is only discovered after downloading entire bodies.
  • chain_request accepts start_index and limit without bounds; a peer can request a very large range or send a very large response.
  • There is no request ID/response correlation, no maximum response size, and no per-peer sync rate limit.
  • p2p.py coverage is 37% (README), so these paths are under-tested.

Impact:

  • Slow sync and high memory use on long chains.
  • Wasted bandwidth and CPU on invalid or adversarial chains.
  • DoS vector via oversized requests/responses or request floods.
  • Repeated 50-block backward scans on forks.
  • Multi-node research at 10k+ blocks is impractical.

Expected behavior:

  • Sync headers first with a locator, validate the header chain (PoW, target, timestamp, parent linkage, cumulative work), then download bodies in bounded batches.
  • Bound request/response sizes, add request IDs, unicast to one peer, and rate-limit per peer.
  • Disconnect or ban peers that send invalid or oversized data.

Proposed fix:

  1. Add getheaders with a locator (recent block hashes), stop_hash, and max (e.g. 2000), plus a headers response.
  2. Validate headers before bodies: PoW, target, timestamp, parent linkage, cumulative work.
  3. Add getblock by hash or bounded range; fetch bodies in small batches (e.g. 64 blocks) with a maximum number of in-flight requests.
  4. Verify transaction root, receipt root, and state root after executing the bodies.
  5. Add request IDs, unicast requests to one peer, and deduplicate responses.
  6. Cap start_index, limit, and response bytes; add a per-peer token bucket.
  7. Feed invalid or oversized responses into the existing validation counters and ban repeat offenders.
  8. Add tests for 10k-block sync, 100-block reorg, invalid headers, invalid bodies, oversized requests/responses, restart mid-sync, and rate limiting.
  9. Document the protocol and limits in docs/sync.md.

Acceptance criteria:

  • 10k-block sync completes within an agreed target and bounded memory.
  • Headers are validated before bodies are downloaded.
  • Fork detection uses a locator, not repeated 50-block scans.
  • Requests and responses are bounded and rate-limited.
  • Invalid or oversized peers are disconnected or banned.
  • No unbounded queues or response buffers.
  • p2p.py coverage is at least 65%.
  • Sync protocol and limits are documented.

Relevant files:

  • main.py (request_chain, chain_request, chain_response)
  • minichain/p2p.py
  • minichain/chain.py
  • tests/test_sync.py (new)
  • tests/test_p2p_limits.py (new)

References:

Steps to Reproduce

  1. Start two nodes on different ports with separate data directories.
  2. Let one node mine more than 500 blocks.
  3. Connect the second node to the first node.
  4. Observe the hello handler request chain_request with limit=500, followed by full-block chain_response payloads.
  5. For the adversarial case, send a chain_request with a very large limit, or send a chain_response containing a very large list of blocks, and observe memory/CPU use.

Logs and Screenshots

Relevant log lines include:

?? Peer ... is ahead (...) . Initiating chunked sync...
?? Peer requested blocks from ... (limit 500).

No screenshots available.

Environment Details

  • OS: Windows 11 / Linux
  • Python 3.10+
  • MiniChain main branch as of 2026-11-08
  • p2p.py coverage: 37% (README coverage report)

Impact

High - Major feature is broken (sync works for small chains, but is not safe or efficient at scale).

Code of Conduct

  • I have joined the Discord server and will post updates there
  • I have searched existing issues to avoid duplicates
主要言語
Python
スター
12
フォーク
27
平均マージ
2分
マージ済み PR(30日)
1

環境構築

はじめの一歩

  1. issue を最後まで読み、次にプロジェクトのコントリビューションガイドを読みます。
  2. 着手することを issue にコメントします — 二人が同じ作業をするのを防げます。
  3. リポジトリをフォークし、ブランチを切って変更します。
  4. issue 番号を参照したプルリクエストを送ります。

StabilityNexus/MiniChain のほかの issue

StabilityNexus/MiniChain の issue をすべて見る

似ている issue

Python の issue をもっと見る

新しい issue をメールで受け取る

初心者向けの GitHub issue を短くまとめたダイジェスト。