Renamed binaries to make things a bit more general

crdt-node/.gitignore

@@ -0,0 +1 @@
+/target

crdt-node/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "crdt-node"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.86"
+async-trait = "0.1.52"
+bdk = { version = "0.29.0", default-feature = false, features = ["all-keys"] }
+bdk_esplora = "0.15.0"
+bdk_sqlite = "0.2.0"
+bdk_wallet = { version = "1.0.0-alpha.13", features = ["all-keys"] }
+bft-json-crdt = { path = "../crates/bft-json-crdt" }
+bft-crdt-derive = { path = "../crates/bft-json-crdt/bft-crdt-derive" }
+bitcoin = { version = "0.32.2", features = ["rand"] }
+clap = { version = "4.5.4", features = ["derive"] }
+dirs = "5.0.1"
+electrum-client = "0.20"
+ezsockets = { version = "*", features = ["client"] }
+fastcrypto = "0.1.8"
+indexmap = { version = "2.2.6", features = ["serde"] }
+reqwest = { version = "*", features = ["blocking"] }
+# serde_cbor = "0.11.2" # move to this once we need to pack things in CBOR
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.117"
+sha256 = "1.5.0"
+tokio = { version = "1.37.0", features = ["full"] }
+toml = "0.8.14"
+tracing = "0.1.32"
+# tracing-subscriber = "0.3.9"
+
+
+[dev-dependencies]
+uuid = { version = "1.8.0", features = ["v4"] }
+
+[features]
+default = ["bft", "logging-list", "logging-json"]
+logging-list = ["logging-base"]
+logging-json = ["logging-base"]
+logging-base = []
+bft = []

crdt-node/src/bft_crdt/keys.rs

@@ -0,0 +1,27 @@
+use std::{
+    fs::{self, File},
+    io::Write,
+    path::PathBuf,
+};
+
+use bft_json_crdt::keypair::{make_keypair, Ed25519KeyPair};
+use fastcrypto::traits::EncodeDecodeBase64;
+
+/// Writes a new Ed25519 keypair to the file at key_path.
+pub(crate) fn write(key_path: &PathBuf) -> Result<(), std::io::Error> {
+    let keys = make_keypair();
+
+    let mut file = File::create(key_path)?;
+    let out = keys.encode_base64();
+    file.write(out.as_bytes())?;
+    Ok(())
+}
+
+pub(crate) fn load_from_file(side_dir: &PathBuf) -> Ed25519KeyPair {
+    let key_path = crate::utils::side_paths(side_dir.clone()).0;
+
+    let data = fs::read_to_string(key_path).expect("couldn't read bft-bft-crdt key file");
+    println!("data: {:?}", data);
+
+    Ed25519KeyPair::decode_base64(&data).expect("couldn't load keypair from file")
+}

crdt-node/src/bft_crdt/mod.rs

@@ -0,0 +1,31 @@
+use bft_crdt_derive::add_crdt_fields;
+use bft_json_crdt::{
+    json_crdt::{CrdtNode, IntoCrdtNode},
+    list_crdt::ListCrdt,
+};
+use serde::{Deserialize, Serialize};
+
+pub mod keys;
+pub mod stdin;
+pub mod websocket;
+
+#[add_crdt_fields]
+#[derive(Clone, CrdtNode, Serialize, Deserialize, Debug)]
+pub struct TransactionList {
+    pub list: ListCrdt<Transaction>,
+}
+
+impl TransactionList {
+    pub fn view_sha(&self) -> String {
+        sha256::digest(serde_json::to_string(&self.list.view()).unwrap().as_bytes()).to_string()
+    }
+}
+
+/// A fake Transaction struct we can use as a simulated payload
+#[add_crdt_fields]
+#[derive(Clone, CrdtNode, Serialize, Deserialize, PartialEq, Debug)]
+pub struct Transaction {
+    from: String,
+    to: String,
+    amount: f64,
+}

crdt-node/src/bft_crdt/stdin.rs

@@ -0,0 +1,11 @@
+use std::io::BufRead;
+
+/// Wait for stdin terminal input and send it to the node if any arrives
+pub(crate) fn input(stdin_sender: std::sync::mpsc::Sender<String>) {
+    let stdin = std::io::stdin();
+    let lines = stdin.lock().lines();
+    for line in lines {
+        let line = line.unwrap();
+        stdin_sender.send(line).unwrap();
+    }
+}

crdt-node/src/bft_crdt/websocket.rs

