use crate::{
domain::{
Address, ChainId,
solana::{Network, Pubkey, Signature},
},
error::Error,
};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Clone, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct Identifier(String);
impl Identifier {
pub fn new(v: &str) -> Result<Self, Error> {
if v.is_empty()
|| v.len() > 256
|| !v
.bytes()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b':'))
{
return Err(super::invalid_identity());
}
Ok(Self(v.into()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Identifier {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Identifier").finish_non_exhaustive()
}
}
impl TryFrom<String> for Identifier {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(&v)
}
}
impl From<Identifier> for String {
fn from(v: Identifier) -> Self {
v.0
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct Text(String);
impl Text {
pub fn new(v: &str) -> Result<Self, Error> {
if v.trim().is_empty() || v.len() > 512 || v.chars().any(char::is_control) {
return Err(super::invalid_identity());
}
Ok(Self(v.into()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Text {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Text").finish_non_exhaustive()
}
}
impl TryFrom<String> for Text {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(&v)
}
}
impl From<Text> for String {
fn from(v: Text) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "family", rename_all = "snake_case", deny_unknown_fields)]
pub enum Family {
Evm {
chain_id: ChainId,
},
Solana {
network: Network,
},
Provider {
kind: Identifier,
},
}
impl Family {
#[must_use]
pub fn source_type(&self) -> &str {
match self {
Self::Evm { .. } => "EVM",
Self::Solana { .. } => "SOLANA",
Self::Provider { kind } => kind.as_str(),
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ChainFields")]
pub struct Chain {
alias: Identifier,
provider_id: Option<u64>,
family: Family,
testnet: bool,
}
impl Chain {
pub fn new(
alias: Identifier,
provider_id: Option<u64>,
family: Family,
testnet: bool,
) -> Result<Self, Error> {
if provider_id == Some(0)
|| matches!(&family,Family::Provider{kind} if matches!(kind.as_str(),"EVM"|"SOLANA"))
|| matches!(&family,Family::Evm{chain_id} if provider_id.map(ChainId::from)!=Some(*chain_id))
{
return Err(super::invalid_identity());
}
Ok(Self {
alias,
provider_id,
family,
testnet,
})
}
#[must_use]
pub const fn alias(&self) -> &Identifier {
&self.alias
}
#[must_use]
pub const fn provider_id(&self) -> Option<u64> {
self.provider_id
}
#[must_use]
pub const fn family(&self) -> &Family {
&self.family
}
#[must_use]
pub const fn testnet(&self) -> bool {
self.testnet
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ChainFields {
alias: Identifier,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
provider_id: Option<u64>,
family: Family,
testnet: bool,
}
impl TryFrom<ChainFields> for Chain {
type Error = Error;
fn try_from(v: ChainFields) -> Result<Self, Error> {
Self::new(v.alias, v.provider_id, v.family, v.testnet)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "Vec<Chain>", into = "Vec<Chain>")]
pub struct Catalogue(Vec<Chain>);
impl Catalogue {
pub fn new(v: Vec<Chain>) -> Result<Self, Error> {
if v.is_empty()
|| v.len() > 512
|| !crate::domain::market::unique(v.iter().map(|c| c.alias.clone()))
{
return Err(super::invalid_identity());
}
Ok(Self(v))
}
#[must_use]
pub fn chains(&self) -> &[Chain] {
&self.0
}
pub fn resolve(&self, alias: &str) -> Result<&Chain, Error> {
self.0
.iter()
.find(|c| c.alias.as_str() == alias)
.ok_or(Error::UnsupportedCapability)
}
}
impl TryFrom<Vec<Chain>> for Catalogue {
type Error = Error;
fn try_from(v: Vec<Chain>) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Catalogue> for Vec<Chain> {
fn from(v: Catalogue) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "identity",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum AssetIdentifier {
Native,
EvmToken(Address),
SolanaMint(Pubkey),
Provider(Text),
}
pub const SOLANA_NATIVE_ASSET_ADDRESS: &str = "So11111111111111111111111111111111111111111";
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AssetFields")]
pub struct Asset {
chain: Chain,
identifier: AssetIdentifier,
decimals: u8,
}
impl Asset {
pub fn new(chain: Chain, identifier: AssetIdentifier, decimals: u8) -> Result<Self, Error> {
let valid = match (&identifier, chain.family()) {
(AssetIdentifier::EvmToken(a), Family::Evm { .. }) => a.bytes() != [0; 20],
(AssetIdentifier::SolanaMint(p), Family::Solana { .. }) => {
p.to_string() != SOLANA_NATIVE_ASSET_ADDRESS
}
(AssetIdentifier::Native, _)
| (AssetIdentifier::Provider(_), Family::Provider { .. }) => true,
_ => false,
};
if !valid {
return Err(super::invalid_identity());
}
Ok(Self {
chain,
identifier,
decimals,
})
}
#[must_use]
pub const fn chain(&self) -> &Chain {
&self.chain
}
#[must_use]
pub const fn identifier(&self) -> &AssetIdentifier {
&self.identifier
}
#[must_use]
pub const fn decimals(&self) -> u8 {
self.decimals
}
#[must_use]
pub fn source_address(&self) -> String {
match &self.identifier {
AssetIdentifier::Native if matches!(self.chain.family(), Family::Solana { .. }) => {
SOLANA_NATIVE_ASSET_ADDRESS.into()
}
AssetIdentifier::Native => "0x0000000000000000000000000000000000000000".into(),
AssetIdentifier::EvmToken(a) => a.to_string(),
AssetIdentifier::SolanaMint(a) => a.to_string(),
AssetIdentifier::Provider(a) => a.as_str().into(),
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct AssetFields {
chain: Chain,
identifier: AssetIdentifier,
decimals: u8,
}
impl TryFrom<AssetFields> for Asset {
type Error = Error;
fn try_from(v: AssetFields) -> Result<Self, Error> {
Self::new(v.chain, v.identifier, v.decimals)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "family",
content = "address",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum Account {
Evm(Address),
Solana(Pubkey),
Provider(Text),
}
impl Account {
pub fn validate(&self, chain: &Chain) -> Result<(), Error> {
if matches!(
(self, chain.family()),
(Self::Evm(_), Family::Evm { .. })
| (Self::Solana(_), Family::Solana { .. })
| (Self::Provider(_), Family::Provider { .. })
) {
Ok(())
} else {
Err(super::invalid_identity())
}
}
#[must_use]
pub fn source_address(&self) -> String {
match self {
Self::Evm(a) => a.to_string(),
Self::Solana(a) => a.to_string(),
Self::Provider(a) => a.as_str().into(),
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "family",
content = "id",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum TransactionId {
Evm(crate::domain::evm::TransactionId),
Solana(Signature),
Provider(Text),
}
impl TransactionId {
pub fn validate(&self, chain: &Chain) -> Result<(), Error> {
if matches!(
(self, chain.family()),
(Self::Evm(_), Family::Evm { .. })
| (Self::Solana(_), Family::Solana { .. })
| (Self::Provider(_), Family::Provider { .. })
) {
Ok(())
} else {
Err(super::invalid_identity())
}
}
#[must_use]
pub fn source_id(&self) -> String {
match self {
Self::Evm(v) => v.to_string(),
Self::Solana(v) => v.to_string(),
Self::Provider(v) => v.as_str().into(),
}
}
}