288 lines
10 KiB
Nim
288 lines
10 KiB
Nim
# Nimbus
|
|
# Copyright (c) 2021-2023 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.
|
|
|
|
{.push raises: [].}
|
|
|
|
import
|
|
std/os,
|
|
confutils, confutils/std/net, chronicles, chronicles/topics_registry,
|
|
chronos, metrics, metrics/chronos_httpserver, json_rpc/clients/httpclient,
|
|
json_rpc/rpcproxy, stew/[byteutils, io2, results],
|
|
eth/keys, eth/net/nat,
|
|
eth/p2p/discoveryv5/protocol as discv5_protocol,
|
|
beacon_chain/beacon_clock,
|
|
beacon_chain/spec/forks,
|
|
beacon_chain/spec/datatypes/altair,
|
|
beacon_chain/gossip_processing/light_client_processor,
|
|
./conf, ./network_metadata, ./common/common_utils,
|
|
./rpc/[rpc_web3_api, rpc_eth_api, rpc_discovery_api, rpc_portal_api,
|
|
rpc_portal_debug_api],
|
|
./network/state/[state_network, state_content],
|
|
./network/history/[history_network, history_content],
|
|
./network/beacon_light_client/[
|
|
beacon_light_client_init_loader,
|
|
beacon_light_client,
|
|
],
|
|
./network/wire/[portal_stream, portal_protocol_config],
|
|
./eth_data/history_data_ssz_e2s,
|
|
./content_db,
|
|
./version, ./logging
|
|
|
|
chronicles.formatIt(IoErrorCode): $it
|
|
|
|
proc initBeaconLightClient(
|
|
network: LightClientNetwork, networkData: NetworkInitData,
|
|
trustedBlockRoot: Option[Eth2Digest]): LightClient =
|
|
let
|
|
getBeaconTime = networkData.clock.getBeaconTimeFn()
|
|
|
|
refDigests = newClone networkData.forks
|
|
|
|
lc = LightClient.new(
|
|
network,
|
|
network.portalProtocol.baseProtocol.rng,
|
|
networkData.metadata.cfg,
|
|
refDigests,
|
|
getBeaconTime,
|
|
networkData.genesis_validators_root,
|
|
LightClientFinalizationMode.Optimistic
|
|
)
|
|
|
|
# TODO: For now just log new headers. Ultimately we should also use callbacks
|
|
# for each lc object to save them to db and offer them to the network.
|
|
# TODO-2: The above statement sounds that this work should really be done at a
|
|
# later lower, and these callbacks are rather for use for the "application".
|
|
proc onFinalizedHeader(
|
|
lightClient: LightClient, finalizedHeader: ForkedLightClientHeader) =
|
|
withForkyHeader(finalizedHeader):
|
|
when lcDataFork > LightClientDataFork.None:
|
|
info "New LC finalized header",
|
|
finalized_header = shortLog(forkyHeader)
|
|
|
|
proc onOptimisticHeader(
|
|
lightClient: LightClient, optimisticHeader: ForkedLightClientHeader) =
|
|
withForkyHeader(optimisticHeader):
|
|
when lcDataFork > LightClientDataFork.None:
|
|
info "New LC optimistic header",
|
|
optimistic_header = shortLog(forkyHeader)
|
|
|
|
lc.onFinalizedHeader = onFinalizedHeader
|
|
lc.onOptimisticHeader = onOptimisticHeader
|
|
lc.trustedBlockRoot = trustedBlockRoot
|
|
|
|
# proc onSecond(time: Moment) =
|
|
# let wallSlot = getBeaconTime().slotOrZero()
|
|
# # TODO this is a place to enable/disable gossip based on the current status
|
|
# # of light client
|
|
# # lc.updateGossipStatus(wallSlot + 1)
|
|
|
|
# proc runOnSecondLoop() {.async.} =
|
|
# let sleepTime = chronos.seconds(1)
|
|
# while true:
|
|
# let start = chronos.now(chronos.Moment)
|
|
# await chronos.sleepAsync(sleepTime)
|
|
# let afterSleep = chronos.now(chronos.Moment)
|
|
# let sleepTime = afterSleep - start
|
|
# onSecond(start)
|
|
# let finished = chronos.now(chronos.Moment)
|
|
# let processingTime = finished - afterSleep
|
|
# trace "onSecond task completed", sleepTime, processingTime
|
|
|
|
# onSecond(Moment.now())
|
|
|
|
# asyncSpawn runOnSecondLoop()
|
|
|
|
lc
|
|
|
|
proc run(config: PortalConf) {.raises: [CatchableError].} =
|
|
setupLogging(config.logLevel, config.logStdout)
|
|
|
|
notice "Launching Fluffy",
|
|
version = fullVersionStr, cmdParams = commandLineParams()
|
|
|
|
# Make sure dataDir exists
|
|
let pathExists = createPath(config.dataDir.string)
|
|
if pathExists.isErr():
|
|
fatal "Failed to create data directory", dataDir = config.dataDir,
|
|
error = pathExists.error
|
|
quit 1
|
|
|
|
let
|
|
rng = newRng()
|
|
bindIp = config.listenAddress
|
|
udpPort = Port(config.udpPort)
|
|
# TODO: allow for no TCP port mapping!
|
|
(extIp, _, extUdpPort) =
|
|
try: setupAddress(config.nat,
|
|
config.listenAddress, udpPort, udpPort, "dcli")
|
|
except CatchableError as exc: raise exc
|
|
# TODO: Ideally we don't have the Exception here
|
|
except Exception as exc: raiseAssert exc.msg
|
|
netkey =
|
|
if config.networkKey.isSome():
|
|
config.networkKey.get()
|
|
else:
|
|
getPersistentNetKey(rng[], config.networkKeyFile, config.dataDir.string)
|
|
|
|
var bootstrapRecords: seq[Record]
|
|
loadBootstrapFile(string config.bootstrapNodesFile, bootstrapRecords)
|
|
bootstrapRecords.add(config.bootstrapNodes)
|
|
|
|
case config.portalNetwork
|
|
of testnet0:
|
|
for enrURI in testnet0BootstrapNodes:
|
|
var record: Record
|
|
if fromURI(record, enrURI):
|
|
bootstrapRecords.add(record)
|
|
else:
|
|
discard
|
|
|
|
let
|
|
discoveryConfig = DiscoveryConfig.init(
|
|
config.tableIpLimit, config.bucketIpLimit, config.bitsPerHop)
|
|
d = newProtocol(
|
|
netkey,
|
|
extIp, none(Port), extUdpPort,
|
|
bootstrapRecords = bootstrapRecords,
|
|
bindIp = bindIp, bindPort = udpPort,
|
|
enrAutoUpdate = config.enrAutoUpdate,
|
|
config = discoveryConfig,
|
|
rng = rng)
|
|
|
|
d.open()
|
|
|
|
# Store the database at contentdb prefixed with the first 8 chars of node id.
|
|
# This is done because the content in the db is dependant on the `NodeId` and
|
|
# the selected `Radius`.
|
|
let
|
|
db = ContentDB.new(config.dataDir / "db" / "contentdb_" &
|
|
d.localNode.id.toBytesBE().toOpenArray(0, 8).toHex(), maxSize = config.storageSize)
|
|
|
|
portalConfig = PortalProtocolConfig.init(
|
|
config.tableIpLimit,
|
|
config.bucketIpLimit,
|
|
config.bitsPerHop,
|
|
config.radiusConfig,
|
|
config.disablePoke
|
|
)
|
|
streamManager = StreamManager.new(d)
|
|
|
|
stateNetwork = Opt.some(StateNetwork.new(
|
|
d, db, streamManager,
|
|
bootstrapRecords = bootstrapRecords,
|
|
portalConfig = portalConfig))
|
|
|
|
accumulator =
|
|
# Building an accumulator from header epoch files takes > 2m30s and is
|
|
# thus not really a viable option at start-up.
|
|
# Options are:
|
|
# - Start with baked-in accumulator
|
|
# - Start with file containing SSZ encoded accumulator
|
|
if config.accumulatorFile.isSome():
|
|
readAccumulator(string config.accumulatorFile.get()).expect(
|
|
"Need a file with a valid SSZ encoded accumulator")
|
|
else:
|
|
# Get it from binary file containing SSZ encoded accumulator
|
|
try:
|
|
SSZ.decode(finishedAccumulator, FinishedAccumulator)
|
|
except SszError as err:
|
|
raiseAssert "Invalid baked-in accumulator: " & err.msg
|
|
|
|
historyNetwork = Opt.some(HistoryNetwork.new(
|
|
d, db, streamManager, accumulator,
|
|
bootstrapRecords = bootstrapRecords,
|
|
portalConfig = portalConfig))
|
|
|
|
beaconLightClient =
|
|
# TODO: Currently disabled by default as it is not sufficiently polished.
|
|
# Eventually this should be always-on functionality.
|
|
if config.trustedBlockRoot.isSome():
|
|
let
|
|
# Fluffy works only over mainnet data currently
|
|
networkData = loadNetworkData("mainnet")
|
|
beaconLightClientDb = LightClientDb.new(
|
|
config.dataDir / "lightClientDb")
|
|
lightClientNetwork = LightClientNetwork.new(
|
|
d,
|
|
beaconLightClientDb,
|
|
streamManager,
|
|
networkData.forks,
|
|
bootstrapRecords = bootstrapRecords)
|
|
|
|
Opt.some(initBeaconLightClient(
|
|
lightClientNetwork, networkData, config.trustedBlockRoot))
|
|
else:
|
|
Opt.none(LightClient)
|
|
|
|
# TODO: If no new network key is generated then we should first check if an
|
|
# enr file exists, and in the case it does read out the seqNum from it and
|
|
# reuse that.
|
|
let enrFile = config.dataDir / "fluffy_node.enr"
|
|
if io2.writeFile(enrFile, d.localNode.record.toURI()).isErr:
|
|
fatal "Failed to write the enr file", file = enrFile
|
|
quit 1
|
|
|
|
|
|
## Start metrics HTTP server
|
|
if config.metricsEnabled:
|
|
let
|
|
address = config.metricsAddress
|
|
port = config.metricsPort
|
|
info "Starting metrics HTTP server",
|
|
url = "http://" & $address & ":" & $port & "/metrics"
|
|
try:
|
|
chronos_httpserver.startMetricsHttpServer($address, port)
|
|
except CatchableError as exc: raise exc
|
|
# TODO: Ideally we don't have the Exception here
|
|
except Exception as exc: raiseAssert exc.msg
|
|
|
|
## Starting the different networks.
|
|
d.start()
|
|
if stateNetwork.isSome():
|
|
stateNetwork.get().start()
|
|
if historyNetwork.isSome():
|
|
historyNetwork.get().start()
|
|
if beaconLightClient.isSome():
|
|
let lc = beaconLightClient.get()
|
|
lc.network.start()
|
|
lc.start()
|
|
|
|
## Starting the JSON-RPC APIs
|
|
if config.rpcEnabled:
|
|
let ta = initTAddress(config.rpcAddress, config.rpcPort)
|
|
var rpcHttpServerWithProxy = RpcProxy.new([ta], config.proxyUri)
|
|
rpcHttpServerWithProxy.installDiscoveryApiHandlers(d)
|
|
rpcHttpServerWithProxy.installWeb3ApiHandlers()
|
|
if stateNetwork.isSome():
|
|
rpcHttpServerWithProxy.installPortalApiHandlers(
|
|
stateNetwork.get().portalProtocol, "state")
|
|
if historyNetwork.isSome():
|
|
rpcHttpServerWithProxy.installEthApiHandlers(historyNetwork.get())
|
|
rpcHttpServerWithProxy.installPortalApiHandlers(
|
|
historyNetwork.get().portalProtocol, "history")
|
|
rpcHttpServerWithProxy.installPortalDebugApiHandlers(
|
|
historyNetwork.get().portalProtocol, "history")
|
|
if beaconLightClient.isSome():
|
|
rpcHttpServerWithProxy.installPortalApiHandlers(
|
|
beaconLightClient.get().network.portalProtocol, "beaconLightClient")
|
|
# TODO: Test proxy with remote node over HTTPS
|
|
waitFor rpcHttpServerWithProxy.start()
|
|
|
|
runForever()
|
|
|
|
when isMainModule:
|
|
{.pop.}
|
|
let config = PortalConf.load(
|
|
version = clientName & " " & fullVersionStr & "\p\p" & nimBanner,
|
|
copyrightBanner = copyrightBanner
|
|
)
|
|
{.push raises: [].}
|
|
|
|
case config.cmd
|
|
of PortalCmd.noCommand:
|
|
run(config)
|