main.rs

use std::{io::BufReader, net::{IpAddr, Ipv4Addr, SocketAddr, ToSocketAddrs}, time::{SystemTime, UNIX_EPOCH}};

use bip324::{Handshake, Role};
use bitcoin::{consensus::{deserialize, serialize, Encodable}, p2p::{message::{NetworkMessage, RawNetworkMessage}, message_network::VersionMessage, Address, ServiceFlags}, Network};
use bytes::BytesMut;
use tokio::{io::{AsyncReadExt, AsyncWriteExt}, net::TcpStream};

pub const PROTOCOL_VERSION: u32 = 70015;

pub fn new_version_message() -> Vec<u8> {
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("time went backwards")
        .as_secs();
    let ip = SocketAddr::new(
        IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
        38332
    );
    let recv = SocketAddr::new(
        IpAddr::V4(Ipv4Addr::new(141, 136, 35, 8)),
        38332
    );
    let r = Address::new(&recv, ServiceFlags::NONE);
    let from_and_recv = Address::new(&ip, ServiceFlags::NONE);
    let msg = VersionMessage {
        version: PROTOCOL_VERSION,
        services: ServiceFlags::NONE,
        timestamp: now as i64,
        receiver: r,
        sender: from_and_recv,
        nonce: 2304823094,
        user_agent: "".to_string(),
        start_height: 0,
        relay: false,
    };
    let data = RawNetworkMessage::new(Network::Signet.magic(), NetworkMessage::Version(msg));
    let mut buf = Vec::new();
    data.consensus_encode(&mut buf).unwrap();
    buf
}

#[tokio::main]
async fn main() {
    let ip = SocketAddr::new(
        IpAddr::V4(Ipv4Addr::new(141, 136, 35, 8)),
        38332
    );
    let mut remote = TcpStream::connect(ip).await.unwrap();
    let data = new_version_message();
    remote.write_all(&data).await.unwrap();
    let mut buf = [0; 4];
    remote.read_exact(&mut buf).await.unwrap();
    println!("{}", hex::encode(buf.clone()));
    println!("{:?}", buf);
    // let mut local_material_message = vec![0u8; 64];
    // let mut handshake = Handshake::new(
    //     bip324::Network::Signet,
    //     Role::Initiator,
    //     None,
    //     &mut local_material_message,
    // )
    // .unwrap();
    // remote.write_all(&local_material_message).await.unwrap();
    // println!("Sent handshake to remote.");

    // // 64 bytes ES.
    // let mut remote_material_message = [0u8; 64];
    // println!("Reading handshake response from remote.");
    // remote.read_exact(&mut remote_material_message).await.unwrap();

    // println!("Completing materials.");
    // let mut local_garbage_terminator_message = [0u8; 36];
    // handshake
    //     .complete_materials(
    //         remote_material_message,
    //         &mut local_garbage_terminator_message,
    //     )
    //     .unwrap();

    // println!("Sending garbage terminator and version packet.");
    // remote.write_all(&local_garbage_terminator_message).await.unwrap();

    // // Keep pulling bytes from the buffer until the garbage is flushed.
    // // TODO: Fix arbitrary size.
    // let mut remote_garbage_and_version_buffer = BytesMut::with_capacity(4096);
    // loop {
    //     println!("Authenticating garbage and version packet...");
    //     let read = remote
    //         .read_buf(&mut remote_garbage_and_version_buffer)
    //         .await;
    //     match read {
    //         Err(e) => { 
    //             println!("{}", e.to_string());
    //             break
    //         },
    //         _ => {
    //             let auth =
    //                 handshake.authenticate_garbage_and_version(&remote_garbage_and_version_buffer);
    //             match auth {
    //                 Err(e) => match e {
    //                     // Read again if too small, other wise surface error.
    //                     bip324::Error::MessageLengthTooSmall => continue,
    //                     e => {
    //                         println!("{}", e.to_string());
    //                         break
    //                     },
    //                 },
    //                 _ => break,
    //             }
    //         }
    //     }
    // };
    // println!("Channel authenticated.");
}