@@ -0,0 +1,66 @@
+use async_trait::async_trait;
+use bft_json_crdt::json_crdt::SignedOp;
+use ezsockets::ClientConfig;
+use tokio::sync::mpsc;
+
+use crate::utils;
+
+pub struct Client {
+    incoming_sender: mpsc::Sender<SignedOp>,
+    handle: ezsockets::Client<Client>,
+}
+
+impl Client {
+    /// Start the websocket client
+    pub async fn new(incoming_sender: mpsc::Sender<SignedOp>) -> ezsockets::Client<Client> {
+        let config = ClientConfig::new("ws://localhost:8080/websocket");
+        let (handle, future) = ezsockets::connect(
+            |client| Client {
+                incoming_sender,
+                handle: client,
+            },
+            config,
+        )
+        .await;
+        tokio::spawn(async move {
+            future.await.unwrap();
+        });
+        handle
+    }
+}
+
+#[async_trait]
+impl ezsockets::ClientExt for Client {
+    // Right now we're only using the Call type for sending signed ops
+    // change this to an enum if we need to send other types of calls, and
+    // match on it.
+    type Call = String;
+
+    /// When we receive a text message, apply the bft-crdt operation contained in it to our
+    /// local bft-crdt.
+    async fn on_text(&mut self, text: String) -> Result<(), ezsockets::Error> {
+        let string_sha = utils::shassy(text.clone());
+        println!("received text, sha: {string_sha}");
+        let incoming: bft_json_crdt::json_crdt::SignedOp = serde_json::from_str(&text).unwrap();
+        let object_sha = utils::shappy(incoming.clone());
+        println!("deserialized: {}", object_sha);
+        if string_sha != object_sha {
+            panic!("sha mismatch: {string_sha} != {object_sha}, bft-bft-crdt has failed");
+        }
+        self.incoming_sender.send(incoming).await?;
+        Ok(())
+    }
+
+    /// When we receive a binary message, log the bytes. Currently unused.
+    async fn on_binary(&mut self, bytes: Vec<u8>) -> Result<(), ezsockets::Error> {
+        tracing::info!("received bytes: {bytes:?}");
+        Ok(())
+    }
+
+    /// Call this with the `Call` type to send application data to the websocket client
+    /// (and from there, to the server).
+    async fn on_call(&mut self, call: Self::Call) -> Result<(), ezsockets::Error> {
+        self.handle.text(call)?;
+        Ok(())
+    }
+}

crdt-node/src/bitcoin/clients/electrum.rs

@@ -0,0 +1,101 @@
+use crate::{bitcoin, utils};
+use bdk::bitcoin::psbt::PartiallySignedTransaction;
+use bdk::bitcoin::Network;
+use bdk::database::MemoryDatabase;
+use bdk::keys::ExtendedKey;
+use bdk::template::Bip84;
+use bdk::wallet::AddressIndex::{self, New};
+use bdk::wallet::AddressInfo;
+use bdk::{blockchain::ElectrumBlockchain, electrum_client, SyncOptions};
+use bdk::{FeeRate, KeychainKind, SignOptions, TransactionDetails, Wallet};
+
+/// DEPRECATED
+///
+/// This is a bdk example that uses the Electrum client to interact with the Bitcoin network.
+/// Electrum is a light client that connects to a server to get information about the Bitcoin network.
+/// The BDK itself does not have the ability to connect to e.g. esplora servers. As the Blockstream Electrum Signet
+/// server does not appear to be picking up transactions properly at the moment, I've shifted over to using
+/// the (more complex) `bdk_wallet` crate and the esplora client there (see the other bitcoin client).
+///
+/// Note:the types below are all completely different than the types in `bdk_wallet`.
+pub async fn run() -> Result<(), anyhow::Error> {
+    let dave = utils::home(&"dave".to_string());
+    let sammy = utils::home(&"sammy".to_string());
+    let dave_key = bitcoin::keys::load_from_file(&dave).unwrap();
+    let sammy_key = bitcoin::keys::load_from_file(&sammy).unwrap();
+
+    let dave_wallet = create_wallet(dave_key)?;
+    let sammy_wallet = create_wallet(sammy_key)?;
+
+    let dave_address = dave_wallet.get_address(AddressIndex::Peek(0))?.to_string();
+    let sammy_address = sammy_wallet.get_address(AddressIndex::Peek(0))?.to_string();
+
+    println!("Dave's address: {}", dave_address);
+    println!("Sammy's address: {}", sammy_address);
+
+    let blockchain = ElectrumBlockchain::from(electrum_client::Client::new(
+        "ssl://electrum.blockstream.info:60002",
+    )?);
+
+    println!("Syncing...");
+    dave_wallet.sync(&blockchain, SyncOptions::default())?;
+
+    display_balance(&dave_wallet);
+    display_balance(&sammy_wallet);
+
+    let (mut psbt, details) =
+        build_sending_tx(&dave_wallet, sammy_wallet.get_address(New)?).expect("psbt build error");
+
+    println!("About to sign the transaction: {:?}", details);
+
+    dave_wallet.sign(&mut psbt, SignOptions::default())?;
+    let _signed_tx = psbt.extract_tx();
+
+    // println!("Broadcasting...");
+    // blockchain.broadcast(&signed_tx).expect("broadcast error");
+    // println!("Transaction ID: {:?}", signed_tx.txid());
+    Ok(())
+}
+
+/// Create a BDK wallet using BIP 84 descriptor ("m/84h/1h/0h/0" and "m/84h/1h/0h/1")
+pub fn create_wallet(xkey: ExtendedKey) -> anyhow::Result<Wallet<MemoryDatabase>> {
+    let xprv = xkey
+        .into_xprv(Network::Testnet)
+        .expect("couldn't turn xkey into xprv");
+
+    let external_descriptor = Bip84(xprv, KeychainKind::External);
+    let internal_descriptor = Some(Bip84(xprv, KeychainKind::Internal));
+
+    let wallet = Wallet::new(
+        external_descriptor,
+        internal_descriptor,
+        Network::Testnet,
+        MemoryDatabase::default(),
+    )?;
+
+    Ok(wallet)
+}
+
+fn display_balance(wallet: &Wallet<MemoryDatabase>) {
+    println!(
+        "Wallet balance for {} after syncing: {:?} sats on network {}",
+        wallet
+            .get_address(bdk::wallet::AddressIndex::Peek(0))
+            .expect("couldn't get address"),
+        wallet.get_balance().expect("couldn't show balance"),
+        wallet.network(),
+    );
+}
+
+fn build_sending_tx(
+    wallet: &Wallet<MemoryDatabase>,
+    recipient: AddressInfo,
+) -> anyhow::Result<(PartiallySignedTransaction, TransactionDetails), anyhow::Error> {
+    let mut builder = wallet.build_tx();
+    builder
+        .add_recipient(recipient.script_pubkey(), 1000)
+        .enable_rbf()
+        .do_not_spend_change()
+        .fee_rate(FeeRate::from_sat_per_vb(7.0));
+    Ok(builder.finish()?)
+}

