Load genesis config from file

relayer/Cargo.toml

@@ -21,7 +21,6 @@ futures.workspace = true
 gear-core.workspace = true
 gclient.workspace = true
 hex.workspace = true
-hex-literal.workspace = true
 keccak-hash.workspace = true
 lazy_static.workspace = true
 libc.workspace = true

relayer/src/main.rs

@@ -1,14 +1,12 @@
 extern crate pretty_env_logger;
 
 use clap::{Args, Parser, Subcommand};
-use hex_literal::hex;
 use pretty_env_logger::env_logger::fmt::TimestampPrecision;
 
 use ethereum_client::EthApi;
 use gear_rpc_client::GearApi;
 use message_relayer::MessageRelayer;
 use proof_storage::{FileSystemProofStorage, GearProofStorage, ProofStorage};
-use prover::proving::GenesisConfig;
 use relay_merkle_roots::MerkleRootRelayer;
 use utils_prometheus::MetricsBuilder;
 
@@ -23,11 +21,6 @@ const DEFAULT_VARA_RPC: &str = "ws://localhost:8989";
 const DEFAULT_ETH_RPC: &str = "http://localhost:8545";
 const DEFAULT_PROMETHEUS_ENDPOINT: &str = "0.0.0.0:9090";
 
-const GENESIS_CONFIG: GenesisConfig = GenesisConfig {
-    authority_set_id: 1,
-    authority_set_hash: hex!("b9853ab2fb585702dfd9040ee8bc9f94dc5b0abd8b0f809ec23fdc0265b21e24"),
-};
-
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
 #[command(propagate_version = true)]
@@ -211,7 +204,10 @@ async fn main() {
                     Box::from(FileSystemProofStorage::new("./proof_storage".into()))
                 };
 
-            let relayer = MerkleRootRelayer::new(gear_api, eth_api, proof_storage).await;
+            let genesis_config = genesis_config::load_from_file();
+
+            let relayer =
+                MerkleRootRelayer::new(gear_api, eth_api, genesis_config, proof_storage).await;
 
             metrics
                 .register_service(&relayer)

relayer/src/prover_interface.rs

@@ -2,13 +2,13 @@ use std::{str::FromStr, time::Instant};
 
 use utils_prometheus::MeteredService;
 
-use super::GENESIS_CONFIG;
 use gear_rpc_client::{dto, GearApi};
 use num::BigUint;
 use primitive_types::H256;
 use prometheus::{core::Collector, HistogramOpts, HistogramVec};
 use prover::proving::{
-    self, BlockFinality, BranchNodeData, PreCommit, ProofWithCircuitData, StorageInclusion,
+    self, BlockFinality, BranchNodeData, GenesisConfig, PreCommit, ProofWithCircuitData,
+    StorageInclusion,
 };
 
 pub struct Metrics;
@@ -27,15 +27,18 @@ lazy_static::lazy_static!(
         ).unwrap();
 );
 
