Implement WalletConnect Request Queue System

[sallymoc]

Summary

Implement a serial queue system to handle multiple concurrent WalletConnect session requests (signing, transactions, approvals). Currently, if multiple requests arrive simultaneously, they may overlap or cause UI issues. Requests should be queued and processed one at a time.

Background

WalletConnect dApps can send multiple signing/transaction requests in rapid succession. Without proper queue management, this can lead to:

• Multiple approval modals appearing simultaneously
• Race conditions in navigation state
• Confusing user experience
• Potential for accidental approvals

Proposed Architecture

Request Queue

Create a request queue service that:

• Maintains a FIFO queue of pending WalletConnect requests
• Tracks whether a request is currently in progress
• Processes requests sequentially
• Adds a configurable delay between request processing (e.g., 2 seconds)

Pseudocode:

class WalletConnectRequestQueue:
    requestQueue: Queue<AsyncFunction>
    inProgress: boolean = false
    requestDelay: Duration = 2 seconds

    enqueue(request: AsyncFunction)
    processNext()
    blockRequests(duration: Duration)

Request Flow

1. WalletConnect event listeners receive session_request or session_proposal
2. Event handler wraps the request and calls enqueue()
3. If queue is empty and no request in progress, execute immediately
4. Otherwise, add to queue
5. On request completion (approve/reject), wait for delay, then process next

Approval UI

• Use Completer/Future-based navigation for approval screens
• Pass onApprove and onReject callbacks as route parameters
• Resolve the Future when user makes a decision
• Modal closes, queue processes next request

Pseudocode:

function showApprovalScreen(request):
    create completer

    navigate to ApprovalScreen with:
        request: request
        onApprove: () => completer.resolve(true)
        onReject: () => completer.resolve(false)

    return completer.future

Session Proposal Deduplication

Track proposal IDs to prevent duplicate connection dialogs:

Pseudocode:

processedProposals: Set<String>

function handleSessionProposal(proposal):
    if processedProposals.contains(proposal.id):
        return
    processedProposals.add(proposal.id)
    queue.enqueue(() => showConnectionApproval(proposal))

Acceptance Criteria

• Single approval modal displayed at a time
• Queued requests process sequentially after approval/rejection
• Configurable delay between request processing
• Duplicate session proposals are ignored
• Queue state persists across app backgrounding (or clears appropriately)
• Timeout handling for requests that aren't acted upon
• Unit tests for queue logic

Additional Considerations

• Should the queue be cleared when the app goes to background?
• What's the maximum queue size before rejecting new requests?
• Should there be a timeout for pending requests in the queue?
• How to handle request expiration (WalletConnect requests have TTL)?

References

• WalletConnect v2 session request documentation
• Kraken Wallet React Native implementation (MIT licensed): uses serial queue with 2-second delays between requests