use std::{fmt, str::FromStr};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::error::{Error, ValidationError};
use super::{Address, Amount, Asset, NetworkId};
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Timestamp(u64);
impl Timestamp {
#[must_use]
pub const fn from_unix_seconds(seconds: u64) -> Self {
Self(seconds)
}
#[must_use]
pub const fn unix_seconds(self) -> u64 {
self.0
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct BlockHash([u8; 32]);
impl BlockHash {
pub fn parse(value: &str) -> Result<Self, Error> {
let Some(payload) = value.strip_prefix("0x") else {
return Err(ValidationError::InvalidBlockHash.into());
};
if payload.len() != 64 || !payload.bytes().all(|byte| byte.is_ascii_hexdigit()) {
return Err(ValidationError::InvalidBlockHash.into());
}
const_hex::decode_to_array(payload)
.map(Self)
.map_err(|_| ValidationError::InvalidBlockHash.into())
}
#[must_use]
pub const fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
#[must_use]
pub const fn bytes(self) -> [u8; 32] {
self.0
}
}
impl FromStr for BlockHash {
type Err = Error;
fn from_str(value: &str) -> Result<Self, Self::Err> {
Self::parse(value)
}
}
impl fmt::Display for BlockHash {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&const_hex::encode_prefixed(self.0))
}
}
impl Serialize for BlockHash {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(self)
}
}
impl<'de> Deserialize<'de> for BlockHash {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Self::parse(&String::deserialize(deserializer)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", content = "value", rename_all = "snake_case")]
pub enum BlockSelector {
Latest,
Safe,
Finalized,
Number(u64),
Hash(BlockHash),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BlockContext {
number: u64,
hash: BlockHash,
timestamp: Timestamp,
}
impl BlockContext {
#[must_use]
pub const fn new(number: u64, hash: BlockHash, timestamp: Timestamp) -> Self {
Self {
number,
hash,
timestamp,
}
}
#[must_use]
pub const fn number(&self) -> u64 {
self.number
}
#[must_use]
pub const fn hash(&self) -> &BlockHash {
&self.hash
}
#[must_use]
pub const fn timestamp(&self) -> Timestamp {
self.timestamp
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Finality {
Unknown,
Safe,
Finalized,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SourceFields")]
pub struct Source {
provider_id: String,
method: String,
integration_version: String,
}
impl Source {
pub fn new(
provider_id: impl Into<String>,
method: impl Into<String>,
integration_version: impl Into<String>,
) -> Result<Self, Error> {
let source = Self {
provider_id: provider_id.into(),
method: method.into(),
integration_version: integration_version.into(),
};
if [
&source.provider_id,
&source.method,
&source.integration_version,
]
.iter()
.any(|value| !super::valid_label(value, 128))
{
return Err(ValidationError::InvalidSourceLabel.into());
}
Ok(source)
}
#[must_use]
pub fn provider_id(&self) -> &str {
&self.provider_id
}
#[must_use]
pub fn method(&self) -> &str {
&self.method
}
#[must_use]
pub fn integration_version(&self) -> &str {
&self.integration_version
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SourceFields {
provider_id: String,
method: String,
integration_version: String,
}
impl TryFrom<SourceFields> for Source {
type Error = Error;
fn try_from(fields: SourceFields) -> Result<Self, Self::Error> {
Self::new(
fields.provider_id,
fields.method,
fields.integration_version,
)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Operation {
NativeBalance,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ContextFields")]
pub struct ObservationContext {
schema_version: u16,
operation: Operation,
network: NetworkId,
requested_selector: BlockSelector,
block: BlockContext,
source: Source,
retrieved_at: Timestamp,
finality: Finality,
confirmations: Option<u64>,
}
impl ObservationContext {
pub fn new(
network: NetworkId,
requested_selector: BlockSelector,
block: BlockContext,
source: Source,
retrieved_at: Timestamp,
) -> Result<Self, Error> {
let mismatched = match requested_selector {
BlockSelector::Number(number) => number != block.number(),
BlockSelector::Hash(hash) => hash != *block.hash(),
BlockSelector::Latest | BlockSelector::Safe | BlockSelector::Finalized => false,
};
if mismatched {
return Err(ValidationError::BlockMismatch.into());
}
Ok(Self {
schema_version: 1,
operation: Operation::NativeBalance,
network,
requested_selector,
block,
source,
retrieved_at,
finality: Finality::Unknown,
confirmations: None,
})
}
#[must_use]
pub const fn with_finality(mut self, finality: Finality, confirmations: Option<u64>) -> Self {
self.finality = finality;
self.confirmations = confirmations;
self
}
#[must_use]
pub const fn schema_version(&self) -> u16 {
self.schema_version
}
#[must_use]
pub const fn operation(&self) -> Operation {
self.operation
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub const fn requested_selector(&self) -> &BlockSelector {
&self.requested_selector
}
#[must_use]
pub const fn block(&self) -> &BlockContext {
&self.block
}
#[must_use]
pub const fn source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn retrieved_at(&self) -> Timestamp {
self.retrieved_at
}
#[must_use]
pub const fn finality(&self) -> Finality {
self.finality
}
#[must_use]
pub const fn confirmations(&self) -> Option<u64> {
self.confirmations
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ContextFields {
schema_version: u16,
operation: Operation,
network: NetworkId,
requested_selector: BlockSelector,
block: BlockContext,
source: Source,
retrieved_at: Timestamp,
finality: Finality,
#[serde(deserialize_with = "super::deserialize_optional")]
confirmations: Option<u64>,
}
impl TryFrom<ContextFields> for ObservationContext {
type Error = Error;
fn try_from(fields: ContextFields) -> Result<Self, Self::Error> {
if fields.schema_version != 1 {
return Err(ValidationError::UnsupportedSchemaVersion.into());
}
let Operation::NativeBalance = fields.operation;
Self::new(
fields.network,
fields.requested_selector,
fields.block,
fields.source,
fields.retrieved_at,
)
.map(|context| context.with_finality(fields.finality, fields.confirmations))
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "BalanceFields")]
pub struct Balance {
address: Address,
asset: Asset,
amount: Amount,
}
impl Balance {
pub fn new(address: Address, asset: Asset, amount: Amount) -> Result<Self, Error> {
if amount.decimals() != Some(asset.decimals()) {
return Err(ValidationError::DecimalMismatch.into());
}
Ok(Self {
address,
asset,
amount,
})
}
#[must_use]
pub const fn address(&self) -> &Address {
&self.address
}
#[must_use]
pub const fn asset(&self) -> &Asset {
&self.asset
}
#[must_use]
pub const fn amount(&self) -> &Amount {
&self.amount
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct BalanceFields {
address: Address,
asset: Asset,
amount: Amount,
}
impl TryFrom<BalanceFields> for Balance {
type Error = Error;
fn try_from(fields: BalanceFields) -> Result<Self, Self::Error> {
Self::new(fields.address, fields.asset, fields.amount)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Observation<T> {
#[serde(flatten)]
context: ObservationContext,
value: T,
}
impl<T> Observation<T> {
#[must_use]
pub const fn value(&self) -> &T {
&self.value
}
#[must_use]
pub const fn context(&self) -> &ObservationContext {
&self.context
}
}
impl Observation<Balance> {
pub fn native_balance(value: Balance, context: ObservationContext) -> Result<Self, Error> {
if value.asset().network().chain_id() != context.network().chain_id() {
return Err(ValidationError::NetworkMismatch.into());
}
Ok(Self { context, value })
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct BalanceObservationFields {
schema_version: u16,
operation: Operation,
network: NetworkId,
requested_selector: BlockSelector,
block: BlockContext,
source: Source,
retrieved_at: Timestamp,
finality: Finality,
#[serde(deserialize_with = "super::deserialize_optional")]
confirmations: Option<u64>,
value: Balance,
}
impl<'de> Deserialize<'de> for Observation<Balance> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let fields = BalanceObservationFields::deserialize(deserializer)?;
let context = ObservationContext::try_from(ContextFields {
schema_version: fields.schema_version,
operation: fields.operation,
network: fields.network,
requested_selector: fields.requested_selector,
block: fields.block,
source: fields.source,
retrieved_at: fields.retrieved_at,
finality: fields.finality,
confirmations: fields.confirmations,
})
.map_err(serde::de::Error::custom)?;
Self::native_balance(fields.value, context).map_err(serde::de::Error::custom)
}
}