Replace implementation of TakerId with public key

This is a backwards-incompatible change in regards to the database
because we previously serialized UUIDs and now expect to deserialize
public keys.

It is a first step towards #576.

daemon/src/maker_inc_connections.rs

@@ -1,6 +1,7 @@
 use crate::maker_cfd::{FromTaker, NewTakerOnline};
 use crate::model::cfd::{Order, OrderId};
 use crate::model::{BitMexPriceEventId, TakerId};
+use crate::noise::TransportStateExt;
 use crate::tokio_ext::FutureExt;
 use crate::{forward_only_ok, maker_cfd, noise, send_to_socket, wire};
 use anyhow::Result;
@@ -117,11 +118,11 @@ impl Actor {
         taker_address: SocketAddr,
         _: &mut Context<Self>,
     ) -> Result<()> {
-        let taker_id = TakerId::default();
+        let transport_state = noise::responder_handshake(&mut stream, &self.noise_priv_key).await?;
+        let taker_id = TakerId::new(transport_state.get_remote_public_key()?);
 
         tracing::info!(%taker_id, address = %taker_address, "New taker connected");
 
-        let transport_state = noise::responder_handshake(&mut stream, &self.noise_priv_key).await?;
         let transport_state = Arc::new(Mutex::new(transport_state));
 
         let (read, write) = stream.into_split();

daemon/src/model.rs

@@ -5,6 +5,7 @@ use chrono::DateTime;
 use reqwest::Url;
 use rust_decimal::prelude::ToPrimitive;
 use rust_decimal::Decimal;
+use serde::de::Error as _;
 use serde::{Deserialize, Serialize};
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 use std::convert::TryInto;
@@ -13,7 +14,6 @@ use std::ops::{Add, Div, Mul, Sub};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{fmt, str};
 use time::{OffsetDateTime, PrimitiveDateTime, Time};
-use uuid::Uuid;
 
 pub mod cfd;
 
@@ -383,18 +383,41 @@ pub enum Position {
     Short,
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub struct TakerId(Uuid);
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct TakerId(x25519_dalek::PublicKey);
 
-impl Default for TakerId {
-    fn default() -> Self {
-        Self(Uuid::new_v4())
+impl TakerId {
+    pub fn new(key: x25519_dalek::PublicKey) -> Self {
+        Self(key)
+    }
+}
+
+impl Serialize for TakerId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_str(self)
+    }
+}
+
+impl<'de> Deserialize<'de> for TakerId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let hex = String::deserialize(deserializer)?;
+
+        let mut bytes = [0u8; 32];
+        hex::decode_to_slice(&hex, &mut bytes).map_err(D::Error::custom)?;
+
+        Ok(Self(x25519_dalek::PublicKey::from(bytes)))
     }
 }
 
 impl fmt::Display for TakerId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
+        write!(f, "{}", hex::encode(self.0.as_bytes()))
     }
 }
 
@@ -632,4 +655,16 @@ mod tests {
 
         assert_eq!(ts_b.seconds() - ts_a.seconds(), -36000);
     }
+
+    #[test]
+    fn roundtrip_taker_id_serde() {
+        let id = TakerId::new(x25519_dalek::PublicKey::from([42u8; 32]));
+
+        serde_test::assert_tokens(
+            &id,
+            &[serde_test::Token::String(
+                "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+            )],
+        );
+    }
 }

daemon/src/noise.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{anyhow, Context, Result};
 use snow::{Builder, TransportState};
 use std::io;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -75,3 +75,22 @@ async fn send(stream: &mut TcpStream, buf: &[u8]) -> Result<()> {
     stream.write_all(buf).await?;
     Ok(())
 }
+
+pub trait TransportStateExt {
+    /// Extract the remote's public key from this transport state.
+    fn get_remote_public_key(&self) -> Result<x25519_dalek::PublicKey>;
+}
+
+impl TransportStateExt for TransportState {
+    fn get_remote_public_key(&self) -> Result<x25519_dalek::PublicKey> {
+        let public_key: [u8; 32] = self
+            .get_remote_static()
+            .context("No public key for remote connection")?
+            .to_vec()
+            .try_into()
+            .map_err(|_| anyhow!("Expected public key to be 32 bytes"))?;
+        let public_key = x25519_dalek::PublicKey::from(public_key);
+
+        Ok(public_key)
+    }
+}