First commit.

Author: bhat

Cargo.lock

@@ -0,0 +1,25 @@
+[package]
+name = "duino-miner"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_yaml = "0.8"
+
+sha-1 = "0.9"
+data-encoding = "2.3"
+rand = "0.8"
+parity-wordlist = "1"
+
+tokio = { version = "1.9", features = ["full"] }
+futures = "0.3"
+
+clap = "3.0.0-beta.2"
+thiserror = "1.0"
+
+[profile.release]
+opt-level = 'z'
+lto = true
+codegen-units = 1
+panic = 'abort'

Cargo.toml

@@ -0,0 +1,27 @@
+# duino-miner
+
+A multiplexed CPU miner for Duinocoin (duino-coin),
+*if you know what I am talking about*.
+
+This high-performance miner is implemented in asynchronous Rust, from scratch.
+This makes it several times faster than the official miner,
+and highly efficient even on non-conventional mining hardwares
+such as a Raspberry Pi. (Again, if you know what I am talking about.)
+
+To build this project, execute
+
+```sh
+cargo build --release
+```
+
+To generate a config file for the miner, execute
+
+```sh
+duino-miner generate -u my_username --device-type=AVR --firmware="Official AVR Miner v2.6" --device-name-prefix "avr-" --target-rate 182
+```
+
+To run the miner from your config file, execute
+
+```sh
+duino-miner run
+```

README.md

@@ -0,0 +1,56 @@
+use duino_miner::error::MinerError;
+
+use tokio::net::TcpStream;
+
+use rand::{thread_rng, Rng};
+use rand::distributions::Alphanumeric;
+
+use clap::{AppSettings, Clap};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+
+#[derive(Clap)]
+#[clap(version = "0.0", author = "Black H. <[email protected]>")]
+#[clap(setting = AppSettings::ColoredHelp)]
+struct Opts {
+    #[clap(short, long, default_value = "51.15.127.80")]
+    host: String,
+    #[clap(short, long, default_value = "2811")]
+    port: u16,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let opts: Opts = Opts::parse();
+
+    let mut username = parity_wordlist::random_phrase(2);
+    username.retain(|c| !c.is_whitespace());
+    let password: String = thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(16)
+        .map(char::from)
+        .collect();
+
+    let mut stream = TcpStream::connect(
+        format!("{}:{}", opts.host, opts.port)).await.map_err(|_| MinerError::Connection)?;
+
+    println!("Connected to pool {}:{}", opts.host, opts.port);
+
+    let mut cmd_in: [u8; 200] = [0; 200];
+
+    let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+    println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
+
+    let cmd_job = format!("REGI,{},{},{}@gmail.com\n", username, password, username);
+    stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
+    let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+    let reg_status = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?;
+
+    if reg_status != "OK" {
+        println!("register failed: {}", reg_status);
+    } else {
+        println!("registered {} with {}", username, password);
+    }
+
+    Ok(())
+}

src/bin/register.rs

@@ -0,0 +1,85 @@
+use duino_miner::error::MinerError;
+
+use serde::{Serialize, Deserialize};
+
+use tokio::net::TcpStream;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+use clap::{AppSettings, Clap};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct Config {
+    host: String,
+    port: u16,
+
+    main_account: String,
+    accounts: Vec<Account>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct Account {
+    username: String,
+    password: String,
+}
+
+#[derive(Clap)]
+#[clap(version = "0.0", author = "Black H. <[email protected]>")]
+#[clap(setting = AppSettings::ColoredHelp)]
+struct Opts {
+    #[clap(short, long, default_value = "transfer.yaml")]
+    config_file: String,
+    #[clap(short)]
+    force: bool,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let opts: Opts = Opts::parse();
+
+    let c_serial = tokio::fs::read_to_string(opts.config_file).await?;
+    let c: Config = serde_yaml::from_str(c_serial.as_str())?;
+
+    for account in c.accounts {
+        if account.username == c.main_account {
+            continue;
+        }
+
+        let mut stream = TcpStream::connect(
+            format!("{}:{}", c.host, c.port)).await.map_err(|_| MinerError::Connection)?;
+
+        println!("Connected to pool {}:{}", c.host, c.port);
+
+        let mut cmd_in: [u8; 200] = [0; 200];
+
+        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+        println!("version: {}", std::str::from_utf8(&cmd_in[..n])?);
+
+        let cmd_job = format!("LOGI,{},{}\n", account.username, account.password);
+        stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
+        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+        let login_status = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?;
+
+        if login_status != "OK" {
+            println!("{} login failed", account.username);
+            continue;
+        }
+
+        stream.write("BALA".as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
+        let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+        let balance: f32 = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?.parse()?;
+        println!("account {} has balance {}", account.username, balance);
+
+        let balance = balance as u32;
+
+        if balance > 100 || opts.force {
+            let cmd_job = format!("SEND,-,{},{}\n", c.main_account, balance);
+            stream.write(cmd_job.as_bytes()).await.map_err(|_| MinerError::SendCommand)?;
+            let n = stream.read(&mut cmd_in).await.map_err(|_| MinerError::RecvCommand)?;
+            let transfer_status = std::str::from_utf8(&cmd_in[..n]).map_err(|_| MinerError::InvalidUTF8)?;
+
+            println!("transfer of {} coins to {} exited with status {}", balance, c.main_account, transfer_status);
+        }
+    }
+
+    Ok(())
+}

src/bin/transfer.rs

@@ -0,0 +1,15 @@
+#[derive(thiserror::Error, Debug)]
+pub enum MinerError {
+    #[error("Could not establish a connection")]
+    Connection,
+    #[error("Could not send command")]
+    SendCommand,
+    #[error("Could not receive command")]
+    RecvCommand,
+    #[error("Received invalid UTF-8")]
+    InvalidUTF8,
+    #[error("Received malformed job: `{0}`")]
+    MalformedJob(String),
+    #[error("unknown error")]
+    Unknown,
+}

src/error.rs

@@ -0,0 +1 @@
+pub mod error;