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

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

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

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

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

package/dist/src/v1/wallets.js

@@ -0,0 +1,472 @@
+"use strict";
+/**
+ * @hidden
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// Wallets Object
+// BitGo accessor to a user's wallets.
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utxo_lib_1 = require("@bitgo/utxo-lib");
+const utxolib = require("@bitgo/utxo-lib");
+const _ = require("lodash");
+const Bluebird = require("bluebird");
+const co = Bluebird.coroutine;
+const Wallet = require('./wallet');
+//
+// Constructor
+//
+const Wallets = function (bitgo) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+};
+//
+// list
+// List the user's wallets
+//
+Wallets.prototype.list = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const args = [];
+    if (params.skip && params.prevId) {
+        throw new Error('cannot specify both skip and prevId');
+    }
+    if (params.limit) {
+        if (!_.isNumber(params.limit)) {
+            throw new Error('invalid limit argument, expecting number');
+        }
+        args.push('limit=' + params.limit);
+    }
+    if (params.getbalances) {
+        if (!_.isBoolean(params.getbalances)) {
+            throw new Error('invalid getbalances argument, expecting boolean');
+        }
+        args.push('getbalances=' + params.getbalances);
+    }
+    if (params.skip) {
+        if (!_.isNumber(params.skip)) {
+            throw new Error('invalid skip argument, expecting number');
+        }
+        args.push('skip=' + params.skip);
+    }
+    else if (params.prevId) {
+        args.push('prevId=' + params.prevId);
+    }
+    let query = '';
+    if (args.length) {
+        query = '?' + args.join('&');
+    }
+    const self = this;
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/wallet' + query)).result())
+        .then(function (body) {
+        body.wallets = body.wallets.map(function (w) {
+            return new Wallet(self.bitgo, w);
+        });
+        return body;
+    })
+        .nodeify(callback);
+};
+Wallets.prototype.getWallet = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    const self = this;
+    let query = '';
+    if (params.gpk) {
+        query = '?gpk=1';
+    }
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/wallet/' + params.id + query)).result())
+        .then(function (wallet) {
+        return new Wallet(self.bitgo, wallet);
+    })
+        .nodeify(callback);
+};
+//
+// listInvites
+// List the invites on a user
+//
+Wallets.prototype.listInvites = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletinvite')).result()).nodeify(callback);
+};
+//
+// cancelInvite
+// cancel a wallet invite that a user initiated
+//
+Wallets.prototype.cancelInvite = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletInviteId'], [], callback);
+    return Bluebird.resolve(this.bitgo.del(this.bitgo.url('/walletinvite/' + params.walletInviteId)).result()).nodeify(callback);
+};
+//
+// listShares
+// List the user's wallet shares
+//
+Wallets.prototype.listShares = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletshare')).result()).nodeify(callback);
+};
+//
+// resendShareInvite
+// Resend the invitation email which shares a wallet with another user
+// Params:
+//    walletShareId - the wallet share to get information on
+//
+Wallets.prototype.resendShareInvite = function (params, callback) {
+    return co(function* () {
+        params = params || {};
+        sdk_core_1.common.validateParams(params, ['walletShareId'], [], callback);
+        const urlParts = params.walletShareId + '/resendemail';
+        // @ts-expect-error - no implicit this
+        return this.bitgo.post(this.bitgo.url('/walletshare/' + urlParts)).result();
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// getShare
+// Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.
+// Params:
+//    walletShareId - the wallet share to get information on
+//
+Wallets.prototype.getShare = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletShareId'], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletshare/' + params.walletShareId)).result()).nodeify(callback);
+};
+//
+// updateShare
+// updates a wallet share
+// Params:
+//    walletShareId - the wallet share to update
+//    state - the new state of the wallet share
+//
+Wallets.prototype.updateShare = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletShareId'], [], callback);
+    return Bluebird.resolve(this.bitgo
+        .post(this.bitgo.url('/walletshare/' + params.walletShareId))
+        .send(params)
+        .result()).nodeify(callback);
+};
+//
+// cancelShare
+// cancels a wallet share
+// Params:
+//    walletShareId - the wallet share to update
+//
+Wallets.prototype.cancelShare = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletShareId'], [], callback);
+    return Bluebird.resolve(this.bitgo
+        .del(this.bitgo.url('/walletshare/' + params.walletShareId))
+        .send()
+        .result()).nodeify(callback);
+};
+//
+// acceptShare
+// Accepts a wallet share, adding the wallet to the user's list
+// Needs a user's password to decrypt the shared key
+// Params:
+//    walletShareId - the wallet share to accept
+//    userPassword - (required if more a keychain was shared) user's password to decrypt the shared wallet
+//    newWalletPassphrase - new wallet passphrase for saving the shared wallet xprv.
+//                          If left blank and a wallet with more than view permissions was shared, then the userpassword is used.
+//    overrideEncryptedXprv - set only if the xprv was received out-of-band.
+//
+Wallets.prototype.acceptShare = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletShareId'], ['overrideEncryptedXprv'], callback);
+    const self = this;
+    let encryptedXprv = params.overrideEncryptedXprv;
+    return this.getShare({ walletShareId: params.walletShareId })
+        .then(function (walletShare) {
+        // Return right away if there is no keychain to decrypt, or if explicit encryptedXprv was provided
+        if (!walletShare.keychain || !walletShare.keychain.encryptedXprv || encryptedXprv) {
+            return walletShare;
+        }
+        // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme
+        if (!params.userPassword) {
+            throw new Error('userPassword param must be provided to decrypt shared key');
+        }
+        return self.bitgo.getECDHSharingKeychain().then(function (sharingKeychain) {
+            if (!sharingKeychain.encryptedXprv) {
+                throw new Error('EncryptedXprv was not found on sharing keychain');
+            }
+            // Now we have the sharing keychain, we can work out the secret used for sharing the wallet with us
+            sharingKeychain.xprv = self.bitgo.decrypt({
+                password: params.userPassword,
+                input: sharingKeychain.encryptedXprv,
+            });
+            // Derive key by path (which is used between these 2 users only)
+            const secret = sdk_core_1.getSharedSecret(utxo_lib_1.bip32.fromBase58(sharingKeychain.xprv).derivePath(sdk_core_1.sanitizeLegacyPath(walletShare.keychain.path)), Buffer.from(walletShare.keychain.fromPubKey, 'hex')).toString('hex');
+            // Yes! We got the secret successfully here, now decrypt the shared wallet xprv
+            const decryptedSharedWalletXprv = self.bitgo.decrypt({
+                password: secret,
+                input: walletShare.keychain.encryptedXprv,
+            });
+            // We will now re-encrypt the wallet with our own password
+            const newWalletPassphrase = params.newWalletPassphrase || params.userPassword;
+            encryptedXprv = self.bitgo.encrypt({ password: newWalletPassphrase, input: decryptedSharedWalletXprv });
+            // Carry on to the next block where we will post the acceptance of the share with the encrypted xprv
+            return walletShare;
+        });
+    })
+        .then(function (walletShare) {
+        const updateParams = {
+            walletShareId: params.walletShareId,
+            state: 'accepted',
+        };
+        if (encryptedXprv) {
+            updateParams.encryptedXprv = encryptedXprv;
+        }
+        return self.updateShare(updateParams);
+    })
+        .nodeify(callback);
+};
+//
+// createKey
+// Create a single bitcoin key.  This runs locally.
+// Returns: {
+//   address: <address>
+//   key: <key, in WIF format>
+// }
+Wallets.prototype.createKey = function (params) {
+    const key = sdk_core_1.makeRandomKey();
+    return {
+        address: sdk_core_1.getAddressP2PKH(key),
+        key: key.toWIF(),
+    };
+};
+//
+// createWalletWithKeychains
+// Create a new 2-of-3 wallet and it's associated keychains.
+// Returns the locally created keys with their encrypted xprvs.
+// **WARNING: BE SURE TO BACKUP! NOT DOING SO CAN RESULT IN LOSS OF FUNDS!**
+//
+// 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase
+// 2. If no xpub was provided, creates the backup keychain locally on the client, and encrypts it with the provided passphrase
+// 3. Uploads the encrypted user and backup keychains to BitGo
+// 4. Creates the BitGo key on the service
+// 5. Creates the wallet on BitGo with the 3 public keys above
+//
+// Parameters include:
+//   "passphrase": wallet passphrase to encrypt user and backup keys with
+//   "label": wallet label, is shown in BitGo UI
+//   "backupXpub": backup keychain xpub, it is HIGHLY RECOMMENDED you generate this on a separate machine!
+//                 BITGO DOES NOT GUARANTEE SAFETY OF WALLETS WITH MULTIPLE KEYS CREATED ON THE SAME MACHINE **
+//   "backupXpubProvider": Provision backup key from this provider (KRS), e.g. "keyternal".
+//                         Setting this value will create an instant-capable wallet.
+//   "passcodeEncryptionCode": the code used to encrypt the wallet passcode used in the recovery process
+// Returns: {
+//   wallet: newly created wallet model object
+//   userKeychain: the newly created user keychain, which has an encrypted xprv stored on BitGo
+//   backupKeychain: the newly created backup keychain
+//
+// ** BE SURE TO BACK UP THE ENCRYPTED USER AND BACKUP KEYCHAINS!**
+//
+// }
+Wallets.prototype.createWalletWithKeychains = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['passphrase'], ['label', 'backupXpub', 'enterprise', 'passcodeEncryptionCode'], callback);
+    const self = this;
+    const label = params.label;
+    // Create the user and backup key.
+    const userKeychain = this.bitgo.keychains().create();
+    userKeychain.encryptedXprv = this.bitgo.encrypt({ password: params.passphrase, input: userKeychain.xprv });
+    const keychainData = {
+        xpub: userKeychain.xpub,
+        encryptedXprv: userKeychain.encryptedXprv,
+    };
+    if (params.passcodeEncryptionCode) {
+        keychainData.originalPasscodeEncryptionCode = params.passcodeEncryptionCode;
+    }
+    const hasBackupXpub = !!params.backupXpub;
+    const hasBackupXpubProvider = !!params.backupXpubProvider;
+    if (hasBackupXpub && hasBackupXpubProvider) {
+        throw new Error('Cannot provide more than one backupXpub or backupXpubProvider flag');
+    }
+    if (params.disableTransactionNotifications !== undefined && !_.isBoolean(params.disableTransactionNotifications)) {
+        throw new Error('Expected disableTransactionNotifications to be a boolean. ');
+    }
+    let backupKeychain;
+    let bitgoKeychain;
+    // Add the user keychain
+    return self.bitgo
+        .keychains()
+        .add(keychainData)
+        .then(function () {
+        // Add the backup keychain
+        if (params.backupXpubProvider) {
+            // If requested, use a KRS or backup key provider
+            return self.bitgo
+                .keychains()
+                .createBackup({
+                provider: params.backupXpubProvider,
+                disableKRSEmail: params.disableKRSEmail,
+            })
+                .then(function (keychain) {
+                backupKeychain = keychain;
+            });
+        }
+        if (params.backupXpub) {
+            // user provided backup xpub
+            backupKeychain = { xpub: params.backupXpub };
+        }
+        else {
+            // no provided xpub, so default to creating one here
+            backupKeychain = self.bitgo.keychains().create();
+        }
+        return self.bitgo.keychains().add(backupKeychain);
+    })
+        .then(function () {
+        return self.bitgo.keychains().createBitGo();
+    })
+        .then(function (keychain) {
+        bitgoKeychain = keychain;
+        const walletParams = {
+            label: label,
+            m: 2,
+            n: 3,
+            keychains: [{ xpub: userKeychain.xpub }, { xpub: backupKeychain.xpub }, { xpub: bitgoKeychain.xpub }],
+        };
+        if (params.enterprise) {
+            walletParams.enterprise = params.enterprise;
+        }
+        if (params.disableTransactionNotifications) {
+            walletParams.disableTransactionNotifications = params.disableTransactionNotifications;
+        }
+        return self.add(walletParams);
+    })
+        .then(function (newWallet) {
+        const result = {
+            wallet: newWallet,
+            userKeychain: userKeychain,
+            backupKeychain: backupKeychain,
+            bitgoKeychain: bitgoKeychain,
+        };
+        if (backupKeychain.xprv) {
+            result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';
+        }
+        return result;
+    })
+        .nodeify(callback);
+};
+//
+// createForwardWallet
+// Creates a forward wallet from a single private key.
+// BitGo will watch the wallet and send any incoming transactions to a destination multi-sig wallet
+// WARNING: THE PRIVATE KEY WILL BE SENT TO BITGO. YOU MUST CONTACT BITGO BEFORE USING THIS FEATURE!
+// WE CANNOT GUARANTEE THE SECURITY OF SINGLE-SIG WALLETS AS CUSTODY IS UNCLEAR.
+//
+// Params:
+//    privKey - the private key on a legacy single-signature wallet to be watched (WIF format)
+//    sourceAddress - the bitcoin address to forward from (corresponds to the private key)
+//    destinationWallet - the wallet object to send the destination coins to (when incoming transactions are detected)
+//    label - label for the wallet
+//
+Wallets.prototype.createForwardWallet = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['privKey', 'sourceAddress'], ['label'], callback);
+    if (!_.isObject(params.destinationWallet) || !params.destinationWallet.id) {
+        throw new Error('expecting destinationWallet object');
+    }
+    const self = this;
+    let newDestinationAddress;
+    let addressFromPrivKey;
+    try {
+        const key = utxolib.ECPair.fromWIF(params.privKey, sdk_core_1.getNetwork());
+        addressFromPrivKey = sdk_core_1.getAddressP2PKH(key);
+    }
+    catch (e) {
+        throw new Error('expecting a valid privKey');
+    }
+    if (addressFromPrivKey !== params.sourceAddress) {
+        throw new Error('privKey does not match source address - got ' + addressFromPrivKey + ' expected ' + params.sourceAddress);
+    }
+    return params.destinationWallet.createAddress().then(function (result) {
+        // Create new address on the destination wallet to receive coins
+        newDestinationAddress = result.address;
+        const walletParams = {
+            type: 'forward',
+            sourceAddress: params.sourceAddress,
+            destinationAddress: newDestinationAddress,
+            privKey: params.privKey,
+            label: params.label,
+        };
+        if (params.enterprise) {
+            walletParams.enterprise = params.enterprise;
+        }
+        return Bluebird.resolve(self.bitgo.post(self.bitgo.url('/wallet')).send(walletParams).result()).nodeify(callback);
+    });
+};
+/**
+ * Add a new wallet (advanced mode).
+ * This allows you to manually submit the keychains, type, m and n of the wallet
+ * @param {string} label label of the wallet to be shown in UI
+ * @param {number} m number of keys required to unlock wallet (2)
+ * @param {number} n number of keys available on the wallet (3)
+ * @param {array} keychains array of keychain xpubs
+ * @param {string} enterprise ID of the enterprise entity to create this wallet under.
+ * @param {boolean} disableTransactionNotifications When set to true disables notifications for transactions on this wallet.
+ */
+Wallets.prototype.add = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], ['label', 'enterprise'], callback);
+    if (Array.isArray(params.keychains) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {
+        throw new Error('invalid argument');
+    }
+    // TODO: support more types of multisig
+    if (params.m !== 2 || params.n !== 3) {
+        throw new Error('unsupported multi-sig type');
+    }
+    const self = this;
+    const keychains = params.keychains.map(function (k) {
+        return { xpub: k.xpub };
+    });
+    const walletParams = {
+        label: params.label,
+        m: params.m,
+        n: params.n,
+        keychains: keychains,
+    };
+    if (params.enterprise) {
+        walletParams.enterprise = params.enterprise;
+    }
+    if (params.disableTransactionNotifications) {
+        walletParams.disableTransactionNotifications = params.disableTransactionNotifications;
+    }
+    return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/wallet')).send(walletParams).result())
+        .then(function (body) {
+        return new Wallet(self.bitgo, body);
+    })
+        .nodeify(callback);
+};
+//
+// get
+// Shorthand to getWallet
+// Parameters include:
+//   id: the id of the wallet
+//
+Wallets.prototype.get = function (params, callback) {
+    return this.getWallet(params, callback);
+};
+//
+// remove
+// Remove an existing wallet.
+// Parameters include:
+//   id: the id of the wallet
+//
+Wallets.prototype.remove = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    return Bluebird.resolve(this.bitgo.del(this.bitgo.url('/wallet/' + params.id)).result()).nodeify(callback);
+};
+module.exports = Wallets;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wallets.js","sourceRoot":"","sources":["../../../src/v1/wallets.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// Wallets Object\n// BitGo accessor to a user's wallets.\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\nimport {\n  common,\n  getAddressP2PKH,\n  getNetwork,\n  getSharedSecret,\n  makeRandomKey,\n  sanitizeLegacyPath,\n} from '@bitgo/sdk-core';\nimport { bip32 } from '@bitgo/utxo-lib';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport * as _ from 'lodash';\nimport * as Bluebird from 'bluebird';\nconst co = Bluebird.coroutine;\nconst Wallet = require('./wallet');\n\n//\n// Constructor\n//\nconst Wallets = function (bitgo) {\n  // @ts-expect-error - no implicit this\n  this.bitgo = bitgo;\n};\n\n//\n// list\n// List the user's wallets\n//\nWallets.prototype.list = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const args: string[] = [];\n\n  if (params.skip && params.prevId) {\n    throw new Error('cannot specify both skip and prevId');\n  }\n\n  if (params.limit) {\n    if (!_.isNumber(params.limit)) {\n      throw new Error('invalid limit argument, expecting number');\n    }\n    args.push('limit=' + params.limit);\n  }\n  if (params.getbalances) {\n    if (!_.isBoolean(params.getbalances)) {\n      throw new Error('invalid getbalances argument, expecting boolean');\n    }\n    args.push('getbalances=' + params.getbalances);\n  }\n  if (params.skip) {\n    if (!_.isNumber(params.skip)) {\n      throw new Error('invalid skip argument, expecting number');\n    }\n    args.push('skip=' + params.skip);\n  } else if (params.prevId) {\n    args.push('prevId=' + params.prevId);\n  }\n\n  let query = '';\n  if (args.length) {\n    query = '?' + args.join('&');\n  }\n\n  const self = this;\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/wallet' + query)).result())\n    .then(function (body) {\n      body.wallets = body.wallets.map(function (w) {\n        return new Wallet(self.bitgo, w);\n      });\n      return body;\n    })\n    .nodeify(callback);\n};\n\nWallets.prototype.getWallet = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  const self = this;\n\n  let query = '';\n  if (params.gpk) {\n    query = '?gpk=1';\n  }\n\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/wallet/' + params.id + query)).result())\n    .then(function (wallet) {\n      return new Wallet(self.bitgo, wallet);\n    })\n    .nodeify(callback);\n};\n\n//\n// listInvites\n// List the invites on a user\n//\nWallets.prototype.listInvites = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletinvite')).result()).nodeify(callback);\n};\n\n//\n// cancelInvite\n// cancel a wallet invite that a user initiated\n//\nWallets.prototype.cancelInvite = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletInviteId'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.bitgo.url('/walletinvite/' + params.walletInviteId)).result()).nodeify(\n    callback\n  );\n};\n\n//\n// listShares\n// List the user's wallet shares\n//\nWallets.prototype.listShares = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletshare')).result()).nodeify(callback);\n};\n\n//\n// resendShareInvite\n// Resend the invitation email which shares a wallet with another user\n// Params:\n//    walletShareId - the wallet share to get information on\n//\nWallets.prototype.resendShareInvite = function (params, callback) {\n  return co(function* () {\n    params = params || {};\n    common.validateParams(params, ['walletShareId'], [], callback);\n\n    const urlParts = params.walletShareId + '/resendemail';\n    // @ts-expect-error - no implicit this\n    return this.bitgo.post(this.bitgo.url('/walletshare/' + urlParts)).result();\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// getShare\n// Gets a wallet share information, including the encrypted sharing keychain. requires unlock if keychain is present.\n// Params:\n//    walletShareId - the wallet share to get information on\n//\nWallets.prototype.getShare = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletShareId'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.bitgo.url('/walletshare/' + params.walletShareId)).result()).nodeify(\n    callback\n  );\n};\n\n//\n// updateShare\n// updates a wallet share\n// Params:\n//    walletShareId - the wallet share to update\n//    state - the new state of the wallet share\n//\nWallets.prototype.updateShare = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletShareId'], [], callback);\n\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.bitgo.url('/walletshare/' + params.walletShareId))\n      .send(params)\n      .result()\n  ).nodeify(callback);\n};\n\n//\n// cancelShare\n// cancels a wallet share\n// Params:\n//    walletShareId - the wallet share to update\n//\nWallets.prototype.cancelShare = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletShareId'], [], callback);\n\n  return Bluebird.resolve(\n    this.bitgo\n      .del(this.bitgo.url('/walletshare/' + params.walletShareId))\n      .send()\n      .result()\n  ).nodeify(callback);\n};\n\n//\n// acceptShare\n// Accepts a wallet share, adding the wallet to the user's list\n// Needs a user's password to decrypt the shared key\n// Params:\n//    walletShareId - the wallet share to accept\n//    userPassword - (required if more a keychain was shared) user's password to decrypt the shared wallet\n//    newWalletPassphrase - new wallet passphrase for saving the shared wallet xprv.\n//                          If left blank and a wallet with more than view permissions was shared, then the userpassword is used.\n//    overrideEncryptedXprv - set only if the xprv was received out-of-band.\n//\nWallets.prototype.acceptShare = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletShareId'], ['overrideEncryptedXprv'], callback);\n\n  const self = this;\n  let encryptedXprv = params.overrideEncryptedXprv;\n\n  return this.getShare({ walletShareId: params.walletShareId })\n    .then(function (walletShare) {\n      // Return right away if there is no keychain to decrypt, or if explicit encryptedXprv was provided\n      if (!walletShare.keychain || !walletShare.keychain.encryptedXprv || encryptedXprv) {\n        return walletShare;\n      }\n\n      // More than viewing was requested, so we need to process the wallet keys using the shared ecdh scheme\n      if (!params.userPassword) {\n        throw new Error('userPassword param must be provided to decrypt shared key');\n      }\n\n      return self.bitgo.getECDHSharingKeychain().then(function (sharingKeychain) {\n        if (!sharingKeychain.encryptedXprv) {\n          throw new Error('EncryptedXprv was not found on sharing keychain');\n        }\n\n        // Now we have the sharing keychain, we can work out the secret used for sharing the wallet with us\n        sharingKeychain.xprv = self.bitgo.decrypt({\n          password: params.userPassword,\n          input: sharingKeychain.encryptedXprv,\n        });\n\n        // Derive key by path (which is used between these 2 users only)\n        const secret = getSharedSecret(\n          bip32.fromBase58(sharingKeychain.xprv).derivePath(sanitizeLegacyPath(walletShare.keychain.path)),\n          Buffer.from(walletShare.keychain.fromPubKey, 'hex')\n        ).toString('hex');\n\n        // Yes! We got the secret successfully here, now decrypt the shared wallet xprv\n        const decryptedSharedWalletXprv = self.bitgo.decrypt({\n          password: secret,\n          input: walletShare.keychain.encryptedXprv,\n        });\n\n        // We will now re-encrypt the wallet with our own password\n        const newWalletPassphrase = params.newWalletPassphrase || params.userPassword;\n        encryptedXprv = self.bitgo.encrypt({ password: newWalletPassphrase, input: decryptedSharedWalletXprv });\n\n        // Carry on to the next block where we will post the acceptance of the share with the encrypted xprv\n        return walletShare;\n      });\n    })\n    .then(function (walletShare) {\n      const updateParams: any = {\n        walletShareId: params.walletShareId,\n        state: 'accepted',\n      };\n\n      if (encryptedXprv) {\n        updateParams.encryptedXprv = encryptedXprv;\n      }\n\n      return self.updateShare(updateParams);\n    })\n    .nodeify(callback);\n};\n\n//\n// createKey\n// Create a single bitcoin key.  This runs locally.\n// Returns: {\n//   address: <address>\n//   key: <key, in WIF format>\n// }\nWallets.prototype.createKey = function (params) {\n  const key = makeRandomKey();\n  return {\n    address: getAddressP2PKH(key),\n    key: key.toWIF(),\n  };\n};\n\n//\n// createWalletWithKeychains\n// Create a new 2-of-3 wallet and it's associated keychains.\n// Returns the locally created keys with their encrypted xprvs.\n// **WARNING: BE SURE TO BACKUP! NOT DOING SO CAN RESULT IN LOSS OF FUNDS!**\n//\n// 1. Creates the user keychain locally on the client, and encrypts it with the provided passphrase\n// 2. If no xpub was provided, creates the backup keychain locally on the client, and encrypts it with the provided passphrase\n// 3. Uploads the encrypted user and backup keychains to BitGo\n// 4. Creates the BitGo key on the service\n// 5. Creates the wallet on BitGo with the 3 public keys above\n//\n// Parameters include:\n//   \"passphrase\": wallet passphrase to encrypt user and backup keys with\n//   \"label\": wallet label, is shown in BitGo UI\n//   \"backupXpub\": backup keychain xpub, it is HIGHLY RECOMMENDED you generate this on a separate machine!\n//                 BITGO DOES NOT GUARANTEE SAFETY OF WALLETS WITH MULTIPLE KEYS CREATED ON THE SAME MACHINE **\n//   \"backupXpubProvider\": Provision backup key from this provider (KRS), e.g. \"keyternal\".\n//                         Setting this value will create an instant-capable wallet.\n//   \"passcodeEncryptionCode\": the code used to encrypt the wallet passcode used in the recovery process\n// Returns: {\n//   wallet: newly created wallet model object\n//   userKeychain: the newly created user keychain, which has an encrypted xprv stored on BitGo\n//   backupKeychain: the newly created backup keychain\n//\n// ** BE SURE TO BACK UP THE ENCRYPTED USER AND BACKUP KEYCHAINS!**\n//\n// }\nWallets.prototype.createWalletWithKeychains = function (params, callback) {\n  params = params || {};\n  common.validateParams(\n    params,\n    ['passphrase'],\n    ['label', 'backupXpub', 'enterprise', 'passcodeEncryptionCode'],\n    callback\n  );\n  const self = this;\n  const label = params.label;\n\n  // Create the user and backup key.\n  const userKeychain = this.bitgo.keychains().create();\n  userKeychain.encryptedXprv = this.bitgo.encrypt({ password: params.passphrase, input: userKeychain.xprv });\n\n  const keychainData: any = {\n    xpub: userKeychain.xpub,\n    encryptedXprv: userKeychain.encryptedXprv,\n  };\n\n  if (params.passcodeEncryptionCode) {\n    keychainData.originalPasscodeEncryptionCode = params.passcodeEncryptionCode;\n  }\n\n  const hasBackupXpub = !!params.backupXpub;\n  const hasBackupXpubProvider = !!params.backupXpubProvider;\n  if (hasBackupXpub && hasBackupXpubProvider) {\n    throw new Error('Cannot provide more than one backupXpub or backupXpubProvider flag');\n  }\n\n  if (params.disableTransactionNotifications !== undefined && !_.isBoolean(params.disableTransactionNotifications)) {\n    throw new Error('Expected disableTransactionNotifications to be a boolean. ');\n  }\n\n  let backupKeychain;\n  let bitgoKeychain;\n\n  // Add the user keychain\n  return self.bitgo\n    .keychains()\n    .add(keychainData)\n    .then(function () {\n      // Add the backup keychain\n      if (params.backupXpubProvider) {\n        // If requested, use a KRS or backup key provider\n        return self.bitgo\n          .keychains()\n          .createBackup({\n            provider: params.backupXpubProvider,\n            disableKRSEmail: params.disableKRSEmail,\n          })\n          .then(function (keychain) {\n            backupKeychain = keychain;\n          });\n      }\n\n      if (params.backupXpub) {\n        // user provided backup xpub\n        backupKeychain = { xpub: params.backupXpub };\n      } else {\n        // no provided xpub, so default to creating one here\n        backupKeychain = self.bitgo.keychains().create();\n      }\n\n      return self.bitgo.keychains().add(backupKeychain);\n    })\n    .then(function () {\n      return self.bitgo.keychains().createBitGo();\n    })\n    .then(function (keychain) {\n      bitgoKeychain = keychain;\n      const walletParams: any = {\n        label: label,\n        m: 2,\n        n: 3,\n        keychains: [{ xpub: userKeychain.xpub }, { xpub: backupKeychain.xpub }, { xpub: bitgoKeychain.xpub }],\n      };\n\n      if (params.enterprise) {\n        walletParams.enterprise = params.enterprise;\n      }\n\n      if (params.disableTransactionNotifications) {\n        walletParams.disableTransactionNotifications = params.disableTransactionNotifications;\n      }\n\n      return self.add(walletParams);\n    })\n    .then(function (newWallet) {\n      const result: any = {\n        wallet: newWallet,\n        userKeychain: userKeychain,\n        backupKeychain: backupKeychain,\n        bitgoKeychain: bitgoKeychain,\n      };\n\n      if (backupKeychain.xprv) {\n        result.warning = 'Be sure to backup the backup keychain -- it is not stored anywhere else!';\n      }\n\n      return result;\n    })\n    .nodeify(callback);\n};\n\n//\n// createForwardWallet\n// Creates a forward wallet from a single private key.\n// BitGo will watch the wallet and send any incoming transactions to a destination multi-sig wallet\n// WARNING: THE PRIVATE KEY WILL BE SENT TO BITGO. YOU MUST CONTACT BITGO BEFORE USING THIS FEATURE!\n// WE CANNOT GUARANTEE THE SECURITY OF SINGLE-SIG WALLETS AS CUSTODY IS UNCLEAR.\n//\n// Params:\n//    privKey - the private key on a legacy single-signature wallet to be watched (WIF format)\n//    sourceAddress - the bitcoin address to forward from (corresponds to the private key)\n//    destinationWallet - the wallet object to send the destination coins to (when incoming transactions are detected)\n//    label - label for the wallet\n//\nWallets.prototype.createForwardWallet = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['privKey', 'sourceAddress'], ['label'], callback);\n\n  if (!_.isObject(params.destinationWallet) || !params.destinationWallet.id) {\n    throw new Error('expecting destinationWallet object');\n  }\n\n  const self = this;\n\n  let newDestinationAddress;\n  let addressFromPrivKey;\n\n  try {\n    const key = utxolib.ECPair.fromWIF(params.privKey, getNetwork() as utxolib.BitcoinJSNetwork);\n    addressFromPrivKey = getAddressP2PKH(key);\n  } catch (e) {\n    throw new Error('expecting a valid privKey');\n  }\n\n  if (addressFromPrivKey !== params.sourceAddress) {\n    throw new Error(\n      'privKey does not match source address - got ' + addressFromPrivKey + ' expected ' + params.sourceAddress\n    );\n  }\n\n  return params.destinationWallet.createAddress().then(function (result) {\n    // Create new address on the destination wallet to receive coins\n    newDestinationAddress = result.address;\n\n    const walletParams: any = {\n      type: 'forward',\n      sourceAddress: params.sourceAddress,\n      destinationAddress: newDestinationAddress,\n      privKey: params.privKey,\n      label: params.label,\n    };\n\n    if (params.enterprise) {\n      walletParams.enterprise = params.enterprise;\n    }\n\n    return Bluebird.resolve(self.bitgo.post(self.bitgo.url('/wallet')).send(walletParams).result()).nodeify(callback);\n  });\n};\n\n/**\n * Add a new wallet (advanced mode).\n * This allows you to manually submit the keychains, type, m and n of the wallet\n * @param {string} label label of the wallet to be shown in UI\n * @param {number} m number of keys required to unlock wallet (2)\n * @param {number} n number of keys available on the wallet (3)\n * @param {array} keychains array of keychain xpubs\n * @param {string} enterprise ID of the enterprise entity to create this wallet under.\n * @param {boolean} disableTransactionNotifications When set to true disables notifications for transactions on this wallet.\n */\nWallets.prototype.add = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], ['label', 'enterprise'], callback);\n\n  if (Array.isArray(params.keychains) === false || !_.isNumber(params.m) || !_.isNumber(params.n)) {\n    throw new Error('invalid argument');\n  }\n\n  // TODO: support more types of multisig\n  if (params.m !== 2 || params.n !== 3) {\n    throw new Error('unsupported multi-sig type');\n  }\n\n  const self = this;\n  const keychains = params.keychains.map(function (k) {\n    return { xpub: k.xpub };\n  });\n  const walletParams: any = {\n    label: params.label,\n    m: params.m,\n    n: params.n,\n    keychains: keychains,\n  };\n\n  if (params.enterprise) {\n    walletParams.enterprise = params.enterprise;\n  }\n\n  if (params.disableTransactionNotifications) {\n    walletParams.disableTransactionNotifications = params.disableTransactionNotifications;\n  }\n\n  return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/wallet')).send(walletParams).result())\n    .then(function (body) {\n      return new Wallet(self.bitgo, body);\n    })\n    .nodeify(callback);\n};\n\n//\n// get\n// Shorthand to getWallet\n// Parameters include:\n//   id: the id of the wallet\n//\nWallets.prototype.get = function (params, callback) {\n  return this.getWallet(params, callback);\n};\n\n//\n// remove\n// Remove an existing wallet.\n// Parameters include:\n//   id: the id of the wallet\n//\nWallets.prototype.remove = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.bitgo.url('/wallet/' + params.id)).result()).nodeify(callback);\n};\n\nmodule.exports = Wallets;\n"]}