@solana/web3.js 1.95.2 → 1.95.4

package/lib/index.esm.js

@@ -9,7 +9,7 @@ import { blob } from '@solana/buffer-layout';
 import { toBigIntLE, toBufferLE } from 'bigint-buffer';
 import require$$0 from 'util';
 import require$$0$1 from 'http';
-import require$$0$2, { Agent as Agent$1 } from 'https';
+import require$$0$2, { Agent } from 'https';
 import { coerce, instance, string, tuple, literal, unknown, type, number, array, nullable, optional, boolean, record, union, create, any, assert as assert$1 } from 'superstruct';
 import RpcClient from 'jayson/lib/client/browser';
 import * as nodeFetch from 'node-fetch';
@@ -2935,7 +2935,7 @@ class SystemProgram {
       isSigner: false,
       isWritable: true
     }];
-    if (params.basePubkey != params.fromPubkey) {
+    if (!params.basePubkey.equals(params.fromPubkey)) {
       keys.push({
         pubkey: params.basePubkey,
         isSigner: true,
@@ -3378,163 +3378,171 @@ var agentkeepalive = {exports: {}};
  * Helpers.
  */
 
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var w = d * 7;
-var y = d * 365.25;
-
-/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- *  - `long` verbose formatting [false]
- *
- * @param {String|Number} val
- * @param {Object} [options]
- * @throws {Error} throw an error if val is not a non-empty string or a number
- * @return {String|Number}
- * @api public
- */
-
-var ms$2 = function (val, options) {
-  options = options || {};
-  var type = typeof val;
-  if (type === 'string' && val.length > 0) {
-    return parse(val);
-  } else if (type === 'number' && isFinite(val)) {
-    return options.long ? fmtLong(val) : fmtShort(val);
-  }
-  throw new Error(
-    'val is not a non-empty string or a valid number. val=' +
-      JSON.stringify(val)
-  );
-};
-
-/**
- * Parse the given `str` and return milliseconds.
- *
- * @param {String} str
- * @return {Number}
- * @api private
- */
-
-function parse(str) {
-  str = String(str);
-  if (str.length > 100) {
-    return;
-  }
-  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-    str
-  );
-  if (!match) {
-    return;
-  }
-  var n = parseFloat(match[1]);
-  var type = (match[2] || 'ms').toLowerCase();
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'weeks':
-    case 'week':
-    case 'w':
-      return n * w;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function (val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
 
-function fmtShort(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return Math.round(ms / d) + 'd';
-  }
-  if (msAbs >= h) {
-    return Math.round(ms / h) + 'h';
-  }
-  if (msAbs >= m) {
-    return Math.round(ms / m) + 'm';
-  }
-  if (msAbs >= s) {
-    return Math.round(ms / s) + 's';
-  }
-  return ms + 'ms';
-}
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
 
-/**
- * Long format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
 
-function fmtLong(ms) {
-  var msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
-  }
-  if (msAbs >= h) {
-    return plural(ms, msAbs, h, 'hour');
-  }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
-  }
-  if (msAbs >= s) {
-    return plural(ms, msAbs, s, 'second');
-  }
-  return ms + ' ms';
-}
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
 
-/**
- * Pluralization helper.
- */
+	/**
+	 * Pluralization helper.
+	 */
 
-function plural(ms, msAbs, n, name) {
-  var isPlural = msAbs >= n * 1.5;
-  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
 }
 
 /*!
@@ -3543,569 +3551,622 @@ function plural(ms, msAbs, n, name) {
  * MIT Licensed
  */
 
-/**
- * Module dependencies.
- */
+var humanizeMs;
+var hasRequiredHumanizeMs;
 
-var util = require$$0;
-var ms$1 = ms$2;
+function requireHumanizeMs () {
+	if (hasRequiredHumanizeMs) return humanizeMs;
+	hasRequiredHumanizeMs = 1;
 
-var humanizeMs = function (t) {
-  if (typeof t === 'number') return t;
-  var r = ms$1(t);
-  if (r === undefined) {
-    var err = new Error(util.format('humanize-ms(%j) result undefined', t));
-    console.warn(err.stack);
-  }
-  return r;
-};
+	/**
+	 * Module dependencies.
+	 */
 
-var constants = {
-  // agent
-  CURRENT_ID: Symbol('agentkeepalive#currentId'),
-  CREATE_ID: Symbol('agentkeepalive#createId'),
-  INIT_SOCKET: Symbol('agentkeepalive#initSocket'),
-  CREATE_HTTPS_CONNECTION: Symbol('agentkeepalive#createHttpsConnection'),
-  // socket
-  SOCKET_CREATED_TIME: Symbol('agentkeepalive#socketCreatedTime'),
-  SOCKET_NAME: Symbol('agentkeepalive#socketName'),
-  SOCKET_REQUEST_COUNT: Symbol('agentkeepalive#socketRequestCount'),
-  SOCKET_REQUEST_FINISHED_COUNT: Symbol('agentkeepalive#socketRequestFinishedCount'),
-};
+	var util = require$$0;
+	var ms = /*@__PURE__*/ requireMs();
 
-const OriginalAgent = require$$0$1.Agent;
-const ms = humanizeMs;
-const debug = require$$0.debuglog('agentkeepalive');
-const {
-  INIT_SOCKET: INIT_SOCKET$1,
-  CURRENT_ID,
-  CREATE_ID,
-  SOCKET_CREATED_TIME,
-  SOCKET_NAME,
-  SOCKET_REQUEST_COUNT,
-  SOCKET_REQUEST_FINISHED_COUNT,
-} = constants;
-
-// OriginalAgent come from
-// - https://github.com/nodejs/node/blob/v8.12.0/lib/_http_agent.js
-// - https://github.com/nodejs/node/blob/v10.12.0/lib/_http_agent.js
-
-// node <= 10
-let defaultTimeoutListenerCount = 1;
-const majorVersion = parseInt(process.version.split('.', 1)[0].substring(1));
-if (majorVersion >= 11 && majorVersion <= 12) {
-  defaultTimeoutListenerCount = 2;
-} else if (majorVersion >= 13) {
-  defaultTimeoutListenerCount = 3;
+	humanizeMs = function (t) {
+	  if (typeof t === 'number') return t;
+	  var r = ms(t);
+	  if (r === undefined) {
+	    var err = new Error(util.format('humanize-ms(%j) result undefined', t));
+	    console.warn(err.stack);
+	  }
+	  return r;
+	};
+	return humanizeMs;
 }
 
-function deprecate(message) {
-  console.log('[agentkeepalive:deprecated] %s', message);
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	constants = {
+	  // agent
+	  CURRENT_ID: Symbol('agentkeepalive#currentId'),
+	  CREATE_ID: Symbol('agentkeepalive#createId'),
+	  INIT_SOCKET: Symbol('agentkeepalive#initSocket'),
+	  CREATE_HTTPS_CONNECTION: Symbol('agentkeepalive#createHttpsConnection'),
+	  // socket
+	  SOCKET_CREATED_TIME: Symbol('agentkeepalive#socketCreatedTime'),
+	  SOCKET_NAME: Symbol('agentkeepalive#socketName'),
+	  SOCKET_REQUEST_COUNT: Symbol('agentkeepalive#socketRequestCount'),
+	  SOCKET_REQUEST_FINISHED_COUNT: Symbol('agentkeepalive#socketRequestFinishedCount'),
+	};
+	return constants;
 }
 
-class Agent extends OriginalAgent {
-  constructor(options) {
-    options = options || {};
-    options.keepAlive = options.keepAlive !== false;
-    // default is keep-alive and 4s free socket timeout
-    // see https://medium.com/ssense-tech/reduce-networking-errors-in-nodejs-23b4eb9f2d83
-    if (options.freeSocketTimeout === undefined) {
-      options.freeSocketTimeout = 4000;
-    }
-    // Legacy API: keepAliveTimeout should be rename to `freeSocketTimeout`
-    if (options.keepAliveTimeout) {
-      deprecate('options.keepAliveTimeout is deprecated, please use options.freeSocketTimeout instead');
-      options.freeSocketTimeout = options.keepAliveTimeout;
-      delete options.keepAliveTimeout;
-    }
-    // Legacy API: freeSocketKeepAliveTimeout should be rename to `freeSocketTimeout`
-    if (options.freeSocketKeepAliveTimeout) {
-      deprecate('options.freeSocketKeepAliveTimeout is deprecated, please use options.freeSocketTimeout instead');
-      options.freeSocketTimeout = options.freeSocketKeepAliveTimeout;
-      delete options.freeSocketKeepAliveTimeout;
-    }
-
-    // Sets the socket to timeout after timeout milliseconds of inactivity on the socket.
-    // By default is double free socket timeout.
-    if (options.timeout === undefined) {
-      // make sure socket default inactivity timeout >= 8s
-      options.timeout = Math.max(options.freeSocketTimeout * 2, 8000);
-    }
-
-    // support humanize format
-    options.timeout = ms(options.timeout);
-    options.freeSocketTimeout = ms(options.freeSocketTimeout);
-    options.socketActiveTTL = options.socketActiveTTL ? ms(options.socketActiveTTL) : 0;
-
-    super(options);
-
-    this[CURRENT_ID] = 0;
-
-    // create socket success counter
-    this.createSocketCount = 0;
-    this.createSocketCountLastCheck = 0;
-
-    this.createSocketErrorCount = 0;
-    this.createSocketErrorCountLastCheck = 0;
-
-    this.closeSocketCount = 0;
-    this.closeSocketCountLastCheck = 0;
-
-    // socket error event count
-    this.errorSocketCount = 0;
-    this.errorSocketCountLastCheck = 0;
-
-    // request finished counter
-    this.requestCount = 0;
-    this.requestCountLastCheck = 0;
-
-    // including free socket timeout counter
-    this.timeoutSocketCount = 0;
-    this.timeoutSocketCountLastCheck = 0;
-
-    this.on('free', socket => {
-      // https://github.com/nodejs/node/pull/32000
-      // Node.js native agent will check socket timeout eqs agent.options.timeout.
-      // Use the ttl or freeSocketTimeout to overwrite.
-      const timeout = this.calcSocketTimeout(socket);
-      if (timeout > 0 && socket.timeout !== timeout) {
-        socket.setTimeout(timeout);
-      }
-    });
-  }
-
-  get freeSocketKeepAliveTimeout() {
-    deprecate('agent.freeSocketKeepAliveTimeout is deprecated, please use agent.options.freeSocketTimeout instead');
-    return this.options.freeSocketTimeout;
-  }
-
-  get timeout() {
-    deprecate('agent.timeout is deprecated, please use agent.options.timeout instead');
-    return this.options.timeout;
-  }
-
-  get socketActiveTTL() {
-    deprecate('agent.socketActiveTTL is deprecated, please use agent.options.socketActiveTTL instead');
-    return this.options.socketActiveTTL;
-  }
-
-  calcSocketTimeout(socket) {
-    /**
-     * return <= 0: should free socket
-     * return > 0: should update socket timeout
-     * return undefined: not find custom timeout
-     */
-    let freeSocketTimeout = this.options.freeSocketTimeout;
-    const socketActiveTTL = this.options.socketActiveTTL;
-    if (socketActiveTTL) {
-      // check socketActiveTTL
-      const aliveTime = Date.now() - socket[SOCKET_CREATED_TIME];
-      const diff = socketActiveTTL - aliveTime;
-      if (diff <= 0) {
-        return diff;
-      }
-      if (freeSocketTimeout && diff < freeSocketTimeout) {
-        freeSocketTimeout = diff;
-      }
-    }
-    // set freeSocketTimeout
-    if (freeSocketTimeout) {
-      // set free keepalive timer
-      // try to use socket custom freeSocketTimeout first, support headers['keep-alive']
-      // https://github.com/node-modules/urllib/blob/b76053020923f4d99a1c93cf2e16e0c5ba10bacf/lib/urllib.js#L498
-      const customFreeSocketTimeout = socket.freeSocketTimeout || socket.freeSocketKeepAliveTimeout;
-      return customFreeSocketTimeout || freeSocketTimeout;
-    }
-  }
-
-  keepSocketAlive(socket) {
-    const result = super.keepSocketAlive(socket);
-    // should not keepAlive, do nothing
-    if (!result) return result;
-
-    const customTimeout = this.calcSocketTimeout(socket);
-    if (typeof customTimeout === 'undefined') {
-      return true;
-    }
-    if (customTimeout <= 0) {
-      debug('%s(requests: %s, finished: %s) free but need to destroy by TTL, request count %s, diff is %s',
-        socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT], customTimeout);
-      return false;
-    }
-    if (socket.timeout !== customTimeout) {
-      socket.setTimeout(customTimeout);
-    }
-    return true;
-  }
-
-  // only call on addRequest
-  reuseSocket(...args) {
-    // reuseSocket(socket, req)
-    super.reuseSocket(...args);
-    const socket = args[0];
-    const req = args[1];
-    req.reusedSocket = true;
-    const agentTimeout = this.options.timeout;
-    if (getSocketTimeout(socket) !== agentTimeout) {
-      // reset timeout before use
-      socket.setTimeout(agentTimeout);
-      debug('%s reset timeout to %sms', socket[SOCKET_NAME], agentTimeout);
-    }
-    socket[SOCKET_REQUEST_COUNT]++;
-    debug('%s(requests: %s, finished: %s) reuse on addRequest, timeout %sms',
-      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
-      getSocketTimeout(socket));
-  }
-
-  [CREATE_ID]() {
-    const id = this[CURRENT_ID]++;
-    if (this[CURRENT_ID] === Number.MAX_SAFE_INTEGER) this[CURRENT_ID] = 0;
-    return id;
-  }
-
-  [INIT_SOCKET$1](socket, options) {
-    // bugfix here.
-    // https on node 8, 10 won't set agent.options.timeout by default
-    // TODO: need to fix on node itself
-    if (options.timeout) {
-      const timeout = getSocketTimeout(socket);
-      if (!timeout) {
-        socket.setTimeout(options.timeout);
-      }
-    }
-
-    if (this.options.keepAlive) {
-      // Disable Nagle's algorithm: http://blog.caustik.com/2012/04/08/scaling-node-js-to-100k-concurrent-connections/
-      // https://fengmk2.com/benchmark/nagle-algorithm-delayed-ack-mock.html
-      socket.setNoDelay(true);
-    }
-    this.createSocketCount++;
-    if (this.options.socketActiveTTL) {
-      socket[SOCKET_CREATED_TIME] = Date.now();
-    }
-    // don't show the hole '-----BEGIN CERTIFICATE----' key string
-    socket[SOCKET_NAME] = `sock[${this[CREATE_ID]()}#${options._agentKey}]`.split('-----BEGIN', 1)[0];
-    socket[SOCKET_REQUEST_COUNT] = 1;
-    socket[SOCKET_REQUEST_FINISHED_COUNT] = 0;
-    installListeners(this, socket, options);
-  }
-
-  createConnection(options, oncreate) {
-    let called = false;
-    const onNewCreate = (err, socket) => {
-      if (called) return;
-      called = true;
+var agent;
+var hasRequiredAgent;
+
+function requireAgent () {
+	if (hasRequiredAgent) return agent;
+	hasRequiredAgent = 1;
+
+	const OriginalAgent = require$$0$1.Agent;
+	const ms = /*@__PURE__*/ requireHumanizeMs();
+	const debug = require$$0.debuglog('agentkeepalive');
+	const {
+	  INIT_SOCKET,
+	  CURRENT_ID,
+	  CREATE_ID,
+	  SOCKET_CREATED_TIME,
+	  SOCKET_NAME,
+	  SOCKET_REQUEST_COUNT,
+	  SOCKET_REQUEST_FINISHED_COUNT,
+	} = /*@__PURE__*/ requireConstants();
+
+	// OriginalAgent come from
+	// - https://github.com/nodejs/node/blob/v8.12.0/lib/_http_agent.js
+	// - https://github.com/nodejs/node/blob/v10.12.0/lib/_http_agent.js
+
+	// node <= 10
+	let defaultTimeoutListenerCount = 1;
+	const majorVersion = parseInt(process.version.split('.', 1)[0].substring(1));
+	if (majorVersion >= 11 && majorVersion <= 12) {
+	  defaultTimeoutListenerCount = 2;
+	} else if (majorVersion >= 13) {
+	  defaultTimeoutListenerCount = 3;
+	}
 
-      if (err) {
-        this.createSocketErrorCount++;
-        return oncreate(err);
-      }
-      this[INIT_SOCKET$1](socket, options);
-      oncreate(err, socket);
-    };
+	function deprecate(message) {
+	  console.log('[agentkeepalive:deprecated] %s', message);
+	}
 
-    const newSocket = super.createConnection(options, onNewCreate);
-    if (newSocket) onNewCreate(null, newSocket);
-    return newSocket;
-  }
+	class Agent extends OriginalAgent {
+	  constructor(options) {
+	    options = options || {};
+	    options.keepAlive = options.keepAlive !== false;
+	    // default is keep-alive and 4s free socket timeout
+	    // see https://medium.com/ssense-tech/reduce-networking-errors-in-nodejs-23b4eb9f2d83
+	    if (options.freeSocketTimeout === undefined) {
+	      options.freeSocketTimeout = 4000;
+	    }
+	    // Legacy API: keepAliveTimeout should be rename to `freeSocketTimeout`
+	    if (options.keepAliveTimeout) {
+	      deprecate('options.keepAliveTimeout is deprecated, please use options.freeSocketTimeout instead');
+	      options.freeSocketTimeout = options.keepAliveTimeout;
+	      delete options.keepAliveTimeout;
+	    }
+	    // Legacy API: freeSocketKeepAliveTimeout should be rename to `freeSocketTimeout`
+	    if (options.freeSocketKeepAliveTimeout) {
+	      deprecate('options.freeSocketKeepAliveTimeout is deprecated, please use options.freeSocketTimeout instead');
+	      options.freeSocketTimeout = options.freeSocketKeepAliveTimeout;
+	      delete options.freeSocketKeepAliveTimeout;
+	    }
+
+	    // Sets the socket to timeout after timeout milliseconds of inactivity on the socket.
+	    // By default is double free socket timeout.
+	    if (options.timeout === undefined) {
+	      // make sure socket default inactivity timeout >= 8s
+	      options.timeout = Math.max(options.freeSocketTimeout * 2, 8000);
+	    }
+
+	    // support humanize format
+	    options.timeout = ms(options.timeout);
+	    options.freeSocketTimeout = ms(options.freeSocketTimeout);
+	    options.socketActiveTTL = options.socketActiveTTL ? ms(options.socketActiveTTL) : 0;
+
+	    super(options);
+
+	    this[CURRENT_ID] = 0;
+
+	    // create socket success counter
+	    this.createSocketCount = 0;
+	    this.createSocketCountLastCheck = 0;
+
+	    this.createSocketErrorCount = 0;
+	    this.createSocketErrorCountLastCheck = 0;
+
+	    this.closeSocketCount = 0;
+	    this.closeSocketCountLastCheck = 0;
+
+	    // socket error event count
+	    this.errorSocketCount = 0;
+	    this.errorSocketCountLastCheck = 0;
+
+	    // request finished counter
+	    this.requestCount = 0;
+	    this.requestCountLastCheck = 0;
+
+	    // including free socket timeout counter
+	    this.timeoutSocketCount = 0;
+	    this.timeoutSocketCountLastCheck = 0;
+
+	    this.on('free', socket => {
+	      // https://github.com/nodejs/node/pull/32000
+	      // Node.js native agent will check socket timeout eqs agent.options.timeout.
+	      // Use the ttl or freeSocketTimeout to overwrite.
+	      const timeout = this.calcSocketTimeout(socket);
+	      if (timeout > 0 && socket.timeout !== timeout) {
+	        socket.setTimeout(timeout);
+	      }
+	    });
+	  }
+
+	  get freeSocketKeepAliveTimeout() {
+	    deprecate('agent.freeSocketKeepAliveTimeout is deprecated, please use agent.options.freeSocketTimeout instead');
+	    return this.options.freeSocketTimeout;
+	  }
+
+	  get timeout() {
+	    deprecate('agent.timeout is deprecated, please use agent.options.timeout instead');
+	    return this.options.timeout;
+	  }
+
+	  get socketActiveTTL() {
+	    deprecate('agent.socketActiveTTL is deprecated, please use agent.options.socketActiveTTL instead');
+	    return this.options.socketActiveTTL;
+	  }
+
+	  calcSocketTimeout(socket) {
+	    /**
+	     * return <= 0: should free socket
+	     * return > 0: should update socket timeout
+	     * return undefined: not find custom timeout
+	     */
+	    let freeSocketTimeout = this.options.freeSocketTimeout;
+	    const socketActiveTTL = this.options.socketActiveTTL;
+	    if (socketActiveTTL) {
+	      // check socketActiveTTL
+	      const aliveTime = Date.now() - socket[SOCKET_CREATED_TIME];
+	      const diff = socketActiveTTL - aliveTime;
+	      if (diff <= 0) {
+	        return diff;
+	      }
+	      if (freeSocketTimeout && diff < freeSocketTimeout) {
+	        freeSocketTimeout = diff;
+	      }
+	    }
+	    // set freeSocketTimeout
+	    if (freeSocketTimeout) {
+	      // set free keepalive timer
+	      // try to use socket custom freeSocketTimeout first, support headers['keep-alive']
+	      // https://github.com/node-modules/urllib/blob/b76053020923f4d99a1c93cf2e16e0c5ba10bacf/lib/urllib.js#L498
+	      const customFreeSocketTimeout = socket.freeSocketTimeout || socket.freeSocketKeepAliveTimeout;
+	      return customFreeSocketTimeout || freeSocketTimeout;
+	    }
+	  }
+
+	  keepSocketAlive(socket) {
+	    const result = super.keepSocketAlive(socket);
+	    // should not keepAlive, do nothing
+	    if (!result) return result;
+
+	    const customTimeout = this.calcSocketTimeout(socket);
+	    if (typeof customTimeout === 'undefined') {
+	      return true;
+	    }
+	    if (customTimeout <= 0) {
+	      debug('%s(requests: %s, finished: %s) free but need to destroy by TTL, request count %s, diff is %s',
+	        socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT], customTimeout);
+	      return false;
+	    }
+	    if (socket.timeout !== customTimeout) {
+	      socket.setTimeout(customTimeout);
+	    }
+	    return true;
+	  }
+
+	  // only call on addRequest
+	  reuseSocket(...args) {
+	    // reuseSocket(socket, req)
+	    super.reuseSocket(...args);
+	    const socket = args[0];
+	    const req = args[1];
+	    req.reusedSocket = true;
+	    const agentTimeout = this.options.timeout;
+	    if (getSocketTimeout(socket) !== agentTimeout) {
+	      // reset timeout before use
+	      socket.setTimeout(agentTimeout);
+	      debug('%s reset timeout to %sms', socket[SOCKET_NAME], agentTimeout);
+	    }
+	    socket[SOCKET_REQUEST_COUNT]++;
+	    debug('%s(requests: %s, finished: %s) reuse on addRequest, timeout %sms',
+	      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
+	      getSocketTimeout(socket));
+	  }
+
+	  [CREATE_ID]() {
+	    const id = this[CURRENT_ID]++;
+	    if (this[CURRENT_ID] === Number.MAX_SAFE_INTEGER) this[CURRENT_ID] = 0;
+	    return id;
+	  }
+
+	  [INIT_SOCKET](socket, options) {
+	    // bugfix here.
+	    // https on node 8, 10 won't set agent.options.timeout by default
+	    // TODO: need to fix on node itself
+	    if (options.timeout) {
+	      const timeout = getSocketTimeout(socket);
+	      if (!timeout) {
+	        socket.setTimeout(options.timeout);
+	      }
+	    }
+
+	    if (this.options.keepAlive) {
+	      // Disable Nagle's algorithm: http://blog.caustik.com/2012/04/08/scaling-node-js-to-100k-concurrent-connections/
+	      // https://fengmk2.com/benchmark/nagle-algorithm-delayed-ack-mock.html
+	      socket.setNoDelay(true);
+	    }
+	    this.createSocketCount++;
+	    if (this.options.socketActiveTTL) {
+	      socket[SOCKET_CREATED_TIME] = Date.now();
+	    }
+	    // don't show the hole '-----BEGIN CERTIFICATE----' key string
+	    socket[SOCKET_NAME] = `sock[${this[CREATE_ID]()}#${options._agentKey}]`.split('-----BEGIN', 1)[0];
+	    socket[SOCKET_REQUEST_COUNT] = 1;
+	    socket[SOCKET_REQUEST_FINISHED_COUNT] = 0;
+	    installListeners(this, socket, options);
+	  }
+
+	  createConnection(options, oncreate) {
+	    let called = false;
+	    const onNewCreate = (err, socket) => {
+	      if (called) return;
+	      called = true;
+
+	      if (err) {
+	        this.createSocketErrorCount++;
+	        return oncreate(err);
+	      }
+	      this[INIT_SOCKET](socket, options);
+	      oncreate(err, socket);
+	    };
+
+	    const newSocket = super.createConnection(options, onNewCreate);
+	    if (newSocket) onNewCreate(null, newSocket);
+	    return newSocket;
+	  }
+
+	  get statusChanged() {
+	    const changed = this.createSocketCount !== this.createSocketCountLastCheck ||
+	      this.createSocketErrorCount !== this.createSocketErrorCountLastCheck ||
+	      this.closeSocketCount !== this.closeSocketCountLastCheck ||
+	      this.errorSocketCount !== this.errorSocketCountLastCheck ||
+	      this.timeoutSocketCount !== this.timeoutSocketCountLastCheck ||
+	      this.requestCount !== this.requestCountLastCheck;
+	    if (changed) {
+	      this.createSocketCountLastCheck = this.createSocketCount;
+	      this.createSocketErrorCountLastCheck = this.createSocketErrorCount;
+	      this.closeSocketCountLastCheck = this.closeSocketCount;
+	      this.errorSocketCountLastCheck = this.errorSocketCount;
+	      this.timeoutSocketCountLastCheck = this.timeoutSocketCount;
+	      this.requestCountLastCheck = this.requestCount;
+	    }
+	    return changed;
+	  }
+
+	  getCurrentStatus() {
+	    return {
+	      createSocketCount: this.createSocketCount,
+	      createSocketErrorCount: this.createSocketErrorCount,
+	      closeSocketCount: this.closeSocketCount,
+	      errorSocketCount: this.errorSocketCount,
+	      timeoutSocketCount: this.timeoutSocketCount,
+	      requestCount: this.requestCount,
+	      freeSockets: inspect(this.freeSockets),
+	      sockets: inspect(this.sockets),
+	      requests: inspect(this.requests),
+	    };
+	  }
+	}
 
-  get statusChanged() {
-    const changed = this.createSocketCount !== this.createSocketCountLastCheck ||
-      this.createSocketErrorCount !== this.createSocketErrorCountLastCheck ||
-      this.closeSocketCount !== this.closeSocketCountLastCheck ||
-      this.errorSocketCount !== this.errorSocketCountLastCheck ||
-      this.timeoutSocketCount !== this.timeoutSocketCountLastCheck ||
-      this.requestCount !== this.requestCountLastCheck;
-    if (changed) {
-      this.createSocketCountLastCheck = this.createSocketCount;
-      this.createSocketErrorCountLastCheck = this.createSocketErrorCount;
-      this.closeSocketCountLastCheck = this.closeSocketCount;
-      this.errorSocketCountLastCheck = this.errorSocketCount;
-      this.timeoutSocketCountLastCheck = this.timeoutSocketCount;
-      this.requestCountLastCheck = this.requestCount;
-    }
-    return changed;
-  }
+	// node 8 don't has timeout attribute on socket
+	// https://github.com/nodejs/node/pull/21204/files#diff-e6ef024c3775d787c38487a6309e491dR408
+	function getSocketTimeout(socket) {
+	  return socket.timeout || socket._idleTimeout;
+	}
 
-  getCurrentStatus() {
-    return {
-      createSocketCount: this.createSocketCount,
-      createSocketErrorCount: this.createSocketErrorCount,
-      closeSocketCount: this.closeSocketCount,
-      errorSocketCount: this.errorSocketCount,
-      timeoutSocketCount: this.timeoutSocketCount,
-      requestCount: this.requestCount,
-      freeSockets: inspect(this.freeSockets),
-      sockets: inspect(this.sockets),
-      requests: inspect(this.requests),
-    };
-  }
-}
+	function installListeners(agent, socket, options) {
+	  debug('%s create, timeout %sms', socket[SOCKET_NAME], getSocketTimeout(socket));
+
+	  // listener socket events: close, timeout, error, free
+	  function onFree() {
+	    // create and socket.emit('free') logic
+	    // https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L311
+	    // no req on the socket, it should be the new socket
+	    if (!socket._httpMessage && socket[SOCKET_REQUEST_COUNT] === 1) return;
+
+	    socket[SOCKET_REQUEST_FINISHED_COUNT]++;
+	    agent.requestCount++;
+	    debug('%s(requests: %s, finished: %s) free',
+	      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
+
+	    // should reuse on pedding requests?
+	    const name = agent.getName(options);
+	    if (socket.writable && agent.requests[name] && agent.requests[name].length) {
+	      // will be reuse on agent free listener
+	      socket[SOCKET_REQUEST_COUNT]++;
+	      debug('%s(requests: %s, finished: %s) will be reuse on agent free event',
+	        socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
+	    }
+	  }
+	  socket.on('free', onFree);
+
+	  function onClose(isError) {
+	    debug('%s(requests: %s, finished: %s) close, isError: %s',
+	      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT], isError);
+	    agent.closeSocketCount++;
+	  }
+	  socket.on('close', onClose);
+
+	  // start socket timeout handler
+	  function onTimeout() {
+	    // onTimeout and emitRequestTimeout(_http_client.js)
+	    // https://github.com/nodejs/node/blob/v12.x/lib/_http_client.js#L711
+	    const listenerCount = socket.listeners('timeout').length;
+	    // node <= 10, default listenerCount is 1, onTimeout
+	    // 11 < node <= 12, default listenerCount is 2, onTimeout and emitRequestTimeout
+	    // node >= 13, default listenerCount is 3, onTimeout,
+	    //   onTimeout(https://github.com/nodejs/node/pull/32000/files#diff-5f7fb0850412c6be189faeddea6c5359R333)
+	    //   and emitRequestTimeout
+	    const timeout = getSocketTimeout(socket);
+	    const req = socket._httpMessage;
+	    const reqTimeoutListenerCount = req && req.listeners('timeout').length || 0;
+	    debug('%s(requests: %s, finished: %s) timeout after %sms, listeners %s, defaultTimeoutListenerCount %s, hasHttpRequest %s, HttpRequest timeoutListenerCount %s',
+	      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
+	      timeout, listenerCount, defaultTimeoutListenerCount, !!req, reqTimeoutListenerCount);
+	    if (debug.enabled) {
+	      debug('timeout listeners: %s', socket.listeners('timeout').map(f => f.name).join(', '));
+	    }
+	    agent.timeoutSocketCount++;
+	    const name = agent.getName(options);
+	    if (agent.freeSockets[name] && agent.freeSockets[name].indexOf(socket) !== -1) {
+	      // free socket timeout, destroy quietly
+	      socket.destroy();
+	      // Remove it from freeSockets list immediately to prevent new requests
+	      // from being sent through this socket.
+	      agent.removeSocket(socket, options);
+	      debug('%s is free, destroy quietly', socket[SOCKET_NAME]);
+	    } else {
+	      // if there is no any request socket timeout handler,
+	      // agent need to handle socket timeout itself.
+	      //
+	      // custom request socket timeout handle logic must follow these rules:
+	      //  1. Destroy socket first
+	      //  2. Must emit socket 'agentRemove' event tell agent remove socket
+	      //     from freeSockets list immediately.
+	      //     Otherise you may be get 'socket hang up' error when reuse
+	      //     free socket and timeout happen in the same time.
+	      if (reqTimeoutListenerCount === 0) {
+	        const error = new Error('Socket timeout');
+	        error.code = 'ERR_SOCKET_TIMEOUT';
+	        error.timeout = timeout;
+	        // must manually call socket.end() or socket.destroy() to end the connection.
+	        // https://nodejs.org/dist/latest-v10.x/docs/api/net.html#net_socket_settimeout_timeout_callback
+	        socket.destroy(error);
+	        agent.removeSocket(socket, options);
+	        debug('%s destroy with timeout error', socket[SOCKET_NAME]);
+	      }
+	    }
+	  }
+	  socket.on('timeout', onTimeout);
+
+	  function onError(err) {
+	    const listenerCount = socket.listeners('error').length;
+	    debug('%s(requests: %s, finished: %s) error: %s, listenerCount: %s',
+	      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
+	      err, listenerCount);
+	    agent.errorSocketCount++;
+	    if (listenerCount === 1) {
+	      // if socket don't contain error event handler, don't catch it, emit it again
+	      debug('%s emit uncaught error event', socket[SOCKET_NAME]);
+	      socket.removeListener('error', onError);
+	      socket.emit('error', err);
+	    }
+	  }
+	  socket.on('error', onError);
+
+	  function onRemove() {
+	    debug('%s(requests: %s, finished: %s) agentRemove',
+	      socket[SOCKET_NAME],
+	      socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
+	    // We need this function for cases like HTTP 'upgrade'
+	    // (defined by WebSockets) where we need to remove a socket from the
+	    // pool because it'll be locked up indefinitely
+	    socket.removeListener('close', onClose);
+	    socket.removeListener('error', onError);
+	    socket.removeListener('free', onFree);
+	    socket.removeListener('timeout', onTimeout);
+	    socket.removeListener('agentRemove', onRemove);
+	  }
+	  socket.on('agentRemove', onRemove);
+	}
 
-// node 8 don't has timeout attribute on socket
-// https://github.com/nodejs/node/pull/21204/files#diff-e6ef024c3775d787c38487a6309e491dR408
-function getSocketTimeout(socket) {
-  return socket.timeout || socket._idleTimeout;
-}
+	agent = Agent;
 
-function installListeners(agent, socket, options) {
-  debug('%s create, timeout %sms', socket[SOCKET_NAME], getSocketTimeout(socket));
-
-  // listener socket events: close, timeout, error, free
-  function onFree() {
-    // create and socket.emit('free') logic
-    // https://github.com/nodejs/node/blob/master/lib/_http_agent.js#L311
-    // no req on the socket, it should be the new socket
-    if (!socket._httpMessage && socket[SOCKET_REQUEST_COUNT] === 1) return;
-
-    socket[SOCKET_REQUEST_FINISHED_COUNT]++;
-    agent.requestCount++;
-    debug('%s(requests: %s, finished: %s) free',
-      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
-
-    // should reuse on pedding requests?
-    const name = agent.getName(options);
-    if (socket.writable && agent.requests[name] && agent.requests[name].length) {
-      // will be reuse on agent free listener
-      socket[SOCKET_REQUEST_COUNT]++;
-      debug('%s(requests: %s, finished: %s) will be reuse on agent free event',
-        socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
-    }
-  }
-  socket.on('free', onFree);
-
-  function onClose(isError) {
-    debug('%s(requests: %s, finished: %s) close, isError: %s',
-      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT], isError);
-    agent.closeSocketCount++;
-  }
-  socket.on('close', onClose);
-
-  // start socket timeout handler
-  function onTimeout() {
-    // onTimeout and emitRequestTimeout(_http_client.js)
-    // https://github.com/nodejs/node/blob/v12.x/lib/_http_client.js#L711
-    const listenerCount = socket.listeners('timeout').length;
-    // node <= 10, default listenerCount is 1, onTimeout
-    // 11 < node <= 12, default listenerCount is 2, onTimeout and emitRequestTimeout
-    // node >= 13, default listenerCount is 3, onTimeout,
-    //   onTimeout(https://github.com/nodejs/node/pull/32000/files#diff-5f7fb0850412c6be189faeddea6c5359R333)
-    //   and emitRequestTimeout
-    const timeout = getSocketTimeout(socket);
-    const req = socket._httpMessage;
-    const reqTimeoutListenerCount = req && req.listeners('timeout').length || 0;
-    debug('%s(requests: %s, finished: %s) timeout after %sms, listeners %s, defaultTimeoutListenerCount %s, hasHttpRequest %s, HttpRequest timeoutListenerCount %s',
-      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
-      timeout, listenerCount, defaultTimeoutListenerCount, !!req, reqTimeoutListenerCount);
-    if (debug.enabled) {
-      debug('timeout listeners: %s', socket.listeners('timeout').map(f => f.name).join(', '));
-    }
-    agent.timeoutSocketCount++;
-    const name = agent.getName(options);
-    if (agent.freeSockets[name] && agent.freeSockets[name].indexOf(socket) !== -1) {
-      // free socket timeout, destroy quietly
-      socket.destroy();
-      // Remove it from freeSockets list immediately to prevent new requests
-      // from being sent through this socket.
-      agent.removeSocket(socket, options);
-      debug('%s is free, destroy quietly', socket[SOCKET_NAME]);
-    } else {
-      // if there is no any request socket timeout handler,
-      // agent need to handle socket timeout itself.
-      //
-      // custom request socket timeout handle logic must follow these rules:
-      //  1. Destroy socket first
-      //  2. Must emit socket 'agentRemove' event tell agent remove socket
-      //     from freeSockets list immediately.
-      //     Otherise you may be get 'socket hang up' error when reuse
-      //     free socket and timeout happen in the same time.
-      if (reqTimeoutListenerCount === 0) {
-        const error = new Error('Socket timeout');
-        error.code = 'ERR_SOCKET_TIMEOUT';
-        error.timeout = timeout;
-        // must manually call socket.end() or socket.destroy() to end the connection.
-        // https://nodejs.org/dist/latest-v10.x/docs/api/net.html#net_socket_settimeout_timeout_callback
-        socket.destroy(error);
-        agent.removeSocket(socket, options);
-        debug('%s destroy with timeout error', socket[SOCKET_NAME]);
-      }
-    }
-  }
-  socket.on('timeout', onTimeout);
-
-  function onError(err) {
-    const listenerCount = socket.listeners('error').length;
-    debug('%s(requests: %s, finished: %s) error: %s, listenerCount: %s',
-      socket[SOCKET_NAME], socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT],
-      err, listenerCount);
-    agent.errorSocketCount++;
-    if (listenerCount === 1) {
-      // if socket don't contain error event handler, don't catch it, emit it again
-      debug('%s emit uncaught error event', socket[SOCKET_NAME]);
-      socket.removeListener('error', onError);
-      socket.emit('error', err);
-    }
-  }
-  socket.on('error', onError);
-
-  function onRemove() {
-    debug('%s(requests: %s, finished: %s) agentRemove',
-      socket[SOCKET_NAME],
-      socket[SOCKET_REQUEST_COUNT], socket[SOCKET_REQUEST_FINISHED_COUNT]);
-    // We need this function for cases like HTTP 'upgrade'
-    // (defined by WebSockets) where we need to remove a socket from the
-    // pool because it'll be locked up indefinitely
-    socket.removeListener('close', onClose);
-    socket.removeListener('error', onError);
-    socket.removeListener('free', onFree);
-    socket.removeListener('timeout', onTimeout);
-    socket.removeListener('agentRemove', onRemove);
-  }
-  socket.on('agentRemove', onRemove);
+	function inspect(obj) {
+	  const res = {};
+	  for (const key in obj) {
+	    res[key] = obj[key].length;
+	  }
+	  return res;
+	}
+	return agent;
 }
 
-var agent = Agent;
+var https_agent;
+var hasRequiredHttps_agent;
+
+function requireHttps_agent () {
+	if (hasRequiredHttps_agent) return https_agent;
+	hasRequiredHttps_agent = 1;
+
+	const OriginalHttpsAgent = require$$0$2.Agent;
+	const HttpAgent = /*@__PURE__*/ requireAgent();
+	const {
+	  INIT_SOCKET,
+	  CREATE_HTTPS_CONNECTION,
+	} = /*@__PURE__*/ requireConstants();
+
+	class HttpsAgent extends HttpAgent {
+	  constructor(options) {
+	    super(options);
+
+	    this.defaultPort = 443;
+	    this.protocol = 'https:';
+	    this.maxCachedSessions = this.options.maxCachedSessions;
+	    /* istanbul ignore next */
+	    if (this.maxCachedSessions === undefined) {
+	      this.maxCachedSessions = 100;
+	    }
+
+	    this._sessionCache = {
+	      map: {},
+	      list: [],
+	    };
+	  }
+
+	  createConnection(options, oncreate) {
+	    const socket = this[CREATE_HTTPS_CONNECTION](options, oncreate);
+	    this[INIT_SOCKET](socket, options);
+	    return socket;
+	  }
+	}
 
-function inspect(obj) {
-  const res = {};
-  for (const key in obj) {
-    res[key] = obj[key].length;
-  }
-  return res;
+	// https://github.com/nodejs/node/blob/master/lib/https.js#L89
+	HttpsAgent.prototype[CREATE_HTTPS_CONNECTION] = OriginalHttpsAgent.prototype.createConnection;
+
+	[
+	  'getName',
+	  '_getSession',
+	  '_cacheSession',
+	  // https://github.com/nodejs/node/pull/4982
+	  '_evictSession',
+	].forEach(function(method) {
+	  /* istanbul ignore next */
+	  if (typeof OriginalHttpsAgent.prototype[method] === 'function') {
+	    HttpsAgent.prototype[method] = OriginalHttpsAgent.prototype[method];
+	  }
+	});
+
+	https_agent = HttpsAgent;
+	return https_agent;
 }
 
-const OriginalHttpsAgent = require$$0$2.Agent;
-const HttpAgent = agent;
-const {
-  INIT_SOCKET,
-  CREATE_HTTPS_CONNECTION,
-} = constants;
-
-let HttpsAgent$1 = class HttpsAgent extends HttpAgent {
-  constructor(options) {
-    super(options);
-
-    this.defaultPort = 443;
-    this.protocol = 'https:';
-    this.maxCachedSessions = this.options.maxCachedSessions;
-    /* istanbul ignore next */
-    if (this.maxCachedSessions === undefined) {
-      this.maxCachedSessions = 100;
-    }
-
-    this._sessionCache = {
-      map: {},
-      list: [],
-    };
-  }
-
-  createConnection(options, oncreate) {
-    const socket = this[CREATE_HTTPS_CONNECTION](options, oncreate);
-    this[INIT_SOCKET](socket, options);
-    return socket;
-  }
-};
-
-// https://github.com/nodejs/node/blob/master/lib/https.js#L89
-HttpsAgent$1.prototype[CREATE_HTTPS_CONNECTION] = OriginalHttpsAgent.prototype.createConnection;
-
-[
-  'getName',
-  '_getSession',
-  '_cacheSession',
-  // https://github.com/nodejs/node/pull/4982
-  '_evictSession',
-].forEach(function(method) {
-  /* istanbul ignore next */
-  if (typeof OriginalHttpsAgent.prototype[method] === 'function') {
-    HttpsAgent$1.prototype[method] = OriginalHttpsAgent.prototype[method];
-  }
-});
+var hasRequiredAgentkeepalive;
 
-var https_agent = HttpsAgent$1;
+function requireAgentkeepalive () {
+	if (hasRequiredAgentkeepalive) return agentkeepalive.exports;
+	hasRequiredAgentkeepalive = 1;
 
-agentkeepalive.exports = agent;
-var HttpsAgent = agentkeepalive.exports.HttpsAgent = https_agent;
-agentkeepalive.exports.constants = constants;
+	agentkeepalive.exports = /*@__PURE__*/ requireAgent();
+	agentkeepalive.exports.HttpsAgent = /*@__PURE__*/ requireHttps_agent();
+	agentkeepalive.exports.constants = /*@__PURE__*/ requireConstants();
+	return agentkeepalive.exports;
+}
 
-var agentkeepaliveExports = agentkeepalive.exports;
+var agentkeepaliveExports = /*@__PURE__*/ requireAgentkeepalive();
 var HttpKeepAliveAgent = /*@__PURE__*/getDefaultExportFromCjs(agentkeepaliveExports);
 
-var objToString = Object.prototype.toString;
-var objKeys = Object.keys || function(obj) {
-		var keys = [];
-		for (var name in obj) {
-			keys.push(name);
-		}
-		return keys;
-	};
+var fastStableStringify$1;
+var hasRequiredFastStableStringify;
+
+function requireFastStableStringify () {
+	if (hasRequiredFastStableStringify) return fastStableStringify$1;
+	hasRequiredFastStableStringify = 1;
+	var objToString = Object.prototype.toString;
+	var objKeys = Object.keys || function(obj) {
+			var keys = [];
+			for (var name in obj) {
+				keys.push(name);
+			}
+			return keys;
+		};
 
-function stringify(val, isArrayProp) {
-	var i, max, str, keys, key, propVal, toStr;
-	if (val === true) {
-		return "true";
-	}
-	if (val === false) {
-		return "false";
-	}
-	switch (typeof val) {
-		case "object":
-			if (val === null) {
-				return null;
-			} else if (val.toJSON && typeof val.toJSON === "function") {
-				return stringify(val.toJSON(), isArrayProp);
-			} else {
-				toStr = objToString.call(val);
-				if (toStr === "[object Array]") {
-					str = '[';
-					max = val.length - 1;
-					for(i = 0; i < max; i++) {
-						str += stringify(val[i], true) + ',';
-					}
-					if (max > -1) {
-						str += stringify(val[i], true);
-					}
-					return str + ']';
-				} else if (toStr === "[object Object]") {
-					// only object is left
-					keys = objKeys(val).sort();
-					max = keys.length;
-					str = "";
-					i = 0;
-					while (i < max) {
-						key = keys[i];
-						propVal = stringify(val[key], false);
-						if (propVal !== undefined) {
-							if (str) {
-								str += ',';
+	function stringify(val, isArrayProp) {
+		var i, max, str, keys, key, propVal, toStr;
+		if (val === true) {
+			return "true";
+		}
+		if (val === false) {
+			return "false";
+		}
+		switch (typeof val) {
+			case "object":
+				if (val === null) {
+					return null;
+				} else if (val.toJSON && typeof val.toJSON === "function") {
+					return stringify(val.toJSON(), isArrayProp);
+				} else {
+					toStr = objToString.call(val);
+					if (toStr === "[object Array]") {
+						str = '[';
+						max = val.length - 1;
+						for(i = 0; i < max; i++) {
+							str += stringify(val[i], true) + ',';
+						}
+						if (max > -1) {
+							str += stringify(val[i], true);
+						}
+						return str + ']';
+					} else if (toStr === "[object Object]") {
+						// only object is left
+						keys = objKeys(val).sort();
+						max = keys.length;
+						str = "";
+						i = 0;
+						while (i < max) {
+							key = keys[i];
+							propVal = stringify(val[key], false);
+							if (propVal !== undefined) {
+								if (str) {
+									str += ',';
+								}
+								str += JSON.stringify(key) + ':' + propVal;
 							}
-							str += JSON.stringify(key) + ':' + propVal;
+							i++;
 						}
-						i++;
+						return '{' + str + '}';
+					} else {
+						return JSON.stringify(val);
 					}
-					return '{' + str + '}';
-				} else {
-					return JSON.stringify(val);
 				}
-			}
-		case "function":
-		case "undefined":
-			return isArrayProp ? null : undefined;
-		case "string":
-			return JSON.stringify(val);
-		default:
-			return isFinite(val) ? val : null;
+			case "function":
+			case "undefined":
+				return isArrayProp ? null : undefined;
+			case "string":
+				return JSON.stringify(val);
+			default:
+				return isFinite(val) ? val : null;
+		}
 	}
-}
 
-var fastStableStringify = function(val) {
-	var returnVal = stringify(val, false);
-	if (returnVal !== undefined) {
-		return ''+ returnVal;
-	}
-};
+	fastStableStringify$1 = function(val) {
+		var returnVal = stringify(val, false);
+		if (returnVal !== undefined) {
+			return ''+ returnVal;
+		}
+	};
+	return fastStableStringify$1;
+}
 
-var fastStableStringify$1 = /*@__PURE__*/getDefaultExportFromCjs(fastStableStringify);
+var fastStableStringifyExports = /*@__PURE__*/ requireFastStableStringify();
+var fastStableStringify = /*@__PURE__*/getDefaultExportFromCjs(fastStableStringifyExports);
 
 const MINIMUM_SLOT_PER_EPOCH = 32;
 
@@ -4930,7 +4991,7 @@ function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disable
           maxSockets: 25
         };
         if (url.startsWith('https:')) {
-          agent = new HttpsAgent(agentOptions);
+          agent = new agentkeepaliveExports.HttpsAgent(agentOptions);
         } else {
           agent = new HttpKeepAliveAgent(agentOptions);
         }
@@ -4938,9 +4999,9 @@ function createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disable
     } else {
       if (httpAgent !== false) {
         const isHttps = url.startsWith('https:');
-        if (isHttps && !(httpAgent instanceof Agent$1)) {
+        if (isHttps && !(httpAgent instanceof Agent)) {
           throw new Error('The endpoint `' + url + '` can only be paired with an `https.Agent`. You have, instead, supplied an ' + '`http.Agent` through `httpAgent`.');
-        } else if (!isHttps && httpAgent instanceof Agent$1) {
+        } else if (!isHttps && httpAgent instanceof Agent) {
           throw new Error('The endpoint `' + url + '` can only be paired with an `http.Agent`. You have, instead, supplied an ' + '`https.Agent` through `httpAgent`.');
         }
         agent = httpAgent;
@@ -5897,7 +5958,7 @@ const LogsNotificationResult = type({
 
 /** @internal */
 const COMMON_HTTP_HEADERS = {
-  'solana-client': `js/${"0.0.0-development"}`
+  'solana-client': `js/${"1.0.0-maintenance"}`
 };
 
 /**
@@ -5990,7 +6051,7 @@ class Connection {
           config
         } = extractCommitmentFromConfig(commitmentOrConfig);
         const args = this._buildArgs([], commitment, undefined /* encoding */, config);
-        const requestHash = fastStableStringify$1(args);
+        const requestHash = fastStableStringify(args);
         requestPromises[requestHash] = requestPromises[requestHash] ?? (async () => {
           try {
             const unsafeRes = await this._rpcRequest('getBlockHeight', args);
@@ -8309,9 +8370,10 @@ class Connection {
               this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId] = subscription.callbacks;
               await this._updateSubscriptions();
             } catch (e) {
-              if (e instanceof Error) {
-                console.error(`${method} error for argument`, args, e.message);
-              }
+              console.error(`Received ${e instanceof Error ? '' : 'JSON-RPC '}error calling \`${method}\``, {
+                args,
+                error: e
+              });
               if (!isCurrentConnectionStillActive()) {
                 return;
               }
@@ -8447,7 +8509,7 @@ class Connection {
    */
   args) {
     const clientSubscriptionId = this._nextClientSubscriptionId++;
-    const hash = fastStableStringify$1([subscriptionConfig.method, args]);
+    const hash = fastStableStringify([subscriptionConfig.method, args]);
     const existingSubscription = this._subscriptionsByHash[hash];
     if (existingSubscription === undefined) {
       this._subscriptionsByHash[hash] = {