Issues with PublicClient Instances Over WSS and Managing Connections

[utgarda]

Hi Viem Community,

I've encountered a peculiar behavior with PublicClient instances created using WSS transport. It appears that after a few hours of inactivity, newly created instances immediately fail to watch contract events. This inactivity refers to not creating or using new instances during this time. The issue isn't tied to the lifetime of any single instance but seems related to the time elapsed since the last active use across all instances.

Here's how I'm setting up the PublicClient:

createPublicClient({
  chain: arbitrum,
  transport: webSocket(wssEndpoint, {
    key: 'arbitrum',
    name: arbitrum.name,
  }),
})

When attempting to use these instances after a period of inactivity, I receive errors indicating that the WebSocket connection is closed, specifically when calling publicClient.watchContractEvent. Here's an example error message:

WebSocket request failed.
URL: wss://host.com/provider_secret_key
Request body: {"jsonrpc":"2.0","id":94,"method":"eth_getLogs","params":[{"address":"0x0620f8324531894D9f75dA76DD5E382C4c4fA274","topics":["0x4a6c40516242d2bc8453081e1746087d26dc596dcc95d61f76381accb7469939","0x000000000000000000000000644af561f2257007c34c5bedbdf9812d03fa3869","0x0000000000000000000000000000000000000000000000000000000000000000"],"fromBlock":"0xb8ccdf8"}]}
Details: Socket is closed.
Version: [email protected]

And Chainstack reports HTTP 499 errors.

This seems not to be related to the number of instances but rather to the duration of inactivity. My question to the community and developers:

1. Are WSS sockets reused by createPublicClient? If so, is there a method to either ensure a fresh connection for each new instance or to keep the existing connections alive?
2. Is there a way to explicitly close or destroy a PublicClient instance to manage these connections better?

Any insights or advice on managing these WSS connections for long-running applications would be greatly appreciated.

Thank you!

Same question on SO

[nstylo]

I am facing a very similar issue. I am employing publicClient.watchContractEvent too. I am only expecting to get messages very sparingly. I am using Chainstack as my node provider and as I learned from customer support they close idle websockets after 1h. This seems to happen silently as I am not getting any information about this happening, so the client sits there idle in a disconnected state. I would love it there was a way to keep connections alive.

[nstylo]

This is my current hack:

  client.transport
    .getRpcClient()
    .then((client) => {
      client.socket.addEventListener("message", (ev) => {
        const response = JSON.parse(ev.data);
        if (response.id === 1337) {
          logger.info("pong from:\t", chain.name);
        }
      });
    })
    .then(() => {
      setInterval(
        async () => {
          try {
            client.transport.getRpcClient().then((client) => {
              client.socket.send(
                JSON.stringify({
                  jsonrpc: "2.0",
                  method: "eth_blockNumber",
                  params: [],
                  id: 1337,
                }),
              );
            });
            logger.info("ping to:\t", chain.name);
          } catch (error) {
            console.error(`Error on keep alive for ${chain.name}:`, error);
          }
        },
        2 * 60 * 1000,
      ); // 2 min
    });

[gershido]

Experiencing similar issues

[gershido]

I'm implementing a similar strategy like the one shared above by @nstylo. My issue now is handling a reconnection event properly, which does happen even when pinging regularly. If there was a reconnection, I want to attach again the event listeners that handle the pinging mechanism. If a reconnection happens, does Viem use the same WebSocket client? What I'm trying to understand is whether I can use the "open" event in order to reassign the listeners.

[nstylo]

I was faced with the same problem. Even with a keep-alive mechanism, the connection was closed after some time and the client became silently stale. This is what I came up with. I see it as a quick and dirty fix, but works great. I wish it would be included natively in viem.

private async connect() {
    this._log("info", "Connecting...");

    const socketRpcClient = await this._client.transport.getRpcClient();

    const heartbeat = () => {
      this._log("info", "ping ->");
      this._client
        .getBlockNumber()
        .then((_) => {
          this._log("info", "<- pong");
        })
        .catch((err) => this._log("error", err));
    };

    const intervalId = setInterval(heartbeat, 5 * 60 * 1000);

    const onOpen = (ev: Event) => {
      // drop
    };
    const onMessage = (ev: MessageEvent<any>) => {
      // drop
    };
    const onError = (ev: Event) => {
      this._log("error", ev);
    };
    const onClose = async () => {
      this._log("warn", "Websocket connection closed!");
      socketRpcClient.socket.removeEventListener("open", onOpen);
      socketRpcClient.socket.removeEventListener("message", onMessage);
      socketRpcClient.socket.removeEventListener("error", onError);
      socketRpcClient.socket.removeEventListener("close", onClose);
      // NOTE: IMPORTANT: invalidate viem's socketClientCache! When close
      // happens on socket level, the same socketClient with the closed websocket will be
      // re-used from cache leading to 'Socket is closed.' error.
      socketRpcClient.close();
      clearInterval(intervalId);
      this._followeeWatchRegistry.clear();
      await this.hydrate();
      this._client = this._clientManager.getClient(this._chain);
      this._log("info", "Re-establishing connection!");
      this.connect();
    };

    const setupEventListeners = () => {
      socketRpcClient.socket.addEventListener("open", onOpen);
      socketRpcClient.socket.addEventListener("message", onMessage);
      socketRpcClient.socket.addEventListener("error", onError);
      socketRpcClient.socket.addEventListener("close", onClose);
    };

    setupEventListeners();

    heartbeat();
  }