init contract function

olga24912 · olga24912 · commit 111a5e7ef712 · 2025-12-19T19:35:04.000Z
diff --git a/contracts/near/eth-types/src/lib.rs b/contracts/near/eth-types/src/lib.rs
@@ -160,8 +160,6 @@ macro_rules! uint_declare_wrapper_and_serde {
                 tree_hash::Hash256::from(bytes)
             }
         }
-
-
     };
 }
 
diff --git a/contracts/near/eth2-client/src/data/dump_sepolia_data.py b/contracts/near/eth2-client/src/data/dump_sepolia_data.py
@@ -67,29 +67,29 @@ def fetch_execution_block(number: int) -> BlockData:
 
 def normalize_block(raw: BlockData) -> dict:
     return {
-        "parent_hash": raw.get("parentHash"),
-        "uncles_hash": raw.get("sha3Uncles"),
-        "author": raw.get("miner"),
-        "state_root": raw.get("stateRoot"),
-        "transactions_root": raw.get("transactionsRoot"),
-        "receipts_root": raw.get("receiptsRoot"),
-        "log_bloom": raw.get("logsBloom"),
+        "parentHash": raw.get("parentHash"),
+        "sha3Uncles": raw.get("sha3Uncles"),
+        "miner": raw.get("miner"),
+        "stateRoot": raw.get("stateRoot"),
+        "transactionsRoot": raw.get("transactionsRoot"),
+        "receiptsRoot": raw.get("receiptsRoot"),
+        "logsBloom": raw.get("logsBloom"),
         "difficulty": hex(raw.get("difficulty", 0)),
         "number": hex(raw.get("number", 0)),
-        "gas_limit": hex(raw.get("gasLimit", 0)),
-        "gas_used": hex(raw.get("gasUsed", 0)),
+        "gasLimit": hex(raw.get("gasLimit", 0)),
+        "gasUsed": hex(raw.get("gasUsed", 0)),
         "timestamp": hex(raw.get("timestamp", 0)),
-        "extra_data": raw.get("extraData"),
-        "mix_hash": raw.get("mixHash"),
+        "extraData": raw.get("extraData"),
+        "mixHash": raw.get("mixHash"),
         "nonce": raw.get("nonce"),
-        "base_fee_per_gas": hex(raw.get("baseFeePerGas", 0))
+        "baseFeePerGas": hex(raw.get("baseFeePerGas", 0))
         if raw.get("baseFeePerGas") is not None
         else None,  # Convert to hex
-        "withdrawals_root": raw.get("withdrawalsRoot"),
-        "blob_gas_used": hex(raw.get("blobGasUsed", 0)),
-        "excess_blob_gas": hex(raw.get("excessBlobGas", 0)),
-        "parent_beacon_block_root": raw.get("parentBeaconBlockRoot"),
-        "requests_hash": raw.get("requestsHash"),
+        "withdrawalsRoot": raw.get("withdrawalsRoot"),
+        "blobGasUsed": hex(raw.get("blobGasUsed", 0)),
+        "excessBlobGas": hex(raw.get("excessBlobGas", 0)),
+        "parentBeaconBlockRoot": raw.get("parentBeaconBlockRoot"),
+        "requestsHash": raw.get("requestsHash"),
     }
 
 
diff --git a/contracts/near/eth2-client/src/tests/unit_tests.rs b/contracts/near/eth2-client/src/tests/unit_tests.rs
@@ -490,7 +490,8 @@ mod tests {
             for i in 0..342 {
                 sync_committee_bits.set(i, true);
             }
-            update.sync_aggregate.sync_committee_bits = sync_committee_bits.as_raw_mut_slice().to_vec().into();
+            update.sync_aggregate.sync_committee_bits =
+                sync_committee_bits.as_raw_mut_slice().to_vec().into();
 
             contract.submit_beacon_chain_light_client_update(update);
         }
diff --git a/relayer/relayer.toml b/relayer/relayer.toml
@@ -21,6 +21,13 @@ submission_sleep_secs = 12
 dry_run = false
 fast_mode = false
 