-pub async fn prove_genesis(gear_api: &GearApi) -> anyhow::Result<ProofWithCircuitData> {
+pub async fn prove_genesis(
+    gear_api: &GearApi,
+    genesis_config: GenesisConfig,
+) -> anyhow::Result<ProofWithCircuitData> {
     log::info!(
         "Proving genesis authority set change {} -> {}",
-        GENESIS_CONFIG.authority_set_id,
-        GENESIS_CONFIG.authority_set_id + 1
+        genesis_config.authority_set_id,
+        genesis_config.authority_set_id + 1
     );
 
     let (block, current_epoch_block_finality) = gear_api
-        .fetch_finality_proof_for_session(GENESIS_CONFIG.authority_set_id)
+        .fetch_finality_proof_for_session(genesis_config.authority_set_id)
         .await?;
 
     let next_validator_set_inclusion_proof = gear_api
@@ -51,7 +54,7 @@ pub async fn prove_genesis(gear_api: &GearApi) -> anyhow::Result<ProofWithCircui
 
     let proof = prover::proving::prove_genesis(
         parse_rpc_block_finality_proof(current_epoch_block_finality),
-        GENESIS_CONFIG,
+        genesis_config,
         next_validator_set_inclusion_proof,
         next_validator_set_storage_data,
     );
@@ -154,6 +157,7 @@ impl FinalProof {
 pub async fn prove_final(
     gear_api: &GearApi,
     previous_proof: ProofWithCircuitData,
+    genesis_config: GenesisConfig,
     at_block: H256,
 ) -> anyhow::Result<FinalProof> {
     let (block, block_finality) = gear_api.fetch_finality_proof(at_block).await?;
@@ -168,7 +172,7 @@ pub async fn prove_final(
     let proof = proving::prove_message_sent(
         previous_proof,
         parse_rpc_block_finality_proof(block_finality),
-        GENESIS_CONFIG,
+        genesis_config,
         sent_message_inclusion_proof,
         message_contents,
     );

relayer/src/relay_merkle_roots.rs

@@ -1,4 +1,5 @@
 use prometheus::{Gauge, IntGauge};
+use prover::proving::GenesisConfig;
 use std::{
     thread,
     time::{Duration, Instant},
@@ -7,7 +8,6 @@ use std::{
 use crate::{
     proof_storage::ProofStorage,
     prover_interface::{self, FinalProof},
-    GENESIS_CONFIG,
 };
 
 use ethereum_client::{EthApi, TxHash, TxStatus};
@@ -20,9 +20,12 @@ const MIN_MAIN_LOOP_DURATION: Duration = Duration::from_secs(5);
 pub struct MerkleRootRelayer {
     gear_api: GearApi,
     eth_api: EthApi,
+
     proof_storage: Box<dyn ProofStorage>,
     eras: Eras,
 
+    genesis_config: GenesisConfig,
+
     metrics: Metrics,
 }
 
@@ -73,9 +76,10 @@ impl MerkleRootRelayer {
     pub async fn new(
         gear_api: GearApi,
         eth_api: EthApi,
+        genesis_config: GenesisConfig,
         proof_storage: Box<dyn ProofStorage>,
     ) -> MerkleRootRelayer {
-        let eras = Eras::new(None, gear_api.clone(), eth_api.clone())
+        let eras = Eras::new(None, gear_api.clone(), eth_api.clone(), genesis_config)
             .await
             .unwrap_or_else(|err| panic!("Error while creating era storage: {}", err));
 
@@ -84,6 +88,7 @@ impl MerkleRootRelayer {
         MerkleRootRelayer {
             gear_api,
             eth_api,
+            genesis_config,
             proof_storage,
             eras,
             metrics,
@@ -162,18 +167,18 @@ impl MerkleRootRelayer {
 
         match latest_proven_authority_set_id {
             None => {
-                if latest_authority_set_id <= GENESIS_CONFIG.authority_set_id {
+                if latest_authority_set_id <= self.genesis_config.authority_set_id {
                     log::warn!(
                         "Network haven't reached genesis authority set id yet. Current authority set id: {}, expected genesis: {}", 
                         latest_authority_set_id,
-                        GENESIS_CONFIG.authority_set_id,
+                        self.genesis_config.authority_set_id,
                     );
                     return Ok(0);
                 }
 
-                let proof = prover_interface::prove_genesis(&self.gear_api).await?;
+                let proof = prover_interface::prove_genesis(&self.gear_api, self.genesis_config).await?;
                 self.proof_storage
-                    .init(proof, GENESIS_CONFIG.authority_set_id)
+                    .init(proof, self.genesis_config.authority_set_id)
                     .unwrap();
 
                 Ok(1)
@@ -211,7 +216,13 @@ impl MerkleRootRelayer {
             .proof_storage
             .get_proof_for_authority_set_id(authority_set_id)?;
 
-        prover_interface::prove_final(&self.gear_api, inner_proof, finalized_head).await
+        prover_interface::prove_final(
+            &self.gear_api,
+            inner_proof,
+            self.genesis_config,
+            finalized_head,
+        )
+        .await
     }
 }
 
@@ -222,6 +233,8 @@ struct Eras {
     gear_api: GearApi,
     eth_api: EthApi,
 
+    genesis_config: GenesisConfig,
+
     metrics: EraMetrics,
 }
 
@@ -266,6 +279,7 @@ impl Eras {
         last_sealed: Option<u64>,
         gear_api: GearApi,
         eth_api: EthApi,
+        genesis_config: GenesisConfig,
     ) -> anyhow::Result<Self> {
         let last_sealed = if let Some(l) = last_sealed {
             l
@@ -285,6 +299,8 @@ impl Eras {
             gear_api,
             eth_api,
 
+            genesis_config,
+
             metrics,
         })
     }
@@ -316,7 +332,9 @@ impl Eras {
             .find_era_first_block(authority_set_id + 1)
             .await?;
         let inner_proof = proof_storage.get_proof_for_authority_set_id(authority_set_id)?;
-        let proof = prover_interface::prove_final(&self.gear_api, inner_proof, block).await?;
+        let proof =
+            prover_interface::prove_final(&self.gear_api, inner_proof, self.genesis_config, block)
+                .await?;
 
         let block_number = self.gear_api.block_hash_to_number(block).await?;