Add configuration to enable keepAlive on the rpc providers

[Meemaw]

Describe the Feature

When using rpc providers, e.g JsonRpcProvider a new tcp connection is created for each request. This can add significant overhead to each request.

It should be possible to enable the keeepalive on the provider.

Code Example

const provider = new providers.JsonRpcProvider(process.env.RPC_URL, { http: { keepAlive: true } });

[ricmoo]

I don't think this is something can can safely be added to the low-level library. You can use your own getUrlFunc to try out custom HTTP fetching, if you can identify a safe mechanism, I could add it to the FetchRequest object...

[nickgrealy]

I came here looking for a keepAlive option... then went with a WebSocketProvider instead. 10x faster.

[gshmakov]

If anyone is still interested in long living connections (and optionally disabled Nagle's algorithm), below is the very dirty fix

/ethers-io/ethers.js/tree/main/lib.commonjs/utils/geturl.js

/**
 *  @_ignore:
 */
+++
+++   let customNetworkAgent = null;
+++
function createGetUrl(options) {
    async function getUrl(req, signal) {
        // Make sure we weren't cancelled before sending
        (0, errors_js_1.assert)(signal == null || !signal.cancelled, "request cancelled before sending", "CANCELLED");
        const protocol = req.url.split(":")[0].toLowerCase();
        (0, errors_js_1.assert)(protocol === "http" || protocol === "https", `unsupported protocol ${protocol}`, "UNSUPPORTED_OPERATION", {
            info: { protocol },
            operation: "request"
        });
        (0, errors_js_1.assert)(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
            operation: "request"
        });
        const method = req.method;
        const headers = Object.assign({}, req.headers);
        const reqOptions = { method, headers };
        if (options) {
            if (options.agent) {
                reqOptions.agent = options.agent;
            }
        }
+++
+++        if (customNetworkAgent == null) {
+++            customNetworkAgent = new ((protocol === "http") ? http_1.default : https_1.default).Agent({ keepAlive: true});
+++        }
+++        reqOptions.agent = customNetworkAgent;
+++
        // Create a Node-specific AbortController, if available
        let abort = null;
        try {
            abort = new AbortController();
            reqOptions.abort = abort.signal;
        }
        catch (e) {
            console.log(e);
        }
        const request = ((protocol === "http") ? http_1.default : https_1.default).request(req.url, reqOptions);
        request.setTimeout(req.timeout);
+++
+++        request.on('socket', (sock) => { sock.setNoDelay(true); });
+++        
        const body = req.body;
        if (body) {