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

Ouverte
#178 0 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

@anshulchikhale30-p y travaille déjà.

Depuis le 8/11/2026.

  • #179 par @anshulchikhale30-p — fermée sans fusion
  • #180 par @anshulchikhale30-p — ouverte

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
25/100
Type d'issue
Fonctionnalité
Clarté
Clairement spécifiée
Activité
Active
Stack technique
python

Piste de recherche

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.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

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
Langage dominant
Python
Étoiles
12
Forks
27
Merge moyen
2 min
PR mergées (30 j)
1

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de StabilityNexus/MiniChain

Toutes les issues de StabilityNexus/MiniChain

Issues similaires

Plus d'issues Python

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.