rustico/core
2
0
Fork 0
Code Issues 9 Pull Requests Projects Releases Wiki Activity

moved price manager from pairs into managers

Browse Source
This commit is contained in:
Giulio De Pasquale 2021-01-14 12:53:54 +00:00
parent 23c2d58647
commit dcc1293455
5 changed files with 143 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
rustybot/src/bot.rs
View File

@ -5,17 +5,16 @@ use bitfinex::api::Bitfinex;
use bitfinex::positions::Position;
use bitfinex::ticker::TradingPairTicker;
use futures_util::stream::FuturesUnordered;
use tokio::stream::StreamExt;
use tokio::time::delay_for;
use crate::connectors::{Client, Connector, ExchangeKind};
use crate::currency::{Symbol, SymbolPair};
use crate::events::{Event, EventKind};
use crate::managers::{OrderManager, PositionManager};
use crate::pairs::PriceManager;
use crate::managers::{OrderManager, PositionManager, PriceManager};
use crate::strategy::PositionStrategy;
use crate::ticker::Ticker;
use crate::BoxError;
use tokio::stream::StreamExt;
pub struct BfxBot {
ticker: Ticker,

2
rustybot/src/events.rs
View File

@ -5,8 +5,8 @@ use tokio::stream::StreamExt;
use tokio::task::JoinHandle;
use crate::bot::BfxBot;
use crate::managers::PriceManager;
use crate::models::{Position, PositionProfitState};
use crate::pairs::PriceManager;
use crate::BoxError;
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]

141
rustybot/src/managers.rs
View File

