Use block delta when computing translator start block

client/src/client.rs

@@ -9,7 +9,6 @@ use reth_primitives::B256;
 use reth_rpc_types::engine::{ForkchoiceState, ForkchoiceUpdated};
 use reth_rpc_types::Block;
 use serde_json::json;
-use std::cmp;
 use telos_translator_rs::block::TelosEVMBlock;
 use tokio::sync::mpsc;
 use tracing::{debug, error};
@@ -36,7 +35,7 @@ pub enum Error {
     Database(eyre::Report),
     #[error("Client is too many blocks ({0}) behind the executor, start from a more recent block or increase maximum range"
     )]
-    RangeAboveMaximum(u64),
+    RangeAboveMaximum(u32),
     #[error("Cannot shutdown translator: {0}")]
     TranslatorShutdown(String),
 }
@@ -106,20 +105,15 @@ impl ConsensusClient {
         }
     }
 
-    fn latest_evm_number(&self) -> Option<u64> {
-        Some(self.latest_valid_executor_block.as_ref()?.header.number)
+    pub fn latest_evm_number(&self) -> Option<u32> {
+        self.latest_valid_executor_block
+            .as_ref()
+            .map(|block| block.header.number.as_u32())
     }
 
-    pub fn min_latest_or_lib(&self, lib: Option<&data::Block>) -> Option<u32> {
-        match (lib, self.latest_evm_block().as_ref()) {
-            (Some(lib), Some(latest)) => Some(cmp::min(lib.number, latest.0)),
-            (_, _) => None,
-        }
-    }
-
-    pub fn sync_range(&self) -> Option<u64> {
+    pub fn sync_range(&self) -> Option<u32> {
         self.latest_evm_number()?
-            .checked_sub(self.config.evm_start_block.as_u64())
+            .checked_sub(self.config.evm_start_block)
     }
 
     pub async fn run(

client/src/config.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use serde::Deserialize;
-use telos_translator_rs::translator::TranslatorConfig;
+use telos_translator_rs::{translator::TranslatorConfig, types::translator_types::ChainId};
 
 /// Telos Consensus Client CLI Arguments
 #[derive(Parser, Debug, Clone)]
@@ -20,7 +20,7 @@ pub struct AppConfig {
     pub log_level: String,
 
     /// EVM Chain id, Telos mainnet is 40 and testnet is 41
-    pub chain_id: u64,
+    pub chain_id: ChainId,
 
     /// Execution API http endpoint (JWT protected endpoint on reth)
     pub execution_endpoint: String,
@@ -70,16 +70,10 @@ pub struct AppConfig {
 
 impl From<&AppConfig> for TranslatorConfig {
     fn from(config: &AppConfig) -> Self {
-        let block_delta = match config.chain_id {
-            40 => 36,
-            41 => 57,
-            _ => 0,
-        };
         Self {
-            chain_id: config.chain_id,
+            chain_id: config.chain_id.clone(),
             evm_start_block: config.evm_start_block,
             evm_stop_block: config.evm_stop_block,
-            block_delta,
             prev_hash: config.prev_hash.clone(),
             validate_hash: config.validate_hash.clone(),
             http_endpoint: config.chain_endpoint.clone(),

client/src/main_utils.rs

@@ -1,8 +1,9 @@
+use std::cmp;
+
 use crate::client::Error::{CannotStartConsensusClient, TranslatorShutdown};
 use crate::client::{ConsensusClient, Error, Shutdown};
 use crate::config::{AppConfig, CliArgs};
 use crate::data::Block;
-use reth_primitives::revm_primitives::bitvec::macros::internal::funty::Fundamental;
 use telos_translator_rs::block::TelosEVMBlock;
 use telos_translator_rs::translator::Translator;
 use tokio::sync::mpsc;
@@ -60,7 +61,11 @@ pub async fn build_consensus_client(
     // Translator
     let lib = client.db.get_lib()?;
 
-    let latest_number = client.min_latest_or_lib(lib.as_ref());
+    let latest_number = lib
+        .as_ref()
+        .map(|lib| lib.number + config.chain_id.block_delta())
+        .zip(client.latest_evm_number())
+        .map(|(lib, latest)| cmp::min(lib, latest));
 
     let last_checked = match latest_number {
         Some(latest_number) => client.db.get_block_or_prev(latest_number)?,
@@ -75,7 +80,7 @@ pub async fn build_consensus_client(
     }
 
     if let Some(sync_range) = client.sync_range() {
-        if sync_range > config.maximum_sync_range.as_u64() {
+        if sync_range > config.maximum_sync_range {
             return Err(Error::RangeAboveMaximum(sync_range));
         }
     }

client/tests/ship_read.rs

@@ -11,6 +11,7 @@ use telos_consensus_client::config::{AppConfig, CliArgs};
 use telos_consensus_client::json_rpc::JsonRequestBody;
 use telos_translator_rs::block::TelosEVMBlock;
 use telos_translator_rs::translator::Translator;
+use telos_translator_rs::types::translator_types::ChainId;
 use testcontainers::core::ContainerPort::Tcp;
 use testcontainers::{runners::AsyncRunner, ContainerAsync, GenericImage};
 use tokio::sync::oneshot::Sender;
@@ -213,7 +214,7 @@ async fn evm_deploy() {
 
     let config = AppConfig {
         log_level: "debug".to_string(),
-        chain_id: 41,
+        chain_id: ChainId(41),
         execution_endpoint: format!("http://localhost:{MOCK_EXECUTION_API_PORT}"),
         jwt_secret: "57ea261c64b8a871e4df3f0c790efd0d02f9846e5085483e3098f30118fd1520".to_string(),
         ship_endpoint: format!("ws://localhost:{port_18999}"),

translator/src/tasks/final_processor.rs

@@ -25,6 +25,7 @@ pub async fn final_processor(
     let mut last_log = Instant::now();
     let mut unlogged_blocks = 0;
     let mut unlogged_transactions = 0;
+    let block_delta = config.chain_id.block_delta();
 
     let mut parent_hash = FixedBytes::from_str(&config.prev_hash)
         .wrap_err("Prev hash config is not a valid 32 byte hex string")?;
@@ -40,19 +41,19 @@ pub async fn final_processor(
     let mut validated = validate_hash.is_none();
 
     let native_to_evm_cache = NameToAddressCache::new(api_client);
-    let stop_block = config
+    let stop_block = &config
         .evm_stop_block
-        .map(|n| n + config.block_delta)
+        .map(|n| n + block_delta)
         .unwrap_or(u32::MAX);
 
     while let Some(mut block) = rx.recv().await {
-        if block.block_num > stop_block {
+        if &block.block_num > stop_block {
             break;
         }
         debug!("Finalizing block #{}", block.block_num);
 
         let (header, exec_payload) = block
-            .generate_evm_data(parent_hash, config.block_delta, &native_to_evm_cache)
+            .generate_evm_data(parent_hash, block_delta, &native_to_evm_cache)
             .await;
 
         let block_hash = exec_payload.block_hash;
@@ -185,7 +186,7 @@ pub async fn final_processor(
             }
         }
         parent_hash = block_hash;
-        if block_num == stop_block {
+        if &block_num == stop_block {
             debug!("Processed stop block #{block_num}, exiting...");
             shutdown_tx
                 .send(())

translator/src/tasks/raw_deserializer.rs

@@ -24,6 +24,7 @@ pub async fn raw_deserializer(
     let mut unackd_blocks = 0;
     let mut last_log = Instant::now();
     let mut unlogged_blocks = 0;
+    let block_delta = config.chain_id.block_delta();
 
     // TODO: maybe get this working as an ABI again?
     //   the problem is that the ABI from ship has invalid table names like `account_metadata`
@@ -53,7 +54,7 @@ pub async fn raw_deserializer(
 
         match ship_result {
             ShipResult::GetStatusResultV0(r) => {
-                let start_block_num = config.evm_start_block + config.block_delta;
+                let start_block_num = config.evm_start_block + block_delta;
                 let chain_begin_block = r.chain_state_begin_block;
                 if start_block_num <= chain_begin_block {
                     return Err(eyre!("Start block {start_block_num} has to be greater than first chain block ({chain_begin_block})"));
@@ -67,7 +68,7 @@ pub async fn raw_deserializer(
                     // Increment stop block value by block delta + 1 as bound is exclusive
                     end_block_num: config
                         .evm_stop_block
-                        .map(|n| n + config.block_delta + 1)
+                        .map(|n| n + block_delta + 1)
                         .unwrap_or(u32::MAX),
                     max_messages_in_flight: 10000,
                     have_positions: vec![],
@@ -83,7 +84,7 @@ pub async fn raw_deserializer(
                 unackd_blocks += 1;
                 if let Some(b) = &r.this_block {
                     let block = ProcessingEVMBlock::new(
-                        config.chain_id,
+                        config.chain_id.0,
                         b.block_num,
                         b.block_id,
                         r.last_irreversible.block_num,

translator/src/translator.rs

@@ -1,5 +1,6 @@
 use crate::block::{ProcessingEVMBlock, TelosEVMBlock};
 use crate::tasks::{evm_block_processor, final_processor, raw_deserializer, ship_reader};
+use crate::types::translator_types::ChainId;
 use antelope::api::client::APIClient;
 use antelope::api::default_provider::DefaultProvider;
 use eyre::{eyre, Context, Result};
@@ -16,10 +17,9 @@ pub fn default_channel_size() -> usize {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TranslatorConfig {
-    pub chain_id: u64,
+    pub chain_id: ChainId,
     pub evm_start_block: u32,
     pub evm_stop_block: Option<u32>,
-    pub block_delta: u32,
     pub prev_hash: String,
     pub validate_hash: Option<String>,
 

translator/src/types/env.rs

@@ -13,11 +13,10 @@ pub const ZERO_HASH_HEX: &str = "00000000000000000000000000000000000000000000000
 lazy_static! {
     pub static ref ZERO_HASH: FixedBytes<32> = FixedBytes::from_str(ZERO_HASH_HEX).unwrap();
     pub static ref MAINNET_GENESIS_CONFIG: TranslatorConfig = TranslatorConfig {
-        chain_id: 40,
+        chain_id: 40.into(),
 
         evm_start_block: 37,
         evm_stop_block: None,
-        block_delta: 36,
 
         prev_hash: ZERO_HASH_HEX.to_string(),
         validate_hash: Some(
@@ -32,11 +31,10 @@ lazy_static! {
         final_message_channel_size: default_channel_size()
     };
     pub static ref MAINNET_DEPLOY_CONFIG: TranslatorConfig = TranslatorConfig {
-        chain_id: 40,
+        chain_id: 40.into(),
 
         evm_start_block: 180698860,
         evm_stop_block: None,
-        block_delta: 36,
 
         prev_hash: "757720a8e51c63ef1d4f907d6569dacaa965e91c2661345902de18af11f81063".to_string(),
         validate_hash: Some(
@@ -51,11 +49,10 @@ lazy_static! {
         final_message_channel_size: default_channel_size()
     };
     pub static ref TESTNET_GENESIS_CONFIG: TranslatorConfig = TranslatorConfig {
-        chain_id: 41,
+        chain_id: 41.into(),
 
         evm_start_block: 58,
         evm_stop_block: None,
-        block_delta: 57,
 
         prev_hash: ZERO_HASH_HEX.to_string(),
         validate_hash: Some(
@@ -70,11 +67,10 @@ lazy_static! {
         final_message_channel_size: default_channel_size()
     };
     pub static ref TESTNET_DEPLOY_CONFIG: TranslatorConfig = TranslatorConfig {
-        chain_id: 41,
+        chain_id: 41.into(),
 
         evm_start_block: 136393814,
         evm_stop_block: None,
-        block_delta: 57,
 
         prev_hash: "8e149fd918bad5a4adfe6f17478e46643f7db7292a2b7b9247f48dc85bdeec94".to_string(),
         validate_hash: None,

translator/src/types/translator_types.rs

@@ -10,6 +10,7 @@ use antelope::chain::name::Name;
 use futures_util::stream::{SplitSink, SplitStream};
 use moka::sync::Cache;
 use reth_primitives::revm_primitives::bitvec::macros::internal::funty::Fundamental;
+use serde::{Deserialize, Serialize};
 use std::collections::BinaryHeap;
 use std::net::TcpStream;
 use std::sync::{Arc, Mutex};
@@ -183,3 +184,22 @@ impl Clone for PriorityQueue {
         }
     }
 }
+
+#[derive(Clone, Serialize, Deserialize, Debug)]
+pub struct ChainId(pub u64);
+
+impl From<u64> for ChainId {
+    fn from(value: u64) -> Self {
+        ChainId(value)
+    }
+}
+
+impl ChainId {
+    pub fn block_delta(&self) -> u32 {
+        match self.0 {
+            40 => 36,
+            41 => 57,
+            _ => 0,
+        }
+    }
+}

translator/tests/block_headers.rs

@@ -10,7 +10,7 @@ use telos_translator_rs::{
         ship_types::{
             BlockHeader, BlockPosition, GetBlocksResultV0, SignedBlock, SignedBlockHeader,
         },
-        translator_types::NameToAddressCache,
+        translator_types::{ChainId, NameToAddressCache},
     },
 };
 
@@ -78,8 +78,7 @@ async fn generate_block(
 
 #[tokio::test]
 async fn genesis_mainnet() {
-    let evm_chain_id_mainnet = 40;
-    let evm_delta = 36;
+    let evm_chain_id_mainnet = ChainId(40);
     let http_endpoint = "https://mainnet.telos.net".to_string();
 
     let native_to_evm_cache = NameToAddressCache::new(
@@ -91,12 +90,16 @@ async fn genesis_mainnet() {
         0, 0,
     ]);
 
-    let mut block = generate_block(evm_chain_id_mainnet, http_endpoint, 36).await;
+    let mut block = generate_block(evm_chain_id_mainnet.0, http_endpoint, 36).await;
 
     block.deserialize();
 
     let (header, payload) = block
-        .generate_evm_data(zero_bytes, evm_delta, &native_to_evm_cache)
+        .generate_evm_data(
+            zero_bytes,
+            evm_chain_id_mainnet.block_delta(),
+            &native_to_evm_cache,
+        )
         .await;
 
     println!("genesis: {:#?}", header);
@@ -111,8 +114,7 @@ async fn genesis_mainnet() {
 
 #[tokio::test]
 async fn deploy_mainnet() {
-    let evm_chain_id_mainnet = 40;
-    let evm_delta = 36;
+    let evm_chain_id_mainnet = ChainId(40);
     let http_endpoint = "https://mainnet.telos.net".to_string();
 
     let native_to_evm_cache = NameToAddressCache::new(
@@ -122,7 +124,7 @@ async fn deploy_mainnet() {
     let parent_hash = FixedBytes::from_hex(&MAINNET_DEPLOY_CONFIG.prev_hash).unwrap();
 
     let mut block = generate_block(
-        evm_chain_id_mainnet,
+        evm_chain_id_mainnet.0,
         http_endpoint,
         MAINNET_DEPLOY_CONFIG.evm_start_block,
     )
@@ -131,7 +133,11 @@ async fn deploy_mainnet() {
     block.deserialize();
 
     let (header, payload) = block
-        .generate_evm_data(parent_hash, evm_delta, &native_to_evm_cache)
+        .generate_evm_data(
+            parent_hash,
+            evm_chain_id_mainnet.block_delta(),
+            &native_to_evm_cache,
+        )
         .await;
 
     println!("genesis: {:#?}", header);