@bitgo/sdk-api 1.3.0-dev.1 → 1.4.0

package/dist/src/v1/keychains.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * @hidden
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// Keychains Object
+// BitGo accessor to a user's keychain.
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const utxo_lib_1 = require("@bitgo/utxo-lib");
+const crypto_1 = require("crypto");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const _ = require('lodash');
+const Bluebird = require("bluebird");
+const co = Bluebird.coroutine;
+//
+// Constructor
+//
+const Keychains = function (bitgo) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+};
+//
+// isValid
+// Tests a xpub or xprv string to see if it is a valid keychain.
+//
+Keychains.prototype.isValid = function (params) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], []);
+    if (!_.isString(params.key) && !_.isObject(params.key)) {
+        throw new Error('key must be a string or object');
+    }
+    try {
+        if (!params.key.path) {
+            utxo_lib_1.bip32.fromBase58(params.key);
+        }
+        else {
+            utxo_lib_1.bip32.fromBase58(params.key.xpub).derivePath(sdk_core_1.sanitizeLegacyPath(params.key.path));
+        }
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+//
+// create
+// Create a new keychain locally.
+// Does not send the keychain to bitgo, only creates locally.
+// If |seed| is provided, used to seed the keychain.  Otherwise,
+// a random keychain is created.
+//
+Keychains.prototype.create = function (params) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], []);
+    let seed;
+    if (!params.seed) {
+        // An extended private key has both a normal 256 bit private key and a 256
+        // bit chain code, both of which must be random. 512 bits is therefore the
+        // maximum entropy and gives us maximum security against cracking.
+        seed = crypto_1.randomBytes(512 / 8);
+    }
+    else {
+        seed = params.seed;
+    }
+    const extendedKey = utxo_lib_1.bip32.fromSeed(seed);
+    const xpub = extendedKey.neutered().toBase58();
+    let ethAddress;
+    try {
+        ethAddress = sdk_core_1.Util.xpubToEthAddress(xpub);
+    }
+    catch (e) {
+        // ethereum is unavailable
+    }
+    return {
+        xpub: xpub,
+        xprv: extendedKey.toBase58(),
+        ethAddress: ethAddress,
+    };
+};
+// used by deriveLocal
+const apiResponse = function (status, result, message) {
+    const err = new Error(message);
+    err.status = status;
+    err.result = result;
+    return err;
+};
+//
+// deriveLocal
+// Locally derives a keychain from a top level BIP32 string, given a path.
+//
+Keychains.prototype.deriveLocal = function (params) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['path'], ['xprv', 'xpub']);
+    if (!params.xprv && !params.xpub) {
+        throw new Error('must provide an xpub or xprv for derivation.');
+    }
+    if (params.xprv && params.xpub) {
+        throw new Error('cannot provide both xpub and xprv');
+    }
+    let hdNode;
+    try {
+        hdNode = utxo_lib_1.bip32.fromBase58(params.xprv || params.xpub);
+    }
+    catch (e) {
+        throw apiResponse(400, {}, 'Unable to parse the xprv or xpub');
+    }
+    let derivedNode;
+    try {
+        derivedNode = hdNode.derivePath(sdk_core_1.sanitizeLegacyPath(params.path));
+    }
+    catch (e) {
+        throw apiResponse(400, {}, 'Unable to derive HD key from path');
+    }
+    const xpub = derivedNode.neutered().toBase58();
+    let ethAddress;
+    try {
+        ethAddress = sdk_core_1.Util.xpubToEthAddress(xpub);
+    }
+    catch (e) {
+        // ethereum is unavailable
+    }
+    return {
+        path: params.path,
+        xpub: xpub,
+        xprv: params.xprv && derivedNode.toBase58(),
+        ethAddress: ethAddress,
+    };
+};
+//
+// list
+// List the user's keychains
+//
+Keychains.prototype.list = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/keychain')).result('keychains'))
+        .then(function (keychains) {
+        keychains.map(function (keychain) {
+            if (keychain.xpub &&
+                keychain.ethAddress &&
+                sdk_core_1.Util.xpubToEthAddress &&
+                keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+                throw new Error('ethAddress and xpub do not match');
+            }
+        });
+        return keychains;
+    })
+        .nodeify(callback);
+};
+/**
+ * iterates through all keys associated with the user, decrypts them with the old password and encrypts them with the
+ * new password
+ * @param params.oldPassword {String} - The old password used for encrypting the key
+ * @param params.newPassword {String} - The new password to be used for encrypting the key
+ * @param callback
+ * @returns result.keychains {Object} - e.g.:
+ *  {
+ *    xpub1: encryptedPrv1,
+ *    xpub2: encryptedPrv2,
+ *    ...
+ *  }
+ *  @returns result.version {Number}
+ */
+Keychains.prototype.updatePassword = function (params, callback) {
+    return co(function* coUpdatePassword() {
+        sdk_core_1.common.validateParams(params, ['oldPassword', 'newPassword'], [], callback);
+        // @ts-expect-error - no implicit this
+        const encrypted = yield this.bitgo.post(this.bitgo.url('/user/encrypted')).result();
+        const newKeychains = {};
+        // @ts-expect-error - no implicit this
+        const self = this;
+        _.forOwn(encrypted.keychains, function keychainsForOwn(oldEncryptedXprv, xpub) {
+            try {
+                const decryptedPrv = self.bitgo.decrypt({ input: oldEncryptedXprv, password: params.oldPassword });
+                const newEncryptedPrv = self.bitgo.encrypt({ input: decryptedPrv, password: params.newPassword });
+                newKeychains[xpub] = newEncryptedPrv;
+            }
+            catch (e) {
+                // decrypting the keychain with the old password didn't work so we just keep it the way it is
+                newKeychains[xpub] = oldEncryptedXprv;
+            }
+        });
+        return { keychains: newKeychains, version: encrypted.version };
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// add
+// Add a new keychain
+//
+Keychains.prototype.add = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['xpub'], ['encryptedXprv', 'type', 'isLedger'], callback);
+    return Bluebird.resolve(this.bitgo
+        .post(this.bitgo.url('/keychain'))
+        .send({
+        xpub: params.xpub,
+        encryptedXprv: params.encryptedXprv,
+        type: params.type,
+        originalPasscodeEncryptionCode: params.originalPasscodeEncryptionCode,
+        isLedger: params.isLedger,
+    })
+        .result())
+        .then(function (keychain) {
+        if (keychain.xpub &&
+            keychain.ethAddress &&
+            sdk_core_1.Util.xpubToEthAddress &&
+            keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+            throw new Error('ethAddress and xpub do not match');
+        }
+        return keychain;
+    })
+        .nodeify(callback);
+};
+//
+// createBitGo
+// Add a new BitGo server keychain
+//
+Keychains.prototype.createBitGo = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/keychain/bitgo')).send(params).result())
+        .then(function (keychain) {
+        if (keychain.xpub &&
+            keychain.ethAddress &&
+            sdk_core_1.Util.xpubToEthAddress &&
+            keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+            throw new Error('ethAddress and xpub do not match');
+        }
+        return keychain;
+    })
+        .nodeify(callback);
+};
+//
+// createBackup
+// Create a new backup keychain through bitgo - often used for creating a keychain on a KRS
+//
+Keychains.prototype.createBackup = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['provider'], [], callback);
+    return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/keychain/backup')).send(params).result())
+        .then(function (keychain) {
+        // not all keychains have an xpub
+        if (keychain.xpub &&
+            keychain.ethAddress &&
+            sdk_core_1.Util.xpubToEthAddress &&
+            keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+            throw new Error('ethAddress and xpub do not match');
+        }
+        return keychain;
+    })
+        .nodeify(callback);
+};
+//
+// get
+// Fetch an existing keychain
+// Parameters include:
+//   xpub:  the xpub of the key to lookup (required)
+//
+Keychains.prototype.get = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], ['xpub', 'ethAddress'], callback);
+    if (!params.xpub && !params.ethAddress) {
+        throw new Error('xpub or ethAddress must be defined');
+    }
+    const id = params.xpub || params.ethAddress;
+    return Bluebird.resolve(this.bitgo
+        .post(this.bitgo.url('/keychain/' + encodeURIComponent(id)))
+        .send({})
+        .result())
+        .then(function (keychain) {
+        if (keychain.xpub &&
+            keychain.ethAddress &&
+            sdk_core_1.Util.xpubToEthAddress &&
+            keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+            throw new Error('ethAddress and xpub do not match');
+        }
+        return keychain;
+    })
+        .nodeify(callback);
+};
+//
+// update
+// Update an existing keychain
+// Parameters include:
+//   xpub:  the xpub of the key to lookup (required)
+//
+Keychains.prototype.update = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['xpub'], ['encryptedXprv'], callback);
+    return Bluebird.resolve(this.bitgo
+        .put(this.bitgo.url('/keychain/' + params.xpub))
+        .send({
+        encryptedXprv: params.encryptedXprv,
+    })
+        .result())
+        .then(function (keychain) {
+        if (keychain.xpub &&
+            keychain.ethAddress &&
+            sdk_core_1.Util.xpubToEthAddress &&
+            keychain.ethAddress !== sdk_core_1.Util.xpubToEthAddress(keychain.xpub)) {
+            throw new Error('ethAddress and xpub do not match');
+        }
+        return keychain;
+    })
+        .nodeify(callback);
+};
+module.exports = Keychains;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keychains.js","sourceRoot":"","sources":["../../../src/v1/keychains.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// Keychains Object\n// BitGo accessor to a user's keychain.\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\n\nimport { bip32 } from '@bitgo/utxo-lib';\nimport { randomBytes } from 'crypto';\nimport { common, Util, sanitizeLegacyPath } from '@bitgo/sdk-core';\nconst _ = require('lodash');\nimport * as Bluebird from 'bluebird';\nconst co = Bluebird.coroutine;\n\n//\n// Constructor\n//\nconst Keychains = function (bitgo) {\n  // @ts-expect-error - no implicit this\n  this.bitgo = bitgo;\n};\n\n//\n// isValid\n// Tests a xpub or xprv string to see if it is a valid keychain.\n//\nKeychains.prototype.isValid = function (params) {\n  params = params || {};\n  common.validateParams(params, [], []);\n\n  if (!_.isString(params.key) && !_.isObject(params.key)) {\n    throw new Error('key must be a string or object');\n  }\n\n  try {\n    if (!params.key.path) {\n      bip32.fromBase58(params.key);\n    } else {\n      bip32.fromBase58(params.key.xpub).derivePath(sanitizeLegacyPath(params.key.path));\n    }\n    return true;\n  } catch (e) {\n    return false;\n  }\n};\n\n//\n// create\n// Create a new keychain locally.\n// Does not send the keychain to bitgo, only creates locally.\n// If |seed| is provided, used to seed the keychain.  Otherwise,\n// a random keychain is created.\n//\nKeychains.prototype.create = function (params) {\n  params = params || {};\n  common.validateParams(params, [], []);\n\n  let seed;\n  if (!params.seed) {\n    // An extended private key has both a normal 256 bit private key and a 256\n    // bit chain code, both of which must be random. 512 bits is therefore the\n    // maximum entropy and gives us maximum security against cracking.\n    seed = randomBytes(512 / 8);\n  } else {\n    seed = params.seed;\n  }\n\n  const extendedKey = bip32.fromSeed(seed);\n  const xpub = extendedKey.neutered().toBase58();\n\n  let ethAddress;\n  try {\n    ethAddress = Util.xpubToEthAddress(xpub);\n  } catch (e) {\n    // ethereum is unavailable\n  }\n\n  return {\n    xpub: xpub,\n    xprv: extendedKey.toBase58(),\n    ethAddress: ethAddress,\n  };\n};\n\n// used by deriveLocal\nconst apiResponse = function (status, result, message) {\n  const err: any = new Error(message);\n  err.status = status;\n  err.result = result;\n  return err;\n};\n\n//\n// deriveLocal\n// Locally derives a keychain from a top level BIP32 string, given a path.\n//\nKeychains.prototype.deriveLocal = function (params) {\n  params = params || {};\n  common.validateParams(params, ['path'], ['xprv', 'xpub']);\n\n  if (!params.xprv && !params.xpub) {\n    throw new Error('must provide an xpub or xprv for derivation.');\n  }\n  if (params.xprv && params.xpub) {\n    throw new Error('cannot provide both xpub and xprv');\n  }\n\n  let hdNode;\n  try {\n    hdNode = bip32.fromBase58(params.xprv || params.xpub);\n  } catch (e) {\n    throw apiResponse(400, {}, 'Unable to parse the xprv or xpub');\n  }\n\n  let derivedNode;\n  try {\n    derivedNode = hdNode.derivePath(sanitizeLegacyPath(params.path));\n  } catch (e) {\n    throw apiResponse(400, {}, 'Unable to derive HD key from path');\n  }\n\n  const xpub = derivedNode.neutered().toBase58();\n\n  let ethAddress;\n  try {\n    ethAddress = Util.xpubToEthAddress(xpub);\n  } catch (e) {\n    // ethereum is unavailable\n  }\n\n  return {\n    path: params.path,\n    xpub: xpub,\n    xprv: params.xprv && derivedNode.toBase58(),\n    ethAddress: ethAddress,\n  };\n};\n\n//\n// list\n// List the user's keychains\n//\nKeychains.prototype.list = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/keychain')).result('keychains'))\n    .then(function (keychains) {\n      keychains.map(function (keychain) {\n        if (\n          keychain.xpub &&\n          keychain.ethAddress &&\n          Util.xpubToEthAddress &&\n          keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n        ) {\n          throw new Error('ethAddress and xpub do not match');\n        }\n      });\n      return keychains;\n    })\n    .nodeify(callback);\n};\n\n/**\n * iterates through all keys associated with the user, decrypts them with the old password and encrypts them with the\n * new password\n * @param params.oldPassword {String} - The old password used for encrypting the key\n * @param params.newPassword {String} - The new password to be used for encrypting the key\n * @param callback\n * @returns result.keychains {Object} - e.g.:\n *  {\n *    xpub1: encryptedPrv1,\n *    xpub2: encryptedPrv2,\n *    ...\n *  }\n *  @returns result.version {Number}\n */\nKeychains.prototype.updatePassword = function (params, callback) {\n  return co(function* coUpdatePassword() {\n    common.validateParams(params, ['oldPassword', 'newPassword'], [], callback);\n    // @ts-expect-error - no implicit this\n    const encrypted = yield this.bitgo.post(this.bitgo.url('/user/encrypted')).result();\n    const newKeychains = {};\n    // @ts-expect-error - no implicit this\n    const self = this;\n    _.forOwn((encrypted as any).keychains, function keychainsForOwn(oldEncryptedXprv, xpub) {\n      try {\n        const decryptedPrv = self.bitgo.decrypt({ input: oldEncryptedXprv, password: params.oldPassword });\n        const newEncryptedPrv = self.bitgo.encrypt({ input: decryptedPrv, password: params.newPassword });\n        newKeychains[xpub] = newEncryptedPrv;\n      } catch (e) {\n        // decrypting the keychain with the old password didn't work so we just keep it the way it is\n        newKeychains[xpub] = oldEncryptedXprv;\n      }\n    });\n    return { keychains: newKeychains, version: (encrypted as any).version };\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// add\n// Add a new keychain\n//\nKeychains.prototype.add = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['xpub'], ['encryptedXprv', 'type', 'isLedger'], callback);\n\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.bitgo.url('/keychain'))\n      .send({\n        xpub: params.xpub,\n        encryptedXprv: params.encryptedXprv,\n        type: params.type,\n        originalPasscodeEncryptionCode: params.originalPasscodeEncryptionCode,\n        isLedger: params.isLedger,\n      })\n      .result()\n  )\n    .then(function (keychain) {\n      if (\n        keychain.xpub &&\n        keychain.ethAddress &&\n        Util.xpubToEthAddress &&\n        keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n      ) {\n        throw new Error('ethAddress and xpub do not match');\n      }\n      return keychain;\n    })\n    .nodeify(callback);\n};\n\n//\n// createBitGo\n// Add a new BitGo server keychain\n//\nKeychains.prototype.createBitGo = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/keychain/bitgo')).send(params).result())\n    .then(function (keychain) {\n      if (\n        keychain.xpub &&\n        keychain.ethAddress &&\n        Util.xpubToEthAddress &&\n        keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n      ) {\n        throw new Error('ethAddress and xpub do not match');\n      }\n      return keychain;\n    })\n    .nodeify(callback);\n};\n\n//\n// createBackup\n// Create a new backup keychain through bitgo - often used for creating a keychain on a KRS\n//\nKeychains.prototype.createBackup = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['provider'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/keychain/backup')).send(params).result())\n    .then(function (keychain) {\n      // not all keychains have an xpub\n      if (\n        keychain.xpub &&\n        keychain.ethAddress &&\n        Util.xpubToEthAddress &&\n        keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n      ) {\n        throw new Error('ethAddress and xpub do not match');\n      }\n      return keychain;\n    })\n    .nodeify(callback);\n};\n\n//\n// get\n// Fetch an existing keychain\n// Parameters include:\n//   xpub:  the xpub of the key to lookup (required)\n//\nKeychains.prototype.get = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], ['xpub', 'ethAddress'], callback);\n\n  if (!params.xpub && !params.ethAddress) {\n    throw new Error('xpub or ethAddress must be defined');\n  }\n\n  const id = params.xpub || params.ethAddress;\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.bitgo.url('/keychain/' + encodeURIComponent(id)))\n      .send({})\n      .result()\n  )\n    .then(function (keychain) {\n      if (\n        keychain.xpub &&\n        keychain.ethAddress &&\n        Util.xpubToEthAddress &&\n        keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n      ) {\n        throw new Error('ethAddress and xpub do not match');\n      }\n      return keychain;\n    })\n    .nodeify(callback);\n};\n\n//\n// update\n// Update an existing keychain\n// Parameters include:\n//   xpub:  the xpub of the key to lookup (required)\n//\nKeychains.prototype.update = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['xpub'], ['encryptedXprv'], callback);\n\n  return Bluebird.resolve(\n    this.bitgo\n      .put(this.bitgo.url('/keychain/' + params.xpub))\n      .send({\n        encryptedXprv: params.encryptedXprv,\n      })\n      .result()\n  )\n    .then(function (keychain) {\n      if (\n        keychain.xpub &&\n        keychain.ethAddress &&\n        Util.xpubToEthAddress &&\n        keychain.ethAddress !== Util.xpubToEthAddress(keychain.xpub)\n      ) {\n        throw new Error('ethAddress and xpub do not match');\n      }\n      return keychain;\n    })\n    .nodeify(callback);\n};\n\nmodule.exports = Keychains;\n"]}

