fix: warnings

Author: Ludo Galabru

src/bin.rs

@@ -3,9 +3,6 @@ extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 
-#[macro_use]
-extern crate lazy_static;
-
 #[macro_use]
 extern crate rocket;
 

src/deployment/mod.rs

@@ -46,7 +46,7 @@ use clarity_repl::repl::SessionSettings;
 use clarity_repl::repl::{ExecutionResult, Session};
 use libsecp256k1::{PublicKey, SecretKey};
 use serde_yaml;
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+use std::collections::{BTreeMap, HashMap, VecDeque};
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::PathBuf;
@@ -68,14 +68,15 @@ pub struct DeploymentGenerationArtifacts {
     pub diags: HashMap<QualifiedContractIdentifier, Vec<Diagnostic>>,
 }
 
+#[allow(dead_code)]
 pub fn encode_contract_call(
     _contract_name: &ContractName,
     _source: &str,
     _nonce: u64,
     _deployment_fee_rate: u64,
     _network: &StacksNetwork,
 ) -> Result<(StacksTransaction, StacksAddress), String> {
-    Err(format!("unimplemented"))
+    Err(format!("encode_contract_call operations unimplemented"))
 }
 
 pub fn encode_contract_publish(
@@ -323,7 +324,7 @@ pub fn get_absolute_deployment_path(
     manifest: &ProjectManifest,
     relative_deployment_path: &str,
 ) -> PathBuf {
-    let mut base_path = manifest.get_project_root_dir();
+    let base_path = manifest.get_project_root_dir();
     let path = match PathBuf::from_str(relative_deployment_path) {
         Ok(path) => path,
         Err(_e) => {
@@ -481,7 +482,7 @@ pub fn apply_on_chain_deployment(
                     let _ =
                         deployment_event_tx.send(DeploymentEvent::ContractUpdate(ContractUpdate {
                             contract_id: format!("{}.{}", issuer_address, tx.contract_name),
-                            status: ContractStatus::Queued,
+                            status: ContractStatus::Encoded,
                             comment: None,
                         }));
                 }
@@ -522,7 +523,17 @@ pub fn apply_on_chain_deployment(
                         (sender, contract_name, TransactionStatus::Broadcasted),
                     );
                 }
-                Err(_e) => return,
+                Err(e) => {
+                    let message = format!("{:?}", e);
+                    let _ =
+                        deployment_event_tx.send(DeploymentEvent::ContractUpdate(ContractUpdate {
+                            contract_id: format!("{}.{}", sender.to_address(), contract_name),
+                            status: ContractStatus::Error,
+                            comment: Some(message.clone()),
+                        }));
+                    let _ = deployment_event_tx.send(DeploymentEvent::Interrupted(message));
+                    return;
+                }
             };
         }
 
@@ -578,7 +589,7 @@ pub fn apply_on_chain_deployment(
 }
 
 pub fn check_deployments(manifest: &ProjectManifest) -> Result<(), String> {
-    let mut base_path = manifest.get_project_root_dir();
+    let base_path = manifest.get_project_root_dir();
     let files = get_deployments_files(manifest)?;
     for (path, relative_path) in files.into_iter() {
         let _spec = match DeploymentSpecification::from_config_file(&path, &base_path) {
@@ -764,7 +775,7 @@ pub fn generate_default_deployment(
     let mut boot_contracts_asts = session.get_boot_contracts_asts();
     let boot_contracts_ids = boot_contracts_asts
         .iter()
-        .map(|(k, v)| k.clone())
+        .map(|(k, _)| k.clone())
         .collect::<Vec<QualifiedContractIdentifier>>();
     requirements_asts.append(&mut boot_contracts_asts);
 

src/deployment/requirements.rs

@@ -54,10 +54,11 @@ pub fn retrieve_contract(
     Ok((code, file_path))
 }
 
+#[allow(dead_code)]
 #[derive(Deserialize, Debug, Default, Clone)]
 struct Contract {
     source: String,
-    publish_height: u32,
+    _publish_height: u32,
 }
 
 async fn fetch_contract(request_url: String) -> Result<Contract, String> {

src/deployment/ui/mod.rs

@@ -9,8 +9,8 @@ use crossterm::{
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
+use std::io::stdout;
 use std::sync::mpsc::Receiver;
-use std::{error::Error, io::stdout};
 use tui::{backend::CrosstermBackend, Terminal};
 
 pub fn start_ui(

src/frontend/cli.rs

@@ -1,8 +1,8 @@
 use crate::deployment::{
     self, apply_on_chain_deployment, check_deployments, generate_default_deployment,
     get_absolute_deployment_path, get_default_deployment_path, load_deployment,
-    load_deployment_if_exists, read_deployment_or_generate_default, setup_session_with_deployment,
-    write_deployment, DeploymentCommand, DeploymentEvent,
+    load_deployment_if_exists, setup_session_with_deployment, write_deployment, DeploymentCommand,
+    DeploymentEvent,
 };
 use crate::generate::{
     self,
@@ -528,6 +528,18 @@ pub fn main() {
                 let (command_tx, command_rx) = std::sync::mpsc::channel();
                 let (event_tx, event_rx) = std::sync::mpsc::channel();
                 let manifest_moved = manifest.clone();
+
+                if manifest.project.telemetry {
+                    #[cfg(feature = "telemetry")]
+                    telemetry_report_event(DeveloperUsageEvent::ProtocolPublished(
+                        DeveloperUsageDigest::new(
+                            &manifest.project.name,
+                            &manifest.project.authors,
+                        ),
+                        deployment.network.clone(),
+                    ));
+                }
+
                 std::thread::spawn(move || {
                     let manifest = manifest_moved;
                     apply_on_chain_deployment(&manifest, deployment, event_tx, command_rx, true);
@@ -539,7 +551,7 @@ pub fn main() {
                     loop {
                         let cmd = match event_rx.recv() {
                             Ok(cmd) => cmd,
-                            Err(e) => break,
+                            Err(_e) => break,
                         };
                         match cmd {
                             DeploymentEvent::Interrupted(message) => {
@@ -583,13 +595,8 @@ pub fn main() {
             Contracts::NewContract(cmd) => {
                 let manifest = load_manifest_or_exit(cmd.manifest_path);
 
-                let changes = generate::get_changes_for_new_contract(
-                    &manifest.path,
-                    cmd.name,
-                    None,
-                    true,
-                    vec![],
-                );
+                let changes =
+                    generate::get_changes_for_new_contract(&manifest.path, cmd.name, None, true);
                 if !execute_changes(changes) {
                     std::process::exit(1);
                 }
@@ -676,6 +683,10 @@ pub fn main() {
             let mut terminal = Terminal::load(session);
             terminal.start();
 
+            if hints_enabled {
+                display_post_console_hint();
+            }
+
             // Report telemetry
             if manifest.project.telemetry {
                 #[cfg(feature = "telemetry")]

src/frontend/dap.rs

@@ -45,8 +45,8 @@ pub fn run_dap() -> Result<(), String> {
                 false,
                 None,
             ) {
-                Ok(result) => Ok(()),
-                Err(diagnostics) => Err("unable to interpret expression".to_string()),
+                Ok(_result) => Ok(()),
+                Err(_diagnostics) => Err("unable to interpret expression".to_string()),
             }
         }
         Err(e) => Err(format!("dap_init: {}", e)),

src/frontend/telemetry.rs

@@ -13,7 +13,7 @@ pub enum DeveloperUsageEvent {
     CheckExecuted(DeveloperUsageDigest),
     TestSuiteExecuted(DeveloperUsageDigest, bool, u32),
     DevnetExecuted(DeveloperUsageDigest),
-    ContractPublished(DeveloperUsageDigest, StacksNetwork),
+    ProtocolPublished(DeveloperUsageDigest, StacksNetwork),
     DebugStarted(DeveloperUsageDigest, u32),
     DAPDebugStarted(DeveloperUsageDigest),
     UnknownCommand(DeveloperUsageDigest, String),
@@ -84,8 +84,8 @@ async fn send_event(event: DeveloperUsageEvent) {
                 "ci_mode": ci_mode,
             }),
         ),
-        DeveloperUsageEvent::ContractPublished(digest, network) => (
-            "ContractPublished",
+        DeveloperUsageEvent::ProtocolPublished(digest, network) => (
+            "ProtocolPublished",
             json!({
                 "project_id": digest.project_id,
                 "team_id": digest.team_id,

src/generate/contract.rs

@@ -19,12 +19,12 @@ impl GetChangesForNewContract {
         }
     }
 
-    pub fn run(&mut self, include_test: bool, deps: Vec<String>) -> Vec<Changes> {
+    pub fn run(&mut self, include_test: bool) -> Vec<Changes> {
         self.create_template_contract();
         if include_test {
             self.create_template_test();
         }
-        self.index_contract_in_clarinet_toml(deps);
+        self.index_contract_in_clarinet_toml();
         self.changes.clone()
     }
 
@@ -115,7 +115,7 @@ Clarinet.test({{
         self.changes.push(Changes::AddFile(change));
     }
 
-    fn index_contract_in_clarinet_toml(&mut self, deps: Vec<String>) {
+    fn index_contract_in_clarinet_toml(&mut self) {
         let contract_file_name = format!("{}.clar", self.contract_name);
         let manifest_path = self.manifest_path.clone();
 

src/generate/mod.rs

@@ -3,12 +3,11 @@ mod contract;
 mod notebook;
 mod project;
 
-use crate::types::RequirementConfig;
 pub use changes::{Changes, DirectoryCreation, FileCreation, TOMLEdition};
 use contract::GetChangesForNewContract;
 use notebook::GetChangesForNewNotebook;
 use project::GetChangesForNewProject;
-use std::{collections::HashMap, path::PathBuf};
+use std::path::PathBuf;
 
 pub fn get_changes_for_new_project(
     project_path: String,
@@ -24,26 +23,9 @@ pub fn get_changes_for_new_contract(
     contract_name: String,
     source: Option<String>,
     include_test: bool,
-    deps: Vec<String>,
 ) -> Vec<Changes> {
     let mut command = GetChangesForNewContract::new(manifest_path.clone(), contract_name, source);
-    command.run(include_test, deps)
-}
-
-pub fn get_changes_for_new_link(
-    manifest_path: PathBuf,
-    contract_id: String,
-    _source: Option<String>,
-) -> Vec<Changes> {
-    let change = TOMLEdition {
-        comment: format!("Adding {} as a requirement in Clarinet.toml", contract_id),
-        manifest_path,
-        contracts_to_add: HashMap::new(),
-        requirements_to_add: vec![RequirementConfig {
-            contract_id: contract_id.clone(),
-        }],
-    };
-    vec![Changes::EditTOML(change)]
+    command.run(include_test)
 }
 
 #[allow(dead_code)]

src/integrate/chains_coordinator.rs

@@ -1,9 +1,6 @@
 use super::DevnetEvent;
 use crate::deployment::types::DeploymentSpecification;
-use crate::deployment::{
-    apply_on_chain_deployment, read_deployment_or_generate_default, setup_session_with_deployment,
-    DeploymentCommand, DeploymentEvent,
-};
+use crate::deployment::{apply_on_chain_deployment, DeploymentCommand, DeploymentEvent};
 use crate::indexer::{chains, Indexer, IndexerConfig};
 use crate::integrate::{MempoolAdmissionData, ServiceStatusData, Status};
 use crate::types::{self, AccountConfig, ChainConfig, DevnetConfig, ProjectManifest};
@@ -15,18 +12,17 @@ use clarity_repl::clarity::representations::ClarityName;
 use clarity_repl::clarity::types::{BuffData, SequenceData, TupleData, Value as ClarityValue};
 use clarity_repl::clarity::util::address::AddressHashMode;
 use clarity_repl::clarity::util::hash::{hex_bytes, Hash160};
-use clarity_repl::repl::settings::InitialContract;
-use clarity_repl::repl::Session;
+
 use rocket::config::{Config, LogLevel};
 use rocket::serde::json::{json, Json, Value as JsonValue};
 use rocket::serde::Deserialize;
 use rocket::State;
-use std::collections::VecDeque;
+
 use std::convert::TryFrom;
 use std::error::Error;
-use std::iter::FromIterator;
+
 use std::net::{IpAddr, Ipv4Addr};
-use std::path::PathBuf;
+
 use std::str;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -289,7 +285,6 @@ pub fn handle_new_bitcoin_block(
     indexer_rw_lock: &State<Arc<RwLock<Indexer>>>,
     devnet_events_tx: &State<Arc<Mutex<Sender<DevnetEvent>>>>,
     marshalled_block: Json<JsonValue>,
-    background_job_tx_mutex: &State<Arc<Mutex<Sender<ChainsCoordinatorCommand>>>>,
 ) -> Json<JsonValue> {
     let devnet_events_tx = devnet_events_tx.inner();
 
@@ -622,7 +617,7 @@ pub fn perform_protocol_deployment(
         loop {
             let event = match deployment_events_rx.recv() {
                 Ok(event) => event,
-                Err(e) => break,
+                Err(_e) => break,
             };
             match event {
                 DeploymentEvent::ContractUpdate(_) => {}