Nostr interfacr

// [package]
// name = "nostr_interfacr"
// version = "0.1.0"
// edition = "2021"
//
// # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
//
// [dependencies]
// nostr-sdk = "0.9"
// serde = "1.0.151"
// serde_json = "1.0.91"
// tokio = { version = "1", features = ["full"] }

use nostr_sdk::nostr::util::time::timestamp;
use nostr_sdk::nostr::{SubscriptionFilter, Kind, KindBase};
use nostr_sdk::{Client, Result, RelayPoolNotifications};

use tokio::task;

#[tokio::main]
async fn main() -> Result<()> {
    let my_keys = Client::generate_keys();
    let my_keys_cpy = my_keys.clone();

    let for_loc = task::spawn(async move {

        let foreign_client = Client::new(&my_keys);
        let foreign_relays: Vec<&str> = vec!["wss://relay.damus.io", "wss://relay.nostr.ch"];

        // Add relays
        for foreign_relay in foreign_relays {
            foreign_client.add_relay(foreign_relay, None).await.unwrap();
        }

        foreign_client.connect().await.unwrap();

        let subscription = SubscriptionFilter::new().since(timestamp());
        foreign_client.subscribe(vec![subscription]).await.unwrap();


        let local_client = Client::new(&my_keys);
        local_client.add_relay("ws://localhost:8080", None).await.unwrap();
        local_client.connect().await.unwrap();
        // Display public key
        println!("Foreign->Local: Ready !");
        println!("\tPublic key: {}", my_keys.public_key_as_str());
        loop {
            let mut notifications = foreign_client.notifications();
            while let Ok(notification) = notifications.recv().await {
                if let RelayPoolNotifications::ReceivedEvent(event) = notification {
                    if event.kind == Kind::Base(KindBase::TextNote) {
                        match event.verify() {
                            Ok(_) => {
                                local_client.send_event(event).await.unwrap();
                            }
                            Err(e) => {
                                println!("Error verifying event: {}", e);
                            }
                        }
                    }
                }
            }
        }
    });

    let _loc_for = task::spawn(async move {

        let foreign_client = Client::new(&my_keys_cpy);
        let foreign_relays: Vec<&str> = vec!["wss://relay.damus.io", "wss://relay.nostr.ch"];

        // Add relays
        for foreign_relay in foreign_relays {
            foreign_client.add_relay(foreign_relay, None).await.unwrap();
        }

        foreign_client.connect().await.unwrap();


        let local_client = Client::new(&my_keys_cpy);
        local_client.add_relay("ws://localhost:8080", None).await.unwrap();
        local_client.connect().await.unwrap();

        let subscription = SubscriptionFilter::new().since(timestamp());
        local_client.subscribe(vec![subscription]).await.unwrap();
        // Display public key
        println!("Local->Foreign: Ready !");
        println!("\tPublic key: {}", my_keys_cpy.public_key_as_str());
        loop {
            let mut notifications = local_client.notifications();
            while let Ok(notification) = notifications.recv().await {
                if let RelayPoolNotifications::ReceivedEvent(event) = notification {
                    if event.kind == Kind::Base(KindBase::TextNote) {
                        println!("Received event: {:?}", event);
                        match event.verify() {
                            Ok(_) => {
                                println!("Received verified event: {:?}", event);
                                foreign_client.send_event(event).await.unwrap();
                            }
                            Err(e) => {
                                println!("Error verifying event: {}", e);
                            }
                        }
                    }
                }
            }
        }
    });
    for_loc.await.unwrap();
    Ok(())
}