crdt-node/src/bitcoin/clients/esplora.rs

@@ -0,0 +1,188 @@
+use std::{collections::BTreeSet, fs, io::Write};
+
+use bdk::keys::bip39::Mnemonic;
+use bdk_esplora::{
+    esplora_client::{self, AsyncClient},
+    EsploraAsyncExt,
+};
+use bdk_wallet::{
+    bitcoin::{Address, Amount, Network, Script},
+    chain::ConfirmationTimeHeightAnchor,
+    keys::{DerivableKey, ExtendedKey},
+    wallet::AddressInfo,
+    KeychainKind, SignOptions, Wallet,
+};
+
+use bdk_sqlite::{rusqlite::Connection, Store};
+
+use crate::utils;
+
+const STOP_GAP: usize = 50;
+const PARALLEL_REQUESTS: usize = 5;
+
+/// A wallet that uses the Esplora client to interact with the Bitcoin network.
+pub struct EsploraWallet {
+    client: AsyncClient,
+    db: Store<KeychainKind, ConfirmationTimeHeightAnchor>,
+    name: String,
+    wallet: Wallet,
+}
+
+impl EsploraWallet {
+    /// Builds and signs a send transaction to send coins between addresses.
+    ///
+    /// Does NOT send it, you must call `broadcast` to do that.
+    ///
+    /// We could split the creation and signing easily if needed.
+    pub(crate) fn build_and_sign_send_tx(
+        &mut self,
+        recipient: Address,
+        amount: Amount,
+    ) -> Result<bitcoin::Transaction, anyhow::Error> {
+        let mut tx_builder = self.wallet.build_tx();
+        tx_builder
+            .add_recipient(recipient.script_pubkey(), amount)
+            .enable_rbf();
+        let mut psbt = tx_builder.finish()?;
+        let finalized = self.wallet.sign(&mut psbt, SignOptions::default())?;
+        assert!(finalized);
+        let tx = psbt.extract_tx()?;
+        Ok(tx)
+    }
+
+    /// Syncs the wallet with the latest state of the Bitcoin blockchain
+    pub(crate) async fn sync(&mut self) -> Result<(), anyhow::Error> {
+        print!("Syncing...");
+
+        fn generate_inspect(
+            kind: KeychainKind,
+        ) -> impl FnMut(u32, &Script) + Send + Sync + 'static {
+            let mut once = Some(());
+            let mut stdout = std::io::stdout();
+            move |spk_i, _| {
+                match once.take() {
+                    Some(_) => print!("\nScanning keychain [{:?}]", kind),
+                    None => print!(" {:<3}", spk_i),
+                };
+                stdout.flush().expect("must flush");
+            }
+        }
+        let request = self
+            .wallet
+            .start_full_scan()
+            .inspect_spks_for_all_keychains({
+                let mut once = BTreeSet::<KeychainKind>::new();
+                move |keychain, spk_i, _| {
+                    match once.insert(keychain) {
+                        true => print!("\nScanning keychain [{:?}]", keychain),
+                        false => print!(" {:<3}", spk_i),
+                    }
+                    std::io::stdout().flush().expect("must flush")
+                }
+            })
+            .inspect_spks_for_keychain(
+                KeychainKind::External,
+                generate_inspect(KeychainKind::External),
+            )
+            .inspect_spks_for_keychain(
+                KeychainKind::Internal,
+                generate_inspect(KeychainKind::Internal),
+            );
+        let mut update = self
+            .client
+            .full_scan(request, STOP_GAP, PARALLEL_REQUESTS)
+            .await?;
+        let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
+        let _ = update.graph_update.update_last_seen_unconfirmed(now);
+        self.wallet.apply_update(update)?;
+        self.persist_local()?;
+        println!("Sync complete for {}", self.name);
+        Ok(())
+    }
+
+    fn persist_local(&mut self) -> Result<(), anyhow::Error> {
+        Ok(if let Some(changeset) = self.wallet.take_staged() {
+            self.db.write(&changeset)?;
+        })
+    }
+
+    /// Gets the next unused address from the wallet.
+    pub(crate) fn next_unused_address(&mut self) -> Result<AddressInfo, anyhow::Error> {
+        let address = self.wallet.next_unused_address(KeychainKind::External);
+        self.persist_local()?;
+        println!(
+            "Generated address: https://mutinynet.com/address/{}",
+            address
+        );
+        Ok(address)
+    }
+
+    /// Returns the balance of the wallet.
+    pub(crate) fn balance(&self) -> bdk_wallet::wallet::Balance {
+        self.wallet.balance()
+    }
+
+    /// Broadcasts a signed transaction to the network.
+    pub(crate) async fn broadcast(
+        &self,
+        tx: &bitcoin::Transaction,
+    ) -> Result<(), esplora_client::Error> {
+        println!(
+            "{} broadcasting tx https://mutinynet.com/tx/{}",
+            self.name,
+            tx.compute_txid()
+        );
+        self.client.broadcast(tx).await
+    }
+}
+
+/// Creates a Bitcoin descriptor wallet with the mnemonic in the given user directory.
+pub(crate) fn create_wallet(name: &str, network: Network) -> anyhow::Result<EsploraWallet> {
+    let keys_dir = utils::home(name);
+
+    let mnemonic_path = crate::utils::side_paths(keys_dir).1; // TODO: this tuple stinks
+    let mnemonic_words = fs::read_to_string(mnemonic_path).expect("couldn't read bitcoin key file");
+
+    println!("Creating wallet from mnemonic: {mnemonic_words}");
+    let mnemonic = Mnemonic::parse(mnemonic_words).unwrap();
+
+    // Generate the extended key
+    let xkey: ExtendedKey = mnemonic
+        .into_extended_key()
+        .expect("couldn't turn mnemonic into xkey");
+
+    let xprv = xkey
+        .into_xprv(Network::Signet)
+        .expect("problem converting xkey to xprv")
+        .to_string();
+
+    println!("Setting up esplora database for {name}");
+
+    let db_path = format!("/tmp/{name}-bdk-esplora-async-example.sqlite");
+    let conn = Connection::open(db_path)?;
+    let mut db = Store::new(conn)?;
+    let external_descriptor = format!("wpkh({xprv}/84'/1'/0'/0/*)");
+    let internal_descriptor = format!("wpkh({xprv}/84'/1'/0'/1/*)");
+    let changeset = db.read().expect("couldn't read esplora database");
+
+    let wallet = Wallet::new_or_load(
+        &external_descriptor,
+        &internal_descriptor,
+        changeset,
+        network,
+    )
+    .expect("problem setting up wallet");
+
+    let client = esplora_client::Builder::new("https://mutinynet.com/api")
+        .build_async()
+        .expect("couldn't build esplora client");
+
+    let esplora = EsploraWallet {
+        name: name.to_string(),
+        wallet,
+        db,
+        client,
+    };
+
+    Ok(esplora)
+}

