Merge branch 'development' into tx-result

* development:
  fix: db error when starting state sync fixes tari-project#225 (tari-project#227)
  feat: add template name to list templates + minor cleanups (tari-project#226)
  fix: remove handle new valid transaction check (tari-project#224)
  fix: vns should not store transactions for shards outside committee range (see issue tari-project#193) (tari-project#206)
  feat!: add is_mut field to function def (see issue tari-project#213) (tari-project#214)
  fix: fix VN merkle root mismatch (tari-project#220)
  feat: determine leader from payload (tari-project#221)

Cargo.toml

@@ -12,6 +12,7 @@ members = [
     "dan_layer/transaction_manifest",
     "dan_layer/template_test_tooling",
     "dan_layer/integration_tests",
+    "dan_layer/tari_bor",
     "applications/tari_validator_node",
     "applications/tari_validator_node_cli",
 ]

applications/tari_validator_node/proto/dan/consensus.proto

@@ -5,6 +5,7 @@ syntax = "proto3";
 
 package tari.dan.consensus;
 
+import "common.proto";
 import "transaction.proto";
 
 enum HotStuffMessageType {
@@ -58,9 +59,10 @@ message HotStuffTreeNode {
 
 message ValidatorMetadata {
   bytes public_key = 1;
-  bytes signature = 2;
-  bytes merkle_proof = 3;
-  uint64 merkle_leaf_index = 4;
+  bytes vn_shard_key = 2;
+  tari.dan.common.Signature signature = 3;
+  bytes merkle_proof = 4;
+  uint64 merkle_leaf_index = 5;
 }
 
 message TariDanPayload {

applications/tari_validator_node/src/bootstrap.rs

@@ -127,7 +127,12 @@ pub async fn spawn_services(
     );
 
     // Mempool
-    let mempool = mempool::spawn(rx_new_transaction_message, outbound_messaging.clone());
+    let mempool = mempool::spawn(
+        rx_new_transaction_message,
+        outbound_messaging.clone(),
+        epoch_manager.clone(),
+        node_identity.clone(),
+    );
 
     // Networking
     let peer_provider = CommsPeerProvider::new(comms.peer_manager());
@@ -171,7 +176,7 @@ pub async fn spawn_services(
         shutdown.clone(),
     )?;
 
-    let shard_store_store = SqliteShardStoreFactory::try_create(config.validator_node.data_dir.join("state.db"))?;
+    let shard_store_store = SqliteShardStoreFactory::try_create(config.validator_node.state_db_path())?;
 
     let comms = setup_p2p_rpc(config, comms, peer_provider, shard_store_store, mempool.clone());
     let comms = comms::spawn_comms_using_transport(comms, p2p_config.transport.clone())

applications/tari_validator_node/src/config.rs

@@ -98,6 +98,10 @@ pub struct ValidatorNodeConfig {
 }
 
 impl ValidatorNodeConfig {
+    pub fn state_db_path(&self) -> PathBuf {
+        self.data_dir.join("state.db")
+    }
+
     pub fn set_base_path<P: AsRef<Path>>(&mut self, base_path: P) {
         if !self.shard_key_file.is_absolute() {
             self.shard_key_file = base_path.as_ref().join(&self.shard_key_file);

applications/tari_validator_node/src/grpc/services/base_node_client.rs

@@ -101,7 +101,7 @@ impl BaseNodeClient for GrpcBaseNodeClient {
         })
     }
 
-    async fn get_validator_nodes(&mut self, height: u64) -> Result<Vec<ValidatorNode>, BaseNodeError> {
+    async fn get_validator_nodes(&mut self, height: u64) -> Result<Vec<ValidatorNode<CommsPublicKey>>, BaseNodeError> {
         let inner = self.connection().await?;
         let request = grpc::GetActiveValidatorNodesRequest { height };
         let mut vns = vec![];

applications/tari_validator_node/src/grpc/services/wallet_client.rs

@@ -62,7 +62,6 @@ impl GrpcWalletClient {
             let inner = Client::connect(url).await?;
             self.client = Some(inner);
         }
-        dbg!(self.endpoint);
         self.client
             .as_mut()
             .ok_or_else(|| DigitalAssetError::FatalError("no connection".into()))

applications/tari_validator_node/src/json_rpc/handlers.rs

@@ -181,7 +181,13 @@ impl JsonRpcHandlers {
             .map_err(internal_error(answer_id))?;
 
         if transaction.wait_for_result {
-            return wait_for_transaction_result(answer_id, hash, subscription, Duration::from_secs(30)).await;
+            return wait_for_transaction_result(
+                answer_id,
+                hash,
+                subscription,
+                Duration::from_secs(transaction.wait_for_result_timeout.unwrap_or(30)),
+            )
+            .await;
         }
 
         Ok(JsonRpcResponse::success(answer_id, SubmitTransactionResponse {
@@ -324,6 +330,7 @@ impl JsonRpcHandlers {
             templates: templates
                 .into_iter()
                 .map(|t| TemplateMetadata {
+                    name: t.name,
                     address: t.address,
                     url: t.url,
                     binary_sha: t.binary_sha,
@@ -351,6 +358,7 @@ impl JsonRpcHandlers {
 
         Ok(JsonRpcResponse::success(answer_id, GetTemplateResponse {
             registration_metadata: TemplateMetadata {
+                name: template.metadata.name,
                 address: template.metadata.address,
                 url: template.metadata.url,
                 binary_sha: template.metadata.binary_sha,

applications/tari_validator_node/src/json_rpc/server.rs

@@ -62,7 +62,7 @@ async fn handler(
     Extension(handlers): Extension<Arc<JsonRpcHandlers>>,
     ContentLengthLimit(value): ContentLengthLimit<JsonRpcExtractor, JSON_SIZE_LIMIT_BYTES>,
 ) -> JrpcResult {
-    info!(target: LOG_TARGET, "🌐 JSON-RPC request: {}", value.method);
+    debug!(target: LOG_TARGET, "🌐 JSON-RPC request: {}", value.method);
     match value.method.as_str() {
         // Transaction
         // "get_transaction_status" => handlers.get_transaction_status(value).await,

applications/tari_validator_node/src/p2p/proto/conversions/consensus.rs

@@ -54,7 +54,7 @@ impl From<VoteMessage> for proto::consensus::VoteMessage {
             shard_id: msg.shard().as_bytes().to_vec(),
             decision: i32::from(msg.decision().as_u8()),
             all_shard_nodes: msg.all_shard_nodes().iter().map(|n| n.clone().into()).collect(),
-            validator_metadata: Some(msg.validator_metadata().to_owned().into()),
+            validator_metadata: Some(msg.validator_metadata().clone().into()),
         }
     }
 }
@@ -63,6 +63,9 @@ impl TryFrom<proto::consensus::VoteMessage> for VoteMessage {
     type Error = anyhow::Error;
 
     fn try_from(value: proto::consensus::VoteMessage) -> Result<Self, Self::Error> {
+        let metadata = value
+            .validator_metadata
+            .ok_or_else(|| anyhow!("Validator metadata is missing"))?;
         Ok(VoteMessage::with_validator_metadata(
             TreeNodeHash::try_from(value.local_node_hash)?,
             ShardId::from_bytes(&value.shard_id)?,
@@ -72,17 +75,7 @@ impl TryFrom<proto::consensus::VoteMessage> for VoteMessage {
                 .into_iter()
                 .map(|n| n.try_into())
                 .collect::<Result<Vec<_>, _>>()?,
-            ValidatorMetadata::from_bytes(
-                &value.validator_metadata.as_ref().unwrap().public_key,
-                &value.validator_metadata.as_ref().unwrap().signature,
-                &value.validator_metadata.as_ref().unwrap().merkle_proof,
-                &value
-                    .validator_metadata
-                    .as_ref()
-                    .unwrap()
-                    .merkle_leaf_index
-                    .to_le_bytes(),
-            )?,
+            metadata.try_into()?,
         ))
     }
 }
@@ -308,30 +301,37 @@ impl From<SubstateState> for proto::consensus::SubstateState {
 
 // -------------------------------- ValidatorMetadata -------------------------------- //
 
+impl From<ValidatorMetadata> for proto::consensus::ValidatorMetadata {
+    fn from(msg: ValidatorMetadata) -> Self {
+        let merkle_proof = msg.encode_merkle_proof();
+        Self {
+            public_key: msg.public_key.to_vec(),
+            vn_shard_key: msg.vn_shard_key.as_bytes().to_vec(),
+            signature: Some(msg.signature.into()),
+            merkle_proof,
+            merkle_leaf_index: msg.merkle_leaf_index,
+        }
+    }
+}
+
 impl TryFrom<proto::consensus::ValidatorMetadata> for ValidatorMetadata {
     type Error = anyhow::Error;
 
     fn try_from(value: proto::consensus::ValidatorMetadata) -> Result<Self, Self::Error> {
-        Ok(Self {
-            public_key: value.public_key,
-            signature: value.signature,
-            merkle_proof: value.merkle_proof,
+        Ok(ValidatorMetadata {
+            public_key: PublicKey::from_bytes(&value.public_key)?,
+            vn_shard_key: value.vn_shard_key.try_into()?,
+            signature: value
+                .signature
+                .map(TryFrom::try_from)
+                .transpose()?
+                .ok_or_else(|| anyhow!("ValidatorMetadata missing signature"))?,
+            merkle_proof: ValidatorMetadata::decode_merkle_proof(&value.merkle_proof)?,
             merkle_leaf_index: value.merkle_leaf_index,
         })
     }
 }
 
-impl From<ValidatorMetadata> for proto::consensus::ValidatorMetadata {
-    fn from(value: ValidatorMetadata) -> Self {
-        Self {
-            public_key: value.public_key,
-            signature: value.signature,
-            merkle_proof: value.merkle_proof,
-            merkle_leaf_index: value.merkle_leaf_index,
-        }
-    }
-}
-
 // -------------------------------- TariDanPayload -------------------------------- //
 
 impl TryFrom<proto::consensus::TariDanPayload> for TariDanPayload {