chore: polishing JS api, plumbing events

Author: lgalabru

node-bindings/lib/index.js

@@ -1,16 +1,16 @@
 "use strict";
 
 const { promisify } = require("util");
-const { stackDevnetNew, stackDevnetStart, stackDevnetOnStacksBlock, stackDevnetOnBitcoinBlock, stackDevnetTerminate } = require('../native/index.node');
+const { stacksDevnetNew, stacksDevnetStart, stacksDevnetStop, stacksDevnetWaitForStacksBlock, stacksDevnetWaitForBitcoinBlock } = require('../native/index.node');
 
 class StacksDevnet {
 
     constructor() {
-        this.handle = stackDevnetNew();
+        this.handle = stacksDevnetNew();
     }
 
     start() {
-        return stackDevnetStart.call(this.handle);
+        return stacksDevnetStart.call(this.handle);
     }
 
     waitForBootCompletion(callback) {
@@ -20,18 +20,18 @@ class StacksDevnet {
     }
 
     waitForStacksBlock(callback) {
-        return stackDevnetOnStacksBlock.call(this.handle, callback);
+        return stacksDevnetWaitForStacksBlock.call(this.handle, callback);
     }
 
     waitForBitcoinBlock(callback) {
-        return stackDevnetOnBitcoinBlock.call(this.handle, callback);
+        return stacksDevnetWaitForBitcoinBlock.call(this.handle, callback);
     }
 
     waitForAttachment(callback) {
     }
 
     stop() {
-        stackDevnetTerminate.call(this.handle);
+        stacksDevnetStop.call(this.handle);
     }
 }
 

node-bindings/src/lib.rs

@@ -107,7 +107,7 @@ impl StacksDevnet {
         Ok(cx.undefined())
     }
 
-    fn js_terminate(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    fn js_stop(mut cx: FunctionContext) -> JsResult<JsUndefined> {
         cx.this()
             .downcast_or_throw::<JsBox<StacksDevnet>, _>(&mut cx)?
             .stop(None)
@@ -127,15 +127,18 @@ impl StacksDevnet {
 
         while let Ok(message) = devnet.devnet_event_rx.recv() {
             match message {
-                _ => {
-                    println!("Hello world :)");
+                NodeObserverEvent::NewStacksBlock => {
+                    println!("New stacks block");
                     let args: Vec<Handle<JsValue>> =
                         vec![cx.null().upcast(), cx.number(1 as f64).upcast()];
                     let _res = callback.call(&mut cx, devnet, args)?;
                     // let expected = cx.boolean(true);
                     // if res.strict_equals(&mut cx, expected) {
                     //     break;
                     // }
+                    break;
+                }
+                _ => {
                 }
             }
         }
@@ -153,24 +156,18 @@ impl StacksDevnet {
 
         while let Ok(message) = devnet.devnet_event_rx.recv() {
             match message {
-                _ => {
-                    println!("Hello world :)");
-                    // let this = cx.undefined();
+                NodeObserverEvent::NewBitcoinBlock => {
+                    println!("New bitcoin block");
                     let args: Vec<Handle<JsValue>> =
                         vec![cx.null().upcast(), cx.number(1 as f64).upcast()];
                     let _res = callback.call(&mut cx, devnet, args)?;
-                    break;
-                    //     // callback.call(&mut cx, this, vec![])?;
-
-                    // }
-                    // DevnetMessage::Callback(f) => {
-                    //     // The connection and channel are owned by the thread, but _lent_ to
-                    //     // the callback. The callback has exclusive access to the connection
-                    //     // for the duration of the callback.
-                    //     f(&channel);
+                    // let expected = cx.boolean(true);
+                    // if res.strict_equals(&mut cx, expected) {
+                    //     break;
                     // }
-                    // // Immediately close the connection, even if there are pending messages
-                    // DevnetMessage::Close => break,
+                    break;
+                }
+                _ => {
                 }
             }
         }
@@ -181,14 +178,14 @@ impl StacksDevnet {
 
 #[neon::main]
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
-    cx.export_function("stackDevnetNew", StacksDevnet::js_new)?;
-    cx.export_function("stackDevnetStart", StacksDevnet::js_start)?;
-    cx.export_function("stackDevnetOnStacksBlock", StacksDevnet::js_on_stacks_block)?;
+    cx.export_function("stacksDevnetNew", StacksDevnet::js_new)?;
+    cx.export_function("stacksDevnetStart", StacksDevnet::js_start)?;
+    cx.export_function("stacksDevnetStop", StacksDevnet::js_stop)?;
+    cx.export_function("stacksDevnetWaitForStacksBlock", StacksDevnet::js_on_stacks_block)?;
     cx.export_function(
-        "stackDevnetOnBitcoinBlock",
+        "stacksDevnetWaitForBitcoinBlock",
         StacksDevnet::js_on_bitcoin_block,
     )?;
-    cx.export_function("stackDevnetTerminate", StacksDevnet::js_terminate)?;
     Ok(())
 }
 

src/integrate/events_observer.rs

@@ -279,7 +279,7 @@ pub fn handle_new_burn_block(
     match node_event_tx.lock() {
         Ok(tx) => {
             if let Some(ref tx) = *tx {
-                tx.send(NodeObserverEvent::NewBlock)
+                tx.send(NodeObserverEvent::NewBitcoinBlock)
                     .expect("Unable to broadcast event");
             }
         }
@@ -297,8 +297,18 @@ pub fn handle_new_block(
     config: &State<Arc<RwLock<EventObserverConfig>>>,
     devnet_events_tx: &State<Arc<Mutex<Sender<DevnetEvent>>>>,
     new_block: Json<NewBlock>,
-    _node_event_tx: &State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
+    node_event_tx: &State<Arc<Mutex<Option<Sender<NodeObserverEvent>>>>>,
 ) -> Json<Value> {
+    match node_event_tx.lock() {
+        Ok(tx) => {
+            if let Some(ref tx) = *tx {
+                tx.send(NodeObserverEvent::NewStacksBlock)
+                    .expect("Unable to broadcast event");
+            }
+        }
+        _ => {}
+    };
+
     let devnet_events_tx = devnet_events_tx.inner();
     let config = config.inner();
 

src/integrate/mod.rs

@@ -15,7 +15,8 @@ pub use orchestrator::DevnetOrchestrator;
 use self::events_observer::EventObserverConfig;
 
 pub enum NodeObserverEvent {
-    NewBlock,
+    NewStacksBlock,
+    NewBitcoinBlock,
 }
 
 pub fn run_devnet(