Don't repeat names in modules and types

daemon/src/maker.rs

@@ -24,7 +24,7 @@ mod bitmex_price_feed;
 mod db;
 mod keypair;
 mod logger;
-mod maker_cfd_actor;
+mod maker_cfd;
 mod maker_inc_connections;
 mod model;
 mod routes;
@@ -160,7 +160,7 @@ async fn main() -> Result<()> {
                 let (maker_inc_connections_address, maker_inc_connections_context) =
                     xtra::Context::new(None);
 
-                let cfd_maker_actor_inbox = maker_cfd_actor::MakerCfdActor::new(
+                let cfd_maker_actor_inbox = maker_cfd::Actor::new(
                     db,
                     wallet,
                     schnorrsig::PublicKey::from_keypair(SECP256K1, &oracle),
@@ -220,7 +220,7 @@ async fn main() -> Result<()> {
                     async move {
                         loop {
                             cfd_actor_inbox
-                                .do_send_async(maker_cfd_actor::SyncWallet)
+                                .do_send_async(maker_cfd::SyncWallet)
                                 .await
                                 .unwrap();
                             tokio::time::sleep(wallet_sync_interval).await;

daemon/src/maker_cfd_actor.rs → daemon/src/maker_cfd.rs

@@ -45,7 +45,7 @@ pub struct CfdSetupCompleted {
 
 pub struct SyncWallet;
 
-pub struct MakerCfdActor {
+pub struct Actor {
     db: sqlx::SqlitePool,
     wallet: Wallet,
     oracle_pk: schnorrsig::PublicKey,
@@ -60,7 +60,7 @@ pub struct MakerCfdActor {
     contract_setup_message_buffer: Vec<SetupMsg>,
 }
 
-impl MakerCfdActor {
+impl Actor {
     pub async fn new(
         db: sqlx::SqlitePool,
         wallet: Wallet,
@@ -399,56 +399,56 @@ impl MakerCfdActor {
 }
 
 #[async_trait]
-impl Handler<TakeOrder> for MakerCfdActor {
+impl Handler<TakeOrder> for Actor {
     async fn handle(&mut self, msg: TakeOrder, _ctx: &mut Context<Self>) {
         log_error!(self.handle_take_order(msg))
     }
 }
 
 #[async_trait]
-impl Handler<AcceptOrder> for MakerCfdActor {
+impl Handler<AcceptOrder> for Actor {
     async fn handle(&mut self, msg: AcceptOrder, ctx: &mut Context<Self>) {
         log_error!(self.handle_accept_order(msg, ctx))
     }
 }
 
 #[async_trait]
-impl Handler<RejectOrder> for MakerCfdActor {
+impl Handler<RejectOrder> for Actor {
     async fn handle(&mut self, msg: RejectOrder, _ctx: &mut Context<Self>) {
         log_error!(self.handle_reject_order(msg))
     }
 }
 
 #[async_trait]
-impl Handler<NewOrder> for MakerCfdActor {
+impl Handler<NewOrder> for Actor {
     async fn handle(&mut self, msg: NewOrder, _ctx: &mut Context<Self>) {
         log_error!(self.handle_new_order(msg));
     }
 }
 
 #[async_trait]
-impl Handler<NewTakerOnline> for MakerCfdActor {
+impl Handler<NewTakerOnline> for Actor {
     async fn handle(&mut self, msg: NewTakerOnline, _ctx: &mut Context<Self>) {
         log_error!(self.handle_new_taker_online(msg));
     }
 }
 
 #[async_trait]
-impl Handler<IncProtocolMsg> for MakerCfdActor {
+impl Handler<IncProtocolMsg> for Actor {
     async fn handle(&mut self, msg: IncProtocolMsg, _ctx: &mut Context<Self>) {
         log_error!(self.handle_inc_protocol_msg(msg));
     }
 }
 
 #[async_trait]
-impl Handler<CfdSetupCompleted> for MakerCfdActor {
+impl Handler<CfdSetupCompleted> for Actor {
     async fn handle(&mut self, msg: CfdSetupCompleted, _ctx: &mut Context<Self>) {
         log_error!(self.handle_cfd_setup_completed(msg));
     }
 }
 
 #[async_trait]
-impl Handler<SyncWallet> for MakerCfdActor {
+impl Handler<SyncWallet> for Actor {
     async fn handle(&mut self, _msg: SyncWallet, _ctx: &mut Context<Self>) {
         log_error!(self.handle_sync_wallet());
     }
@@ -486,4 +486,4 @@ impl Message for RejectOrder {
     type Result = ();
 }
 
-impl xtra::Actor for MakerCfdActor {}
+impl xtra::Actor for Actor {}

daemon/src/maker_inc_connections.rs

@@ -1,9 +1,8 @@
 use crate::actors::log_error;
-use crate::maker_cfd_actor::MakerCfdActor;
 use crate::model::cfd::{Order, OrderId};
 use crate::model::TakerId;
 use crate::wire::SetupMsg;
-use crate::{maker_cfd_actor, wire};
+use crate::{maker_cfd, wire};
 use anyhow::{Context as AnyhowContext, Result};
 use async_trait::async_trait;
 use futures::{Future, StreamExt};
@@ -50,13 +49,13 @@ impl Message for NewTakerOnline {
 
 pub struct Actor {
     write_connections: HashMap<TakerId, MakerToTakerSender>,
-    cfd_actor: Address<MakerCfdActor>,
+    cfd_actor: Address<maker_cfd::Actor>,
 }
 
 impl xtra::Actor for Actor {}
 
 impl Actor {
-    pub fn new(cfd_actor: Address<MakerCfdActor>) -> Self {
+    pub fn new(cfd_actor: Address<maker_cfd::Actor>) -> Self {
         Self {
             write_connections: HashMap::<TakerId, MakerToTakerSender>::new(),
             cfd_actor,
@@ -103,7 +102,7 @@ impl Actor {
 
     async fn handle_new_taker_online(&mut self, msg: NewTakerOnline) -> Result<()> {
         self.cfd_actor
-            .do_send_async(maker_cfd_actor::NewTakerOnline { id: msg.taker_id })
+            .do_send_async(maker_cfd::NewTakerOnline { id: msg.taker_id })
             .await?;
 
         self.write_connections
@@ -148,7 +147,7 @@ impl Handler<NewTakerOnline> for Actor {
 
 pub fn in_taker_messages(
     read: OwnedReadHalf,
-    cfd_actor_inbox: Address<MakerCfdActor>,
+    cfd_actor_inbox: Address<maker_cfd::Actor>,
     taker_id: TakerId,
 ) -> impl Future<Output = ()> {
     let mut messages = FramedRead::new(read, LengthDelimitedCodec::new()).map(|result| {
@@ -161,7 +160,7 @@ pub fn in_taker_messages(
             match message {
                 Ok(wire::TakerToMaker::TakeOrder { order_id, quantity }) => {
                     cfd_actor_inbox
-                        .do_send_async(maker_cfd_actor::TakeOrder {
+                        .do_send_async(maker_cfd::TakeOrder {
                             taker_id,
                             order_id,
                             quantity,
@@ -171,7 +170,7 @@ pub fn in_taker_messages(
                 }
                 Ok(wire::TakerToMaker::Protocol(msg)) => {
                     cfd_actor_inbox
-                        .do_send_async(maker_cfd_actor::IncProtocolMsg(msg))
+                        .do_send_async(maker_cfd::IncProtocolMsg(msg))
                         .await
                         .unwrap();
                 }

daemon/src/routes_maker.rs

@@ -1,5 +1,5 @@
 use crate::auth::Authenticated;
-use crate::maker_cfd_actor::{self, MakerCfdActor};
+use crate::maker_cfd;
 use crate::model::cfd::{Cfd, Order, OrderId, Origin};
 use crate::model::{Usd, WalletInfo};
 use crate::routes::EmbeddedFileExt;
@@ -72,7 +72,7 @@ pub struct CfdNewOrderRequest {
 #[rocket::post("/order/sell", data = "<order>")]
 pub async fn post_sell_order(
     order: Json<CfdNewOrderRequest>,
-    cfd_actor_address: &State<Address<MakerCfdActor>>,
+    cfd_actor_address: &State<Address<maker_cfd::Actor>>,
     _auth: Authenticated,
 ) -> Result<status::Accepted<()>, status::BadRequest<String>> {
     let order = Order::from_default_with_price(order.price, Origin::Ours)
@@ -81,7 +81,7 @@ pub async fn post_sell_order(
         .with_max_quantity(order.max_quantity);
 
     cfd_actor_address
-        .do_send_async(maker_cfd_actor::NewOrder(order))
+        .do_send_async(maker_cfd::NewOrder(order))
         .await
         .expect("actor to always be available");
 
@@ -131,11 +131,11 @@ pub struct AcceptOrRejectOrderRequest {
 #[rocket::post("/order/accept", data = "<cfd_accept_order_request>")]
 pub async fn post_accept_order(
     cfd_accept_order_request: Json<AcceptOrRejectOrderRequest>,
-    cfd_actor_address: &State<Address<MakerCfdActor>>,
+    cfd_actor_address: &State<Address<maker_cfd::Actor>>,
     _auth: Authenticated,
 ) -> status::Accepted<()> {
     cfd_actor_address
-        .do_send_async(maker_cfd_actor::AcceptOrder {
+        .do_send_async(maker_cfd::AcceptOrder {
             order_id: cfd_accept_order_request.order_id,
         })
         .await
@@ -146,11 +146,11 @@ pub async fn post_accept_order(
 #[rocket::post("/order/reject", data = "<cfd_reject_order_request>")]
 pub async fn post_reject_order(
     cfd_reject_order_request: Json<AcceptOrRejectOrderRequest>,
-    cfd_actor_address: &State<Address<MakerCfdActor>>,
+    cfd_actor_address: &State<Address<maker_cfd::Actor>>,
     _auth: Authenticated,
 ) -> status::Accepted<()> {
     cfd_actor_address
-        .do_send_async(maker_cfd_actor::RejectOrder {
+        .do_send_async(maker_cfd::RejectOrder {
             order_id: cfd_reject_order_request.order_id,
         })
         .await