Ethereum relayer server

Causes send test to pass for the processor.

processor/src/main.rs

@@ -748,7 +748,15 @@ async fn main() {
     #[cfg(feature = "bitcoin")]
     NetworkId::Bitcoin => run(db, Bitcoin::new(url).await, coordinator).await,
     #[cfg(feature = "ethereum")]
-    NetworkId::Ethereum => run(db.clone(), Ethereum::new(db, url).await, coordinator).await,
+    NetworkId::Ethereum => {
+      let relayer_hostname = env::var("ETHEREUM_RELAYER_HOSTNAME")
+        .expect("ethereum relayer hostname wasn't specified")
+        .to_string();
+      let relayer_port =
+        env::var("ETHEREUM_RELAYER_PORT").expect("ethereum relayer port wasn't specified");
+      let relayer_url = relayer_hostname + ":" + &relayer_port;
+      run(db.clone(), Ethereum::new(db, url, relayer_url).await, coordinator).await
+    }
     #[cfg(feature = "monero")]
     NetworkId::Monero => run(db, Monero::new(url).await, coordinator).await,
     _ => panic!("spawning a processor for an unsupported network"),

processor/src/networks/ethereum.rs

@@ -31,6 +31,11 @@ use tokio::{
   time::sleep,
   sync::{RwLock, RwLockReadGuard},
 };
+#[cfg(not(test))]
+use tokio::{
+  io::{AsyncReadExt, AsyncWriteExt},
+  net::TcpStream,
+};
 
 use serai_client::{
   primitives::{Coin, Amount, Balance, NetworkId},
@@ -290,6 +295,8 @@ pub struct Ethereum<D: Db> {
   // address. Accordingly, all methods present are consistent to a Serai chain with a finalized
   // first key (regardless of local state), and this is safe.
   db: D,
+  #[cfg_attr(test, allow(unused))]
+  relayer_url: String,
   provider: Arc<RootProvider<SimpleRequest>>,
   deployer: Deployer,
   router: Arc<RwLock<Option<Router>>>,
@@ -309,9 +316,9 @@ impl<D: Db> fmt::Debug for Ethereum<D> {
   }
 }
 impl<D: Db> Ethereum<D> {
-  pub async fn new(db: D, url: String) -> Self {
+  pub async fn new(db: D, daemon_url: String, relayer_url: String) -> Self {
     let provider = Arc::new(RootProvider::new(
-      ClientBuilder::default().transport(SimpleRequest::new(url), true),
+      ClientBuilder::default().transport(SimpleRequest::new(daemon_url), true),
     ));
 
     let mut deployer = Deployer::new(provider.clone()).await;
@@ -322,7 +329,9 @@ impl<D: Db> Ethereum<D> {
     }
     let deployer = deployer.unwrap().unwrap();
 
-    Ethereum { db, provider, deployer, router: Arc::new(RwLock::new(None)) }
+    dbg!(&relayer_url);
+    dbg!(relayer_url.len());
+    Ethereum { db, relayer_url, provider, deployer, router: Arc::new(RwLock::new(None)) }
   }
 
   // Obtain a reference to the Router, sleeping until it's deployed if it hasn't already been.
@@ -714,8 +723,32 @@ impl<D: Db> Network for Ethereum<D> {
     // Publish this to the dedicated TX server for a solver to actually publish
     #[cfg(not(test))]
     {
-      let _ = completion;
-      todo!("TODO");
+      let mut msg = vec![];
+      match completion.command() {
+        RouterCommand::UpdateSeraiKey { nonce, .. } | RouterCommand::Execute { nonce, .. } => {
+          msg.extend(&u32::try_from(nonce).unwrap().to_le_bytes());
+        }
+      }
+      completion.write(&mut msg).unwrap();
+
+      let Ok(mut socket) = TcpStream::connect(&self.relayer_url).await else {
+        log::warn!("couldn't connect to the relayer server");
+        Err(NetworkError::ConnectionError)?
+      };
+      let Ok(()) = socket.write_all(&u32::try_from(msg.len()).unwrap().to_le_bytes()).await else {
+        log::warn!("couldn't send the message's len to the relayer server");
+        Err(NetworkError::ConnectionError)?
+      };
+      let Ok(()) = socket.write_all(&msg).await else {
+        log::warn!("couldn't write the message to the relayer server");
+        Err(NetworkError::ConnectionError)?
+      };
+      if socket.read_u8().await.ok() != Some(1) {
+        log::warn!("didn't get the ack from the relayer server");
+        Err(NetworkError::ConnectionError)?;
+      }
+
+      Ok(())
     }
 
     // Publish this using a dummy account we fund with magic RPC commands

processor/src/tests/literal/mod.rs

@@ -423,7 +423,7 @@ mod ethereum {
           });
         }
 
-        Ethereum::new(db, url.clone()).await
+        Ethereum::new(db, url.clone(), String::new()).await
       })
     }
   }