Struct RateLimitCache 

pub struct RateLimitCache {
    redis: Option<ConnectionManager>,
    order_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>,
    cancel_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>,
    api_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>,
    rfq_submit_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>,
    tier_cache: Arc<dyn TierCacheApi>,
    window_duration: Duration,
    check_and_increment_script: Script,
    get_count_script: Script,
}

Rate limit cache using fixed window algorithm.

Supports both Redis (distributed) and in-memory (single-instance) backends. When Redis is configured, rate limits are shared across all API server instances. When Redis is not configured, falls back to in-memory rate limiting.

Fields

redis: Option<ConnectionManager>

Redis connection manager (None if using in-memory backend)

order_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>

In-memory counters for order placements per wallet

cancel_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>

In-memory counters for cancellations per wallet

api_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>

In-memory counters for API requests per wallet

rfq_submit_counts: RwLock<HashMap<WalletAddress, FixedWindowCounter>>

In-memory counters for RFQ submissions per wallet

tier_cache: Arc<dyn TierCacheApi>

Reference to tier cache for getting limits (TierCache handles its own locking)

window_duration: Duration

Window duration (default: 60 seconds)

check_and_increment_script: Script

Lua script for atomic check-and-increment

get_count_script: Script

Lua script for getting current count

Implementations

impl RateLimitCache

pub async fn new( tier_cache: Arc<dyn TierCacheApi>, redis_url: Option<&str>, ) -> Self

Create a new rate limit cache.

If redis_url is provided and connection succeeds, uses Redis backend. Otherwise falls back to in-memory backend.

async fn connect_redis(url: &str) -> Result<ConnectionManager, RedisError>

Connect to Redis and return a connection manager.

pub fn backend(&self) -> RateLimitBackend

Get the backend type being used.

fn redis_key( wallet: &WalletAddress, action: RateLimitAction, window_start: u64, ) -> String

Generate Redis key for a wallet/action/window.

fn get_window_start(now_secs: u64, window_secs: u64) -> u64

Get the window start timestamp (truncated to minute boundary).

fn get_counters( &self, action: RateLimitAction, ) -> &StdRwLock<HashMap<WalletAddress, FixedWindowCounter>>

Get the counters map for the given action type (in-memory backend).

fn get_limit_for_action(limits: &TradingLimits, action: RateLimitAction) -> u32

Get the limit for the given action from trading limits.

pub async fn check_and_increment( &self, wallet: &WalletAddress, action: RateLimitAction, ) -> Result<RateLimitInfo, RateLimitError>

Check and increment the rate limit counter for a wallet/action.

Returns Ok(RateLimitInfo) if allowed, Err(RateLimitError) if exceeded or unavailable.

async fn check_and_increment_redis( &self, redis: ConnectionManager, wallet: &WalletAddress, action: RateLimitAction, limit: u32, ) -> Result<RateLimitInfo, RateLimitError>

Check and increment using Redis backend.

fn check_and_increment_memory( &self, wallet: &WalletAddress, action: RateLimitAction, limit: u32, ) -> Result<RateLimitInfo, RateLimitError>

Check and increment using in-memory backend.

pub async fn get_info( &self, wallet: &WalletAddress, action: RateLimitAction, ) -> Result<RateLimitInfo, RateLimitError>

Get current rate limit info for a wallet/action without incrementing.

async fn get_info_redis( &self, redis: ConnectionManager, wallet: &WalletAddress, action: RateLimitAction, limit: u32, ) -> Result<RateLimitInfo, RateLimitError>

Get info using Redis backend.

fn get_info_memory( &self, wallet: &WalletAddress, action: RateLimitAction, limit: u32, ) -> RateLimitInfo

Get info using in-memory backend.

pub fn cleanup_expired(&self)

Clean up expired entries to prevent memory growth (in-memory backend only). Call this periodically (e.g., every 5 minutes).

pub fn tracked_wallet_count(&self) -> usize

Get the number of tracked wallets (for metrics, in-memory backend only).