repo_id stringclasses 137
values | file_path stringlengths 10 89 | content stringlengths 0 990k | __index_level_0__ int64 0 0 |
|---|---|---|---|
websocket | /mono/crates/exchange_proxy/src/bin/poloniex/adapter/websocket/public.rs | use crate::adapter::{
models::websocket::{
public::{
request::{
PublicWsPing, PublicWsRequest, PublicWsSubscription, PublicWsSubscriptionRequest,
PublicWsSubscriptionType,
},
response::PublicWsMessage,
},
PoloniexWsRequestEv... | 0 |
server | /mono/crates/exchange_proxy/src/server/mod.rs | use std::sync::Arc;
use axum::Router;
use fdr_common::task::{FdrTask, FdrTaskResult, ShutdownType};
use fdr_http::Server as FdrHttpServer;
use crate::{context::Context, error::ExchangeProxyError};
pub mod realm;
pub struct Server {
context: Arc<Context>,
}
impl Server {
pub fn new(context: Arc<Context>) -... | 0 |
realm | /mono/crates/exchange_proxy/src/server/realm/mod.rs | pub mod funding;
pub mod market;
pub mod subaccounts;
pub mod trading;
pub mod user_data;
| 0 |
subaccounts | /mono/crates/exchange_proxy/src/server/realm/subaccounts/mod.rs | use axum::{routing::get, Router};
pub fn router() -> Router {
Router::new().route("/sub_accounts/hello", get(hello))
}
async fn hello() -> &'static str {
"Hello, World!"
}
| 0 |
market | /mono/crates/exchange_proxy/src/server/realm/market/pair.rs | use crate::context::Context;
use axum::{extract::Path, Extension, Json};
use catalog::{KRAKEN_PAIRS, POLONIEX_PAIRS};
use exchange_client::realm::{market::get_pair::GetPairsResponse, FdrApiResult};
use fdr_common::{
crypto::{assets::CurrencyPair, pairs::TradingPair},
exchange::Exchange,
tracing::instrument,... | 0 |
market | /mono/crates/exchange_proxy/src/server/realm/market/mod.rs | use axum::{routing::get, Router};
mod asset;
mod book;
mod pair;
pub fn router() -> Router {
Router::new()
.route("/market/books", get(book::get_books))
.route("/market/book/:pair", get(book::get_book))
.route("/market/assets", get(asset::get_assets))
.route("/market/asset/:asset",... | 0 |
market | /mono/crates/exchange_proxy/src/server/realm/market/asset.rs | use crate::context::Context;
use axum::{extract::Path, Extension, Json};
use catalog::{KRAKEN_ASSETS, POLONIEX_ASSETS};
use exchange_client::realm::{market::get_asset::GetAssetsResponse, FdrApiResult};
use fdr_common::{
crypto::assets::{Asset, TradingAsset},
exchange::Exchange,
tracing::instrument,
};
use h... | 0 |
market | /mono/crates/exchange_proxy/src/server/realm/market/book.rs | use crate::{book_manager::BookManagerGetters, context::Context};
use axum::{
extract::{Path, Query},
Extension, Json,
};
use exchange_client::realm::{
market::get_book::{BookWithMeta, GetBookResponse},
FdrApiError, FdrApiResult,
};
use fdr_common::{crypto::assets::CurrencyPair, tracing::instrument};
use... | 0 |
trading | /mono/crates/exchange_proxy/src/server/realm/trading/mod.rs | use axum::{routing::post, Router};
mod cancel_order;
mod create_order;
pub fn router() -> Router {
let router = Router::new()
.route("/trading/cancel_async", post(cancel_order::cancel_order_async))
.route("/trading/cancel", post(cancel_order::cancel_order));
#[cfg(feature = "create_order")]
... | 0 |
trading | /mono/crates/exchange_proxy/src/server/realm/trading/create_order.rs | use std::sync::Arc;
use axum::{Extension, Json};
use chrono::Utc;
use exchange_client::realm::{
trading::create_order::{CreateOrderRequest, CreateOrderResponse},
FdrApiError, FdrApiResult,
};
use http::StatusCode;
use rust_decimal::Decimal;
use uuid::Uuid;
use fdr_common::{
crypto::orders::{FdrOrderStatus... | 0 |
trading | /mono/crates/exchange_proxy/src/server/realm/trading/cancel_order.rs | use std::sync::Arc;
use axum::{Extension, Json};
use exchange_client::realm::{
trading::cancel_order::{CancelOrderRequest, CancelOrderResponse},
FdrApiError, FdrApiResult,
};
use http::StatusCode;
use fdr_common::{
crypto::orders::{FdrOrderCancellationStatus, FdrOrderStatus},
tracing::instrument,
};
u... | 0 |
funding | /mono/crates/exchange_proxy/src/server/realm/funding/mod.rs | use axum::{routing::get, Router};
pub fn router() -> Router {
Router::new().route("/funding/hello", get(hello))
}
async fn hello() -> &'static str {
"Hello, World!"
}
| 0 |
user_data | /mono/crates/exchange_proxy/src/server/realm/user_data/mod.rs | use axum::{routing::get, Router};
mod get_trade_volume;
pub fn router() -> Router {
Router::new().route("/user_data/trade_volume", get(get_trade_volume::get_trade_volume))
}
| 0 |
user_data | /mono/crates/exchange_proxy/src/server/realm/user_data/get_trade_volume.rs | use crate::{
context::Context,
error::{ExchangeAdapterError, ExchangeProxyError},
};
use axum::{Extension, Json};
use exchange_client::realm::{
user_data::get_trade_volume::{GetTradeVolumeRequest, GetTradeVolumeResponse},
FdrApiResult,
};
use fdr_common::{tracing::instrument, TradingStrategy};
use http:... | 0 |
reconciler | /mono/crates/exchange_proxy/src/reconciler/mod.rs | use async_trait::async_trait;
use std::{collections::HashMap, sync::Arc, time::Duration};
use rust_decimal::prelude::ToPrimitive;
use sqlx::Error;
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use fdr_common::{
crypto::{assets::CurrencyPair, orders::FdrOrderStatus},
exchange::Market,
task::{Fdr... | 0 |
reconciler | /mono/crates/exchange_proxy/src/reconciler/models.rs | use chrono::{DateTime, Utc};
use fdr_common::crypto::{
assets::Asset,
orders::{FdrOrderSide, FdrOrderStatus, FdrOrderType},
};
use rust_decimal::Decimal;
use uuid::Uuid;
#[derive(Debug, Copy, Clone)]
pub enum ReconcileBy {
OrderId(Uuid),
// kraken API is lame
UserRef(i32),
}
#[derive(Debug, Clone)... | 0 |
permute | /mono/crates/permute/Cargo.toml | [package]
name = "permute"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
serde = { workspace = true, features = ["derive"] }
| 0 |
src | /mono/crates/permute/src/inc_range.rs | use std::{
cmp::PartialOrd,
ops::{Add, Mul},
};
use serde::Deserialize;
use crate::nth_iter::Nth;
/// IncrementRange defines a range of values from `min` to `max` in increments
/// of `inc`. For example, IncrementRange{0, 10, 2} would produce the values
/// {0, 2, 4, 6, 8, 10}. The IncrementRange is inclusid... | 0 |
src | /mono/crates/permute/src/increment.rs | use std::ops::AddAssign;
/// Increment describes how to increment a value
pub trait Increment {
fn increment(&mut self);
}
/// Implement Increment for anything that you can AddAssign the value 1 u32
impl<T> Increment for T
where
T: Copy + AddAssign + From<u8>,
{
fn increment(&mut self) {
*self += ... | 0 |
src | /mono/crates/permute/src/nth_iter.rs | use crate::increment::Increment;
/// Nth produces the nth element in a set. Nth is based on std::ops::Index but
/// allows for returning owned values (where Index only allows for returning
/// borrowed values). This is useful for generating the nth element of a set on
/// demand, without the responsibility of owning t... | 0 |
src | /mono/crates/permute/src/lib.rs | mod increment;
pub mod inc_range;
pub mod nth_iter;
| 0 |
catalog | /mono/crates/catalog/Cargo.toml | [package]
name = "catalog"
version = "0.1.0"
edition = "2021"
authors = ["Steve Sampson <mail@stephensampson.dev>"]
description = "Exchange Catalogs... Assets, Pairs, and their specs"
[dependencies]
fdr-common = { path = "../fdr_common" }
indexmap = { workspace = true }
lazy_static = { workspace = true }
rust_decimal... | 0 |
resources | /mono/crates/catalog/resources/poloniex_pairs.json | [ {
"symbol" : "BTS_BTC",
"baseCurrencyName" : "BTS",
"quoteCurrencyName" : "BTC",
"displayName" : "BTS/BTC",
"state" : "NORMAL",
"visibleStartTime" : 1659018816626,
"tradableStartTime" : 1659018816626,
"symbolTradeLimit" : {
"symbol" : "BTS_BTC",
"priceScale" : 10,
"quantityScale" : 0,
... | 0 |
resources | /mono/crates/catalog/resources/poloniex_assets.json | [ {
"id" : 1,
"coin" : "1CR",
"delisted" : true,
"tradeEnable" : false,
"name" : "1CRedit",
"networkList" : [ {
"id" : 1,
"coin" : "1CR",
"name" : "1CRedit",
"currencyType" : "address",
"blockchain" : "1CR",
"withdrawalEnable" : false,
"depositEnable" : false,
"depositAddress... | 0 |
resources | /mono/crates/catalog/resources/update_catalog.sh | #!/bin/bash
# Update Kraken Assets
curl https://api.kraken.com/0/public/Assets | jq .result > kraken_assets.json
# Update Kraken Pairs
curl https://api.kraken.com/0/public/AssetPairs | jq .result > kraken_pairs.json
# Update Poloniex Assets
curl https://api.poloniex.com/v2/currencies > poloniex_assets.json
# Update... | 0 |
resources | /mono/crates/catalog/resources/kraken_pairs.json | {
"1INCHEUR": {
"altname": "1INCHEUR",
"wsname": "1INCH/EUR",
"aclass_base": "currency",
"base": "1INCH",
"aclass_quote": "currency",
"quote": "ZEUR",
"lot": "unit",
"cost_decimals": 5,
"pair_decimals": 3,
"lot_decimals": 8,
"lot_multiplier": 1,
"leverage_buy": [],
... | 0 |
resources | /mono/crates/catalog/resources/kraken_assets.json | {
"1INCH": {
"aclass": "currency",
"altname": "1INCH",
"decimals": 10,
"display_decimals": 5,
"status": "enabled"
},
"AAVE": {
"aclass": "currency",
"altname": "AAVE",
"decimals": 10,
"display_decimals": 5,
"status": "enabled"
},
"ACA": {
"aclass": "currency",
"... | 0 |
src | /mono/crates/catalog/src/lib.rs | #![allow(ambiguous_glob_reexports)]
#[cfg(feature = "kraken")]
pub mod kraken;
#[cfg(feature = "kraken")]
pub use kraken::*;
#[cfg(feature = "poloniex")]
pub mod poloniex;
#[cfg(feature = "poloniex")]
pub use poloniex::*;
pub enum CatalogError {
Parse(String),
}
| 0 |
kraken | /mono/crates/catalog/src/kraken/assets.rs | use std::collections::HashMap;
use lazy_static::lazy_static;
use fdr_common::crypto::assets::{Asset, TradingAsset};
use crate::KrakenAsset;
lazy_static! {
pub static ref KRAKEN_ASSETS: HashMap<Asset, TradingAsset> = {
let asset_catalog = include_str!("../../resources/kraken_assets.json");
serde_... | 0 |
kraken | /mono/crates/catalog/src/kraken/pairs.rs | use std::collections::HashMap;
use lazy_static::lazy_static;
use fdr_common::crypto::{
assets::{Asset, CurrencyPair},
pairs::TradingPair,
};
use crate::KrakenPair;
lazy_static! {
pub static ref KRAKEN_PAIR_DATA: &'static str = include_str!("../../resources/kraken_pairs.json");
pub static ref KRAKEN_... | 0 |
kraken | /mono/crates/catalog/src/kraken/mod.rs | pub mod assets;
pub use assets::*;
pub mod pairs;
pub use pairs::*;
#[cfg(feature = "models")]
pub mod models;
#[cfg(feature = "models")]
pub use models::*;
| 0 |
kraken | /mono/crates/catalog/src/kraken/models.rs | use std::str::FromStr;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use fdr_common::crypto::{assets::TradingAsset, pairs::TradingPair};
#[derive(Serialize, Deserialize, Debug)]
pub struct KrakenAsset {
pub altname: String,
pub aclass: String,
pub decimals: u32,
pub status: String,
... | 0 |
poloniex | /mono/crates/catalog/src/poloniex/assets.rs | use std::collections::HashMap;
use lazy_static::lazy_static;
use fdr_common::crypto::assets::{Asset, TradingAsset};
use crate::PoloniexAsset;
lazy_static! {
pub static ref POLONIEX_ASSETS: HashMap<Asset, TradingAsset> = {
let asset_catalog = include_str!("../../resources/poloniex_assets.json");
... | 0 |
poloniex | /mono/crates/catalog/src/poloniex/pairs.rs | use std::collections::HashMap;
use lazy_static::lazy_static;
use fdr_common::crypto::{
assets::{Asset, CurrencyPair},
pairs::TradingPair,
};
use crate::PoloniexPair;
lazy_static! {
pub static ref POLONIEX_PAIR_DATA: &'static str = include_str!("../../resources/poloniex_pairs.json");
pub static ref P... | 0 |
poloniex | /mono/crates/catalog/src/poloniex/mod.rs | pub mod assets;
pub use assets::*;
pub mod pairs;
pub use pairs::*;
#[cfg(feature = "models")]
pub mod models;
#[cfg(feature = "models")]
pub use models::*;
| 0 |
poloniex | /mono/crates/catalog/src/poloniex/models.rs | use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use crate::CatalogError;
use fdr_common::crypto::{assets::TradingAsset, pairs::TradingPair};
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all(deserialize = "camelCase"))]
pub struct PoloniexAsset {
pub id: u32,
pub coin: String,... | 0 |
back_testing_service | /mono/crates/back_testing_service/Cargo.toml | [package]
name = "back-testing-service"
version = "0.1.0"
edition = "2021"
authors = ["Justin Heisler"]
description = "Back testing mock server"
[dependencies]
exchange-proxy = { path = "../exchange_proxy" }
exchange-client = { path = "../exchange_client" }
fdr-common = { path = "../fdr_common", features = ["tracing"]... | 0 |
src | /mono/crates/back_testing_service/src/metrics.rs | use fdr_common::error::FdrResult;
use prometheus::Registry;
use std::sync::Arc;
pub struct Metrics {
pub registry: Arc<Registry>,
}
impl Metrics {
pub fn new(prefix: &str) -> FdrResult<Self> {
let registry = Registry::new_custom(Some(prefix.to_string()), None)?;
Ok(Self {
registry:... | 0 |
src | /mono/crates/back_testing_service/src/error.rs | use exchange_client::realm::FdrApiError;
use http::StatusCode;
use thiserror::Error;
use uuid::Uuid;
use fdr_common::error::FdrError;
use fdr_event::{events::FdrEvent, FdrEventError};
use fdr_store::error::FdrStoreError;
use strategies::error::StrategyError;
use strategy_manager::error::StrategyManagerError;
#[derive... | 0 |
src | /mono/crates/back_testing_service/src/main.rs | #![allow(dead_code)]
#[macro_use]
extern crate slog;
use crate::{
error::{BackTestingServiceError, BackTestingServiceResult},
exchange_adapter::MockExchangeAdapter,
init::init_global_state,
manager::BackTestManager,
};
use async_trait::async_trait;
use axum::Router;
use config_generator::config::BackTe... | 0 |
init | /mono/crates/back_testing_service/src/init/mod.rs | use crate::{error::BackTestingServiceResult, manager::context::Context};
use ::strategies::{config::StrategyConfigKind, market_makers::on_ticker::MarketMakerOnTickerConfig};
use fdr_common::exchange::Venue;
use fdr_store::{
archive::{models::GetArchivesFilter, ArchiveStore},
backtest::{
account_details:... | 0 |
manager | /mono/crates/back_testing_service/src/manager/mod.rs | use crate::{error::BackTestingServiceResult, manager::context::Context};
use chrono::Utc;
use fdr_common::{
crypto::{
assets::CurrencyPair,
orders::{FdrOrderSide, FdrOrderStatus},
},
exchange::{Exchange, Market},
ticker::FdrTickerUpdate,
};
use fdr_event::{
events::{
FdrEvent... | 0 |
manager | /mono/crates/back_testing_service/src/manager/models.rs | use chrono::{DateTime, Utc};
use fdr_common::{
crypto::{
assets::CurrencyPair,
orders::{FdrOrderSide, FdrOrderStatus, FdrOrderType, OrderEntry},
},
exchange::{Exchange, Market},
TradingStrategy,
};
use fdr_event::events::FdrOrderPlaced;
use rust_decimal::Decimal;
use std::collections::Ha... | 0 |
manager | /mono/crates/back_testing_service/src/manager/context.rs | use async_trait::async_trait;
use prometheus::Registry;
use slog::Logger;
use std::{collections::HashMap, sync::Arc};
use crate::{error::BackTestingServiceError, manager::models::BackTestOrderManager, metrics::Metrics};
use config_generator::config::BackTestConfig;
use fdr_common::{context::FdrServiceContext, crypto::... | 0 |
exchange_adapter | /mono/crates/back_testing_service/src/exchange_adapter/mod.rs | use crate::manager::BackTestManager;
use async_trait::async_trait;
use exchange_client::{
error::ExchangeClientResult,
realm::{
market::{
get_asset::GetAssetsResponse, get_book::GetBookResponse, get_pair::GetPairsResponse,
ExchangeAdapterMarketTrait,
},
user_data:... | 0 |
config | /mono/crates/back_testing_service/src/config/config-local.toml.tmpl | strategy_type = "MARKET_MAKER_ON_TICKER"
run_id = "90d99ddf-ba11-480e-9a31-792670745053"
state_strategy = "Database"
[server]
port = 3000
listen_address = "0.0.0.0"
[postgres]
hostname = "localhost"
port = 5432
database = "trading-test"
max_connections = 100
username = "trading-test"
password = "trading-test"
[metri... | 0 |
technical_analysis | /mono/crates/technical_analysis/Cargo.toml | [package]
name = "technical_analysis"
version.workspace = true
edition.workspace = true
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
fdr-common = { path = "../fdr_common" }
async-trait = { workspace = true }
chrono = { workspace = true, features = ["... | 0 |
src | /mono/crates/technical_analysis/src/value.rs | use derive_more::Display;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use strum_macros::EnumIter;
use crate::error::IndicatorError;
#[derive(Display, Debug, EnumIter, Serialize, Deserialize, Hash, Eq, PartialEq, Clone, Copy)]
pub enum IndicatorSymbol {
#[serde(rename = "sma")]
#[display(fm... | 0 |
src | /mono/crates/technical_analysis/src/error.rs | use fdr_common::exchange::Market;
use std::sync::PoisonError;
use thiserror::Error;
use crate::{
period::Period,
value::{IndicatorSymbol, IndicatorValue},
};
pub type IndicatorResult<T> = Result<T, IndicatorError>;
#[derive(Error, Debug)]
pub enum IndicatorError {
#[error("Market not configured in regist... | 0 |
src | /mono/crates/technical_analysis/src/registry.rs | use crate::{
error::IndicatorResult,
indicators::{cache::CachedIndicator, IndicatorTrait},
period::Period,
value::{IndicatorSymbol, IndicatorValue},
};
use fdr_common::{exchange::Market, ticker::ticker_buffer::TickerBuffer};
use std::{collections::HashMap, sync::Arc};
use strum::IntoEnumIterator;
use to... | 0 |
src | /mono/crates/technical_analysis/src/period.rs | use chrono::Duration;
use derive_more::Display;
use lazy_static::lazy_static;
use strum_macros::EnumIter;
lazy_static! {
static ref MINUTE1: Duration = Duration::minutes(1);
static ref MINUTE3: Duration = Duration::minutes(3);
static ref MINUTE5: Duration = Duration::minutes(5);
static ref MINUTE15: Du... | 0 |
src | /mono/crates/technical_analysis/src/lib.rs | pub mod error;
pub mod indicators;
pub mod period;
pub mod registry;
pub mod value;
| 0 |
indicators | /mono/crates/technical_analysis/src/indicators/cache.rs | use crate::{
error::IndicatorResult,
indicators::IndicatorTrait,
period::Period,
registry::RegistryType,
value::{IndicatorSymbol, IndicatorValue},
};
use chrono::{DateTime, Utc};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use std::{collections::HashMap, sync::RwLock};
const DATETI... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/standard_deviation.rs | use crate::{
error::IndicatorResult,
indicators::{IndicatorTrait, IndicatorValue},
period::Period,
registry::RegistryType,
value::IndicatorSymbol,
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use rust_decimal::{Decimal, MathematicalOps};
use rust_decimal_macros::dec;
pub struct S... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/mod.rs | use crate::{
error::IndicatorResult,
period::Period,
registry::RegistryType,
value::{IndicatorSymbol, IndicatorValue},
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
pub mod cache;
pub mod exponential_moving_average;
pub mod relative_strength_index;
pub mod simple_moving_average;
pub m... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/stdprc.rs | use super::IndicatorTrait;
use crate::error::{IndicatorError, IndicatorResult};
use crate::period::Period;
use crate::registry::RegistryType;
use crate::value::{IndicatorSymbol, IndicatorValue};
use fdr_common::exchange::Market;
use fdr_common::ticker::FdrTickerUpdate;
use rust_decimal::{Decimal, RoundingStrategy};
//... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/exponential_moving_average.rs | use crate::{
error::IndicatorResult,
indicators::{IndicatorTrait, IndicatorValue},
period::Period,
registry::RegistryType,
value::IndicatorSymbol,
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
/// Exponential Moving Average ... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/vwap.rs | use crate::{
error::IndicatorResult,
indicators::{IndicatorTrait, IndicatorValue},
period::Period,
registry::RegistryType,
value::IndicatorSymbol,
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use rust_decimal::Decimal;
pub struct VWAPIndicator;
/// Volume Weighted Average Price ... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/simple_moving_average.rs | use crate::{
error::IndicatorResult,
indicators::{IndicatorTrait, IndicatorValue},
period::Period,
registry::RegistryType,
value::IndicatorSymbol,
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use rust_decimal::Decimal;
pub struct SimpleMovingAverage;
/// Simple Moving Average is... | 0 |
indicators | /mono/crates/technical_analysis/src/indicators/relative_strength_index.rs | use crate::{
error::IndicatorResult,
indicators::{IndicatorTrait, IndicatorValue},
period::Period,
registry::RegistryType,
value::IndicatorSymbol,
};
use fdr_common::{exchange::Market, ticker::FdrTickerUpdate};
use rust_decimal::Decimal;
pub struct RelativeStrengthIndex;
/// Relative Strength Inde... | 0 |
price_guard | /mono/crates/price_guard/Cargo.toml | [package]
name = "price_guard"
version.workspace = true
edition.workspace = true
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
fdr-common = { path = "../fdr_common" }
fdr-store = { path = "../fdr_store" }
async-trait = { workspace = true }
rust_decima... | 0 |
src | /mono/crates/price_guard/src/bucket.rs | use crate::{error::PriceGuardResult, PriceGuardTrait};
use async_trait::async_trait;
use fdr_common::crypto::orders::FdrOrderSide;
use fdr_store::trades::models::TradeDto;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Debug, Clone, Serialize, Deserialize, Part... | 0 |
src | /mono/crates/price_guard/src/average.rs | use crate::{error::PriceGuardResult, PriceGuardTrait};
use async_trait::async_trait;
use fdr_common::crypto::assets::CurrencyPair;
use fdr_store::{core::pool::Pool, metrics::MetricsStore, trades::models::TradeDto};
use rust_decimal::Decimal;
use std::sync::Arc;
use uuid::Uuid;
/// A guard that uses the average price o... | 0 |
src | /mono/crates/price_guard/src/error.rs | use thiserror::Error;
#[derive(Error, Debug)]
pub enum PriceGuardError {
#[error(transparent)]
FdrStore(#[from] fdr_store::error::FdrStoreError),
}
pub type PriceGuardResult<T> = Result<T, PriceGuardError>;
| 0 |
src | /mono/crates/price_guard/src/static_guard.rs | use crate::{error::PriceGuardResult, PriceGuardTrait};
use async_trait::async_trait;
use fdr_store::trades::models::TradeDto;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StaticPriceGuardConfig {
pub min_sell_price: Decimal,
... | 0 |
src | /mono/crates/price_guard/src/tvwap.rs | use async_trait::async_trait;
use std::{collections::VecDeque, f64::consts::E, sync::Arc};
use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::{error::PriceGuardResult, PriceGuardTrait};
use fdr_common::crypto::{
assets::{Asset, CurrencyPair},
... | 0 |
src | /mono/crates/price_guard/src/lib.rs | pub mod average;
pub mod bucket;
pub mod error;
pub mod static_guard;
pub mod tvwap;
use crate::{
average::AveragePriceGuard,
bucket::Bucket,
error::PriceGuardResult,
static_guard::{StaticPriceGuard, StaticPriceGuardConfig},
tvwap::{TimeVolumeWeightedAveragePriceGuard, TimeVolumeWeightedAveragePric... | 0 |
fdr_common | /mono/crates/fdr_common/Cargo.toml | [package]
name = "fdr-common"
version = "0.1.0"
edition = "2021"
authors = ["Steve Sampson <mail@stephensampson.dev>"]
description = "Common code for trading applications"
[package.metadata.cargo-udeps.ignore]
normal = ["rust_decimal_macros"]
[dependencies]
anyhow = { workspace = true }
async-trait = { workspace = tr... | 0 |
src | /mono/crates/fdr_common/src/task.rs | use std::{
collections::HashMap,
fmt::Debug,
sync::{
atomic::{AtomicBool, Ordering},
Arc,
},
time::Duration,
};
use slog::{info, warn};
use tokio::{
signal::unix::{signal, SignalKind},
sync::Barrier,
task::{Id, JoinError, JoinSet},
};
use tokio_util::sync::CancellationTo... | 0 |
src | /mono/crates/fdr_common/src/metrics.rs | use crate::error::FdrResult;
use prometheus::{Encoder, Registry, TextEncoder};
use std::sync::Arc;
pub fn get_metrics_registry(metrics_registry: Arc<Registry>) -> FdrResult<String> {
let mut buffer = vec![];
let encoder = TextEncoder::new();
let metric_families = metrics_registry.gather();
encoder.enco... | 0 |
src | /mono/crates/fdr_common/src/error.rs | use crate::crypto::assets::CurrencyPair;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum FdrError {
#[error(transparent)]
Hyper(#[from] hyper::Error),
#[error(transparent)]
Anyhow(#[from] anyhow::Error),
#[error(transparent)]
AddrParse(#[from] std::net::AddrParseError),
#[error(trans... | 0 |
src | /mono/crates/fdr_common/src/logging.rs | use slog::Drain;
pub fn default_logger() -> slog::Logger {
let drain = slog_async::Async::new(slog_envlogger::new(
slog_term::CompactFormat::new(slog_term::TermDecorator::new().build())
.build()
.fuse(),
))
.build();
slog::Logger::root(drain.fuse(), slog::o!())
}
| 0 |
src | /mono/crates/fdr_common/src/lib.rs | use derive_more::Display;
use rust_decimal::Decimal;
use sqlx::postgres::{PgHasArrayType, PgTypeInfo};
pub mod config;
pub mod context;
pub mod crypto;
pub mod error;
pub mod exchange;
pub mod metrics;
pub mod task;
#[cfg(feature = "tracing")]
pub mod tracing;
pub mod logging;
pub mod ticker;
pub mod utils;
pub type... | 0 |
src | /mono/crates/fdr_common/src/context.rs | use async_trait::async_trait;
use slog::Logger;
use std::sync::Arc;
#[async_trait]
pub trait FdrServiceContext<C>
where
C: serde::de::DeserializeOwned + Clone + Send + Sync + 'static,
{
type Context: FdrServiceContext<C>;
type Error;
async fn from_config(config: C) -> Result<Self::Context, Self::Error>... | 0 |
exchange | /mono/crates/fdr_common/src/exchange/auth.rs | use crate::utils::config::from_file_or_const;
#[derive(Debug, Clone, serde::Deserialize)]
pub struct ExchangeAuth {
#[serde(deserialize_with = "from_file_or_const")]
pub api_key: String,
#[serde(deserialize_with = "from_file_or_const")]
pub api_secret: String,
}
| 0 |
exchange | /mono/crates/fdr_common/src/exchange/mod.rs | use derive_more::Display;
use serde::{Deserialize, Serialize};
use crate::{crypto::assets::CurrencyPair, ticker::FdrTickerUpdate};
pub mod auth;
#[derive(serde::Serialize, Display, Debug, Copy, Clone, sqlx::Type, Hash, PartialEq, Eq, Default)]
#[serde(rename_all = "UPPERCASE")]
#[sqlx(type_name = "exchange", rename_... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/assets.rs | use crate::error::FdrError;
use derive_more::Display as DDisplay;
use serde::Deserialize;
use sqlx::postgres::{PgHasArrayType, PgTypeInfo};
use std::fmt::{Display, Formatter};
#[derive(
serde::Deserialize, serde::Serialize, DDisplay, Debug, Copy, Clone, sqlx::Type, Hash, Ord, PartialOrd, Eq, PartialEq,
)]
#[serde(... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/orders.rs | use crate::{crypto::assets::Asset, exchange::Market, TradingStrategy};
use derive_more::Display;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrderEntry {
pub id: Uuid,
pub market: Market,
pub... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/pairs.rs | use rust_decimal::Decimal;
#[derive(Debug, Default, Clone, Copy, serde::Deserialize, serde::Serialize, PartialEq)]
pub struct TradingPair {
pub cost_decimals: u32,
pub pair_decimals: u32,
pub lot_decimals: u32,
pub min_order: Decimal,
pub tick_size: Decimal,
}
#[derive(Debug, Default, Clone, Copy,... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/account_balance.rs | use crate::{
crypto::assets::{Asset, CurrencyPair},
exchange::Exchange,
TradingStrategy,
};
use derive_more::Display;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(serde::Deserialize, serde::Serialize, PartialEq, Eq, Debug, Copy, Clone, sqlx::Type, Display)]
#[ser... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/asset_balance.rs | use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use std::ops::{Add, Sub};
#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, PartialEq)]
pub struct AssetBalance {
available: Decimal,
total: Decimal,
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
pub enum BalanceT... | 0 |
crypto | /mono/crates/fdr_common/src/crypto/mod.rs | pub mod account_balance;
pub mod asset_balance;
pub mod assets;
pub mod book;
pub mod orders;
pub mod pairs;
| 0 |
crypto | /mono/crates/fdr_common/src/crypto/book.rs | use crate::{Price, Volume};
use std::collections::BTreeMap;
#[derive(Default, Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
/// A book is a collection of asks and bids
/// The asks and bids are both sorted by price ascending
/// but we can easily reverse the iterator to get descending
/// Example:
//... | 0 |
tracing | /mono/crates/fdr_common/src/tracing/mod.rs | use http::HeaderMap;
use opentelemetry::{
global,
propagation::{Extractor, Injector},
KeyValue,
};
use opentelemetry_otlp::{Protocol, WithExportConfig};
use opentelemetry_sdk::{
propagation::TraceContextPropagator,
runtime, trace,
trace::{RandomIdGenerator, Sampler},
Resource,
};
use tracing... | 0 |
tracing | /mono/crates/fdr_common/src/tracing/config.rs | use serde::{Deserialize, Serialize};
use tracing_core::LevelFilter;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct TracingConfig {
#[serde(
deserialize_with = "deserialize_level_filter",
serialize_with = "serialize_level_filter"
)]
pub level: LevelFilter,
pub tempo_url: Stri... | 0 |
utils | /mono/crates/fdr_common/src/utils/mod.rs | pub mod channel;
pub mod cli;
pub mod config;
pub mod serde;
| 0 |
utils | /mono/crates/fdr_common/src/utils/config.rs | use crate::error::FdrError;
use serde::{
de::{Deserializer, Error},
Deserialize,
};
pub fn from_file_or_const<'de, D>(deserializer: D) -> Result<String, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
if let Some(s) = s.strip_prefix("file:") {
std::fs::r... | 0 |
utils | /mono/crates/fdr_common/src/utils/cli.rs | pub use clap::Parser;
#[derive(Parser, Debug)]
pub struct Args<T: serde::de::DeserializeOwned + Clone + Send + Sync + 'static> {
#[arg(short, long, env, value_parser = toml_from_file::<T>)]
pub config: T,
#[arg(short, long, env, default_value = "false")]
pub validate: bool,
}
pub fn toml_from_file<T: ... | 0 |
utils | /mono/crates/fdr_common/src/utils/channel.rs | use tokio::sync::broadcast::{channel, Receiver, Sender};
pub struct Channel<T: Clone> {
tx: Sender<T>,
}
impl<T: Clone> Default for Channel<T> {
fn default() -> Self {
let (tx, _) = channel::<T>(1);
Self { tx }
}
}
impl<T: Clone> Channel<T> {
pub fn new(capacity: usize) -> Self {
... | 0 |
serde | /mono/crates/fdr_common/src/utils/serde/mod.rs | use chrono::{DateTime, Utc};
use serde::{
de::{DeserializeOwned, Visitor},
Deserialize, Deserializer, Serializer,
};
use std::{fmt, fmt::Display};
pub fn serialize_option_as_string<S, T>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
T: Display + Sized,
{
match va... | 0 |
ticker | /mono/crates/fdr_common/src/ticker/mod.rs | pub mod ticker_buffer;
use crate::{crypto::assets::CurrencyPair, exchange::Exchange};
use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
#[derive(Debug, Copy, Clone, serde::Deserialize, serde::Serialize, Eq, PartialEq, Hash)]
pub struct FdrTickerUpdate {
pub exchange: Exchange,
pub pair: CurrencyPair,
... | 0 |
ticker | /mono/crates/fdr_common/src/ticker/ticker_buffer.rs | use crate::ticker::FdrTickerUpdate;
use chrono::{DateTime, Duration, Utc};
use std::collections::{BTreeMap, Bound};
const DEFAULT_CAPACITY: usize = 1000;
/// TickerBuffer stores tickers up to a max duration ago. The buffer can provides time bound ranges of tickers in log(N)
/// time and attempts to reduce the cost of... | 0 |
config | /mono/crates/fdr_common/src/config/mod.rs | use crate::{exchange::Exchange, TradingStrategy};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricsConfig {
pub prefix: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerConfig {
pub port: u16,
pub listen_address: String,
}
#[... | 0 |
fdr_balances | /mono/crates/fdr_balances/Cargo.toml | [package]
name = "fdr-balances"
version.workspace = true
edition.workspace = true
[dependencies]
fdr-common = { path = "../fdr_common", features = ["tracing"] }
fdr-store = { path = "../fdr_store" }
fdr-event = { path = "../fdr_event" }
async-trait = { workspace = true }
rust_decimal = { workspace = true, features = ... | 0 |
src | /mono/crates/fdr_balances/src/error.rs | use thiserror::Error;
#[derive(Error, Debug)]
pub enum FdrBalancesError {
#[error(transparent)]
Sqlx(#[from] sqlx::Error),
#[error(transparent)]
UrlParse(#[from] url::ParseError),
#[error(transparent)]
Json(#[from] serde_json::Error),
#[error(transparent)]
FdrStore(#[from] fdr_store::er... | 0 |
src | /mono/crates/fdr_balances/src/lib.rs | pub mod error;
pub mod virtual_account;
| 0 |
virtual_account | /mono/crates/fdr_balances/src/virtual_account/pair.rs | use crate::{error::FdrBalancesResult, virtual_account::VirtualAccount};
use chrono::{DateTime, Utc};
use fdr_event::events::FdrOrderTrade;
use rust_decimal::Decimal;
#[derive(Debug)]
pub struct VirtualAccountPair {
base: VirtualAccount,
quote: VirtualAccount,
}
#[derive(Debug)]
pub struct PairBalances {
p... | 0 |
virtual_account | /mono/crates/fdr_balances/src/virtual_account/mod.rs | pub mod pair;
use crate::error::FdrBalancesResult;
use chrono::{DateTime, Utc};
use fdr_common::crypto::{assets::Asset, orders::FdrOrderSide};
use fdr_event::events::FdrOrderTrade;
use fdr_store::{core::pool::Pool, virtual_accounts::VirtualAccountStore};
use rust_decimal::Decimal;
use std::{ops::Neg, sync::Arc};
use u... | 0 |
strategies | /mono/crates/strategies/Cargo.toml | [package]
name = "strategies"
version = "0.1.0"
edition = "2021"
authors = ["Justin"]
description = "Strategy Repository"
[dependencies]
strat-common = { path = "../strat_common" }
fdr-common = { path = "../fdr_common" }
fdr-event = { path = "../fdr_event" }
fdr-store = { path = "../fdr_store" }
fdr-balances = { path ... | 0 |
src | /mono/crates/strategies/src/error.rs | use fdr_balances::error::FdrBalancesError;
use thiserror::Error;
use fdr_common::{
crypto::assets::{Asset, CurrencyPair},
error::FdrError,
exchange::Exchange,
};
use fdr_event::FdrEventError;
use fdr_store::error::FdrStoreError;
use price_guard::error::PriceGuardError;
use strat_common::state_managers::cha... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.