try to fix bug

examples/echo_client.rs

@@ -1,5 +1,6 @@
 use adnl::{AdnlPeer, AdnlRawPublicKey};
 use std::{env, error::Error};
+use x25519_dalek::PublicKey;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -14,14 +15,14 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let remote_public = AdnlRawPublicKey::try_from(&*hex::decode(public_key_hex)?)?;
 
     // act as a client: connect to ADNL server and perform handshake
-    let mut client = AdnlPeer::connect(&remote_public, addr).await?;
+    let mut client = AdnlPeer::connect(&remote_public, addr).await.unwrap();
 
     // send over ADNL
-    client.send(&mut "hello".as_bytes().to_vec()).await?;
+    client.send(&mut "hello".as_bytes().to_vec()).await.unwrap();
 
     // receive result into vector
     let mut result = Vec::<u8>::new();
-    client.receive(&mut result).await?;
+    client.receive(&mut result).await.unwrap();
 
     println!("received: {}", String::from_utf8(result).unwrap());
     Ok(())

examples/echo_server.rs

@@ -28,10 +28,12 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
+    //приватный 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
+    // публичный 8f40c5adb68f25624ae5b214ea767a6ec94d829d3d7b5e1ad1ba6f3e2138285f
     // ADNL: print public key and adnl address associated with given private key
     println!(
         "Public key is: {}",
-        hex::encode(private_key.public().as_bytes())
+        hex::encode(private_key.public().key_to_bytes())
     );
     println!(
         "Address is: {}",

src/helper_types.rs

@@ -10,19 +10,19 @@ pub trait AdnlPublicKey {
     fn address(&self) -> AdnlAddress {
         let mut hasher = Sha256::new();
         hasher.update([0xc6, 0xb4, 0x13, 0x48]); // type id - always ed25519
-        hasher.update(self.to_bytes());
+        hasher.update(self.key_to_bytes());
         AdnlAddress(hasher.finalize().into())
     }
 
-    fn to_bytes(&self) -> [u8; 32];
+    fn key_to_bytes(&self) -> [u8; 32];
 }
 
 /// Public key can be provided using raw slice
 #[derive(Clone)]
 pub struct AdnlRawPublicKey([u8; 32]);
 
 impl AdnlPublicKey for AdnlRawPublicKey {
-    fn to_bytes(&self) -> [u8; 32] {
+    fn key_to_bytes(&self) -> [u8; 32] {
         self.0
     }
 }

src/integrations/dalek.rs

@@ -7,7 +7,7 @@ use curve25519_dalek::montgomery::MontgomeryPoint;
 use x25519_dalek::{PublicKey, StaticSecret};
 
 impl AdnlPublicKey for PublicKey {
-    fn to_bytes(&self) -> [u8; 32] {
+    fn key_to_bytes(&self) -> [u8; 32] {
         MontgomeryPoint(self.to_bytes())
             .to_edwards(0)
             .unwrap()
@@ -18,7 +18,7 @@ impl AdnlPublicKey for PublicKey {
 
 fn edwards_to_montgomery<P: AdnlPublicKey>(public_key: &P) -> PublicKey {
     PublicKey::from(
-        CompressedEdwardsY::from_slice(&public_key.to_bytes())
+        CompressedEdwardsY::from_slice(&public_key.key_to_bytes())
             .unwrap()
             .decompress()
             .unwrap()

src/primitives/handshake.rs

@@ -5,6 +5,7 @@ use crate::{
 };
 use aes::cipher::KeyIvInit;
 use ctr::cipher::StreamCipher;
+use curve25519_dalek::edwards::CompressedEdwardsY;
 use sha2::{Digest, Sha256};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
@@ -57,7 +58,7 @@ impl<P: AdnlPublicKey> AdnlHandshake<P> {
 
         let mut packet = [0u8; 256];
         packet[..32].copy_from_slice(self.receiver.as_bytes());
-        packet[32..64].copy_from_slice(&self.sender.to_bytes());
+        packet[32..64].copy_from_slice(&self.sender.key_to_bytes());
         packet[64..96].copy_from_slice(&hash);
         packet[96..256].copy_from_slice(&raw_params);
         packet

src/tests.rs

@@ -2,6 +2,8 @@ extern crate alloc;
 
 use super::*;
 use alloc::vec::Vec;
+use curve25519_dalek::edwards::CompressedEdwardsY;
+use x25519_dalek::StaticSecret;
 
 #[test]
 fn test_handshake_1() {
@@ -103,8 +105,8 @@ fn test_handshake(
         "receiver mismatch"
     );
     assert_eq!(
-        handshake2.sender().to_bytes(),
-        local_public.to_bytes(),
+        handshake2.sender().key_to_bytes(),
+        local_public.key_to_bytes(),
         "sender mismatch"
     );
     assert_eq!(