Enum ChainIdPattern 

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}"

Example

use x402_rs::chain::{ChainId, ChainIdPattern};

// Match all EVM chains
let all_evm = ChainIdPattern::wildcard("eip155");
assert!(all_evm.matches(&ChainId::new("eip155", "8453")));
assert!(all_evm.matches(&ChainId::new("eip155", "137")));
assert!(!all_evm.matches(&ChainId::new("solana", "mainnet")));

// Match specific chain
let base_only = ChainIdPattern::exact("eip155", "8453");
assert!(base_only.matches(&ChainId::new("eip155", "8453")));
assert!(!base_only.matches(&ChainId::new("eip155", "137")));

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.

Example

use x402_rs::chain::{ChainId, ChainIdPattern};

let pattern = ChainIdPattern::wildcard("eip155");
assert!(pattern.matches(&ChainId::new("eip155", "1")));
assert!(pattern.matches(&ChainId::new("eip155", "8453")));

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

Creates an exact pattern that matches only the specified chain.

Example

use x402_rs::chain::{ChainId, ChainIdPattern};

let pattern = ChainIdPattern::exact("eip155", "8453");
assert!(pattern.matches(&ChainId::new("eip155", "8453")));
assert!(!pattern.matches(&ChainId::new("eip155", "137")));

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.

Example

use x402_rs::chain::{ChainId, ChainIdPattern};
use std::collections::HashSet;

let refs: HashSet<String> = ["1", "8453", "137"].iter().map(|s| s.to_string()).collect();
let pattern = ChainIdPattern::set("eip155", refs);
assert!(pattern.matches(&ChainId::new("eip155", "8453")));
assert!(!pattern.matches(&ChainId::new("eip155", "42")));

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 From<ChainIdPattern> for Vec<ChainIdPattern>

fn from(value: ChainIdPattern) -> 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.