1100 lines
34 KiB
Nim
1100 lines
34 KiB
Nim
|
# beacon_chain
|
|||
|
|
# Copyright (c) 2018-2020 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
|
|||
|
|
# Standard library
|
|||
|
|
std/tables,
|
|||
|
|
# Status
|
|||
|
|
eth/db/kvstore,
|
|||
|
|
chronicles,
|
|||
|
|
nimcrypto/[hash, utils],
|
|||
|
|
serialization,
|
|||
|
|
json_serialization,
|
|||
|
|
# Internal
|
|||
|
|
./spec/[datatypes, digest, crypto],
|
|||
|
|
./ssz
|
|||
|
|
|
|||
|
|
# Requirements
|
|||
|
|
# --------------------------------------------
|
|||
|
|
#
|
|||
|
|
# Overview of slashing and how it ties in with the rest of Eth2.0
|
|||
|
|
#
|
|||
|
|
# Phase 0 for humans - Validator responsibilities:
|
|||
|
|
# - https://notes.ethereum.org/@djrtwo/Bkn3zpwxB#Validator-responsibilities
|
|||
|
|
#
|
|||
|
|
# Phase 0 spec - Honest Validator - how to avoid slashing
|
|||
|
|
# - https://github.com/ethereum/eth2.0-specs/blob/v0.12.2/specs/phase0/validator.md#how-to-avoid-slashing
|
|||
|
|
#
|
|||
|
|
# In-depth reading on slashing conditions
|
|||
|
|
#
|
|||
|
|
# - Detecting slashing conditions https://hackmd.io/@n0ble/By897a5sH
|
|||
|
|
# - Open issue on writing a slashing detector https://github.com/ethereum/eth2.0-pm/issues/63
|
|||
|
|
# - Casper the Friendly Finality Gadget, Vitalik Buterin and Virgil Griffith
|
|||
|
|
# https://arxiv.org/pdf/1710.09437.pdf
|
|||
|
|
# Figure 2
|
|||
|
|
# An individual validator ν MUST NOT publish two distinct votes,
|
|||
|
|
# 〈ν,s1,t1,h(s1),h(t1) AND〈ν,s2,t2,h(s2),h(t2)〉,
|
|||
|
|
# such that either:
|
|||
|
|
# I. h(t1) = h(t2).
|
|||
|
|
# Equivalently, a validator MUST NOT publish two distinct votes for the same target height.
|
|||
|
|
# OR
|
|||
|
|
# II. h(s1) < h(s2) < h(t2) < h(t1).
|
|||
|
|
# Equivalently, a validator MUST NOT vote within the span of its other votes.
|
|||
|
|
# - Vitalik's annotated spec: https://github.com/ethereum/annotated-spec/blob/d8c51af84f9f309d91c37379c1fcb0810bc5f10a/phase0/beacon-chain.md#proposerslashing
|
|||
|
|
# 1. A proposer can get slashed for signing two distinct headers at the same slot.
|
|||
|
|
# 2. An attester can get slashed for signing
|
|||
|
|
# two attestations that together violate
|
|||
|
|
# the Casper FFG slashing conditions.
|
|||
|
|
# - https://github.com/ethereum/eth2.0-specs/blob/v0.12.2/specs/phase0/validator.md#ffg-vote
|
|||
|
|
# The "source" is the current_justified_epoch
|
|||
|
|
# The "target" is the current_epoch
|
|||
|
|
#
|
|||
|
|
# Reading on weak subjectivity
|
|||
|
|
# - https://notes.ethereum.org/@adiasg/weak-subjectvity-eth2
|
|||
|
|
# - https://www.symphonious.net/2019/11/27/exploring-ethereum-2-weak-subjectivity-period/
|
|||
|
|
# - https://ethresear.ch/t/weak-subjectivity-under-the-exit-queue-model/5187
|
|||
|
|
#
|
|||
|
|
# Reading of interop serialization format
|
|||
|
|
# - Import/export format: https://hackmd.io/@sproul/Bk0Y0qdGD
|
|||
|
|
# - Tests: https://github.com/eth2-clients/slashing-protection-interchange-tests
|
|||
|
|
#
|
|||
|
|
# Relaxation for Nimbus
|
|||
|
|
#
|
|||
|
|
# We are not building a slashing detector but only protecting
|
|||
|
|
# attached validator from slashing, hence we make the following assumptions
|
|||
|
|
#
|
|||
|
|
# 1. We only need to store specific validators signed blocks and attestations
|
|||
|
|
# 2. We assume that our node is synced past
|
|||
|
|
# the last finalized epoch
|
|||
|
|
# hence we only need to keep track of blocks and attestations
|
|||
|
|
# since the last finalized epoch and we don't need to care
|
|||
|
|
# about the weak subjectivity period.
|
|||
|
|
# i.e. if `Node.isSynced()` returns false
|
|||
|
|
# a node skips its validator duties and doesn't invoke slashing protection.
|
|||
|
|
# and `isSynced` syncs at least up to the blockchain last finalized epoch.
|
|||
|
|
#
|
|||
|
|
# Hence the database or key-value store should support
|
|||
|
|
#
|
|||
|
|
# Queries
|
|||
|
|
# 1. db.signedBlockExistsFor(validator, slot) -> bool
|
|||
|
|
# 2. db.attestationExistsFor(validator, target_epoch) -> bool
|
|||
|
|
# 3. db.attestationSurrounds(validator, source_epoch, target_epoch)
|
|||
|
|
#
|
|||
|
|
# Update
|
|||
|
|
# 1. db.registerBlock(validator, slot, block_root)
|
|||
|
|
# 2. db.registerAttestation(validator, source_epoch, target_epoch, attestation_root)
|
|||
|
|
#
|
|||
|
|
# Maintenance
|
|||
|
|
# 1. db.prune(finalized_epoch)
|
|||
|
|
#
|
|||
|
|
# Interop
|
|||
|
|
# 1. db.import(json)
|
|||
|
|
# 2. db.export(json)
|
|||
|
|
# 3. db.export(json, validator)
|
|||
|
|
# 4. db.export(json, seq[validator])
|
|||
|
|
|
|||
|
|
# Technical Discussion
|
|||
|
|
# --------------------------------------------
|
|||
|
|
#
|
|||
|
|
# TODO: Merge with BeaconChainDB?
|
|||
|
|
# - https://stackoverflow.com/questions/21844479/multiple-databases-vs-single-database-with-logically-partitioned-data
|
|||
|
|
#
|
|||
|
|
# Reasons for merging
|
|||
|
|
# - Single database
|
|||
|
|
#
|
|||
|
|
# Reasons for not merging
|
|||
|
|
# - BeaconChainDB is about the beacon node itself
|
|||
|
|
# while slashing protection is about validators
|
|||
|
|
# - BeaconChainDB is append-only
|
|||
|
|
# while slashing protection will be pruned
|
|||
|
|
# at each finalization.
|
|||
|
|
# Hence we might want different backend in the future
|
|||
|
|
# - In a VC/BN split configuration the slashing protection
|
|||
|
|
# may be better attached to the VC. (VC: Validator Client, BN: Beacon Node)
|
|||
|
|
# - The slashing protection DB only held cryptographic hashes
|
|||
|
|
# and epoch/slot integers which are uncompressible
|
|||
|
|
# while BeaconChainDB is snappy-compressed.
|
|||
|
|
#
|
|||
|
|
# TODO: if we enshrine the split we likely want to use
|
|||
|
|
# a relational DB instead of KV-Store,
|
|||
|
|
# for efficient pruning and range queries support
|
|||
|
|
|
|||
|
|
# DB primitives
|
|||
|
|
# --------------------------------------------
|
|||
|
|
# Implementation
|
|||
|
|
#
|
|||
|
|
# As mentioned in the technical discussion
|
|||
|
|
# we currently use a simple KV-store abstraction
|
|||
|
|
# with no range queries or iterators.
|
|||
|
|
#
|
|||
|
|
# To support our requirements
|
|||
|
|
# we store block proposals and attestations
|
|||
|
|
# as per-validator linked lists
|
|||
|
|
|
|||
|
|
type
|
|||
|
|
SlashingProtectionDB* = ref object
|
|||
|
|
## Database storing the blocks attested
|
|||
|
|
## by validators attached to a beacon node
|
|||
|
|
## or validator client.
|
|||
|
|
backend: KvStoreRef
|
|||
|
|
|
|||
|
|
BadVoteKind* = enum
|
|||
|
|
## Attestation bad vote kind
|
|||
|
|
# h: height (i.e. epoch for attestation, slot for blocks)
|
|||
|
|
# t: target
|
|||
|
|
# s: source
|
|||
|
|
# 1: existing attestations
|
|||
|
|
# 2: candidate attestation
|
|||
|
|
|
|||
|
|
# Spec slashing condition
|
|||
|
|
DoubleVote # h(t1) = h(t2)
|
|||
|
|
SurroundedVote # h(s1) < h(s2) < h(t2) < h(t1)
|
|||
|
|
SurroundingVote # h(s2) < h(s1) < h(t1) < h(t2)
|
|||
|
|
# Non-spec, should never happen in a well functioning client
|
|||
|
|
TargetPrecedesSource # h(t1) < h(s1) - current epoch precedes last justified epoch
|
|||
|
|
|
|||
|
|
BadVote* = object
|
|||
|
|
case kind*: BadVoteKind
|
|||
|
|
of DoubleVote:
|
|||
|
|
existingAttestation*: Eth2Digest
|
|||
|
|
of SurroundedVote, SurroundingVote:
|
|||
|
|
existingAttestationRoot*: Eth2Digest # Many roots might be in conflict
|
|||
|
|
sourceExisting*, targetExisting*: Epoch
|
|||
|
|
sourceSlashable*, targetSlashable*: Epoch
|
|||
|
|
of TargetPrecedesSource:
|
|||
|
|
discard
|
|||
|
|
|
|||
|
|
SlotDesc = object
|
|||
|
|
# Using tuple instead of objects, crashes the Nim compiler
|
|||
|
|
# with SSZ serialization
|
|||
|
|
# Making this generic as well
|
|||
|
|
start, stop: Slot
|
|||
|
|
isInit: bool
|
|||
|
|
EpochDesc = object
|
|||
|
|
start, stop: Epoch
|
|||
|
|
isInit: bool
|
|||
|
|
|
|||
|
|
KeysEpochs = object
|
|||
|
|
## Per-validator linked lists start/stop
|
|||
|
|
blockSlots: SlotDesc
|
|||
|
|
sourceEpochs: EpochDesc
|
|||
|
|
targetEpochs: EpochDesc
|
|||
|
|
|
|||
|
|
SlashingKeyKind = enum
|
|||
|
|
# Note: source epochs are not unique
|
|||
|
|
# and so cannot be used to build a key
|
|||
|
|
kBlock
|
|||
|
|
kTargetEpoch
|
|||
|
|
kLinkedListMeta
|
|||
|
|
# Interchange format
|
|||
|
|
kGenesisValidatorRoot
|
|||
|
|
kNumValidators
|
|||
|
|
kValidator
|
|||
|
|
|
|||
|
|
BlockNode = object
|
|||
|
|
prev, next: Slot
|
|||
|
|
# TODO distinct type for block root vs all other ETH2Digest
|
|||
|
|
block_root: Eth2Digest
|
|||
|
|
|
|||
|
|
TargetEpochNode = object
|
|||
|
|
prev, next: Epoch
|
|||
|
|
# TODO distinct type for attestation root vs all other ETH2Digest
|
|||
|
|
attestation_root: Eth2Digest
|
|||
|
|
source: Epoch
|
|||
|
|
|
|||
|
|
ValID = array[RawPubKeySize, byte]
|
|||
|
|
## This is the serialized byte representation
|
|||
|
|
## of a Validator Public Key.
|
|||
|
|
## Portable between Miracl/BLST
|
|||
|
|
## and limits serialization/deserialization call
|
|||
|
|
|
|||
|
|
{.push raises: [Defect].}
|
|||
|
|
logScope:
|
|||
|
|
topics = "antislash"
|
|||
|
|
|
|||
|
|
const UseSlashingProtection* {.booldefine.} = true
|
|||
|
|
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
static: echo " Built with slashing protection"
|
|||
|
|
else:
|
|||
|
|
static: echo " Built without slashing protection"
|
|||
|
|
|
|||
|
|
func subkey(
|
|||
|
|
kind: static SlashingKeyKind,
|
|||
|
|
validator: ValID,
|
|||
|
|
slot: Slot
|
|||
|
|
): array[RawPubKeySize+8, byte] =
|
|||
|
|
static: doAssert kind == kBlock
|
|||
|
|
|
|||
|
|
# Big endian to get a naturally ascending order on slots in sorted indices
|
|||
|
|
result[0..<8] = toBytesBE(slot.uint64)
|
|||
|
|
# .. but 7 bytes should be enough for slots - in return, we get a nicely
|
|||
|
|
# rounded key length
|
|||
|
|
result[0] = byte ord(kBlock)
|
|||
|
|
result[8..<56] = validator
|
|||
|
|
|
|||
|
|
func subkey(
|
|||
|
|
kind: static SlashingKeyKind,
|
|||
|
|
validator: ValID,
|
|||
|
|
epoch: Epoch
|
|||
|
|
): array[RawPubKeySize+8, byte] =
|
|||
|
|
static: doAssert kind == kTargetEpoch, "Got invalid kind " & $kind
|
|||
|
|
|
|||
|
|
# Big endian to get a naturally ascending order on slots in sorted indices
|
|||
|
|
result[0..<8] = toBytesBE(epoch.uint64)
|
|||
|
|
# .. but 7 bytes should be enough for slots - in return, we get a nicely
|
|||
|
|
# rounded key length
|
|||
|
|
result[0] = byte ord(kind)
|
|||
|
|
result[8..<56] = validator
|
|||
|
|
|
|||
|
|
func subkey(
|
|||
|
|
kind: static SlashingKeyKind,
|
|||
|
|
validator: ValID
|
|||
|
|
): array[RawPubKeySize+1, byte] =
|
|||
|
|
static: doAssert kind == kLinkedListMeta
|
|||
|
|
|
|||
|
|
result[0] = byte ord(kLinkedListMeta)
|
|||
|
|
result[1 .. ^1] = validator
|
|||
|
|
|
|||
|
|
func subkey(kind: static SlashingKeyKind): array[1, byte] =
|
|||
|
|
static: doAssert kind in {kNumValidators, kGenesisValidatorRoot}
|
|||
|
|
result[0] = byte ord(kind)
|
|||
|
|
|
|||
|
|
func subkey(kind: static SlashingKeyKind, valIndex: uint32): array[5, byte] =
|
|||
|
|
static: doAssert kind == kValidator
|
|||
|
|
# Big endian to get a naturally ascending order on slots in sorted indices
|
|||
|
|
result[1..<5] = toBytesBE(valIndex)
|
|||
|
|
result[0] = byte ord(kind)
|
|||
|
|
|
|||
|
|
proc put(db: SlashingProtectionDB, key: openarray[byte], v: auto) =
|
|||
|
|
db.backend.put(
|
|||
|
|
key,
|
|||
|
|
SSZ.encode(v)
|
|||
|
|
).expect("working database")
|
|||
|
|
|
|||
|
|
proc get(db: SlashingProtectionDB,
|
|||
|
|
key: openarray[byte],
|
|||
|
|
T: typedesc): Opt[T] =
|
|||
|
|
|
|||
|
|
const ExpectedNodeSszSize = block:
|
|||
|
|
when T is BlockNode:
|
|||
|
|
2*sizeof(Epoch) + sizeof(Eth2Digest)
|
|||
|
|
elif T is TargetEpochNode:
|
|||
|
|
2*sizeof(Epoch) + sizeof(Eth2Digest) + sizeof(Epoch)
|
|||
|
|
elif T is KeysEpochs:
|
|||
|
|
2*sizeof(Slot) + 4*sizeof(Epoch) + 3*sizeof(bool)
|
|||
|
|
elif T is Eth2Digest:
|
|||
|
|
sizeof(Eth2Digest)
|
|||
|
|
elif T is uint32:
|
|||
|
|
sizeof(uint32)
|
|||
|
|
elif T is ValidatorPubKey:
|
|||
|
|
RawPubKeySize
|
|||
|
|
else:
|
|||
|
|
{.error: "Invalid database node type: " & $T.}
|
|||
|
|
## SSZ serialization is packed
|
|||
|
|
## However in-memory, BlockNode, TargetEpochNode
|
|||
|
|
## might be bigger due to alignment/compiler padding
|
|||
|
|
|
|||
|
|
var res: Opt[T]
|
|||
|
|
proc decode(data: openArray[byte]) =
|
|||
|
|
# We are capturing "result" and "T" from outer scope
|
|||
|
|
# And allocating on the heap which are not ideal
|
|||
|
|
# from a safety and performance point of view.
|
|||
|
|
try:
|
|||
|
|
if data.len == ExpectedNodeSszSize:
|
|||
|
|
when T is ValidatorPubKey:
|
|||
|
|
# symbol resolution bug
|
|||
|
|
# SSZ.decode doesn't see "fromSSZBytes"
|
|||
|
|
res.ok ValidatorPubKey.fromSszBytes(data)
|
|||
|
|
else:
|
|||
|
|
res.ok SSZ.decode(data, T) # captures from `get` scope
|
|||
|
|
else:
|
|||
|
|
# If the data can't be deserialized, it could be because it's from a
|
|||
|
|
# version of the software that uses a different SSZ encoding
|
|||
|
|
warn "Unable to deserialize data, old database?",
|
|||
|
|
typ = $T,
|
|||
|
|
dataLen = data.len,
|
|||
|
|
expectedSize = ExpectedNodeSszSize
|
|||
|
|
discard
|
|||
|
|
except SerializationError as e:
|
|||
|
|
# If the data can't be deserialized, it could be because it's from a
|
|||
|
|
# version of the software that uses a different SSZ encoding
|
|||
|
|
warn "Unable to deserialize data, old database?",
|
|||
|
|
typ = $T,
|
|||
|
|
dataLen = data.len,
|
|||
|
|
expectedSize = ExpectedNodeSszSize
|
|||
|
|
discard
|
|||
|
|
|
|||
|
|
discard db.backend.get(key, decode).expect("working database")
|
|||
|
|
|
|||
|
|
res
|
|||
|
|
|
|||
|
|
proc setGenesis(db: SlashingProtectionDB, genesis_validator_root: Eth2Digest) =
|
|||
|
|
# Workaround SSZ / nim-serialization visibility issue
|
|||
|
|
# "template WriterType(T: type SSZ): type"
|
|||
|
|
# by having a non-generic proc
|
|||
|
|
db.put(
|
|||
|
|
subkey(kGenesisValidatorRoot),
|
|||
|
|
genesis_validator_root
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
proc init*(
|
|||
|
|
T: type SlashingProtectionDB,
|
|||
|
|
genesis_validator_root: Eth2Digest,
|
|||
|
|
backend: KVStoreRef): SlashingProtectionDB =
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
result = T(backend: backend)
|
|||
|
|
result.setGenesis(genesis_validator_root)
|
|||
|
|
|
|||
|
|
proc close*(db: SlashingProtectionDB) =
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
discard db.backend.close()
|
|||
|
|
|
|||
|
|
# DB Queries
|
|||
|
|
# --------------------------------------------
|
|||
|
|
|
|||
|
|
proc checkSlashableBlockProposalImpl(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
slot: Slot
|
|||
|
|
): Result[void, Eth2Digest] =
|
|||
|
|
## Returns an error if the specified validator
|
|||
|
|
## already proposed a block for the specified slot.
|
|||
|
|
## This would lead to slashing.
|
|||
|
|
## The error contains the blockroot that was already proposed
|
|||
|
|
##
|
|||
|
|
## Returns success otherwise
|
|||
|
|
# TODO distinct type for the result block root
|
|||
|
|
let valID = validator.toRaw()
|
|||
|
|
let foundBlock = db.get(
|
|||
|
|
subkey(kBlock, valID, slot),
|
|||
|
|
BlockNode
|
|||
|
|
)
|
|||
|
|
if foundBlock.isNone():
|
|||
|
|
return ok()
|
|||
|
|
return err(foundBlock.unsafeGet().block_root)
|
|||
|
|
|
|||
|
|
proc checkSlashableBlockProposal*(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
slot: Slot
|
|||
|
|
): Result[void, Eth2Digest] =
|
|||
|
|
## Returns an error if the specified validator
|
|||
|
|
## already proposed a block for the specified slot.
|
|||
|
|
## This would lead to slashing.
|
|||
|
|
## The error contains the blockroot that was already proposed
|
|||
|
|
##
|
|||
|
|
## Returns success otherwise
|
|||
|
|
# TODO distinct type for the result block root
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
checkSlashableBlockProposalImpl(
|
|||
|
|
db, validator, slot
|
|||
|
|
)
|
|||
|
|
else:
|
|||
|
|
ok()
|
|||
|
|
|
|||
|
|
proc checkSlashableAttestationImpl(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
source: Epoch,
|
|||
|
|
target: Epoch
|
|||
|
|
): Result[void, BadVote] =
|
|||
|
|
## Returns an error if the specified validator
|
|||
|
|
## already proposed a block for the specified slot.
|
|||
|
|
## This would lead to slashing.
|
|||
|
|
## The error contains the blockroot that was already proposed
|
|||
|
|
##
|
|||
|
|
## Returns success otherwise
|
|||
|
|
# TODO distinct type for the result attestation root
|
|||
|
|
|
|||
|
|
let valID = validator.toRaw()
|
|||
|
|
|
|||
|
|
# Sanity
|
|||
|
|
# ---------------------------------
|
|||
|
|
if source > target:
|
|||
|
|
return err(BadVote(kind: TargetPrecedesSource))
|
|||
|
|
|
|||
|
|
# Casper FFG 1st slashing condition
|
|||
|
|
# Detect h(t1) = h(t2)
|
|||
|
|
# ---------------------------------
|
|||
|
|
let foundAttestation = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, target),
|
|||
|
|
TargetEpochNode
|
|||
|
|
)
|
|||
|
|
if foundAttestation.isSome():
|
|||
|
|
# Logged by caller
|
|||
|
|
return err(BadVote(
|
|||
|
|
kind: DoubleVote,
|
|||
|
|
existingAttestation: foundAttestation.unsafeGet().attestation_root
|
|||
|
|
))
|
|||
|
|
|
|||
|
|
# TODO: we hack KV-store range queries
|
|||
|
|
# ---------------------------------
|
|||
|
|
let maybeLL = db.get(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
if maybeLL.isNone:
|
|||
|
|
info "No slashing protection data - first attestation?",
|
|||
|
|
validator = validator,
|
|||
|
|
attSource = source,
|
|||
|
|
attTarget = target
|
|||
|
|
return ok()
|
|||
|
|
let ll = maybeLL.unsafeGet()
|
|||
|
|
if not ll.targetEpochs.isInit:
|
|||
|
|
info "No attestation slashing protection data - first attestation?",
|
|||
|
|
validator = validator,
|
|||
|
|
attSource = source,
|
|||
|
|
attTarget = target
|
|||
|
|
return ok()
|
|||
|
|
|
|||
|
|
# Chain reorg
|
|||
|
|
# Detect h(s2) < h(s1)
|
|||
|
|
# If the candidate attestation source precedes
|
|||
|
|
# source(s) we have in the SlashingProtectionDB
|
|||
|
|
# we have a chain reorg
|
|||
|
|
# ---------------------------------
|
|||
|
|
if source < ll.sourceEpochs.stop:
|
|||
|
|
warn "Detected a chain reorg",
|
|||
|
|
earliestJustifiedEpoch = ll.sourceEpochs.start,
|
|||
|
|
oldestJustifiedEpoch = ll.sourceEpochs.stop,
|
|||
|
|
reorgJustifiedEpoch = source,
|
|||
|
|
monitoredValidator = validator
|
|||
|
|
|
|||
|
|
# Casper FFG 2nd slashing condition
|
|||
|
|
# -> Surrounded vote
|
|||
|
|
# Detect h(s1) < h(s2) < h(t2) < h(t1)
|
|||
|
|
# ---------------------------------
|
|||
|
|
# Casper FFG 2nd slashing condition
|
|||
|
|
# -> Surrounding vote
|
|||
|
|
# Detect h(s2) < h(s1) < h(t1) < h(t2)
|
|||
|
|
# ---------------------------------
|
|||
|
|
|
|||
|
|
template s2: untyped = source
|
|||
|
|
template t2: untyped = target
|
|||
|
|
|
|||
|
|
# We start from the final target epoch
|
|||
|
|
var t1: Epoch
|
|||
|
|
var t1Node: TargetEpochNode
|
|||
|
|
|
|||
|
|
t1 = ll.targetEpochs.stop
|
|||
|
|
t1Node = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, t1),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
template s1: untyped = t1Node.source
|
|||
|
|
template ar1: untyped = t1Node.attestation_root
|
|||
|
|
|
|||
|
|
# Surrounding vote
|
|||
|
|
while true:
|
|||
|
|
if not(t1 < t2):
|
|||
|
|
# s1|s2 < t2 < t1 -> surrounded vote case
|
|||
|
|
break
|
|||
|
|
if s2 < s1:
|
|||
|
|
# s2 < s1 < t1 < t2
|
|||
|
|
# Logged by caller
|
|||
|
|
return err(BadVote(
|
|||
|
|
kind: SurroundingVote,
|
|||
|
|
existingAttestationRoot: ar1,
|
|||
|
|
sourceExisting: s1,
|
|||
|
|
targetExisting: t1,
|
|||
|
|
sourceSlashable: s2,
|
|||
|
|
targetSlashable: t2
|
|||
|
|
))
|
|||
|
|
|
|||
|
|
# Next iteration
|
|||
|
|
if t1Node.prev == default(Epoch) or
|
|||
|
|
t1Node.prev == ll.targetEpochs.stop:
|
|||
|
|
return ok()
|
|||
|
|
else:
|
|||
|
|
t1 = t1Node.prev
|
|||
|
|
t1Node = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, t1Node.prev),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
# Surrounded vote
|
|||
|
|
doAssert t2 < t1, "Checking surrounded vote"
|
|||
|
|
while true:
|
|||
|
|
if t1 < s2:
|
|||
|
|
# s1 < t1 < s2 < t2
|
|||
|
|
return ok()
|
|||
|
|
if s1 < s2:
|
|||
|
|
# s1 < s2 < t2 < t1
|
|||
|
|
# Logged by caller
|
|||
|
|
return err(BadVote(
|
|||
|
|
kind: SurroundedVote,
|
|||
|
|
existingAttestationRoot: ar1,
|
|||
|
|
sourceExisting: s1,
|
|||
|
|
targetExisting: t1,
|
|||
|
|
sourceSlashable: s2,
|
|||
|
|
targetSlashable: t2
|
|||
|
|
))
|
|||
|
|
|
|||
|
|
# Next iteration
|
|||
|
|
if t1Node.prev == default(Epoch) or
|
|||
|
|
t1Node.prev == ll.targetEpochs.stop:
|
|||
|
|
return ok()
|
|||
|
|
else:
|
|||
|
|
t1 = t1Node.prev
|
|||
|
|
t1Node = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, t1Node.prev),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
doAssert false, "Unreachable"
|
|||
|
|
|
|||
|
|
proc checkSlashableAttestation*(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
source: Epoch,
|
|||
|
|
target: Epoch
|
|||
|
|
): Result[void, BadVote] =
|
|||
|
|
## Returns an error if the specified validator
|
|||
|
|
## already proposed a block for the specified slot.
|
|||
|
|
## This would lead to slashing.
|
|||
|
|
## The error contains the blockroot that was already proposed
|
|||
|
|
##
|
|||
|
|
## Returns success otherwise
|
|||
|
|
# TODO distinct type for the result attestation root
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
checkSlashableAttestationImpl(
|
|||
|
|
db, validator, source, target
|
|||
|
|
)
|
|||
|
|
else:
|
|||
|
|
ok()
|
|||
|
|
|
|||
|
|
# DB update
|
|||
|
|
# --------------------------------------------
|
|||
|
|
|
|||
|
|
proc registerValidator(db: SlashingProtectionDB, validator: ValidatorPubKey) =
|
|||
|
|
## Add a new validator to the database
|
|||
|
|
## Assumes the validator does not exist
|
|||
|
|
let maybeNumVals = db.get(
|
|||
|
|
subkey(kNumValidators),
|
|||
|
|
uint32
|
|||
|
|
)
|
|||
|
|
var valIndex = 0'u32
|
|||
|
|
if maybeNumVals.isNone():
|
|||
|
|
db.put(subkey(kNumValidators), 1'u32)
|
|||
|
|
else:
|
|||
|
|
valIndex = maybeNumVals.unsafeGet()
|
|||
|
|
db.put(subkey(kNumValidators), valIndex + 1)
|
|||
|
|
|
|||
|
|
db.put(subkey(kValidator, valIndex), validator)
|
|||
|
|
|
|||
|
|
proc registerBlockImpl(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
slot: Slot, block_root: Eth2Digest) =
|
|||
|
|
## Add a block to the slashing protection DB
|
|||
|
|
## `checkSlashableBlockProposal` MUST be run
|
|||
|
|
## before to ensure no overwrite.
|
|||
|
|
|
|||
|
|
let valID = validator.toRaw()
|
|||
|
|
|
|||
|
|
# We want to keep the linked-list ordered
|
|||
|
|
# to ease pruning.
|
|||
|
|
# TODO: DB instead of KV-store,
|
|||
|
|
# at the very least we should isolate that logic
|
|||
|
|
let maybeLL = db.get(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
if maybeLL.isNone:
|
|||
|
|
info "No slashing protection data - initiating block tracking for validator",
|
|||
|
|
validator = validator
|
|||
|
|
|
|||
|
|
db.registerValidator(validator)
|
|||
|
|
|
|||
|
|
let node = BlockNode(
|
|||
|
|
block_root: block_root
|
|||
|
|
)
|
|||
|
|
db.put(subkey(kBlock, valID, slot), node)
|
|||
|
|
db.put(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs(
|
|||
|
|
blockSlots: SlotDesc(start: slot, stop: slot, isInit: true),
|
|||
|
|
# targetEpochs.isInit will be false
|
|||
|
|
)
|
|||
|
|
)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
var ll = maybeLL.unsafeGet()
|
|||
|
|
var cur = ll.blockSlots.stop
|
|||
|
|
if not ll.blockSlots.isInit:
|
|||
|
|
let node = BlockNode(
|
|||
|
|
block_root: block_root
|
|||
|
|
)
|
|||
|
|
ll.blockSlots = SlotDesc(start: slot, stop: slot, isInit: true)
|
|||
|
|
db.put(subkey(kBlock, valID, slot), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
if cur < slot:
|
|||
|
|
# Adding a block later than all known blocks
|
|||
|
|
let node = BlockNode(
|
|||
|
|
prev: cur,
|
|||
|
|
block_root: block_root
|
|||
|
|
)
|
|||
|
|
var prevNode = db.get(
|
|||
|
|
subkey(kBlock, valID, cur),
|
|||
|
|
BlockNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
prevNode.next = slot
|
|||
|
|
ll.blockSlots.stop = slot
|
|||
|
|
db.put(subkey(kBlock, valID, slot), node)
|
|||
|
|
db.put(subkey(kBlock, valID, cur), prevNode)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
# TODO: we likely want a proper DB or better KV-store high-level API
|
|||
|
|
# in the future.
|
|||
|
|
while true:
|
|||
|
|
var curNode = db.get(
|
|||
|
|
subkey(kBlock, valID, cur),
|
|||
|
|
BlockNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
if curNode.prev == ll.blockSlots.start:
|
|||
|
|
# Reached the beginning
|
|||
|
|
# Change: Metadata.start <-> cur
|
|||
|
|
# to: Metadata.start <-> new <-> cur
|
|||
|
|
# This should happen only if registerBlock
|
|||
|
|
# is called out-of-order
|
|||
|
|
warn "Validator proposal in the past - out-of-order antislash registration?",
|
|||
|
|
validator = validator,
|
|||
|
|
slot = slot,
|
|||
|
|
blockroot = blockroot,
|
|||
|
|
earliestBlockProposalSlotInDB = ll.blockSlots.start,
|
|||
|
|
latestBlockProposalSlotInDB = ll.blockSlots.stop
|
|||
|
|
var node = BlockNode(
|
|||
|
|
prev: ll.blockSlots.start,
|
|||
|
|
next: cur,
|
|||
|
|
block_root: block_root
|
|||
|
|
)
|
|||
|
|
ll.blockSlots.start = slot
|
|||
|
|
curNode.prev = slot
|
|||
|
|
db.put(subkey(kBlock, valID, slot), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kBlock, valID, cur), curNode)
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
elif slot < curNode.prev:
|
|||
|
|
# Reached: prev < slot < cur
|
|||
|
|
# Change: prev <-> cur
|
|||
|
|
# to: prev <-> new <-> cur
|
|||
|
|
let prev = curNode.prev
|
|||
|
|
var node = BlockNode(
|
|||
|
|
prev: prev, next: cur,
|
|||
|
|
block_root: block_root
|
|||
|
|
)
|
|||
|
|
var prevNode = db.get(
|
|||
|
|
subkey(kBlock, valID, prev),
|
|||
|
|
BlockNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
prevNode.next = slot
|
|||
|
|
curNode.prev = slot
|
|||
|
|
db.put(subkey(kBlock, valID, slot), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kBlock, valID, cur), curNode)
|
|||
|
|
db.put(subkey(kBlock, valID, prev), prevNode)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
# Previous
|
|||
|
|
cur = curNode.prev
|
|||
|
|
curNode = db.get(
|
|||
|
|
subkey(kBlock, valID, cur),
|
|||
|
|
BlockNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
proc registerBlock*(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
slot: Slot, block_root: Eth2Digest) =
|
|||
|
|
## Add a block to the slashing protection DB
|
|||
|
|
## `checkSlashableBlockProposal` MUST be run
|
|||
|
|
## before to ensure no overwrite.
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
registerBlockImpl(
|
|||
|
|
db, validator, slot, block_root
|
|||
|
|
)
|
|||
|
|
else:
|
|||
|
|
discard
|
|||
|
|
|
|||
|
|
proc registerAttestationImpl(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
source, target: Epoch,
|
|||
|
|
attestation_root: Eth2Digest) =
|
|||
|
|
## Add an attestation to the slashing protection DB
|
|||
|
|
## `checkSlashableAttestation` MUST be run
|
|||
|
|
## before to ensure no overwrite.
|
|||
|
|
|
|||
|
|
let valID = validator.toRaw()
|
|||
|
|
|
|||
|
|
# We want to keep the linked-list ordered
|
|||
|
|
# to ease pruning.
|
|||
|
|
# TODO: DB instead of KV-store,
|
|||
|
|
# at the very least we should isolate that logic
|
|||
|
|
let maybeLL = db.get(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
if maybeLL.isNone:
|
|||
|
|
info "No slashing protection data - initiating attestation tracking for validator",
|
|||
|
|
validator = validator
|
|||
|
|
|
|||
|
|
db.registerValidator(validator)
|
|||
|
|
|
|||
|
|
let node = TargetEpochNode(
|
|||
|
|
source: source,
|
|||
|
|
attestation_root: attestation_root
|
|||
|
|
)
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, target), node)
|
|||
|
|
db.put(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs(
|
|||
|
|
# blockSlots.isInit will be false
|
|||
|
|
sourceEpochs: EpochDesc(start: source, stop: source, isInit: true),
|
|||
|
|
targetEpochs: EpochDesc(start: target, stop: target, isInit: true)
|
|||
|
|
)
|
|||
|
|
)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
var ll = maybeLL.unsafeGet()
|
|||
|
|
var cur = ll.targetEpochs.stop
|
|||
|
|
if not ll.targetEpochs.isInit:
|
|||
|
|
let node = TargetEpochNode(
|
|||
|
|
attestation_root: attestation_root,
|
|||
|
|
source: source
|
|||
|
|
)
|
|||
|
|
ll.targetEpochs = EpochDesc(start: target, stop: target, isInit: true)
|
|||
|
|
ll.sourceEpochs = EpochDesc(start: source, stop: source, isInit: true)
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, target), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
block: # Update source epoch
|
|||
|
|
if ll.sourceEpochs.stop < source:
|
|||
|
|
ll.sourceEpochs.stop = source
|
|||
|
|
if source < ll.sourceEpochs.start:
|
|||
|
|
ll.sourceEpochs.start = source
|
|||
|
|
|
|||
|
|
if cur < target:
|
|||
|
|
# Adding an attestation later than all known blocks
|
|||
|
|
let node = TargetEpochNode(
|
|||
|
|
prev: cur,
|
|||
|
|
source: source,
|
|||
|
|
attestation_root: attestation_root
|
|||
|
|
)
|
|||
|
|
var prevNode = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, cur),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
prevNode.next = target
|
|||
|
|
ll.targetEpochs.stop = target
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, target), node)
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, cur), prevNode)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
# TODO: we likely want a proper DB or better KV-store high-level API
|
|||
|
|
# in the future.
|
|||
|
|
while true:
|
|||
|
|
var curNode = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, cur),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
if curNode.prev == ll.targetEpochs.start:
|
|||
|
|
# Reached the beginning
|
|||
|
|
# Change: Metadata.start <-> cur
|
|||
|
|
# to: Metadata.start <-> new <-> cur
|
|||
|
|
# This should happen only if registerAttestation
|
|||
|
|
# is called out-of-order or if the validator
|
|||
|
|
# changes its vote for an earlier fork than its latest vote
|
|||
|
|
warn "Validator vote targeting the past - out-of-order antislash registration or chain reorg?",
|
|||
|
|
validator = validator,
|
|||
|
|
source_epoch = source,
|
|||
|
|
target_epoch = target,
|
|||
|
|
attestation_root = attestation_root
|
|||
|
|
var node = TargetEpochNode(
|
|||
|
|
prev: ll.targetEpochs.start,
|
|||
|
|
next: cur,
|
|||
|
|
source: source,
|
|||
|
|
attestation_root: attestation_root
|
|||
|
|
)
|
|||
|
|
ll.targetEpochs.start = target
|
|||
|
|
curNode.prev = target
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, target), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, cur), curNode)
|
|||
|
|
db.put(subkey(kLinkedListMeta, valID), ll)
|
|||
|
|
return
|
|||
|
|
elif target < curNode.prev:
|
|||
|
|
# Reached: prev < target < cur
|
|||
|
|
# Change: prev <-> cur
|
|||
|
|
# to: prev <-> new <-> cur
|
|||
|
|
let prev = curNode.prev
|
|||
|
|
var node = TargetEpochNode(
|
|||
|
|
prev: prev, next: cur,
|
|||
|
|
source: source,
|
|||
|
|
attestation_root: attestation_root
|
|||
|
|
)
|
|||
|
|
var prevNode = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, prev),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
prevNode.next = target
|
|||
|
|
curNode.prev = target
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, target), node)
|
|||
|
|
# TODO: what if crash here?
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, cur), curNode)
|
|||
|
|
db.put(subkey(kTargetEpoch, valID, prev), prevNode)
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
# Previous
|
|||
|
|
cur = curNode.prev
|
|||
|
|
curNode = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, cur),
|
|||
|
|
TargetEpochNode
|
|||
|
|
# bug in Nim results, ".e" field inaccessible
|
|||
|
|
# ).expect("Consistent linked-list in DB")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
proc registerAttestation*(
|
|||
|
|
db: SlashingProtectionDB,
|
|||
|
|
validator: ValidatorPubKey,
|
|||
|
|
source, target: Epoch,
|
|||
|
|
attestation_root: Eth2Digest) =
|
|||
|
|
## Add an attestation to the slashing protection DB
|
|||
|
|
## `checkSlashableAttestation` MUST be run
|
|||
|
|
## before to ensure no overwrite.
|
|||
|
|
when UseSlashingProtection:
|
|||
|
|
registerAttestationImpl(
|
|||
|
|
db, validator, source, target, attestation_root
|
|||
|
|
)
|
|||
|
|
else:
|
|||
|
|
discard
|
|||
|
|
|
|||
|
|
# DB maintenance
|
|||
|
|
# --------------------------------------------
|
|||
|
|
# TODO: pruning
|
|||
|
|
# Note that the complete interchange format
|
|||
|
|
# requires all proposals/attestations ever and so prevent pruning.
|
|||
|
|
|
|||
|
|
# Interchange
|
|||
|
|
# --------------------------------------------
|
|||
|
|
|
|||
|
|
type
|
|||
|
|
SPDIF = object
|
|||
|
|
## Slashing Protection Database Interchange Format
|
|||
|
|
metadata: SPDIF_Meta
|
|||
|
|
data: seq[SPDIF_Validator]
|
|||
|
|
|
|||
|
|
Eth2Digest0x = distinct Eth2Digest
|
|||
|
|
## The spec mandates "0x" prefix on serialization
|
|||
|
|
## So we need to set custom read/write
|
|||
|
|
PubKey0x = distinct ValidatorPubKey
|
|||
|
|
## The spec mandates "0x" prefix on serialization
|
|||
|
|
## So we need to set custom read/write
|
|||
|
|
|
|||
|
|
SPDIF_Meta = object
|
|||
|
|
interchange_format: string
|
|||
|
|
interchange_format_version: string
|
|||
|
|
genesis_validator_root: Eth2Digest0x
|
|||
|
|
|
|||
|
|
SPDIF_Validator = object
|
|||
|
|
pubkey: PubKey0x
|
|||
|
|
signed_blocks: seq[SPDIF_SignedBlock]
|
|||
|
|
signed_attestations: seq[SPDIF_SignedAttestation]
|
|||
|
|
|
|||
|
|
SPDIF_SignedBlock = object
|
|||
|
|
slot: Slot
|
|||
|
|
signing_root: Eth2Digest0x # compute_signing_root(block, domain)
|
|||
|
|
|
|||
|
|
SPDIF_SignedAttestation = object
|
|||
|
|
source_epoch: Epoch
|
|||
|
|
target_epoch: Epoch
|
|||
|
|
signing_root: Eth2Digest0x # compute_signing_root(attestation, domain)
|
|||
|
|
|
|||
|
|
proc writeValue*(writer: var JsonWriter, value: PubKey0x)
|
|||
|
|
{.inline, raises: [IOError, Defect].} =
|
|||
|
|
writer.writeValue("0x" & value.ValidatorPubKey.toHex())
|
|||
|
|
|
|||
|
|
proc readValue*(reader: var JsonReader, value: var PubKey0x)
|
|||
|
|
{.raises: [SerializationError, IOError, Defect].} =
|
|||
|
|
let key = ValidatorPubKey.fromHex(reader.readValue(string))
|
|||
|
|
if key.isOk:
|
|||
|
|
value = PubKey0x key.get
|
|||
|
|
else:
|
|||
|
|
# TODO: Can we provide better diagnostic?
|
|||
|
|
raiseUnexpectedValue(reader, "Valid hex-encoded public key expected")
|
|||
|
|
|
|||
|
|
proc writeValue*(w: var JsonWriter, a: Eth2Digest0x)
|
|||
|
|
{.inline, raises: [IOError, Defect].} =
|
|||
|
|
w.writeValue "0x" & a.Eth2Digest.data.toHex(lowercase = true)
|
|||
|
|
|
|||
|
|
proc readValue*(r: var JsonReader, a: var Eth2Digest0x)
|
|||
|
|
{.raises: [SerializationError, IOError, Defect].} =
|
|||
|
|
try:
|
|||
|
|
a = Eth2Digest0x fromHex(Eth2Digest, r.readValue(string))
|
|||
|
|
except ValueError:
|
|||
|
|
raiseUnexpectedValue(r, "Hex string expected")
|
|||
|
|
|
|||
|
|
proc toSPDIF*(db: SlashingProtectionDB, path: string)
|
|||
|
|
{.raises: [IOError, Defect].} =
|
|||
|
|
## Export the full slashing protection database
|
|||
|
|
## to a json the Slashing Protection Database Interchange (Complete) Format
|
|||
|
|
var extract: SPDIF
|
|||
|
|
extract.metadata.interchange_format = "complete"
|
|||
|
|
extract.metadata.interchange_format_version = "3"
|
|||
|
|
extract.metadata.genesis_validator_root = Eth2Digest0x db.get(
|
|||
|
|
subkey(kGenesisValidatorRoot), ETH2Digest
|
|||
|
|
# Bug in results.nim
|
|||
|
|
# ).expect("Slashing Protection requires genesis_validator_root at init")
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
let numValidators = db.get(
|
|||
|
|
subkey(kNumValidators),
|
|||
|
|
uint32
|
|||
|
|
).get(otherwise = 0'u32)
|
|||
|
|
|
|||
|
|
for i in 0'u32 ..< numValidators:
|
|||
|
|
var validator: SPDIF_Validator
|
|||
|
|
validator.pubkey = PubKey0x db.get(
|
|||
|
|
subkey(kValidator, i),
|
|||
|
|
ValidatorPubKey
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
let valID = validator.pubkey.ValidatorPubKey.toRaw()
|
|||
|
|
let ll = db.get(
|
|||
|
|
subkey(kLinkedListMeta, valID),
|
|||
|
|
KeysEpochs
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
if ll.blockSlots.isInit:
|
|||
|
|
var curSlot = ll.blockSlots.start
|
|||
|
|
while true:
|
|||
|
|
let node = db.get(
|
|||
|
|
subkey(kBlock, valID, curSlot),
|
|||
|
|
BlockNode
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
validator.signed_blocks.add SPDIF_SignedBlock(
|
|||
|
|
slot: curSlot,
|
|||
|
|
signing_root: Eth2Digest0x node.block_root
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
if curSlot == ll.blockSlots.stop:
|
|||
|
|
break
|
|||
|
|
else:
|
|||
|
|
curSlot = node.next
|
|||
|
|
|
|||
|
|
if ll.targetEpochs.isInit:
|
|||
|
|
var curEpoch = ll.targetEpochs.start
|
|||
|
|
var count = 0
|
|||
|
|
while true:
|
|||
|
|
let node = db.get(
|
|||
|
|
subkey(kTargetEpoch, valID, curEpoch),
|
|||
|
|
TargetEpochNode
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
validator.signed_attestations.add SPDIF_SignedAttestation(
|
|||
|
|
source_epoch: node.source, target_epoch: curEpoch,
|
|||
|
|
signing_root: Eth2Digest0x node.attestation_root
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
if curEpoch == ll.targetEpochs.stop:
|
|||
|
|
break
|
|||
|
|
else:
|
|||
|
|
curEpoch = node.next
|
|||
|
|
|
|||
|
|
inc count
|
|||
|
|
doAssert count < 5
|
|||
|
|
|
|||
|
|
# Update extract without reallocating seqs
|
|||
|
|
# by manually transferring ownership
|
|||
|
|
extract.data.setLen(extract.data.len + 1)
|
|||
|
|
shallowCopy(extract.data[^1], validator)
|
|||
|
|
|
|||
|
|
Json.saveFile(path, extract, pretty = true)
|
|||
|
|
echo "Exported slashing protection DB to '", path, "'"
|
|||
|
|
|
|||
|
|
proc fromSPDIF*(db: SlashingProtectionDB, path: string): bool
|
|||
|
|
{.raises: [SerializationError, IOError, Defect].} =
|
|||
|
|
## Import a (Complete) Slashing Protection Database Interchange Format
|
|||
|
|
## file into the specified slahsing protection DB
|
|||
|
|
##
|
|||
|
|
## The database must be initialized.
|
|||
|
|
## The genesis_validator_root must match or
|
|||
|
|
## the DB must have a zero root
|
|||
|
|
|
|||
|
|
let extract = Json.loadFile(path, SPDIF)
|
|||
|
|
|
|||
|
|
doAssert not db.isNil, "The Slashing Protection DB must be initialized."
|
|||
|
|
doAssert not db.backend.isNil, "The Slashing Protection DB must be initialized."
|
|||
|
|
|
|||
|
|
let dbGenValRoot = db.get(
|
|||
|
|
subkey(kGenesisValidatorRoot), ETH2Digest
|
|||
|
|
).unsafeGet()
|
|||
|
|
|
|||
|
|
if dbGenValRoot != default(Eth2Digest) and
|
|||
|
|
dbGenValRoot != extract.metadata.genesis_validator_root.Eth2Digest:
|
|||
|
|
echo "The slashing protection database and imported file refer to different blockchains."
|
|||
|
|
return false
|
|||
|
|
|
|||
|
|
if dbGenValRoot == default(Eth2Digest):
|
|||
|
|
db.put(
|
|||
|
|
subkey(kGenesisValidatorRoot),
|
|||
|
|
extract.metadata.genesis_validator_root.Eth2Digest
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
for v in 0 ..< extract.data.len:
|
|||
|
|
for b in 0 ..< extract.data[v].signed_blocks.len:
|
|||
|
|
db.registerBlock(
|
|||
|
|
extract.data[v].pubkey.ValidatorPubKey,
|
|||
|
|
extract.data[v].signed_blocks[b].slot,
|
|||
|
|
extract.data[v].signed_blocks[b].signing_root.Eth2Digest
|
|||
|
|
)
|
|||
|
|
for a in 0 ..< extract.data[v].signed_attestations.len:
|
|||
|
|
db.registerAttestation(
|
|||
|
|
extract.data[v].pubkey.ValidatorPubKey,
|
|||
|
|
extract.data[v].signed_attestations[a].source_epoch,
|
|||
|
|
extract.data[v].signed_attestations[a].target_epoch,
|
|||
|
|
extract.data[v].signed_attestations[a].signing_root.Eth2Digest
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
return true
|