nimbus-eth1/nimbus/sync/beacon/skeleton_algo.nim

499 lines
16 KiB
Nim
Raw Normal View History

# Nimbus
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at
# https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at
# https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed
# except according to those terms.
import
./skeleton_desc,
./skeleton_utils,
./skeleton_db,
../../utils/utils
{.push gcsafe, raises: [].}
logScope:
topics = "skeleton"
# ------------------------------------------------------------------------------
# Private helpers
# ------------------------------------------------------------------------------
proc fastForwardHead(sk: SkeletonRef, last: Segment, target: uint64): Result[void, string] =
# Try fast forwarding the chain head to the number
let
head = last.head
maybeHead = sk.getHeader(head, true).valueOr:
return err(error)
if maybeHead.isNone:
return ok()
var
headBlock = maybeHead.get
headBlockHash = headBlock.blockHash
for newHead in head + 1 .. target:
let maybeHead = sk.getHeader(newHead, true).valueOr:
return err(error)
if maybeHead.isNone:
break
let newBlock = maybeHead.get
if newBlock.parentHash != headBlockHash:
# Head can't be updated forward
break
headBlock = newBlock
headBlockHash = headBlock.blockHash
last.head = headBlock.u64
debug "lastchain head fast forwarded",
`from`=head, to=last.head, tail=last.tail
ok()
proc backStep(sk: SkeletonRef): Result[uint64, string] =
if sk.conf.fillCanonicalBackStep <= 0:
return ok(0)
let sc = sk.last
var
newTail = sc.tail
maybeTailHeader: Opt[BlockHeader]
while true:
newTail = newTail + sk.conf.fillCanonicalBackStep
maybeTailHeader = sk.getHeader(newTail, true).valueOr:
return err(error)
if maybeTailHeader.isSome or newTail > sc.head: break
if newTail > sc.head:
newTail = sc.head
maybeTailHeader = sk.getHeader(newTail, true).valueOr:
return err(error)
if maybeTailHeader.isSome and newTail > 0:
debug "Backstepped skeleton", head=sc.head, tail=newTail
let tailHeader = maybeTailHeader.get
sk.last.tail = tailHeader.u64
sk.last.next = tailHeader.parentHash
sk.writeProgress()
return ok(newTail)
# we need a new head, emptying the subchains
sk.clear()
sk.writeProgress()
debug "Couldn't backStep subchain 0, dropping subchains for new head signal"
return ok(0)
# ------------------------------------------------------------------------------
# Public functions
# ------------------------------------------------------------------------------
proc isLinked*(sk: SkeletonRef): Result[bool, string] =
## Returns true if the skeleton chain is linked to canonical
if sk.isEmpty:
return ok(false)
let sc = sk.last
# if its genesis we are linked
if sc.tail == 0:
return ok(true)
let head = sk.blockHeight
if sc.tail > head + 1:
return ok(false)
let number = sc.tail - 1
let maybeHeader = sk.getHeader(number).valueOr:
return err("isLinked: " & error)
# The above sc.tail > head - 1
# assure maybeHeader.isSome
doAssert maybeHeader.isSome
let nextHeader = maybeHeader.get
let linked = sc.next == nextHeader.blockHash
if linked and sk.len > 1:
# Remove all other subchains as no more relevant
sk.removeAllButLast()
sk.writeProgress()
return ok(linked)
proc trySubChainsMerge*(sk: SkeletonRef): Result[bool, string] =
var
merged = false
edited = false
# If the subchain extended into the next subchain, we need to handle
# the overlap. Since there could be many overlaps, do this in a loop.
while sk.len > 1 and sk.second.head >= sk.last.tail:
# Extract some stats from the second subchain
let sc = sk.second
# Since we just overwrote part of the next subchain, we need to trim
# its head independent of matching or mismatching content
if sc.tail >= sk.last.tail:
# Fully overwritten, get rid of the subchain as a whole
debug "Previous subchain fully overwritten", sub=sc
sk.removeSecond()
edited = true
continue
else:
# Partially overwritten, trim the head to the overwritten size
debug "Previous subchain partially overwritten", sub=sc
sc.head = sk.last.tail - 1
edited = true
# If the old subchain is an extension of the new one, merge the two
# and let the skeleton syncer restart (to clean internal state)
let
maybeSecondHead = sk.getHeader(sk.second.head).valueOr:
return err(error)
secondHeadHash = maybeSecondHead.blockHash
if maybeSecondHead.isSome and secondHeadHash == sk.last.next:
# only merge if we can integrate a big progress, as each merge leads
# to disruption of the block fetcher to start a fresh
if (sc.head - sc.tail) > sk.conf.subchainMergeMinimum:
debug "Previous subchain merged head", sub=sc
sk.last.tail = sc.tail
sk.last.next = sc.next
sk.removeSecond()
# If subchains were merged, all further available headers
# are invalid since we skipped ahead.
merged = true
else:
debug "Subchain ignored for merge", sub=sc
sk.removeSecond()
edited = true
if edited: sk.writeProgress()
ok(merged)
proc putBlocks*(sk: SkeletonRef, headers: openArray[BlockHeader]):
Result[StatusAndNumber, string] =
## Writes skeleton blocks to the db by number
## @returns number of blocks saved
var
merged = false
tailUpdated = false
if sk.len == 0:
return err("no subchain set")
# best place to debug beacon downloader
when false:
var numbers: seq[uint64]
for header in headers:
numbers.add header.u64
debugEcho numbers
for header in headers:
let
number = header.u64
headerHash = header.blockHash
if number >= sk.last.tail:
# These blocks should already be in skeleton, and might be coming in
# from previous events especially if the previous subchains merge
continue
elif number == 0:
let genesisHash = sk.genesisHash
if headerHash == genesisHash:
return err("Skeleton pubBlocks with invalid genesis block " &
"number=" & $number &
", hash=" & headerHash.short &
", genesisHash=" & genesisHash.short)
continue
# Extend subchain or create new segment if necessary
if sk.last.next == headerHash:
sk.putHeader(header)
sk.pulled += 1
sk.last.tail = number
sk.last.next = header.parentHash
tailUpdated = true
else:
# Critical error, we expect new incoming blocks to extend the canonical
# subchain which is the [0]'th
debug "Blocks don't extend canonical subchain",
sub=sk.last,
number,
hash=headerHash.short
return err("Blocks don't extend canonical subchain")
merged = sk.trySubChainsMerge().valueOr:
return err(error)
if tailUpdated or merged:
sk.progress.canonicalHeadReset = true
# If its merged, we need to break as the new tail could be quite ahead
# so we need to clear out and run the reverse block fetcher again
if merged: break
sk.writeProgress()
# Print a progress report making the UX a bit nicer
#if getTime() - sk.logged > STATUS_LOG_INTERVAL:
# var left = sk.last.tail - 1 - sk.blockHeight
# if sk.progress.linked: left = 0
# if left > 0:
# sk.logged = getTime()
# if sk.pulled == 0:
# info "Beacon sync starting", left=left
# else:
# let sinceStarted = getTime() - sk.started
# let eta = (sinceStarted div sk.pulled.int64) * left.int64
# info "Syncing beacon headers",
# downloaded=sk.pulled, left=left, eta=eta.short
sk.progress.linked = sk.isLinked().valueOr:
return err(error)
var res = StatusAndNumber(number: headers.len.uint64)
# If the sync is finished, start filling the canonical chain.
if sk.progress.linked:
res.status.incl FillCanonical
if merged:
res.status.incl SyncMerged
ok(res)
# Inserts skeleton blocks into canonical chain and runs execution.
proc fillCanonicalChain*(sk: SkeletonRef): Result[void, string] =
if sk.filling: return ok()
sk.filling = true
var
canonicalHead = sk.blockHeight
maybeOldHead = Opt.none BlockHeader
let subchain = sk.last
if sk.progress.canonicalHeadReset:
# Grab previous head block in case of resettng canonical head
let oldHead = sk.canonicalHead().valueOr:
return err(error)
maybeOldHead = Opt.some oldHead
if subchain.tail > canonicalHead + 1:
return err("Canonical head should already be on or " &
"ahead subchain tail canonicalHead=" &
$canonicalHead & ", tail=" & $subchain.tail)
let newHead = if subchain.tail > 0: subchain.tail - 1
else: 0
debug "Resetting canonicalHead for fillCanonicalChain",
`from`=canonicalHead, to=newHead
canonicalHead = newHead
sk.resetCanonicalHead(canonicalHead, oldHead.u64)
sk.progress.canonicalHeadReset = false
let start {.used.} = canonicalHead
# This subchain is a reference to update the tail for
# the very subchain we are filling the data for
debug "Starting canonical chain fill",
canonicalHead, subchainHead=subchain.head
while sk.filling and canonicalHead < subchain.head:
# Get next block
let
number = canonicalHead + 1
maybeHeader = sk.getHeader(number).valueOr:
return err(error)
if maybeHeader.isNone:
# This shouldn't happen, but if it does because of some issues,
# we should back step and fetch again
debug "fillCanonicalChain block not found, backStepping", number
sk.backStep().isOkOr:
return err(error)
break
# Insert into chain
let header = maybeHeader.get
let res = sk.insertBlock(header, true)
if res.isErr:
let maybeHead = sk.getHeader(subchain.head).valueOr:
return err(error)
# In post-merge, notify the engine API of encountered bad chains
if maybeHead.isSome:
sk.com.notifyBadBlock(header, maybeHead.get)
debug "fillCanonicalChain putBlock", msg=res.error
if maybeOldHead.isSome:
let oldHead = maybeOldHead.get
if oldHead.u64 >= number:
# Put original canonical head block back if reorg fails
sk.insertBlock(oldHead, true).isOkOr:
return err(error)
let numBlocksInserted = res.valueOr: 0
if numBlocksInserted != 1:
debug "Failed to put block from skeleton chain to canonical",
number=number,
hash=header.blockHashStr,
parentHash=header.parentHash.short
# Lets log some parent by number and parent by hash, that may help to understand whats going on
let parent {.used.} = sk.getHeader(number - 1).valueOr:
return err(error)
debug "ParentByNumber", number=parent.numberStr, hash=parent.blockHashStr
let parentWithHash {.used.} = sk.getHeader(header.parentHash).valueOr:
return err(error)
debug "parentByHash",
number=parentWithHash.numberStr,
hash=parentWithHash.blockHashStr
sk.backStep().isOkOr:
return err(error)
break
canonicalHead += numBlocksInserted
sk.fillLogIndex += numBlocksInserted
# Delete skeleton block to clean up as we go, if block is fetched and chain is linked
# it will be fetched from the chain without any issues
sk.deleteHeaderAndBody(header)
if sk.fillLogIndex >= 20:
debug "Skeleton canonical chain fill status",
canonicalHead,
chainHead=sk.blockHeight,
subchainHead=subchain.head
sk.fillLogIndex = 0
sk.filling = false
debug "Successfully put blocks from skeleton chain to canonical",
start, `end`=canonicalHead,
skeletonHead=subchain.head
ok()
proc processNewHead*(sk: SkeletonRef, head: BlockHeader,
force = false): Result[bool, string] =
## processNewHead does the internal shuffling for a new head marker and either
## accepts and integrates it into the skeleton or requests a reorg. Upon reorg,
## the syncer will tear itself down and restart with a fresh head. It is simpler
## to reconstruct the sync state than to mutate it.
## @returns true if the chain was reorged
# If the header cannot be inserted without interruption, return an error for
# the outer loop to tear down the skeleton sync and restart it
let
number = head.u64
headHash = head.blockHash
genesisHash = sk.genesisHash
if number == 0:
if headHash != genesisHash:
return err("Invalid genesis setHead announcement " &
"number=" & $number &
", hash=" & headHash.short &
", genesisHash=" & genesisHash.short
)
# genesis announcement
return ok(false)
let last = if sk.isEmpty:
debug "Skeleton empty, comparing against genesis head=0 tail=0",
newHead=number
# set the lastchain to genesis for comparison in
# following conditions
segment(0, 0, zeroBlockHash)
else:
sk.last
if last.tail > number:
# Not a noop / double head announce, abort with a reorg
if force:
debug "Skeleton setHead before tail, resetting skeleton",
tail=last.tail, head=last.head, newHead=number
last.head = number
last.tail = number
last.next = head.parentHash
else:
debug "Skeleton announcement before tail, will reset skeleton",
tail=last.tail, head=last.head, newHead=number
return ok(true)
elif last.head >= number:
# Check if its duplicate announcement, if not trim the head and
# let the match run after this if block
let maybeDupBlock = sk.getHeader(number).valueOr:
return err(error)
let maybeDupHash = maybeDupBlock.blockHash
if maybeDupBlock.isSome and maybeDupHash == headHash:
debug "Skeleton duplicate announcement",
tail=last.tail, head=last.head, number, hash=headHash.short
return ok(false)
else:
# Since its not a dup block, so there is reorg in the chain or at least
# in the head which we will let it get addressed after this if else block
if force:
debug "Skeleton differing announcement",
tail=last.tail,
head=last.head,
number=number,
expected=maybeDupHash.short,
actual=headHash.short
else:
debug "Skeleton stale announcement",
tail=last.tail,
head=last.head,
number
return ok(true)
elif last.head + 1 < number:
if force:
sk.fastForwardHead(last, number - 1).isOkOr:
return err(error)
# If its still less than number then its gapped head
if last.head + 1 < number:
debug "Beacon chain gapped setHead",
head=last.head, newHead=number
return ok(true)
else:
debug "Beacon chain gapped announcement",
head=last.head, newHead=number
return ok(true)
let maybeParent = sk.getHeader(number - 1).valueOr:
return err(error)
let parentHash = maybeParent.blockHash
if maybeParent.isNone or parentHash != head.parentHash:
if force:
debug "Beacon chain forked",
ancestor=maybeParent.numberStr,
hash=maybeParent.blockHashStr,
want=head.parentHash.short
return ok(true)
if force:
last.head = number
if sk.isEmpty:
# If there was no subchain to being with i.e. initialized from genesis
# and no reorg then push in subchains else the reorg handling will
# push the new chain
sk.push(last)
sk.progress.linked = sk.isLinked.valueOr:
return err(error)
debug "Beacon chain extended new", last
return ok(false)