@bitgo/sdk-api 2.0.0-hotfix.0 → 2.1.0

package/dist/src/util.js

@@ -1,30 +1,64 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddressP2PKH = exports.makeRandomKey = exports.getNetwork = void 0;
-const utxolib = require("@bitgo/utxo-lib");
+exports.getNetwork = getNetwork;
+exports.tryPromise = tryPromise;
+const utxolib = __importStar(require("@bitgo/utxo-lib"));
 const sdk_core_1 = require("@bitgo/sdk-core");
 function getNetwork(network) {
     network = network || sdk_core_1.common.getNetwork();
     return utxolib.networks[network];
 }
-exports.getNetwork = getNetwork;
-function makeRandomKey() {
-    return utxolib.ECPair.makeRandom({ network: getNetwork() });
-}
-exports.makeRandomKey = makeRandomKey;
-function getAddressP2PKH(key) {
-    let pubkey;
-    if ('getPublicKeyBuffer' in key) {
-        pubkey = key.getPublicKeyBuffer();
-    }
-    else {
-        pubkey = key.publicKey;
+/**
+ * A native Promise-based replacement for Bluebird.try
+ *
+ * This function executes the provided function and returns a Promise.
+ * If the function throws synchronously, the exception is caught and returned as a rejected Promise.
+ * If the function returns a Promise, that Promise is returned.
+ * If the function returns any other value, a resolved Promise with that value is returned.
+ *
+ * @param {Function} fn - The function to execute
+ * @returns {Promise<T>} A promise that resolves with the return value of fn or rejects with any error thrown
+ */
+function tryPromise(fn) {
+    try {
+        const result = fn();
+        return Promise.resolve(result);
     }
-    const { address } = utxolib.payments.p2pkh({ pubkey, network: key.network });
-    if (!address) {
-        throw new Error('could not compute address');
+    catch (error) {
+        return Promise.reject(error);
     }
-    return address;
 }
-exports.getAddressP2PKH = getAddressP2PKH;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

package/dist/src/v1/blockchain.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * @hidden
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// Blockchain Object
+// BitGo accessor to a any Bitcoin address.
+// Using this does not require authentication and is unrelated to BitGo wallet management.
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const lodash_1 = __importDefault(require("lodash"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+//
+// Constructor
+//
+const Blockchain = function (bitgo) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+};
+//
+// Get an address
+// Fetch an address summary information.
+// Includes balance and pending balance.
+//
+// Parameters include:
+//   address: the address to get
+//
+Blockchain.prototype.getAddress = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], [], callback);
+    return Promise.resolve(this.bitgo.get(this.bitgo.url('/address/' + params.address)).result())
+        .then(callback)
+        .catch(callback);
+};
+//
+// Get address transactions
+// List the transactions for a given address
+// Parameters include:
+//   address: the address to get transactions for
+//
+Blockchain.prototype.getAddressTransactions = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], [], callback);
+    // TODO: support start and limit params
+    return Promise.resolve(this.bitgo.get(this.bitgo.url('/address/' + params.address + '/tx')).result())
+        .then(callback)
+        .catch(callback);
+};
+//
+// Unspent Transactions
+// List the unspent outputs for a given address
+// Parameters include:
+//   address: the address to get unspent transactions
+//   limit: return enough unspents to accumulate to at least this amount (in satoshis).
+//
+Blockchain.prototype.getAddressUnspents = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], [], callback);
+    let url = this.bitgo.url('/address/' + params.address + '/unspents');
+    if (params.limit) {
+        if (!lodash_1.default.isInteger(params.limit)) {
+            throw new Error('invalid limit - number expected');
+        }
+        url += '?limit=' + params.limit * 1e8;
+    }
+    return Promise.resolve(this.bitgo.get(url).result())
+        .then(function (body) {
+        return body.unspents;
+    })
+        .then(callback)
+        .catch(callback);
+};
+//
+// Get transaction
+// Fetch transaction details.
+//
+// Parameters include:
+//   id: the transaction id to get
+//
+Blockchain.prototype.getTransaction = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    return Promise.resolve(this.bitgo.get(this.bitgo.url('/tx/' + params.id)).result())
+        .then(callback)
+        .catch(callback);
+};
+//
+// Get transaction that spends a specific output
+// Fetch transaction details.
+//
+// Parameters include:
+//   txid: the transaction id of the output
+//   vout: the position of the output on the transaction that created it
+//
+Blockchain.prototype.getTransactionByInput = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['txid'], [], callback);
+    if (!lodash_1.default.isInteger(params.vout)) {
+        throw new Error('invalid vout - number expected');
+    }
+    return Promise.resolve(this.bitgo.get(this.bitgo.url('/tx/input/' + params.txid + '/' + params.vout)).result())
+        .then(callback)
+        .catch(callback);
+};
+//
+// Get block
+// Fetch block details.
+//
+// Parameters include:
+//   id: the block hash to get, or latest for the latest
+//
+Blockchain.prototype.getBlock = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    return Promise.resolve(this.bitgo.get(this.bitgo.url('/block/' + params.id)).result())
+        .then(callback)
+        .catch(callback);
+};
+module.exports = Blockchain;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blockchain.js","sourceRoot":"","sources":["../../../src/v1/blockchain.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// Blockchain Object\n// BitGo accessor to a any Bitcoin address.\n// Using this does not require authentication and is unrelated to BitGo wallet management.\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\n\nimport _ from 'lodash';\n\nimport { common } from '@bitgo/sdk-core';\n\n//\n// Constructor\n//\nconst Blockchain = function (bitgo) {\n  // @ts-expect-error - no implicit this\n  this.bitgo = bitgo;\n};\n\n//\n// Get an address\n// Fetch an address summary information.\n// Includes balance and pending balance.\n//\n// Parameters include:\n//   address: the address to get\n//\nBlockchain.prototype.getAddress = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], [], callback);\n\n  return Promise.resolve(this.bitgo.get(this.bitgo.url('/address/' + params.address)).result())\n    .then(callback)\n    .catch(callback);\n};\n\n//\n// Get address transactions\n// List the transactions for a given address\n// Parameters include:\n//   address: the address to get transactions for\n//\nBlockchain.prototype.getAddressTransactions = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], [], callback);\n\n  // TODO: support start and limit params\n  return Promise.resolve(this.bitgo.get(this.bitgo.url('/address/' + params.address + '/tx')).result())\n    .then(callback)\n    .catch(callback);\n};\n\n//\n// Unspent Transactions\n// List the unspent outputs for a given address\n// Parameters include:\n//   address: the address to get unspent transactions\n//   limit: return enough unspents to accumulate to at least this amount (in satoshis).\n//\nBlockchain.prototype.getAddressUnspents = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], [], callback);\n\n  let url = this.bitgo.url('/address/' + params.address + '/unspents');\n  if (params.limit) {\n    if (!_.isInteger(params.limit)) {\n      throw new Error('invalid limit - number expected');\n    }\n    url += '?limit=' + params.limit * 1e8;\n  }\n\n  return Promise.resolve(this.bitgo.get(url).result())\n    .then(function (body) {\n      return body.unspents;\n    })\n    .then(callback)\n    .catch(callback);\n};\n\n//\n// Get transaction\n// Fetch transaction details.\n//\n// Parameters include:\n//   id: the transaction id to get\n//\nBlockchain.prototype.getTransaction = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  return Promise.resolve(this.bitgo.get(this.bitgo.url('/tx/' + params.id)).result())\n    .then(callback)\n    .catch(callback);\n};\n\n//\n// Get transaction that spends a specific output\n// Fetch transaction details.\n//\n// Parameters include:\n//   txid: the transaction id of the output\n//   vout: the position of the output on the transaction that created it\n//\nBlockchain.prototype.getTransactionByInput = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['txid'], [], callback);\n  if (!_.isInteger(params.vout)) {\n    throw new Error('invalid vout - number expected');\n  }\n  return Promise.resolve(this.bitgo.get(this.bitgo.url('/tx/input/' + params.txid + '/' + params.vout)).result())\n    .then(callback)\n    .catch(callback);\n};\n\n//\n// Get block\n// Fetch block details.\n//\n// Parameters include:\n//   id: the block hash to get, or latest for the latest\n//\nBlockchain.prototype.getBlock = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  return Promise.resolve(this.bitgo.get(this.bitgo.url('/block/' + params.id)).result())\n    .then(callback)\n    .catch(callback);\n};\n\nmodule.exports = Blockchain;\n"]}

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

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

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

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

