address Unify client starting process for rlp (#3909)

RazorClient · advaita-saha · web-flow · commit 6bc56df64c5b · 2026-01-16T10:09:51.000Z
* add client booting pick e98da11 add era client booting * code clean up * simply and clean code * address reviews by removing era part for now * address reviews * reduce code * address reviews * address reviews * fix tests * Update scripts/check_revision.sh --------- Co-authored-by: Advaita Saha <adv11sphs@gmail.com>
diff --git a/execution_chain/conf.nim b/execution_chain/conf.nim
@@ -60,7 +60,6 @@ type
   NimbusCmd* {.pure.} = enum
     executionClient
     `import`
-    `import-rlp`
 
   RpcFlag* {.pure.} = enum
     ## RPC flags
@@ -512,6 +511,18 @@ type
               " CL which will result in a smaller memory footprint"
         name: "debug-beacon-sync-target-is-final".}: bool
 
+      bootstrapBlocksFile* {.
+        desc: "Import RLP encoded block files before starting the client"
+        defaultValue: @[]
+        name: "bootstrap-blocks-file" .}: seq[InputFile]
+
+      bootstrapBlocksFinalized* {.
+        hidden
+        desc: "Treat bootstrap RLP imports as finalized chain segments"
+        defaultValue: false
+        name: "debug-bootstrap-finalized" .}: bool
+
+    # We now load all the import specific configurations directly into  ExecutionClientConf
     of NimbusCmd.`import`:
       maxBlocks* {.
         desc: "Maximum number of blocks to import"
@@ -563,12 +574,6 @@ type
         defaultValue: false
         name: "debug-store-slot-hashes".}: bool
 
-    of NimbusCmd.`import-rlp`:
-      blocksFile* {.
-        argument
-        desc: "One or more RLP encoded block(s) files"
-        name: "blocks-file" .}: seq[InputFile]
-
 func parseHexOrDec256(p: string): UInt256 {.raises: [ValueError].} =
   if startsWith(p, "0x"):
     parse(p, UInt256, 16)
@@ -827,4 +832,3 @@ proc makeConfig*(cmdLine = commandLineParams(), ignoreUnknown = false): Executio
 when isMainModule:
   # for testing purpose
   discard makeConfig()
-
diff --git a/execution_chain/core/block_import.nim b/execution_chain/core/block_import.nim
@@ -16,27 +16,27 @@ import
   chronos,
   ./chain,
   ../conf,
-  ../utils/utils,
-  beacon_chain/process_state,
-  ./chain/forked_chain/chain_serialize
+  beacon_chain/process_state
 
-proc importRlpBlocks*(blocksRlp:seq[byte],
-                      chain: ForkedChainRef,
-                      finalize: bool):
-                        Future[Result[void, string]] {.async: (raises: [CancelledError]).} =
+# Only parse the RLP data and feed blocks into the ForkedChainRef.
+# Optionally finalize via fork-choice when requested.
+proc importRlpBlocks*(
+    blocksRlp: seq[byte], chain: ForkedChainRef, finalize: bool
+): Future[Result[void, string]] {.async: (raises: [CancelledError]).} =
   var
-    # the encoded rlp can contains one or more blocks
+    # the encoded rlp can contain one or more blocks
     rlp = rlpFromBytes(blocksRlp)
     blk: Block
     printBanner = false
     firstSkip = Opt.none(uint64)
 
   while not ProcessState.stopIt(notice("Shutting down", reason = it)) and rlp.hasData:
-    blk = try:
-      rlp.read(Block)
-    except RlpError as e:
-      # terminate if there was a decoding error
-      return err($e.name & ": " & e.msg)
+    blk =
+      try:
+        rlp.read(Block)
+      except RlpError as e:
+        # terminate if there was a decoding error
+        return err($e.name & ": " & e.msg)
 
     if blk.header.number <= chain.baseNumber:
       if firstSkip.isNone:
