chore: polishing devnet js interface

Author: lgalabru

node-bindings/lib/index.js

@@ -5,7 +5,15 @@ const { stacksDevnetNew, stacksDevnetStart, stacksDevnetStop, stacksDevnetWaitFo
 class StacksDevnet {
 
     constructor(setup) {
-        this.handle = stacksDevnetNew(setup.config.manifestPath, setup.logger);
+        let manifestPath = setup.manifestPath;
+        var logs = setup.logs;
+        logs ||= false;
+        var accounts = setup.settings.accounts;
+        accounts ||= [];
+        var devnet = setup.settings.devnet;
+        devnet ||= {};
+        console.log(manifestPath);
+        this.handle = stacksDevnetNew(manifestPath, logs, accounts, devnet);
     }
 
     start() {

node-bindings/lib/test.js

@@ -1,10 +1,36 @@
 const StacksDevnet = require("./index");
 
+// const devnet = new StacksDevnet({
+//     config: {
+//         manifestPath: "/Users/ludovic/Coding/clarinet/clarinet-cli/examples/counter/Clarinet.toml",
+//     },
+//     logger: (msg) => console.log(msg)
+// });
+
 const devnet = new StacksDevnet({
-    config: {
-        manifestPath: "/Users/ludovic/Coding/clarinet/clarinet-cli/examples/counter/Clarinet.toml",
-    },
-    logger: (msg) => console.log(msg)
+    manifestPath: "/Users/ludovic/Coding/clarinet/clarinet-cli/examples/counter/Clarinet.toml",
+    logs: true,
+    settings: {
+        accounts: [
+            {
+                id: "wallet_9",
+                mnemonic: "sell invite acquire kitten bamboo drastic jelly vivid peace spawn twice guilt pave pen trash pretty park cube fragile unaware remain midnight betray rebuild",
+                balance: 100_000_000,
+            }
+        ],
+        devnet: {
+            orchestrator_port: 8000,
+            pox_stacking_orders: [
+                {
+                    start_at_cycle: 3,
+                    duration: 12,
+                    wallet: "wallet_1",
+                    slots: 2,
+                    btc_address: "mr1iPkD9N3RJZZxXRk7xF9d36gffa6exNC"
+                }
+            ]    
+        }
+    }
 });
 
 devnet.start();

node-bindings/src/lib.rs

@@ -1,7 +1,9 @@
 use clarinet_lib::integrate::{self, BlockData, DevnetEvent, DevnetOrchestrator};
-use clarinet_lib::types::DevnetConfigFile;
+use clarinet_lib::types::{AccountConfig, DevnetConfigFile, PoxStackingOrder, DEFAULT_DERIVATION_PATH, compute_addresses};
+use clarinet_lib::bip39::{Language, Mnemonic};
 use neon::prelude::*;
 use core::panic;
+use std::collections::BTreeMap;
 use std::path::PathBuf;
 use std::sync::mpsc;
 use std::thread;
@@ -23,7 +25,7 @@ enum DevnetCommand {
 impl Finalize for StacksDevnet {}
 
 impl StacksDevnet {
-    fn new<'a, C>(cx: &mut C, manifest_path: String) -> Self
+    fn new<'a, C>(cx: &mut C, manifest_path: String, logs_enabled: bool, _accounts: BTreeMap<String, AccountConfig>, devnet_overrides: DevnetConfigFile) -> Self
     where
         C: Context<'a>,
     {
@@ -37,7 +39,6 @@ impl StacksDevnet {
 
         thread::spawn(move || {
             let manifest_path = get_manifest_path_or_exit(Some(manifest_path.into()));
-            let devnet_overrides = DevnetConfigFile::default();
             let devnet = DevnetOrchestrator::new(manifest_path, Some(devnet_overrides));
 
             if let Ok(DevnetCommand::Start(callback)) = rx.recv() {
@@ -81,7 +82,9 @@ impl StacksDevnet {
                             stacks_block_tx.send(block.clone()).expect("Unable to transmit stacks block");
                         }
                         DevnetEvent::Log(log) => {
-                            println!("{:?}", log);
+                            if logs_enabled {
+                                println!("{:?}", log);
+                            }
                         }
                         _ => {}
                     }
@@ -111,8 +114,248 @@ impl StacksDevnet {
 impl StacksDevnet {
     fn js_new(mut cx: FunctionContext) -> JsResult<JsBox<StacksDevnet>> {
         let manifest_path = cx.argument::<JsString>(0)?.value(&mut cx);
+        
+        let logs_enabled = cx.argument::<JsBoolean>(1)?.value(&mut cx);
+
+        let accounts = cx.argument::<JsArray>(2)?.to_vec(&mut cx)?;
+
+        let devnet_settings = cx.argument::<JsObject>(3)?;
+
+        let mut genesis_accounts = BTreeMap::new();
+
+        for account in accounts.iter() {
+            let account_settings = account.downcast_or_throw::<JsObject, _>(&mut cx)?;
+            let id = account_settings
+                .get(&mut cx, "id")?
+                .downcast_or_throw::<JsString, _>(&mut cx)?
+                .value(&mut cx);
+
+            let words = account_settings
+                .get(&mut cx, "mnemonic")?
+                .downcast_or_throw::<JsString, _>(&mut cx)?
+                .value(&mut cx);
+
+            let mnemonic = Mnemonic::parse_in_normalized(Language::English, &words)
+                .unwrap()
+                .to_string();
+
+            let balance = match account_settings.get(&mut cx, "balance")?.downcast::<JsNumber, _>(&mut cx) {
+                Ok(res) => res.value(&mut cx),
+                _ => 0.0,
+            };
+    
+            let is_mainnet = match account_settings.get(&mut cx, "is_mainnet")?.downcast::<JsBoolean, _>(&mut cx) {
+                Ok(res) => res.value(&mut cx),
+                _ => false,
+            };
+
+            let derivation = match account_settings.get(&mut cx, "derivation")?.downcast::<JsString, _>(&mut cx) {
+                Ok(res) => res.value(&mut cx),
+                _ => DEFAULT_DERIVATION_PATH.to_string(),
+            };
+
+            let (address, _, _) =
+                compute_addresses(&mnemonic, &derivation, is_mainnet);
+
+            let account = AccountConfig {
+                mnemonic,
+                address,
+                derivation,
+                is_mainnet,
+                balance: balance as u64,
+            };
+            genesis_accounts.insert(id, account);            
+        }
+
+        let mut overrides = DevnetConfigFile::default();
+
+        if let Ok(res) = devnet_settings.get(&mut cx, "orchestrator_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.orchestrator_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_node_p2p_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.bitcoin_node_p2p_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_node_rpc_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.bitcoin_node_rpc_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_node_p2p_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.stacks_node_p2p_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_node_rpc_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.stacks_node_rpc_port = Some(res.value(&mut cx) as u16);
+        }
+                
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_api_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.stacks_api_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_api_events_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.stacks_api_events_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_explorer_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.bitcoin_explorer_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_explorer_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.stacks_explorer_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_controller_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.bitcoin_controller_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_node_username")?.downcast::<JsString, _>(&mut cx) {
+            overrides.bitcoin_node_username = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_node_password")?.downcast::<JsString, _>(&mut cx) {
+            overrides.bitcoin_node_password = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "miner_mnemonic")?.downcast::<JsString, _>(&mut cx) {
+            overrides.miner_mnemonic = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "miner_derivation_path")?.downcast::<JsString, _>(&mut cx) {
+            overrides.miner_derivation_path = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_controller_block_time")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.bitcoin_controller_block_time = Some(res.value(&mut cx) as u32);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "working_dir")?.downcast::<JsString, _>(&mut cx) {
+            overrides.working_dir = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "postgres_port")?.downcast::<JsNumber, _>(&mut cx) {
+            overrides.postgres_port = Some(res.value(&mut cx) as u16);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "postgres_username")?.downcast::<JsString, _>(&mut cx) {
+            overrides.postgres_username = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "postgres_password")?.downcast::<JsString, _>(&mut cx) {
+            overrides.postgres_password = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "postgres_database")?.downcast::<JsString, _>(&mut cx) {
+            overrides.postgres_database = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_node_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.bitcoin_node_image_url = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "bitcoin_explorer_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.bitcoin_explorer_image_url = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_node_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.stacks_node_image_url = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_api_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.stacks_api_image_url = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_explorer_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.stacks_explorer_image_url = Some(res.value(&mut cx));
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "postgres_image_url")?.downcast::<JsString, _>(&mut cx) {
+            overrides.postgres_image_url = Some(res.value(&mut cx));
+        }
+        
+        // Disable scripts
+        overrides.execute_script = Some(vec![]);
+
+        // Disable bitcoin_explorer, stacks_explorer and stacks_api by default:
+        if let Ok(res) = devnet_settings.get(&mut cx, "disable_bitcoin_explorer")?.downcast::<JsBoolean, _>(&mut cx) {
+            overrides.disable_bitcoin_explorer = Some(res.value(&mut cx));
+        } else {
+            overrides.disable_bitcoin_explorer = Some(true);
+        }
+        
+        if let Ok(res) = devnet_settings.get(&mut cx, "disable_stacks_explorer")?.downcast::<JsBoolean, _>(&mut cx) {
+            overrides.disable_stacks_explorer = Some(res.value(&mut cx));
+        } else {
+            overrides.disable_stacks_explorer = Some(true);
+        }
+
+        if let Ok(res) = devnet_settings.get(&mut cx, "disable_stacks_api")?.downcast::<JsBoolean, _>(&mut cx) {
+            overrides.disable_stacks_api = Some(res.value(&mut cx));
+        } else {
+            overrides.disable_stacks_api = Some(true);
+        }
+        
+        // Retrieve stacks_node_events_observers
+        if let Ok(res) = devnet_settings.get(&mut cx, "stacks_node_events_observers")?.downcast::<JsArray, _>(&mut cx) {
+            let raw_events_observers = res.to_vec(&mut cx)?;
+            let mut events_observers = vec![];
+
+            for raw_events_observer in raw_events_observers.iter() {
+                let observer_url = raw_events_observer
+                    .downcast_or_throw::<JsString, _>(&mut cx)?
+                    .value(&mut cx);
+                events_observers.push(observer_url);
+            }
+            overrides.stacks_node_events_observers = Some(events_observers);
+        }
+
+        // Retrieve stacking_orders
+        if let Ok(res) = devnet_settings.get(&mut cx, "pox_stacking_orders")?.downcast::<JsArray, _>(&mut cx) {
+            let raw_stacking_orders = res.to_vec(&mut cx)?;
+            let mut stacking_orders = vec![];
+
+            for raw_stacking_order in raw_stacking_orders.iter() {
+                let order_settings = raw_stacking_order.downcast_or_throw::<JsObject, _>(&mut cx)?;
+
+                let start_at_cycle = order_settings
+                    .get(&mut cx, "start_at_cycle")?
+                    .downcast_or_throw::<JsNumber, _>(&mut cx)?
+                    .value(&mut cx) as u32;
+
+                let duration = order_settings
+                    .get(&mut cx, "duration")?
+                    .downcast_or_throw::<JsNumber, _>(&mut cx)?
+                    .value(&mut cx) as u32;
+
+                let wallet = order_settings
+                    .get(&mut cx, "wallet")?
+                    .downcast_or_throw::<JsString, _>(&mut cx)?
+                    .value(&mut cx);
+
+                let slots = order_settings
+                    .get(&mut cx, "slots")?
+                    .downcast_or_throw::<JsNumber, _>(&mut cx)?
+                    .value(&mut cx) as u64;
+
+                let btc_address = order_settings
+                    .get(&mut cx, "btc_address")?
+                    .downcast_or_throw::<JsString, _>(&mut cx)?
+                    .value(&mut cx);
+                
+                stacking_orders.push(PoxStackingOrder {
+                    start_at_cycle,
+                    duration,
+                    wallet,
+                    slots,
+                    btc_address,
+                });
+            }
+            overrides.pox_stacking_orders = Some(stacking_orders);
+        }
 
-        let devnet = StacksDevnet::new(&mut cx, manifest_path);
+        println!("{:?}", overrides);
+        
+        let devnet = StacksDevnet::new(&mut cx, manifest_path, logs_enabled, genesis_accounts, overrides);
         Ok(cx.boxed(devnet))
     }
 

src/frontend/cli.rs

@@ -403,7 +403,7 @@ pub fn main() {
         Command::Integrate(cmd) => {
             let manifest_path = get_manifest_path_or_exit(cmd.manifest_path);
             let devnet = DevnetOrchestrator::new(manifest_path, None);
-            integrate::run_devnet(devnet, None, None, !cmd.no_dashboard);
+            integrate::run_devnet(devnet, None, !cmd.no_dashboard);
             if hints_enabled {
                 display_deploy_hint();
             }