use super::{Currency, HistoryRequest, MarketsRequest, PricesRequest, SearchQuery};
use crate::{
domain::{
Timestamp,
market::{Identifier, Label, NonnegativeDecimal, UnixMilliseconds, UtcDateTime, unique},
},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "status", content = "value", rename_all = "snake_case")]
pub enum PriceAvailability {
Present(NonnegativeDecimal),
NotReported,
AssetUnavailable,
CurrencyUnavailable,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SearchCoin {
id: Identifier,
name: Label,
symbol: Label,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
market_cap_rank: Option<u64>,
}
impl SearchCoin {
#[must_use]
pub const fn new(
id: Identifier,
name: Label,
symbol: Label,
market_cap_rank: Option<u64>,
) -> Self {
Self {
id,
name,
symbol,
market_cap_rank,
}
}
#[must_use]
pub const fn id(&self) -> &Identifier {
&self.id
}
#[must_use]
pub const fn name(&self) -> &Label {
&self.name
}
#[must_use]
pub const fn symbol(&self) -> &Label {
&self.symbol
}
#[must_use]
pub const fn market_cap_rank(&self) -> &Option<u64> {
&self.market_cap_rank
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PriceQuote {
id: Identifier,
currency: Currency,
availability: PriceAvailability,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
last_updated_at: Option<Timestamp>,
}
impl PriceQuote {
#[must_use]
pub const fn new(
id: Identifier,
currency: Currency,
availability: PriceAvailability,
last_updated_at: Option<Timestamp>,
) -> Self {
Self {
id,
currency,
availability,
last_updated_at,
}
}
#[must_use]
pub const fn id(&self) -> &Identifier {
&self.id
}
#[must_use]
pub const fn currency(&self) -> &Currency {
&self.currency
}
#[must_use]
pub const fn availability(&self) -> &PriceAvailability {
&self.availability
}
#[must_use]
pub const fn last_updated_at(&self) -> &Option<Timestamp> {
&self.last_updated_at
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CoinMarket {
id: Identifier,
name: Label,
symbol: Label,
currency: Currency,
values: MarketValues,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
market_cap_rank: Option<u64>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
last_updated: Option<UtcDateTime>,
}
impl CoinMarket {
#[must_use]
pub const fn new(
id: Identifier,
name: Label,
symbol: Label,
currency: Currency,
values: MarketValues,
market_cap_rank: Option<u64>,
last_updated: Option<UtcDateTime>,
) -> Self {
Self {
id,
name,
symbol,
currency,
values,
market_cap_rank,
last_updated,
}
}
#[must_use]
pub const fn id(&self) -> &Identifier {
&self.id
}
#[must_use]
pub const fn name(&self) -> &Label {
&self.name
}
#[must_use]
pub const fn symbol(&self) -> &Label {
&self.symbol
}
#[must_use]
pub const fn currency(&self) -> &Currency {
&self.currency
}
#[must_use]
pub const fn current_price(&self) -> &Option<NonnegativeDecimal> {
self.values.current_price()
}
#[must_use]
pub const fn market_cap(&self) -> &Option<NonnegativeDecimal> {
self.values.market_cap()
}
#[must_use]
pub const fn total_volume(&self) -> &Option<NonnegativeDecimal> {
self.values.total_volume()
}
#[must_use]
pub const fn market_cap_rank(&self) -> &Option<u64> {
&self.market_cap_rank
}
#[must_use]
pub const fn last_updated(&self) -> &Option<UtcDateTime> {
&self.last_updated
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChartPoint {
timestamp: UnixMilliseconds,
value: NonnegativeDecimal,
}
impl ChartPoint {
#[must_use]
pub const fn new(timestamp: UnixMilliseconds, value: NonnegativeDecimal) -> Self {
Self { timestamp, value }
}
#[must_use]
pub const fn timestamp(&self) -> &UnixMilliseconds {
&self.timestamp
}
#[must_use]
pub const fn value(&self) -> &NonnegativeDecimal {
&self.value
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SearchFields")]
pub struct SearchResults {
query: SearchQuery,
coins: Vec<SearchCoin>,
}
impl SearchResults {
pub fn new(query: SearchQuery, coins: Vec<SearchCoin>) -> Result<Self, Error> {
if coins.len() > 100_000 || !unique(coins.iter().map(SearchCoin::id)) {
return Err(ValidationError::InvalidMarketRecord.into());
}
Ok(Self { query, coins })
}
#[must_use]
pub const fn query(&self) -> &SearchQuery {
&self.query
}
#[must_use]
pub fn coins(&self) -> &[SearchCoin] {
&self.coins
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SearchFields {
query: SearchQuery,
coins: Vec<SearchCoin>,
}
impl TryFrom<SearchFields> for SearchResults {
type Error = Error;
fn try_from(v: SearchFields) -> Result<Self, Error> {
Self::new(v.query, v.coins)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PriceFields")]
pub struct Prices {
request: PricesRequest,
quotes: Vec<PriceQuote>,
}
impl Prices {
pub fn new(request: PricesRequest, quotes: Vec<PriceQuote>) -> Result<Self, Error> {
if quotes.len() != request.ids().len() * request.currencies().len()
|| request
.ids()
.iter()
.flat_map(|id| {
request
.currencies()
.iter()
.map(move |currency| (id, currency))
})
.zip("es)
.any(|((id, currency), q)| id != q.id() || currency != q.currency())
{
return Err(ValidationError::InvalidMarketRecord.into());
}
Ok(Self { request, quotes })
}
#[must_use]
pub const fn request(&self) -> &PricesRequest {
&self.request
}
#[must_use]
pub fn quotes(&self) -> &[PriceQuote] {
&self.quotes
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct PriceFields {
request: PricesRequest,
quotes: Vec<PriceQuote>,
}
impl TryFrom<PriceFields> for Prices {
type Error = Error;
fn try_from(v: PriceFields) -> Result<Self, Error> {
Self::new(v.request, v.quotes)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PageStatus {
ShortPage,
MayHaveMore,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "MarketsPageFields")]
pub struct MarketsPage {
request: MarketsRequest,
coins: Vec<CoinMarket>,
}
impl MarketsPage {
pub fn new(request: MarketsRequest, coins: Vec<CoinMarket>) -> Result<Self, Error> {
if coins.len() > usize::from(request.count())
|| !unique(coins.iter().map(CoinMarket::id))
|| coins.iter().any(|v| {
v.currency() != request.currency()
|| request.ids().is_some_and(|ids| !ids.contains(v.id()))
})
{
return Err(ValidationError::InvalidMarketRecord.into());
}
Ok(Self { request, coins })
}
#[must_use]
pub const fn request(&self) -> &MarketsRequest {
&self.request
}
#[must_use]
pub fn coins(&self) -> &[CoinMarket] {
&self.coins
}
#[must_use]
pub fn status(&self) -> PageStatus {
if self.coins.len() == usize::from(self.request.count()) {
PageStatus::MayHaveMore
} else {
PageStatus::ShortPage
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct MarketsPageFields {
request: MarketsRequest,
coins: Vec<CoinMarket>,
}
impl TryFrom<MarketsPageFields> for MarketsPage {
type Error = Error;
fn try_from(v: MarketsPageFields) -> Result<Self, Error> {
Self::new(v.request, v.coins)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryFields")]
pub struct HistoricalChart {
request: HistoryRequest,
prices: Vec<ChartPoint>,
market_caps: Vec<ChartPoint>,
total_volumes: Vec<ChartPoint>,
}
impl HistoricalChart {
pub fn new(
request: HistoryRequest,
prices: Vec<ChartPoint>,
market_caps: Vec<ChartPoint>,
total_volumes: Vec<ChartPoint>,
) -> Result<Self, Error> {
let from = request.from_unix_seconds() * 1000;
let to = request.to_unix_seconds() * 1000;
if [&prices, &market_caps, &total_volumes].iter().any(|v| {
v.len() > 100_000
|| v.iter()
.any(|p| !(from..=to).contains(&p.timestamp().get()))
|| v.windows(2).any(|p| p[0].timestamp() >= p[1].timestamp())
}) {
return Err(ValidationError::InvalidMarketRecord.into());
}
Ok(Self {
request,
prices,
market_caps,
total_volumes,
})
}
#[must_use]
pub const fn request(&self) -> &HistoryRequest {
&self.request
}
#[must_use]
pub fn prices(&self) -> &[ChartPoint] {
&self.prices
}
#[must_use]
pub fn market_caps(&self) -> &[ChartPoint] {
&self.market_caps
}
#[must_use]
pub fn total_volumes(&self) -> &[ChartPoint] {
&self.total_volumes
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryFields {
request: HistoryRequest,
prices: Vec<ChartPoint>,
market_caps: Vec<ChartPoint>,
total_volumes: Vec<ChartPoint>,
}
impl TryFrom<HistoryFields> for HistoricalChart {
type Error = Error;
fn try_from(v: HistoryFields) -> Result<Self, Error> {
Self::new(v.request, v.prices, v.market_caps, v.total_volumes)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MarketValues {
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
current_price: Option<NonnegativeDecimal>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
market_cap: Option<NonnegativeDecimal>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
total_volume: Option<NonnegativeDecimal>,
}
impl MarketValues {
#[must_use]
pub const fn new(
current_price: Option<NonnegativeDecimal>,
market_cap: Option<NonnegativeDecimal>,
total_volume: Option<NonnegativeDecimal>,
) -> Self {
Self {
current_price,
market_cap,
total_volume,
}
}
#[must_use]
pub const fn current_price(&self) -> &Option<NonnegativeDecimal> {
&self.current_price
}
#[must_use]
pub const fn market_cap(&self) -> &Option<NonnegativeDecimal> {
&self.market_cap
}
#[must_use]
pub const fn total_volume(&self) -> &Option<NonnegativeDecimal> {
&self.total_volume
}
}