crdt-node/src/bitcoin/clients/mod.rs

@@ -0,0 +1,2 @@
+pub mod electrum;
+pub mod esplora;

crdt-node/src/bitcoin/driver.rs

@@ -0,0 +1,60 @@
+use bdk_wallet::bitcoin::{Amount, Network};
+
+use crate::bitcoin::clients;
+
+/// Demonstrates the use of bdk with the Esplora client.
+///
+/// This is more complex than the bare `bdk` crate, but the esplora client works.
+///
+/// Also, it very handily works with the mutinynet.com esplora server, which is configured
+/// with 30 second block times.
+pub(crate) async fn run() -> Result<(), anyhow::Error> {
+    simple_transfer().await
+}
+
+async fn simple_transfer() -> Result<(), anyhow::Error> {
+    let mut dave = clients::esplora::create_wallet("dave", Network::Signet)?;
+    let mut sammy = clients::esplora::create_wallet("sammy", Network::Signet)?;
+
+    let _next_address = dave.next_unused_address()?;
+
+    let dave_balance = dave.balance();
+    println!(
+        "Dave wallet balance before syncing: {} sats",
+        dave_balance.total()
+    );
+
+    dave.sync().await?;
+
+    let dave_balance = dave.balance();
+    println!("Wallet balance after syncing: {} sats", dave_balance);
+
+    let sammy_address = sammy.next_unused_address()?.address;
+    println!("Sammy's address: {}", sammy_address);
+
+    let sammy_balance = sammy.balance();
+    println!(
+        "Sammy wallet balance before syncing: {} sats",
+        sammy_balance
+    );
+
+    sammy.sync().await?;
+
+    let sammy_balance = sammy.balance();
+    println!("Sammy wallet balance after syncing: {} sats", sammy_balance);
+
+    let send_amount = Amount::from_sat(500);
+
+    if dave_balance.total() < send_amount {
+        println!(
+            "Please send at least {} sats to the receiving address",
+            send_amount
+        );
+        std::process::exit(0);
+    }
+
+    let tx = dave.build_and_sign_send_tx(sammy_address, send_amount)?;
+    dave.broadcast(&tx).await?;
+
+    Ok(())
+}

