Rust GBT proof of concept

backend/rust-gbt/src/lib.rs

@@ -0,0 +1,75 @@
+use neon::{prelude::*, types::buffer::TypedArray};
+
+mod gbt;
+mod thread_transaction;
+mod audit_transaction;
+use thread_transaction::{ThreadTransaction};
+
+fn go(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+  let mempool_arg = cx.argument::<JsArrayBuffer>(0)?.root(&mut cx).into_inner(&mut cx);
+  let callback = cx.argument::<JsFunction>(1)?.root(&mut cx);
+  let channel = cx.channel();
+
+  let buffer = mempool_arg.as_slice(&mut cx);
+  let thread_transactions = ThreadTransaction::batch_from_buffer(buffer);
+
+  std::thread::spawn(move || {
+    let (blocks, rates, clusters) = gbt::gbt(thread_transactions);
+
+    channel.send(move |mut cx| {
+      let result = JsObject::new(&mut cx);
+
+      let js_blocks = JsArray::new(&mut cx, blocks.len() as u32);
+      for (i, block) in blocks.iter().enumerate() {
+        let inner = JsArray::new(&mut cx, block.len() as u32);
+        for (j, uid) in block.iter().enumerate() {
+          let v = cx.number(*uid);
+          inner.set(&mut cx, j as u32, v)?;
+        }
+        js_blocks.set(&mut cx, i as u32, inner)?;
+      }
+
+      let js_clusters = JsArray::new(&mut cx, clusters.len() as u32);
+      for (i, cluster) in clusters.iter().enumerate() {
+        let inner = JsArray::new(&mut cx, cluster.len() as u32);
+        for (j, uid) in cluster.iter().enumerate() {
+          let v = cx.number(*uid);
+          inner.set(&mut cx, j as u32, v)?;
+        }
+        js_clusters.set(&mut cx, i as u32, inner)?;
+      }
+
+      let js_rates = JsArray::new(&mut cx, rates.len() as u32);
+      for (i, (uid, rate)) in rates.iter().enumerate() {
+        let inner = JsArray::new(&mut cx, 2);
+        let js_uid = cx.number(*uid);
+        let js_rate = cx.number(*rate);
+        inner.set(&mut cx, 0, js_uid)?;
+        inner.set(&mut cx, 1, js_rate)?;
+        js_rates.set(&mut cx, i as u32, inner)?;
+      }
+
+      result.set(&mut cx, "blocks", js_blocks)?;
+      result.set(&mut cx, "clusters", js_clusters)?;
+      result.set(&mut cx, "rates", js_rates)?;
+
+      let callback = callback.into_inner(&mut cx);
+      let this = cx.undefined();
+      let args = vec![
+        result.upcast()
+      ];
+
+      callback.call(&mut cx, this, args)?;
+
+      Ok(())
+    });
+  });
+
+  Ok(cx.undefined())
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+  cx.export_function("go", go)?;
+  Ok(())
+}