@subql/node-ethereum 0.4.1-8 → 0.4.1-storeCache-0.0.3

package/dist/ethereum/ethers/json-rpc-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc-provider.js","sourceRoot":"","sources":["../../../src/ethereum/ethers/json-rpc-provider.ts"],"names":[],"mappings":";;;AAAA,oBAAoB;AACpB,0DAAqD;AACrD,4CAA+C;AAE/C,wDAAkF;AAIlF,SAAS,SAAS,CAAC,OAGlB;IACC,IAAI,OAAO,CAAC,KAAK,EAAE;QACjB,iBAAiB;QACjB,MAAM,KAAK,GAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpD,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;QAChC,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;QAChC,MAAM,KAAK,CAAC;KACb;IAED,OAAO,OAAO,CAAC,MAAM,CAAC;AACxB,CAAC;AAED,MAAa,eAAgB,SAAQ,2BAAmB;IACtD,YAAY,GAA4B,EAAE,OAAoB;QAC5D,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACtB,CAAC;IAED,IAAI,CAAC,MAAc,EAAE,MAAkB;QACrC,MAAM,OAAO,GAAG;YACd,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,MAAM;YACd,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE;YAClB,OAAO,EAAE,KAAK;SACf,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACjB,MAAM,EAAE,SAAS;YACjB,OAAO,EAAE,IAAA,qBAAQ,EAAC,OAAO,CAAC;YAC1B,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QAEH,kEAAkE;QAClE,sEAAsE;QACtE,MAAM,KAAK,GAAG,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACtE,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;YAChC,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SAC5B;QAED,MAAM,MAAM,GAAG,IAAA,eAAS,EACtB,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EACvB,SAAS,CACV,CAAC,IAAI,CACJ,CAAC,MAAM,EAAE,EAAE;YACT,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBACjB,MAAM,EAAE,UAAU;gBAClB,OAAO,EAAE,OAAO;gBAChB,QAAQ,EAAE,MAAM;gBAChB,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;YACR,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBACjB,MAAM,EAAE,UAAU;gBAClB,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,OAAO;gBAChB,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,MAAM,KAAK,CAAC;QACd,CAAC,CACF,CAAC;QAEF,uDAAuD;QACvD,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;YAC7B,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;YAC7B,CAAC,EAAE,CAAC,CAAC,CAAC;SACP;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA/DD,0CA+DC","sourcesContent":["/* eslint-disable */\nimport { deepCopy } from '@ethersproject/properties';\nimport { fetchJson } from '@ethersproject/web';\n\nimport { JsonRpcProvider as BaseJsonRpcProvider } from '@ethersproject/providers';\nimport { Networkish } from '@ethersproject/networks';\nimport { ConnectionInfo } from './web';\n\nfunction getResult(payload: {\n  error?: { code?: number; data?: any; message?: string };\n  result?: any;\n}): any {\n  if (payload.error) {\n    // @TODO: not any\n    const error: any = new Error(payload.error.message);\n    error.code = payload.error.code;\n    error.data = payload.error.data;\n    throw error;\n  }\n\n  return payload.result;\n}\n\nexport class JsonRpcProvider extends BaseJsonRpcProvider {\n  constructor(url: string | ConnectionInfo, network?: Networkish) {\n    super(url, network);\n  }\n\n  send(method: string, params: Array<any>): Promise<any> {\n    const request = {\n      method: method,\n      params: params,\n      id: this._nextId++,\n      jsonrpc: '2.0',\n    };\n\n    this.emit('debug', {\n      action: 'request',\n      request: deepCopy(request),\n      provider: this,\n    });\n\n    // We can expand this in the future to any call, but for now these\n    // are the biggest wins and do not require any serializing parameters.\n    const cache = ['eth_chainId', 'eth_blockNumber'].indexOf(method) >= 0;\n    if (cache && this._cache[method]) {\n      return this._cache[method];\n    }\n\n    const result = fetchJson(\n      this.connection,\n      JSON.stringify(request),\n      getResult,\n    ).then(\n      (result) => {\n        this.emit('debug', {\n          action: 'response',\n          request: request,\n          response: result,\n          provider: this,\n        });\n\n        return result;\n      },\n      (error) => {\n        this.emit('debug', {\n          action: 'response',\n          error: error,\n          request: request,\n          provider: this,\n        });\n\n        throw error;\n      },\n    );\n\n    // Cache the fetch, but clear it on the next event loop\n    if (cache) {\n      this._cache[method] = result;\n      setTimeout(() => {\n        this._cache[method] = null;\n      }, 0);\n    }\n\n    return result;\n  }\n}\n"]}

package/dist/ethereum/ethers/web/_version.d.ts

@@ -0,0 +1 @@
+export declare const version = "web/5.7.1";

package/dist/ethereum/ethers/web/_version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+/* eslint-disable */
+exports.version = 'web/5.7.1';
+//# sourceMappingURL=_version.js.map

package/dist/ethereum/ethers/web/_version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_version.js","sourceRoot":"","sources":["../../../../src/ethereum/ethers/web/_version.ts"],"names":[],"mappings":";;;AAAA,oBAAoB;AACP,QAAA,OAAO,GAAG,WAAW,CAAC","sourcesContent":["/* eslint-disable */\nexport const version = 'web/5.7.1';\n"]}

package/dist/ethereum/ethers/web/geturl.d.ts

@@ -0,0 +1,3 @@
+import type { GetUrlResponse, Options } from './types';
+export { GetUrlResponse, Options };
+export declare function getUrl(href: string, options?: Options): Promise<GetUrlResponse>;

package/dist/ethereum/ethers/web/geturl.js

@@ -0,0 +1,116 @@
+/* eslint-disable */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrl = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const zlib_1 = require("zlib");
+const url_1 = require("url");
+const bytes_1 = require("@ethersproject/bytes");
+const properties_1 = require("@ethersproject/properties");
+const logger_1 = require("@ethersproject/logger");
+const _version_1 = require("./_version");
+const logger = new logger_1.Logger(_version_1.version);
+function getResponse(request) {
+    return new Promise((resolve, reject) => {
+        request.once('response', (resp) => {
+            const response = {
+                statusCode: resp.statusCode,
+                statusMessage: resp.statusMessage,
+                headers: Object.keys(resp.headers).reduce((accum, name) => {
+                    let value = resp.headers[name];
+                    if (Array.isArray(value)) {
+                        value = value.join(', ');
+                    }
+                    accum[name] = value;
+                    return accum;
+                }, {}),
+                body: null,
+            };
+            //resp.setEncoding("utf8");
+            resp.on('data', (chunk) => {
+                if (response.body == null) {
+                    response.body = new Uint8Array(0);
+                }
+                response.body = (0, bytes_1.concat)([response.body, chunk]);
+            });
+            resp.on('end', () => {
+                if (response.headers['content-encoding'] === 'gzip') {
+                    //const size = response.body.length;
+                    response.body = (0, bytes_1.arrayify)((0, zlib_1.gunzipSync)(response.body));
+                    //console.log("Delta:", response.body.length - size, Buffer.from(response.body).toString());
+                }
+                resolve(response);
+            });
+            resp.on('error', (error) => {
+                /* istanbul ignore next */
+                error.response = response;
+                reject(error);
+            });
+        });
+        request.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+// The URL.parse uses null instead of the empty string
+function nonnull(value) {
+    if (value == null) {
+        return '';
+    }
+    return value;
+}
+async function getUrl(href, options) {
+    var _a, _b;
+    if (options == null) {
+        options = {};
+    }
+    // @TODO: Once we drop support for node 8, we can pass the href
+    //        directly into request and skip adding the components
+    //        to this request object
+    const url = (0, url_1.parse)(href);
+    const request = {
+        protocol: nonnull(url.protocol),
+        hostname: nonnull(url.hostname),
+        port: nonnull(url.port),
+        path: nonnull(url.pathname) + nonnull(url.search),
+        method: options.method || 'GET',
+        headers: (0, properties_1.shallowCopy)(options.headers || {}),
+        agent: null,
+    };
+    if (options.allowGzip) {
+        request.headers['accept-encoding'] = 'gzip';
+    }
+    let req = null;
+    switch (nonnull(url.protocol)) {
+        case 'http:':
+            if ((_a = options === null || options === void 0 ? void 0 : options.agents) === null || _a === void 0 ? void 0 : _a.http) {
+                request.agent = options.agents.http;
+            }
+            req = http_1.default.request(request);
+            break;
+        case 'https:':
+            if ((_b = options === null || options === void 0 ? void 0 : options.agents) === null || _b === void 0 ? void 0 : _b.https) {
+                request.agent = options.agents.https;
+            }
+            req = https_1.default.request(request);
+            break;
+        default:
+            /* istanbul ignore next */
+            logger.throwError(`unsupported protocol ${url.protocol}`, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
+                protocol: url.protocol,
+                operation: 'request',
+            });
+    }
+    if (options.body) {
+        req.write(Buffer.from(options.body));
+    }
+    req.end();
+    const response = await getResponse(req);
+    return response;
+}
+exports.getUrl = getUrl;
+//# sourceMappingURL=geturl.js.map

package/dist/ethereum/ethers/web/geturl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geturl.js","sourceRoot":"","sources":["../../../../src/ethereum/ethers/web/geturl.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\n'use strict';\n\nimport http from 'http';\nimport https from 'https';\nimport { gunzipSync } from 'zlib';\nimport { parse } from 'url';\n\nimport { arrayify, concat } from '@ethersproject/bytes';\nimport { shallowCopy } from '@ethersproject/properties';\n\nimport type { GetUrlResponse, Options } from './types';\n\nimport { Logger } from '@ethersproject/logger';\nimport { version } from './_version';\nconst logger = new Logger(version);\n\nexport { GetUrlResponse, Options };\n\nfunction getResponse(request: http.ClientRequest): Promise<GetUrlResponse> {\n  return new Promise((resolve, reject) => {\n    request.once('response', (resp: http.IncomingMessage) => {\n      const response: GetUrlResponse = {\n        statusCode: resp.statusCode,\n        statusMessage: resp.statusMessage,\n        headers: Object.keys(resp.headers).reduce((accum, name) => {\n          let value = resp.headers[name];\n          if (Array.isArray(value)) {\n            value = value.join(', ');\n          }\n          accum[name] = value;\n          return accum;\n        }, <{ [name: string]: string }>{}),\n        body: null,\n      };\n      //resp.setEncoding(\"utf8\");\n\n      resp.on('data', (chunk: Uint8Array) => {\n        if (response.body == null) {\n          response.body = new Uint8Array(0);\n        }\n        response.body = concat([response.body, chunk]);\n      });\n\n      resp.on('end', () => {\n        if (response.headers['content-encoding'] === 'gzip') {\n          //const size = response.body.length;\n          response.body = arrayify(gunzipSync(response.body));\n          //console.log(\"Delta:\", response.body.length - size, Buffer.from(response.body).toString());\n        }\n        resolve(response);\n      });\n\n      resp.on('error', (error) => {\n        /* istanbul ignore next */\n        (<any>error).response = response;\n        reject(error);\n      });\n    });\n\n    request.on('error', (error) => {\n      reject(error);\n    });\n  });\n}\n\n// The URL.parse uses null instead of the empty string\nfunction nonnull(value: string): string {\n  if (value == null) {\n    return '';\n  }\n  return value;\n}\n\nexport async function getUrl(\n  href: string,\n  options?: Options,\n): Promise<GetUrlResponse> {\n  if (options == null) {\n    options = {};\n  }\n\n  // @TODO: Once we drop support for node 8, we can pass the href\n  //        directly into request and skip adding the components\n  //        to this request object\n  const url = parse(href);\n\n  const request = {\n    protocol: nonnull(url.protocol),\n    hostname: nonnull(url.hostname),\n    port: nonnull(url.port),\n    path: nonnull(url.pathname) + nonnull(url.search),\n\n    method: options.method || 'GET',\n    headers: shallowCopy(options.headers || {}),\n    agent: null,\n  };\n\n  if (options.allowGzip) {\n    request.headers['accept-encoding'] = 'gzip';\n  }\n\n  let req: http.ClientRequest = null;\n  switch (nonnull(url.protocol)) {\n    case 'http:':\n      if (options?.agents?.http) {\n        request.agent = options.agents.http;\n      }\n      req = http.request(request);\n      break;\n    case 'https:':\n      if (options?.agents?.https) {\n        request.agent = options.agents.https;\n      }\n      req = https.request(request);\n      break;\n    default:\n      /* istanbul ignore next */\n      logger.throwError(\n        `unsupported protocol ${url.protocol}`,\n        Logger.errors.UNSUPPORTED_OPERATION,\n        {\n          protocol: url.protocol,\n          operation: 'request',\n        },\n      );\n  }\n\n  if (options.body) {\n    req.write(Buffer.from(options.body));\n  }\n  req.end();\n\n  const response = await getResponse(req);\n  return response;\n}\n"]}

package/dist/ethereum/ethers/web/index.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+export declare type ConnectionInfo = {
+    url: string;
+    headers?: {
+        [key: string]: string | number;
+    };
+    user?: string;
+    password?: string;
+    allowInsecureAuthentication?: boolean;
+    allowGzip?: boolean;
+    throttleLimit?: number;
+    throttleSlotInterval?: number;
+    throttleCallback?: (attempt: number, url: string) => Promise<boolean>;
+    skipFetchSetup?: boolean;
+    fetchOptions?: Record<string, string>;
+    errorPassThrough?: boolean;
+    timeout?: number;
+    agents?: {
+        http?: http.Agent;
+        https?: https.Agent;
+    };
+};
+export interface OnceBlockable {
+    once(eventName: 'block', handler: () => void): void;
+}
+export interface OncePollable {
+    once(eventName: 'poll', handler: () => void): void;
+}
+export declare type PollOptions = {
+    timeout?: number;
+    floor?: number;
+    ceiling?: number;
+    interval?: number;
+    retryLimit?: number;
+    onceBlock?: OnceBlockable;
+    oncePoll?: OncePollable;
+};
+export declare type FetchJsonResponse = {
+    statusCode: number;
+    headers: {
+        [header: string]: string;
+    };
+};
+export declare function _fetchData<T = Uint8Array>(connection: string | ConnectionInfo, body?: Uint8Array, processFunc?: (value: Uint8Array, response: FetchJsonResponse) => T): Promise<T>;
+export declare function fetchJson(connection: string | ConnectionInfo, json?: string, processFunc?: (value: any, response: FetchJsonResponse) => any): Promise<any>;
+export declare function poll<T>(func: () => Promise<T>, options?: PollOptions): Promise<T>;

package/dist/ethereum/ethers/web/index.js

@@ -0,0 +1,433 @@
+/* eslint-disable */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poll = exports.fetchJson = exports._fetchData = void 0;
+const base64_1 = require("@ethersproject/base64");
+const bytes_1 = require("@ethersproject/bytes");
+const properties_1 = require("@ethersproject/properties");
+const strings_1 = require("@ethersproject/strings");
+const logger_1 = require("@ethersproject/logger");
+const _version_1 = require("./_version");
+const logger = new logger_1.Logger(_version_1.version);
+const geturl_1 = require("./geturl");
+function staller(duration) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+}
+function bodyify(value, type) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if ((0, bytes_1.isBytesLike)(value)) {
+        if (type &&
+            (type.split('/')[0] === 'text' ||
+                type.split(';')[0].trim() === 'application/json')) {
+            try {
+                return (0, strings_1.toUtf8String)(value);
+            }
+            catch (error) { }
+        }
+        return (0, bytes_1.hexlify)(value);
+    }
+    return value;
+}
+function unpercent(value) {
+    return (0, strings_1.toUtf8Bytes)(value.replace(/%([0-9a-f][0-9a-f])/gi, (all, code) => {
+        return String.fromCharCode(parseInt(code, 16));
+    }));
+}
+// This API is still a work in progress; the future changes will likely be:
+// - ConnectionInfo => FetchDataRequest<T = any>
+// - FetchDataRequest.body? = string | Uint8Array | { contentType: string, data: string | Uint8Array }
+//   - If string => text/plain, Uint8Array => application/octet-stream (if content-type unspecified)
+// - FetchDataRequest.processFunc = (body: Uint8Array, response: FetchDataResponse) => T
+// For this reason, it should be considered internal until the API is finalized
+function _fetchData(connection, body, processFunc) {
+    // How many times to retry in the event of a throttle
+    const attemptLimit = typeof connection === 'object' && connection.throttleLimit != null
+        ? connection.throttleLimit
+        : 12;
+    logger.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, 'invalid connection throttle limit', 'connection.throttleLimit', attemptLimit);
+    const throttleCallback = typeof connection === 'object' ? connection.throttleCallback : null;
+    const throttleSlotInterval = typeof connection === 'object' &&
+        typeof connection.throttleSlotInterval === 'number'
+        ? connection.throttleSlotInterval
+        : 100;
+    logger.assertArgument(throttleSlotInterval > 0 && throttleSlotInterval % 1 === 0, 'invalid connection throttle slot interval', 'connection.throttleSlotInterval', throttleSlotInterval);
+    const errorPassThrough = typeof connection === 'object' ? !!connection.errorPassThrough : false;
+    const headers = {};
+    let url = null;
+    // @TODO: Allow ConnectionInfo to override some of these values
+    const options = {
+        method: 'GET',
+    };
+    let allow304 = false;
+    let timeout = 2 * 60 * 1000;
+    if (typeof connection === 'string') {
+        url = connection;
+    }
+    else if (typeof connection === 'object') {
+        if (connection == null || connection.url == null) {
+            logger.throwArgumentError('missing URL', 'connection.url', connection);
+        }
+        url = connection.url;
+        if (typeof connection.timeout === 'number' && connection.timeout > 0) {
+            timeout = connection.timeout;
+        }
+        if (connection.headers) {
+            for (const key in connection.headers) {
+                headers[key.toLowerCase()] = {
+                    key: key,
+                    value: String(connection.headers[key]),
+                };
+                if (['if-none-match', 'if-modified-since'].indexOf(key.toLowerCase()) >= 0) {
+                    allow304 = true;
+                }
+            }
+        }
+        options.allowGzip = !!connection.allowGzip;
+        if (connection.user != null && connection.password != null) {
+            if (url.substring(0, 6) !== 'https:' &&
+                connection.allowInsecureAuthentication !== true) {
+                logger.throwError('basic authentication requires a secure https url', logger_1.Logger.errors.INVALID_ARGUMENT, {
+                    argument: 'url',
+                    url: url,
+                    user: connection.user,
+                    password: '[REDACTED]',
+                });
+            }
+            const authorization = connection.user + ':' + connection.password;
+            headers['authorization'] = {
+                key: 'Authorization',
+                value: 'Basic ' + (0, base64_1.encode)((0, strings_1.toUtf8Bytes)(authorization)),
+            };
+        }
+        if (connection.skipFetchSetup != null) {
+            options.skipFetchSetup = !!connection.skipFetchSetup;
+        }
+        if (connection.fetchOptions != null) {
+            options.fetchOptions = (0, properties_1.shallowCopy)(connection.fetchOptions);
+        }
+        if (connection.agents != null) {
+            options.agents = connection.agents;
+        }
+    }
+    const reData = new RegExp('^data:([^;:]*)?(;base64)?,(.*)$', 'i');
+    const dataMatch = url ? url.match(reData) : null;
+    if (dataMatch) {
+        try {
+            const response = {
+                statusCode: 200,
+                statusMessage: 'OK',
+                headers: { 'content-type': dataMatch[1] || 'text/plain' },
+                body: dataMatch[2]
+                    ? (0, base64_1.decode)(dataMatch[3])
+                    : unpercent(dataMatch[3]),
+            };
+            let result = response.body;
+            if (processFunc) {
+                result = processFunc(response.body, response);
+            }
+            return Promise.resolve(result);
+        }
+        catch (error) {
+            logger.throwError('processing response error', logger_1.Logger.errors.SERVER_ERROR, {
+                body: bodyify(dataMatch[1], dataMatch[2]),
+                error: error,
+                requestBody: null,
+                requestMethod: 'GET',
+                url: url,
+            });
+        }
+    }
+    if (body) {
+        options.method = 'POST';
+        options.body = body;
+        if (headers['content-type'] == null) {
+            headers['content-type'] = {
+                key: 'Content-Type',
+                value: 'application/octet-stream',
+            };
+        }
+        if (headers['content-length'] == null) {
+            headers['content-length'] = {
+                key: 'Content-Length',
+                value: String(body.length),
+            };
+        }
+    }
+    const flatHeaders = {};
+    Object.keys(headers).forEach((key) => {
+        const header = headers[key];
+        flatHeaders[header.key] = header.value;
+    });
+    options.headers = flatHeaders;
+    const runningTimeout = (function () {
+        let timer = null;
+        const promise = new Promise(function (resolve, reject) {
+            if (timeout) {
+                timer = setTimeout(() => {
+                    if (timer == null) {
+                        return;
+                    }
+                    timer = null;
+                    reject(logger.makeError('timeout', logger_1.Logger.errors.TIMEOUT, {
+                        requestBody: bodyify(options.body, flatHeaders['content-type']),
+                        requestMethod: options.method,
+                        timeout: timeout,
+                        url: url,
+                    }));
+                }, timeout);
+            }
+        });
+        const cancel = function () {
+            if (timer == null) {
+                return;
+            }
+            clearTimeout(timer);
+            timer = null;
+        };
+        return { promise, cancel };
+    })();
+    const runningFetch = (async function () {
+        for (let attempt = 0; attempt < attemptLimit; attempt++) {
+            let response = null;
+            try {
+                response = await (0, geturl_1.getUrl)(url, options);
+                if (attempt < attemptLimit) {
+                    if (response.statusCode === 301 || response.statusCode === 302) {
+                        // Redirection; for now we only support absolute locataions
+                        const location = response.headers.location || '';
+                        if (options.method === 'GET' && location.match(/^https:/)) {
+                            url = response.headers.location;
+                            continue;
+                        }
+                    }
+                    else if (response.statusCode === 429) {
+                        // Exponential back-off throttling
+                        let tryAgain = true;
+                        if (throttleCallback) {
+                            tryAgain = await throttleCallback(attempt, url);
+                        }
+                        if (tryAgain) {
+                            let stall = 0;
+                            const retryAfter = response.headers['retry-after'];
+                            if (typeof retryAfter === 'string' &&
+                                retryAfter.match(/^[1-9][0-9]*$/)) {
+                                stall = parseInt(retryAfter) * 1000;
+                            }
+                            else {
+                                stall =
+                                    throttleSlotInterval *
+                                        parseInt(String(Math.random() * Math.pow(2, attempt)));
+                            }
+                            //console.log("Stalling 429");
+                            await staller(stall);
+                            continue;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                response = error.response;
+                if (response == null) {
+                    runningTimeout.cancel();
+                    logger.throwError('missing response', logger_1.Logger.errors.SERVER_ERROR, {
+                        requestBody: bodyify(options.body, flatHeaders['content-type']),
+                        requestMethod: options.method,
+                        serverError: error,
+                        url: url,
+                    });
+                }
+            }
+            let body = response.body;
+            if (allow304 && response.statusCode === 304) {
+                body = null;
+            }
+            else if (!errorPassThrough &&
+                (response.statusCode < 200 || response.statusCode >= 300)) {
+                runningTimeout.cancel();
+                logger.throwError('bad response', logger_1.Logger.errors.SERVER_ERROR, {
+                    status: response.statusCode,
+                    headers: response.headers,
+                    body: bodyify(body, response.headers ? response.headers['content-type'] : null),
+                    requestBody: bodyify(options.body, flatHeaders['content-type']),
+                    requestMethod: options.method,
+                    url: url,
+                });
+            }
+            if (processFunc) {
+                try {
+                    const result = await processFunc(body, response);
+                    runningTimeout.cancel();
+                    return result;
+                }
+                catch (error) {
+                    // Allow the processFunc to trigger a throttle
+                    if (error.throttleRetry && attempt < attemptLimit) {
+                        let tryAgain = true;
+                        if (throttleCallback) {
+                            tryAgain = await throttleCallback(attempt, url);
+                        }
+                        if (tryAgain) {
+                            const timeout = throttleSlotInterval *
+                                parseInt(String(Math.random() * Math.pow(2, attempt)));
+                            //console.log("Stalling callback");
+                            await staller(timeout);
+                            continue;
+                        }
+                    }
+                    runningTimeout.cancel();
+                    logger.throwError('processing response error', logger_1.Logger.errors.SERVER_ERROR, {
+                        body: bodyify(body, response.headers ? response.headers['content-type'] : null),
+                        error: error,
+                        requestBody: bodyify(options.body, flatHeaders['content-type']),
+                        requestMethod: options.method,
+                        url: url,
+                    });
+                }
+            }
+            runningTimeout.cancel();
+            // If we had a processFunc, it either returned a T or threw above.
+            // The "body" is now a Uint8Array.
+            return body;
+        }
+        return logger.throwError('failed response', logger_1.Logger.errors.SERVER_ERROR, {
+            requestBody: bodyify(options.body, flatHeaders['content-type']),
+            requestMethod: options.method,
+            url: url,
+        });
+    })();
+    return Promise.race([runningTimeout.promise, runningFetch]);
+}
+exports._fetchData = _fetchData;
+function fetchJson(connection, json, processFunc) {
+    let processJsonFunc = (value, response) => {
+        let result = null;
+        if (value != null) {
+            try {
+                result = JSON.parse((0, strings_1.toUtf8String)(value));
+            }
+            catch (error) {
+                logger.throwError('invalid JSON', logger_1.Logger.errors.SERVER_ERROR, {
+                    body: value,
+                    error: error,
+                });
+            }
+        }
+        if (processFunc) {
+            result = processFunc(result, response);
+        }
+        return result;
+    };
+    // If we have json to send, we must
+    // - add content-type of application/json (unless already overridden)
+    // - convert the json to bytes
+    let body = null;
+    if (json != null) {
+        body = (0, strings_1.toUtf8Bytes)(json);
+        // Create a connection with the content-type set for JSON
+        const updated = typeof connection === 'string'
+            ? { url: connection }
+            : (0, properties_1.shallowCopy)(connection);
+        if (updated.headers) {
+            const hasContentType = Object.keys(updated.headers).filter((k) => k.toLowerCase() === 'content-type').length !== 0;
+            if (!hasContentType) {
+                updated.headers = (0, properties_1.shallowCopy)(updated.headers);
+                updated.headers['content-type'] = 'application/json';
+            }
+        }
+        else {
+            updated.headers = { 'content-type': 'application/json' };
+        }
+        connection = updated;
+    }
+    return _fetchData(connection, body, processJsonFunc);
+}
+exports.fetchJson = fetchJson;
+function poll(func, options) {
+    if (!options) {
+        options = {};
+    }
+    options = (0, properties_1.shallowCopy)(options);
+    if (options.floor == null) {
+        options.floor = 0;
+    }
+    if (options.ceiling == null) {
+        options.ceiling = 10000;
+    }
+    if (options.interval == null) {
+        options.interval = 250;
+    }
+    return new Promise(function (resolve, reject) {
+        let timer = null;
+        let done = false;
+        // Returns true if cancel was successful. Unsuccessful cancel means we're already done.
+        const cancel = () => {
+            if (done) {
+                return false;
+            }
+            done = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            return true;
+        };
+        if (options.timeout) {
+            timer = setTimeout(() => {
+                if (cancel()) {
+                    reject(new Error('timeout'));
+                }
+            }, options.timeout);
+        }
+        const retryLimit = options.retryLimit;
+        let attempt = 0;
+        function check() {
+            return func().then(function (result) {
+                // If we have a result, or are allowed null then we're done
+                if (result !== undefined) {
+                    if (cancel()) {
+                        resolve(result);
+                    }
+                }
+                else if (options.oncePoll) {
+                    options.oncePoll.once('poll', check);
+                }
+                else if (options.onceBlock) {
+                    options.onceBlock.once('block', check);
+                    // Otherwise, exponential back-off (up to 10s) our next request
+                }
+                else if (!done) {
+                    attempt++;
+                    if (attempt > retryLimit) {
+                        if (cancel()) {
+                            reject(new Error('retry limit reached'));
+                        }
+                        return;
+                    }
+                    let timeout = options.interval *
+                        parseInt(String(Math.random() * Math.pow(2, attempt)));
+                    if (timeout < options.floor) {
+                        timeout = options.floor;
+                    }
+                    if (timeout > options.ceiling) {
+                        timeout = options.ceiling;
+                    }
+                    setTimeout(check, timeout);
+                }
+                return null;
+            }, function (error) {
+                if (cancel()) {
+                    reject(error);
+                }
+            });
+        }
+        check();
+    });
+}
+exports.poll = poll;
+//# sourceMappingURL=index.js.map