use crate::{
domain::solana::{Commitment, Pubkey, Signature},
error::Error,
};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct Cursor(String);
impl Cursor {
pub fn new(value: impl Into<String>) -> Result<Self, Error> {
let value = value.into();
if value.is_empty() || value.len() > 2048 || value.chars().any(char::is_control) {
return Err(super::bounded::invalid_request());
}
Ok(Self(value))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Cursor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Cursor { .. }")
}
}
impl TryFrom<String> for Cursor {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Cursor> for String {
fn from(v: Cursor) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SortDirection {
Asc,
Desc,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AssetSort {
Id,
Created,
RecentAction,
Updated,
None,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum AssetPosition {
Page {
page: u32,
},
Cursor {
cursor: Option<Cursor>,
},
Range {
before: Option<Pubkey>,
after: Option<Pubkey>,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetOptions {
pub show_unverified_collections: bool,
pub show_collection_metadata: bool,
pub show_fungible: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetRequest {
pub id: Pubkey,
pub options: AssetOptions,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "OwnerRequestFields")]
pub struct OwnerRequest {
owner: Pubkey,
limit: u16,
position: AssetPosition,
sort: AssetSort,
direction: SortDirection,
options: AssetOptions,
show_grand_total: bool,
show_native_balance: bool,
show_zero_balance: bool,
}
impl OwnerRequest {
#[allow(clippy::too_many_arguments)]
pub fn new(
owner: Pubkey,
limit: u16,
position: AssetPosition,
sort: AssetSort,
direction: SortDirection,
options: AssetOptions,
show_grand_total: bool,
show_native_balance: bool,
show_zero_balance: bool,
) -> Result<Self, Error> {
if !(1..=1000).contains(&limit) {
return Err(super::bounded::invalid_request());
}
match &position {
AssetPosition::Page { page: 0 } => return Err(super::bounded::invalid_request()),
AssetPosition::Range { before, after }
if before.is_none() && after.is_none()
|| before
.zip(*after)
.is_some_and(|(b, a)| a.bytes() >= b.bytes()) =>
{
return Err(super::bounded::invalid_request());
}
_ => {}
}
if !matches!(position, AssetPosition::Page { .. }) && sort != AssetSort::Id {
return Err(super::bounded::invalid_request());
}
Ok(Self {
owner,
limit,
position,
sort,
direction,
options,
show_grand_total,
show_native_balance,
show_zero_balance,
})
}
#[must_use]
pub const fn owner(&self) -> Pubkey {
self.owner
}
#[must_use]
pub const fn limit(&self) -> u16 {
self.limit
}
#[must_use]
pub const fn position(&self) -> &AssetPosition {
&self.position
}
#[must_use]
pub const fn sort(&self) -> AssetSort {
self.sort
}
#[must_use]
pub const fn direction(&self) -> SortDirection {
self.direction
}
#[must_use]
pub const fn options(&self) -> AssetOptions {
self.options
}
#[must_use]
pub const fn show_grand_total(&self) -> bool {
self.show_grand_total
}
#[must_use]
pub const fn show_native_balance(&self) -> bool {
self.show_native_balance
}
#[must_use]
pub const fn show_zero_balance(&self) -> bool {
self.show_zero_balance
}
pub fn with_cursor(&self, cursor: Cursor) -> Result<Self, Error> {
if !matches!(self.position, AssetPosition::Cursor { .. }) {
return Err(super::bounded::invalid_request());
}
let mut next = self.clone();
next.position = AssetPosition::Cursor {
cursor: Some(cursor),
};
Ok(next)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct OwnerRequestFields {
owner: Pubkey,
limit: u16,
position: AssetPosition,
sort: AssetSort,
direction: SortDirection,
options: AssetOptions,
show_grand_total: bool,
show_native_balance: bool,
show_zero_balance: bool,
}
impl TryFrom<OwnerRequestFields> for OwnerRequest {
type Error = Error;
fn try_from(f: OwnerRequestFields) -> Result<Self, Error> {
Self::new(
f.owner,
f.limit,
f.position,
f.sort,
f.direction,
f.options,
f.show_grand_total,
f.show_native_balance,
f.show_zero_balance,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ParseRequestFields")]
pub struct ParseRequest {
signatures: Vec<Signature>,
commitment: Commitment,
}
impl ParseRequest {
pub fn new(signatures: Vec<Signature>, commitment: Commitment) -> Result<Self, Error> {
if signatures.is_empty() || signatures.len() > 100 || commitment == Commitment::Processed {
return Err(super::bounded::invalid_request());
}
Ok(Self {
signatures,
commitment,
})
}
#[must_use]
pub fn signatures(&self) -> &[Signature] {
&self.signatures
}
#[must_use]
pub const fn commitment(&self) -> Commitment {
self.commitment
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ParseRequestFields {
#[serde(deserialize_with = "super::bounded::list")]
signatures: Vec<Signature>,
commitment: Commitment,
}
impl TryFrom<ParseRequestFields> for ParseRequest {
type Error = Error;
fn try_from(f: ParseRequestFields) -> Result<Self, Error> {
Self::new(f.signatures, f.commitment)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "BoundsFields")]
pub struct Bounds {
gt: Option<u64>,
gte: Option<u64>,
lt: Option<u64>,
lte: Option<u64>,
}
impl Bounds {
pub fn new(
gt: Option<u64>,
gte: Option<u64>,
lt: Option<u64>,
lte: Option<u64>,
) -> Result<Self, Error> {
if gt.is_none() && gte.is_none() && lt.is_none() && lte.is_none()
|| gt.is_some() && gte.is_some()
|| lt.is_some() && lte.is_some()
{
return Err(super::bounded::invalid_request());
}
let min = match gt {
Some(v) => v
.checked_add(1)
.ok_or_else(super::bounded::invalid_request)?,
None => gte.unwrap_or(0),
};
let max = match lt {
Some(v) => v
.checked_sub(1)
.ok_or_else(super::bounded::invalid_request)?,
None => lte.unwrap_or(u64::MAX),
};
if min > max {
return Err(super::bounded::invalid_request());
}
Ok(Self { gt, gte, lt, lte })
}
#[must_use]
pub const fn comparisons(self) -> [Option<u64>; 4] {
[self.gt, self.gte, self.lt, self.lte]
}
pub(super) fn contains(self, value: u64) -> bool {
self.gt.is_none_or(|v| value > v)
&& self.gte.is_none_or(|v| value >= v)
&& self.lt.is_none_or(|v| value < v)
&& self.lte.is_none_or(|v| value <= v)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct BoundsFields {
gt: Option<u64>,
gte: Option<u64>,
lt: Option<u64>,
lte: Option<u64>,
}
impl TryFrom<BoundsFields> for Bounds {
type Error = Error;
fn try_from(f: BoundsFields) -> Result<Self, Error> {
Self::new(f.gt, f.gte, f.lt, f.lte)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryRequestFields")]
pub struct HistoryRequest {
address: Pubkey,
limit: u8,
commitment: Commitment,
direction: SortDirection,
before_signature: Option<Signature>,
after_signature: Option<Signature>,
slot: Option<Bounds>,
time: Option<Bounds>,
pagination_token: Option<Cursor>,
}
impl HistoryRequest {
#[allow(clippy::too_many_arguments)]
pub fn new(
address: Pubkey,
limit: u8,
commitment: Commitment,
direction: SortDirection,
before_signature: Option<Signature>,
after_signature: Option<Signature>,
slot: Option<Bounds>,
time: Option<Bounds>,
pagination_token: Option<Cursor>,
) -> Result<Self, Error> {
if !(1..=100).contains(&limit)
|| commitment == Commitment::Processed
|| before_signature
.zip(after_signature)
.is_some_and(|(a, b)| a == b)
{
return Err(super::bounded::invalid_request());
}
Ok(Self {
address,
limit,
commitment,
direction,
before_signature,
after_signature,
slot,
time,
pagination_token,
})
}
#[must_use]
pub const fn address(&self) -> Pubkey {
self.address
}
#[must_use]
pub const fn limit(&self) -> u8 {
self.limit
}
#[must_use]
pub const fn commitment(&self) -> Commitment {
self.commitment
}
#[must_use]
pub const fn direction(&self) -> SortDirection {
self.direction
}
#[must_use]
pub const fn signatures(&self) -> [Option<Signature>; 2] {
[self.before_signature, self.after_signature]
}
#[must_use]
pub const fn slot(&self) -> Option<Bounds> {
self.slot
}
#[must_use]
pub const fn time(&self) -> Option<Bounds> {
self.time
}
#[must_use]
pub const fn pagination_token(&self) -> Option<&Cursor> {
self.pagination_token.as_ref()
}
#[must_use]
pub fn with_token(&self, token: Cursor) -> Self {
let mut next = self.clone();
next.pagination_token = Some(token);
next
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryRequestFields {
address: Pubkey,
limit: u8,
commitment: Commitment,
direction: SortDirection,
before_signature: Option<Signature>,
after_signature: Option<Signature>,
slot: Option<Bounds>,
time: Option<Bounds>,
pagination_token: Option<Cursor>,
}
impl TryFrom<HistoryRequestFields> for HistoryRequest {
type Error = Error;
fn try_from(f: HistoryRequestFields) -> Result<Self, Error> {
Self::new(
f.address,
f.limit,
f.commitment,
f.direction,
f.before_signature,
f.after_signature,
f.slot,
f.time,
f.pagination_token,
)
}
}