Connect, share wins, swap ideas, and chill with fellow community members

Member Lounge

: An engineering deep-dive into building the real-time event streaming pipeline in 

 connections per client exhausts node limits and causes memory leaks in 

, and how to architect an in-memory multiplexed 

 block log bursts without freezing client 

1. The Bottleneck: Why 1:1 On-Chain WebSocket Subscriptions Fail

When building live dashboards, terminal interfaces, or mobile 

, users expect trade feeds and balance changes to update in real time.

Every client connects to the backend via 

This breaks in production for three distinct reasons:

: 500 connected clients open 500 parallel 

 connections, quickly hitting node provider rate limits and triggering 

: When mobile browsers disconnect (backgrounding the app or switching Wi-Fi), unclosed socket listeners remain attached to the 

, causing memory usage to steadily climb on the server.

: A brief network hiccup causes hundreds of clients to reconnect simultaneously, creating a thundering-herd spike that crashes 

2. Architecture: Single-Ingress Multiplexing & Heartbeat Pruning

). It listens to contract event logs (such as market executions and 

, the listener normalizes the raw log data into a typed 

 event payload and pushes it to an internal in-memory 

: Client connections are managed in an active set. Every 30 seconds, the server dispatches a 

 frame. If a client fails to respond with a 

 before the next tick, the socket is terminated and its references are garbage collected immediately.

3. Production TypeScript & Node.js Implementation

Below is a standalone implementation of a multiplexed WebSocket server for Arc contract events:

import { WebSocketServer, WebSocket } from 'ws';

import { createPublicClient, webSocket } from 'viem';

// 1. Configure Arc Testnet WebSocket RPC

  nativeCurrency: { name: 'USDC', symbol: 'USDC', decimals: 6 },

  rpcUrls: { default: { http: ['https://rpc.testnet.arc.network'], webSocket: ['wss://rpc.testnet.arc.network'] } },

  transport: webSocket('wss://rpc.testnet.arc.network'),

interface ExtWebSocket extends WebSocket {

  private clients: Set<ExtWebSocket> = new Set();

  constructor(port: number, contractAddress: `0x${string}`) {

    this.wss = new WebSocketServer({ port });

    this.subscribeToArcEvents(contractAddress);

  // Manage client connections and cleanup 

    this.wss.on('connection', (ws: ExtWebSocket) => {

  // 30-Second Ping/Pong Heartbeat to prevent memory leaks

 // Single onchain listener broadcasting to all clients

  private subscribeToArcEvents(contractAddress: `0x${string}`) {

          const payload = JSON.stringify({

            txHash: log.transactionHash,

            blockNumber: log.blockNumber.toString(),

          // Broadcast to active clients with backpressure check

          this.clients.forEach((client) => {

            if (client.readyState === WebSocket.OPEN && client.bufferedAmount === 0) {

 consensus finalizes blocks in <800ms, event bursts arrive significantly faster than on 12-second Ethereum. Checking 

 prevents slow mobile clients from buffering megabytes of unread messages in memory.

 servers must maintain a 12-block buffer to handle potential chain reorganizations before notifying clients. On 

, blocks finalize deterministically upon inclusion, meaning backend events can be treated as final immediately upon receipt.

5. Official References & Open Source Backend

Architecture, Gas, and RPC specifications.

When streaming live contract events across high concurrency on 

, are you using single-process in-memory 

 or scaling out with Redis/Valkey message queues?

Puls Architecture: Scaling Real-Time WebSocket Feeds for Onchain Contract Events

Home

Forum

Events

Content

Courses

Collections

People

Contributors

Albums

Groups

Chat

Channels

Not being used

Help

Join the global network of builders developing the Economic OS for the internet. We’re reimagining how value moves, creating the tools that make the economy work for everyone.

Arc House

What do you do professionally (be specific especially if you are self employed)

Join a global network of builders developing the Economic OS for the internet. We’re reimagining how value moves, creating the tools that make that economy work for everyone. 

Arc House | Build the economic OS for the internet with us

Copyright

Terms of Service

Privacy

Code of Conduct

Your Privacy Choices

It looks like there is no account associated with the email you provided. The event is for members only. Please complete the application to join our community first.

Thank you for your interest in joining us

Thanks for your interest in joining the event. However, your account is still pending. Once it's approved, you'll be able to register for the event. Please contact us via dev@arc.io if you need support.

Pending Approval

Login to the The Arc Community Hub community to connect with others, attend community events, and more!

Login or Sign Up for even more

To unlock all parts of the community complete your profile using verifiable and real information.

Hey, complete your profile

It looks like there is no account associated with the email you provided. Please complete the application to join our community.

Thank you for your interest in joining Arc House.

Thanks for your interest in joining Arc House. We will review your request shortly and email you once it's approved. Meanwhile, please feel free to contact us via dev@arc.io for any questions.

Accounts are unapproved when profile information cannot be verified or when activity patterns indicate spam, inorganic participation, or behavior that undermines trust in the program.

To strengthen your profile for future consideration, sign in with a verified LinkedIn account, use real and current profile information, and participate constructively in other community spaces.

Commercial customers should raise concerns through their support channel.

https://www.arc.network/community-guidelines