MIME-Version: 1.0
From: Jim Posen <jim.posen@gmail.com>
Date: Fri, 15 Dec 2017 15:55:16 -0800
Message-ID: <CADZtCSjR8Cd30Ag__+Rr2FV8rdbYY4_bUgGKeEgpoyTjxzM=dw@mail.gmail.com>
To: Bitcoin Protocol Discussion <bitcoin-dev@lists.linuxfoundation.org>
Content-Type: multipart/alternative; boundary="001a1147bce67faa74056069bb56"
Subject: [bitcoin-dev] Parallel header download during sync
Precedence: list

--001a1147bce67faa74056069bb56
Content-Type: text/plain; charset="UTF-8"

One of the ideas that Greg Maxwell brought up in the "'Compressed' headers
stream" thread is the possibility of a header sync mechanism that allowed
parallel download from multiple peers. With the current getheaders/headers
semantics, headers must be downloaded sequentially from genesis. In my
testing, I saw that syncing headers directly from a colocated node took <5s
whereas syncing normally from network peers takes ~5 min for me, which goes
to show that 5s is an upper bound on the time to process all headers if
they are locally available. So if we can introduce new p2p messages for
header sync, what would they look like? Here's one idea.

A new getheadersv2 request would include a start height for the range of
headers requested and a commitment to the last block in the chain that you
want to download. Then you find N peers that are all on the same chain,
partition the range of headers from 0 to the chain height minus some
reasonable reorg safety buffer (~6 blocks), and send download requests in
parallel. So how do we know that the peers are on the same chain and that
their headers served connect into this chain?

When you connect to outbound peers and are in IBD, you will query them for
a Merkle Mountain Range commitment to all headers up to a height X (which
is 6ish blocks before their start height from the version message). Then
you choose the commitment that the majority of the queried peers sent (or
some other heuristic), and these become your download peers. Every
getheadersv2 request includes the start height, X, and the chain
commitment. The headersv2 response messages include all of the headers
followed by a merkle branch linking the last header into the chain
commitment. Headers are processed in order as they arrive and if any of the
headers are invalid, you can ban/disconnect all peers that committed to it,
drop the buffer of later headers and start over.

That's the basic idea. Here are other details:

- This would require an additional 32-byte MMR commitment for each header
in memory.
- When a node receives a headersv2 request and constructs a merkle proof
for the last header, it checks against the sent commitment. In the case of
a really deep reorg, that check would fail, and the node can instead
respond with an updated commitment hash for that height.
- Another packet is needed, getheaderchain or something, that a syncing
peer first sends along with a header locator and an end height. The peer
responds with headerchain, which includes the last common header from the
locator along with the chain commitment at that height and a merkle branch
proving inclusion of that header in the chain.
- Nodes would cache chain commitments for the last ~20 blocks (somewhat
arbitrary), and refuse to serve chain commitments for heights before that.

Thoughts? This is a pretty recycled idea, so please point me at prior
proposals that are similar as well.

-jimpo

--001a1147bce67faa74056069bb56
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">One of the ideas that Greg Maxwell brought up in the &quot=
;&#39;Compressed&#39; headers stream&quot; thread is the possibility of a h=
eader sync mechanism that allowed parallel download from multiple peers. Wi=
th the current getheaders/headers semantics, headers must be downloaded seq=
uentially from genesis. In my testing, I saw that syncing headers directly =
from a colocated node took &lt;5s whereas syncing normally from network pee=
rs takes ~5 min for me, which goes to show that 5s is an upper bound on the=
 time to process all headers if they are locally available. So if we can in=
troduce new p2p messages for header sync, what would they look like? Here&#=
39;s one idea.<div><br></div><div>A new getheadersv2 request would include =
a start height for the range of headers requested and a commitment to the l=
ast block in the chain that you want to download. Then you find N peers tha=
t are all on the same chain, partition the range of headers from 0 to the c=
hain height minus some reasonable reorg safety buffer (~6 blocks), and send=
 download requests in parallel. So how do we know that the peers are on the=
 same chain and that their headers served connect into this chain?</div><di=
v><br></div><div>When you connect to outbound peers and are in IBD, you wil=
l query them for a Merkle Mountain Range commitment to all headers up to a =
height X (which is 6ish blocks before their start height from the version m=
essage). Then you choose the commitment that the majority of the queried pe=
ers sent (or some other heuristic), and these become your download peers. E=
very getheadersv2 request includes the start height, X, and the chain commi=
tment. The headersv2 response messages include all of the headers followed =
by a merkle branch linking the last header into the chain commitment. Heade=
rs are processed in order as they arrive and if any of the headers are inva=
lid, you can ban/disconnect all peers that committed to it, drop the buffer=
 of later headers and start over.</div><div><br></div><div>That&#39;s the b=
asic idea. Here are other details:</div><div><br></div><div>- This would re=
quire an additional 32-byte MMR commitment for each header in memory.</div>=
<div>- When a node receives a headersv2 request and constructs a merkle pro=
of for the last header, it checks against the sent commitment. In the case =
of a really deep reorg, that check would fail, and the node can instead res=
pond with an updated commitment hash for that height.</div><div>- Another p=
acket is needed, getheaderchain or something, that a syncing peer first sen=
ds along with a header locator and an end height. The peer responds with he=
aderchain, which includes the last common header from the locator along wit=
h the chain commitment at that height and a merkle branch proving inclusion=
 of that header in the chain.</div><div>- Nodes would cache chain commitmen=
ts for the last ~20 blocks (somewhat arbitrary), and refuse to serve chain =
commitments for heights before that.</div><div><br></div><div>Thoughts? Thi=
s is a pretty recycled idea, so please point me at prior proposals that are=
 similar as well.</div><div><br></div><div>-jimpo</div></div>

--001a1147bce67faa74056069bb56--