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

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,316 @@
+"use strict";
+/**
+ * @hidden
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 utxo_lib_1 = require("@bitgo/utxo-lib");
+const utxolib = __importStar(require("@bitgo/utxo-lib"));
+const lodash_1 = __importDefault(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 Promise.resolve(this.bitgo.get(url).result('recipients')).then(callback).catch(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' },
+    };
+    lodash_1.default.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 = lodash_1.default.pick(info, lodash_1.default.keys(fields));
+    if (lodash_1.default.isEmpty(result)) {
+        throw new Error('empty travel data');
+    }
+    return result;
+};
+function validateTravelRuleDecryptParams(params = {}) {
+    const tx = params.tx;
+    if (!lodash_1.default.isObject(tx)) {
+        throw new Error('expecting tx param to be object');
+    }
+    if (!tx.receivedTravelInfo || !tx.receivedTravelInfo.length) {
+        return { tx, hdNode: undefined };
+    }
+    const keychain = params.keychain;
+    if (!lodash_1.default.isObject(keychain) || !lodash_1.default.isString(keychain.xprv)) {
+        throw new Error('expecting keychain param with xprv');
+    }
+    const hdNode = utxo_lib_1.bip32.fromBase58(keychain.xprv);
+    return { tx, hdNode };
+}
+function prepareTravelRuleParamsCommon(self, 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 || !lodash_1.default.isObject(recipient)) {
+        throw new Error('invalid or missing recipient');
+    }
+    if (!travelInfo || !lodash_1.default.isObject(travelInfo)) {
+        throw new Error('invalid or missing travelInfo');
+    }
+    if (!params.noValidate) {
+        travelInfo = self.validateTravelInfo(travelInfo);
+    }
+    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, (0, sdk_core_1.getNetwork)());
+    if (!fromKey) {
+        fromKey = (0, sdk_core_1.makeRandomKey)();
+    }
+    // Compute the shared key for encryption
+    const sharedSecret = (0, sdk_core_1.getSharedSecret)(fromKey, Buffer.from(recipient.pubKey, 'hex')).toString('hex');
+    // JSON-ify and encrypt the payload
+    const travelInfoJSON = JSON.stringify(travelInfo);
+    return {
+        txid,
+        recipient,
+        travelInfoJSON,
+        fromKey,
+        sharedSecret,
+        fromPrivateInfo: params.fromPrivateInfo,
+    };
+}
+function buildTravelRuleSendParams(prepared, encryptedTravelInfo) {
+    const result = {
+        txid: prepared.txid,
+        outputIndex: prepared.recipient.outputIndex,
+        toPubKey: prepared.recipient.pubKey,
+        fromPubKey: prepared.fromKey.publicKey.toString('hex'),
+        encryptedTravelInfo: encryptedTravelInfo,
+        fromPrivateInfo: undefined,
+    };
+    if (prepared.fromPrivateInfo) {
+        result.fromPrivateInfo = prepared.fromPrivateInfo;
+    }
+    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
+ * Auto-detects v1 (SJCL) and v2 (Argon2id) envelopes.
+ */
+TravelRule.prototype.decryptReceivedTravelInfo = async function (params = {}) {
+    const { tx, hdNode } = validateTravelRuleDecryptParams(params);
+    if (!hdNode) {
+        return tx;
+    }
+    for (const info of tx.receivedTravelInfo) {
+        const key = hdNode.derivePath((0, sdk_core_1.sanitizeLegacyPath)(info.toPubKeyPath));
+        const secret = (0, sdk_core_1.getSharedSecret)(key, Buffer.from(info.fromPubKey, 'hex')).toString('hex');
+        try {
+            const decrypted = await 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 = async function (params) {
+    const prepared = prepareTravelRuleParamsCommon(this, params);
+    const encryptedTravelInfo = await this.bitgo.encrypt({
+        input: prepared.travelInfoJSON,
+        password: prepared.sharedSecret,
+        encryptionVersion: params.encryptionVersion,
+    });
+    return buildTravelRuleSendParams(prepared, encryptedTravelInfo);
+};
+/**
+ * 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 (!lodash_1.default.isNumber(params.outputIndex)) {
+        throw new Error('invalid outputIndex');
+    }
+    return Promise.resolve(this.bitgo
+        .post(this.url(params.txid + '/' + params.outputIndex))
+        .send(params)
+        .result())
+        .then(callback)
+        .catch(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 (!lodash_1.default.isArray(travelInfos)) {
+        throw new Error('expected parameter travelInfos to be array');
+    }
+    const self = this;
+    const travelInfoMap = (0, lodash_1.default)(travelInfos)
+        .keyBy('outputIndex')
+        .mapValues(function (travelInfo) {
+        return self.validateTravelInfo(travelInfo);
+    })
+        .value();
+    return self.getRecipients({ txid: params.txid }).then(async function (recipients) {
+        // Build up data to post
+        const sendParamsList = [];
+        // don't regenerate a new random key for each recipient
+        const fromKey = params.fromKey || (0, sdk_core_1.makeRandomKey)().toWIF();
+        for (const recipient of recipients) {
+            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 = await 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 { bip32, BIP32Interface } from '@bitgo/utxo-lib';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport _ from 'lodash';\n\ninterface ReceivedTravelInfoEntry {\n  toPubKeyPath: string;\n  fromPubKey: string;\n  encryptedTravelInfo: string;\n  travelInfo: string;\n  transactionId: string;\n  outputIndex: number;\n}\n\ninterface DecryptReceivedTravelRuleOptions {\n  tx?: {\n    receivedTravelInfo?: ReceivedTravelInfoEntry[];\n  };\n  keychain?: {\n    xprv?: string;\n  };\n  hdnode?: 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 Promise.resolve(this.bitgo.get(url).result('recipients')).then(callback).catch(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\nfunction validateTravelRuleDecryptParams(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, hdNode: undefined as BIP32Interface | undefined };\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  return { tx, hdNode };\n}\n\nfunction prepareTravelRuleParamsCommon(self: { validateTravelInfo: (info: any) => any }, params: any) {\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 = self.validateTravelInfo(travelInfo);\n  }\n\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\n  return {\n    txid,\n    recipient,\n    travelInfoJSON,\n    fromKey,\n    sharedSecret,\n    fromPrivateInfo: params.fromPrivateInfo,\n  };\n}\n\nfunction buildTravelRuleSendParams(\n  prepared: {\n    txid: string;\n    recipient: Recipient;\n    fromKey: utxolib.ECPairInterface;\n    fromPrivateInfo?: string;\n  },\n  encryptedTravelInfo: string\n) {\n  const result = {\n    txid: prepared.txid,\n    outputIndex: prepared.recipient.outputIndex,\n    toPubKey: prepared.recipient.pubKey,\n    fromPubKey: prepared.fromKey.publicKey.toString('hex'),\n    encryptedTravelInfo: encryptedTravelInfo,\n    fromPrivateInfo: undefined as string | undefined,\n  };\n\n  if (prepared.fromPrivateInfo) {\n    result.fromPrivateInfo = prepared.fromPrivateInfo;\n  }\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 * Auto-detects v1 (SJCL) and v2 (Argon2id) envelopes.\n */\nTravelRule.prototype.decryptReceivedTravelInfo = async function (params: DecryptReceivedTravelRuleOptions = {}) {\n  const { tx, hdNode } = validateTravelRuleDecryptParams(params);\n  if (!hdNode) {\n    return tx;\n  }\n\n  for (const info of tx!.receivedTravelInfo!) {\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 = await 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 = async function (params) {\n  const prepared = prepareTravelRuleParamsCommon(this, params);\n  const encryptedTravelInfo = await this.bitgo.encrypt({\n    input: prepared.travelInfoJSON,\n    password: prepared.sharedSecret,\n    encryptionVersion: params.encryptionVersion,\n  });\n\n  return buildTravelRuleSendParams(prepared, encryptedTravelInfo);\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 Promise.resolve(\n    this.bitgo\n      .post(this.url(params.txid + '/' + params.outputIndex))\n      .send(params)\n      .result()\n  )\n    .then(callback)\n    .catch(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(async 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    for (const recipient of recipients) {\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 = await 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/verifyAddress.d.ts

@@ -0,0 +1,6 @@
+import { Network } from '@bitgo/utxo-lib';
+/**
+ * Verify a Bitcoin address is a valid address
+ */
+export declare function verifyAddress(address: any, network: Network): boolean;
+//# sourceMappingURL=verifyAddress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifyAddress.d.ts","sourceRoot":"","sources":["../../../src/v1/verifyAddress.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,KAAA,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAOhE"}

package/dist/src/v1/verifyAddress.js

@@ -0,0 +1,50 @@
+"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.verifyAddress = verifyAddress;
+const utxolib = __importStar(require("@bitgo/utxo-lib"));
+/**
+ * Verify a Bitcoin address is a valid address
+ */
+function verifyAddress(address, network) {
+    try {
+        const script = utxolib.addressFormat.toOutputScriptTryFormats(address, network, undefined);
+        return address === utxolib.address.fromOutputScript(script, network);
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyaWZ5QWRkcmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy92MS92ZXJpZnlBZGRyZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBTUEsc0NBT0M7QUFiRCx5REFBMkM7QUFHM0M7O0dBRUc7QUFDSCxTQUFnQixhQUFhLENBQUMsT0FBTyxFQUFFLE9BQWdCO0lBQ3JELElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxhQUFhLENBQUMsd0JBQXdCLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsQ0FBQztRQUMzRixPQUFPLE9BQU8sS0FBSyxPQUFPLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztRQUNYLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyB1dHhvbGliIGZyb20gJ0BiaXRnby91dHhvLWxpYic7XG5pbXBvcnQgeyBOZXR3b3JrIH0gZnJvbSAnQGJpdGdvL3V0eG8tbGliJztcblxuLyoqXG4gKiBWZXJpZnkgYSBCaXRjb2luIGFkZHJlc3MgaXMgYSB2YWxpZCBhZGRyZXNzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB2ZXJpZnlBZGRyZXNzKGFkZHJlc3MsIG5ldHdvcms6IE5ldHdvcmspOiBib29sZWFuIHtcbiAgdHJ5IHtcbiAgICBjb25zdCBzY3JpcHQgPSB1dHhvbGliLmFkZHJlc3NGb3JtYXQudG9PdXRwdXRTY3JpcHRUcnlGb3JtYXRzKGFkZHJlc3MsIG5ldHdvcmssIHVuZGVmaW5lZCk7XG4gICAgcmV0dXJuIGFkZHJlc3MgPT09IHV0eG9saWIuYWRkcmVzcy5mcm9tT3V0cHV0U2NyaXB0KHNjcmlwdCwgbmV0d29yayk7XG4gIH0gY2F0Y2ggKGUpIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdfQ==

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;AAwDH,QAAA,MAAM,MAAM,mCAYX,CAAC;AAyjFF,SAAS,MAAM,CAAC"}