fix: use subnet_leader_mnemonic to update subnet contract

Author: obycode

components/clarinet-cli/Cargo.toml

@@ -134,6 +134,7 @@ base58 = "0.2.0"
 ctrlc = "3.1.9"
 strum = { version = "0.23.0", features = ["derive"] }
 bitcoin = "0.29.2"
+tiny-hderive = "0.3.0"
 segment = { version = "0.1.2", optional = true }
 mac_address = { version = "1.1.2", optional = true }
 tower-lsp = { version = "0.18.0", optional = true }

components/clarinet-cli/src/frontend/cli.rs

@@ -25,7 +25,12 @@ use clarinet_deployments::{
 use clarinet_files::{
     get_manifest_location, FileLocation, ProjectManifest, ProjectManifestFile, RequirementConfig,
 };
+use clarinet_utils::get_bip39_seed_from_mnemonic;
 use clarity_repl::analysis::call_checker::ContractAnalysis;
+use clarity_repl::clarity::address::AddressHashMode;
+use clarity_repl::clarity::stacks_common::types::chainstate::StacksAddress;
+use clarity_repl::clarity::util::hash::bytes_to_hex;
+use clarity_repl::clarity::util::secp256k1::Secp256k1PublicKey;
 use clarity_repl::clarity::vm::analysis::AnalysisDatabase;
 use clarity_repl::clarity::vm::costs::LimitedCostTracker;
 use clarity_repl::clarity::vm::diagnostic::{Diagnostic, Level};
@@ -34,13 +39,15 @@ use clarity_repl::clarity::ClarityVersion;
 use clarity_repl::repl::diagnostic::{output_code, output_diagnostic};
 use clarity_repl::repl::{ClarityCodeSource, ClarityContract, ContractDeployer, DEFAULT_EPOCH};
 use clarity_repl::{analysis, repl, Terminal};
+use libsecp256k1::{PublicKey, SecretKey};
 use stacks_network::chainhook_event_observer::chainhooks::types::ChainhookSpecification;
 use stacks_network::chainhook_event_observer::utils::Context;
 use stacks_network::{self, DevnetOrchestrator};
 use std::collections::HashMap;
 use std::fs::{self, File};
 use std::io::prelude::*;
 use std::{env, process};
+use tiny_hderive::bip32::ExtendedPrivKey;
 
 use clap::{IntoApp, Parser, Subcommand};
 use clap_generate::{Generator, Shell};
@@ -1302,7 +1309,11 @@ pub fn main() {
                         }
                     }
                     .issuer;
-
+                let subnet_leader = compute_stx_address(
+                    &devnet_config.subnet_leader_mnemonic,
+                    &devnet_config.subnet_leader_derivation_path,
+                    &StacksNetwork::Devnet,
+                );
                 let _ = fs::create_dir(format!("{}/requirements", cache_location.display()));
 
                 let ctx = Context {
@@ -1314,6 +1325,7 @@ pub fn main() {
                     &ctx,
                     cache_location,
                     &subnet_deployer,
+                    &subnet_leader.into(),
                 )) {
                     Ok(_) => {}
                     Err(e) => {
@@ -1951,6 +1963,40 @@ impl DiagnosticsDigest {
     }
 }
 
+pub fn compute_stx_address(
+    mnemonic: &str,
+    derivation_path: &str,
+    network: &StacksNetwork,
+) -> StacksAddress {
+    let bip39_seed = match get_bip39_seed_from_mnemonic(&mnemonic, "") {
+        Ok(bip39_seed) => bip39_seed,
+        Err(_) => panic!(),
+    };
+
+    let ext = ExtendedPrivKey::derive(&bip39_seed[..], derivation_path).unwrap();
+
+    let secret_key = SecretKey::parse_slice(&ext.secret()).unwrap();
+
+    // Enforce a 33 bytes secret key format, expected by Stacks
+    let mut secret_key_bytes = secret_key.serialize().to_vec();
+    secret_key_bytes.push(1);
+    let miner_secret_key_hex = bytes_to_hex(&secret_key_bytes);
+
+    let public_key = PublicKey::from_secret_key(&secret_key);
+    let pub_key = Secp256k1PublicKey::from_slice(&public_key.serialize_compressed()).unwrap();
+    let version = clarity_repl::clarity::address::C32_ADDRESS_VERSION_TESTNET_SINGLESIG;
+
+    let stx_address = StacksAddress::from_public_keys(
+        version,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![pub_key],
+    )
+    .unwrap();
+
+    stx_address
+}
+
 fn display_separator() {
     println!("{}", yellow!("----------------------------"));
 }

components/clarinet-files/src/network_manifest.rs

@@ -690,7 +690,7 @@ impl NetworkManifest {
             let subnet_events_ingestion_port =
                 devnet_config.subnet_events_ingestion_port.unwrap_or(30445);
 
-            let mut stacks_node_events_observers = devnet_config
+            let stacks_node_events_observers = devnet_config
                 .stacks_node_events_observers
                 .take()
                 .unwrap_or(vec![]);

components/stacks-network/src/orchestrator.rs

@@ -27,10 +27,11 @@ use reqwest::RequestBuilder;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::fs::{self, File};
-use std::io::{Cursor, Write};
+use std::io::{Cursor, Read, Write};
 use std::path::PathBuf;
 use std::sync::mpsc::{Receiver, Sender};
 use std::time::Duration;
+use tar::EntryType;
 
 #[derive(Debug)]
 pub struct DevnetOrchestrator {
@@ -1399,6 +1400,7 @@ events_keys = ["*"]
         ctx: &Context,
         cache_dir: PathBuf,
         deployer: &StandardPrincipalData,
+        miner: &StandardPrincipalData,
     ) -> Result<(), String> {
         let (docker, devnet_config) = match (&self.docker_client, &self.network_config) {
             (Some(ref docker), Some(ref network_config)) => match network_config.devnet {
@@ -1478,9 +1480,21 @@ events_keys = ["*"]
             };
             let contract_path = prefix.join(filename_str);
 
-            entry
-                .unpack(contract_path.clone())
-                .map_err(|e| e.to_string())?;
+            // Write the contract file, replacing the miner address
+            if entry.header().entry_type() == EntryType::Regular {
+                let mut buffer = String::new();
+                entry
+                    .read_to_string(&mut buffer)
+                    .map_err(|e| e.to_string())?;
+                let contract_content = buffer.replace(
+                    "(define-data-var miner principal tx-sender)",
+                    &format!("(define-data-var miner principal '{})", &miner),
+                );
+                let contract_file = FileLocation::from_path(contract_path.clone());
+                contract_file
+                    .write_content(contract_content.as_bytes())
+                    .map_err(|e| e.to_string())?;
+            }
 
             // Write the metadata file
             let metadata_path = contract_path.with_extension("json");