+[init]
+network = "sepolia"
+init_update = "../contracts/near/eth2-client/src/data/sepolia/light_client_update_period_925.json"
+first_update = "../contracts/near/eth2-client/src/data/sepolia/light_client_update_period_926.json"
+headers = "../contracts/near/eth2-client/src/data/sepolia/execution_blocks_8286935_8295112.json"
+hashes_gc_threshold = 51000
+
 [logging]
 level = "info"
 json = false
diff --git a/relayer/src/clients/near.rs b/relayer/src/clients/near.rs
@@ -67,13 +67,19 @@ impl ContractClient {
             e
         })
         .wrap_err(format!("Failed to call view method '{}'", method_name))?;
-        let result = response.borsh::<T>().map_err(|e| {
-            error!("Failed to deserialize response from '{}': {:#}", method_name, e);
-            e
-        }).wrap_err(format!(
-            "Failed to deserialize result from '{}'",
-            method_name
-        ))?;
+        let result = response
+            .borsh::<T>()
+            .map_err(|e| {
+                error!(
+                    "Failed to deserialize response from '{}': {:#}",
+                    method_name, e
+                );
+                e
+            })
+            .wrap_err(format!(
+                "Failed to deserialize result from '{}'",
+                method_name
+            ))?;
         Ok(result)
     }
 
@@ -118,26 +124,38 @@ impl ContractClient {
         )
         .await
         .map_err(|e| {
-            error!("NEAR view call 'block_hash_safe' for block {} timed out: {:#}", block_number, e);
+            error!(
+                "NEAR view call 'block_hash_safe' for block {} timed out: {:#}",
+                block_number, e
+            );
             e
         })
         .wrap_err("NEAR view timed out")?
         .map_err(|e| {
-            error!("NEAR view call 'block_hash_safe' for block {} failed: {:#}", block_number, e);
+            error!(
+                "NEAR view call 'block_hash_safe' for block {} failed: {:#}",
+                block_number, e
+            );
             e
         })
         .wrap_err(format!(
             "Failed to call view method 'block_hash_safe' with block number {}",
             block_number
         ))?;
 
-        let result = response.borsh::<Option<H256>>().map_err(|e| {
-            error!("Failed to deserialize block hash for block {}: {:#}", block_number, e);
-            e
-        }).wrap_err(format!(
-            "Failed to get block hash result for block number {}",
-            block_number
-        ))?;
+        let result = response
+            .borsh::<Option<H256>>()
+            .map_err(|e| {
+                error!(
+                    "Failed to deserialize block hash for block {}: {:#}",
+                    block_number, e
+                );
+                e
+            })
+            .wrap_err(format!(
+                "Failed to get block hash result for block number {}",
+                block_number
+            ))?;
         Ok(result)
     }
 