package/dist/src/v1/markets.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @hidden
+ */
+export {};
+//# sourceMappingURL=markets.d.ts.map

package/dist/src/v1/markets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markets.d.ts","sourceRoot":"","sources":["../../../src/v1/markets.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/v1/markets.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * @hidden
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// Markets Object
+// BitGo accessor to Bitcoin market data.
+//
+// Copyright 2015, BitGo, Inc.  All Rights Reserved.
+//
+const Bluebird = require("bluebird");
+const sdk_core_1 = require("@bitgo/sdk-core");
+//
+// Constructor
+//
+const Markets = function (bitgo) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+};
+/**
+ * Get the latest bitcoin price data
+ * @param params {}
+ * @param callback
+ * @returns {*} an object containing price and volume data from the
+ * current day in a number of currencies
+ **/
+Markets.prototype.latest = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/market/latest')).result()).nodeify(callback);
+};
+/**
+ * Get yesterday's bitcoin price data
+ * @param params {}
+ * @param callback
+ * @returns {*} an object containing price and volume data from the
+ * previous day in a number of currencies
+ */
+Markets.prototype.yesterday = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/market/yesterday')).result()).nodeify(callback);
+};
+/**
+ * Get bitcoin price data from up to 90 days prior to today
+ * @param params { currencyName: the code for the desired currency, for example USD }
+ * @param callback
+ * @returns {*} an object containing average prices from a number of previous days
+ */
+Markets.prototype.lastDays = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['currencyName'], [], callback);
+    const days = !isNaN(parseInt(params.days, 10)) ? parseInt(params.days, 10) : 90;
+    if (days && days < 0) {
+        throw new Error('must use a non-negative number of days');
+    }
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/market/last/' + days + '/' + params.currencyName)).result()).nodeify(callback);
+};
+module.exports = Markets;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/v1/pendingapproval.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @hidden
+ */
+declare const PendingApproval: (bitgo: any, pendingApproval: any, wallet: any) => void;
+export = PendingApproval;
+//# sourceMappingURL=pendingapproval.d.ts.map

package/dist/src/v1/pendingapproval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingapproval.d.ts","sourceRoot":"","sources":["../../../src/v1/pendingapproval.ts"],"names":[],"mappings":"AAAA;;GAEG;AAkBH,QAAA,MAAM,eAAe,yDAOpB,CAAC;AAiVF,SAAS,eAAe,CAAC"}