use std::{fmt, str::FromStr};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use super::U256;
use crate::{
domain::amount::parse_uint,
error::{Error, ValidationError},
};
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Quantity(U256);
impl Quantity {
#[must_use]
pub const fn new(value: U256) -> Self {
Self(value)
}
pub fn from_decimal(value: &str) -> Result<Self, Error> {
parse_uint(value).map(Self)
}
#[must_use]
pub const fn value(self) -> U256 {
self.0
}
}
impl From<u64> for Quantity {
fn from(value: u64) -> Self {
Self(U256::from(value))
}
}
impl Serialize for Quantity {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.collect_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Quantity {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::from_decimal(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TransactionId([u8; 32]);
impl TransactionId {
#[must_use]
pub const fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
pub fn parse(value: &str) -> Result<Self, Error> {
let payload = value
.strip_prefix("0x")
.ok_or(ValidationError::InvalidEvmTransactionId)?;
if payload.len() != 64 || !payload.bytes().all(|b| b.is_ascii_hexdigit()) {
return Err(ValidationError::InvalidEvmTransactionId.into());
}
const_hex::decode_to_array(payload)
.map(Self)
.map_err(|_| ValidationError::InvalidEvmTransactionId.into())
}
#[must_use]
pub const fn bytes(self) -> [u8; 32] {
self.0
}
}
impl FromStr for TransactionId {
type Err = Error;
fn from_str(v: &str) -> Result<Self, Error> {
Self::parse(v)
}
}
impl fmt::Display for TransactionId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&const_hex::encode_prefixed(self.0))
}
}
impl Serialize for TransactionId {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.collect_str(self)
}
}
impl<'de> Deserialize<'de> for TransactionId {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct Data(Vec<u8>);
impl Data {
pub const MAX_BYTES: usize = 1_048_576;
pub fn new(bytes: Vec<u8>) -> Result<Self, Error> {
if bytes.len() > Self::MAX_BYTES {
return Err(ValidationError::InvalidEvmBytes.into());
}
Ok(Self(bytes))
}
pub fn parse(value: &str) -> Result<Self, Error> {
let payload = value
.strip_prefix("0x")
.ok_or(ValidationError::InvalidEvmBytes)?;
if !payload.len().is_multiple_of(2)
|| payload.len() > Self::MAX_BYTES * 2
|| !payload.bytes().all(|b| b.is_ascii_hexdigit())
{
return Err(ValidationError::InvalidEvmBytes.into());
}
const_hex::decode(payload)
.map(Self)
.map_err(|_| ValidationError::InvalidEvmBytes.into())
}
#[must_use]
pub fn bytes(&self) -> &[u8] {
&self.0
}
#[must_use]
pub fn to_hex(&self) -> String {
const_hex::encode_prefixed(&self.0)
}
}
impl fmt::Debug for Data {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Data")
.field("byte_length", &self.0.len())
.finish_non_exhaustive()
}
}
impl Serialize for Data {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&self.to_hex())
}
}
impl<'de> Deserialize<'de> for Data {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct Word([u8; 32]);
impl Word {
#[must_use]
pub const fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
pub fn parse(value: &str) -> Result<Self, Error> {
let payload = value
.strip_prefix("0x")
.ok_or(ValidationError::InvalidEvmBytes)?;
if payload.len() != 64 || !payload.bytes().all(|b| b.is_ascii_hexdigit()) {
return Err(ValidationError::InvalidEvmBytes.into());
}
const_hex::decode_to_array(payload)
.map(Self)
.map_err(|_| ValidationError::InvalidEvmBytes.into())
}
#[must_use]
pub const fn bytes(self) -> [u8; 32] {
self.0
}
}
impl fmt::Display for Word {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&const_hex::encode_prefixed(self.0))
}
}
impl Serialize for Word {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.collect_str(self)
}
}
impl<'de> Deserialize<'de> for Word {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}