Enum ChainIdPattern 

#[non_exhaustive]
pub enum ChainIdPattern {
    Wildcard {
        namespace: String,
    },
    Exact {
        namespace: String,
        reference: String,
    },
    Set {
        namespace: String,
        references: HashSet<String>,
    },
}

A pattern for matching chain IDs.

Chain ID patterns allow flexible matching of blockchain networks:

• Wildcard: Matches any chain within a namespace (e.g., eip155:* matches all EVM chains)
• Exact: Matches a specific chain (e.g., eip155:8453 matches only Base)
• Set: Matches any chain from a set (e.g., eip155:{1,8453,137} matches Ethereum, Base, or Polygon)

Serialization

Patterns serialize to human-readable strings:

• Wildcard: "eip155:*"
• Exact: "eip155:8453"
• Set: "eip155:{1,8453,137}"

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Wildcard

Matches any chain within the specified namespace.

Fields

namespace: String

The namespace to match (e.g., eip155, solana).

Exact

Matches exactly one specific chain.

Fields

namespace: String

The namespace of the chain.

reference: String

The reference of the chain.

Set

Matches any chain from a set of references within a namespace.

Fields

namespace: String

The namespace of the chains.

references: HashSet<String>

The set of chain references to match.

Implementations

impl ChainIdPattern

pub fn wildcard<S: Into<String>>(namespace: S) -> Self

Creates a wildcard pattern that matches any chain in the given namespace.

pub fn exact<N: Into<String>, R: Into<String>>( namespace: N, reference: R, ) -> Self

Creates an exact pattern that matches only the specified chain.

pub fn set<N: Into<String>>(namespace: N, references: HashSet<String>) -> Self

Creates a set pattern that matches any chain from the given set of references.

pub fn matches(&self, chain_id: &ChainId) -> bool

Check if a ChainId matches this pattern.

• Wildcard matches any chain with the same namespace
• Exact matches only if both namespace and reference are equal
• Set matches if the namespace is equal and the reference is in the set

pub fn namespace(&self) -> &str

Returns the namespace of this pattern.

Trait Implementations

impl Clone for ChainIdPattern

fn clone(&self) -> ChainIdPattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChainIdPattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChainIdPattern

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ChainIdPattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<ChainId> for ChainIdPattern

fn from(chain_id: ChainId) -> Self

Converts to this type from the input type.

impl FromStr for ChainIdPattern

type Err = ChainIdFormatError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Serialize for ChainIdPattern

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.