package/dist/src/v1/keychains.js

@@ -0,0 +1,328 @@
+"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');
+//
+// 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((0, 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 = (0, 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((0, 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 Promise.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;
+    })
+        .then(callback)
+        .catch(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 async function coUpdatePassword() {
+        sdk_core_1.common.validateParams(params, ['oldPassword', 'newPassword'], [], callback);
+        // @ts-expect-error - no implicit this
+        const encrypted = await this.bitgo.post(this.bitgo.url('/user/encrypted')).result();
+        const newKeychains = {};
+        // @ts-expect-error - no implicit this
+        const self = this;
+        for (const [xpub, oldEncryptedXprv] of Object.entries(encrypted.keychains)) {
+            try {
+                const decryptedPrv = await self.bitgo.decrypt({
+                    input: oldEncryptedXprv,
+                    password: params.oldPassword,
+                });
+                const encryptionVersion = (0, sdk_core_1.isV2Envelope)(oldEncryptedXprv) ? 2 : 1;
+                const newEncryptedPrv = await self.bitgo.encrypt({
+                    input: decryptedPrv,
+                    password: params.newPassword,
+                    encryptionVersion,
+                });
+                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)
+        .then(callback)
+        .catch(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 Promise.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;
+    })
+        .then(callback)
+        .catch(callback);
+};
+//
+// createBitGo
+// Add a new BitGo server keychain
+//
+Keychains.prototype.createBitGo = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Promise.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;
+    })
+        .then(callback)
+        .catch(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 Promise.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;
+    })
+        .then(callback)
+        .catch(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 Promise.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;
+    })
+        .then(callback)
+        .catch(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 Promise.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;
+    })
+        .then(callback)
+        .catch(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, isV2Envelope, Util, sanitizeLegacyPath } from '@bitgo/sdk-core';\nconst _ = require('lodash');\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 Promise.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    .then(callback)\n    .catch(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 async function coUpdatePassword() {\n    common.validateParams(params, ['oldPassword', 'newPassword'], [], callback);\n    // @ts-expect-error - no implicit this\n    const encrypted = await this.bitgo.post(this.bitgo.url('/user/encrypted')).result();\n    const newKeychains = {};\n    // @ts-expect-error - no implicit this\n    const self = this;\n    for (const [xpub, oldEncryptedXprv] of Object.entries((encrypted as any).keychains)) {\n      try {\n        const decryptedPrv = await self.bitgo.decrypt({\n          input: oldEncryptedXprv as string,\n          password: params.oldPassword,\n        });\n        const encryptionVersion = isV2Envelope(oldEncryptedXprv as string) ? 2 : 1;\n        const newEncryptedPrv = await self.bitgo.encrypt({\n          input: decryptedPrv,\n          password: params.newPassword,\n          encryptionVersion,\n        });\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 as string;\n      }\n    }\n    return { keychains: newKeychains, version: (encrypted as any).version };\n  }\n    .call(this)\n    .then(callback)\n    .catch(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 Promise.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    .then(callback)\n    .catch(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 Promise.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    .then(callback)\n    .catch(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 Promise.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    .then(callback)\n    .catch(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 Promise.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    .then(callback)\n    .catch(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 Promise.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    .then(callback)\n    .catch(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"}