unify chain id generation and usage

fuel-block-executor/Cargo.toml

@@ -11,5 +11,6 @@ description = "Fuel Block Executor"
 
 [dependencies]
 anyhow = "1.0"
+fuel-chain-config = { path = "../fuel-chain-config", version = "0.15.0" }
 fuel-core-interfaces = { path = "../fuel-core-interfaces", version = "0.15.0" }
 tokio = { version = "1.21", features = ["full"] }

fuel-block-executor/src/refs.rs

@@ -1,3 +1,6 @@
 mod contract;
 
-pub use contract::ContractRef;
+pub use contract::{
+    ContractRef,
+    ContractStorageTrait,
+};

fuel-block-executor/src/refs/contract.rs

@@ -1,24 +1,34 @@
+use fuel_chain_config::GenesisCommitment;
 use fuel_core_interfaces::{
     common::{
         fuel_storage::{
             Mappable,
             MerkleRootStorage,
+            StorageAsMut,
             StorageAsRef,
             StorageInspect,
         },
         fuel_tx::{
             Bytes32,
             ContractId,
         },
+        prelude::{
+            Hasher,
+            MerkleRoot,
+        },
     },
     db::{
         ContractsAssets,
         ContractsLatestUtxo,
         ContractsState,
     },
     executor::Error,
+    not_found,
+};
+use std::{
+    borrow::Cow,
+    error::Error as StdError,
 };
-use std::borrow::Cow;
 
 /// The wrapper around `contract_id` to simplify work with `Contract` in the database.
 pub struct ContractRef<Database> {
@@ -102,3 +112,47 @@ where
         self.database.root(&self.contract_id).map(Into::into)
     }
 }
+
+pub trait ContractStorageTrait<'a>:
+    StorageInspect<ContractsLatestUtxo, Error = Self::InnerError>
+    + MerkleRootStorage<ContractId, ContractsState<'a>, Error = Self::InnerError>
+    + MerkleRootStorage<ContractId, ContractsAssets<'a>, Error = Self::InnerError>
+{
+    type InnerError: StdError + Send + Sync + 'static;
+}
+
+impl<'a, Database> GenesisCommitment for ContractRef<&'a mut Database>
+where
+    for<'b> Database: ContractStorageTrait<'a>,
+{
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        let contract_id = *self.contract_id();
+        let utxo = self
+            .database()
+            .storage::<ContractsLatestUtxo>()
+            .get(&contract_id)?
+            .ok_or(not_found!(ContractsLatestUtxo))?
+            .into_owned();
+
+        let state_root = self
+            .database_mut()
+            .storage::<ContractsState>()
+            .root(&contract_id)?;
+
+        let balance_root = self
+            .database_mut()
+            .storage::<ContractsAssets>()
+            .root(&contract_id)?;
+
+        let contract_hash = *Hasher::default()
+            // `ContractId` already is based on contract's code and salt so we don't need it.
+            .chain(contract_id.as_ref())
+            .chain(utxo.tx_id().as_ref())
+            .chain([utxo.output_index()])
+            .chain(state_root.as_slice())
+            .chain(balance_root.as_slice())
+            .finalize();
+
+        Ok(contract_hash)
+    }
+}

fuel-chain-config/Cargo.toml

@@ -12,6 +12,7 @@ description = "Fuel Chain config types"
 
 [dependencies]
 anyhow = "1.0"
+bincode = "1.3"
 fuel-core-interfaces = { path = "../fuel-core-interfaces", version = "0.15.0", features = [
     "serde",
 ] }

fuel-chain-config/src/config/chain.rs

@@ -4,6 +4,10 @@ use fuel_core_interfaces::common::{
         Address,
         AssetId,
     },
