@bitgo/sdk-api 1.0.1-dev.0

package/dist/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@bitgo/sdk-api",
+    "version": "1.0.1-dev.0",
+    "description": "REST wrapper for BitGoJS",
+    "main": "./dist/src/index.js",
+    "web": "./dist/web/main.js",
+    "types": "./dist/src/index.d.ts",
+    "scripts": {
+        "build": "yarn tsc --build --incremental --verbose .",
+        "fmt": "prettier --write .",
+        "check-fmt": "prettier --check .",
+        "clean": "rm -r ./dist",
+        "precommit": "lint-staged",
+        "prepare": "npm run build",
+        "build-web": "webpack",
+        "build-web-prod": "webpack --mode=production --node-env=production",
+        "prepublishOnly": "npm run build-web-prod"
+    },
+    "author": "BitGo Inc.",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/BitGo/BitGoJS.git",
+        "directory": "modules/statics"
+    },
+    "husky": {
+        "hooks": {
+            "pre-commit": "lint-staged"
+        }
+    },
+    "lint-staged": {
+        "**/*.ts": [
+            "prettier --write",
+            "git add"
+        ]
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "nyc": {
+        "extension": [
+            ".ts"
+        ]
+    },
+    "dependencies": {
+        "@bitgo/sdk-core": "^1.0.1-dev.0",
+        "@bitgo/sjcl": "^1.0.1-dev.0",
+        "@bitgo/utxo-lib": "^2.2.2-dev.0",
+        "@types/superagent": "4.1.15",
+        "debug": "3.1.0",
+        "sanitize-html": "^1.27.5",
+        "superagent": "3.8.3",
+        "superagent-proxy": "3.0.0"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.17.8",
+        "@babel/preset-env": "^7.16.11",
+        "@webpack-cli/generators": "^2.4.2",
+        "babel-loader": "^8.2.4",
+        "html-webpack-plugin": "^5.5.0",
+        "webpack": "^5.70.0",
+        "webpack-cli": "^4.9.2",
+        "webpack-dev-server": "^4.7.4"
+    },
+    "gitHead": "e9d78e8064169cd03f12c111af18603de5c29e1b"
+}

package/dist/src/api.d.ts

@@ -0,0 +1,49 @@
+import * as superagent from 'superagent';
+import { VerifyResponseOptions } from './types';
+import { BitGoAPI } from './bitgoAPI';
+export interface BitGoRequest<ResultType = any> extends superagent.SuperAgentRequest {
+    result: (optionalField?: string) => Promise<ResultType>;
+}
+/**
+ * Add the bitgo-specific result() function on a superagent request.
+ *
+ * If the server response is successful, the `result()` function will return either the entire response body,
+ * or the field from the response body specified by the `optionalField` parameter if it is provided.
+ *
+ * If the server response with an error, `result()` will handle HTTP errors appropriately by
+ * rethrowing them as an `ApiResponseError` if possible, and otherwise rethrowing the underlying response error.
+ *
+ * @param req
+ */
+export declare function toBitgoRequest<ResponseResultType = any>(req: superagent.SuperAgentRequest): BitGoRequest<ResponseResultType>;
+/**
+ * Return a function which extracts the specified response body property from the response if successful,
+ * otherwise throw an `ApiErrorResponse` parsed from the response body.
+ * @param optionalField
+ */
+export declare function handleResponseResult<ResponseResultType>(optionalField?: string): (res: superagent.Response) => ResponseResultType;
+/**
+ * Handle an error or an error containing an HTTP response and use it to throw a well-formed error object.
+ *
+ * @param e
+ */
+export declare function handleResponseError(e: Error & {
+    response?: superagent.Response;
+}): never;
+/**
+ * Serialize request data based on the request content type
+ * Note: Not sure this is still needed or even useful. Consider removing.
+ * @param req
+ */
+export declare function serializeRequestData(req: superagent.Request): string | undefined;
+/**
+ * Set the superagent query string correctly for browsers or node.
+ * @param req
+ */
+export declare function setRequestQueryString(req: superagent.SuperAgentRequest): void;
+/**
+ * Verify that the response received from the server is signed correctly.
+ * Right now, it is very permissive with the timestamp variance.
+ */
+export declare function verifyResponse(bitgo: BitGoAPI, token: string | undefined, method: VerifyResponseOptions['method'], req: superagent.SuperAgentRequest, response: superagent.Response): superagent.Response;
+//# sourceMappingURL=api.d.ts.map

