Per-Caller and Per-Wallet Lock Quotas with Rate Limiting [HIGH]

[HayimShaul]

Description
Impose a hard upper bound on the number of active lock entries any single caller identity (or wallet) may hold simultaneously. Requests that would exceed this quota must be rejected with an appropriate error rather than written to the store. Complement the quota with a rate limit (e.g., maximum lock-creation requests per second per identity) to prevent burst flooding. These controls should be enforced in the service layer, above the database, so they apply regardless of which storage backend is in use.

Short Summary
Currently we assume a rate limiter in the upper layers but we don't have a rate limiter for the view.

[SurbhiAgarwal1]

I’d like to propose an approach to enforce per-caller and per-wallet lock quotas along with rate limiting at the service layer.

1. Per-Caller / Per-Wallet Lock Quota

Introduce a quota manager that tracks the number of active locks held by each identity (caller or wallet).

Key Idea

• Maintain an in-memory counter (with optional persistence if needed)
• Enforce a hard limit before allowing new lock creation

type LockQuotaManager struct {
    activeLocks map[string]int
    maxLocks    int
    mu          sync.Mutex
}

func (m *LockQuotaManager) TryAcquire(id string) error {
    m.mu.Lock()
    defer m.mu.Unlock()

    if m.activeLocks[id] >= m.maxLocks {
        return ErrLockQuotaExceeded
    }

    m.activeLocks[id]++
    return nil
}

func (m *LockQuotaManager) Release(id string) {
    m.mu.Lock()
    defer m.mu.Unlock()

    if m.activeLocks[id] > 0 {
        m.activeLocks[id]--
    }
}