@ -1,15 +1,152 @@
use std::collections::{HashMap, VecDeque};
use crate::connectors::{Client, Connector};
use crate::events::Event;
use crate::models::{Order, Position};
use crate::currency::SymbolPair;
use crate::events::{Event, EventDispatcher, SignalKind};
use crate::models::{Order, Position, PriceTicker};
use crate::strategy::PositionStrategy;
use crate::ticker::Ticker;
use crate::BoxError;
pub struct EventManager {
events: Vec<Event>,
}
#[derive(Clone, Debug)]
pub struct PriceManager {
pair: SymbolPair,
prices: Vec<PriceEntry>,
client: Client,
}
impl PriceManager {
pub fn new(pair: SymbolPair, client: Client) -> Self {
PriceManager {
pair,
prices: Vec::new(),
client,
}
}
pub fn add_entry(&mut self, entry: PriceEntry) {
self.prices.push(entry);
}
pub async fn update(&mut self, tick: u64) -> Result<PriceEntry, BoxError> {
let current_prices = self.client.current_prices(&self.pair).await?.into();
Ok(PriceEntry::new(
tick,
current_prices,
self.pair.clone(),
None,
None,
))
}
// pub fn add_position(&mut self, position: Position) {
// let (new_position, events, signals) = {
// match &self.strategy {
// Some(strategy) => strategy.on_new_tick(&position, &self),
// None => (position, vec![], vec![]),
// }
// };
//
// self.positions
// .entry(self.current_tick)
// .or_default()
// .push(new_position.clone());
//
// // calling position state callbacks
// self.dispatcher
// .call_position_state_handlers(&new_position, &self);
//
// // adding events and calling callbacks
// for e in events {
// self.add_event(e);
// }
//
// // adding signals to current tick vector
// for s in signals {
// self.add_signal(s);
// }
// }
// fn add_event(&mut self, event: Event) {
// self.events.push(event);
//
// self.dispatcher.call_event_handlers(&event, &self);
// }
//
// fn add_signal(&mut self, signal: SignalKind) {
// self.signals.insert(self.current_tick(), signal);
// }
pub fn pair(&self) -> &SymbolPair {
&self.pair
}
// pub fn position_previous_tick(&self, id: u64, tick: Option<u64>) -> Option<&Position> {
// let tick = match tick {
// Some(tick) => {
// if tick < 1 {
// 1
// } else {
// tick
// }
// }
// None => self.current_tick() - 1,
// };
//
// self.positions
// .get(&tick)
// .and_then(|x| x.iter().find(|x| x.position_id() == id))
// }
}
#[derive(Clone, Debug)]
pub struct PriceEntry {
tick: u64,
pair: SymbolPair,
price: PriceTicker,
events: Option<Vec<Event>>,
signals: Option<Vec<SignalKind>>,
}
impl PriceEntry {
pub fn new(
tick: u64,
price: PriceTicker,
pair: SymbolPair,
events: Option<Vec<Event>>,
signals: Option<Vec<SignalKind>>,
) -> Self {
PriceEntry {
tick,
pair,
price,
events,
signals,
}
}
pub fn tick(&self) -> u64 {
self.tick
}
pub fn pair(&self) -> &SymbolPair {
&self.pair
}
pub fn price(&self) -> PriceTicker {
self.price
}
pub fn events(&self) -> &Option<Vec<Event>> {
&self.events
}
pub fn signals(&self) -> &Option<Vec<SignalKind>> {
&self.signals
}
}
pub struct PositionManager {
queue: VecDeque<Position>,
open_positions: Vec<Position>,

145
rustybot/src/pairs.rs
View File

@ -1,145 +0,0 @@
use std::collections::HashMap;
// use crate::strategy::PositionStrategy;
use crate::connectors::Client;
use crate::currency::SymbolPair;
use crate::events::{Event, EventDispatcher, SignalKind};
use crate::models::{Order, Position, PriceTicker};
use crate::BoxError;
#[derive(Clone, Debug)]
pub struct PriceManager {
pair: SymbolPair,
prices: Vec<PriceEntry>,
client: Client,
}
#[derive(Clone, Debug)]
pub struct PriceEntry {
tick: u64,
pair: SymbolPair,
price: PriceTicker,
events: Option<Vec<Event>>,
signals: Option<Vec<SignalKind>>,
}
impl PriceEntry {
pub fn tick(&self) -> u64 {
self.tick
}
pub fn pair(&self) -> &SymbolPair {
&self.pair
}
pub fn price(&self) -> PriceTicker {
self.price
}
pub fn events(&self) -> &Option<Vec<Event>> {
&self.events
}
pub fn signals(&self) -> &Option<Vec<SignalKind>> {
&self.signals
}
}
impl PriceEntry {
pub fn new(
tick: u64,
price: PriceTicker,
pair: SymbolPair,
events: Option<Vec<Event>>,
signals: Option<Vec<SignalKind>>,
) -> Self {
PriceEntry {
tick,
pair,
price,
events,
signals,
}
}
}
impl PriceManager {
pub fn new(pair: SymbolPair, client: Client) -> Self {
PriceManager {
pair,
prices: Vec::new(),
client,
}
}
pub fn add_entry(&mut self, entry: PriceEntry) {
self.prices.push(entry);
}
pub async fn update(&mut self, tick: u64) -> Result<PriceEntry, BoxError> {
let current_prices = self.client.current_prices(&self.pair).await?.into();
Ok(PriceEntry::new(
tick,
current_prices,
self.pair.clone(),
None,
None,
))
}
// pub fn add_position(&mut self, position: Position) {
// let (new_position, events, signals) = {
// match &self.strategy {
// Some(strategy) => strategy.on_new_tick(&position, &self),
// None => (position, vec![], vec![]),
// }
// };
//
// self.positions
// .entry(self.current_tick)
// .or_default()
// .push(new_position.clone());
//
// // calling position state callbacks
// self.dispatcher
// .call_position_state_handlers(&new_position, &self);
//
// // adding events and calling callbacks
// for e in events {
// self.add_event(e);
// }
//
// // adding signals to current tick vector
// for s in signals {
// self.add_signal(s);
// }
// }
// fn add_event(&mut self, event: Event) {
// self.events.push(event);
//
// self.dispatcher.call_event_handlers(&event, &self);
// }
//
// fn add_signal(&mut self, signal: SignalKind) {
// self.signals.insert(self.current_tick(), signal);
// }
pub fn pair(&self) -> &SymbolPair {
&self.pair
}
// pub fn position_previous_tick(&self, id: u64, tick: Option<u64>) -> Option<&Position> {
// let tick = match tick {
// Some(tick) => {
// if tick < 1 {
// 1
// } else {
// tick
// }
// }
// None => self.current_tick() - 1,
// };
//
// self.positions
// .get(&tick)
// .and_then(|x| x.iter().find(|x| x.position_id() == id))
// }
}

2
rustybot/src/strategy.rs
View File

@ -1,8 +1,8 @@
use std::collections::HashMap;
use crate::events::{Event, EventKind, EventMetadata, SignalKind};
use crate::managers::PriceManager;
use crate::models::{Position, PositionProfitState};
use crate::pairs::PriceManager;
use dyn_clone::DynClone;
pub trait PositionStrategy: DynClone {