package/dist/src/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AAIzC,OAAO,EAAoB,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,MAAM,WAAW,YAAY,CAAC,UAAU,GAAG,GAAG,CAAE,SAAQ,UAAU,CAAC,iBAAiB;IAClF,MAAM,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,kBAAkB,GAAG,GAAG,EACrD,GAAG,EAAE,UAAU,CAAC,iBAAiB,GAChC,YAAY,CAAC,kBAAkB,CAAC,CASlC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,kBAAkB,EACrD,aAAa,CAAC,EAAE,MAAM,GACrB,CAAC,GAAG,EAAE,UAAU,CAAC,QAAQ,KAAK,kBAAkB,CAOlD;AAkBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,GAAG;IAAE,QAAQ,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAA;CAAE,GAAG,KAAK,CAKxF;AAgCD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,UAAU,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAkBhF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,CAAC,iBAAiB,GAAG,IAAI,CAwB7E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,EACf,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,qBAAqB,CAAC,QAAQ,CAAC,EACvC,GAAG,EAAE,UAAU,CAAC,iBAAiB,EACjC,QAAQ,EAAE,UAAU,CAAC,QAAQ,GAC5B,UAAU,CAAC,QAAQ,CA+CrB"}

package/dist/src/api.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyResponse = exports.setRequestQueryString = exports.serializeRequestData = exports.handleResponseError = exports.handleResponseResult = exports.toBitgoRequest = void 0;
+/**
+ * @prettier
+ */
+const debug_1 = require("debug");
+const eol = require("eol");
+const _ = require("lodash");
+const sanitizeHtml = require("sanitize-html");
+const superagent = require("superagent");
+const urlLib = require("url");
+const querystring = require("querystring");
+const types_1 = require("./types");
+const debug = debug_1.default('bitgo:api');
+/**
+ * Add the bitgo-specific result() function on a superagent request.
+ *
+ * If the server response is successful, the `result()` function will return either the entire response body,
+ * or the field from the response body specified by the `optionalField` parameter if it is provided.
+ *
+ * If the server response with an error, `result()` will handle HTTP errors appropriately by
+ * rethrowing them as an `ApiResponseError` if possible, and otherwise rethrowing the underlying response error.
+ *
+ * @param req
+ */
+function toBitgoRequest(req) {
+    return Object.assign(req, {
+        result(optionalField) {
+            return req.then((response) => handleResponseResult(optionalField)(response), (error) => handleResponseError(error));
+        },
+    });
+}
+exports.toBitgoRequest = toBitgoRequest;
+/**
+ * Return a function which extracts the specified response body property from the response if successful,
+ * otherwise throw an `ApiErrorResponse` parsed from the response body.
+ * @param optionalField
+ */
+function handleResponseResult(optionalField) {
+    return function (res) {
+        if (_.isNumber(res.status) && res.status >= 200 && res.status < 300) {
+            return optionalField ? res.body[optionalField] : res.body;
+        }
+        throw errFromResponse(res);
+    };
+}
+exports.handleResponseResult = handleResponseResult;
+/**
+ * Extract relevant information from a successful response (that is, a response with an HTTP status code
+ * between 200 and 299), but which resulted in an application specific error and use it to construct and
+ * throw an `ApiErrorResponse`.
+ *
+ * @param res
+ */
+function errFromResponse(res) {
+    const message = createResponseErrorString(res);
+    const status = res.status;
+    const result = res.body;
+    const invalidToken = _.has(res.header, 'x-auth-required') && res.header['x-auth-required'] === 'true';
+    const needsOtp = res.body.needsOTP !== undefined;
+    return new types_1.ApiResponseError(message, status, result, invalidToken, needsOtp);
+}
+/**
+ * Handle an error or an error containing an HTTP response and use it to throw a well-formed error object.
+ *
+ * @param e
+ */
+function handleResponseError(e) {
+    if (e.response) {
+        throw errFromResponse(e.response);
+    }
+    throw e;
+}
+exports.handleResponseError = handleResponseError;
+/**
+ * There are many ways a request can fail, and may ways information on that failure can be
+ * communicated to the client. This function tries to handle those cases and create a sane error string
+ * @param res Response from an HTTP request
+ */
+function createResponseErrorString(res) {
+    var _a;
+    let errString = res.status.toString(); // at the very least we'll have the status code
+    if ((_a = res.body) === null || _a === void 0 ? void 0 : _a.error) {
+        // this is the case we hope for, where the server gives us a nice error from the JSON body
+        errString = res.body.error;
+    }
+    else if (res.text) {
+        // if the response came back as text, we try to parse it as HTML and remove all tags, leaving us
+        // just the bare text, which we then trim of excessive newlines and limit to a certain length
+        try {
+            let sanitizedText = sanitizeHtml(res.text, { allowedTags: [] });
+            sanitizedText = sanitizedText.trim();
+            sanitizedText = eol.lf(sanitizedText); // use '\n' for all newlines
+            sanitizedText = _.replace(sanitizedText, /\n[ |\t]{1,}\n/g, '\n\n'); // remove the spaces/tabs between newlines
+            sanitizedText = _.replace(sanitizedText, /[\n]{3,}/g, '\n\n'); // have at most 2 consecutive newlines
+            sanitizedText = sanitizedText.substring(0, 5000); // prevent message from getting too large
+            errString = errString + '\n' + sanitizedText; // add it to our existing errString (at this point the more info the better!)
+        }
+        catch (e) {
+            // do nothing, the response's HTML was too wacky to be parsed cleanly
+            debug('got error with message "%s" while creating response error string from response: %s', e.message, res.text);
+        }
+    }
+    return errString;
+}
+/**
+ * Serialize request data based on the request content type
+ * Note: Not sure this is still needed or even useful. Consider removing.
+ * @param req
+ */
+function serializeRequestData(req) {
+    let data = req._data;
+    if (typeof data !== 'string') {
+        let contentType = req.get('Content-Type');
+        // Parse out just the content type from the header (ignore the charset)
+        if (contentType) {
+            contentType = contentType.split(';')[0];
+        }
+        let serialize = superagent.serialize[contentType];
+        if (!serialize && /[\/+]json\b/.test(contentType)) {
+            serialize = superagent.serialize['application/json'];
+        }
+        if (serialize) {
+            data = serialize(data);
+            req._data = data;
+            return data;
+        }
+    }
+}
+exports.serializeRequestData = serializeRequestData;
+/**
+ * Set the superagent query string correctly for browsers or node.
+ * @param req
+ */
+function setRequestQueryString(req) {
+    const urlDetails = urlLib.parse(req.url);
+    let queryString;
+    const query = req._query;
+    const qs = req.qs;
+    if (query && query.length > 0) {
+        // browser version
+        queryString = query.join('&');
+        req._query = [];
+    }
+    else if (qs) {
+        // node version
+        queryString = querystring.stringify(qs);
+        req.qs = null;
+    }
+    if (queryString) {
+        if (urlDetails.search) {
+            urlDetails.search += '&' + queryString;
+        }
+        else {
+            urlDetails.search = '?' + queryString;
+        }
+        req.url = urlLib.format(urlDetails);
+    }
+}
+exports.setRequestQueryString = setRequestQueryString;
+/**
+ * Verify that the response received from the server is signed correctly.
+ * Right now, it is very permissive with the timestamp variance.
+ */
+function verifyResponse(bitgo, token, method, req, response) {
+    // we can't verify the response if we're not authenticated
+    if (!req.isV2Authenticated || !req.authenticationToken) {
+        return response;
+    }
+    const verificationResponse = bitgo.verifyResponse({
+        url: req.url,
+        hmac: response.header.hmac,
+        statusCode: response.status,
+        text: response.text,
+        timestamp: response.header.timestamp,
+        token: req.authenticationToken,
+        method,
+    });
+    if (!verificationResponse.isValid) {
+        // calculate the HMAC
+        const receivedHmac = response.header.hmac;
+        const expectedHmac = verificationResponse.expectedHmac;
+        const signatureSubject = verificationResponse.signatureSubject;
+        // Log only the first 10 characters of the token to ensure the full token isn't logged.
+        const partialBitgoToken = token ? token.substring(0, 10) : '';
+        const errorDetails = {
+            expectedHmac,
+            receivedHmac,
+            hmacInput: signatureSubject,
+            requestToken: req.authenticationToken,
+            bitgoToken: partialBitgoToken,
+        };
+        debug('Invalid response HMAC: %O', errorDetails);
+        throw new types_1.ApiResponseError('invalid response HMAC, possible man-in-the-middle-attack', 511, errorDetails);
+    }
+    if (bitgo.getAuthVersion() === 3 && !verificationResponse.isInResponseValidityWindow) {
+        const errorDetails = {
+            timestamp: response.header.timestamp,
+            verificationTime: verificationResponse.verificationTime,
+        };
+        debug('Server response outside response validity time window: %O', errorDetails);
+        throw new types_1.ApiResponseError('server response outside response validity time window, possible man-in-the-middle-attack', 511, errorDetails);
+    }
+    return response;
+}
+exports.verifyResponse = verifyResponse;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport Debug from 'debug';\nimport * as eol from 'eol';\nimport * as _ from 'lodash';\nimport * as sanitizeHtml from 'sanitize-html';\nimport * as superagent from 'superagent';\nimport * as urlLib from 'url';\nimport * as querystring from 'querystring';\n\nimport { ApiResponseError, VerifyResponseOptions } from './types';\nimport { BitGoAPI } from './bitgoAPI';\n\nconst debug = Debug('bitgo:api');\n\nexport interface BitGoRequest<ResultType = any> extends superagent.SuperAgentRequest {\n  result: (optionalField?: string) => Promise<ResultType>;\n}\n\n/**\n * Add the bitgo-specific result() function on a superagent request.\n *\n * If the server response is successful, the `result()` function will return either the entire response body,\n * or the field from the response body specified by the `optionalField` parameter if it is provided.\n *\n * If the server response with an error, `result()` will handle HTTP errors appropriately by\n * rethrowing them as an `ApiResponseError` if possible, and otherwise rethrowing the underlying response error.\n *\n * @param req\n */\nexport function toBitgoRequest<ResponseResultType = any>(\n  req: superagent.SuperAgentRequest\n): BitGoRequest<ResponseResultType> {\n  return Object.assign(req, {\n    result(optionalField?: string) {\n      return req.then(\n        (response) => handleResponseResult<ResponseResultType>(optionalField)(response),\n        (error) => handleResponseError(error)\n      );\n    },\n  });\n}\n\n/**\n * Return a function which extracts the specified response body property from the response if successful,\n * otherwise throw an `ApiErrorResponse` parsed from the response body.\n * @param optionalField\n */\nexport function handleResponseResult<ResponseResultType>(\n  optionalField?: string\n): (res: superagent.Response) => ResponseResultType {\n  return function (res: superagent.Response): ResponseResultType {\n    if (_.isNumber(res.status) && res.status >= 200 && res.status < 300) {\n      return optionalField ? res.body[optionalField] : res.body;\n    }\n    throw errFromResponse(res);\n  };\n}\n\n/**\n * Extract relevant information from a successful response (that is, a response with an HTTP status code\n * between 200 and 299), but which resulted in an application specific error and use it to construct and\n * throw an `ApiErrorResponse`.\n *\n * @param res\n */\nfunction errFromResponse<ResponseBodyType>(res: superagent.Response): ApiResponseError {\n  const message = createResponseErrorString(res);\n  const status = res.status;\n  const result = res.body as ResponseBodyType;\n  const invalidToken = _.has(res.header, 'x-auth-required') && res.header['x-auth-required'] === 'true';\n  const needsOtp = res.body.needsOTP !== undefined;\n  return new ApiResponseError(message, status, result, invalidToken, needsOtp);\n}\n\n/**\n * Handle an error or an error containing an HTTP response and use it to throw a well-formed error object.\n *\n * @param e\n */\nexport function handleResponseError(e: Error & { response?: superagent.Response }): never {\n  if (e.response) {\n    throw errFromResponse(e.response);\n  }\n  throw e;\n}\n\n/**\n * There are many ways a request can fail, and may ways information on that failure can be\n * communicated to the client. This function tries to handle those cases and create a sane error string\n * @param res Response from an HTTP request\n */\nfunction createResponseErrorString(res: superagent.Response): string {\n  let errString = res.status.toString(); // at the very least we'll have the status code\n  if (res.body?.error) {\n    // this is the case we hope for, where the server gives us a nice error from the JSON body\n    errString = res.body.error;\n  } else if (res.text) {\n    // if the response came back as text, we try to parse it as HTML and remove all tags, leaving us\n    // just the bare text, which we then trim of excessive newlines and limit to a certain length\n    try {\n      let sanitizedText = sanitizeHtml(res.text, { allowedTags: [] });\n      sanitizedText = sanitizedText.trim();\n      sanitizedText = eol.lf(sanitizedText); // use '\\n' for all newlines\n      sanitizedText = _.replace(sanitizedText, /\\n[ |\\t]{1,}\\n/g, '\\n\\n'); // remove the spaces/tabs between newlines\n      sanitizedText = _.replace(sanitizedText, /[\\n]{3,}/g, '\\n\\n'); // have at most 2 consecutive newlines\n      sanitizedText = sanitizedText.substring(0, 5000); // prevent message from getting too large\n      errString = errString + '\\n' + sanitizedText; // add it to our existing errString (at this point the more info the better!)\n    } catch (e) {\n      // do nothing, the response's HTML was too wacky to be parsed cleanly\n      debug('got error with message \"%s\" while creating response error string from response: %s', e.message, res.text);\n    }\n  }\n\n  return errString;\n}\n\n/**\n * Serialize request data based on the request content type\n * Note: Not sure this is still needed or even useful. Consider removing.\n * @param req\n */\nexport function serializeRequestData(req: superagent.Request): string | undefined {\n  let data: string | Record<string, unknown> = (req as any)._data;\n  if (typeof data !== 'string') {\n    let contentType = req.get('Content-Type');\n    // Parse out just the content type from the header (ignore the charset)\n    if (contentType) {\n      contentType = contentType.split(';')[0];\n    }\n    let serialize = superagent.serialize[contentType];\n    if (!serialize && /[\\/+]json\\b/.test(contentType)) {\n      serialize = superagent.serialize['application/json'];\n    }\n    if (serialize) {\n      data = serialize(data);\n      (req as any)._data = data;\n      return data;\n    }\n  }\n}\n\n/**\n * Set the superagent query string correctly for browsers or node.\n * @param req\n */\nexport function setRequestQueryString(req: superagent.SuperAgentRequest): void {\n  const urlDetails = urlLib.parse(req.url);\n\n  let queryString: string | undefined;\n  const query: string[] = (req as any)._query;\n  const qs: { [key: string]: string } = (req as any).qs;\n  if (query && query.length > 0) {\n    // browser version\n    queryString = query.join('&');\n    (req as any)._query = [];\n  } else if (qs) {\n    // node version\n    queryString = querystring.stringify(qs);\n    (req as any).qs = null;\n  }\n\n  if (queryString) {\n    if (urlDetails.search) {\n      urlDetails.search += '&' + queryString;\n    } else {\n      urlDetails.search = '?' + queryString;\n    }\n    req.url = urlLib.format(urlDetails);\n  }\n}\n\n/**\n * Verify that the response received from the server is signed correctly.\n * Right now, it is very permissive with the timestamp variance.\n */\nexport function verifyResponse(\n  bitgo: BitGoAPI,\n  token: string | undefined,\n  method: VerifyResponseOptions['method'],\n  req: superagent.SuperAgentRequest,\n  response: superagent.Response\n): superagent.Response {\n  // we can't verify the response if we're not authenticated\n  if (!req.isV2Authenticated || !req.authenticationToken) {\n    return response;\n  }\n\n  const verificationResponse = bitgo.verifyResponse({\n    url: req.url,\n    hmac: response.header.hmac,\n    statusCode: response.status,\n    text: response.text,\n    timestamp: response.header.timestamp,\n    token: req.authenticationToken,\n    method,\n  });\n\n  if (!verificationResponse.isValid) {\n    // calculate the HMAC\n    const receivedHmac = response.header.hmac;\n    const expectedHmac = verificationResponse.expectedHmac;\n    const signatureSubject = verificationResponse.signatureSubject;\n    // Log only the first 10 characters of the token to ensure the full token isn't logged.\n    const partialBitgoToken = token ? token.substring(0, 10) : '';\n    const errorDetails = {\n      expectedHmac,\n      receivedHmac,\n      hmacInput: signatureSubject,\n      requestToken: req.authenticationToken,\n      bitgoToken: partialBitgoToken,\n    };\n    debug('Invalid response HMAC: %O', errorDetails);\n    throw new ApiResponseError('invalid response HMAC, possible man-in-the-middle-attack', 511, errorDetails);\n  }\n\n  if (bitgo.getAuthVersion() === 3 && !verificationResponse.isInResponseValidityWindow) {\n    const errorDetails = {\n      timestamp: response.header.timestamp,\n      verificationTime: verificationResponse.verificationTime,\n    };\n    debug('Server response outside response validity time window: %O', errorDetails);\n    throw new ApiResponseError(\n      'server response outside response validity time window, possible man-in-the-middle-attack',\n      511,\n      errorDetails\n    );\n  }\n  return response;\n}\n"]}

package/dist/src/bitgoAPI.d.ts

@@ -0,0 +1,111 @@
+import { BitGoRequest } from './api';
+import * as utxolib from '@bitgo/utxo-lib';
+import { EnvironmentName } from '@bitgo/sdk-core';
+import { AccessTokenOptions, IRequestTracer, PingOptions, AuthenticateOptions, CalculateHmacSubjectOptions, CalculateRequestHeadersOptions, CalculateRequestHmacOptions, ProcessedAuthenticationOptions, RequestHeaders, VerifyResponseInfo, VerifyResponseOptions, BitGoAPIOptions } from './types';
+export declare abstract class BitGoAPI {
+    protected static _constants: any;
+    protected static _constantsExpire: any;
+    protected static _testnetWarningMessage: boolean;
+    readonly env: EnvironmentName;
+    protected readonly _baseUrl: string;
+    protected readonly _baseApiUrl: string;
+    protected readonly _baseApiUrlV2: string;
+    protected readonly _env: EnvironmentName;
+    protected readonly _authVersion: Exclude<BitGoAPIOptions['authVersion'], undefined>;
+    protected _hmacVerification: boolean;
+    protected readonly _proxy?: string;
+    protected _extensionKey?: utxolib.ECPair.ECPairInterface;
+    protected _reqId?: IRequestTracer;
+    protected _token?: string;
+    protected _version: string;
+    protected _userAgent?: string;
+    constructor(params?: BitGoAPIOptions);
+    /**
+     * Return the current BitGo environment
+     */
+    getEnv(): EnvironmentName;
+    /**
+     * Return the current auth version used for requests to the BitGo server
+     */
+    getAuthVersion(): number;
+    /**
+     * This is a patching function which can apply our authorization
+     * headers to any outbound request.
+     * @param method
+     */
+    private requestPatch;
+    get(url: string): BitGoRequest;
+    post(url: string): BitGoRequest;
+    put(url: string): BitGoRequest;
+    del(url: string): BitGoRequest;
+    patch(url: string): BitGoRequest;
+    /**
+     * Calculate the HMAC for the given key and message
+     * @param key {String} - the key to use for the HMAC
+     * @param message {String} - the actual message to HMAC
+     * @returns {*} - the result of the HMAC operation
+     */
+    calculateHMAC(key: string, message: string): string;
+    /**
+     * Calculate the subject string that is to be HMAC'ed for a HTTP request or response
+     * @param urlPath request url, including query params
+     * @param text request body text
+     * @param timestamp request timestamp from `Date.now()`
+     * @param statusCode Only set for HTTP responses, leave blank for requests
+     * @param method request method
+     * @returns {string}
+     */
+    calculateHMACSubject({ urlPath, text, timestamp, statusCode, method }: CalculateHmacSubjectOptions): string;
+    /**
+     * Calculate the HMAC for an HTTP request
+     */
+    calculateRequestHMAC({ url: urlPath, text, timestamp, token, method }: CalculateRequestHmacOptions): string;
+    /**
+     * Calculate request headers with HMAC
+     */
+    calculateRequestHeaders({ url, text, token, method }: CalculateRequestHeadersOptions): RequestHeaders;
+    /**
+     * Verify the HMAC for an HTTP response
+     */
+    verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac, method, }: VerifyResponseOptions): VerifyResponseInfo;
+    /**
+     * Process the username, password and otp into an object containing the username and hashed password, ready to
+     * send to bitgo for authentication.
+     */
+    preprocessAuthenticationParams({ username, password, otp, forceSMS, extensible, trust, }: AuthenticateOptions): ProcessedAuthenticationOptions;
+    /**
+     * Fetch useful constant values from the BitGo server.
+     * These values do change infrequently, so they need to be fetched,
+     * but are unlikely to change during the lifetime of a BitGo object,
+     * so they can safely cached.
+     */
+    fetchConstants(): Promise<any>;
+    /**
+     * Create a url for calling BitGo platform APIs
+     * @param path
+     * @param version
+     */
+    url(path: string, version?: number): string;
+    /**
+     * Create a url for calling BitGo microservice APIs
+     */
+    microservicesUrl(path: string): string;
+    /**
+     * Gets the version of the BitGoJS package
+     */
+    version(): string;
+    /**
+     * Synchronous method for activating an access token.
+     */
+    authenticateWithAccessToken({ accessToken }: AccessTokenOptions): void;
+    /**
+     * Test connectivity to the server
+     * @param params
+     */
+    ping({ reqId }?: PingOptions): Promise<any>;
+    /**
+     * Set a request tracer to provide request IDs during multi-request workflows
+     */
+    setRequestTracer(reqTracer: IRequestTracer): void;
+}
+//# sourceMappingURL=bitgoAPI.d.ts.map

package/dist/src/bitgoAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitgoAPI.d.ts","sourceRoot":"","sources":["../../src/bitgoAPI.ts"],"names":[],"mappings":"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"}