crdt-node/src/bitcoin/keys.rs

@@ -0,0 +1,50 @@
+use bdk::{
+    keys::{
+        bip39::{Language, Mnemonic, WordCount},
+        DerivableKey, ExtendedKey, GeneratableKey, GeneratedKey,
+    },
+    miniscript,
+};
+
+use std::{
+    fs::{self, File},
+    io::Write,
+    path::PathBuf,
+};
+
+pub fn make_mnemonic() -> String {
+    let mnemonic: GeneratedKey<_, miniscript::Segwitv0> =
+        Mnemonic::generate((WordCount::Words12, Language::English)).unwrap();
+    mnemonic.to_string()
+}
+
+/// Write the mnemonic to a file in the node's side directory
+///
+/// TODO: obviously spitting the mnemonic out to the console is not for production
+pub(crate) fn write(mnemonic_path: &PathBuf) -> Result<(), std::io::Error> {
+    let mnemonic = make_mnemonic();
+    let mut file = File::create(mnemonic_path)?;
+    println!("mnemonic: {mnemonic}");
+    file.write(mnemonic.as_bytes())?;
+
+    Ok(())
+}
+
+/// Creates Signet Bitcoin descriptors from a mnemonic
+pub fn get(mnemonic_words: String) -> anyhow::Result<ExtendedKey> {
+    let mnemonic = Mnemonic::parse(mnemonic_words).unwrap();
+
+    // Generate the extended key
+    let xkey: ExtendedKey = mnemonic
+        .into_extended_key()
+        .expect("couldn't turn mnemonic into xkey");
+
+    Ok(xkey)
+}
+
+pub(crate) fn load_from_file(side_dir: &PathBuf) -> anyhow::Result<ExtendedKey> {
+    let mnemonic_path = crate::utils::side_paths(side_dir.clone()).1; // TODO: this tuple stinks
+    let mnemonic_words = fs::read_to_string(mnemonic_path).expect("couldn't read bitcoin key file");
+    println!("Creating wallet from mnemonic: {mnemonic_words}");
+    get(mnemonic_words)
+}

crdt-node/src/bitcoin/mod.rs

@@ -0,0 +1,3 @@
+pub mod clients;
+pub mod driver;
+pub mod keys;

crdt-node/src/cli/mod.rs

