ccxt 4.2.11 → 4.2.13

package/dist/cjs/js/src/static_dependencies/node-fetch/index.js

@@ -0,0 +1,372 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var http = require('node:http');
+var https = require('node:https');
+var zlib = require('node:zlib');
+var Stream = require('node:stream');
+var node_buffer = require('node:buffer');
+var body = require('./body.js');
+var response = require('./response.js');
+var headers = require('./headers.js');
+var request = require('./request.js');
+var fetchError = require('./errors/fetch-error.js');
+var abortError = require('./errors/abort-error.js');
+var isRedirect = require('./utils/is-redirect.js');
+var is = require('./utils/is.js');
+var referrer = require('./utils/referrer.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib);
+var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream);
+
+/**
+ * Index.js
+ *
+ * a request API compatible with window.fetch
+ *
+ * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
+ */
+const supportedSchemas = new Set(['data:', 'http:', 'https:']);
+/**
+ * Fetch function
+ *
+ * @param   {string | URL | import('./request').default} url - Absolute url or Request instance
+ * @param   {*} [options_] - Fetch options
+ * @return  {Promise<import('./response').default>}
+ */
+async function fetch(url, options_) {
+    return new Promise((resolve, reject) => {
+        // Build request object
+        const request$1 = new request["default"](url, options_);
+        const { parsedURL, options } = request.getNodeRequestOptions(request$1);
+        if (!supportedSchemas.has(parsedURL.protocol)) {
+            throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
+        }
+        /*if (parsedURL.protocol === 'data:') {
+            const data = dataUriToBuffer(request.url);
+            const response = new Response(data, {headers: {'Content-Type': data.typeFull}});
+            resolve(response);
+            return;
+        }*/
+        // Wrap http.request into fetch
+        const send = (parsedURL.protocol === 'https:' ? https__default["default"] : http__default["default"]).request;
+        const { signal } = request$1;
+        let response$1 = null;
+        const abort = () => {
+            const error = new abortError.AbortError('The operation was aborted.');
+            reject(error);
+            if (request$1.body && request$1.body instanceof Stream__default["default"].Readable) {
+                request$1.body.destroy(error);
+            }
+            if (!response$1 || !response$1.body) {
+                return;
+            }
+            response$1.body.emit('error', error);
+        };
+        if (signal && signal.aborted) {
+            abort();
+            return;
+        }
+        const abortAndFinalize = () => {
+            abort();
+            finalize();
+        };
+        // Send request
+        const request_ = send(parsedURL.toString(), options);
+        if (signal) {
+            signal.addEventListener('abort', abortAndFinalize);
+        }
+        const finalize = () => {
+            request_.abort();
+            if (signal) {
+                signal.removeEventListener('abort', abortAndFinalize);
+            }
+        };
+        request_.on('error', error => {
+            reject(new fetchError.FetchError(`request to ${request$1.url} failed, reason: ${error.message}`, 'system', error));
+            finalize();
+        });
+        fixResponseChunkedTransferBadEnding(request_, error => {
+            if (response$1 && response$1.body) {
+                response$1.body.destroy(error);
+            }
+        });
+        /* c8 ignore next 18 */
+        if (process.version < 'v14') {
+            // Before Node.js 14, pipeline() does not fully support async iterators and does not always
+            // properly handle when the socket close/end events are out of order.
+            request_.on('socket', s => {
+                let endedWithEventsCount;
+                s.prependListener('end', () => {
+                    endedWithEventsCount = s._eventsCount;
+                });
+                s.prependListener('close', hadError => {
+                    // if end happened before close but the socket didn't emit an error, do it now
+                    if (response$1 && endedWithEventsCount < s._eventsCount && !hadError) {
+                        const error = new Error('Premature close');
+                        error.code = 'ERR_STREAM_PREMATURE_CLOSE';
+                        response$1.body.emit('error', error);
+                    }
+                });
+            });
+        }
+        request_.on('response', response_ => {
+            request_.setTimeout(0);
+            const headers$1 = headers.fromRawHeaders(response_.rawHeaders);
+            // HTTP fetch step 5
+            if (isRedirect.isRedirect(response_.statusCode)) {
+                // HTTP fetch step 5.2
+                const location = headers$1.get('Location');
+                // HTTP fetch step 5.3
+                let locationURL = null;
+                try {
+                    locationURL = location === null ? null : new URL(location, request$1.url);
+                }
+                catch {
+                    // error here can only be invalid URL in Location: header
+                    // do not throw when options.redirect == manual
+                    // let the user extract the errorneous redirect URL
+                    if (request$1.redirect !== 'manual') {
+                        reject(new fetchError.FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
+                        finalize();
+                        return;
+                    }
+                }
+                // HTTP fetch step 5.5
+                switch (request$1.redirect) {
+                    case 'error':
+                        reject(new fetchError.FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request$1.url}`, 'no-redirect'));
+                        finalize();
+                        return;
+                    case 'manual':
+                        // Nothing to do
+                        break;
+                    case 'follow': {
+                        // HTTP-redirect fetch step 2
+                        if (locationURL === null) {
+                            break;
+                        }
+                        // HTTP-redirect fetch step 5
+                        if (request$1.counter >= request$1.follow) {
+                            reject(new fetchError.FetchError(`maximum redirect reached at: ${request$1.url}`, 'max-redirect'));
+                            finalize();
+                            return;
+                        }
+                        // HTTP-redirect fetch step 6 (counter increment)
+                        // Create a new Request object.
+                        const requestOptions = {
+                            headers: new headers["default"](request$1.headers),
+                            follow: request$1.follow,
+                            counter: request$1.counter + 1,
+                            agent: request$1.agent,
+                            compress: request$1.compress,
+                            method: request$1.method,
+                            body: body.clone(request$1),
+                            signal: request$1.signal,
+                            size: request$1.size,
+                            referrer: request$1.referrer,
+                            referrerPolicy: request$1.referrerPolicy
+                        };
+                        // when forwarding sensitive headers like "Authorization",
+                        // "WWW-Authenticate", and "Cookie" to untrusted targets,
+                        // headers will be ignored when following a redirect to a domain
+                        // that is not a subdomain match or exact match of the initial domain.
+                        // For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
+                        // will forward the sensitive headers, but a redirect to "bar.com" will not.
+                        // headers will also be ignored when following a redirect to a domain using
+                        // a different protocol. For example, a redirect from "https://foo.com" to "http://foo.com"
+                        // will not forward the sensitive headers
+                        if (!is.isDomainOrSubdomain(request$1.url, locationURL) || !is.isSameProtocol(request$1.url, locationURL)) {
+                            for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
+                                requestOptions.headers.delete(name);
+                            }
+                        }
+                        // HTTP-redirect fetch step 9
+                        if (response_.statusCode !== 303 && request$1.body && options_.body instanceof Stream__default["default"].Readable) {
+                            reject(new fetchError.FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
+                            finalize();
+                            return;
+                        }
+                        // HTTP-redirect fetch step 11
+                        if (response_.statusCode === 303 || ((response_.statusCode === 301 || response_.statusCode === 302) && request$1.method === 'POST')) {
+                            requestOptions.method = 'GET';
+                            requestOptions.body = undefined;
+                            requestOptions.headers.delete('content-length');
+                        }
+                        // HTTP-redirect fetch step 14
+                        const responseReferrerPolicy = referrer.parseReferrerPolicyFromHeader(headers$1);
+                        if (responseReferrerPolicy) {
+                            requestOptions.referrerPolicy = responseReferrerPolicy;
+                        }
+                        // HTTP-redirect fetch step 15
+                        resolve(fetch(new request["default"](locationURL, requestOptions)));
+                        finalize();
+                        return;
+                    }
+                    default:
+                        return reject(new TypeError(`Redirect option '${request$1.redirect}' is not a valid value of RequestRedirect`));
+                }
+            }
+            // Prepare response
+            if (signal) {
+                response_.once('end', () => {
+                    signal.removeEventListener('abort', abortAndFinalize);
+                });
+            }
+            let body$1 = Stream.pipeline(response_, new Stream.PassThrough(), error => {
+                if (error) {
+                    reject(error);
+                }
+            });
+            // see https://github.com/nodejs/node/pull/29376
+            /* c8 ignore next 3 */
+            if (process.version < 'v12.10') {
+                response_.on('aborted', abortAndFinalize);
+            }
+            const responseOptions = {
+                url: request$1.url,
+                status: response_.statusCode,
+                statusText: response_.statusMessage,
+                headers: headers$1,
+                size: request$1.size,
+                counter: request$1.counter,
+                highWaterMark: request$1.highWaterMark
+            };
+            // HTTP-network fetch step 12.1.1.3
+            const codings = headers$1.get('Content-Encoding');
+            // HTTP-network fetch step 12.1.1.4: handle content codings
+            // in following scenarios we ignore compression support
+            // 1. compression support is disabled
+            // 2. HEAD request
+            // 3. no Content-Encoding header
+            // 4. no content response (204)
+            // 5. content not modified response (304)
+            if (!request$1.compress || request$1.method === 'HEAD' || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
+                response$1 = new response(body$1, responseOptions);
+                resolve(response$1);
+                return;
+            }
+            // For Node v6+
+            // Be less strict when decoding compressed responses, since sometimes
+            // servers send slightly invalid responses that are still accepted
+            // by common browsers.
+            // Always using Z_SYNC_FLUSH is what cURL does.
+            const zlibOptions = {
+                flush: zlib__default["default"].Z_SYNC_FLUSH,
+                finishFlush: zlib__default["default"].Z_SYNC_FLUSH
+            };
+            // For gzip
+            if (codings === 'gzip' || codings === 'x-gzip') {
+                body$1 = Stream.pipeline(body$1, zlib__default["default"].createGunzip(zlibOptions), error => {
+                    if (error) {
+                        reject(error);
+                    }
+                });
+                response$1 = new response(body$1, responseOptions);
+                resolve(response$1);
+                return;
+            }
+            // For deflate
+            if (codings === 'deflate' || codings === 'x-deflate') {
+                // Handle the infamous raw deflate response from old servers
+                // a hack for old IIS and Apache servers
+                const raw = Stream.pipeline(response_, new Stream.PassThrough(), error => {
+                    if (error) {
+                        reject(error);
+                    }
+                });
+                raw.once('data', chunk => {
+                    // See http://stackoverflow.com/questions/37519828
+                    if ((chunk[0] & 0x0F) === 0x08) {
+                        body$1 = Stream.pipeline(body$1, zlib__default["default"].createInflate(), error => {
+                            if (error) {
+                                reject(error);
+                            }
+                        });
+                    }
+                    else {
+                        body$1 = Stream.pipeline(body$1, zlib__default["default"].createInflateRaw(), error => {
+                            if (error) {
+                                reject(error);
+                            }
+                        });
+                    }
+                    response$1 = new response(body$1, responseOptions);
+                    resolve(response$1);
+                });
+                raw.once('end', () => {
+                    // Some old IIS servers return zero-length OK deflate responses, so
+                    // 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
+                    if (!response$1) {
+                        response$1 = new response(body$1, responseOptions);
+                        resolve(response$1);
+                    }
+                });
+                return;
+            }
+            // For br
+            if (codings === 'br') {
+                body$1 = Stream.pipeline(body$1, zlib__default["default"].createBrotliDecompress(), error => {
+                    if (error) {
+                        reject(error);
+                    }
+                });
+                response$1 = new response(body$1, responseOptions);
+                resolve(response$1);
+                return;
+            }
+            // Otherwise, use response as-is
+            response$1 = new response(body$1, responseOptions);
+            resolve(response$1);
+        });
+        // eslint-disable-next-line promise/prefer-await-to-then
+        body.writeToStream(request_, request$1).catch(reject);
+    });
+}
+function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+    const LAST_CHUNK = node_buffer.Buffer.from('0\r\n\r\n');
+    let isChunkedTransfer = false;
+    let properLastChunkReceived = false;
+    let previousChunk;
+    request.on('response', response => {
+        const { headers } = response;
+        isChunkedTransfer = headers['transfer-encoding'] === 'chunked' && !headers['content-length'];
+    });
+    request.on('socket', socket => {
+        const onSocketClose = () => {
+            if (isChunkedTransfer && !properLastChunkReceived) {
+                const error = new Error('Premature close');
+                error.code = 'ERR_STREAM_PREMATURE_CLOSE';
+                errorCallback(error);
+            }
+        };
+        const onData = buf => {
+            properLastChunkReceived = node_buffer.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
+            // Sometimes final 0-length chunk and end of message code are in separate packets
+            if (!properLastChunkReceived && previousChunk) {
+                properLastChunkReceived = (node_buffer.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 &&
+                    node_buffer.Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0);
+            }
+            previousChunk = buf;
+        };
+        socket.prependListener('close', onSocketClose);
+        socket.on('data', onData);
+        request.on('close', () => {
+            socket.removeListener('close', onSocketClose);
+            socket.removeListener('data', onData);
+        });
+    });
+}
+
+exports.Response = response;
+exports.Headers = headers["default"];
+exports.Request = request["default"];
+exports.FetchError = fetchError.FetchError;
+exports.AbortError = abortError.AbortError;
+exports.isRedirect = isRedirect.isRedirect;
+exports["default"] = fetch;

package/dist/cjs/js/src/static_dependencies/node-fetch/request.js

@@ -0,0 +1,273 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_url = require('node:url');
+var node_util = require('node:util');
+var headers = require('./headers.js');
+var body = require('./body.js');
+var is = require('./utils/is.js');
+var getSearch = require('./utils/get-search.js');
+var referrer = require('./utils/referrer.js');
+
+/**
+ * Request.js
+ *
+ * Request class contains server only options
+ *
+ * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
+ */
+const INTERNALS = Symbol('Request internals');
+/**
+ * Check if `obj` is an instance of Request.
+ *
+ * @param  {*} object
+ * @return {boolean}
+ */
+const isRequest = object => {
+    return (typeof object === 'object' &&
+        typeof object[INTERNALS] === 'object');
+};
+const doBadDataWarn = node_util.deprecate(() => { }, '.data is not a valid RequestInit property, use .body instead', 'https://github.com/node-fetch/node-fetch/issues/1000 (request)');
+/**
+ * Request class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#request-class
+ *
+ * @param   Mixed   input  Url or Request instance
+ * @param   Object  init   Custom options
+ * @return  Void
+ */
+class Request extends body["default"] {
+    constructor(input, init = {}) {
+        let parsedURL;
+        // Normalize input and force URL to be encoded as UTF-8 (https://github.com/node-fetch/node-fetch/issues/245)
+        if (isRequest(input)) {
+            parsedURL = new URL(input.url);
+        }
+        else {
+            parsedURL = new URL(input);
+            input = {};
+        }
+        if (parsedURL.username !== '' || parsedURL.password !== '') {
+            throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
+        }
+        let method = init.method || input.method || 'GET';
+        if (/^(delete|get|head|options|post|put)$/i.test(method)) {
+            method = method.toUpperCase();
+        }
+        if (!isRequest(init) && 'data' in init) {
+            doBadDataWarn();
+        }
+        // eslint-disable-next-line no-eq-null, eqeqeq
+        if ((init.body != null || (isRequest(input) && input.body !== null)) &&
+            (method === 'GET' || method === 'HEAD')) {
+            throw new TypeError('Request with GET/HEAD method cannot have body');
+        }
+        const inputBody = init.body ?
+            init.body :
+            (isRequest(input) && input.body !== null ?
+                body.clone(input) :
+                null);
+        super(inputBody, {
+            size: init.size || input.size || 0
+        });
+        const headers$1 = new headers["default"](init.headers || input.headers || {});
+        if (inputBody !== null && !headers$1.has('Content-Type')) {
+            const contentType = body.extractContentType(inputBody);
+            if (contentType) {
+                headers$1.set('Content-Type', contentType);
+            }
+        }
+        let signal = isRequest(input) ?
+            input.signal :
+            null;
+        if ('signal' in init) {
+            signal = init.signal;
+        }
+        // eslint-disable-next-line no-eq-null, eqeqeq
+        if (signal != null && !is.isAbortSignal(signal)) {
+            throw new TypeError('Expected signal to be an instanceof AbortSignal or EventTarget');
+        }
+        // §5.4, Request constructor steps, step 15.1
+        // eslint-disable-next-line no-eq-null, eqeqeq
+        let referrer = init.referrer == null ? input.referrer : init.referrer;
+        if (referrer === '') {
+            // §5.4, Request constructor steps, step 15.2
+            referrer = 'no-referrer';
+        }
+        else if (referrer) {
+            // §5.4, Request constructor steps, step 15.3.1, 15.3.2
+            const parsedReferrer = new URL(referrer);
+            // §5.4, Request constructor steps, step 15.3.3, 15.3.4
+            referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? 'client' : parsedReferrer;
+        }
+        else {
+            referrer = undefined;
+        }
+        this[INTERNALS] = {
+            method,
+            redirect: init.redirect || input.redirect || 'follow',
+            headers: headers$1,
+            parsedURL,
+            signal,
+            referrer
+        };
+        // Node-fetch-only options
+        this.follow = init.follow === undefined ? (input.follow === undefined ? 20 : input.follow) : init.follow;
+        this.compress = init.compress === undefined ? (input.compress === undefined ? true : input.compress) : init.compress;
+        this.counter = init.counter || input.counter || 0;
+        this.agent = init.agent || input.agent;
+        this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
+        this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
+        // §5.4, Request constructor steps, step 16.
+        // Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
+        this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || '';
+    }
+    /** @returns {string} */
+    get method() {
+        return this[INTERNALS].method;
+    }
+    /** @returns {string} */
+    get url() {
+        return node_url.format(this[INTERNALS].parsedURL);
+    }
+    /** @returns {Headers} */
+    get headers() {
+        return this[INTERNALS].headers;
+    }
+    get redirect() {
+        return this[INTERNALS].redirect;
+    }
+    /** @returns {AbortSignal} */
+    get signal() {
+        return this[INTERNALS].signal;
+    }
+    // https://fetch.spec.whatwg.org/#dom-request-referrer
+    get referrer() {
+        if (this[INTERNALS].referrer === 'no-referrer') {
+            return '';
+        }
+        if (this[INTERNALS].referrer === 'client') {
+            return 'about:client';
+        }
+        if (this[INTERNALS].referrer) {
+            return this[INTERNALS].referrer.toString();
+        }
+        return undefined;
+    }
+    get referrerPolicy() {
+        return this[INTERNALS].referrerPolicy;
+    }
+    set referrerPolicy(referrerPolicy) {
+        this[INTERNALS].referrerPolicy = referrer.validateReferrerPolicy(referrerPolicy);
+    }
+    /**
+     * Clone this request
+     *
+     * @return  Request
+     */
+    clone() {
+        return new Request(this);
+    }
+    get [Symbol.toStringTag]() {
+        return 'Request';
+    }
+}
+Object.defineProperties(Request.prototype, {
+    method: { enumerable: true },
+    url: { enumerable: true },
+    headers: { enumerable: true },
+    redirect: { enumerable: true },
+    clone: { enumerable: true },
+    signal: { enumerable: true },
+    referrer: { enumerable: true },
+    referrerPolicy: { enumerable: true }
+});
+/**
+ * Convert a Request to Node.js http request options.
+ *
+ * @param {Request} request - A Request instance
+ * @return The options object to be passed to http.request
+ */
+const getNodeRequestOptions = request => {
+    const { parsedURL } = request[INTERNALS];
+    const headers$1 = new headers["default"](request[INTERNALS].headers);
+    // Fetch step 1.3
+    if (!headers$1.has('Accept')) {
+        headers$1.set('Accept', '*/*');
+    }
+    // HTTP-network-or-cache fetch steps 2.4-2.7
+    let contentLengthValue = null;
+    if (request.body === null && /^(post|put)$/i.test(request.method)) {
+        contentLengthValue = '0';
+    }
+    if (request.body !== null) {
+        const totalBytes = body.getTotalBytes(request);
+        // Set Content-Length if totalBytes is a number (that is not NaN)
+        if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
+            contentLengthValue = String(totalBytes);
+        }
+    }
+    if (contentLengthValue) {
+        headers$1.set('Content-Length', contentLengthValue);
+    }
+    // 4.1. Main fetch, step 2.6
+    // > If request's referrer policy is the empty string, then set request's referrer policy to the
+    // > default referrer policy.
+    if (request.referrerPolicy === '') {
+        request.referrerPolicy = referrer.DEFAULT_REFERRER_POLICY;
+    }
+    // 4.1. Main fetch, step 2.7
+    // > If request's referrer is not "no-referrer", set request's referrer to the result of invoking
+    // > determine request's referrer.
+    if (request.referrer && request.referrer !== 'no-referrer') {
+        request[INTERNALS].referrer = referrer.determineRequestsReferrer(request);
+    }
+    else {
+        request[INTERNALS].referrer = 'no-referrer';
+    }
+    // 4.5. HTTP-network-or-cache fetch, step 6.9
+    // > If httpRequest's referrer is a URL, then append `Referer`/httpRequest's referrer, serialized
+    // >  and isomorphic encoded, to httpRequest's header list.
+    if (request[INTERNALS].referrer instanceof URL) {
+        headers$1.set('Referer', request.referrer);
+    }
+    // HTTP-network-or-cache fetch step 2.11
+    if (!headers$1.has('User-Agent')) {
+        headers$1.set('User-Agent', 'node-fetch');
+    }
+    // HTTP-network-or-cache fetch step 2.15
+    if (request.compress && !headers$1.has('Accept-Encoding')) {
+        headers$1.set('Accept-Encoding', 'gzip, deflate, br');
+    }
+    let { agent } = request;
+    if (typeof agent === 'function') {
+        agent = agent(parsedURL);
+    }
+    if (!headers$1.has('Connection') && !agent) {
+        headers$1.set('Connection', 'close');
+    }
+    // HTTP-network fetch step 4.2
+    // chunked encoding is handled by Node.js
+    const search = getSearch.getSearch(parsedURL);
+    // Pass the full URL directly to request(), but overwrite the following
+    // options:
+    const options = {
+        // Overwrite search to retain trailing ? (issue #776)
+        path: parsedURL.pathname + search,
+        // The following options are not expressed in the URL
+        method: request.method,
+        headers: headers$1[Symbol.for('nodejs.util.inspect.custom')](),
+        insecureHTTPParser: request.insecureHTTPParser,
+        agent
+    };
+    return {
+        /** @type {URL} */
+        parsedURL,
+        options
+    };
+};
+
+exports["default"] = Request;
+exports.getNodeRequestOptions = getNodeRequestOptions;