Finish refactoring changes and fix linter warnings

applications/tari_app_grpc/proto/wallet.proto

@@ -287,10 +287,10 @@ message CreateFollowOnAssetCheckpointResponse {
 }
 
 message CreateCommitteeDefinitionRequest {
-    bytes asset_public_key = 1;
-    repeated bytes committee = 2;
-    uint64 effective_sidechain_height = 3;
-    bool is_initial = 4;
+    bytes contract_id = 1;
+    CommitteeMembers validator_committee = 2;
+    uint64 acceptance_period_expiry = 3;
+    uint64 minimum_quorum_required = 4;
 }
 
 message CreateCommitteeDefinitionResponse {

applications/tari_app_grpc/src/conversions/sidechain_features.rs

@@ -68,6 +68,45 @@ impl TryFrom<grpc::SideChainFeatures> for SideChainFeatures {
     }
 }
 
+impl TryFrom<grpc::CreateCommitteeDefinitionRequest> for SideChainFeatures {
+    type Error = String;
+
+    fn try_from(request: grpc::CreateCommitteeDefinitionRequest) -> Result<Self, Self::Error> {
+        let acceptance_period_expiry = request.acceptance_period_expiry;
+        let minimum_quorum_required = request.minimum_quorum_required;
+        let validator_committee = request
+            .validator_committee
+            .map(CommitteeMembers::try_from)
+            .transpose()?
+            .unwrap();
+
+        Ok(Self {
+            contract_id: request.contract_id.try_into().map_err(|_| "Invalid contract_id")?,
+            definition: None,
+            constitution: Some(ContractConstitution {
+                validator_committee: validator_committee.clone(),
+                acceptance_requirements: ContractAcceptanceRequirements {
+                    minimum_quorum_required: minimum_quorum_required as u32,
+                    acceptance_period_expiry,
+                },
+                consensus: SideChainConsensus::MerkleRoot,
+                checkpoint_params: CheckpointParameters {
+                    minimum_quorum_required: 5,
+                    abandoned_interval: 100,
+                },
+                constitution_change_rules: ConstitutionChangeRules {
+                    change_flags: ConstitutionChangeFlags::all(),
+                    requirements_for_constitution_change: Some(RequirementsForConstitutionChange {
+                        minimum_constitution_committee_signatures: 5,
+                        constitution_committee: Some(validator_committee),
+                    }),
+                },
+                initial_reward: 100.into(),
+            }),
+        })
+    }
+}
+
 //---------------------------------- ContractDefinition --------------------------------------------//
 
 impl TryFrom<grpc::ContractDefinition> for ContractDefinition {

applications/tari_collectibles/src-tauri/src/clients/wallet_client.rs

@@ -137,22 +137,23 @@ impl WalletClient {
   pub async fn create_committee_definition(
     &mut self,
     asset_public_key: &str,
-    committee: &[String],
-    effective_sidechain_height: u64,
-    is_initial: bool,
+    committee: Vec<String>,
+    acceptance_period_expiry: u64,
+    minimum_quorum_required: u64,
   ) -> Result<grpc::CreateCommitteeDefinitionResponse, CollectiblesError> {
     let inner = self.get_inner_mut()?;
-    let committee = committee
-      .iter()
-      .map(|s| Vec::from_hex(s))
-      .collect::<Result<Vec<_>, _>>()?;
+
+    let committee = tari_app_grpc::tari_rpc::CommitteeMembers {
+      members: committee.into_iter().map(|s| s.into_bytes()).collect(),
+    };
 
     let request = grpc::CreateCommitteeDefinitionRequest {
-      asset_public_key: Vec::from_hex(asset_public_key)?,
-      committee,
-      effective_sidechain_height,
-      is_initial,
+      contract_id: Vec::from_hex(asset_public_key)?,
+      validator_committee: Some(committee),
+      acceptance_period_expiry,
+      minimum_quorum_required,
     };
+
     let result = inner
       .create_committee_definition(request)
       .await

applications/tari_collectibles/src-tauri/src/commands/assets/mod.rs

@@ -308,17 +308,23 @@ pub(crate) async fn inner_assets_create_initial_checkpoint(
 
 #[tauri::command]
 pub(crate) async fn assets_create_committee_definition(
-  asset_public_key: String,
+  contract_id: String,
   committee: Vec<String>,
-  is_initial: bool,
+  acceptance_period_expiry: u64,
+  minimum_quorum_required: u64,
   state: tauri::State<'_, ConcurrentAppState>,
 ) -> Result<Vec<String>, Status> {
   let mut client = state.create_wallet_client().await;
   client.connect().await?;
 
   // TODO: effective sidechain height...
   client
-    .create_committee_definition(&asset_public_key, &committee, 0, is_initial)
+    .create_committee_definition(
+      &contract_id,
+      committee.clone(),
+      acceptance_period_expiry,
+      minimum_quorum_required,
+    )
     .await?;
 
   Ok(committee)

applications/tari_console_wallet/src/automation/commands.rs

@@ -56,7 +56,7 @@ use tari_core::transactions::{
         ContractDefinition,
         RequirementsForConstitutionChange,
         SideChainConsensus,
-        SideChainFeatures,
+        SideChainFeaturesBuilder,
         TransactionOutput,
         UnblindedOutput,
     },
@@ -884,12 +884,12 @@ pub async fn command_runner(
                 }?;
 
                 let acceptance_period_expiry = match parsed.args.get(1) {
-                    Some(ParsedArgument::Int(ref int)) => Ok(int.clone()),
+                    Some(ParsedArgument::Int(ref int)) => Ok(*int),
                     _ => Err(CommandError::Argument),
                 }?;
 
                 let minimum_quorum_required = match parsed.args.get(1) {
-                    Some(ParsedArgument::Int(ref int)) => Ok(int.clone()),
+                    Some(ParsedArgument::Int(ref int)) => Ok(*int),
                     _ => Err(CommandError::Argument),
                 }?;
 
@@ -903,10 +903,8 @@ pub async fn command_runner(
                         .collect::<Result<Vec<RistrettoPublicKey>, _>>()?,
                 )?;
 
-                let side_chain_features = SideChainFeatures {
-                    contract_id,
-                    definition: None,
-                    constitution: Some(ContractConstitution {
+                let side_chain_features = SideChainFeaturesBuilder::new(contract_id)
+                    .with_contract_constitution(ContractConstitution {
                         validator_committee: validator_committee.clone(),
                         acceptance_requirements: ContractAcceptanceRequirements {
                             minimum_quorum_required: minimum_quorum_required as u32,
@@ -925,8 +923,8 @@ pub async fn command_runner(
                             }),
                         },
                         initial_reward: 100.into(),
-                    }),
-                };
+                    })
+                    .finish();
 
                 let mut asset_manager = wallet.asset_manager.clone();
                 let (tx_id, transaction) = asset_manager.create_committee_definition(&side_chain_features).await?;

applications/tari_console_wallet/src/grpc/wallet_grpc_server.rs

@@ -85,9 +85,8 @@ use tari_common_types::{
 use tari_comms::{multiaddr::Multiaddr, types::CommsPublicKey, CommsNode};
 use tari_core::transactions::{
     tari_amount::MicroTari,
-    transaction_components::{OutputFeatures, UnblindedOutput},
+    transaction_components::{OutputFeatures, SideChainFeatures, UnblindedOutput},
 };
-use tari_crypto::ristretto::RistrettoPublicKey;
 use tari_utilities::{hex::Hex, ByteArray, Hashable};
 use tari_wallet::{
     connectivity_service::{OnlineStatus, WalletConnectivityInterface},
@@ -781,24 +780,10 @@ impl wallet_server::Wallet for WalletGrpcServer {
         let mut transaction_service = self.wallet.transaction_service.clone();
         let message = request.into_inner();
 
-        let asset_public_key = PublicKey::from_bytes(message.asset_public_key.as_slice())
-            .map_err(|e| Status::invalid_argument(format!("Asset public key was not a valid pub key:{}", e)))?;
-        let committee_public_keys: Vec<RistrettoPublicKey> = message
-            .committee
-            .iter()
-            .map(|c| PublicKey::from_bytes(c.as_slice()))
-            .collect::<Result<_, _>>()
-            .map_err(|err| Status::invalid_argument(format!("Committee did not contain valid pub keys:{}", err)))?;
-        let effective_sidechain_height = message.effective_sidechain_height;
-        let is_initial = message.is_initial;
+        let side_chain_features = SideChainFeatures::try_from(message).map_err(Status::internal)?;
 
         let (tx_id, transaction) = asset_manager
-            .create_committee_definition(
-                &asset_public_key,
-                &committee_public_keys,
-                effective_sidechain_height,
-                is_initial,
-            )
+            .create_committee_definition(&side_chain_features)
             .await
             .map_err(|e| Status::internal(e.to_string()))?;
 
@@ -807,12 +792,16 @@ impl wallet_server::Wallet for WalletGrpcServer {
             "Committee definition transaction: {:?}", transaction
         );
 
+        let committee_size = match side_chain_features.constitution {
+            Some(constitution) => constitution.validator_committee.members().len(),
+            None => 0,
+        };
+
         let message = format!(
-            "{} member committee for asset {}... at sidechain height {}",
-            committee_public_keys.len(),
-            &asset_public_key.to_hex()[..7],
-            effective_sidechain_height
+            "Committee definition for {} members for {:?}",
+            committee_size, side_chain_features.contract_id,
         );
+
         let _ = transaction_service
             .submit_transaction(tx_id, transaction, 0.into(), message)
             .await

base_layer/wallet/src/assets/asset_manager.rs

@@ -23,7 +23,7 @@
 use log::*;
 use tari_common_types::{
     transaction::TxId,
-    types::{Commitment, FixedHash, PublicKey, ASSET_CHECKPOINT_ID, COMMITTEE_DEFINITION_ID},
+    types::{Commitment, FixedHash, PublicKey, ASSET_CHECKPOINT_ID},
 };
 use tari_core::transactions::transaction_components::{
     ContractDefinition,

base_layer/wallet/src/assets/asset_manager_handle.rs

@@ -125,12 +125,12 @@ impl AssetManagerHandle {
 
     pub async fn create_committee_definition(
         &mut self,
-        constitution_definition: &SideChainFeatures,
+        side_chain_features: &SideChainFeatures,
     ) -> Result<(TxId, Transaction), WalletError> {
         match self
             .handle
             .call(AssetManagerRequest::CreateCommitteeDefinition {
-                constitution_definition: Box::new(constitution_definition.clone()),
+                constitution_definition: Box::new(side_chain_features.clone()),
             })
             .await??
         {