@@ -0,0 +1,28 @@
+use clap::Parser;
+use clap::Subcommand;
+
+pub(crate) fn parse_args() -> Args {
+    let args = Args::parse();
+
+    args
+}
+
+/// A P2P smart contract execution node
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+pub(crate) struct Args {
+    #[command(subcommand)]
+    pub(crate) command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+pub(crate) enum Commands {
+    /// Placeholder for future BTC commands
+    Btc {},
+
+    /// runs the Side Node
+    Run { name: String },
+
+    /// initializes the Side Node with a new keypair
+    Init { name: String },
+}

crdt-node/src/init/config.rs

@@ -0,0 +1,21 @@
+use serde::Serialize;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+use toml::to_string;
+
+/// Our node config. For now, it just has a name, but it'll expand as we add more features.
+#[derive(Serialize)]
+pub(crate) struct SideNodeConfig {
+    pub(crate) name: String,
+}
+
+pub(crate) fn write_toml(
+    config: &SideNodeConfig,
+    file_path: &PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let toml_string = to_string(config)?;
+    let mut file = File::create(file_path)?;
+    file.write_all(toml_string.as_bytes())?;
+    Ok(())
+}

crdt-node/src/init/mod.rs

@@ -0,0 +1,120 @@
+use std::path::PathBuf;
+
+use config::SideNodeConfig;
+
+use crate::{bft_crdt, bitcoin, utils};
+
+pub(crate) mod config;
+
+pub(crate) fn init(home: PathBuf, config: SideNodeConfig) -> Result<(), std::io::Error> {
+    ensure_side_directory_exists(&home)?;
+    let (bft_crdt_key_path, bitcoin_key_path, config_path) = utils::side_paths(home.clone());
+
+    println!("Writing bft bft-crdt key to: {:?}", bft_crdt_key_path);
+    bft_crdt::keys::write(&bft_crdt_key_path)?;
+
+    println!("Writing bitcoin key to: {:?}", bitcoin_key_path);
+    bitcoin::keys::write(&bitcoin_key_path)?;
+
+    println!("Writing config to: {:?}", config_path);
+    config::write_toml(&config, &config_path).expect("unable to write config file");
+
+    Ok(())
+}
+
+/// Ensures that the directory at side_dir exists, so we have a place
+/// to store our key files and config file.
+fn ensure_side_directory_exists(side_dir: &PathBuf) -> Result<(), std::io::Error> {
+    if side_dir.exists() {
+        return Ok(());
+    }
+    println!(
+        "Config directory doesn't exist, creating at: {:?}",
+        side_dir
+    );
+    std::fs::create_dir_all(side_dir)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{fs, path::Path, str::FromStr};
+
+    use fastcrypto::{
+        ed25519::Ed25519KeyPair,
+        traits::{EncodeDecodeBase64, KeyPair, ToFromBytes},
+    };
+
+    use super::*;
+
+    /// Generates a SideNodeConfig with a unique name for each test.
+    /// This is necessary because the tests run in parallel and we
+    /// don't want them to interfere with each other - without a unique
+    /// name, the tests would all try to write to the same directory and we
+    /// get test indeterminacy
+    fn side_node_config() -> (SideNodeConfig, String) {
+        let name = format!("test-{}", uuid::Uuid::new_v4()).to_string();
+        (SideNodeConfig { name: name.clone() }, name)
+    }
+
+    #[test]
+    fn creates_bitcoin_keys() {
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
+
+        let mut bitcoin_keys_path = PathBuf::new();
+        bitcoin_keys_path.push(side_dir.clone());
+        bitcoin_keys_path.push(utils::BITCOIN_KEY_FILE);
+
+        let _ = init(PathBuf::from_str(&side_dir).unwrap(), config);
+        assert!(bitcoin_keys_path.exists());
+
+        // check that the pem is readable
+        // let data = fs::read_to_string(bitcoin_keys_path).expect("couldn't read key file");
+        // let keys = Ed25519KeyPair::decode_base64(&data).expect("couldn't load keypair from file");
+        // assert_eq!(keys.public().as_bytes().len(), 32);
+    }
+
+    #[test]
+    fn creates_side_node_directory() {
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
+
+        let mut test_home = PathBuf::new();
+
+        test_home.push(side_dir);
+        let node_dir = Path::new(&test_home).parent().unwrap().to_str().unwrap();
+        let _ = init(test_home.clone(), config);
+        assert!(std::path::Path::new(node_dir).exists());
+    }
+
+    #[test]
+    fn creates_bft_crdt_key_file() {
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
+
+        let mut key_file_path = PathBuf::new();
+        key_file_path.push(side_dir.clone());
+        key_file_path.push(utils::BFT_CRDT_KEY_FILE);
+
+        let _ = init(PathBuf::from_str(&side_dir).unwrap(), config);
+        assert!(key_file_path.exists());
+
+        // check that the pem is readable
+        let data = fs::read_to_string(key_file_path).expect("couldn't read key file");
+        let keys = Ed25519KeyPair::decode_base64(&data).expect("couldn't load keypair from file");
+        assert_eq!(keys.public().as_bytes().len(), 32);
+    }
+
+    #[test]
+    fn creates_config_file() {
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
+
+        let mut config_file_path = PathBuf::new();
+        config_file_path.push(side_dir.clone());
+        config_file_path.push(utils::CONFIG_FILE);
+
+        let _ = init(PathBuf::from_str(&side_dir).unwrap(), config);
+        assert!(config_file_path.exists());
+    }
+}

crdt-node/src/lib.rs

@@ -0,0 +1,66 @@
+use bft_crdt::websocket;
+use bft_crdt::TransactionList;
+use bft_json_crdt::json_crdt::{BaseCrdt, SignedOp};
+use cli::{parse_args, Commands};
+use node::SideNode;
+use tokio::{sync::mpsc, task};
+
+pub mod bft_crdt;
+pub mod bitcoin;
+pub(crate) mod cli;
+pub(crate) mod init;
+pub mod node;
+pub mod utils;
+
+#[tokio::main]
+pub async fn run() {
+    let args = parse_args();
+
+    match &args.command {
+        Some(Commands::Init { name }) => {
+            let config = init::config::SideNodeConfig {
+                name: name.to_string(),
+            };
+
+            let _ = init::init(utils::home(name), config);
+        }
+        Some(Commands::Run { name }) => {
+            let mut node = setup(name).await;
+            node.start().await;
+        }
+        Some(Commands::Btc {}) => {
+            let _ = bitcoin::driver::run().await;
+        }
+        None => println!("No command provided. Exiting. See --help for more information."),
+    }
+}
+
+/// Wire everything up outside the application so that we can test more easily later
+async fn setup(name: &String) -> SideNode {
+    // First, load up the keys and create a bft-bft-crdt
+    let side_dir = utils::home(name);
+    let bft_crdt_keys = bft_crdt::keys::load_from_file(&side_dir);
+    let keys = bitcoin::keys::load_from_file(&side_dir).unwrap();
+    let bitcoin_wallet = bitcoin::clients::electrum::create_wallet(keys).unwrap();
+    let crdt = BaseCrdt::<TransactionList>::new(&bft_crdt_keys);
+
+    // Channels for internal communication, and a tokio task for stdin input
+    let (incoming_sender, incoming_receiver) = mpsc::channel::<SignedOp>(32);
+    let (stdin_sender, stdin_receiver) = std::sync::mpsc::channel();
+    task::spawn(async move {
+        bft_crdt::stdin::input(stdin_sender);
+    });
+
+    // Finally, create the node and return it
+    let handle = websocket::Client::new(incoming_sender).await;
+    let node = SideNode::new(
+        crdt,
+        bft_crdt_keys,
+        bitcoin_wallet,
+        incoming_receiver,
+        stdin_receiver,
+        handle,
+    );
+    println!("Node setup complete.");
+    node
+}

crdt-node/src/main.rs

@@ -0,0 +1,5 @@
+use crdt_node;
+
+fn main() {
+    crdt_node::run();
+}

crdt-node/src/node.rs

@@ -0,0 +1,100 @@
+use bdk::database::MemoryDatabase;
+use bft_json_crdt::json_crdt::{BaseCrdt, SignedOp};
+use fastcrypto::ed25519::Ed25519KeyPair;
+use tokio::sync::mpsc;
+
+use crate::{bft_crdt::websocket::Client, bft_crdt::TransactionList, utils};
+
+pub struct SideNode {
+    crdt: BaseCrdt<TransactionList>,
+    bft_crdt_keys: fastcrypto::ed25519::Ed25519KeyPair,
+    _bitcoin_wallet: bdk::Wallet<MemoryDatabase>, // currently not read anywhere
+    incoming_receiver: mpsc::Receiver<SignedOp>,
+    stdin_receiver: std::sync::mpsc::Receiver<String>,
+    handle: ezsockets::Client<Client>,
+}
+
+impl SideNode {
+    pub fn new(
+        crdt: BaseCrdt<TransactionList>,
+        bft_crdt_keys: Ed25519KeyPair,
+        bitcoin_wallet: bdk::Wallet<MemoryDatabase>,
+        incoming_receiver: mpsc::Receiver<SignedOp>,
+        stdin_receiver: std::sync::mpsc::Receiver<String>,
+        handle: ezsockets::Client<Client>,
+    ) -> Self {
+        let node = Self {
+            crdt,
+            bft_crdt_keys,
+            _bitcoin_wallet: bitcoin_wallet,
+            incoming_receiver,
+            stdin_receiver,
+            handle,
+        };
+        node
+    }
+
+    pub(crate) async fn start(&mut self) {
+        println!("Starting node...");
+
+        loop {
+            match self.stdin_receiver.try_recv() {
+                Ok(stdin) => {
+                    let transaction = utils::fake_generic_transaction_json(stdin);
+                    let json = serde_json::to_value(transaction).unwrap();
+                    let signed_op = self.add_transaction_local(json);
+                    println!("STDIN: {}", utils::shappy(signed_op.clone()));
+                    self.send_to_network(signed_op).await;
+                }
+                Err(_) => {} // ignore empty channel errors in this PoC
+            }
+            match self.incoming_receiver.try_recv() {
+                Ok(incoming) => {
+                    println!("INCOMING: {}", utils::shappy(incoming.clone()));
+                    self.handle_incoming(incoming);
+                }
+                Err(_) => {} // ignore empty channel errors in this PoC
+            }
+        }
+    }
+
+    async fn send_to_network(&self, signed_op: SignedOp) {
+        let to_send = serde_json::to_string(&signed_op).unwrap();
+        self.handle.call(to_send).unwrap();
+    }
+
+    pub fn handle_incoming(&mut self, incoming: SignedOp) {
+        self.crdt.apply(incoming);
+        // self.trace_crdt();
+    }
+
+    pub fn add_transaction_local(
+        &mut self,
+        transaction: serde_json::Value,
+    ) -> bft_json_crdt::json_crdt::SignedOp {
+        let last = self
+            .crdt
+            .doc
+            .list
+            .ops
+            .last()
+            .expect("couldn't find last op");
+        let signed_op = self
+            .crdt
+            .doc
+            .list
+            .insert(last.id, transaction)
+            .sign(&self.bft_crdt_keys);
+        // self.trace_crdt();
+        signed_op
+    }
+
+    /// Print the current state of the CRDT, can be used to debug
+    pub fn trace_crdt(&self) {
+        println!("{:?}", self.crdt.doc.view_sha());
+    }
+
+    pub fn current_sha(&self) -> String {
+        self.crdt.doc.view_sha()
+    }
+}

crdt-node/src/utils.rs

@@ -0,0 +1,48 @@
+use bft_json_crdt::json_crdt::SignedOp;
+use serde_json::{json, Value};
+use std::path::PathBuf;
+
+pub(crate) const BITCOIN_KEY_FILE: &str = "bitcoin_keys.pem";
+pub(crate) const BFT_CRDT_KEY_FILE: &str = "keys.pem";
+pub(crate) const CONFIG_FILE: &str = "config.toml";
+
+/// Returns the path to the key file and config for this host OS.
+pub(crate) fn side_paths(prefix: PathBuf) -> (PathBuf, PathBuf, PathBuf) {
+    let mut bft_crdt_key_path = prefix.clone();
+    bft_crdt_key_path.push(BFT_CRDT_KEY_FILE);
+
+    let mut bitcoin_key_path = prefix.clone();
+    bitcoin_key_path.push(BITCOIN_KEY_FILE);
+
+    let mut config_path = prefix.clone();
+    config_path.push(CONFIG_FILE);
+
+    (bft_crdt_key_path, bitcoin_key_path, config_path)
+}
+
+/// Returns the path to the home directory for this host OS and the given node name
+pub(crate) fn home(name: &str) -> std::path::PathBuf {
+    let mut path = dirs::home_dir().unwrap();
+    path.push(".side");
+    path.push(name);
+    path
+}
+
+/// Generate a fake transaction with customizable from_pubkey String
+pub fn fake_generic_transaction_json(from: String) -> Value {
+    json!({
+        "from": from,
+        "to": "Bob",
+        "amount": 1
+    })
+}
+
+pub fn shappy(op: SignedOp) -> String {
+    let b = serde_json::to_string(&op).unwrap().into_bytes();
+    sha256::digest(b).to_string()
+}
+
+pub fn shassy(text: String) -> String {
+    let b = text.into_bytes();
+    sha256::digest(b).to_string()
+}

crdt-node/tests/crdt.rs

@@ -0,0 +1,54 @@
+use bft_json_crdt::json_crdt::BaseCrdt;
+use bft_json_crdt::keypair::make_keypair;
+use bft_json_crdt::op::ROOT_ID;
+use side_node::bft_crdt::TransactionList;
+
+// case 1 - send valid updates
+#[test]
+fn test_valid_updates() {
+    // Insert to bft-crdt.doc on local node, test applying the same operation to a remote node
+    // and check that the view is the same
+    let keypair1 = make_keypair();
+    let mut crdt1 = BaseCrdt::<TransactionList>::new(&keypair1);
+
+    let val_a = side_node::utils::fake_generic_transaction_json(String::from("a"));
+    let val_b = side_node::utils::fake_generic_transaction_json(String::from("b"));
+    let val_c = side_node::utils::fake_generic_transaction_json(String::from("c"));
+
+    let _a = crdt1
+        .doc
+        .list
+        .insert(ROOT_ID, val_a.clone())
+        .sign(&keypair1);
+    let _b = crdt1
+        .doc
+        .list
+        .insert(_a.id(), val_b.clone())
+        .sign(&keypair1);
+    let _c = crdt1
+        .doc
+        .list
+        .insert(_b.id(), val_c.clone())
+        .sign(&keypair1);
+
+    let keypair2 = make_keypair();
+    let mut crdt2 = BaseCrdt::<TransactionList>::new(&keypair2);
+    crdt2.apply(_a.clone());
+    crdt2.apply(_b);
+    crdt2.apply(_c.clone());
+
+    assert_eq!(
+        crdt2.doc.list.view(),
+        crdt1.doc.list.view(),
+        "views should be equal"
+    );
+
+    crdt2.apply(_a.clone());
+    crdt2.apply(_a);
+
+    assert_eq!(
+        crdt1.doc.list.view(),
+        crdt2.doc.list.view(),
+        "views are still equal after repeated applies"
+    );
+}

crdt-node/tests/side_node.rs

@@ -0,0 +1,60 @@
+use bft_json_crdt::{
+    json_crdt::{BaseCrdt, SignedOp},
+    keypair::make_keypair,
+};
+use side_node::{
+    bft_crdt::websocket::Client, bft_crdt::TransactionList, bitcoin, node::SideNode, utils,
+};
+use tokio::sync::mpsc;
+
+#[tokio::test]
+async fn test_distribute_via_websockets() {
+    let mut node1 = setup("alice").await;
+    let mut node2 = setup("bob").await;
+
+    assert_eq!(node1.current_sha(), node2.current_sha());
+
+    let transaction = utils::fake_generic_transaction_json("from_alice".to_string());
+    let signed_op = node1.add_transaction_local(transaction);
+    node2.handle_incoming(signed_op);
+
+    assert_eq!(node1.current_sha(), node2.current_sha());
+
+    let transaction = utils::fake_generic_transaction_json("from_alice2".to_string());
+    let signed_op = node1.add_transaction_local(transaction);
+    node2.handle_incoming(signed_op);
+
+    assert_eq!(node1.current_sha(), node2.current_sha());
+
+    let transaction = utils::fake_generic_transaction_json("from_alice3".to_string());
+    let signed_op = node1.add_transaction_local(transaction);
+    node2.handle_incoming(signed_op);
+
+    assert_eq!(node1.current_sha(), node2.current_sha());
+}
+
+/// Wire everything up, ignoring things we are not using in the test
+async fn setup(_: &str) -> SideNode {
+    // First, load up the keys and create a bft-bft-crdt
+    let bft_crdt_keys = make_keypair();
+    let mnemonic_words = bitcoin::keys::make_mnemonic();
+    let keys = bitcoin::keys::get(mnemonic_words).unwrap();
+    let bitcoin_wallet = bitcoin::clients::electrum::create_wallet(keys).unwrap();
+    let crdt = BaseCrdt::<TransactionList>::new(&bft_crdt_keys);
+
+    // Channels for internal communication, and a tokio task for stdin input
+    let (incoming_sender, incoming_receiver) = mpsc::channel::<SignedOp>(32);
+    let (_, stdin_receiver) = std::sync::mpsc::channel();
+
+    // Finally, create the node and return it
+    let handle = Client::new(incoming_sender).await;
+    let node = SideNode::new(
+        crdt,
+        bft_crdt_keys,
+        bitcoin_wallet,
+        incoming_receiver,
+        stdin_receiver,
+        handle,
+    );
+    node
+}