one commit contains all impl

vanity-worker/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "vanity-worker"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "4", features = ["derive", "env", "cargo"] }
+
+libvanity = {path = "../libvanity"}
+
+x25519-dalek = "1.2.0"
+rand_core = {version = "0.5.1", features = ["getrandom"]}
+
+tonic = "0.8"
+tokio = {version = "1", features = ["full"]}
+tokio-stream = { version = "0.1.11", features = ["net"] }
+
+base64 = "0.13.0"
+regex = "1.6.0"
+tracing-subscriber = { version = "0.3.16", features = ["json"] }
+tracing = { version = "0.1.37", features = ["log"] }
+futures = "0.3.25"

vanity-worker/src/main.rs

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+
+use rand_core::OsRng;
+use tokio::sync::RwLock;
+use x25519_dalek::{PublicKey, StaticSecret};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client =
+        libvanity::worker::worker_client::WorkerClient::connect("grpc://127.0.0.1:8877").await?;
+
+    let (tx, rx) = tokio::sync::mpsc::channel(128);
+
+    let requests = std::sync::Arc::new(RwLock::new(HashMap::new()));
+
+    let mut another = client.clone();
+    let requests_writer = requests.clone();
+    let pull_thread = tokio::spawn(async move {
+        use libvanity::worker::request::NewOrDone::{Done, New};
+
+        let mut tasks = another
+            .poll(tokio_stream::wrappers::ReceiverStream::new(rx))
+            .await
+            .expect("msg")
+            .into_inner();
+        let requests = requests_writer;
+        while let Some(msg) = tasks.message().await.unwrap() {
+            if let Some(new_or_done) = msg.new_or_done {
+                match new_or_done {
+                    New(request) => {
+                        let mut writer = requests.write().await;
+                        writer.insert(request.id, request.pattern);
+                    }
+                    Done(response) => {
+                        let mut writer = requests.write().await;
+                        writer.remove(&response);
+                    }
+                }
+            }
+        }
+    });
+
+    let worker_threads = Vec::from_iter(1..10).into_iter().map(|id| {
+        let requests = requests.clone();
+        let tx = tx.clone();
+        let _id = id.clone();
+        tokio::spawn(async move {
+            loop {
+                let requests = requests.read().await.clone();
+                if requests.is_empty() {
+                    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+                    continue;
+                }
+
+                let private = StaticSecret::new(&mut OsRng);
+                let public = PublicKey::from(&private);
+
+                for (id, pattern) in requests.iter() {
+                    let matcher = regex::Regex::new(pattern).unwrap();
+                    let matcher = matcher.clone();
+                    let public_b64 = base64::encode(public.as_bytes());
+                    if matcher.is_match(&public_b64) {
+                        let mut result = libvanity::worker::Result::default();
+                        result.id = id.clone();
+                        result.result = base64::encode(private.to_bytes());
+                        tx.send(result).await.expect("no error");
+                    }
+                }
+            }
+        })
+    });
+
+    let _ = tokio::join!(futures::future::join_all(worker_threads), pull_thread);
+
+    Ok(())
+}