use super::{Address, Amount, ChainId, OperationContext, OperationValue, ReadOperation, ReadState};
use crate::error::{Error, ValidationError};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "BalanceFields")]
pub struct Erc20Balance {
chain_id: ChainId,
contract: Address,
owner: Address,
amount: Amount,
}
impl Erc20Balance {
#[must_use]
pub const fn new(
chain_id: ChainId,
contract: Address,
owner: Address,
raw: super::U256,
) -> Self {
Self {
chain_id,
contract,
owner,
amount: Amount::new(raw, None),
}
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn contract(&self) -> Address {
self.contract
}
#[must_use]
pub const fn owner(&self) -> Address {
self.owner
}
#[must_use]
pub const fn amount(&self) -> Amount {
self.amount
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct BalanceFields {
chain_id: ChainId,
contract: Address,
owner: Address,
amount: Amount,
}
impl TryFrom<BalanceFields> for Erc20Balance {
type Error = Error;
fn try_from(v: BalanceFields) -> Result<Self, Error> {
if v.amount.decimals().is_some() {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self::new(v.chain_id, v.contract, v.owner, v.amount.raw()))
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AllowanceFields")]
pub struct Erc20Allowance {
chain_id: ChainId,
contract: Address,
owner: Address,
spender: Address,
amount: Amount,
}
impl Erc20Allowance {
#[must_use]
pub const fn new(
chain_id: ChainId,
contract: Address,
owner: Address,
spender: Address,
raw: super::U256,
) -> Self {
Self {
chain_id,
contract,
owner,
spender,
amount: Amount::new(raw, None),
}
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn contract(&self) -> Address {
self.contract
}
#[must_use]
pub const fn owner(&self) -> Address {
self.owner
}
#[must_use]
pub const fn spender(&self) -> Address {
self.spender
}
#[must_use]
pub const fn amount(&self) -> Amount {
self.amount
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct AllowanceFields {
chain_id: ChainId,
contract: Address,
owner: Address,
spender: Address,
amount: Amount,
}
impl TryFrom<AllowanceFields> for Erc20Allowance {
type Error = Error;
fn try_from(v: AllowanceFields) -> Result<Self, Error> {
if v.amount.decimals().is_some() {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self::new(
v.chain_id,
v.contract,
v.owner,
v.spender,
v.amount.raw(),
))
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct MetadataText(String);
impl MetadataText {
pub const MAX_BYTES: usize = 4096;
pub fn new(value: String) -> Result<Self, Error> {
if value.len() > Self::MAX_BYTES {
return Err(ValidationError::InvalidEvmMetadata.into());
}
Ok(Self(value))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for MetadataText {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MetadataText").finish_non_exhaustive()
}
}
impl Serialize for MetadataText {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for MetadataText {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::new(String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MetadataUnavailable {
Unsupported,
StateUnavailable,
NullResult,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "status",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum MetadataValue<T> {
Available(T),
Reverted,
Unavailable(MetadataUnavailable),
InvalidAbi,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Erc20Metadata {
chain_id: ChainId,
contract: Address,
name: MetadataValue<MetadataText>,
symbol: MetadataValue<MetadataText>,
decimals: MetadataValue<u8>,
}
impl Erc20Metadata {
#[must_use]
pub const fn new(
chain_id: ChainId,
contract: Address,
name: MetadataValue<MetadataText>,
symbol: MetadataValue<MetadataText>,
decimals: MetadataValue<u8>,
) -> Self {
Self {
chain_id,
contract,
name,
symbol,
decimals,
}
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn contract(&self) -> Address {
self.contract
}
#[must_use]
pub const fn name(&self) -> &MetadataValue<MetadataText> {
&self.name
}
#[must_use]
pub const fn symbol(&self) -> &MetadataValue<MetadataText> {
&self.symbol
}
#[must_use]
pub const fn decimals(&self) -> &MetadataValue<u8> {
&self.decimals
}
}
fn validate_token(
chain: ChainId,
operation: ReadOperation,
c: &OperationContext,
) -> Result<(), Error> {
if c.operation() != operation {
return Err(ValidationError::ObservationOperationMismatch.into());
}
if c.network().chain_id() != chain {
return Err(ValidationError::NetworkMismatch.into());
}
if !matches!(c.state(), ReadState::CanonicalHash { .. }) {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(())
}
impl OperationValue for Erc20Balance {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_token(self.chain_id, ReadOperation::Erc20Balance, c)
}
}
impl OperationValue for Erc20Allowance {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_token(self.chain_id, ReadOperation::Erc20Allowance, c)
}
}
impl OperationValue for Erc20Metadata {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_token(self.chain_id, ReadOperation::Erc20Metadata, c)
}
}