@@ -259,7 +277,12 @@ impl ContractClient {
         )
         .await
         .map_err(|e| {
-            error!("Batch {}/{} submission timed out: {:#}", batch_index + 1, total_batches, e);
+            error!(
+                "Batch {}/{} submission timed out: {:#}",
+                batch_index + 1,
+                total_batches,
+                e
+            );
             e
         })
         .wrap_err(format!(
@@ -283,12 +306,22 @@ impl ContractClient {
         )
         .await
         .map_err(|e| {
-            error!("Batch {}/{} submission timed out: {:#}", batch_index + 1, total_batches, e);
+            error!(
+                "Batch {}/{} submission timed out: {:#}",
+                batch_index + 1,
+                total_batches,
+                e
+            );
             e
         })
         .wrap_err("NEAR call timed out")?
         .map_err(|e| {
-            error!("Batch {}/{} transaction failed: {:#}", batch_index + 1, total_batches, e);
+            error!(
+                "Batch {}/{} transaction failed: {:#}",
+                batch_index + 1,
+                total_batches,
+                e
+            );
             e
         })
         .wrap_err(format!(
@@ -299,7 +332,12 @@ impl ContractClient {
         .status;
 
         if let FinalExecutionStatus::Failure(err) = status {
-            error!("Batch {}/{} rejected by contract: {}", batch_index + 1, total_batches, err);
+            error!(
+                "Batch {}/{} rejected by contract: {}",
+                batch_index + 1,
+                total_batches,
+                err
+            );
             return Err(eyre::Report::msg(format!(
                 "Batch {}/{} submission failed: {}",
                 batch_index + 1,
diff --git a/relayer/src/config.rs b/relayer/src/config.rs
@@ -25,7 +25,10 @@ impl FromStr for Network {
         match s.to_lowercase().as_str() {
             "testnet" | "sepolia" => Ok(Network::Testnet),
             "mainnet" => Ok(Network::Mainnet),
-            _ => Err(format!("Unknown network: {}. Use 'testnet' or 'mainnet'", s)),
+            _ => Err(format!(
+                "Unknown network: {}. Use 'testnet' or 'mainnet'",
+                s
+            )),
         }
     }
 }
@@ -48,6 +51,10 @@ pub struct Config {
     #[serde(default)]
     pub relayer: RelayerConfig,
 
+    /// Config for EthLightClient contract initialization
+    #[serde(default)]
+    pub init: InitConfig,
+
     /// Logging configuration
     #[serde(default)]
     pub logging: LoggingConfig,
@@ -125,6 +132,28 @@ pub struct RelayerConfig {
     pub fast_mode: bool,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InitConfig {
+    #[serde(default)]
+    pub network: String,
+
+    /// Path to the file with init Light Client Update
+    #[serde(default)]
+    pub init_update: String,
+
+    /// Path to the file with the first (next after init) Light Client Update
+    #[serde(default)]
+    pub first_update: String,
+
+    /// Path to the file with headers
+    #[serde(default)]
+    pub headers: String,
+
+    /// Hashes threshold for Garbage Collection
+    #[serde(default)]
+    pub hashes_gc_threshold: u64,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LoggingConfig {
     /// Log level: trace, debug, info, warn, error
@@ -183,6 +212,18 @@ impl Default for RelayerConfig {
     }
 }
 
+impl Default for InitConfig {
+    fn default() -> Self {
+        Self {
+            network: "sepolia".to_string(),
+            init_update: "".to_string(),
+            first_update: "".to_string(),
+            headers: "".to_string(),
+            hashes_gc_threshold: 51000,
+        }
+    }
+}
+
 impl Default for LoggingConfig {
     fn default() -> Self {
         Self {
@@ -359,6 +400,13 @@ impl Config {
                     timeout_secs: defaults::TIMEOUT_SECS,
                 },
                 relayer: RelayerConfig::default(),
+                init: InitConfig {
+                    network: "mainnet".to_string(),
+                    init_update: "".to_string(),
+                    first_update: "".to_string(),
+                    headers: "".to_string(),
+                    hashes_gc_threshold: 51000,
+                },
                 logging: LoggingConfig::default(),
             },
         }
@@ -393,6 +441,7 @@ mod tests {
         assert!(toml.contains("[beacon]"));
         assert!(toml.contains("[near]"));
         assert!(toml.contains("[relayer]"));
+        assert!(toml.contains("[init]"));
         assert!(toml.contains("[logging]"));
     }
 }
diff --git a/relayer/src/main.rs b/relayer/src/main.rs
@@ -60,6 +60,8 @@ enum Commands {
     Run,
     /// Run a single relay job and exit
     RunJob,
+    /// Init Eth Light Client contract
+    Init,
 }
 
 fn setup_logging(level: &str, json: bool) -> Result<()> {
@@ -121,6 +123,14 @@ async fn handle_command(command: Commands, config_path: Option<PathBuf>) -> Resu
 
             EthRelayer::new(config).await?.run_job().await?;
         }
+        Commands::Init => {
+            let config = Config::load(config_path)?;
+            config.validate()?;
+            setup_logging(&config.logging.level, config.logging.json)?;
+            config.print_summary();
+
+            EthRelayer::new(config).await?.init_eth_client().await?;
+        }
     }
     Ok(())
 }
diff --git a/relayer/src/relay.rs b/relayer/src/relay.rs
@@ -1,9 +1,12 @@
+use std::str::FromStr;
 use std::time::Duration;
 
 use crate::constants::protocol::SLOTS_PER_EPOCH;
 use crate::{BeaconClient, ContractClient, ExecutionClient};
 use color_eyre::Result;
-use eth2_utility::types::ClientMode;
+use eth_types::BlockHeader;
+use eth_types::eth2::LightClientUpdate;
+use eth2_utility::types::{ClientMode, InitInput};
 use near_crypto::{InMemorySigner, SecretKey};
 use tokio::time::sleep;
 use tracing::{debug, error, info, warn};
@@ -125,6 +128,37 @@ impl EthRelayer {
         Ok(())
     }
 
+    pub async fn init_eth_client(&self) -> Result<()> {
+        let init_update: LightClientUpdate =
+            serde_json::from_reader(std::fs::File::open(&self.config.init.init_update)?)?;
+        let first_update: LightClientUpdate =
+            serde_json::from_reader(std::fs::File::open(&self.config.init.first_update)?)?;
+        let headers: Vec<BlockHeader> =
+            serde_json::from_reader(std::fs::File::open(&self.config.init.headers)?)?;
+
+        let init_input = InitInput {
+            network: eth2_utility::consensus::Network::from_str(&self.config.init.network)
+                .map_err(|err| color_eyre::eyre::eyre!("Incorrect network name: {err:?}"))?,
+            finalized_execution_header: headers[0].clone(),
+            finalized_beacon_header: first_update.finalized_header.clone().into(),
+            current_sync_committee: init_update
+                .next_sync_committee
+                .ok_or_else(|| color_eyre::eyre::eyre!("Missing sync committee in init update"))?,
+            next_sync_committee: first_update
+                .next_sync_committee
+                .ok_or_else(|| color_eyre::eyre::eyre!("Missing sync committee in first update"))?,
+            validate_updates: true,
+            verify_bls_signatures: true,
+            hashes_gc_threshold: self.config.init.hashes_gc_threshold,
+            trusted_signer: None,
+        };
+
+        self.near_client
+            .init_contract(init_input)
+            .await
+            .map_err(Into::into)
+    }
+
     async fn run_iteration(&self) -> RelayResult {
         // Early return pattern - convert all errors to RelayResult::Error
         let mode = match self.get_mode_if_synced().await {

Original file line number	Diff line number	Diff line change
`@@ -160,8 +160,6 @@ macro_rules! uint_declare_wrapper_and_serde {`
`160`	`160`	`tree_hash::Hash256::from(bytes)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`		`-`
`164`		`-`
`165`	`163`	`};`
`166`	`164`	`}`
`167`	`165`
Original file line number	Diff line number	Diff line change
`@@ -490,7 +490,8 @@ mod tests {`
`490`	`490`	`for i in 0..342 {`
`491`	`491`	`sync_committee_bits.set(i, true);`
`492`	`492`	`}`
`493`		`- update.sync_aggregate.sync_committee_bits = sync_committee_bits.as_raw_mut_slice().to_vec().into();`
	`493`	`+ update.sync_aggregate.sync_committee_bits =`
	`494`	`+ sync_committee_bits.as_raw_mut_slice().to_vec().into();`
`494`	`495`
`495`	`496`	`contract.submit_beacon_chain_light_client_update(update);`
`496`	`497`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,8 @@ enum Commands {`
`60`	`60`	`Run,`
`61`	`61`	`/// Run a single relay job and exit`
`62`	`62`	`RunJob,`
	`63`	`+ /// Init Eth Light Client contract`
	`64`	`+ Init,`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`fn setup_logging(level: &str, json: bool) -> Result<()> {`
`@@ -121,6 +123,14 @@ async fn handle_command(command: Commands, config_path: Option<PathBuf>) -> Resu`
`121`	`123`
`122`	`124`	`EthRelayer::new(config).await?.run_job().await?;`
`123`	`125`	`}`
	`126`	`+ Commands::Init => {`
	`127`	`+ let config = Config::load(config_path)?;`
	`128`	`+ config.validate()?;`
	`129`	`+ setup_logging(&config.logging.level, config.logging.json)?;`
	`130`	`+ config.print_summary();`
	`131`	`+`
	`132`	`+ EthRelayer::new(config).await?.init_eth_client().await?;`
	`133`	`+ }`
`124`	`134`	`}`
`125`	`135`	`Ok(())`
`126`	`136`	`}`