use std::collections::HashSet;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use super::{
AssetId, AssetKind, Hash, Network, NetworkId, PageRequest, PageStatus, PaymentAddress,
StakeAddress,
};
use crate::{
domain::{Amount, ExactDecimal, U256},
error::{Error, ValidationError},
};
pub(super) fn invalid() -> Error {
ValidationError::InvalidCardanoRecord.into()
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Lovelace(U256);
impl Lovelace {
#[must_use]
pub const fn new(raw: U256) -> Self {
Self(raw)
}
pub fn parse(text: &str) -> Result<Self, Error> {
if text.is_empty()
|| text.len() > 78
|| !text.bytes().all(|b| b.is_ascii_digit())
|| (text.len() > 1 && text.starts_with('0'))
{
return Err(invalid());
}
Ok(Self(Amount::from_decimal(text, None)?.raw()))
}
#[must_use]
pub const fn raw(self) -> U256 {
self.0
}
#[must_use]
pub const fn amount(self) -> Amount {
Amount::new(self.0, Some(6))
}
pub fn payment_coin(self) -> Result<u64, Error> {
u64::try_from(self.0).map_err(|_| ValidationError::CardanoAmountOverflow.into())
}
}
impl Serialize for Lovelace {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.collect_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Lovelace {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct SourceText(String);
impl SourceText {
pub fn new(text: impl Into<String>) -> Result<Self, Error> {
let text = text.into();
if text.len() > 4096 {
return Err(invalid());
}
Ok(Self(text))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<String> for SourceText {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<SourceText> for String {
fn from(v: SourceText) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "epoch",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum EpochSelector {
Latest,
Number(u64),
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NetworkSupply {
pub maximum: Lovelace,
pub total: Lovelace,
pub circulating: Lovelace,
pub locked: Lovelace,
pub treasury: Lovelace,
pub reserves: Lovelace,
pub live_stake: Lovelace,
pub active_stake: Lovelace,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EpochData {
pub epoch: u64,
pub start_unix_seconds: u64,
pub end_unix_seconds: u64,
pub first_block_unix_seconds: u64,
pub last_block_unix_seconds: u64,
pub block_count: u64,
pub transaction_count: u64,
pub output: Lovelace,
pub fees: Lovelace,
pub active_stake: Option<Lovelace>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PaymentParameters {
pub epoch: u64,
pub min_fee_coefficient: u64,
pub min_fee_constant: u64,
pub max_transaction_bytes: u32,
pub max_value_bytes: Option<u32>,
pub coins_per_utxo_size: Option<u64>,
pub protocol_major: u64,
pub protocol_minor: u64,
pub key_deposit: Lovelace,
pub pool_deposit: Lovelace,
pub script_memory_price: Option<ExactDecimal>,
pub script_step_price: Option<ExactDecimal>,
}
macro_rules! record {
($name:ident,$fields:ident,$data:ty,$doc:literal,$check:expr) => {
#[doc=$doc]
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct $name {
network: Network,
data: $data,
}
impl $name {
pub fn new(network: Network, data: $data) -> Result<Self, Error> {
let checked: Result<(), Error> = ($check)(&network, &data);
checked?;
Ok(Self { network, data })
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn data(&self) -> &$data {
&self.data
}
}
impl<'de> Deserialize<'de> for $name {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = $fields::deserialize(d)?;
Self::new(v.network, v.data).map_err(serde::de::Error::custom)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct $fields {
network: Network,
data: $data,
}
impl TryFrom<$fields> for $name {
type Error = Error;
fn try_from(v: $fields) -> Result<Self, Error> {
Self::new(v.network, v.data)
}
}
};
}
record!(
NetworkData,
NetworkDataFields,
NetworkSupply,
"Current indexed Cardano supply and stake with expected network attribution.",
|_: &Network, _: &NetworkSupply| Ok(())
);
record!(
Epoch,
EpochFields,
EpochData,
"Indexed facts for a source-selected epoch.",
|_: &Network, d: &EpochData| {
if d.start_unix_seconds >= d.end_unix_seconds {
Err(invalid())
} else {
Ok(())
}
}
);
record!(
ProtocolParameters,
ProtocolParametersFields,
PaymentParameters,
"Indexed source protocol parameters used by explicit pure payment profiles.",
|_: &Network, d: &PaymentParameters| {
if d.max_transaction_bytes == 0
|| d.script_memory_price
.as_ref()
.is_some_and(ExactDecimal::is_negative)
|| d.script_step_price
.as_ref()
.is_some_and(ExactDecimal::is_negative)
{
Err(invalid())
} else {
Ok(())
}
}
);
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AddressData {
pub balance: super::AddressBalance,
pub stake_address: Option<StakeAddress>,
pub address_kind: IndexedAddressKind,
pub script: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum IndexedAddressKind {
Byron,
Shelley,
}
record!(
AddressDetails,
AddressDetailsFields,
AddressData,
"Indexed address facts and balances retained for the exact requested address.",
|n: &Network, d: &AddressData| {
if d.balance.network().identity() != n.identity()
|| d.stake_address
.as_ref()
.is_some_and(|a| !a.is_compatible_with(n.identity()))
{
return Err(ValidationError::NetworkMismatch.into());
}
let address = d.balance.address().bytes();
let kind = address[0] >> 4;
if d.script != matches!(kind, 1 | 3 | 5 | 7)
|| (d.address_kind == IndexedAddressKind::Byron) != (kind == 8)
{
return Err(invalid());
}
if d.stake_address.is_some() && kind >= 6 {
return Err(invalid());
}
if let Some(stake) = &d.stake_address
&& kind <= 3
{
let expected_header =
if matches!(kind, 2 | 3) { 0xf0 } else { 0xe0 } | (address[0] & 15);
if stake.bytes()[0] != expected_header || stake.bytes()[1..] != address[29..] {
return Err(invalid());
}
}
Ok(())
}
);
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct PoolId(String);
impl PoolId {
pub fn parse(text: &str) -> Result<Self, Error> {
if text.len() > 100 {
return Err(invalid());
}
let (hrp, bytes) = bech32::decode(text).map_err(|_| invalid())?;
let canonical = bech32::encode::<bech32::Bech32>(hrp, &bytes).map_err(|_| invalid())?;
if hrp.as_str() != "pool" || bytes.len() != 28 || canonical != text {
return Err(invalid());
}
Ok(Self(canonical))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<String> for PoolId {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::parse(&v)
}
}
impl From<PoolId> for String {
fn from(v: PoolId) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct DrepId(String);
impl DrepId {
pub fn parse(text: &str) -> Result<Self, Error> {
if text.len() > 100 {
return Err(invalid());
}
if matches!(text, "drep_always_abstain" | "drep_always_no_confidence") {
return Ok(Self(text.into()));
}
let (hrp, bytes) = bech32::decode(text).map_err(|_| invalid())?;
let canonical = bech32::encode::<bech32::Bech32>(hrp, &bytes).map_err(|_| invalid())?;
let valid = (bytes.len() == 28 && matches!(hrp.as_str(), "drep" | "drep_script"))
|| (bytes.len() == 29 && hrp.as_str() == "drep" && matches!(bytes[0], 0x22 | 0x23));
if !valid || canonical != text {
return Err(invalid());
}
Ok(Self(canonical))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<String> for DrepId {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::parse(&v)
}
}
impl From<DrepId> for String {
fn from(v: DrepId) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StakeAccountData {
pub address: StakeAddress,
pub active: bool,
pub registered: bool,
pub active_epoch: Option<u64>,
pub controlled: Lovelace,
pub rewards: Lovelace,
pub withdrawals: Lovelace,
pub reserves: Lovelace,
pub treasury: Lovelace,
pub withdrawable: Lovelace,
pub pool: Option<PoolId>,
pub drep: Option<DrepId>,
}
record!(
StakeAccount,
StakeAccountFields,
StakeAccountData,
"Exact indexed stake/account facts without manufacturing zero rewards or delegation.",
|n: &Network, d: &StakeAccountData| {
if !d.address.is_compatible_with(n.identity()) {
return Err(ValidationError::NetworkMismatch.into());
}
Ok(())
}
);
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TokenMetadata {
pub name: SourceText,
pub description: SourceText,
pub ticker: Option<SourceText>,
pub url: Option<SourceText>,
pub decimals: Option<u8>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MetadataAvailability {
Unreported,
Null,
PresentUninterpreted,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetData {
pub asset: AssetId,
pub quantity: Amount,
pub initial_mint: Hash,
pub mint_or_burn_count: u64,
pub metadata: Option<TokenMetadata>,
pub onchain_metadata: MetadataAvailability,
}
record!(
AssetDetails,
AssetDetailsFields,
AssetData,
"Indexed asset quantity/provenance/display data correlated with its requested identity.",
|n: &Network, d: &AssetData| {
if d.asset.network() != n.identity() {
return Err(ValidationError::NetworkMismatch.into());
}
if matches!(d.asset.asset(), AssetKind::Native) || d.quantity.decimals().is_some() {
return Err(invalid());
}
Ok(())
}
);
pub fn asset_fingerprint(asset: &AssetId) -> Result<String, Error> {
let AssetKind::Token {
policy_id,
asset_name,
} = asset.asset()
else {
return Err(invalid());
};
let mut bytes = policy_id.bytes().to_vec();
bytes.extend_from_slice(asset_name.bytes());
let digest = pallas_crypto::hash::Hasher::<160>::hash(&bytes);
bech32::encode::<bech32::Bech32>(
bech32::Hrp::parse("asset").map_err(|_| invalid())?,
digest.as_ref(),
)
.map_err(|_| invalid())
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionReference {
pub transaction_id: Hash,
pub index: u32,
pub block_height: u64,
pub block_unix_seconds: u64,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetEntry {
pub asset: AssetId,
pub quantity: Amount,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetHolder {
pub address: PaymentAddress,
pub quantity: Amount,
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RewardKind {
Leader,
Member,
PoolDepositRefund,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Reward {
pub epoch: u64,
pub amount: Lovelace,
pub pool: PoolId,
pub kind: RewardKind,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum PageTarget {
Assets,
AddressTransactions {
address: PaymentAddress,
},
AssetTransactions {
asset: AssetId,
},
AssetHolders {
asset: AssetId,
},
Rewards {
address: StakeAddress,
},
}
pub trait PageItem {
fn validate(&self, target: &PageTarget, network: NetworkId) -> Result<String, Error>;
}
impl PageItem for AssetEntry {
fn validate(&self, target: &PageTarget, network: NetworkId) -> Result<String, Error> {
if !matches!(target, PageTarget::Assets)
|| self.asset.network() != network
|| matches!(self.asset.asset(), AssetKind::Native)
|| self.quantity.decimals().is_some()
{
return Err(invalid());
}
Ok(asset_unit(&self.asset))
}
}
impl PageItem for TransactionReference {
fn validate(&self, target: &PageTarget, _: NetworkId) -> Result<String, Error> {
if !matches!(
target,
PageTarget::AddressTransactions { .. } | PageTarget::AssetTransactions { .. }
) {
return Err(invalid());
}
Ok(self.transaction_id.to_string())
}
}
impl PageItem for AssetHolder {
fn validate(&self, target: &PageTarget, network: NetworkId) -> Result<String, Error> {
if !matches!(target, PageTarget::AssetHolders { .. })
|| !self.address.is_compatible_with(network)
|| self.quantity.decimals().is_some()
{
return Err(invalid());
}
Ok(self.address.to_string())
}
}
impl PageItem for Reward {
fn validate(&self, target: &PageTarget, _: NetworkId) -> Result<String, Error> {
if !matches!(target, PageTarget::Rewards { .. }) {
return Err(invalid());
}
Ok(format!(
"{}:{}:{:?}",
self.epoch,
self.pool.as_str(),
self.kind
))
}
}
pub(crate) fn asset_unit(asset: &AssetId) -> String {
match asset.asset() {
AssetKind::Native => "lovelace".into(),
AssetKind::Token {
policy_id,
asset_name,
} => format!("{policy_id}{asset_name}"),
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct IndexPage<T> {
network: Network,
target: PageTarget,
request: PageRequest,
status: PageStatus,
items: Vec<T>,
}
impl<T: PageItem> IndexPage<T> {
pub fn new(
network: Network,
target: PageTarget,
request: PageRequest,
items: Vec<T>,
) -> Result<Self, Error> {
match &target {
PageTarget::AddressTransactions { address }
if !address.is_compatible_with(network.identity()) =>
{
return Err(ValidationError::NetworkMismatch.into());
}
PageTarget::Rewards { address } if !address.is_compatible_with(network.identity()) => {
return Err(ValidationError::NetworkMismatch.into());
}
PageTarget::AssetTransactions { asset } | PageTarget::AssetHolders { asset }
if asset.network() != network.identity()
|| matches!(asset.asset(), AssetKind::Native) =>
{
return Err(invalid());
}
_ => {}
}
if items.len() > usize::from(request.count()) {
return Err(invalid());
}
let mut keys = HashSet::new();
for item in &items {
if !keys.insert(item.validate(&target, network.identity())?) {
return Err(invalid());
}
}
let status = if items.len() == usize::from(request.count()) {
PageStatus::MayHaveMore
} else {
PageStatus::ShortPage
};
Ok(Self {
network,
target,
request,
status,
items,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn target(&self) -> &PageTarget {
&self.target
}
#[must_use]
pub const fn request(&self) -> PageRequest {
self.request
}
#[must_use]
pub const fn status(&self) -> PageStatus {
self.status
}
#[must_use]
pub fn items(&self) -> &[T] {
&self.items
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(bound(deserialize = "T: Deserialize<'de>"))]
struct IndexPageFields<T> {
network: Network,
target: PageTarget,
request: PageRequest,
status: PageStatus,
#[serde(deserialize_with = "page_items")]
items: Vec<T>,
}
fn page_items<'de, D: Deserializer<'de>, T: Deserialize<'de>>(d: D) -> Result<Vec<T>, D::Error> {
super::value::bounded_values::<D, T, 100>(d)
}
impl<'de, T: PageItem + Deserialize<'de>> Deserialize<'de> for IndexPage<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = IndexPageFields::<T>::deserialize(d)?;
let page =
Self::new(v.network, v.target, v.request, v.items).map_err(serde::de::Error::custom)?;
if page.status != v.status {
return Err(serde::de::Error::custom(invalid()));
}
Ok(page)
}
}