@bitgo/sdk-api 1.1.0-rc.21 → 1.1.0-rc.24

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

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

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

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

package/dist/src/v1/travelRule.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * @hidden
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ */
+//
+// TravelRule Object
+// BitGo accessor for a specific enterprise
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const sdk_core_1 = require("@bitgo/sdk-core");
+const bip32 = require("bip32");
+const utxolib = require("@bitgo/utxo-lib");
+const Bluebird = require("bluebird");
+const _ = require("lodash");
+//
+// Constructor
+//
+const TravelRule = function (bitgo) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+};
+TravelRule.prototype.url = function (extra) {
+    extra = extra || '';
+    return this.bitgo.url('/travel/' + extra);
+};
+/**
+ * Get available travel-rule info recipients for a transaction
+ * @param params
+ *  txid: transaction id
+ * @param callback
+ * @returns {*}
+ */
+TravelRule.prototype.getRecipients = function (params, callback) {
+    params = params || {};
+    params.txid = params.txid || params.hash;
+    sdk_core_1.common.validateParams(params, ['txid'], [], callback);
+    const url = this.url(params.txid + '/recipients');
+    return Bluebird.resolve(this.bitgo.get(url).result('recipients')).nodeify(callback);
+};
+TravelRule.prototype.validateTravelInfo = function (info) {
+    const fields = {
+        amount: { type: 'number' },
+        toAddress: { type: 'string' },
+        toEnterprise: { type: 'string' },
+        fromUserName: { type: 'string' },
+        fromUserAccount: { type: 'string' },
+        fromUserAddress: { type: 'string' },
+        toUserName: { type: 'string' },
+        toUserAccount: { type: 'string' },
+        toUserAddress: { type: 'string' },
+        extra: { type: 'object' },
+    };
+    _.forEach(fields, function (field, fieldName) {
+        // No required fields yet -- should there be?
+        if (field.required) {
+            if (info[fieldName] === undefined) {
+                throw new Error('missing required field ' + fieldName + ' in travel info');
+            }
+        }
+        if (info[fieldName] && typeof info[fieldName] !== field.type) {
+            throw new Error('incorrect type for field ' + fieldName + ' in travel info, expected ' + field.type);
+        }
+    });
+    // Strip out any other fields we don't know about
+    const result = _.pick(info, _.keys(fields));
+    if (_.isEmpty(result)) {
+        throw new Error('empty travel data');
+    }
+    return result;
+};
+/**
+ * Takes a transaction object as returned by getTransaction or listTransactions, along
+ * with a keychain (or hdnode object), and attempts to decrypt any encrypted travel
+ * info included in the transaction's receivedTravelInfo field.
+ * Parameters:
+ *   tx: a transaction object
+ *   keychain: keychain object (with xprv)
+ * Returns:
+ *   the tx object, augmented with decrypted travelInfo fields
+ */
+TravelRule.prototype.decryptReceivedTravelInfo = function (params = {}) {
+    const tx = params.tx;
+    if (!_.isObject(tx)) {
+        throw new Error('expecting tx param to be object');
+    }
+    if (!tx.receivedTravelInfo || !tx.receivedTravelInfo.length) {
+        return tx;
+    }
+    const keychain = params.keychain;
+    if (!_.isObject(keychain) || !_.isString(keychain.xprv)) {
+        throw new Error('expecting keychain param with xprv');
+    }
+    const hdNode = bip32.fromBase58(keychain.xprv);
+    tx.receivedTravelInfo.forEach((info) => {
+        const key = hdNode.derivePath(sdk_core_1.sanitizeLegacyPath(info.toPubKeyPath));
+        const secret = sdk_core_1.getSharedSecret(key, Buffer.from(info.fromPubKey, 'hex')).toString('hex');
+        try {
+            const decrypted = this.bitgo.decrypt({
+                input: info.encryptedTravelInfo,
+                password: secret,
+            });
+            info.travelInfo = JSON.parse(decrypted);
+        }
+        catch (err) {
+            console.error('failed to decrypt or parse travel info for ', info.transactionId + ':' + info.outputIndex);
+        }
+    });
+    return tx;
+};
+TravelRule.prototype.prepareParams = function (params) {
+    params = params || {};
+    params.txid = params.txid || params.hash;
+    sdk_core_1.common.validateParams(params, ['txid'], ['fromPrivateInfo']);
+    const txid = params.txid;
+    const recipient = params.recipient;
+    let travelInfo = params.travelInfo;
+    if (!recipient || !_.isObject(recipient)) {
+        throw new Error('invalid or missing recipient');
+    }
+    if (!travelInfo || !_.isObject(travelInfo)) {
+        throw new Error('invalid or missing travelInfo');
+    }
+    if (!params.noValidate) {
+        travelInfo = this.validateTravelInfo(travelInfo);
+    }
+    // Fill in toEnterprise if not already filled
+    if (!travelInfo.toEnterprise && recipient.enterprise) {
+        travelInfo.toEnterprise = recipient.enterprise;
+    }
+    // If a key was not provided, create a new random key
+    let fromKey = params.fromKey && utxolib.ECPair.fromWIF(params.fromKey, sdk_core_1.getNetwork());
+    if (!fromKey) {
+        fromKey = sdk_core_1.makeRandomKey();
+    }
+    // Compute the shared key for encryption
+    const sharedSecret = sdk_core_1.getSharedSecret(fromKey, Buffer.from(recipient.pubKey, 'hex')).toString('hex');
+    // JSON-ify and encrypt the payload
+    const travelInfoJSON = JSON.stringify(travelInfo);
+    const encryptedTravelInfo = this.bitgo.encrypt({
+        input: travelInfoJSON,
+        password: sharedSecret,
+    });
+    const result = {
+        txid: txid,
+        outputIndex: recipient.outputIndex,
+        toPubKey: recipient.pubKey,
+        fromPubKey: fromKey.publicKey.toString('hex'),
+        encryptedTravelInfo: encryptedTravelInfo,
+        fromPrivateInfo: undefined,
+    };
+    if (params.fromPrivateInfo) {
+        result.fromPrivateInfo = params.fromPrivateInfo;
+    }
+    return result;
+};
+/**
+ * Send travel data to the server for a transaction
+ */
+TravelRule.prototype.send = function (params, callback) {
+    params = params || {};
+    params.txid = params.txid || params.hash;
+    sdk_core_1.common.validateParams(params, ['txid', 'toPubKey', 'encryptedTravelInfo'], ['fromPubKey', 'fromPrivateInfo'], callback);
+    if (!_.isNumber(params.outputIndex)) {
+        throw new Error('invalid outputIndex');
+    }
+    return Bluebird.resolve(this.bitgo
+        .post(this.url(params.txid + '/' + params.outputIndex))
+        .send(params)
+        .result()).nodeify(callback);
+};
+/**
+ * Send multiple travel rule infos for the outputs of a single transaction.
+ * Parameters:
+ *   - txid (or hash): txid of the transaction (must be a sender of the tx)
+ *   - travelInfos: array of travelInfo objects which look like the following:
+ *     {
+ *       outputIndex: number,     // tx output index
+ *       fromUserName: string,    // name of the sending user
+ *       fromUserAccount: string, // account id of the sending user
+ *       fromUserAddress: string, // mailing address of the sending user
+ *       toUserName: string,      // name of the receiving user
+ *       toUserAccount: string,   // account id of the receiving user
+ *       toUserAddress: string    // mailing address of the receiving user
+ *     }
+ *     All fields aside from outputIndex are optional, but at least one must
+ *     be defined.
+ *
+ *  It is not necessary to provide travelInfo for all output indices.
+ *  End-to-end encryption of the travel info is handled automatically by this method.
+ *
+ */
+TravelRule.prototype.sendMany = function (params, callback) {
+    params = params || {};
+    params.txid = params.txid || params.hash;
+    sdk_core_1.common.validateParams(params, ['txid'], callback);
+    const travelInfos = params.travelInfos;
+    if (!_.isArray(travelInfos)) {
+        throw new Error('expected parameter travelInfos to be array');
+    }
+    const self = this;
+    const travelInfoMap = _(travelInfos)
+        .keyBy('outputIndex')
+        .mapValues(function (travelInfo) {
+        return self.validateTravelInfo(travelInfo);
+    })
+        .value();
+    return self.getRecipients({ txid: params.txid }).then(function (recipients) {
+        // Build up data to post
+        const sendParamsList = [];
+        // don't regenerate a new random key for each recipient
+        const fromKey = params.fromKey || sdk_core_1.makeRandomKey().toWIF();
+        recipients.forEach(function (recipient) {
+            const outputIndex = recipient.outputIndex;
+            const info = travelInfoMap[outputIndex];
+            if (info) {
+                if (info.amount && info.amount !== recipient.amount) {
+                    throw new Error('amount did not match for output index ' + outputIndex);
+                }
+                const sendParams = self.prepareParams({
+                    txid: params.txid,
+                    recipient: recipient,
+                    travelInfo: info,
+                    fromKey: fromKey,
+                    noValidate: true, // don't re-validate
+                });
+                sendParamsList.push(sendParams);
+            }
+        });
+        const result = {
+            matched: sendParamsList.length,
+            results: [],
+        };
+        const sendSerial = function () {
+            const sendParams = sendParamsList.shift();
+            if (!sendParams) {
+                return result;
+            }
+            return self
+                .send(sendParams)
+                .then(function (res) {
+                result.results.push({ result: res });
+                return sendSerial();
+            })
+                .catch(function (err) {
+                result.results.push({ error: err.toString() });
+                return sendSerial();
+            });
+        };
+        return sendSerial();
+    });
+};
+module.exports = TravelRule;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"travelRule.js","sourceRoot":"","sources":["../../../src/v1/travelRule.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// TravelRule Object\n// BitGo accessor for a specific enterprise\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\nimport { common, getNetwork, getSharedSecret, makeRandomKey, sanitizeLegacyPath } from '@bitgo/sdk-core';\nimport * as bip32 from 'bip32';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport * as Bluebird from 'bluebird';\nimport * as _ from 'lodash';\n\ninterface DecryptReceivedTravelRuleOptions {\n  tx?: {\n    receivedTravelInfo?: {\n      toPubKeyPath: string;\n      fromPubKey: string;\n      encryptedTravelInfo: string;\n      travelInfo: string;\n      transactionId: string;\n      outputIndex: number;\n    }[];\n  };\n  keychain?: {\n    xprv?: string;\n  };\n  hdnode?: bip32.BIP32Interface;\n}\n\ninterface Recipient {\n  enterprise: string;\n  pubKey: string;\n  outputIndex: string;\n}\n\n//\n// Constructor\n//\nconst TravelRule = function (bitgo) {\n  // @ts-expect-error - no implicit this\n  this.bitgo = bitgo;\n};\n\nTravelRule.prototype.url = function (extra) {\n  extra = extra || '';\n  return this.bitgo.url('/travel/' + extra);\n};\n\n/**\n * Get available travel-rule info recipients for a transaction\n * @param params\n *  txid: transaction id\n * @param callback\n * @returns {*}\n */\nTravelRule.prototype.getRecipients = function (params, callback) {\n  params = params || {};\n  params.txid = params.txid || params.hash;\n  common.validateParams(params, ['txid'], [], callback);\n\n  const url = this.url(params.txid + '/recipients');\n  return Bluebird.resolve(this.bitgo.get(url).result('recipients')).nodeify(callback);\n};\n\nTravelRule.prototype.validateTravelInfo = function (info) {\n  const fields = {\n    amount: { type: 'number' },\n    toAddress: { type: 'string' },\n    toEnterprise: { type: 'string' },\n    fromUserName: { type: 'string' },\n    fromUserAccount: { type: 'string' },\n    fromUserAddress: { type: 'string' },\n    toUserName: { type: 'string' },\n    toUserAccount: { type: 'string' },\n    toUserAddress: { type: 'string' },\n    extra: { type: 'object' },\n  };\n\n  _.forEach(fields, function (field: any, fieldName) {\n    // No required fields yet -- should there be?\n    if (field.required) {\n      if (info[fieldName] === undefined) {\n        throw new Error('missing required field ' + fieldName + ' in travel info');\n      }\n    }\n    if (info[fieldName] && typeof info[fieldName] !== field.type) {\n      throw new Error('incorrect type for field ' + fieldName + ' in travel info, expected ' + field.type);\n    }\n  });\n\n  // Strip out any other fields we don't know about\n  const result = _.pick(info, _.keys(fields));\n  if (_.isEmpty(result)) {\n    throw new Error('empty travel data');\n  }\n  return result;\n};\n\n/**\n * Takes a transaction object as returned by getTransaction or listTransactions, along\n * with a keychain (or hdnode object), and attempts to decrypt any encrypted travel\n * info included in the transaction's receivedTravelInfo field.\n * Parameters:\n *   tx: a transaction object\n *   keychain: keychain object (with xprv)\n * Returns:\n *   the tx object, augmented with decrypted travelInfo fields\n */\nTravelRule.prototype.decryptReceivedTravelInfo = function (params: DecryptReceivedTravelRuleOptions = {}) {\n  const tx = params.tx;\n  if (!_.isObject(tx)) {\n    throw new Error('expecting tx param to be object');\n  }\n\n  if (!tx.receivedTravelInfo || !tx.receivedTravelInfo.length) {\n    return tx;\n  }\n\n  const keychain = params.keychain;\n  if (!_.isObject(keychain) || !_.isString(keychain.xprv)) {\n    throw new Error('expecting keychain param with xprv');\n  }\n  const hdNode = bip32.fromBase58(keychain.xprv);\n\n  tx.receivedTravelInfo.forEach((info) => {\n    const key = hdNode.derivePath(sanitizeLegacyPath(info.toPubKeyPath));\n    const secret = getSharedSecret(key, Buffer.from(info.fromPubKey, 'hex')).toString('hex');\n    try {\n      const decrypted = this.bitgo.decrypt({\n        input: info.encryptedTravelInfo,\n        password: secret,\n      });\n      info.travelInfo = JSON.parse(decrypted);\n    } catch (err) {\n      console.error('failed to decrypt or parse travel info for ', info.transactionId + ':' + info.outputIndex);\n    }\n  });\n\n  return tx;\n};\n\nTravelRule.prototype.prepareParams = function (params) {\n  params = params || {};\n  params.txid = params.txid || params.hash;\n  common.validateParams(params, ['txid'], ['fromPrivateInfo']);\n  const txid = params.txid;\n  const recipient: Recipient | undefined = params.recipient;\n  let travelInfo = params.travelInfo;\n  if (!recipient || !_.isObject(recipient)) {\n    throw new Error('invalid or missing recipient');\n  }\n  if (!travelInfo || !_.isObject(travelInfo)) {\n    throw new Error('invalid or missing travelInfo');\n  }\n  if (!params.noValidate) {\n    travelInfo = this.validateTravelInfo(travelInfo);\n  }\n\n  // Fill in toEnterprise if not already filled\n  if (!travelInfo.toEnterprise && recipient.enterprise) {\n    travelInfo.toEnterprise = recipient.enterprise;\n  }\n\n  // If a key was not provided, create a new random key\n  let fromKey = params.fromKey && utxolib.ECPair.fromWIF(params.fromKey, getNetwork() as utxolib.BitcoinJSNetwork);\n  if (!fromKey) {\n    fromKey = makeRandomKey();\n  }\n\n  // Compute the shared key for encryption\n  const sharedSecret = getSharedSecret(fromKey, Buffer.from(recipient.pubKey, 'hex')).toString('hex');\n\n  // JSON-ify and encrypt the payload\n  const travelInfoJSON = JSON.stringify(travelInfo);\n  const encryptedTravelInfo = this.bitgo.encrypt({\n    input: travelInfoJSON,\n    password: sharedSecret,\n  });\n\n  const result = {\n    txid: txid,\n    outputIndex: recipient.outputIndex,\n    toPubKey: recipient.pubKey,\n    fromPubKey: fromKey.publicKey.toString('hex'),\n    encryptedTravelInfo: encryptedTravelInfo,\n    fromPrivateInfo: undefined,\n  };\n\n  if (params.fromPrivateInfo) {\n    result.fromPrivateInfo = params.fromPrivateInfo;\n  }\n\n  return result;\n};\n\n/**\n * Send travel data to the server for a transaction\n */\nTravelRule.prototype.send = function (params, callback) {\n  params = params || {};\n  params.txid = params.txid || params.hash;\n  common.validateParams(\n    params,\n    ['txid', 'toPubKey', 'encryptedTravelInfo'],\n    ['fromPubKey', 'fromPrivateInfo'],\n    callback\n  );\n\n  if (!_.isNumber(params.outputIndex)) {\n    throw new Error('invalid outputIndex');\n  }\n\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.url(params.txid + '/' + params.outputIndex))\n      .send(params)\n      .result()\n  ).nodeify(callback);\n};\n\n/**\n * Send multiple travel rule infos for the outputs of a single transaction.\n * Parameters:\n *   - txid (or hash): txid of the transaction (must be a sender of the tx)\n *   - travelInfos: array of travelInfo objects which look like the following:\n *     {\n *       outputIndex: number,     // tx output index\n *       fromUserName: string,    // name of the sending user\n *       fromUserAccount: string, // account id of the sending user\n *       fromUserAddress: string, // mailing address of the sending user\n *       toUserName: string,      // name of the receiving user\n *       toUserAccount: string,   // account id of the receiving user\n *       toUserAddress: string    // mailing address of the receiving user\n *     }\n *     All fields aside from outputIndex are optional, but at least one must\n *     be defined.\n *\n *  It is not necessary to provide travelInfo for all output indices.\n *  End-to-end encryption of the travel info is handled automatically by this method.\n *\n */\nTravelRule.prototype.sendMany = function (params, callback) {\n  params = params || {};\n  params.txid = params.txid || params.hash;\n  common.validateParams(params, ['txid'], callback);\n\n  const travelInfos = params.travelInfos;\n  if (!_.isArray(travelInfos)) {\n    throw new Error('expected parameter travelInfos to be array');\n  }\n\n  const self = this;\n  const travelInfoMap = _(travelInfos)\n    .keyBy('outputIndex')\n    .mapValues(function (travelInfo) {\n      return self.validateTravelInfo(travelInfo);\n    })\n    .value();\n\n  return self.getRecipients({ txid: params.txid }).then(function (recipients) {\n    // Build up data to post\n    const sendParamsList: any[] = [];\n    // don't regenerate a new random key for each recipient\n    const fromKey = params.fromKey || makeRandomKey().toWIF();\n\n    recipients.forEach(function (recipient) {\n      const outputIndex = recipient.outputIndex;\n      const info = travelInfoMap[outputIndex];\n      if (info) {\n        if (info.amount && info.amount !== recipient.amount) {\n          throw new Error('amount did not match for output index ' + outputIndex);\n        }\n        const sendParams = self.prepareParams({\n          txid: params.txid,\n          recipient: recipient,\n          travelInfo: info,\n          fromKey: fromKey,\n          noValidate: true, // don't re-validate\n        });\n        sendParamsList.push(sendParams);\n      }\n    });\n\n    const result: {\n      matched: number;\n      results: {\n        result?: any;\n        error?: string;\n      }[];\n    } = {\n      matched: sendParamsList.length,\n      results: [],\n    };\n\n    const sendSerial = function () {\n      const sendParams = sendParamsList.shift();\n      if (!sendParams) {\n        return result;\n      }\n      return self\n        .send(sendParams)\n        .then(function (res) {\n          result.results.push({ result: res });\n          return sendSerial();\n        })\n        .catch(function (err) {\n          result.results.push({ error: err.toString() });\n          return sendSerial();\n        });\n    };\n\n    return sendSerial();\n  });\n};\n\nmodule.exports = TravelRule;\n"]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../src/v1/wallet.ts"],"names":[],"mappings":"AAAA;;GAEG;AA4BH,QAAA,MAAM,MAAM,mCAYX,CAAC;AA00EF,SAAS,MAAM,CAAC"}