+    prelude::{
+        Hasher,
+        MerkleRoot,
+    },
 };
 use itertools::Itertools;
 use rand::{
@@ -22,6 +26,8 @@ use std::{
     str::FromStr,
 };
 
+use crate::GenesisCommitment;
+
 use super::{
     coin::CoinConfig,
     state::StateConfig,
@@ -123,6 +129,30 @@ impl FromStr for ChainConfig {
     }
 }
 
+impl GenesisCommitment for ChainConfig {
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        // TODO: Hash settlement configuration, consensus block production
+        let config_hash = *Hasher::default()
+            .chain(self.block_gas_limit.to_be_bytes())
+            .chain(self.transaction_parameters.root()?)
+            .chain(self.chain_name.as_bytes())
+            .finalize();
+
+        Ok(config_hash)
+    }
+}
+
+impl GenesisCommitment for ConsensusParameters {
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        // TODO: Define hash algorithm for `ConsensusParameters`
+        let params_hash = Hasher::default()
+            .chain(bincode::serialize(&self)?)
+            .finalize();
+
+        Ok(params_hash.into())
+    }
+}
+
 /// Block production mode and settings
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlockProduction {

fuel-chain-config/src/config/coin.rs

@@ -1,14 +1,26 @@
-use crate::serialization::{
-    HexNumber,
-    HexType,
+use crate::{
+    serialization::{
+        HexNumber,
+        HexType,
+    },
+    GenesisCommitment,
 };
 use fuel_core_interfaces::{
-    common::fuel_types::{
-        Address,
-        AssetId,
-        Bytes32,
+    common::{
+        fuel_types::{
+            Address,
+            AssetId,
+            Bytes32,
+        },
+        prelude::{
+            Hasher,
+            MerkleRoot,
+        },
+    },
+    model::{
+        BlockHeight,
+        Coin,
     },
-    model::BlockHeight,
 };
 
 use serde::{
@@ -45,3 +57,18 @@ pub struct CoinConfig {
     #[serde_as(as = "HexType")]
     pub asset_id: AssetId,
 }
+
+impl GenesisCommitment for Coin {
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        let coin_hash = *Hasher::default()
+            .chain(self.owner)
+            .chain(self.amount.to_be_bytes())
+            .chain(self.asset_id)
+            .chain((*self.maturity).to_be_bytes())
+            .chain([self.status as u8])
+            .chain((*self.block_created).to_be_bytes())
+            .finalize();
+
+        Ok(coin_hash)
+    }
+}

fuel-chain-config/src/config/message.rs

@@ -1,10 +1,14 @@
-use crate::serialization::{
-    HexNumber,
-    HexType,
+use crate::{
+    serialization::{
+        HexNumber,
+        HexType,
+    },
+    GenesisCommitment,
 };
 use fuel_core_interfaces::{
     common::prelude::{
         Address,
+        MerkleRoot,
         Word,
     },
     model::{
@@ -53,3 +57,9 @@ impl From<MessageConfig> for Message {
         }
     }
 }
+
+impl GenesisCommitment for Message {
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        Ok(self.id().into())
+    }
+}

fuel-chain-config/src/genesis.rs

@@ -0,0 +1,25 @@
+use fuel_core_interfaces::{
+    common::prelude::{
+        Hasher,
+        MerkleRoot,
+    },
+    model::Genesis,
+};
+
+pub trait GenesisCommitment {
+    /// Calculates the merkle root of the state of the entity.
+    fn root(&mut self) -> anyhow::Result<MerkleRoot>;
+}
+
+impl GenesisCommitment for Genesis {
+    fn root(&mut self) -> anyhow::Result<MerkleRoot> {
+        let genesis_hash = *Hasher::default()
+            .chain(self.chain_config_hash)
+            .chain(self.coins_root)
+            .chain(self.contracts_root)
+            .chain(self.messages_root)
+            .finalize();
+
+        Ok(genesis_hash)
+    }
+}

fuel-chain-config/src/lib.rs

@@ -1,4 +1,6 @@
 pub mod config;
+mod genesis;
 mod serialization;
 
 pub use config::*;
+pub use genesis::GenesisCommitment;

fuel-core-interfaces/src/model/block.rs

@@ -592,7 +592,7 @@ impl From<FuelBlock> for PartialFuelBlock {
 /// network - contracts states, contracts balances, unspent coins, and messages. It also contains
 /// the hash on the initial config of the network that defines the consensus rules for following
 /// blocks.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Genesis {
     /// The chain config define what consensus type to use, what settlement layer to use,

fuel-core/src/cli/run.rs

@@ -110,7 +110,7 @@ pub struct Command {
 
     #[cfg(feature = "p2p")]
     #[clap(flatten)]
-    pub p2p_args: p2p::P2pArgs,
+    pub p2p_args: p2p::P2PArgs,
 
     #[clap(long = "metrics")]
     pub metrics: bool,
@@ -143,14 +143,7 @@ impl Command {
         let chain_conf: ChainConfig = chain_config.as_str().parse()?;
 
         #[cfg(feature = "p2p")]
-        let p2p_cfg = {
-            let mut p2p = match p2p_args.into_config(&chain_conf) {
-                Ok(value) => value,
-                Err(e) => return Err(e),
-            };
-            p2p.metrics = metrics;
-            p2p
-        };
+        let p2p_cfg = p2p_args.into_config(metrics)?;
 
         // if consensus key is not configured, fallback to dev consensus key
         let consensus_key = load_consensus_key(consensus_key)?.or_else(|| {

fuel-core/src/cli/run/p2p.rs

@@ -9,16 +9,18 @@ use std::{
 
 use clap::Args;
 
-use fuel_chain_config::ChainConfig;
 use fuel_core_interfaces::common::fuel_crypto;
 use fuel_p2p::{
-    config::P2PConfig,
+    config::{
+        NotInitialized,
+        P2PConfig,
+    },
     gossipsub_config::default_gossipsub_builder,
     Multiaddr,
 };
 
 #[derive(Debug, Clone, Args)]
-pub struct P2pArgs {
+pub struct P2PArgs {
     /// Path to the location of DER-encoded Secp256k1 Keypair
     #[clap(long = "keypair")]
     pub keypair: Option<PathBuf>,
@@ -132,12 +134,8 @@ pub struct P2pArgs {
     pub connection_keep_alive: u64,
 }
 
-impl P2pArgs {
-    pub fn into_config(self, chain_config: &ChainConfig) -> anyhow::Result<P2PConfig> {
-        let checksum = *fuel_crypto::Hasher::default()
-            .chain(bincode::serialize(chain_config)?)
-            .finalize();
-
+impl P2PArgs {
+    pub fn into_config(self, metrics: bool) -> anyhow::Result<P2PConfig<NotInitialized>> {
         let local_keypair = {
             match self.keypair {
                 Some(path) => {
@@ -181,9 +179,9 @@ impl P2pArgs {
         };
 
         Ok(P2PConfig {
-            local_keypair,
+            keypair: local_keypair,
             network_name: self.network,
-            checksum,
+            checksum: Default::default(),
             address: self
                 .address
                 .unwrap_or_else(|| IpAddr::V4(Ipv4Addr::from([0, 0, 0, 0]))),
@@ -206,7 +204,8 @@ impl P2pArgs {
             set_connection_keep_alive: Duration::from_secs(self.connection_keep_alive),
             info_interval: Some(Duration::from_secs(self.info_interval)),
             identify_interval: Some(Duration::from_secs(self.identify_interval)),
-            metrics: false,
+            metrics,
+            state: NotInitialized,
         })
     }
 }