use super::{Cursor, MetadataValue, OwnerRequest, SourceText};
use crate::{
domain::{
ExactDecimal,
solana::{Hash, Pubkey},
},
error::Error,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetContent {
pub schema: Option<SourceText>,
pub json_uri: Option<SourceText>,
#[serde(deserialize_with = "super::bounded::optional_list")]
pub files: Option<Vec<AssetFile>>,
pub metadata: Option<MetadataValue>,
pub links: Option<MetadataValue>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetFile {
pub uri: Option<SourceText>,
pub cdn_uri: Option<SourceText>,
pub mime: Option<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetAuthority {
pub address: Pubkey,
#[serde(deserialize_with = "super::bounded::list")]
pub scopes: Vec<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Compression {
pub eligible: bool,
pub compressed: bool,
pub data_hash: Option<Hash>,
pub creator_hash: Option<Hash>,
pub asset_hash: Option<Hash>,
pub tree: Option<Pubkey>,
pub sequence: Option<u64>,
pub leaf_id: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Grouping {
pub key: SourceText,
pub value: SourceText,
pub verified: Option<bool>,
pub metadata: Option<MetadataValue>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Royalty {
pub model: SourceText,
pub target: Option<Pubkey>,
pub percent: ExactDecimal,
pub basis_points: u16,
pub primary_sale_happened: bool,
pub locked: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Creator {
pub address: Pubkey,
pub share: u8,
pub verified: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Ownership {
pub frozen: bool,
pub delegated: bool,
pub delegate: Option<Pubkey>,
pub model: SourceText,
pub owner: Option<Pubkey>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PrintSupply {
pub maximum: u64,
pub current: u64,
pub edition_nonce: Option<u8>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CachedPrice {
pub price_per_token: Option<ExactDecimal>,
pub total_price: Option<ExactDecimal>,
pub currency: SourceText,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TokenInfo {
pub supply: Option<u64>,
pub balance: Option<u64>,
pub decimals: Option<u8>,
pub token_program: Option<Pubkey>,
pub associated_token_address: Option<Pubkey>,
pub mint_authority: Option<Pubkey>,
pub freeze_authority: Option<Pubkey>,
pub symbol: Option<SourceText>,
pub price: Option<CachedPrice>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetData {
pub id: Pubkey,
pub last_indexed_slot: Option<u64>,
pub interface: SourceText,
pub content: Option<AssetContent>,
#[serde(deserialize_with = "super::bounded::optional_list")]
pub authorities: Option<Vec<AssetAuthority>>,
pub compression: Option<Compression>,
#[serde(deserialize_with = "super::bounded::optional_list")]
pub grouping: Option<Vec<Grouping>>,
pub royalty: Option<Royalty>,
#[serde(deserialize_with = "super::bounded::optional_list")]
pub creators: Option<Vec<Creator>>,
pub ownership: Option<Ownership>,
pub print_supply: Option<PrintSupply>,
pub mutable: Option<bool>,
pub burnt: Option<bool>,
pub token_info: Option<TokenInfo>,
pub is_agent: Option<bool>,
pub agent_token: Option<Pubkey>,
pub asset_signer: Option<Pubkey>,
#[serde(deserialize_with = "super::bounded::list")]
pub unsupported_extensions: Vec<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AssetData", into = "AssetData")]
pub struct Asset(AssetData);
impl Asset {
pub fn new(data: AssetData) -> Result<Self, Error> {
let one = ExactDecimal::parse("1")?;
if data.authorities.as_ref().is_some_and(|v| v.len() > 256)
|| data.grouping.as_ref().is_some_and(|v| v.len() > 256)
|| data.creators.as_ref().is_some_and(|v| v.len() > 256)
|| data.unsupported_extensions.len() > 128
|| data
.authorities
.as_ref()
.is_some_and(|v| v.iter().any(|a| a.scopes.len() > 64))
|| data
.content
.as_ref()
.is_some_and(|c| c.files.as_ref().is_some_and(|v| v.len() > 256))
|| data
.creators
.as_ref()
.is_some_and(|v| v.iter().any(|c| c.share > 100))
|| data.royalty.as_ref().is_some_and(|r| {
r.basis_points > 10000 || r.percent.is_negative() || r.percent > one
})
|| data
.token_info
.as_ref()
.and_then(|t| t.price.as_ref())
.is_some_and(|p| {
p.price_per_token
.as_ref()
.is_some_and(ExactDecimal::is_negative)
|| p.total_price
.as_ref()
.is_some_and(ExactDecimal::is_negative)
})
{
return Err(super::bounded::invalid_asset());
}
if let Some(r) = &data.royalty {
let expected = ExactDecimal::parse(&format!(
"{}.{:04}",
r.basis_points / 10000,
r.basis_points % 10000
))?;
if r.percent != expected {
return Err(super::bounded::invalid_asset());
}
}
if data
.print_supply
.as_ref()
.is_some_and(|s| s.maximum != 0 && s.current > s.maximum)
{
return Err(super::bounded::invalid_asset());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &AssetData {
&self.0
}
#[must_use]
pub const fn id(&self) -> Pubkey {
self.0.id
}
}
impl TryFrom<AssetData> for Asset {
type Error = Error;
fn try_from(d: AssetData) -> Result<Self, Error> {
Self::new(d)
}
}
impl From<Asset> for AssetData {
fn from(a: Asset) -> Self {
a.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NativeBalance {
pub lamports: u64,
pub price_per_sol: Option<ExactDecimal>,
pub total_price: Option<ExactDecimal>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "OwnerPageFields")]
pub struct OwnerPage {
request: OwnerRequest,
items: Vec<Asset>,
reported_total: u64,
reported_grand_total: Option<u64>,
reported_page: Option<u32>,
cursor: Option<Cursor>,
native_balance: Option<NativeBalance>,
}
impl OwnerPage {
pub fn new(
request: OwnerRequest,
items: Vec<Asset>,
reported_total: u64,
reported_grand_total: Option<u64>,
reported_page: Option<u32>,
cursor: Option<Cursor>,
native_balance: Option<NativeBalance>,
) -> Result<Self, Error> {
if let super::AssetPosition::Page { page } = request.position()
&& reported_page.is_some_and(|reported| reported != *page)
{
return Err(super::bounded::invalid_asset());
}
let mut ids = std::collections::BTreeSet::new();
if items.len() > usize::from(request.limit())
|| items.iter().any(|a| {
!ids.insert(a.id())
|| a.data().ownership.as_ref().is_some_and(|o| {
o.model.as_str() == "single"
&& o.owner.is_some_and(|owner| owner != request.owner())
})
})
|| native_balance.is_some() && !request.show_native_balance()
|| reported_grand_total.is_some() && !request.show_grand_total()
|| native_balance.as_ref().is_some_and(|b| {
b.price_per_sol
.as_ref()
.is_some_and(ExactDecimal::is_negative)
|| b.total_price
.as_ref()
.is_some_and(ExactDecimal::is_negative)
})
|| cursor.is_some()
&& !matches!(request.position(), super::AssetPosition::Cursor { .. })
{
return Err(super::bounded::invalid_asset());
}
if reported_total < items.len() as u64
|| reported_grand_total.is_some_and(|g| g < reported_total)
{
return Err(super::bounded::invalid_asset());
}
let mut prior: Option<[u8; 32]> = None;
for item in &items {
let id = item.id().bytes();
if let super::AssetPosition::Range { before, after } = request.position()
&& (before.is_some_and(|v| id >= v.bytes())
|| after.is_some_and(|v| id <= v.bytes()))
{
return Err(super::bounded::invalid_asset());
}
if request.sort() == super::AssetSort::Id
&& prior.is_some_and(|p| match request.direction() {
super::SortDirection::Asc => p >= id,
super::SortDirection::Desc => p <= id,
})
{
return Err(super::bounded::invalid_asset());
}
prior = Some(id);
}
Ok(Self {
request,
items,
reported_total,
reported_grand_total,
reported_page,
cursor,
native_balance,
})
}
#[must_use]
pub const fn request(&self) -> &OwnerRequest {
&self.request
}
#[must_use]
pub fn items(&self) -> &[Asset] {
&self.items
}
#[must_use]
pub const fn reported_total(&self) -> u64 {
self.reported_total
}
#[must_use]
pub const fn reported_grand_total(&self) -> Option<u64> {
self.reported_grand_total
}
#[must_use]
pub const fn reported_page(&self) -> Option<u32> {
self.reported_page
}
#[must_use]
pub const fn cursor(&self) -> Option<&Cursor> {
self.cursor.as_ref()
}
#[must_use]
pub const fn native_balance(&self) -> Option<&NativeBalance> {
self.native_balance.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct OwnerPageFields {
request: OwnerRequest,
#[serde(deserialize_with = "super::bounded::list")]
items: Vec<Asset>,
reported_total: u64,
reported_grand_total: Option<u64>,
reported_page: Option<u32>,
cursor: Option<Cursor>,
native_balance: Option<NativeBalance>,
}
impl TryFrom<OwnerPageFields> for OwnerPage {
type Error = Error;
fn try_from(f: OwnerPageFields) -> Result<Self, Error> {
Self::new(
f.request,
f.items,
f.reported_total,
f.reported_grand_total,
f.reported_page,
f.cursor,
f.native_balance,
)
}
}