keyfork/keyfork-seed/src/tests.rs

use crate::client::Client;
use hex_literal::hex;
use keyfork_derive_util::{request::*, DerivationPath, DerivationIndex, ExtendedPrivateKey};
use std::sync::mpsc::channel;
use std::{os::unix::net::UnixStream, str::FromStr};
use tempdir::TempDir;
use tokio::runtime::Builder;

#[test]
fn it_works() {
    // Test literals taken from keyfork-derive-util.
    // Setup
    let entropy = &hex!("000102030405060708090a0b0c0d0e0f")[..];
    let mnemonic = keyforkd::Mnemonic::from_entropy(entropy, Default::default()).unwrap();
    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
    let tempdir = TempDir::new("keyfork-seed").unwrap();
    let socket_path = tempdir.path().join("keyforkd.sock");
    let (tx, rx) = channel();

    let handle = rt.spawn({
        let socket_path = socket_path.clone();
        async move {
            let mut server = keyforkd::UnixServer::bind(&socket_path).unwrap();
            // Connections can be pending for a few seconds, so signal to the main
            // test we're ready to start accepting.
            tx.send(()).unwrap();
            let service = keyforkd::ServiceBuilder::new()
                .layer(keyforkd::middleware::BincodeLayer::new())
                .service(keyforkd::Keyforkd::new(mnemonic));
            server.run(service).await.unwrap();
        }
    });

    rx.recv().unwrap();
    let socket = UnixStream::connect(&socket_path).unwrap();
    let mut client = Client::new(socket);
    let req = DerivationRequest::new(
        DerivationAlgorithm::Ed25519,
        DerivationPath::from_str("m/0'/1'/2'/2'/1000000000'").unwrap(),
    );
    let response = client.request(&req).unwrap();
    assert_eq!(
        response.data,
        hex!("8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793")
    );
    handle.abort();
}

#[test]
fn misc_multi_requests() {
    // Setup
    let entropy = &hex!("000102030405060708090a0b0c0d0e0f")[..];
    let mnemonic = keyforkd::Mnemonic::from_entropy(entropy, Default::default()).unwrap();
    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
    let tempdir = TempDir::new("keyfork-seed").unwrap();
    let socket_path = tempdir.path().join("keyforkd.sock");
    let (tx, rx) = channel();

    let handle = rt.spawn({
        let socket_path = socket_path.clone();
        async move {
            let mut server = keyforkd::UnixServer::bind(&socket_path).unwrap();
            // Connections can be pending for a few seconds, so signal to the main
            // test we're ready to start accepting.
            tx.send(()).unwrap();
            let service = keyforkd::ServiceBuilder::new()
                .layer(keyforkd::middleware::BincodeLayer::new())
                .service(keyforkd::Keyforkd::new(mnemonic));
            server.run(service).await.unwrap();
        }
    });

    rx.recv().unwrap();
    let socket = UnixStream::connect(&socket_path).unwrap();
    let mut client = Client::new(socket);
    let req = DerivationRequest::new(
        DerivationAlgorithm::Ed25519,
        DerivationPath::from_str("m/7366512'/0'").unwrap(),
    );
    let response = client.request(&req).unwrap();
    let key = ExtendedPrivateKey::<ed25519_dalek::SigningKey>::new_from_parts(
        &response.data,
        response.depth,
        response.chain_code,
    ).unwrap();

    for i in 0..255 {
        key.derive_child(&DerivationIndex::new(i, true).unwrap()).unwrap();
    }
    handle.abort();
}