lukechilds
/
itchysats
mirror of https://github.com/lukechilds/itchysats.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Don't repeat names in modules and types

fix-bad-api-calls
Thomas Eizinger 3 years ago
parent
4d33083af7
commit
54263ce38a
No known key found for this signature in database GPG Key ID: 651AC83A6C6C8B96
4 changed files with 28 additions and 29 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      daemon/src/maker.rs
  2. 22
      daemon/src/maker_cfd.rs
  3. 15
      daemon/src/maker_inc_connections.rs
  4. 14
      daemon/src/routes_maker.rs

6
daemon/src/maker.rs
View File

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

22
daemon/src/maker_cfd_actor.rs → daemon/src/maker_cfd.rs
View File

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

15
daemon/src/maker_inc_connections.rs
View File

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

14
daemon/src/routes_maker.rs
View File

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

Write Preview
Loading…
Cancel
Save