@@ -45,60 +45,51 @@ proc importRlpBlocks*(blocksRlp:seq[byte],
 
     if firstSkip.isSome:
       if firstSkip.get == blk.header.number - 1:
-        info "Block number smaller than base",
-          skip=firstSkip.get
+        info "Block number smaller than base", skip = firstSkip.get
       else:
         info "Block number smaller than base",
-          startSkip=firstSkip.get,
-          skipTo=blk.header.number-1
+          startSkip = firstSkip.get, skipTo = blk.header.number - 1
       firstSkip.reset()
 
     if not printBanner:
       info "Start importing block",
-        hash=blk.header.computeBlockHash.short,
-        number=blk.header.number
+        hash = blk.header.computeBlockHash.short, number = blk.header.number
       printBanner = true
 
     let res = await chain.importBlock(blk, finalized = true)
     if res.isErr:
-      error "Error occured when importing block",
-        hash=blk.header.computeBlockHash.short,
-        number=blk.header.number,
-        msg=res.error
+      error "Error occurred when importing block",
+        hash = blk.header.computeBlockHash.short,
+        number = blk.header.number,
+        msg = res.error
       if finalize:
-        ? (await chain.forkChoice(chain.latestHash, chain.latestHash))
+        ?(await chain.forkChoice(chain.latestHash, chain.latestHash))
       return res
 
   if finalize:
-    ? (await chain.forkChoice(chain.latestHash, chain.latestHash))
+    ?(await chain.forkChoice(chain.latestHash, chain.latestHash))
 
   ok()
 
-proc importRlpBlocks*(importFile: string,
-                     chain: ForkedChainRef,
-                     finalize: bool): Future[Result[void, string]] {.async: (raises: [CancelledError]).} =
+proc importRlpBlocks*(
+    importFile: string, chain: ForkedChainRef, finalize: bool
+): Future[Result[void, string]] {.async: (raises: [CancelledError]).} =
   let bytes = io2.readAllBytes(importFile).valueOr:
     return err($error)
   await importRlpBlocks(bytes, chain, finalize)
 
-proc importRlpBlocks*(config: ExecutionClientConf, com: CommonRef): Future[void] {.async: (raises: [CancelledError]).} =
-  # Both baseDistance and persistBatchSize are 0,
-  # we want changes persisted immediately
-  let chain = ForkedChainRef.init(com, baseDistance = 0, persistBatchSize = 1)
+proc importRlpBlocks*(
+    config: ExecutionClientConf, com: CommonRef, chain: ForkedChainRef
+): Future[void] {.async: (raises: [CancelledError]).} =
+  if config.bootstrapBlocksFile.len == 0:
+    return
 
-  # success or not, we quit after importing blocks
-  for i, blocksFile in config.blocksFile:
-    (await importRlpBlocks(string blocksFile, chain, false)).isOkOr:
-      warn "Error when importing blocks", msg=error
-      # Finalize the existing chain in case of rlp read error
-      (await chain.forkChoice(chain.latestHash, chain.latestHash)).isOkOr:
-        error "Error when finalizing chain", msg=error
+  for blocksFile in config.bootstrapBlocksFile:
+    let filePath = string(blocksFile)
+    (await importRlpBlocks(filePath, chain, config.bootstrapBlocksFinalized)).isOkOr:
+      warn "Error when importing blocks", msg = error
+      if config.bootstrapBlocksFinalized:
+        (await chain.forkChoice(chain.latestHash, chain.latestHash)).isOkOr:
+          error "Error when finalizing chain", msg = error
       quit(QuitFailure)
 
-  let txFrame = chain.baseTxFrame
-  chain.serialize(txFrame).isOkOr:
-    error "FC.serialize error: ", msg = error
-  txFrame.checkpoint(chain.base.blk.header.number, skipSnapshot = true)
-  com.db.persist(txFrame)
-
-  quit(QuitSuccess)
diff --git a/execution_chain/nimbus_execution_client.nim b/execution_chain/nimbus_execution_client.nim
@@ -324,6 +324,12 @@ proc runExeClient*(
     txFrame.checkpoint(fc.base.blk.header.number, skipSnapshot = true)
     com.db.persist(txFrame)
 
+ # Rlp import is there, first load the chain segment
+  if config.bootstrapBlocksFile.len > 0:
+    try:
+      waitFor importRlpBlocks(config, com, nimbus.fc)
+    except CancelledError:
+      raiseAssert "Nothing cancels the future"
   # Be graceful about ctrl-c during init
   if ProcessState.stopping.isNone:
     ProcessState.notifyRunning()
@@ -390,11 +396,6 @@ proc main*(config = makeConfig(), nimbus = NimbusNode(nil)) {.noinline.} =
   case config.cmd
   of NimbusCmd.`import`:
     importBlocks(config, com)
-  of NimbusCmd.`import - rlp`:
-    try:
-      waitFor importRlpBlocks(config, com)
-    except CancelledError:
-      raiseAssert "Nothing cancels the future"
   else:
     runExeClient(config, com, nil, nimbus=nimbus)
 
diff --git a/scripts/check_revision.sh b/scripts/check_revision.sh
@@ -42,7 +42,7 @@ if [[ $COPYRIGHT_YEAR_START_GET != *$COPYRIGHT_YEAR_START_EXPECT*  ]]; then
 fi
 
 LAUNCHING_INFO_EXPECT="Launching execution client"
-LAUNCHING_INFO_GET=$($EL import-rlp | head -n 1)
+LAUNCHING_INFO_GET=$($EL import | head -n 1)
 
 if [[ $LAUNCHING_INFO_GET != *$LAUNCHING_INFO_EXPECT*  ]]; then
   echo "\"Launching execution client\" should appear at first line"
diff --git a/tests/test_configuration.nim b/tests/test_configuration.nim
@@ -44,13 +44,19 @@ proc configurationMain*() =
       check dd.dataDir() == "apple\\bin"
       check dd.keyStoreDir == "banana/bin"
 
-    test "import-rlp":
-      let aa = makeTestConfig()
-      check aa.cmd == NimbusCmd.executionClient
-
-      let bb = makeConfig(@["import-rlp", genesisFile])
-      check bb.cmd == NimbusCmd.`import-rlp`
-      check bb.blocksFile[0].string == genesisFile
+    test "bootstrap-blocks-file parsing":
+      let defaults = makeTestConfig()
+      check defaults.bootstrapBlocksFile.len == 0
+      check defaults.bootstrapBlocksFinalized == false
+
+      let cfg = makeConfig(@[
+        "--bootstrap-blocks-file:" & genesisFile,
+        "--debug-bootstrap-finalized:false",
+      ])
+      check cfg.cmd == NimbusCmd.executionClient
+      check cfg.bootstrapBlocksFile.len == 1
+      check cfg.bootstrapBlocksFile[0].string == genesisFile
+      check cfg.bootstrapBlocksFinalized == false
 
     test "network loading config file with no genesis data":
       # no genesis will fallback to geth compatibility mode
