use std::{collections::HashSet, fmt};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
use crate::{
domain::{Amount, U256},
error::{Error, ValidationError},
};
use super::{AssetId, AssetKind, Hash, Network, NetworkId, PaymentAddress, ScriptHash};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AssetAmountFields")]
pub struct AssetAmount {
asset_id: AssetId,
amount: Amount,
}
impl AssetAmount {
pub fn new(asset_id: AssetId, raw: U256, decimals: Option<u8>) -> Result<Self, Error> {
if matches!(asset_id.asset(), AssetKind::Native) && decimals != Some(6) {
return Err(ValidationError::DecimalMismatch.into());
}
Ok(Self {
asset_id,
amount: Amount::new(raw, decimals),
})
}
#[must_use]
pub const fn asset_id(&self) -> &AssetId {
&self.asset_id
}
#[must_use]
pub const fn amount(&self) -> &Amount {
&self.amount
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct AssetAmountFields {
asset_id: AssetId,
amount: Amount,
}
impl TryFrom<AssetAmountFields> for AssetAmount {
type Error = Error;
fn try_from(fields: AssetAmountFields) -> Result<Self, Error> {
Self::new(
fields.asset_id,
fields.amount.raw(),
fields.amount.decimals(),
)
}
}
pub(super) fn validate_assets(
values: &[AssetAmount],
network: NetworkId,
output: bool,
) -> Result<(), Error> {
if values.len() > 10_000 {
return Err(ValidationError::InvalidCardanoRecord.into());
}
let mut identities = HashSet::with_capacity(values.len());
for value in values {
if value.asset_id().network() != network {
return Err(ValidationError::NetworkMismatch.into());
}
if !identities.insert(value.asset_id()) {
return Err(ValidationError::InvalidCardanoRecord.into());
}
if output {
if value.amount().raw() > U256::from(u64::MAX) {
return Err(ValidationError::CardanoAmountOverflow.into());
}
if matches!(value.asset_id().asset(), AssetKind::Token { .. })
&& value.amount().raw().is_zero()
{
return Err(ValidationError::InvalidCardanoRecord.into());
}
}
}
if output
&& !values
.iter()
.any(|value| matches!(value.asset_id().asset(), AssetKind::Native))
{
return Err(ValidationError::InvalidCardanoRecord.into());
}
Ok(())
}
pub(super) fn bounded_values<'de, D, T, const MAX: usize>(
deserializer: D,
) -> Result<Vec<T>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
struct ValuesVisitor<T, const MAX: usize>(std::marker::PhantomData<T>);
impl<'de, T: Deserialize<'de>, const MAX: usize> de::Visitor<'de> for ValuesVisitor<T, MAX> {
type Value = Vec<T>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a bounded collection of Cardano records")
}
fn visit_seq<A: de::SeqAccess<'de>>(self, mut sequence: A) -> Result<Vec<T>, A::Error> {
let mut values = Vec::new();
while let Some(value) = sequence.next_element::<T>()? {
if values.len() == MAX {
return Err(de::Error::custom(ValidationError::InvalidCardanoRecord));
}
values.push(value);
}
Ok(values)
}
}
deserializer.deserialize_seq(ValuesVisitor::<T, MAX>(std::marker::PhantomData))
}
fn deserialize_assets<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Vec<AssetAmount>, D::Error> {
bounded_values::<D, AssetAmount, 10_000>(deserializer)
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AddressBalanceFields")]
pub struct AddressBalance {
network: Network,
address: PaymentAddress,
assets: Vec<AssetAmount>,
}
impl AddressBalance {
pub fn new(
network: Network,
address: PaymentAddress,
assets: Vec<AssetAmount>,
) -> Result<Self, Error> {
if !address.is_compatible_with(network.identity()) {
return Err(ValidationError::NetworkMismatch.into());
}
validate_assets(&assets, network.identity(), false)?;
Ok(Self {
network,
address,
assets,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn address(&self) -> &PaymentAddress {
&self.address
}
#[must_use]
pub fn assets(&self) -> &[AssetAmount] {
&self.assets
}
#[must_use]
pub fn native_amount(&self) -> Option<&Amount> {
self.assets
.iter()
.find(|value| matches!(value.asset_id().asset(), AssetKind::Native))
.map(AssetAmount::amount)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct AddressBalanceFields {
network: Network,
address: PaymentAddress,
#[serde(deserialize_with = "deserialize_assets")]
assets: Vec<AssetAmount>,
}
impl TryFrom<AddressBalanceFields> for AddressBalance {
type Error = Error;
fn try_from(fields: AddressBalanceFields) -> Result<Self, Error> {
Self::new(fields.network, fields.address, fields.assets)
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct HexData(Vec<u8>);
impl HexData {
pub const MAX_BYTES: usize = 1024 * 1024;
pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, Error> {
if bytes.len() > Self::MAX_BYTES {
return Err(ValidationError::InvalidCardanoRecord.into());
}
Ok(Self(bytes))
}
pub fn parse(value: &str) -> Result<Self, Error> {
if value.len() > Self::MAX_BYTES * 2
|| !value.len().is_multiple_of(2)
|| value.starts_with("0x")
|| value.starts_with("0X")
{
return Err(ValidationError::InvalidCardanoRecord.into());
}
Self::from_bytes(
const_hex::decode(value)
.map_err(|_| Error::from(ValidationError::InvalidCardanoRecord))?,
)
}
#[must_use]
pub fn bytes(&self) -> &[u8] {
&self.0
}
}
impl fmt::Debug for HexData {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HexData")
.field("bytes", &self.0.len())
.finish_non_exhaustive()
}
}
impl Serialize for HexData {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&const_hex::encode(&self.0))
}
}
impl<'de> Deserialize<'de> for HexData {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(deserializer)?).map_err(de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct OutputData {
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
datum_hash: Option<Hash>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
inline_datum: Option<HexData>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
reference_script_hash: Option<ScriptHash>,
}
impl OutputData {
#[must_use]
pub const fn new(
datum_hash: Option<Hash>,
inline_datum: Option<HexData>,
reference_script_hash: Option<ScriptHash>,
) -> Self {
Self {
datum_hash,
inline_datum,
reference_script_hash,
}
}
#[must_use]
pub const fn datum_hash(&self) -> Option<Hash> {
self.datum_hash
}
#[must_use]
pub const fn inline_datum(&self) -> Option<&HexData> {
self.inline_datum.as_ref()
}
#[must_use]
pub const fn reference_script_hash(&self) -> Option<ScriptHash> {
self.reference_script_hash
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "UtxoFields")]
pub struct Utxo {
network: Network,
address: PaymentAddress,
transaction_id: Hash,
output_index: u16,
assets: Vec<AssetAmount>,
creation_block: Hash,
data: OutputData,
}
impl Utxo {
pub fn new(
network: Network,
address: PaymentAddress,
transaction_id: Hash,
output_index: u16,
assets: Vec<AssetAmount>,
creation_block: Hash,
data: OutputData,
) -> Result<Self, Error> {
if !address.is_compatible_with(network.identity()) {
return Err(ValidationError::NetworkMismatch.into());
}
validate_assets(&assets, network.identity(), true)?;
Ok(Self {
network,
address,
transaction_id,
output_index,
assets,
creation_block,
data,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn address(&self) -> &PaymentAddress {
&self.address
}
#[must_use]
pub const fn transaction_id(&self) -> Hash {
self.transaction_id
}
#[must_use]
pub const fn output_index(&self) -> u16 {
self.output_index
}
#[must_use]
pub fn assets(&self) -> &[AssetAmount] {
&self.assets
}
#[must_use]
pub const fn creation_block(&self) -> Hash {
self.creation_block
}
#[must_use]
pub const fn datum_hash(&self) -> Option<Hash> {
self.data.datum_hash()
}
#[must_use]
pub const fn inline_datum(&self) -> Option<&HexData> {
self.data.inline_datum()
}
#[must_use]
pub const fn reference_script_hash(&self) -> Option<ScriptHash> {
self.data.reference_script_hash()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct UtxoFields {
network: Network,
address: PaymentAddress,
transaction_id: Hash,
output_index: u16,
#[serde(deserialize_with = "deserialize_assets")]
assets: Vec<AssetAmount>,
creation_block: Hash,
data: OutputData,
}
impl TryFrom<UtxoFields> for Utxo {
type Error = Error;
fn try_from(fields: UtxoFields) -> Result<Self, Error> {
Self::new(
fields.network,
fields.address,
fields.transaction_id,
fields.output_index,
fields.assets,
fields.creation_block,
fields.data,
)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Order {
Asc,
Desc,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PageRequestFields")]
pub struct PageRequest {
page: u32,
count: u8,
order: Order,
}
impl PageRequest {
pub fn new(page: u32, count: u8, order: Order) -> Result<Self, Error> {
if !(1..=21_474_836).contains(&page) || !(1..=100).contains(&count) {
return Err(ValidationError::InvalidPageRequest.into());
}
Ok(Self { page, count, order })
}
#[must_use]
pub const fn page(self) -> u32 {
self.page
}
#[must_use]
pub const fn count(self) -> u8 {
self.count
}
#[must_use]
pub const fn order(self) -> Order {
self.order
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct PageRequestFields {
page: u32,
count: u8,
order: Order,
}
impl TryFrom<PageRequestFields> for PageRequest {
type Error = Error;
fn try_from(fields: PageRequestFields) -> Result<Self, Error> {
Self::new(fields.page, fields.count, fields.order)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PageStatus {
MayHaveMore,
ShortPage,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "UtxoPageFields")]
pub struct UtxoPage {
network: Network,
address: PaymentAddress,
requested_page: PageRequest,
status: PageStatus,
outputs: Vec<Utxo>,
}
impl UtxoPage {
pub fn new(
network: Network,
address: PaymentAddress,
requested_page: PageRequest,
outputs: Vec<Utxo>,
) -> Result<Self, Error> {
if !address.is_compatible_with(network.identity()) {
return Err(ValidationError::NetworkMismatch.into());
}
if outputs.len() > usize::from(requested_page.count()) {
return Err(ValidationError::InvalidCardanoRecord.into());
}
let mut outpoints = HashSet::with_capacity(outputs.len());
for output in &outputs {
if output.network().identity() != network.identity() {
return Err(ValidationError::NetworkMismatch.into());
}
if output.address() != &address
|| !outpoints.insert((output.transaction_id(), output.output_index()))
{
return Err(ValidationError::InvalidCardanoRecord.into());
}
}
let status = if outputs.len() == usize::from(requested_page.count()) {
PageStatus::MayHaveMore
} else {
PageStatus::ShortPage
};
Ok(Self {
network,
address,
requested_page,
status,
outputs,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn address(&self) -> &PaymentAddress {
&self.address
}
#[must_use]
pub const fn requested_page(&self) -> PageRequest {
self.requested_page
}
#[must_use]
pub const fn status(&self) -> PageStatus {
self.status
}
#[must_use]
pub fn outputs(&self) -> &[Utxo] {
&self.outputs
}
}
fn deserialize_outputs<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<Utxo>, D::Error> {
bounded_values::<D, Utxo, 100>(deserializer)
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct UtxoPageFields {
network: Network,
address: PaymentAddress,
requested_page: PageRequest,
status: PageStatus,
#[serde(deserialize_with = "deserialize_outputs")]
outputs: Vec<Utxo>,
}
impl TryFrom<UtxoPageFields> for UtxoPage {
type Error = Error;
fn try_from(fields: UtxoPageFields) -> Result<Self, Error> {
let value = Self::new(
fields.network,
fields.address,
fields.requested_page,
fields.outputs,
)?;
if value.status() != fields.status {
return Err(ValidationError::InvalidCardanoRecord.into());
}
Ok(value)
}
}