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

package/dist/src/v1/wallet.js

@@ -0,0 +1,2095 @@
+"use strict";
+/**
+ * @hidden
+ */
+/**
+ */
+//
+// Wallet Object
+// BitGo accessor for a specific wallet
+//
+// Copyright 2014, BitGo, Inc.  All Rights Reserved.
+//
+const unspents_1 = require("@bitgo/unspents");
+const utxo_lib_1 = require("@bitgo/utxo-lib");
+const TransactionBuilder = require('./transactionBuilder');
+const utxolib = require("@bitgo/utxo-lib");
+const PendingApproval = require('./pendingapproval');
+const sdk_core_1 = require("@bitgo/sdk-core");
+const Bluebird = require("bluebird");
+const co = Bluebird.coroutine;
+const _ = require("lodash");
+const { getExternalChainCode, getInternalChainCode, isChainCode, scriptTypeForChain } = utxolib.bitgo;
+const request = require('superagent');
+//
+// Constructor
+//
+const Wallet = function (bitgo, wallet) {
+    // @ts-expect-error - no implicit this
+    this.bitgo = bitgo;
+    // @ts-expect-error - no implicit this
+    this.wallet = wallet;
+    // @ts-expect-error - no implicit this
+    this.keychains = [];
+    if (wallet.private) {
+        // @ts-expect-error - no implicit this
+        this.keychains = wallet.private.keychains;
+    }
+};
+Wallet.prototype.toJSON = function () {
+    return this.wallet;
+};
+//
+// id
+// Get the id of this wallet.
+//
+Wallet.prototype.id = function () {
+    return this.wallet.id;
+};
+//
+// label
+// Get the label of this wallet.
+//
+Wallet.prototype.label = function () {
+    return this.wallet.label;
+};
+//
+// balance
+// Get the balance of this wallet.
+//
+Wallet.prototype.balance = function () {
+    return this.wallet.balance;
+};
+//
+// balance
+// Get the spendable balance of this wallet.
+// This is the total of all unspents except those that are unconfirmed and external
+//
+Wallet.prototype.spendableBalance = function () {
+    return this.wallet.spendableBalance;
+};
+//
+// confirmedBalance
+// Get the confirmedBalance of this wallet.
+//
+Wallet.prototype.confirmedBalance = function () {
+    return this.wallet.confirmedBalance;
+};
+//
+// canSendInstant
+// Returns if the wallet can send instant transactions
+// This is impacted by the choice of backup key provider
+//
+Wallet.prototype.canSendInstant = function () {
+    return this.wallet && this.wallet.canSendInstant;
+};
+//
+// instant balance
+// Get the instant balance of this wallet.
+// This is the total of all unspents that may be spent instantly.
+//
+Wallet.prototype.instantBalance = function () {
+    if (!this.canSendInstant()) {
+        throw new Error('not an instant wallet');
+    }
+    return this.wallet.instantBalance;
+};
+//
+// unconfirmedSends
+// Get the balance of unconfirmedSends of this wallet.
+//
+Wallet.prototype.unconfirmedSends = function () {
+    return this.wallet.unconfirmedSends;
+};
+//
+// unconfirmedReceives
+// Get the balance of unconfirmedReceives balance of this wallet.
+//
+Wallet.prototype.unconfirmedReceives = function () {
+    return this.wallet.unconfirmedReceives;
+};
+//
+// type
+// Get the type of this wallet, e.g. 'safehd'
+//
+Wallet.prototype.type = function () {
+    return this.wallet.type;
+};
+Wallet.prototype.url = function (extra) {
+    extra = extra || '';
+    return this.bitgo.url('/wallet/' + this.id() + extra);
+};
+//
+// pendingApprovals
+// returns the pending approvals list for this wallet as pending approval objects
+//
+Wallet.prototype.pendingApprovals = function () {
+    const self = this;
+    return this.wallet.pendingApprovals.map(function (p) {
+        return new PendingApproval(self.bitgo, p, self);
+    });
+};
+//
+// approvalsRequired
+// returns the number of approvals required to approve pending approvals involving this wallet
+//
+Wallet.prototype.approvalsRequired = function () {
+    return this.wallet.approvalsRequired || 1;
+};
+//
+// get
+// Refetches this wallet and returns it
+//
+Wallet.prototype.get = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const self = this;
+    return Bluebird.resolve(this.bitgo
+        .get(this.url())
+        .result()
+        .then(function (res) {
+        self.wallet = res;
+        return self;
+    })).nodeify(callback);
+};
+//
+// updateApprovalsRequired
+// Updates the number of approvals required on a pending approval involving this wallet.
+// The approvals required is by default 1, but this function allows you to update the
+// number such that 1 <= approvalsRequired <= walletAdmins.length - 1
+//
+Wallet.prototype.updateApprovalsRequired = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (params.approvalsRequired === undefined ||
+        !_.isInteger(params.approvalsRequired) ||
+        params.approvalsRequired < 1) {
+        throw new Error('invalid approvalsRequired: must be a nonzero positive number');
+    }
+    const self = this;
+    const currentApprovalsRequired = this.approvalsRequired();
+    if (currentApprovalsRequired === params.approvalsRequired) {
+        // no-op, just return the current wallet
+        return Bluebird.try(function () {
+            return self.wallet;
+        }).nodeify(callback);
+    }
+    return Bluebird.resolve(this.bitgo.put(this.url()).send(params).result()).nodeify(callback);
+};
+/**
+ * Returns the correct chain for change, taking into consideration segwit
+ */
+Wallet.prototype.getChangeChain = function (params) {
+    let useSegwitChange = !!this.bitgo.getConstants().enableSegwit;
+    if (!_.isUndefined(params.segwitChange)) {
+        if (!_.isBoolean(params.segwitChange)) {
+            throw new Error('segwitChange must be a boolean');
+        }
+        // if segwit is disabled through the constants, segwit change should still not be created
+        useSegwitChange = this.bitgo.getConstants().enableSegwit && params.segwitChange;
+    }
+    return useSegwitChange ? getInternalChainCode('p2shP2wsh') : getInternalChainCode('p2sh');
+};
+//
+// createAddress
+// Creates a new address for use with this wallet.
+//
+Wallet.prototype.createAddress = function (params, callback) {
+    const self = this;
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (this.type() === 'safe') {
+        throw new Error('You are using a legacy wallet that cannot create a new address');
+    }
+    // Default to client-side address validation on, for safety. Use validate=false to disable.
+    const shouldValidate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();
+    const allowExisting = params.allowExisting;
+    if (typeof allowExisting !== 'boolean') {
+        params.allowExisting = allowExisting === 'true';
+    }
+    const isSegwit = this.bitgo.getConstants().enableSegwit;
+    const defaultChain = isSegwit ? getExternalChainCode('p2shP2wsh') : getExternalChainCode('p2sh');
+    let chain = params.chain;
+    if (chain === null || chain === undefined) {
+        chain = defaultChain;
+    }
+    return Bluebird.resolve(this.bitgo
+        .post(this.url('/address/' + chain))
+        .send(params)
+        .result()
+        .then(function (addr) {
+        if (shouldValidate) {
+            self.validateAddress(addr);
+        }
+        return addr;
+    })).nodeify(callback);
+};
+/**
+ * Generate address locally without calling server
+ * @param params
+ *
+ */
+Wallet.prototype.generateAddress = function ({ segwit, path, keychains, threshold }) {
+    const isSegwit = !!segwit;
+    let signatureThreshold = 2;
+    if (_.isInteger(threshold)) {
+        signatureThreshold = threshold;
+        if (signatureThreshold <= 0) {
+            throw new Error('threshold has to be positive');
+        }
+    }
+    const pathRegex = /^\/1?[01]\/\d+$/;
+    if (!path.match(pathRegex)) {
+        throw new Error('unsupported path: ' + path);
+    }
+    let rootKeys = this.keychains;
+    if (Array.isArray(keychains)) {
+        rootKeys = keychains;
+    }
+    const network = sdk_core_1.common.Environments[this.bitgo.getEnv()].network;
+    const derivedKeys = rootKeys.map(function (k) {
+        const hdnode = utxo_lib_1.bip32.fromBase58(k.xpub);
+        const derivationPath = k.path + (k.walletSubPath || '') + path;
+        return hdnode.derivePath(sdk_core_1.sanitizeLegacyPath(derivationPath)).publicKey;
+    });
+    const pathComponents = path.split('/');
+    const normalizedPathComponents = _.map(pathComponents, (component) => {
+        if (component && component.length > 0) {
+            return parseInt(component, 10);
+        }
+    });
+    const pathDetails = _.filter(normalizedPathComponents, _.isInteger);
+    const addressDetails = {
+        chainPath: path,
+        path: path,
+        chain: pathDetails[0],
+        index: pathDetails[1],
+        wallet: this.id(),
+    };
+    const { scriptPubKey: outputScript, redeemScript, witnessScript, } = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys, isSegwit ? 'p2shP2wsh' : 'p2sh');
+    addressDetails.witnessScript = witnessScript === null || witnessScript === void 0 ? void 0 : witnessScript.toString('hex');
+    addressDetails.redeemScript = redeemScript === null || redeemScript === void 0 ? void 0 : redeemScript.toString('hex');
+    addressDetails.outputScript = outputScript.toString('hex');
+    addressDetails.address = utxolib.address.fromOutputScript(outputScript, sdk_core_1.getNetwork(network));
+    return addressDetails;
+};
+//
+// validateAddress
+// Validates an address and path by calculating it locally from the keychain xpubs
+//
+Wallet.prototype.validateAddress = function (params) {
+    sdk_core_1.common.validateParams(params, ['address', 'path'], []);
+    const isSegwit = !!params.witnessScript && params.witnessScript.length > 0;
+    const generatedAddress = this.generateAddress({ path: params.path, segwit: isSegwit });
+    if (generatedAddress.address !== params.address) {
+        throw new Error('address validation failure: ' + params.address + ' vs. ' + generatedAddress.address);
+    }
+};
+//
+// addresses
+// Gets the addresses of a HD wallet.
+// Options include:
+//  limit: the number of addresses to get
+//
+Wallet.prototype.addresses = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const query = {};
+    if (params.details) {
+        query.details = 1;
+    }
+    const chain = params.chain;
+    if (chain !== null && chain !== undefined) {
+        if (Array.isArray(chain)) {
+            query.chain = _.uniq(_.filter(chain, _.isInteger));
+        }
+        else {
+            if (chain !== 0 && chain !== 1) {
+                throw new Error('invalid chain argument, expecting 0 or 1');
+            }
+            query.chain = chain;
+        }
+    }
+    if (params.limit) {
+        if (!_.isInteger(params.limit)) {
+            throw new Error('invalid limit argument, expecting number');
+        }
+        query.limit = params.limit;
+    }
+    if (params.skip) {
+        if (!_.isInteger(params.skip)) {
+            throw new Error('invalid skip argument, expecting number');
+        }
+        query.skip = params.skip;
+    }
+    if (params.sort) {
+        if (!_.isNumber(params.sort)) {
+            throw new Error('invalid sort argument, expecting number');
+        }
+        query.sort = params.sort;
+    }
+    const url = this.url('/addresses');
+    return Bluebird.resolve(this.bitgo.get(url).query(query).result()).nodeify(callback);
+};
+Wallet.prototype.stats = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const args = [];
+    if (params.limit) {
+        if (!_.isInteger(params.limit)) {
+            throw new Error('invalid limit argument, expecting number');
+        }
+        args.push('limit=' + params.limit);
+    }
+    let query = '';
+    if (args.length) {
+        query = '?' + args.join('&');
+    }
+    const url = this.url('/stats' + query);
+    return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);
+};
+/**
+ * Refresh the wallet object by syncing with the back-end
+ * @param callback
+ * @returns {Wallet}
+ */
+Wallet.prototype.refresh = function (params, callback) {
+    return co(function* () {
+        // when set to true, gpk returns the private data of safe wallets
+        const query = _.extend({}, _.pick(params, ['gpk']));
+        // @ts-expect-error - no implicit this
+        const res = yield this.bitgo.get(this.url()).query(query).result();
+        // @ts-expect-error - no implicit this
+        this.wallet = res;
+        // @ts-expect-error - no implicit this
+        return this;
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// address
+// Gets information about a single address on a HD wallet.
+// Information includes index, path, redeemScript, sent, received, txCount and balance
+// Options include:
+//  address: the address on this wallet to get
+//
+Wallet.prototype.address = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], [], callback);
+    const url = this.url('/addresses/' + params.address);
+    return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);
+};
+/**
+ * Freeze the wallet for a duration of choice, stopping BitGo from signing any transactions.
+ * @param {number} limit The duration to freeze the wallet for in seconds, defaults to 3600.
+ */
+Wallet.prototype.freeze = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (params.duration) {
+        if (!_.isNumber(params.duration)) {
+            throw new Error('invalid duration - should be number of seconds');
+        }
+    }
+    return Bluebird.resolve(this.bitgo.post(this.url('/freeze')).send(params).result()).nodeify(callback);
+};
+//
+// delete
+// Deletes the wallet
+//
+Wallet.prototype.delete = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.del(this.url()).result()).nodeify(callback);
+};
+//
+// labels
+// List the labels for the addresses in a given wallet
+//
+Wallet.prototype.labels = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const url = this.bitgo.url('/labels/' + this.id());
+    return Bluebird.resolve(this.bitgo.get(url).result('labels')).nodeify(callback);
+};
+/**
+ * Rename a wallet
+ * @param params
+ *  - label: the wallet's intended new name
+ * @param callback
+ * @returns {*}
+ */
+Wallet.prototype.setWalletName = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['label'], [], callback);
+    const url = this.bitgo.url('/wallet/' + this.id());
+    return Bluebird.resolve(this.bitgo.put(url).send({ label: params.label }).result()).nodeify(callback);
+};
+//
+// setLabel
+// Sets a label on the provided address
+//
+Wallet.prototype.setLabel = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address', 'label'], [], callback);
+    const self = this;
+    if (!self.bitgo.verifyAddress({ address: params.address })) {
+        throw new Error('Invalid bitcoin address: ' + params.address);
+    }
+    const url = this.bitgo.url('/labels/' + this.id() + '/' + params.address);
+    return Bluebird.resolve(this.bitgo.put(url).send({ label: params.label }).result()).nodeify(callback);
+};
+//
+// deleteLabel
+// Deletes the label associated with the provided address
+//
+Wallet.prototype.deleteLabel = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], [], callback);
+    const self = this;
+    if (!self.bitgo.verifyAddress({ address: params.address })) {
+        throw new Error('Invalid bitcoin address: ' + params.address);
+    }
+    const url = this.bitgo.url('/labels/' + this.id() + '/' + params.address);
+    return Bluebird.resolve(this.bitgo.del(url).result()).nodeify(callback);
+};
+//
+// unspents
+// List ALL the unspents for a given wallet
+// This method will return a paged list of all unspents
+//
+// Parameters include:
+//   limit:  the optional limit of unspents to collect in BTC
+//   minConf: only include results with this number of confirmations
+//   target: the amount of btc to find to spend
+//   instant: only find instant transactions (must specify a target)
+//
+Wallet.prototype.unspents = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const allUnspents = [];
+    const self = this;
+    const getUnspentsBatch = function (skip, limit) {
+        const queryObject = _.cloneDeep(params);
+        if (skip > 0) {
+            queryObject.skip = skip;
+        }
+        if (limit && limit > 0) {
+            queryObject.limit = limit;
+        }
+        return self.unspentsPaged(queryObject).then(function (result) {
+            // The API has its own limit handling. For example, the API does not support limits bigger than 500. If the limit
+            // specified here is bigger than that, we will have to do multiple requests with necessary limit adjustment.
+            for (let i = 0; i < result.unspents.length; i++) {
+                const unspent = result.unspents[i];
+                allUnspents.push(unspent);
+            }
+            // Our limit adjustment makes sure that we never fetch more unspents than we need, meaning that if we hit the
+            // limit, we hit it precisely
+            if (allUnspents.length >= params.limit) {
+                return allUnspents; // we aren't interested in any further unspents
+            }
+            const totalUnspentCount = result.total;
+            // if no target is specified and the SDK indicates that there has been a limit, we need to fetch another batch
+            if (!params.target && totalUnspentCount && totalUnspentCount > allUnspents.length) {
+                // we need to fetch the next batch
+                // let's just offset the current skip by the count
+                const newSkip = skip + result.count;
+                let newLimit;
+                if (limit > 0) {
+                    // we set the new limit to be precisely the number of missing unspents to hit our own limit
+                    newLimit = limit - allUnspents.length;
+                }
+                return getUnspentsBatch(newSkip, newLimit);
+            }
+            return allUnspents;
+        });
+    };
+    return getUnspentsBatch(0, params.limit).nodeify(callback);
+};
+/**
+ * List the unspents (paged) for a given wallet, returning the result as an object of unspents, count, skip and total
+ * This method may not return all the unspents as the list is paged by the API
+ * @param params
+ * @param params.limit the optional limit of unspents to collect in BTC
+ * @param params.skip index in list of unspents to start paging from
+ * @param params.minConfirms only include results with this number of confirmations
+ * @param params.target the amount of btc to find to spend
+ * @param params.instant only find instant transactions (must specify a target)
+ * @param params.targetWalletUnspents desired number of unspents to have in the wallet after the tx goes through (requires target)
+ * @param params.minSize minimum unspent size in satoshis
+ * @param params.segwit request segwit unspents (defaults to true if undefined)
+ * @param params.allowLedgerSegwit allow segwit unspents for ledger devices (defaults to false if undefined)
+ * @param callback
+ * @returns {*}
+ */
+Wallet.prototype.unspentsPaged = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (!_.isUndefined(params.limit) && !_.isInteger(params.limit)) {
+        throw new Error('invalid limit - should be number');
+    }
+    if (!_.isUndefined(params.skip) && !_.isInteger(params.skip)) {
+        throw new Error('invalid skip - should be number');
+    }
+    if (!_.isUndefined(params.minConfirms) && !_.isInteger(params.minConfirms)) {
+        throw new Error('invalid minConfirms - should be number');
+    }
+    if (!_.isUndefined(params.target) && !_.isNumber(params.target)) {
+        throw new Error('invalid target - should be number');
+    }
+    if (!_.isUndefined(params.instant) && !_.isBoolean(params.instant)) {
+        throw new Error('invalid instant flag - should be boolean');
+    }
+    if (!_.isUndefined(params.segwit) && !_.isBoolean(params.segwit)) {
+        throw new Error('invalid segwit flag - should be boolean');
+    }
+    if (!_.isUndefined(params.targetWalletUnspents) && !_.isInteger(params.targetWalletUnspents)) {
+        throw new Error('invalid targetWalletUnspents flag - should be number');
+    }
+    if (!_.isUndefined(params.minSize) && !_.isNumber(params.minSize)) {
+        throw new Error('invalid argument: minSize must be a number');
+    }
+    if (!_.isUndefined(params.instant) && !_.isUndefined(params.minConfirms)) {
+        throw new Error('only one of instant and minConfirms may be defined');
+    }
+    if (!_.isUndefined(params.targetWalletUnspents) && _.isUndefined(params.target)) {
+        throw new Error('targetWalletUnspents can only be specified in conjunction with a target');
+    }
+    if (!_.isUndefined(params.allowLedgerSegwit) && !_.isBoolean(params.allowLedgerSegwit)) {
+        throw new Error('invalid argument: allowLedgerSegwit must be a boolean');
+    }
+    const queryObject = _.cloneDeep(params);
+    if (!_.isUndefined(params.target)) {
+        // skip and limit are unavailable when a target is specified
+        delete queryObject.skip;
+        delete queryObject.limit;
+    }
+    queryObject.segwit = true;
+    if (!_.isUndefined(params.segwit)) {
+        queryObject.segwit = params.segwit;
+    }
+    if (!_.isUndefined(params.allowLedgerSegwit)) {
+        queryObject.allowLedgerSegwit = params.allowLedgerSegwit;
+    }
+    return Bluebird.resolve(this.bitgo.get(this.url('/unspents')).query(queryObject).result()).nodeify(callback);
+};
+//
+// transactions
+// List the transactions for a given wallet
+// Options include:
+//     TODO:  Add iterators for start/count/etc
+Wallet.prototype.transactions = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    const args = [];
+    if (params.limit) {
+        if (!_.isInteger(params.limit)) {
+            throw new Error('invalid limit argument, expecting number');
+        }
+        args.push('limit=' + params.limit);
+    }
+    if (params.skip) {
+        if (!_.isInteger(params.skip)) {
+            throw new Error('invalid skip argument, expecting number');
+        }
+        args.push('skip=' + params.skip);
+    }
+    if (params.minHeight) {
+        if (!_.isInteger(params.minHeight)) {
+            throw new Error('invalid minHeight argument, expecting number');
+        }
+        args.push('minHeight=' + params.minHeight);
+    }
+    if (params.maxHeight) {
+        if (!_.isInteger(params.maxHeight) || params.maxHeight < 0) {
+            throw new Error('invalid maxHeight argument, expecting positive integer');
+        }
+        args.push('maxHeight=' + params.maxHeight);
+    }
+    if (params.minConfirms) {
+        if (!_.isInteger(params.minConfirms) || params.minConfirms < 0) {
+            throw new Error('invalid minConfirms argument, expecting positive integer');
+        }
+        args.push('minConfirms=' + params.minConfirms);
+    }
+    if (!_.isUndefined(params.compact)) {
+        if (!_.isBoolean(params.compact)) {
+            throw new Error('invalid compact argument, expecting boolean');
+        }
+        args.push('compact=' + params.compact);
+    }
+    let query = '';
+    if (args.length) {
+        query = '?' + args.join('&');
+    }
+    const url = this.url('/tx' + query);
+    return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);
+};
+//
+// transaction
+// Get a transaction by ID for a given wallet
+Wallet.prototype.getTransaction = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    const url = this.url('/tx/' + params.id);
+    return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);
+};
+//
+// pollForTransaction
+// Poll a transaction until successful or times out
+// Parameters:
+//   id: the txid
+//   delay: delay between polls in ms (default: 1000)
+//   timeout: timeout in ms (default: 10000)
+Wallet.prototype.pollForTransaction = function (params, callback) {
+    const self = this;
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    if (params.delay && !_.isNumber(params.delay)) {
+        throw new Error('invalid delay parameter');
+    }
+    if (params.timeout && !_.isNumber(params.timeout)) {
+        throw new Error('invalid timeout parameter');
+    }
+    params.delay = params.delay || 1000;
+    params.timeout = params.timeout || 10000;
+    const start = new Date();
+    const doNextPoll = function () {
+        return self
+            .getTransaction(params)
+            .then(function (res) {
+            return res;
+        })
+            .catch(function (err) {
+            if (err.status !== 404 || new Date().valueOf() - start.valueOf() > params.timeout) {
+                throw err;
+            }
+            return Bluebird.delay(params.delay).then(function () {
+                return doNextPoll();
+            });
+        });
+    };
+    return doNextPoll();
+};
+//
+// transaction by sequence id
+// Get a transaction by sequence id for a given wallet
+Wallet.prototype.getWalletTransactionBySequenceId = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['sequenceId'], [], callback);
+    const url = this.url('/tx/sequence/' + params.sequenceId);
+    return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);
+};
+//
+// Key chains
+// Gets the user key chain for this wallet
+// The user key chain is typically the first keychain of the wallet and has the encrypted xpriv stored on BitGo.
+// Useful when trying to get the users' keychain from the server before decrypting to sign a transaction.
+Wallet.prototype.getEncryptedUserKeychain = function (params, callback) {
+    return co(function* () {
+        params = params || {};
+        sdk_core_1.common.validateParams(params, [], [], callback);
+        // @ts-expect-error - no implicit this
+        const self = this;
+        const tryKeyChain = co(function* (index) {
+            if (!self.keychains || index >= self.keychains.length) {
+                const error = new Error('No encrypted keychains on this wallet.');
+                error.code = 'no_encrypted_keychain_on_wallet';
+                throw error;
+            }
+            const params = { xpub: self.keychains[index].xpub };
+            const keychain = yield self.bitgo.keychains().get(params);
+            // If we find the xprv, then this is probably the user keychain we're looking for
+            keychain.walletSubPath = self.keychains[index].path;
+            if (keychain.encryptedXprv) {
+                return keychain;
+            }
+            return tryKeyChain(index + 1);
+        });
+        return tryKeyChain(0);
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// createTransaction
+// Create a transaction (unsigned). To sign it, do signTransaction
+// Parameters:
+//   recipients - object of recipient addresses and the amount to send to each e.g. {address:1500, address2:1500}
+//   fee      - the blockchain fee to send (optional)
+//   feeRate  - the fee per kb to send (optional)
+//   minConfirms - minimum number of confirms to use when gathering unspents
+//   forceChangeAtEnd - force change address to be last output (optional)
+//   noSplitChange - disable automatic change splitting for purposes of unspent management
+//   changeAddress - override the change address (optional)
+//   validate - extra verification of change addresses (which are always verified server-side) (defaults to global config)
+// Returns:
+//   callback(err, { transactionHex: string, unspents: [inputs], fee: satoshis })
+Wallet.prototype.createTransaction = function (params, callback) {
+    params = _.extend({}, params);
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if ((!_.isNumber(params.fee) && !_.isUndefined(params.fee)) ||
+        (!_.isNumber(params.feeRate) && !_.isUndefined(params.feeRate)) ||
+        (!_.isNumber(params.minConfirms) && !_.isUndefined(params.minConfirms)) ||
+        (!_.isBoolean(params.forceChangeAtEnd) && !_.isUndefined(params.forceChangeAtEnd)) ||
+        (!_.isString(params.changeAddress) && !_.isUndefined(params.changeAddress)) ||
+        (!_.isBoolean(params.validate) && !_.isUndefined(params.validate)) ||
+        (!_.isBoolean(params.instant) && !_.isUndefined(params.instant))) {
+        throw new Error('invalid argument');
+    }
+    if (!_.isObject(params.recipients)) {
+        throw new Error('expecting recipients object');
+    }
+    params.validate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();
+    params.wallet = this;
+    return TransactionBuilder.createTransaction(params).nodeify(callback);
+};
+//
+// signTransaction
+// Sign a previously created transaction with a keychain
+// Parameters:
+// transactionHex - serialized form of the transaction in hex
+// unspents - array of unspent information, where each unspent is a chainPath
+//            and redeemScript with the same index as the inputs in the
+//            transactionHex
+// keychain - Keychain containing the xprv to sign with.
+// signingKey - For legacy safe wallets, the private key string.
+// validate - extra verification of signatures (which are always verified server-side) (defaults to global config)
+// Returns:
+//   callback(err, transaction)
+Wallet.prototype.signTransaction = function (params, callback) {
+    params = _.extend({}, params);
+    sdk_core_1.common.validateParams(params, ['transactionHex'], [], callback);
+    if (!Array.isArray(params.unspents)) {
+        throw new Error('expecting the unspents array');
+    }
+    if ((!_.isObject(params.keychain) || !params.keychain.xprv) && !_.isString(params.signingKey)) {
+        // allow passing in a WIF private key for legacy safe wallet support
+        const error = new Error('expecting keychain object with xprv or signingKey WIF');
+        error.code = 'missing_keychain_or_signingKey';
+        throw error;
+    }
+    params.validate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();
+    params.bitgo = this.bitgo;
+    return TransactionBuilder.signTransaction(params)
+        .then(function (result) {
+        return {
+            tx: result.transactionHex,
+        };
+    })
+        .nodeify(callback);
+};
+//
+// send
+// Send a transaction to the Bitcoin network via BitGo.
+// One of the keys is typically signed, and BitGo will sign the other (if approved) and relay it to the P2P network.
+// Parameters:
+//   tx  - the hex encoded, signed transaction to send
+// Returns:
+//
+Wallet.prototype.sendTransaction = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['tx'], ['message', 'otp'], callback);
+    return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/tx/send')).send(params).result())
+        .then(function (body) {
+        if (body.pendingApproval) {
+            return _.extend(body, { status: 'pendingApproval' });
+        }
+        if (body.otp) {
+            return _.extend(body, { status: 'otp' });
+        }
+        return {
+            status: 'accepted',
+            tx: body.transaction,
+            hash: body.transactionHash,
+            instant: body.instant,
+            instantId: body.instantId,
+        };
+    })
+        .nodeify(callback);
+};
+/**
+ * Share the wallet with an existing BitGo user.
+ * @param {string} user The recipient's user id, must have a corresponding user record in our database.
+ * @param {keychain} keychain The keychain to be shared with the recipient.
+ * @param {string} permissions A comma-separated value string that specifies the recipient's permissions if the share is accepted.
+ * @param {string} message The message to be used for this share.
+ */
+Wallet.prototype.createShare = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['user', 'permissions'], [], callback);
+    if (params.keychain && !_.isEmpty(params.keychain)) {
+        if (!params.keychain.xpub ||
+            !params.keychain.encryptedXprv ||
+            !params.keychain.fromPubKey ||
+            !params.keychain.toPubKey ||
+            !params.keychain.path) {
+            throw new Error('requires keychain parameters - xpub, encryptedXprv, fromPubKey, toPubKey, path');
+        }
+    }
+    return Bluebird.resolve(this.bitgo.post(this.url('/share')).send(params).result()).nodeify(callback);
+};
+//
+// createInvite
+// invite a non BitGo customer to join a wallet
+// Parameters:
+//   email - the recipient's email address
+//   permissions - the recipient's permissions if the share is accepted
+// Returns:
+//
+Wallet.prototype.createInvite = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['email', 'permissions'], ['message'], callback);
+    const options = {
+        toEmail: params.email,
+        permissions: params.permissions,
+    };
+    if (params.message) {
+        options.message = params.message;
+    }
+    return Bluebird.resolve(this.bitgo.post(this.url('/invite')).send(options).result()).nodeify(callback);
+};
+//
+// confirmInviteAndShareWallet
+// confirm my invite on this wallet to a recipient who has
+// subsequently signed up by creating the actual wallet share
+// Parameters:
+//   walletInviteId - the wallet invite id
+//   walletPassphrase - required if the wallet share success is expected
+// Returns:
+//
+Wallet.prototype.confirmInviteAndShareWallet = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['walletInviteId'], ['walletPassphrase'], callback);
+    const self = this;
+    return this.bitgo
+        .wallets()
+        .listInvites()
+        .then(function (invites) {
+        const outgoing = invites.outgoing;
+        const invite = _.find(outgoing, function (out) {
+            return out.id === params.walletInviteId;
+        });
+        if (!invite) {
+            throw new Error('wallet invite not found');
+        }
+        const options = {
+            email: invite.toEmail,
+            permissions: invite.permissions,
+            message: invite.message,
+            walletPassphrase: params.walletPassphrase,
+        };
+        return self.shareWallet(options);
+    })
+        .then(function () {
+        // @ts-expect-error - no implicit this
+        return this.bitgo.put(this.bitgo.url('/walletinvite/' + params.walletInviteId));
+    })
+        .nodeify(callback);
+};
+//
+// sendCoins
+// Send coins to a destination address from this wallet using the user key.
+// 1. Gets the user keychain by checking the wallet for a key which has an encrypted xpriv
+// 2. Decrypts user key
+// 3. Creates the transaction with default fee
+// 4. Signs transaction with decrypted user key
+// 3. Sends the transaction to BitGo
+//
+// Parameters:
+//   address - the destination address
+//   amount - the amount in satoshis to be sent
+//   message - optional message to attach to transaction
+//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet
+//   xprv - the private key in string form, if walletPassphrase is not available
+//   (See transactionBuilder.createTransaction for other passthrough params)
+// Returns:
+//
+Wallet.prototype.sendCoins = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['address'], ['message'], callback);
+    if (!_.isNumber(params.amount)) {
+        throw new Error('invalid argument for amount - number expected');
+    }
+    params.recipients = {};
+    params.recipients[params.address] = params.amount;
+    return this.sendMany(params).nodeify(callback);
+};
+//
+// sendMany
+// Send coins to multiple destination addresses from this wallet using the user key.
+// 1. Gets the user keychain by checking the wallet for a key which has an encrypted xpriv
+// 2. Decrypts user key
+// 3. Creates the transaction with default fee
+// 4. Signs transaction with decrypted user key
+// 3. Sends the transaction to BitGo
+//
+// Parameters:
+//   recipients - array of { address: string, amount: number, travelInfo: object } to send to
+//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet
+//   xprv - the private key in string form, if walletPassphrase is not available
+//   (See transactionBuilder.createTransaction for other passthrough params)
+// Returns:
+//
+Wallet.prototype.sendMany = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], ['message', 'otp'], callback);
+    const self = this;
+    if (!_.isObject(params.recipients)) {
+        throw new Error('expecting recipients object');
+    }
+    if (params.fee && !_.isNumber(params.fee)) {
+        throw new Error('invalid argument for fee - number expected');
+    }
+    if (params.feeRate && !_.isNumber(params.feeRate)) {
+        throw new Error('invalid argument for feeRate - number expected');
+    }
+    if (params.instant && !_.isBoolean(params.instant)) {
+        throw new Error('invalid argument for instant - boolean expected');
+    }
+    let bitgoFee;
+    let travelInfos;
+    let finalResult;
+    let unspentsUsed;
+    const acceptedBuildParams = [
+        'numBlocks',
+        'feeRate',
+        'minConfirms',
+        'enforceMinConfirmsForChange',
+        'targetWalletUnspents',
+        'message',
+        'minValue',
+        'maxValue',
+        'noSplitChange',
+        'comment',
+    ];
+    const preservedBuildParams = _.pick(params, acceptedBuildParams);
+    // Get the user keychain
+    const retPromise = this.createAndSignTransaction(params)
+        .then(function (transaction) {
+        // Send the transaction
+        bitgoFee = transaction.bitgoFee;
+        travelInfos = transaction.travelInfos;
+        unspentsUsed = transaction.unspents;
+        return self.sendTransaction({
+            tx: transaction.tx,
+            message: params.message,
+            sequenceId: params.sequenceId,
+            instant: params.instant,
+            otp: params.otp,
+            // The below params are for logging only, and do not impact the API call
+            estimatedSize: transaction.estimatedSize,
+            buildParams: preservedBuildParams,
+        });
+    })
+        .then(function (result) {
+        const tx = utxolib.bitgo.createTransactionFromHex(result.tx, utxolib.networks.bitcoin);
+        const inputsSum = _.sumBy(unspentsUsed, 'value');
+        const outputsSum = _.sumBy(tx.outs, 'value');
+        const feeUsed = inputsSum - outputsSum;
+        if (isNaN(feeUsed)) {
+            throw new Error('invalid feeUsed');
+        }
+        (result.fee = feeUsed), (result.feeRate = (feeUsed * 1000) / tx.virtualSize());
+        result.travelInfos = travelInfos;
+        if (bitgoFee) {
+            result.bitgoFee = bitgoFee;
+        }
+        finalResult = result;
+        // Handle sending travel infos if they exist, but make sure we never fail here.
+        // Error or result (with possible sub-errors) will be provided in travelResult
+        if (travelInfos && travelInfos.length) {
+            try {
+                return self
+                    .pollForTransaction({ id: result.hash })
+                    .then(function () {
+                    return self.bitgo.travelRule().sendMany(result);
+                })
+                    .then(function (res) {
+                    finalResult.travelResult = res;
+                })
+                    .catch(function (err) {
+                    // catch async errors
+                    finalResult.travelResult = { error: err.message };
+                });
+            }
+            catch (err) {
+                // catch synchronous errors
+                finalResult.travelResult = { error: err.message };
+            }
+        }
+    })
+        .then(function () {
+        return finalResult;
+    });
+    return Bluebird.resolve(retPromise).nodeify(callback);
+};
+/**
+ * Accelerate a stuck transaction using Child-Pays-For-Parent (CPFP).
+ *
+ * This should only be used for stuck transactions which have no unconfirmed inputs.
+ *
+ * @param {Object} params - Input parameters
+ * @param {String} params.transactionID - ID of transaction to accelerate
+ * @param {Number} params.feeRate - New effective fee rate for stuck transaction (sat per 1000 bytes)
+ * @param {Number} params.maxAdditionalUnspents - Maximum additional unspents to use from the wallet to cover any child fees that the parent unspent output cannot cover. Defaults to 100.
+ * @param {String} params.walletPassphrase - The passphrase which should be used to decrypt the wallet private key. One of either walletPassphrase or xprv is required.
+ * @param {String} params.xprv - The private key for the wallet. One of either walletPassphrase or xprv is required.
+ * @param {Function} callback
+ * @returns Result of sendTransaction() on the child transaction
+ */
+Wallet.prototype.accelerateTransaction = function accelerateTransaction(params, callback) {
+    const self = this;
+    /**
+     * Helper function to estimate a transactions size in virtual bytes.
+     * Actual transactions may be slightly fewer virtual bytes, due to
+     * the fact that valid ECSDA signatures have a variable length
+     * between 8 and 73 virtual bytes.
+     *
+     * @param inputs.segwit The number of segwit inputs to the transaction
+     * @param inputs.P2SH The number of P2SH inputs to the transaction
+     * @param inputs.P2PKH The number of P2PKH inputs to the transaction
+     */
+    const estimateTxVSize = (inputs) => {
+        const segwit = inputs.segwit || 0;
+        const P2SH = inputs.P2SH || 0;
+        const P2PKH = inputs.P2PKH || 0;
+        const childFeeInfo = TransactionBuilder.calculateMinerFeeInfo({
+            nP2shInputs: P2SH,
+            nP2pkhInputs: P2PKH,
+            nP2shP2wshInputs: segwit,
+            nOutputs: 1,
+            feeRate: 1,
+        });
+        return childFeeInfo.size;
+    };
+    /**
+     * Calculate the number of satoshis that should be paid in fees by the child transaction
+     *
+     * @param inputs Inputs to the child transaction which are passed to estimateTxVSize
+     * @param parentFee The number of satoshis the parent tx originally paid in fees
+     * @param parentVSize The number of virtual bytes in the parent tx
+     * @param feeRate The new fee rate which should be paid by the combined CPFP transaction
+     * @returns {number} The number of satoshis the child tx should pay in fees
+     */
+    const estimateChildFee = ({ inputs, parentFee, parentVSize, feeRate }) => {
+        // calculate how much more we *should* have paid in parent fees,
+        // had the parent been originally sent with the new fee rate
+        const additionalParentFee = _.ceil((parentVSize * feeRate) / 1000) - parentFee;
+        // calculate how much we would pay in fees for the child,
+        // if it were only paying for itself at the new fee rate
+        const childFee = (estimateTxVSize(inputs) * feeRate) / 1000;
+        return _.ceil(childFee + additionalParentFee);
+    };
+    /**
+     * Helper function to find additional unspents to use to pay the child tx fees.
+     * This function is called when the the parent tx output is not sufficient to
+     * cover the total fees which should be paid by the child tx.
+     *
+     * @param inputs Inputs to the child transaction which are passed to estimateTxVSize
+     * @param parentOutputValue The value of the output from the parent tx which we are using as an input to the child tx
+     * @param parentFee The number of satoshis the parent tx originally paid in fees
+     * @param parentVSize The number of virtual bytes in the parent tx
+     * @param maxUnspents The maximum number of additional unspents which should be used to cover the remaining child fees
+     * @returns An object with the additional unspents to use, the updated number of satoshis which should be paid by
+     *          the child tx, and the updated inputs for the child tx.
+     */
+    const findAdditionalUnspents = ({ inputs, parentOutputValue, parentFee, parentVSize, maxUnspents }) => {
+        return co(function* coFindAdditionalUnspents() {
+            const additionalUnspents = [];
+            // ask the server for enough unspents to cover the child fee, assuming
+            // that it can be done without additional unspents (which is not possible,
+            // since if that were the case, findAdditionalUnspents would not have been
+            // called in the first place. This will be corrected before returning)
+            let currentChildFeeEstimate = estimateChildFee({ inputs, parentFee, parentVSize, feeRate: params.feeRate });
+            let uncoveredChildFee = currentChildFeeEstimate - parentOutputValue;
+            while (uncoveredChildFee > 0 && additionalUnspents.length < maxUnspents) {
+                // try to get enough unspents to cover the rest of the child fee
+                // @ts-expect-error - no implicit this
+                const unspents = (yield this.unspents({
+                    minConfirms: 1,
+                    target: uncoveredChildFee,
+                    limit: maxUnspents - additionalUnspents.length,
+                }));
+                if (unspents.length === 0) {
+                    // no more unspents are available
+                    break;
+                }
+                let additionalUnspentValue = 0;
+                // consume all unspents returned by the server, even if we don't need
+                // all of them to cover the child fee. This is because the server will
+                // return enough unspent value to ensure that the minimum change amount
+                // is achieved for the child tx, and we can't leave out those unspents
+                // or else the minimum change amount constraint could be violated
+                _.forEach(unspents, (unspent) => {
+                    // update the child tx inputs
+                    const unspentChain = getChain(unspent);
+                    if (isChainCode(unspentChain) && scriptTypeForChain(unspentChain) === 'p2shP2wsh') {
+                        inputs.segwit++;
+                    }
+                    else {
+                        inputs.P2SH++;
+                    }
+                    additionalUnspents.push(unspent);
+                    additionalUnspentValue += unspent.value;
+                });
+                currentChildFeeEstimate = estimateChildFee({ inputs, parentFee, parentVSize, feeRate: params.feeRate });
+                uncoveredChildFee = currentChildFeeEstimate - parentOutputValue - additionalUnspentValue;
+            }
+            if (uncoveredChildFee > 0) {
+                // Unable to find enough unspents to cover the child fee
+                throw new Error(`Insufficient confirmed unspents available to cover the child fee`);
+            }
+            // found enough unspents
+            return {
+                additional: additionalUnspents,
+                newChildFee: currentChildFeeEstimate,
+                newInputs: inputs,
+            };
+        }).call(this);
+    };
+    /**
+     * Helper function to get a full copy (including witness data) of an arbitrary tx using only the tx id.
+     *
+     * We have to use an external service for this (currently blockstream.info), since
+     * the v1 indexer service (based on bitcoinj) does not have segwit support and
+     * does not return any segwit related fields in the tx hex.
+     *
+     * @param parentTxId The ID of the transaction to get the full hex of
+     * @returns {Bluebird<any>} The full hex for the specified transaction
+     */
+    async function getParentTxHex({ parentTxId }) {
+        const explorerBaseUrl = sdk_core_1.common.Environments[self.bitgo.getEnv()].btcExplorerBaseUrl;
+        const result = await request.get(`${explorerBaseUrl}/tx/${parentTxId}/hex`);
+        if (!result.text || !/([a-f0-9]{2})+/.test(result.text)) {
+            throw new Error(`Did not successfully receive parent tx hex. Received '${_.truncate(result.text, { length: 100 })}' instead.`);
+        }
+        return result.text;
+    }
+    /**
+     * Helper function to get the chain from an unspent or tx output.
+     *
+     * @param outputOrUnspent The output or unspent whose chain should be determined
+     * @returns {number} The chain for the given output or unspent
+     */
+    const getChain = (outputOrUnspent) => {
+        if (outputOrUnspent.chain !== undefined) {
+            return outputOrUnspent.chain;
+        }
+        if (outputOrUnspent.chainPath !== undefined) {
+            return _.toNumber(outputOrUnspent.chainPath.split('/')[1]);
+        }
+        // no way to tell the chain, let's just blow up now instead
+        // of blowing up later when the undefined return value is used.
+        // Note: for unspents the field to use is 'address', but for outputs
+        // the field to use is 'account'
+        throw Error(`Could not get chain for output on account ${outputOrUnspent.account || outputOrUnspent.address}`);
+    };
+    /**
+     * Helper function to calculate the actual value contribution an output or unspent will
+     * contribute to a transaction, were it to be used. Each type of output or unspent
+     * will have a different value contribution since each type has a different number
+     * of virtual bytes, and thus will cause a different fee to be paid.
+     *
+     * @param outputOrUnspent Output or unspent whose effective value should be determined
+     * @returns {number} The actual number of satoshis that this unspent or output
+     *                   would contribute to a transaction, were it to be used.
+     */
+    const effectiveValue = (outputOrUnspent) => {
+        const chain = getChain(outputOrUnspent);
+        if (isChainCode(chain) && scriptTypeForChain(chain) === 'p2shP2wsh') {
+            // VirtualSizes.txP2shP2wshInputSize is in bytes, so we need to convert to kB
+            return outputOrUnspent.value - (unspents_1.VirtualSizes.txP2shP2wshInputSize * params.feeRate) / 1000;
+        }
+        // VirtualSizes.txP2shInputSize is in bytes, so we need to convert to kB
+        return outputOrUnspent.value - (unspents_1.VirtualSizes.txP2shInputSize * params.feeRate) / 1000;
+    };
+    /**
+     * Coroutine which actually implements the accelerateTransaction algorithm
+     *
+     * Described at a high level, the algorithm is as follows:
+     * 1) Find appropriate output from parent transaction to use as child transaction input
+     * 2) Find unspent corresponding to parent transaction output. If not found, return to step 1.
+     * 3) Determine if parent transaction unspent can cover entire child fee, plus minimum change
+     * 4) If yes, go to step 6
+     * 5) Otherwise, find additional unspents from the wallet to use to cover the remaining child fee
+     * 6) Create and sign the child transaction, using the parent transaction output
+     *    (and, if necessary, additional wallet unspents) as inputs
+     * 7) Broadcast the new child transaction
+     */
+    return co(function* coAccelerateTransaction() {
+        params = params || {};
+        sdk_core_1.common.validateParams(params, ['transactionID'], [], callback);
+        // validate fee rate
+        if (params.feeRate === undefined) {
+            throw new Error('Missing parameter: feeRate');
+        }
+        if (!_.isFinite(params.feeRate) || params.feeRate <= 0) {
+            throw new Error('Expecting positive finite number for parameter: feeRate');
+        }
+        // validate maxUnspents
+        if (params.maxAdditionalUnspents === undefined) {
+            // by default, use at most 100 additional unspents (not including the unspent output from the parent tx)
+            params.maxAdditionalUnspents = 100;
+        }
+        if (!_.isInteger(params.maxAdditionalUnspents) || params.maxAdditionalUnspents <= 0) {
+            throw Error('Expecting positive integer for parameter: maxAdditionalUnspents');
+        }
+        // @ts-expect-error - no implicit this
+        const parentTx = yield this.getTransaction({ id: params.transactionID });
+        if (parentTx.confirmations > 0) {
+            throw new Error(`Transaction ${params.transactionID} is already confirmed and cannot be accelerated`);
+        }
+        // get the outputs from the parent tx which are to our wallet
+        const walletOutputs = _.filter(parentTx.outputs, (output) => output.isMine);
+        if (walletOutputs.length === 0) {
+            throw new Error(`Transaction ${params.transactionID} contains no outputs to this wallet, and thus cannot be accelerated`);
+        }
+        // use an output from the parent with largest effective value,
+        // but check to make sure the output is actually unspent.
+        // An output could be spent already if the output was used in a
+        // child tx which itself has become stuck due to low fees and is
+        // also unconfirmed.
+        const sortedOutputs = _.sortBy(walletOutputs, effectiveValue);
+        let parentUnspentToUse;
+        let outputToUse;
+        while (sortedOutputs.length > 0 && parentUnspentToUse === undefined) {
+            outputToUse = sortedOutputs.pop();
+            // find the unspent corresponding to this particular output
+            // TODO: is there a better way to get this unspent?
+            // TODO: The best we can do here is set minSize = maxSize = outputToUse.value
+            // @ts-expect-error - no implicit this
+            const unspentsResult = yield this.unspents({
+                minSize: outputToUse.value,
+                maxSize: outputToUse.value,
+            });
+            parentUnspentToUse = _.find(unspentsResult, (unspent) => {
+                // make sure unspent belongs to the given txid
+                if (unspent.tx_hash !== params.transactionID) {
+                    return false;
+                }
+                // make sure unspent has correct v_out index
+                return unspent.tx_output_n === outputToUse.vout;
+            });
+        }
+        if (parentUnspentToUse === undefined) {
+            throw new Error(`Could not find unspent output from parent tx to use as child input`);
+        }
+        // get the full hex for the parent tx and decode it to get its vsize
+        const parentTxHex = yield getParentTxHex({ parentTxId: params.transactionID });
+        const decodedParent = utxolib.bitgo.createTransactionFromHex(parentTxHex, utxolib.networks.bitcoin);
+        const parentVSize = decodedParent.virtualSize();
+        // make sure id from decoded tx and given tx id match
+        // this should catch problems emanating from the use of an external service
+        // for getting the complete parent tx hex
+        if (decodedParent.getId() !== params.transactionID) {
+            throw new Error(`Decoded transaction id is ${decodedParent.getId()}, which does not match given txid ${params.transactionID}`);
+        }
+        // make sure new fee rate is greater than the parent's current fee rate
+        // virtualSize is returned in vbytes, so we need to convert to kvB
+        const parentRate = (1000 * parentTx.fee) / parentVSize;
+        if (params.feeRate <= parentRate) {
+            throw new Error(`Cannot lower fee rate! (Parent tx fee rate is ${parentRate} sat/kB, and requested fee rate was ${params.feeRate} sat/kB)`);
+        }
+        // determine if parent output can cover child fee
+        const isParentOutputSegwit = isChainCode(outputToUse.chain) && scriptTypeForChain(outputToUse.chain) === 'p2shP2wsh';
+        let childInputs = {
+            segwit: isParentOutputSegwit ? 1 : 0,
+            P2SH: isParentOutputSegwit ? 0 : 1,
+        };
+        let childFee = estimateChildFee({
+            inputs: childInputs,
+            parentFee: parentTx.fee,
+            feeRate: params.feeRate,
+            parentVSize,
+        });
+        const unspentsToUse = [parentUnspentToUse];
+        // try to get the min change size from the server, otherwise default to 0.1 BTC
+        // TODO: minChangeSize is not currently a constant defined on the client and should be added
+        // @ts-expect-error - no implicit this
+        const minChangeSize = this.bitgo.getConstants().minChangeSize || 1e7;
+        if (outputToUse.value < childFee + minChangeSize) {
+            // parent output cannot cover child fee plus the minimum change,
+            // must find additional unspents to cover the difference
+            const { additional, newChildFee, newInputs } = yield findAdditionalUnspents({
+                inputs: childInputs,
+                parentOutputValue: outputToUse.value,
+                parentFee: parentTx.fee,
+                maxUnspents: params.maxAdditionalUnspents,
+                parentVSize,
+            });
+            childFee = newChildFee;
+            childInputs = newInputs;
+            unspentsToUse.push(...additional);
+        }
+        // sanity check the fee rate we're paying for the combined tx
+        // to make sure it's under the max fee rate. Only the child tx
+        // can break this limit, but the combined tx shall not
+        // @ts-expect-error - no implicit this
+        const maxFeeRate = this.bitgo.getConstants().maxFeeRate;
+        const childVSize = estimateTxVSize(childInputs);
+        const combinedVSize = childVSize + parentVSize;
+        const combinedFee = parentTx.fee + childFee;
+        // combined fee rate must be in sat/kB, so we need to convert
+        const combinedFeeRate = (1000 * combinedFee) / combinedVSize;
+        if (combinedFeeRate > maxFeeRate) {
+            throw new Error(`Transaction cannot be accelerated. Combined fee rate of ${combinedFeeRate} sat/kB exceeds maximum fee rate of ${maxFeeRate} sat/kB`);
+        }
+        // create a new change address and determine change amount.
+        // the tx builder will reject transactions which have no recipients,
+        // and such zero-output transactions are forbidden by the Bitcoin protocol,
+        // so we need at least a single recipient for the change which won't be pruned.
+        const changeAmount = _.sumBy(unspentsToUse, (unspent) => unspent.value) - childFee;
+        // @ts-expect-error - no implicit this
+        const changeChain = this.getChangeChain({});
+        // @ts-expect-error - no implicit this
+        const changeAddress = yield this.createAddress({ chain: changeChain });
+        // create the child tx and broadcast
+        // @ts-expect-error - no implicit this
+        const tx = yield this.createAndSignTransaction({
+            unspents: unspentsToUse,
+            recipients: [
+                {
+                    address: changeAddress.address,
+                    amount: changeAmount,
+                },
+            ],
+            fee: childFee,
+            bitgoFee: {
+                amount: 0,
+                address: '',
+            },
+            xprv: params.xprv,
+            walletPassphrase: params.walletPassphrase,
+        });
+        // child fee rate must be in sat/kB, so we need to convert
+        const childFeeRate = (1000 * childFee) / childVSize;
+        if (childFeeRate > maxFeeRate) {
+            // combined tx is within max fee rate limits, but the child tx is not.
+            // in this case, we need to use the ignoreMaxFeeRate flag to get the child tx to be accepted
+            tx.ignoreMaxFeeRate = true;
+        }
+        // @ts-expect-error - no implicit this
+        return this.sendTransaction(tx);
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// createAndSignTransaction
+// INTERNAL function to create and sign a transaction
+//
+// Parameters:
+//   recipients - array of { address, amount } to send to
+//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet
+//   (See transactionBuilder.createTransaction for other passthrough params)
+// Returns:
+//
+Wallet.prototype.createAndSignTransaction = function (params, callback) {
+    return co(function* () {
+        params = params || {};
+        sdk_core_1.common.validateParams(params, [], [], callback);
+        if (!_.isObject(params.recipients)) {
+            throw new Error('expecting recipients object');
+        }
+        if (params.fee && !_.isNumber(params.fee)) {
+            throw new Error('invalid argument for fee - number expected');
+        }
+        if (params.feeRate && !_.isNumber(params.feeRate)) {
+            throw new Error('invalid argument for feeRate - number expected');
+        }
+        if (params.dynamicFeeConfirmTarget && !_.isNumber(params.dynamicFeeConfirmTarget)) {
+            throw new Error('invalid argument for confirmTarget - number expected');
+        }
+        if (params.instant && !_.isBoolean(params.instant)) {
+            throw new Error('invalid argument for instant - boolean expected');
+        }
+        // @ts-expect-error - no implicit this
+        const transaction = (yield this.createTransaction(params));
+        const fee = transaction.fee;
+        const feeRate = transaction.feeRate;
+        const estimatedSize = transaction.estimatedSize;
+        const bitgoFee = transaction.bitgoFee;
+        const travelInfos = transaction.travelInfos;
+        const unspents = transaction.unspents;
+        // Sign the transaction
+        try {
+            // @ts-expect-error - no implicit this
+            const keychain = yield this.getAndPrepareSigningKeychain(params);
+            transaction.keychain = keychain;
+        }
+        catch (e) {
+            if (e.code !== 'no_encrypted_keychain_on_wallet') {
+                throw e;
+            }
+            // this might be a safe wallet, so let's retrieve the private key info
+            // @ts-expect-error - no implicit this
+            yield this.refresh({ gpk: true });
+            // @ts-expect-error - no implicit this
+            const safeUserKey = _.get(this.wallet, 'private.userPrivKey');
+            if (_.isString(safeUserKey) && _.isString(params.walletPassphrase)) {
+                // @ts-expect-error - no implicit this
+                transaction.signingKey = this.bitgo.decrypt({ password: params.walletPassphrase, input: safeUserKey });
+            }
+            else {
+                throw e;
+            }
+        }
+        transaction.feeSingleKeyWIF = params.feeSingleKeyWIF;
+        // @ts-expect-error - no implicit this
+        const result = yield this.signTransaction(transaction);
+        return _.extend(result, {
+            fee,
+            feeRate,
+            instant: params.instant,
+            bitgoFee,
+            travelInfos,
+            estimatedSize,
+            unspents,
+        });
+    })
+        .call(this)
+        .asCallback(callback);
+};
+//
+// getAndPrepareSigningKeychain
+// INTERNAL function to get the user keychain for signing.
+// Caller must provider either a keychain, or walletPassphrase or xprv as a string
+// If the caller provides the keychain with xprv, it is simply returned.
+// If the caller provides the encrypted xprv (walletPassphrase), then fetch the keychain object and decrypt
+// Otherwise if the xprv is provided, fetch the keychain object and augment it with the xprv.
+//
+// Parameters:
+//   keychain - keychain with xprv
+//   xprv - the private key in string form
+//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet
+// Returns:
+//   Keychain object containing xprv, xpub and paths
+//
+Wallet.prototype.getAndPrepareSigningKeychain = function (params, callback) {
+    params = params || {};
+    // If keychain with xprv is already provided, use it
+    if (_.isObject(params.keychain) && params.keychain.xprv) {
+        return Bluebird.resolve(params.keychain);
+    }
+    sdk_core_1.common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);
+    if ((params.walletPassphrase && params.xprv) || (!params.walletPassphrase && !params.xprv)) {
+        throw new Error('must provide exactly one of xprv or walletPassphrase');
+    }
+    const self = this;
+    // Caller provided a wallet passphrase
+    if (params.walletPassphrase) {
+        return self.getEncryptedUserKeychain().then(function (keychain) {
+            // Decrypt the user key with a passphrase
+            try {
+                keychain.xprv = self.bitgo.decrypt({ password: params.walletPassphrase, input: keychain.encryptedXprv });
+            }
+            catch (e) {
+                throw new Error('Unable to decrypt user keychain');
+            }
+            return keychain;
+        });
+    }
+    // Caller provided an xprv - validate and construct keychain object
+    let xpub;
+    try {
+        xpub = utxo_lib_1.bip32.fromBase58(params.xprv).neutered().toBase58();
+    }
+    catch (e) {
+        throw new Error('Unable to parse the xprv');
+    }
+    if (xpub === params.xprv) {
+        throw new Error('xprv provided was not a private key (found xpub instead)');
+    }
+    const walletXpubs = _.map(self.keychains, 'xpub');
+    if (!_.includes(walletXpubs, xpub)) {
+        throw new Error('xprv provided was not a keychain on this wallet!');
+    }
+    // get the keychain object from bitgo to find the path and (potential) wallet structure
+    return self.bitgo
+        .keychains()
+        .get({ xpub: xpub })
+        .then(function (keychain) {
+        keychain.xprv = params.xprv;
+        return keychain;
+    });
+};
+/**
+ * Takes a wallet's unspents and fans them out into a larger number of equally sized unspents
+ * @param params
+ *  target: set how many unspents you want to have in the end
+ *  minConfirms: minimum number of confirms the unspents must have
+ *  xprv: private key to sign transaction
+ *  walletPassphrase: wallet passphrase to decrypt the wallet's private key
+ * @param callback
+ * @returns {*}
+ */
+Wallet.prototype.fanOutUnspents = function (params, callback) {
+    const self = this;
+    return Bluebird.coroutine(function* () {
+        // maximum number of inputs for fanout transaction
+        // (when fanning out, we take all the unspents and make a bigger number of outputs)
+        const MAX_FANOUT_INPUT_COUNT = 80;
+        // maximum number of outputs for fanout transaction
+        const MAX_FANOUT_OUTPUT_COUNT = 300;
+        params = params || {};
+        sdk_core_1.common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);
+        const validate = params.validate === undefined ? true : params.validate;
+        const target = params.target;
+        // the target must be defined, be a number, be at least two, and be a natural number
+        if (!_.isNumber(target) || target < 2 || target % 1 !== 0) {
+            throw new Error('Target needs to be a positive integer');
+        }
+        if (target > MAX_FANOUT_OUTPUT_COUNT) {
+            throw new Error('Fan out target too high');
+        }
+        let minConfirms = params.minConfirms;
+        if (minConfirms === undefined) {
+            minConfirms = 1;
+        }
+        if (!_.isNumber(minConfirms) || minConfirms < 0) {
+            throw new Error('minConfirms needs to be an integer >= 0');
+        }
+        /**
+         * Split a natural number N into n almost equally sized (±1) natural numbers.
+         * In order to calculate the sizes of the parts, we calculate floor(N/n), and thus have the base size of all parts.
+         * If N % n !== 0, this leaves us with a remainder r where r < n. We distribute r equally among the n parts by
+         * adding 1 to the first r parts.
+         * @param total
+         * @param partCount
+         * @returns {Array}
+         */
+        const splitNumberIntoCloseNaturalNumbers = function (total, partCount) {
+            const partSize = Math.floor(total / partCount);
+            const remainder = total - partSize * partCount;
+            // initialize placeholder array
+            const almostEqualParts = new Array(partCount);
+            // fill the first remainder parts with the value partSize+1
+            _.fill(almostEqualParts, partSize + 1, 0, remainder);
+            // fill the remaining parts with the value partSize
+            _.fill(almostEqualParts, partSize, remainder);
+            // assert the correctness of the almost equal parts
+            // TODO: add check for the biggest deviation between any two parts and make sure it's <= 1
+            if (_(almostEqualParts).sum() !== total || _(almostEqualParts).size() !== partCount) {
+                throw new Error('part sum or part count mismatch');
+            }
+            return almostEqualParts;
+        };
+        // first, let's take all the wallet's unspents (with min confirms if necessary)
+        const allUnspents = (yield self.unspents({ minConfirms: minConfirms }));
+        if (allUnspents.length < 1) {
+            throw new Error('No unspents to branch out');
+        }
+        // this consolidation is essentially just a waste of money
+        if (allUnspents.length >= target) {
+            throw new Error('Fan out target has to be bigger than current number of unspents');
+        }
+        // we have at the very minimum 81 inputs, and 81 outputs. That transaction will be big
+        // in the medium run, this algorithm could be reworked to only work with a subset of the transactions
+        if (allUnspents.length > MAX_FANOUT_INPUT_COUNT) {
+            throw new Error('Too many unspents');
+        }
+        // this is all the money that is currently in the wallet
+        const grossAmount = _(allUnspents).map('value').sum();
+        // in order to not modify the params object, we create a copy
+        const txParams = _.extend({}, params);
+        txParams.unspents = allUnspents;
+        txParams.recipients = {};
+        // create target amount of new addresses for this wallet
+        const newAddressPromises = _.range(target).map(() => self.createAddress({ chain: self.getChangeChain(params), validate: validate }));
+        const newAddresses = yield Bluebird.all(newAddressPromises);
+        // let's find a nice, equal distribution of our Satoshis among the new addresses
+        const splitAmounts = splitNumberIntoCloseNaturalNumbers(grossAmount, target);
+        // map the newly created addresses to the almost components amounts we just calculated
+        txParams.recipients = _.zipObject(_.map(newAddresses, 'address'), splitAmounts);
+        txParams.noSplitChange = true;
+        // attempt to create a transaction. As it is a wallet-sweeping transaction with no fee, we expect it to fail
+        try {
+            yield self.sendMany(txParams);
+        }
+        catch (error) {
+            // as expected, the transaction creation did indeed fail due to insufficient fees
+            // the error suggests a fee value which we then use for the transaction
+            // however, let's make sure it wasn't something else
+            if (!error.fee && (!error.result || !error.result.fee)) {
+                // if the error does not contain a fee property, it is something else that has gone awry, and we throw it
+                const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);
+                error.message += `\n\nTX PARAMS:\n ${JSON.stringify(debugParams, null, 4)}`;
+                throw error;
+            }
+            const baseFee = error.fee || error.result.fee;
+            let totalFee = baseFee;
+            if (error.result.bitgoFee && error.result.bitgoFee.amount) {
+                totalFee += error.result.bitgoFee.amount;
+                txParams.bitgoFee = error.result.bitgoFee;
+            }
+            // Need to clear these out since only 1 may be set
+            delete txParams.fee;
+            txParams.originalFeeRate = txParams.feeRate;
+            delete txParams.feeRate;
+            delete txParams.feeTxConfirmTarget;
+            txParams.fee = baseFee;
+            // in order to maintain the equal distribution, we need to subtract the fee from the cumulative funds
+            // in case some unspents got pruned, we need to use error.result.available
+            const netAmount = error.result.available - totalFee; // after fees
+            // that means that the distribution has to be recalculated
+            const remainingSplitAmounts = splitNumberIntoCloseNaturalNumbers(netAmount, target);
+            // and the distribution again mapped to the new addresses
+            txParams.recipients = _.zipObject(_.map(newAddresses, 'address'), remainingSplitAmounts);
+        }
+        // this time, the transaction creation should work
+        let fanoutTx;
+        try {
+            fanoutTx = yield self.sendMany(txParams);
+        }
+        catch (e) {
+            const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);
+            e.message += `\n\nTX PARAMS:\n ${JSON.stringify(debugParams, null, 4)}`;
+            throw e;
+        }
+        return Bluebird.resolve(fanoutTx).asCallback(callback);
+    })().asCallback(callback);
+};
+/**
+ * Determine whether to fan out or coalesce a wallet's unspents
+ * @param params
+ * @param callback
+ * @returns {Request|Promise.<T>|*}
+ */
+Wallet.prototype.regroupUnspents = function (params, callback) {
+    params = params || {};
+    const target = params.target;
+    if (!_.isNumber(target) || target < 1 || target % 1 !== 0) {
+        // the target must be defined, be a number, be at least one, and be a natural number
+        throw new Error('Target needs to be a positive integer');
+    }
+    let minConfirms = params.minConfirms;
+    if (minConfirms === undefined) {
+        minConfirms = 1;
+    }
+    if (!_.isNumber(minConfirms) || minConfirms < 0) {
+        throw new Error('minConfirms needs to be an integer equal to or bigger than 0');
+    }
+    const self = this;
+    return self.unspents({ minConfirms: minConfirms }).then(function (unspents) {
+        if (unspents.length === target) {
+            return unspents;
+        }
+        else if (unspents.length > target) {
+            return self.consolidateUnspents(params, callback);
+        }
+        else if (unspents.length < target) {
+            return self.fanOutUnspents(params, callback);
+        }
+    });
+};
+/**
+ * Consolidate a wallet's unspents into fewer unspents
+ * @param params
+ *  target: set how many unspents you want to have in the end
+ *  maxInputCountPerConsolidation: set how many maximum inputs are to be permitted per consolidation batch
+ *  xprv: private key to sign transaction
+ *  walletPassphrase: wallet passphrase to decrypt the wallet's private key
+ *  maxIterationCount: maximum number of iterations to be performed until function stops
+ *  progressCallback: method to be called with object outlining current progress details
+ * @param callback
+ * @returns {*}
+ */
+Wallet.prototype.consolidateUnspents = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);
+    const validate = params.validate === undefined ? true : params.validate;
+    let target = params.target;
+    if (target === undefined) {
+        target = 1;
+    }
+    else if (!_.isNumber(target) || target < 1 || target % 1 !== 0) {
+        // the target must be defined, be a number, be at least one, and be a natural number
+        throw new Error('Target needs to be a positive integer');
+    }
+    if (params.maxSize && !_.isNumber(params.maxSize)) {
+        throw new Error('maxSize should be a number');
+    }
+    if (params.minSize && !_.isNumber(params.minSize)) {
+        throw new Error('minSize should be a number');
+    }
+    // maximum number of inputs per transaction for consolidation
+    const MAX_INPUT_COUNT = 200;
+    let maxInputCount = params.maxInputCountPerConsolidation;
+    if (maxInputCount === undefined) {
+        // null or unidentified, because equality to zero returns true in if(! clause
+        maxInputCount = MAX_INPUT_COUNT;
+    }
+    if (typeof maxInputCount !== 'number' || maxInputCount < 2 || maxInputCount % 1 !== 0) {
+        throw new Error('Maximum consolidation input count needs to be an integer equal to or bigger than 2');
+    }
+    else if (maxInputCount > MAX_INPUT_COUNT) {
+        throw new Error('Maximum consolidation input count cannot be bigger than ' + MAX_INPUT_COUNT);
+    }
+    const maxIterationCount = params.maxIterationCount || -1;
+    if ((params.maxIterationCount && (!_.isNumber(maxIterationCount) || maxIterationCount < 1)) ||
+        maxIterationCount % 1 !== 0) {
+        throw new Error('Maximum iteration count needs to be an integer equal to or bigger than 1');
+    }
+    let minConfirms = params.minConfirms;
+    if (minConfirms === undefined) {
+        minConfirms = 1;
+    }
+    if (!_.isNumber(minConfirms) || minConfirms < 0) {
+        throw new Error('minConfirms needs to be an integer equal to or bigger than 0');
+    }
+    let minSize = params.minSize || 0;
+    if (params.feeRate) {
+        // fee rate is in satoshis per kB, input size in bytes
+        const feeBasedMinSize = Math.ceil((unspents_1.VirtualSizes.txP2shInputSize * params.feeRate) / 1000);
+        if (params.minSize && minSize < feeBasedMinSize) {
+            throw new Error('provided minSize too low due to too high fee rate');
+        }
+        minSize = Math.max(feeBasedMinSize, minSize);
+        if (!params.minSize) {
+            // fee rate-based min size needs no logging if it was set explicitly
+            console.log('Only consolidating unspents larger than ' +
+                minSize +
+                ' satoshis to avoid wasting money on fees. To consolidate smaller unspents, use a lower fee rate.');
+        }
+    }
+    let iterationCount = 0;
+    const self = this;
+    let consolidationIndex = 0;
+    /**
+     * Consolidate one batch of up to MAX_INPUT_COUNT unspents.
+     * @returns {*}
+     */
+    const runNextConsolidation = co(function* () {
+        const consolidationTransactions = [];
+        let isFinalConsolidation = false;
+        iterationCount++;
+        /*
+         We take a maximum of unspentBulkSizeLimit unspents from the wallet. We want to make sure that we swipe the wallet
+         clean of all excessive unspents, so we add 1 to the target unspent count to make sure we haven't missed anything.
+         In case there are even more unspents than that, to make the consolidation as fast as possible, we expand our
+         selection to include as many as the maximum permissible number of inputs per consolidation batch.
+         Should the target number of unspents be higher than the maximum number if inputs per consolidation,
+         we still want to fetch them all simply to be able to determine whether or not a consolidation can be performed
+         at all, which is dependent on the number of all unspents being higher than the target.
+         In the next version of the unspents version SDK, we will know the total number of unspents without having to fetch
+         them, and therefore will be able to simplify this method.
+         */
+        const queryParams = {
+            limit: target + maxInputCount,
+            minConfirms: minConfirms,
+            minSize: minSize,
+        };
+        if (params.maxSize) {
+            queryParams.maxSize = params.maxSize;
+        }
+        const allUnspents = (yield self.unspents(queryParams));
+        // this consolidation is essentially just a waste of money
+        if (allUnspents.length <= target) {
+            if (iterationCount <= 1) {
+                // this is the first iteration, so the method is incorrect
+                throw new Error('Fewer unspents than consolidation target. Use fanOutUnspents instead.');
+            }
+            else {
+                // it's a later iteration, so the target may have been surpassed (due to confirmations in the background)
+                throw new Error('Done');
+            }
+        }
+        const allUnspentsCount = allUnspents.length;
+        // how many of the unspents do we want to consolidate?
+        // the +1 is because the consolidated block becomes a new unspent later
+        let targetInputCount = allUnspentsCount - target + 1;
+        targetInputCount = Math.min(targetInputCount, allUnspents.length);
+        // if the targetInputCount requires more inputs than we allow per batch, we reduce the number
+        const inputCount = Math.min(targetInputCount, maxInputCount);
+        // if either the number of inputs left to coalesce equals the number we will coalesce in this iteration
+        // or if the number of iterations matches the maximum permitted number
+        isFinalConsolidation = inputCount === targetInputCount || iterationCount === maxIterationCount;
+        const currentChunk = allUnspents.splice(0, inputCount);
+        const changeChain = self.getChangeChain(params);
+        const newAddress = (yield self.createAddress({ chain: changeChain, validate: validate }));
+        const txParams = _.extend({}, params);
+        const currentAddress = newAddress;
+        // the total amount that we are consolidating within this batch
+        const grossAmount = _(currentChunk).map('value').sum(); // before fees
+        txParams.unspents = currentChunk;
+        txParams.recipients = {};
+        txParams.recipients[newAddress.address] = grossAmount;
+        txParams.noSplitChange = true;
+        if (txParams.unspents.length <= 1) {
+            throw new Error('Done');
+        }
+        // let's attempt to create this transaction. We expect it to fail because no fee is set.
+        try {
+            yield self.sendMany(txParams);
+        }
+        catch (error) {
+            // this error should occur due to insufficient funds
+            // however, let's make sure it wasn't something else
+            if (!error.fee && (!error.result || !error.result.fee)) {
+                // if the error does not contain a fee property, it is something else that has gone awry, and we throw it
+                const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);
+                error.message += `\n\nTX PARAMS:\n ${JSON.stringify(debugParams, null, 4)}`;
+                throw error;
+            }
+            const baseFee = error.fee || error.result.fee;
+            let bitgoFee = 0;
+            let totalFee = baseFee;
+            if (error.result.bitgoFee && error.result.bitgoFee.amount) {
+                bitgoFee = error.result.bitgoFee.amount;
+                totalFee += bitgoFee;
+                txParams.bitgoFee = error.result.bitgoFee;
+            }
+            // if the net amount is negative, it should be replaced with the minimum output size
+            const netAmount = Math.max(error.result.available - totalFee, self.bitgo.getConstants().minOutputSize);
+            // Need to clear these out since only 1 may be set
+            delete txParams.fee;
+            txParams.originalFeeRate = txParams.feeRate;
+            delete txParams.feeRate;
+            delete txParams.feeTxConfirmTarget;
+            // we set the fee explicitly
+            txParams.fee = error.result.available - netAmount - bitgoFee;
+            txParams.recipients[newAddress.address] = netAmount;
+        }
+        // this transaction, on the other hand, should be created with no issues, because an appropriate fee is set
+        let sentTx;
+        try {
+            sentTx = yield self.sendMany(txParams);
+        }
+        catch (e) {
+            const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);
+            e.message += `\n\nTX PARAMS:\n ${JSON.stringify(debugParams, null, 4)}`;
+            throw e;
+        }
+        consolidationTransactions.push(sentTx);
+        if (_.isFunction(params.progressCallback)) {
+            params.progressCallback({
+                txid: sentTx.hash,
+                destination: currentAddress,
+                amount: grossAmount,
+                fee: sentTx.fee,
+                inputCount: inputCount,
+                index: consolidationIndex,
+            });
+        }
+        consolidationIndex++;
+        if (!isFinalConsolidation) {
+            // this last consolidation has not yet brought the unspents count down to the target unspent count
+            // therefore, we proceed by consolidating yet another batch
+            // before we do that, we wait 1 second so that the newly created unspent will be fetched in the next batch
+            yield Bluebird.delay(1000);
+            consolidationTransactions.push(...(yield runNextConsolidation()));
+        }
+        // this is the final consolidation transaction. We return all the ones we've had so far
+        return consolidationTransactions;
+    });
+    return runNextConsolidation(this, target)
+        .catch(function (err) {
+        if (err.message === 'Done') {
+            return;
+        }
+        throw err;
+    })
+        .nodeify(callback);
+};
+Wallet.prototype.shareWallet = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['email', 'permissions'], ['walletPassphrase', 'message'], callback);
+    if (params.reshare !== undefined && !_.isBoolean(params.reshare)) {
+        throw new Error('Expected reshare to be a boolean.');
+    }
+    if (params.skipKeychain !== undefined && !_.isBoolean(params.skipKeychain)) {
+        throw new Error('Expected skipKeychain to be a boolean. ');
+    }
+    const needsKeychain = !params.skipKeychain && params.permissions.indexOf('spend') !== -1;
+    if (params.disableEmail !== undefined && !_.isBoolean(params.disableEmail)) {
+        throw new Error('Expected disableEmail to be a boolean.');
+    }
+    const self = this;
+    let sharing;
+    let sharedKeychain;
+    return this.bitgo
+        .getSharingKey({ email: params.email.toLowerCase() })
+        .then(function (result) {
+        sharing = result;
+        if (needsKeychain) {
+            return self.getEncryptedUserKeychain({}).then(function (keychain) {
+                // Decrypt the user key with a passphrase
+                if (keychain.encryptedXprv) {
+                    if (!params.walletPassphrase) {
+                        throw new Error('Missing walletPassphrase argument');
+                    }
+                    try {
+                        keychain.xprv = self.bitgo.decrypt({ password: params.walletPassphrase, input: keychain.encryptedXprv });
+                    }
+                    catch (e) {
+                        throw new Error('Unable to decrypt user keychain');
+                    }
+                    const eckey = sdk_core_1.makeRandomKey();
+                    const secret = sdk_core_1.getSharedSecret(eckey, Buffer.from(sharing.pubkey, 'hex')).toString('hex');
+                    const newEncryptedXprv = self.bitgo.encrypt({ password: secret, input: keychain.xprv });
+                    sharedKeychain = {
+                        xpub: keychain.xpub,
+                        encryptedXprv: newEncryptedXprv,
+                        fromPubKey: eckey.publicKey.toString('hex'),
+                        toPubKey: sharing.pubkey,
+                        path: sharing.path,
+                    };
+                }
+            });
+        }
+    })
+        .then(function () {
+        const options = {
+            user: sharing.userId,
+            permissions: params.permissions,
+            reshare: params.reshare,
+            message: params.message,
+            disableEmail: params.disableEmail,
+        };
+        if (sharedKeychain) {
+            options.keychain = sharedKeychain;
+        }
+        else if (params.skipKeychain) {
+            options.keychain = {};
+        }
+        return self.createShare(options);
+    })
+        .nodeify(callback);
+};
+Wallet.prototype.removeUser = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['user'], [], callback);
+    return Bluebird.resolve(this.bitgo
+        .del(this.url('/user/' + params.user))
+        .send()
+        .result()).nodeify(callback);
+};
+Wallet.prototype.getPolicy = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.url('/policy')).send().result()).nodeify(callback);
+};
+Wallet.prototype.getPolicyStatus = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.url('/policy/status')).send().result()).nodeify(callback);
+};
+Wallet.prototype.setPolicyRule = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id', 'type'], ['message'], callback);
+    if (!_.isObject(params.condition)) {
+        throw new Error('missing parameter: conditions object');
+    }
+    if (!_.isObject(params.action)) {
+        throw new Error('missing parameter: action object');
+    }
+    return Bluebird.resolve(this.bitgo.put(this.url('/policy/rule')).send(params).result()).nodeify(callback);
+};
+Wallet.prototype.removePolicyRule = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], ['message'], callback);
+    return Bluebird.resolve(this.bitgo.del(this.url('/policy/rule')).send(params).result()).nodeify(callback);
+};
+Wallet.prototype.listWebhooks = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    return Bluebird.resolve(this.bitgo.get(this.url('/webhooks')).send().result()).nodeify(callback);
+};
+/**
+ * Simulate wallet webhook, currently for webhooks of type transaction and pending approval
+ * @param params
+ * - webhookId (required): id of the webhook to be simulated
+ * - txHash (optional but required for transaction webhooks) hash of the simulated transaction
+ * - pendingApprovalId (optional but required for pending approval webhooks) id of the simulated pending approval
+ * @param callback
+ * @returns {*}
+ */
+Wallet.prototype.simulateWebhook = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['webhookId'], ['txHash', 'pendingApprovalId'], callback);
+    const hasTxHash = !!params.txHash;
+    const hasPendingApprovalId = !!params.pendingApprovalId;
+    if ((hasTxHash && hasPendingApprovalId) || (!hasTxHash && !hasPendingApprovalId)) {
+        throw new Error('must supply either txHash or pendingApprovalId, but not both');
+    }
+    // depending on the coin type of the wallet, the txHash has to adhere to its respective format
+    // but the server takes care of that
+    // only take the txHash and pendingApprovalId properties
+    const filteredParams = _.pick(params, ['txHash', 'pendingApprovalId']);
+    const webhookId = params.webhookId;
+    return Bluebird.resolve(this.bitgo
+        .post(this.url('/webhooks/' + webhookId + '/simulate'))
+        .send(filteredParams)
+        .result()).nodeify(callback);
+};
+Wallet.prototype.addWebhook = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['url', 'type'], [], callback);
+    return Bluebird.resolve(this.bitgo.post(this.url('/webhooks')).send(params).result()).nodeify(callback);
+};
+Wallet.prototype.removeWebhook = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['url', 'type'], [], callback);
+    return Bluebird.resolve(this.bitgo.del(this.url('/webhooks')).send(params).result()).nodeify(callback);
+};
+Wallet.prototype.estimateFee = function (params, callback) {
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (params.amount && params.recipients) {
+        throw new Error('cannot specify both amount as well as recipients');
+    }
+    if (params.recipients && !_.isObject(params.recipients)) {
+        throw new Error('recipients must be array of { address: abc, amount: 100000 } objects');
+    }
+    if (params.amount && !_.isNumber(params.amount)) {
+        throw new Error('invalid amount argument, expecting number');
+    }
+    const recipients = params.recipients || [];
+    if (params.amount) {
+        // only the amount was passed in, so we need to make a false recipient to run createTransaction with
+        recipients.push({
+            address: sdk_core_1.common.Environments[this.bitgo.env].signingAddress,
+            amount: params.amount,
+        });
+    }
+    const transactionParams = _.extend({}, params);
+    transactionParams.amount = undefined;
+    transactionParams.recipients = recipients;
+    return this.createTransaction(transactionParams).then(function (tx) {
+        return {
+            estimatedSize: tx.estimatedSize,
+            fee: tx.fee,
+            feeRate: tx.feeRate,
+        };
+    });
+};
+// Not fully implemented / released on SDK. Testing for now.
+Wallet.prototype.updatePolicyRule = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id', 'type'], [], callback);
+    return Bluebird.resolve(this.bitgo.put(this.url('/policy/rule')).send(params).result()).nodeify(callback);
+};
+Wallet.prototype.deletePolicyRule = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, ['id'], [], callback);
+    return Bluebird.resolve(this.bitgo.del(this.url('/policy/rule')).send(params).result()).nodeify(callback);
+};
+//
+// getBitGoFee
+// Get the required on-transaction BitGo fee
+//
+Wallet.prototype.getBitGoFee = function (params, callback) {
+    params = params || {};
+    sdk_core_1.common.validateParams(params, [], [], callback);
+    if (!_.isNumber(params.amount)) {
+        throw new Error('invalid amount argument');
+    }
+    if (params.instant && !_.isBoolean(params.instant)) {
+        throw new Error('invalid instant argument');
+    }
+    return Bluebird.resolve(this.bitgo.get(this.url('/billing/fee')).query(params).result()).nodeify(callback);
+};
+module.exports = Wallet;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../../../src/v1/wallet.ts"],"names":[],"mappings":";AAAA;;GAEG;AAEH;GACG;AACH,EAAE;AACF,gBAAgB;AAChB,uCAAuC;AACvC,EAAE;AACF,oDAAoD;AACpD,EAAE;AAEF,8CAA+C;AAE/C,8CAAwC;AACxC,MAAM,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAC3D,2CAA2C;AAC3C,MAAM,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAErD,8CAAyG;AACzG,qCAAqC;AACrC,MAAM,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC;AAC9B,4BAA4B;AAC5B,MAAM,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,WAAW,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC;AACtG,MAAM,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAEtC,EAAE;AACF,cAAc;AACd,EAAE;AACF,MAAM,MAAM,GAAG,UAAU,KAAK,EAAE,MAAM;IACpC,sCAAsC;IACrC,IAAI,CAAC,KAAa,GAAG,KAAK,CAAC;IAC5B,sCAAsC;IACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACrB,sCAAsC;IACtC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IAEpB,IAAI,MAAM,CAAC,OAAO,EAAE;QAClB,sCAAsC;QACtC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC;KAC3C;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG;IACxB,OAAO,IAAI,CAAC,MAAM,CAAC;AACrB,CAAC,CAAC;AAEF,EAAE;AACF,KAAK;AACL,6BAA6B;AAC7B,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,EAAE,GAAG;IACpB,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;AACxB,CAAC,CAAC;AAEF,EAAE;AACF,QAAQ;AACR,gCAAgC;AAChC,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,KAAK,GAAG;IACvB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;AAC3B,CAAC,CAAC;AAEF,EAAE;AACF,UAAU;AACV,kCAAkC;AAClC,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,OAAO,GAAG;IACzB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;AAC7B,CAAC,CAAC;AAEF,EAAE;AACF,UAAU;AACV,4CAA4C;AAC5C,mFAAmF;AACnF,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG;IAClC,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;AACtC,CAAC,CAAC;AAEF,EAAE;AACF,mBAAmB;AACnB,2CAA2C;AAC3C,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG;IAClC,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;AACtC,CAAC,CAAC;AAEF,EAAE;AACF,iBAAiB;AACjB,sDAAsD;AACtD,wDAAwD;AACxD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,cAAc,GAAG;IAChC,OAAO,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;AACnD,CAAC,CAAC;AAEF,EAAE;AACF,kBAAkB;AAClB,0CAA0C;AAC1C,iEAAiE;AACjE,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,cAAc,GAAG;IAChC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;KAC1C;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;AACpC,CAAC,CAAC;AAEF,EAAE;AACF,mBAAmB;AACnB,sDAAsD;AACtD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG;IAClC,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;AACtC,CAAC,CAAC;AAEF,EAAE;AACF,sBAAsB;AACtB,iEAAiE;AACjE,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,mBAAmB,GAAG;IACrC,OAAO,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC;AACzC,CAAC,CAAC;AAEF,EAAE;AACF,OAAO;AACP,6CAA6C;AAC7C,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,IAAI,GAAG;IACtB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;AAC1B,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,KAAK;IACpC,KAAK,GAAG,KAAK,IAAI,EAAE,CAAC;IACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF,EAAE;AACF,mBAAmB;AACnB,iFAAiF;AACjF,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG;IAClC,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,UAAU,CAAC;QACjD,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,EAAE;AACF,oBAAoB;AACpB,8FAA8F;AAC9F,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,iBAAiB,GAAG;IACnC,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,IAAI,CAAC,CAAC;AAC5C,CAAC,CAAC;AAEF,EAAE;AACF,MAAM;AACN,uCAAuC;AACvC,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,GAAG,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC/C,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,OAAO,QAAQ,CAAC,OAAO,CACrB,IAAI,CAAC,KAAK;SACP,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;SACf,MAAM,EAAE;SACR,IAAI,CAAC,UAAU,GAAG;QACjB,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CACL,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACtB,CAAC,CAAC;AAEF,EAAE;AACF,0BAA0B;AAC1B,wFAAwF;AACxF,qFAAqF;AACrF,qEAAqE;AACrE,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,uBAAuB,GAAG,UAAU,MAAM,EAAE,QAAQ;IACnE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAChD,IACE,MAAM,CAAC,iBAAiB,KAAK,SAAS;QACtC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC;QACtC,MAAM,CAAC,iBAAiB,GAAG,CAAC,EAC5B;QACA,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;KACjF;IAED,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,MAAM,wBAAwB,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC1D,IAAI,wBAAwB,KAAK,MAAM,CAAC,iBAAiB,EAAE;QACzD,wCAAwC;QACxC,OAAO,QAAQ,CAAC,GAAG,CAAC;YAClB,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;KACtB;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC9F,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,SAAS,CAAC,cAAc,GAAG,UAAU,MAAM;IAChD,IAAI,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,YAAY,CAAC;IAC/D,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;QACvC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;SACnD;QAED,yFAAyF;QACzF,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,YAAY,IAAI,MAAM,CAAC,YAAY,CAAC;KACjF;IACD,OAAO,eAAe,CAAC,CAAC,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC5F,CAAC,CAAC;AAEF,EAAE;AACF,gBAAgB;AAChB,kDAAkD;AAClD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,MAAM,EAAE,QAAQ;IACzD,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAChD,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,MAAM,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;KACnF;IAED,2FAA2F;IAC3F,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAElG,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;IAC3C,IAAI,OAAO,aAAa,KAAK,SAAS,EAAE;QACtC,MAAM,CAAC,aAAa,GAAG,aAAa,KAAK,MAAM,CAAC;KACjD;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,YAAY,CAAC;IACxD,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAEjG,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IACzB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;QACzC,KAAK,GAAG,YAAY,CAAC;KACtB;IACD,OAAO,QAAQ,CAAC,OAAO,CACrB,IAAI,CAAC,KAAK;SACP,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC;SACnC,IAAI,CAAC,MAAM,CAAC;SACZ,MAAM,EAAE;SACR,IAAI,CAAC,UAAU,IAAI;QAClB,IAAI,cAAc,EAAE;YAClB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;SAC5B;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CACL,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACtB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE;IACjF,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1B,IAAI,kBAAkB,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE;QAC1B,kBAAkB,GAAG,SAAS,CAAC;QAC/B,IAAI,kBAAkB,IAAI,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;SACjD;KACF;IAED,MAAM,SAAS,GAAG,iBAAiB,CAAC;IACpC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;KAC9C;IAED,IAAI,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;IAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;QAC5B,QAAQ,GAAG,SAAS,CAAC;KACtB;IAED,MAAM,OAAO,GAAG,iBAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;IAEjE,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC;QAC1C,MAAM,MAAM,GAAG,gBAAK,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,cAAc,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,aAAa,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;QAC/D,OAAO,MAAM,CAAC,UAAU,CAAC,6BAAkB,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvC,MAAM,wBAAwB,GAAG,CAAC,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,SAAS,EAAE,EAAE;QACnE,IAAI,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YACrC,OAAO,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;SAChC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;IAEpE,MAAM,cAAc,GAAQ;QAC1B,SAAS,EAAE,IAAI;QACf,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;QACrB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;QACrB,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE;KAClB,CAAC;IAEF,MAAM,EACJ,YAAY,EAAE,YAAY,EAC1B,YAAY,EACZ,aAAa,GACd,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,sBAAsB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAErG,cAAc,CAAC,aAAa,GAAG,aAAa,aAAb,aAAa,uBAAb,aAAa,CAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9D,cAAc,CAAC,YAAY,GAAG,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5D,cAAc,CAAC,YAAY,GAAG,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3D,cAAc,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,YAAY,EAAE,qBAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAE7F,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC;AAEF,EAAE;AACF,kBAAkB;AAClB,kFAAkF;AAClF,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM;IACjD,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;IAE3E,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvF,IAAI,gBAAgB,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,EAAE;QAC/C,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,MAAM,CAAC,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;KACvG;AACH,CAAC,CAAC;AAEF,EAAE;AACF,YAAY;AACZ,qCAAqC;AACrC,mBAAmB;AACnB,yCAAyC;AACzC,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,MAAM,EAAE,QAAQ;IACrD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,MAAM,KAAK,GAAQ,EAAE,CAAC;IACtB,IAAI,MAAM,CAAC,OAAO,EAAE;QAClB,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;KACnB;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;QACzC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxB,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;SACpD;aAAM;YACL,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE;gBAC9B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;aAC7D;YACD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;SACrB;KACF;IACD,IAAI,MAAM,CAAC,KAAK,EAAE;QAChB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;YAC9B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;SAC7D;QACD,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;KAC5B;IACD,IAAI,MAAM,CAAC,IAAI,EAAE;QACf,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QACD,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;KAC1B;IACD,IAAI,MAAM,CAAC,IAAI,EAAE;QACf,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QACD,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;KAC1B;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACnC,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvF,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,MAAM,EAAE,QAAQ;IACjD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAChD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,IAAI,MAAM,CAAC,KAAK,EAAE;QAChB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;YAC9B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;SAC7D;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;KACpC;IACD,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,IAAI,CAAC,MAAM,EAAE;QACf,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KAC9B;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC;IAEvC,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,SAAS,CAAC,OAAO,GAAG,UAAU,MAAM,EAAE,QAAQ;IACnD,OAAO,EAAE,CAAC,QAAQ,CAAC;QACjB,iEAAiE;QACjE,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACpD,sCAAsC;QACtC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QACnE,sCAAsC;QACtC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QAClB,sCAAsC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACC,IAAI,CAAC,IAAI,CAAC;SACV,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC,CAAC;AAEF,EAAE;AACF,UAAU;AACV,0DAA0D;AAC1D,sFAAsF;AACtF,mBAAmB;AACnB,8CAA8C;AAC9C,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,OAAO,GAAG,UAAU,MAAM,EAAE,QAAQ;IACnD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEzD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAErD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,MAAM,EAAE,QAAQ;IAClD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,IAAI,MAAM,CAAC,QAAQ,EAAE;QACnB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;KACF;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxG,CAAC,CAAC;AAEF,EAAE;AACF,SAAS;AACT,qBAAqB;AACrB,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,MAAM,EAAE,QAAQ;IAClD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACjF,CAAC,CAAC;AAEF,EAAE;AACF,SAAS;AACT,sDAAsD;AACtD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,MAAM,EAAE,QAAQ;IAClD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAEnD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAClF,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,MAAM,EAAE,QAAQ;IACzD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEvD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IACnD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxG,CAAC,CAAC;AAEF,EAAE;AACF,WAAW;AACX,uCAAuC;AACvC,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,MAAM,EAAE,QAAQ;IACpD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAElE,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE;QAC1D,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;KAC/D;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1E,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxG,CAAC,CAAC;AAEF,EAAE;AACF,cAAc;AACd,yDAAyD;AACzD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEzD,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE;QAC1D,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;KAC/D;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1E,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,EAAE;AACF,WAAW;AACX,2CAA2C;AAC3C,uDAAuD;AACvD,EAAE;AACF,sBAAsB;AACtB,6DAA6D;AAC7D,oEAAoE;AACpE,+CAA+C;AAC/C,oEAAoE;AACpE,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,MAAM,EAAE,QAAQ;IACpD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,MAAM,WAAW,GAAU,EAAE,CAAC;IAC9B,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,MAAM,gBAAgB,GAAG,UAAU,IAAI,EAAE,KAAM;QAC7C,MAAM,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,IAAI,GAAG,CAAC,EAAE;YACZ,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC;SACzB;QACD,IAAI,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;YACtB,WAAW,CAAC,KAAK,GAAG,KAAK,CAAC;SAC3B;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,UAAU,MAAM;YAC1D,iHAAiH;YACjH,4GAA4G;YAC5G,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACnC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aAC3B;YAED,6GAA6G;YAC7G,6BAA6B;YAC7B,IAAI,WAAW,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE;gBACtC,OAAO,WAAW,CAAC,CAAC,+CAA+C;aACpE;YAED,MAAM,iBAAiB,GAAG,MAAM,CAAC,KAAK,CAAC;YACvC,8GAA8G;YAC9G,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,iBAAiB,IAAI,iBAAiB,GAAG,WAAW,CAAC,MAAM,EAAE;gBACjF,kCAAkC;gBAClC,kDAAkD;gBAClD,MAAM,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;gBACpC,IAAI,QAA4B,CAAC;gBACjC,IAAI,KAAK,GAAG,CAAC,EAAE;oBACb,2FAA2F;oBAC3F,QAAQ,GAAG,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC;iBACvC;gBACD,OAAO,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;aAC5C;YAED,OAAO,WAAW,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,OAAO,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7D,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,MAAM,EAAE,QAAQ;IACzD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;QAC9D,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;KACrD;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC5D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;KACpD;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;QAC1E,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC/D,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;KACtD;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAClE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;KAC7D;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAChE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,EAAE;QAC5F,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;KACzE;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QACjE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;QACxE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;KACvE;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC/E,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;KAC5F;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE;QACtF,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,MAAM,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAExC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QACjC,4DAA4D;QAC5D,OAAO,WAAW,CAAC,IAAI,CAAC;QACxB,OAAO,WAAW,CAAC,KAAK,CAAC;KAC1B;IAED,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QACjC,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;KACpC;IAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE;QAC5C,WAAW,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;KAC1D;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC/G,CAAC,CAAC;AAEF,EAAE;AACF,eAAe;AACf,2CAA2C;AAC3C,mBAAmB;AACnB,+CAA+C;AAC/C,MAAM,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,MAAM,EAAE,QAAQ;IACxD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,IAAI,MAAM,CAAC,KAAK,EAAE;QAChB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;YAC9B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;SAC7D;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;KACpC;IACD,IAAI,MAAM,CAAC,IAAI,EAAE;QACf,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;KAClC;IACD,IAAI,MAAM,CAAC,SAAS,EAAE;QACpB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;YAClC,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;SACjE;QACD,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;KAC5C;IACD,IAAI,MAAM,CAAC,SAAS,EAAE;QACpB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,SAAS,GAAG,CAAC,EAAE;YAC1D,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;SAC3E;QACD,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;KAC5C;IACD,IAAI,MAAM,CAAC,WAAW,EAAE;QACtB,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAAC,WAAW,GAAG,CAAC,EAAE;YAC9D,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;SAC7E;QACD,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;KAChD;IACD,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAClC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAChE;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;KACxC;IACD,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,IAAI,IAAI,CAAC,MAAM,EAAE;QACf,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KAC9B;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;IAEpC,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,EAAE;AACF,cAAc;AACd,6CAA6C;AAC7C,MAAM,CAAC,SAAS,CAAC,cAAc,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEpD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;IAEzC,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,EAAE;AACF,qBAAqB;AACrB,mDAAmD;AACnD,cAAc;AACd,iBAAiB;AACjB,qDAAqD;AACrD,4CAA4C;AAC5C,MAAM,CAAC,SAAS,CAAC,kBAAkB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC9D,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IACpD,IAAI,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;QAC7C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;KAC5C;IACD,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QACjD,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;KAC9C;IACD,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC;IACpC,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC;IAEzC,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;IAEzB,MAAM,UAAU,GAAG;QACjB,OAAO,IAAI;aACR,cAAc,CAAC,MAAM,CAAC;aACtB,IAAI,CAAC,UAAU,GAAG;YACjB,OAAO,GAAG,CAAC;QACb,CAAC,CAAC;aACD,KAAK,CAAC,UAAU,GAAG;YAClB,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE;gBACjF,MAAM,GAAG,CAAC;aACX;YACD,OAAO,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;gBACvC,OAAO,UAAU,EAAE,CAAC;YACtB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;IAEF,OAAO,UAAU,EAAE,CAAC;AACtB,CAAC,CAAC;AAEF,EAAE;AACF,6BAA6B;AAC7B,sDAAsD;AACtD,MAAM,CAAC,SAAS,CAAC,gCAAgC,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC5E,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAE5D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAE1D,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,EAAE;AACF,aAAa;AACb,0CAA0C;AAC1C,gHAAgH;AAChH,yGAAyG;AACzG,MAAM,CAAC,SAAS,CAAC,wBAAwB,GAAG,UAAU,MAAM,EAAE,QAAQ;IACpE,OAAO,EAAE,CAAC,QAAQ,CAAC;QACjB,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;QAChD,sCAAsC;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC;QAElB,MAAM,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,KAAK;YACrC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;gBACrD,MAAM,KAAK,GAAQ,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;gBACvE,KAAK,CAAC,IAAI,GAAG,iCAAiC,CAAC;gBAC/C,MAAM,KAAK,CAAC;aACb;YAED,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;YAEpD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC1D,iFAAiF;YACjF,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YACpD,IAAI,QAAQ,CAAC,aAAa,EAAE;gBAC1B,OAAO,QAAQ,CAAC;aACjB;YACD,OAAO,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC,CAAC;SACC,IAAI,CAAC,IAAI,CAAC;SACV,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC,CAAC;AAEF,EAAE;AACF,oBAAoB;AACpB,kEAAkE;AAClE,cAAc;AACd,iHAAiH;AACjH,qDAAqD;AACrD,iDAAiD;AACjD,4EAA4E;AAC5E,yEAAyE;AACzE,0FAA0F;AAC1F,2DAA2D;AAC3D,0HAA0H;AAC1H,WAAW;AACX,iFAAiF;AACjF,MAAM,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC7D,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC9B,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,IACE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAC3E,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAChE;QACA,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KACrC;IAED,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;KAChD;IAED,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAC7F,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;IAErB,OAAO,kBAAkB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxE,CAAC,CAAC;AAEF,EAAE;AACF,kBAAkB;AAClB,wDAAwD;AACxD,cAAc;AACd,6DAA6D;AAC7D,6EAA6E;AAC7E,uEAAuE;AACvE,4BAA4B;AAC5B,wDAAwD;AACxD,gEAAgE;AAChE,kHAAkH;AAClH,WAAW;AACX,+BAA+B;AAC/B,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC3D,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC9B,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;QACnC,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;KACjD;IAED,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;QAC7F,oEAAoE;QACpE,MAAM,KAAK,GAAQ,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QACtF,KAAK,CAAC,IAAI,GAAG,gCAAgC,CAAC;QAC9C,MAAM,KAAK,CAAC;KACb;IAED,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAC7F,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IAC1B,OAAO,kBAAkB,CAAC,eAAe,CAAC,MAAM,CAAC;SAC9C,IAAI,CAAC,UAAU,MAAM;QACpB,OAAO;YACL,EAAE,EAAE,MAAM,CAAC,cAAc;SAC1B,CAAC;IACJ,CAAC,CAAC;SACD,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,EAAE;AACF,OAAO;AACP,uDAAuD;AACvD,oHAAoH;AACpH,cAAc;AACd,sDAAsD;AACtD,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC3D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;IAEpE,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;SACvF,IAAI,CAAC,UAAU,IAAI;QAClB,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;SACtD;QAED,IAAI,IAAI,CAAC,GAAG,EAAE;YACZ,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;SAC1C;QAED,OAAO;YACL,MAAM,EAAE,UAAU;YAClB,EAAE,EAAE,IAAI,CAAC,WAAW;YACpB,IAAI,EAAE,IAAI,CAAC,eAAe;YAC1B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC,CAAC;SACD,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,aAAa,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAErE,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;QAClD,IACE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI;YACrB,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa;YAC9B,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU;YAC3B,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ;YACzB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EACrB;YACA,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;SACnG;KACF;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvG,CAAC,CAAC;AAEF,EAAE;AACF,eAAe;AACf,+CAA+C;AAC/C,cAAc;AACd,0CAA0C;AAC1C,uEAAuE;AACvE,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,MAAM,EAAE,QAAQ;IACxD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;IAE/E,MAAM,OAAO,GAAQ;QACnB,OAAO,EAAE,MAAM,CAAC,KAAK;QACrB,WAAW,EAAE,MAAM,CAAC,WAAW;KAChC,CAAC;IAEF,IAAI,MAAM,CAAC,OAAO,EAAE;QAClB,OAAO,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;KAClC;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACzG,CAAC,CAAC;AAEF,EAAE;AACF,8BAA8B;AAC9B,0DAA0D;AAC1D,6DAA6D;AAC7D,cAAc;AACd,0CAA0C;AAC1C,wEAAwE;AACxE,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,2BAA2B,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,CAAC,kBAAkB,CAAC,EAAE,QAAQ,CAAC,CAAC;IAElF,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,OAAO,IAAI,CAAC,KAAK;SACd,OAAO,EAAE;SACT,WAAW,EAAE;SACb,IAAI,CAAC,UAAU,OAAO;QACrB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAClC,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG;YAC3C,OAAO,GAAG,CAAC,EAAE,KAAK,MAAM,CAAC,cAAc,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;SAC5C;QAED,MAAM,OAAO,GAAG;YACd,KAAK,EAAE,MAAM,CAAC,OAAO;YACrB,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;SAC1C,CAAC;QAEF,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC,CAAC;SACD,IAAI,CAAC;QACJ,sCAAsC;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,gBAAgB,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;IAClF,CAAC,CAAC;SACD,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,EAAE;AACF,YAAY;AACZ,2EAA2E;AAC3E,0FAA0F;AAC1F,uBAAuB;AACvB,8CAA8C;AAC9C,+CAA+C;AAC/C,oCAAoC;AACpC,EAAE;AACF,cAAc;AACd,sCAAsC;AACtC,+CAA+C;AAC/C,wDAAwD;AACxD,wFAAwF;AACxF,gFAAgF;AAChF,4EAA4E;AAC5E,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,MAAM,EAAE,QAAQ;IACrD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;IAElE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IAED,MAAM,CAAC,UAAU,GAAG,EAAE,CAAC;IACvB,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IAElD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF,EAAE;AACF,WAAW;AACX,oFAAoF;AACpF,0FAA0F;AAC1F,uBAAuB;AACvB,8CAA8C;AAC9C,+CAA+C;AAC/C,oCAAoC;AACpC,EAAE;AACF,cAAc;AACd,6FAA6F;AAC7F,wFAAwF;AACxF,gFAAgF;AAChF,4EAA4E;AAC5E,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,MAAM,EAAE,QAAQ;IACpD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;KAChD;IAED,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;QACzC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;IAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QACjD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;KACnE;IAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAClD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;KACpE;IAED,IAAI,QAAQ,CAAC;IACb,IAAI,WAAW,CAAC;IAChB,IAAI,WAAW,CAAC;IAChB,IAAI,YAAY,CAAC;IAEjB,MAAM,mBAAmB,GAAG;QAC1B,WAAW;QACX,SAAS;QACT,aAAa;QACb,6BAA6B;QAC7B,sBAAsB;QACtB,SAAS;QACT,UAAU;QACV,UAAU;QACV,eAAe;QACf,SAAS;KACV,CAAC;IACF,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAEjE,wBAAwB;IACxB,MAAM,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC;SACrD,IAAI,CAAC,UAAU,WAAW;QACzB,uBAAuB;QACvB,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;QAChC,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;QACtC,YAAY,GAAG,WAAW,CAAC,QAAQ,CAAC;QACpC,OAAO,IAAI,CAAC,eAAe,CAAC;YAC1B,EAAE,EAAE,WAAW,CAAC,EAAE;YAClB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,wEAAwE;YACxE,aAAa,EAAE,WAAW,CAAC,aAAa;YACxC,WAAW,EAAE,oBAAoB;SAClC,CAAC,CAAC;IACL,CAAC,CAAC;SACD,IAAI,CAAC,UAAU,MAAM;QACpB,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACvF,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;QACvC,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;SACpC;QACD,CAAC,MAAM,CAAC,GAAG,GAAG,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/E,MAAM,CAAC,WAAW,GAAG,WAAW,CAAC;QACjC,IAAI,QAAQ,EAAE;YACZ,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;SAC5B;QACD,WAAW,GAAG,MAAM,CAAC;QAErB,+EAA+E;QAC/E,8EAA8E;QAC9E,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,EAAE;YACrC,IAAI;gBACF,OAAO,IAAI;qBACR,kBAAkB,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;qBACvC,IAAI,CAAC;oBACJ,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAClD,CAAC,CAAC;qBACD,IAAI,CAAC,UAAU,GAAG;oBACjB,WAAW,CAAC,YAAY,GAAG,GAAG,CAAC;gBACjC,CAAC,CAAC;qBACD,KAAK,CAAC,UAAU,GAAG;oBAClB,qBAAqB;oBACrB,WAAW,CAAC,YAAY,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;gBACpD,CAAC,CAAC,CAAC;aACN;YAAC,OAAO,GAAG,EAAE;gBACZ,2BAA2B;gBAC3B,WAAW,CAAC,YAAY,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;aACnD;SACF;IACH,CAAC,CAAC;SACD,IAAI,CAAC;QACJ,OAAO,WAAW,CAAC;IACrB,CAAC,CAAC,CAAC;IACL,OAAO,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,SAAS,CAAC,qBAAqB,GAAG,SAAS,qBAAqB,CAAC,MAAM,EAAE,QAAQ;IACtF,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB;;;;;;;;;OASG;IACH,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;QAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC;QAC9B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QAEhC,MAAM,YAAY,GAAG,kBAAkB,CAAC,qBAAqB,CAAC;YAC5D,WAAW,EAAE,IAAI;YACjB,YAAY,EAAE,KAAK;YACnB,gBAAgB,EAAE,MAAM;YACxB,QAAQ,EAAE,CAAC;YACX,OAAO,EAAE,CAAC;SACX,CAAC,CAAC;QAEH,OAAO,YAAY,CAAC,IAAI,CAAC;IAC3B,CAAC,CAAC;IAEF;;;;;;;;OAQG;IACH,MAAM,gBAAgB,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,EAAE;QACvE,gEAAgE;QAChE,4DAA4D;QAC5D,MAAM,mBAAmB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;QAE/E,yDAAyD;QACzD,wDAAwD;QACxD,MAAM,QAAQ,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;QAE5D,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,mBAAmB,CAAC,CAAC;IAChD,CAAC,CAAC;IAEF;;;;;;;;;;;;OAYG;IACH,MAAM,sBAAsB,GAAG,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE;QACpG,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC,wBAAwB;YAC1C,MAAM,kBAAkB,GAAU,EAAE,CAAC;YAErC,sEAAsE;YACtE,0EAA0E;YAC1E,0EAA0E;YAC1E,sEAAsE;YACtE,IAAI,uBAAuB,GAAG,gBAAgB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;YAC5G,IAAI,iBAAiB,GAAG,uBAAuB,GAAG,iBAAiB,CAAC;YAEpE,OAAO,iBAAiB,GAAG,CAAC,IAAI,kBAAkB,CAAC,MAAM,GAAG,WAAW,EAAE;gBACvE,gEAAgE;gBAChE,sCAAsC;gBACtC,MAAM,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC;oBACpC,WAAW,EAAE,CAAC;oBACd,MAAM,EAAE,iBAAiB;oBACzB,KAAK,EAAE,WAAW,GAAG,kBAAkB,CAAC,MAAM;iBAC/C,CAAC,CAAQ,CAAC;gBAEX,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;oBACzB,iCAAiC;oBACjC,MAAM;iBACP;gBAED,IAAI,sBAAsB,GAAG,CAAC,CAAC;gBAE/B,qEAAqE;gBACrE,sEAAsE;gBACtE,uEAAuE;gBACvE,sEAAsE;gBACtE,iEAAiE;gBACjE,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,EAAE;oBAC9B,6BAA6B;oBAC7B,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;oBACvC,IAAI,WAAW,CAAC,YAAY,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,KAAK,WAAW,EAAE;wBACjF,MAAM,CAAC,MAAM,EAAE,CAAC;qBACjB;yBAAM;wBACL,MAAM,CAAC,IAAI,EAAE,CAAC;qBACf;oBAED,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBACjC,sBAAsB,IAAI,OAAO,CAAC,KAAK,CAAC;gBAC1C,CAAC,CAAC,CAAC;gBAEH,uBAAuB,GAAG,gBAAgB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;gBACxG,iBAAiB,GAAG,uBAAuB,GAAG,iBAAiB,GAAG,sBAAsB,CAAC;aAC1F;YAED,IAAI,iBAAiB,GAAG,CAAC,EAAE;gBACzB,wDAAwD;gBACxD,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;aACrF;YAED,wBAAwB;YACxB,OAAO;gBACL,UAAU,EAAE,kBAAkB;gBAC9B,WAAW,EAAE,uBAAuB;gBACpC,SAAS,EAAE,MAAM;aAClB,CAAC;QACJ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC,CAAC;IAEF;;;;;;;;;OASG;IACH,KAAK,UAAU,cAAc,CAAC,EAAE,UAAU,EAA0B;QAClE,MAAM,eAAe,GAAG,iBAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,kBAAkB,CAAC;QACpF,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,eAAe,OAAO,UAAU,MAAM,CAAC,CAAC;QAE5E,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YACvD,MAAM,IAAI,KAAK,CACb,yDAAyD,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAC9G,CAAC;SACH;QAED,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACH,MAAM,QAAQ,GAAG,CAAC,eAAe,EAAE,EAAE;QACnC,IAAI,eAAe,CAAC,KAAK,KAAK,SAAS,EAAE;YACvC,OAAO,eAAe,CAAC,KAAK,CAAC;SAC9B;QAED,IAAI,eAAe,CAAC,SAAS,KAAK,SAAS,EAAE;YAC3C,OAAO,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC5D;QAED,2DAA2D;QAC3D,+DAA+D;QAC/D,oEAAoE;QACpE,gCAAgC;QAChC,MAAM,KAAK,CAAC,6CAA6C,eAAe,CAAC,OAAO,IAAI,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC;IACjH,CAAC,CAAC;IAEF;;;;;;;;;OASG;IACH,MAAM,cAAc,GAAG,CAAC,eAAe,EAAE,EAAE;QACzC,MAAM,KAAK,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAAC,KAAK,WAAW,EAAE;YACnE,6EAA6E;YAC7E,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,uBAAY,CAAC,oBAAoB,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;SAC5F;QACD,wEAAwE;QACxE,OAAO,eAAe,CAAC,KAAK,GAAG,CAAC,uBAAY,CAAC,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IACxF,CAAC,CAAC;IAEF;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC,uBAAuB;QACzC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;QAE/D,oBAAoB;QACpB,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;SAC/C;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,EAAE;YACtD,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;SAC5E;QAED,uBAAuB;QACvB,IAAI,MAAM,CAAC,qBAAqB,KAAK,SAAS,EAAE;YAC9C,wGAAwG;YACxG,MAAM,CAAC,qBAAqB,GAAG,GAAG,CAAC;SACpC;QAED,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,qBAAqB,CAAC,IAAI,MAAM,CAAC,qBAAqB,IAAI,CAAC,EAAE;YACnF,MAAM,KAAK,CAAC,iEAAiE,CAAC,CAAC;SAChF;QAED,sCAAsC;QACtC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;QACzE,IAAI,QAAQ,CAAC,aAAa,GAAG,CAAC,EAAE;YAC9B,MAAM,IAAI,KAAK,CAAC,eAAe,MAAM,CAAC,aAAa,iDAAiD,CAAC,CAAC;SACvG;QAED,6DAA6D;QAC7D,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAE5E,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE;YAC9B,MAAM,IAAI,KAAK,CACb,eAAe,MAAM,CAAC,aAAa,qEAAqE,CACzG,CAAC;SACH;QAED,8DAA8D;QAC9D,yDAAyD;QACzD,+DAA+D;QAC/D,gEAAgE;QAChE,oBAAoB;QACpB,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;QAC9D,IAAI,kBAAkB,CAAC;QACvB,IAAI,WAAW,CAAC;QAEhB,OAAO,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,kBAAkB,KAAK,SAAS,EAAE;YACnE,WAAW,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;YAElC,2DAA2D;YAC3D,mDAAmD;YACnD,6EAA6E;YAC7E,sCAAsC;YACtC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC;gBACzC,OAAO,EAAE,WAAW,CAAC,KAAK;gBAC1B,OAAO,EAAE,WAAW,CAAC,KAAK;aAC3B,CAAC,CAAC;YAEH,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,EAAE;gBACtD,8CAA8C;gBAC9C,IAAI,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,aAAa,EAAE;oBAC5C,OAAO,KAAK,CAAC;iBACd;gBACD,4CAA4C;gBAC5C,OAAO,OAAO,CAAC,WAAW,KAAK,WAAW,CAAC,IAAI,CAAC;YAClD,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,kBAAkB,KAAK,SAAS,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;SACvF;QAED,oEAAoE;QACpE,MAAM,WAAW,GAAG,MAAM,cAAc,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;QAC/E,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACpG,MAAM,WAAW,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAEhD,qDAAqD;QACrD,2EAA2E;QAC3E,yCAAyC;QACzC,IAAI,aAAa,CAAC,KAAK,EAAE,KAAK,MAAM,CAAC,aAAa,EAAE;YAClD,MAAM,IAAI,KAAK,CACb,6BAA6B,aAAa,CAAC,KAAK,EAAE,qCAAqC,MAAM,CAAC,aAAa,EAAE,CAC9G,CAAC;SACH;QAED,uEAAuE;QACvE,kEAAkE;QAClE,MAAM,UAAU,GAAG,CAAC,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC;QACvD,IAAI,MAAM,CAAC,OAAO,IAAI,UAAU,EAAE;YAChC,MAAM,IAAI,KAAK,CACb,iDAAiD,UAAU,uCAAuC,MAAM,CAAC,OAAO,UAAU,CAC3H,CAAC;SACH;QAED,iDAAiD;QACjD,MAAM,oBAAoB,GACxB,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,WAAW,CAAC;QAE1F,IAAI,WAAW,GAAG;YAChB,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpC,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SACnC,CAAC;QAEF,IAAI,QAAQ,GAAG,gBAAgB,CAAC;YAC9B,MAAM,EAAE,WAAW;YACnB,SAAS,EAAE,QAAQ,CAAC,GAAG;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,WAAW;SACZ,CAAC,CAAC;QAEH,MAAM,aAAa,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAE3C,+EAA+E;QAC/E,4FAA4F;QAC5F,sCAAsC;QACtC,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,aAAa,IAAI,GAAG,CAAC;QAErE,IAAI,WAAW,CAAC,KAAK,GAAG,QAAQ,GAAG,aAAa,EAAE;YAChD,gEAAgE;YAChE,wDAAwD;YACxD,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,MAAM,sBAAsB,CAAC;gBAC1E,MAAM,EAAE,WAAW;gBACnB,iBAAiB,EAAE,WAAW,CAAC,KAAK;gBACpC,SAAS,EAAE,QAAQ,CAAC,GAAG;gBACvB,WAAW,EAAE,MAAM,CAAC,qBAAqB;gBACzC,WAAW;aACZ,CAAC,CAAC;YACH,QAAQ,GAAG,WAAW,CAAC;YACvB,WAAW,GAAG,SAAS,CAAC;YACxB,aAAa,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;SACnC;QAED,6DAA6D;QAC7D,8DAA8D;QAC9D,sDAAsD;QACtD,sCAAsC;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,UAAU,CAAC;QACxD,MAAM,UAAU,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;QAChD,MAAM,aAAa,GAAG,UAAU,GAAG,WAAW,CAAC;QAC/C,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC;QAC5C,6DAA6D;QAC7D,MAAM,eAAe,GAAG,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,aAAa,CAAC;QAE7D,IAAI,eAAe,GAAG,UAAU,EAAE;YAChC,MAAM,IAAI,KAAK,CACb,2DAA2D,eAAe,uCAAuC,UAAU,SAAS,CACrI,CAAC;SACH;QAED,2DAA2D;QAC3D,oEAAoE;QACpE,2EAA2E;QAC3E,+EAA+E;QAC/E,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC;QACnF,sCAAsC;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC5C,sCAAsC;QACtC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;QAEvE,oCAAoC;QACpC,sCAAsC;QACtC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC;YAC7C,QAAQ,EAAE,aAAa;YACvB,UAAU,EAAE;gBACV;oBACE,OAAO,EAAE,aAAa,CAAC,OAAO;oBAC9B,MAAM,EAAE,YAAY;iBACrB;aACF;YACD,GAAG,EAAE,QAAQ;YACb,QAAQ,EAAE;gBACR,MAAM,EAAE,CAAC;gBACT,OAAO,EAAE,EAAE;aACZ;YACD,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;SAC1C,CAAC,CAAC;QAEH,0DAA0D;QAC1D,MAAM,YAAY,GAAG,CAAC,IAAI,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAC;QACpD,IAAI,YAAY,GAAG,UAAU,EAAE;YAC7B,sEAAsE;YACtE,4FAA4F;YAC5F,EAAE,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAC5B;QAED,sCAAsC;QACtC,OAAO,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;IAClC,CAAC,CAAC;SACC,IAAI,CAAC,IAAI,CAAC;SACV,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC,CAAC;AAEF,EAAE;AACF,2BAA2B;AAC3B,qDAAqD;AACrD,EAAE;AACF,cAAc;AACd,yDAAyD;AACzD,wFAAwF;AACxF,4EAA4E;AAC5E,WAAW;AACX,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,wBAAwB,GAAG,UAAU,MAAM,EAAE,QAAQ;IACpE,OAAO,EAAE,CAAC,QAAQ,CAAC;QACjB,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;QAEhD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;YAClC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;SAChD;QAED,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;YACzC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;SAC/D;QAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;YACjD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;SACnE;QAED,IAAI,MAAM,CAAC,uBAAuB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,uBAAuB,CAAC,EAAE;YACjF,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;SACzE;QAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;YAClD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;SACpE;QAED,sCAAsC;QACtC,MAAM,WAAW,GAAG,CAAC,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAQ,CAAC;QAClE,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC;QAC5B,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;QACpC,MAAM,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC;QAChD,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;QACtC,MAAM,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;QAC5C,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;QAEtC,uBAAuB;QACvB,IAAI;YACF,sCAAsC;YACtC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,MAAM,CAAC,CAAC;YACjE,WAAW,CAAC,QAAQ,GAAG,QAAQ,CAAC;SACjC;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,CAAC,IAAI,KAAK,iCAAiC,EAAE;gBAChD,MAAM,CAAC,CAAC;aACT;YACD,sEAAsE;YACtE,sCAAsC;YACtC,MAAM,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;YAClC,sCAAsC;YACtC,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;YAC9D,IAAI,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;gBAClE,sCAAsC;gBACtC,WAAW,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;aACxG;iBAAM;gBACL,MAAM,CAAC,CAAC;aACT;SACF;QAED,WAAW,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QACrD,sCAAsC;QACtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QACvD,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE;YACtB,GAAG;YACH,OAAO;YACP,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,QAAQ;YACR,WAAW;YACX,aAAa;YACb,QAAQ;SACT,CAAC,CAAC;IACL,CAAC,CAAC;SACC,IAAI,CAAC,IAAI,CAAC;SACV,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC,CAAC;AAEF,EAAE;AACF,+BAA+B;AAC/B,0DAA0D;AAC1D,kFAAkF;AAClF,wEAAwE;AACxE,2GAA2G;AAC3G,6FAA6F;AAC7F,EAAE;AACF,cAAc;AACd,kCAAkC;AAClC,0CAA0C;AAC1C,wFAAwF;AACxF,WAAW;AACX,oDAAoD;AACpD,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,4BAA4B,GAAG,UAAU,MAAM,EAAE,QAAQ;IACxE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IAEtB,oDAAoD;IACpD,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACvD,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;KAC1C;IAED,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;IAE1E,IAAI,CAAC,MAAM,CAAC,gBAAgB,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,gBAAgB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC1F,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;KACzE;IAED,MAAM,IAAI,GAAG,IAAI,CAAC;IAElB,sCAAsC;IACtC,IAAI,MAAM,CAAC,gBAAgB,EAAE;QAC3B,OAAO,IAAI,CAAC,wBAAwB,EAAE,CAAC,IAAI,CAAC,UAAU,QAAQ;YAC5D,yCAAyC;YACzC,IAAI;gBACF,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC;aAC1G;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;aACpD;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;KACJ;IAED,mEAAmE;IACnE,IAAI,IAAI,CAAC;IACT,IAAI;QACF,IAAI,GAAG,gBAAK,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC;KAC5D;IAAC,OAAO,CAAC,EAAE;QACV,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;KAC7C;IAED,IAAI,IAAI,KAAK,MAAM,CAAC,IAAI,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;KAC7E;IAED,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAClD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;KACrE;IAED,uFAAuF;IACvF,OAAO,IAAI,CAAC,KAAK;SACd,SAAS,EAAE;SACX,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;SACnB,IAAI,CAAC,UAAU,QAAQ;QACtB,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QAC5B,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,SAAS,CAAC,cAAc,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC1D,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,OAAO,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC;QACjC,kDAAkD;QAClD,mFAAmF;QACnF,MAAM,sBAAsB,GAAG,EAAE,CAAC;QAClC,mDAAmD;QACnD,MAAM,uBAAuB,GAAG,GAAG,CAAC;QACpC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC1E,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;QAExE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC7B,oFAAoF;QACpF,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,IAAI,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE;YACzD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;SAC1D;QACD,IAAI,MAAM,GAAG,uBAAuB,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;SAC5C;QAED,IAAI,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACrC,IAAI,WAAW,KAAK,SAAS,EAAE;YAC7B,WAAW,GAAG,CAAC,CAAC;SACjB;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,EAAE;YAC/C,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;SAC5D;QAED;;;;;;;;WAQG;QACH,MAAM,kCAAkC,GAAG,UAAU,KAAK,EAAE,SAAS;YACnE,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;YAC/C,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;YAC/C,+BAA+B;YAC/B,MAAM,gBAAgB,GAAG,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;YAC9C,2DAA2D;YAC3D,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,GAAG,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;YACrD,mDAAmD;YACnD,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;YAC9C,mDAAmD;YACnD,0FAA0F;YAC1F,IAAI,CAAC,CAAC,gBAAgB,CAAC,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,gBAAgB,CAAC,CAAC,IAAI,EAAE,KAAK,SAAS,EAAE;gBACnF,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;aACpD;YACD,OAAO,gBAAgB,CAAC;QAC1B,CAAC,CAAC;QAEF,+EAA+E;QAC/E,MAAM,WAAW,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAAQ,CAAC;QAC/E,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;SAC9C;QAED,0DAA0D;QAC1D,IAAI,WAAW,CAAC,MAAM,IAAI,MAAM,EAAE;YAChC,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;SACpF;QAED,sFAAsF;QACtF,qGAAqG;QACrG,IAAI,WAAW,CAAC,MAAM,GAAG,sBAAsB,EAAE;YAC/C,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;SACtC;QAED,wDAAwD;QACxD,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC;QAEtD,6DAA6D;QAC7D,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACtC,QAAQ,CAAC,QAAQ,GAAG,WAAW,CAAC;QAChC,QAAQ,CAAC,UAAU,GAAG,EAAE,CAAC;QAEzB,wDAAwD;QACxD,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAClD,IAAI,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAC/E,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAC5D,gFAAgF;QAChF,MAAM,YAAY,GAAG,kCAAkC,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAC7E,sFAAsF;QACtF,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,CAAC;QAChF,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9B,4GAA4G;QAC5G,IAAI;YACF,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAC/B;QAAC,OAAO,KAAK,EAAE;YACd,iFAAiF;YACjF,uEAAuE;YACvE,oDAAoD;YACpD,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;gBACtD,yGAAyG;gBACzG,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;gBACnE,KAAK,CAAC,OAAO,IAAI,oBAAoB,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;gBAC5E,MAAM,KAAK,CAAC;aACb;YACD,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC;YAC9C,IAAI,QAAQ,GAAG,OAAO,CAAC;YACvB,IAAI,KAAK,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACzD,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;aAC3C;YAED,kDAAkD;YAClD,OAAO,QAAQ,CAAC,GAAG,CAAC;YACpB,QAAQ,CAAC,eAAe,GAAG,QAAQ,CAAC,OAAO,CAAC;YAC5C,OAAO,QAAQ,CAAC,OAAO,CAAC;YACxB,OAAO,QAAQ,CAAC,kBAAkB,CAAC;YACnC,QAAQ,CAAC,GAAG,GAAG,OAAO,CAAC;YACvB,qGAAqG;YACrG,0EAA0E;YAC1E,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,aAAa;YAClE,0DAA0D;YAC1D,MAAM,qBAAqB,GAAG,kCAAkC,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACpF,yDAAyD;YACzD,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,qBAAqB,CAAC,CAAC;SAC1F;QAED,kDAAkD;QAClD,IAAI,QAAQ,CAAC;QACb,IAAI;YACF,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAC1C;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;YACnE,CAAC,CAAC,OAAO,IAAI,oBAAoB,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;YACxE,MAAM,CAAC,CAAC;SACT;QAED,OAAO,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACzD,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC5B,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC3D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,IAAI,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE;QACzD,oFAAoF;QACpF,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;KAC1D;IAED,IAAI,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;IACrC,IAAI,WAAW,KAAK,SAAS,EAAE;QAC7B,WAAW,GAAG,CAAC,CAAC;KACjB;IACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,EAAE;QAC/C,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;KACjF;IAED,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,QAAQ;QACxE,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,EAAE;YAC9B,OAAO,QAAQ,CAAC;SACjB;aAAM,IAAI,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE;YACnC,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;SACnD;aAAM,IAAI,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE;YACnC,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;SAC9C;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,SAAS,CAAC,mBAAmB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC/D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC1E,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAExE,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC3B,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,MAAM,GAAG,CAAC,CAAC;KACZ;SAAM,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,IAAI,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE;QAChE,oFAAoF;QACpF,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;KAC1D;IAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QACjD,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;KAC/C;IAED,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QACjD,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;KAC/C;IAED,6DAA6D;IAC7D,MAAM,eAAe,GAAG,GAAG,CAAC;IAC5B,IAAI,aAAa,GAAG,MAAM,CAAC,6BAA6B,CAAC;IACzD,IAAI,aAAa,KAAK,SAAS,EAAE;QAC/B,6EAA6E;QAC7E,aAAa,GAAG,eAAe,CAAC;KACjC;IACD,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,GAAG,CAAC,IAAI,aAAa,GAAG,CAAC,KAAK,CAAC,EAAE;QACrF,MAAM,IAAI,KAAK,CAAC,oFAAoF,CAAC,CAAC;KACvG;SAAM,IAAI,aAAa,GAAG,eAAe,EAAE;QAC1C,MAAM,IAAI,KAAK,CAAC,0DAA0D,GAAG,eAAe,CAAC,CAAC;KAC/F;IAED,MAAM,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC;IACzD,IACE,CAAC,MAAM,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,GAAG,CAAC,CAAC,CAAC;QACvF,iBAAiB,GAAG,CAAC,KAAK,CAAC,EAC3B;QACA,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;KAC7F;IAED,IAAI,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;IACrC,IAAI,WAAW,KAAK,SAAS,EAAE;QAC7B,WAAW,GAAG,CAAC,CAAC;KACjB;IACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,EAAE;QAC/C,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;KACjF;IAED,IAAI,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;IAClC,IAAI,MAAM,CAAC,OAAO,EAAE;QAClB,sDAAsD;QACtD,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,uBAAY,CAAC,eAAe,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;QAC1F,IAAI,MAAM,CAAC,OAAO,IAAI,OAAO,GAAG,eAAe,EAAE;YAC/C,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;SACtE;QACD,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QAE7C,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;YACnB,oEAAoE;YACpE,OAAO,CAAC,GAAG,CACT,0CAA0C;gBACxC,OAAO;gBACP,kGAAkG,CACrG,CAAC;SACH;KACF;IAED,IAAI,cAAc,GAAG,CAAC,CAAC;IAEvB,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,IAAI,kBAAkB,GAAG,CAAC,CAAC;IAE3B;;;OAGG;IACH,MAAM,oBAAoB,GAAG,EAAE,CAAC,QAAQ,CAAC;QACvC,MAAM,yBAAyB,GAAU,EAAE,CAAC;QAC5C,IAAI,oBAAoB,GAAG,KAAK,CAAC;QACjC,cAAc,EAAE,CAAC;QACjB;;;;;;;;;;WAUG;QAEH,MAAM,WAAW,GAAQ;YACvB,KAAK,EAAE,MAAM,GAAG,aAAa;YAC7B,WAAW,EAAE,WAAW;YACxB,OAAO,EAAE,OAAO;SACjB,CAAC;QACF,IAAI,MAAM,CAAC,OAAO,EAAE;YAClB,WAAW,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;SACtC;QACD,MAAM,WAAW,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAQ,CAAC;QAC9D,0DAA0D;QAC1D,IAAI,WAAW,CAAC,MAAM,IAAI,MAAM,EAAE;YAChC,IAAI,cAAc,IAAI,CAAC,EAAE;gBACvB,0DAA0D;gBAC1D,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;aAC1F;iBAAM;gBACL,yGAAyG;gBACzG,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;aACzB;SACF;QAED,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAM,CAAC;QAE5C,sDAAsD;QACtD,uEAAuE;QACvE,IAAI,gBAAgB,GAAG,gBAAgB,GAAG,MAAM,GAAG,CAAC,CAAC;QACrD,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QAElE,6FAA6F;QAC7F,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,aAAa,CAAC,CAAC;QAE7D,uGAAuG;QACvG,sEAAsE;QACtE,oBAAoB,GAAG,UAAU,KAAK,gBAAgB,IAAI,cAAc,KAAK,iBAAiB,CAAC;QAE/F,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QACvD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAQ,CAAC;QACjG,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACtC,MAAM,cAAc,GAAG,UAAU,CAAC;QAClC,+DAA+D;QAC/D,MAAM,WAAW,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,cAAc;QAEtE,QAAQ,CAAC,QAAQ,GAAG,YAAY,CAAC;QACjC,QAAQ,CAAC,UAAU,GAAG,EAAE,CAAC;QACzB,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC;QACtD,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC;QAE9B,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE;YACjC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC;SACzB;QAED,wFAAwF;QACxF,IAAI;YACF,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAC/B;QAAC,OAAO,KAAK,EAAE;YACd,oDAAoD;YACpD,oDAAoD;YACpD,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;gBACtD,yGAAyG;gBACzG,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;gBACnE,KAAK,CAAC,OAAO,IAAI,oBAAoB,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;gBAC5E,MAAM,KAAK,CAAC;aACb;YACD,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC;YAC9C,IAAI,QAAQ,GAAG,CAAC,CAAC;YACjB,IAAI,QAAQ,GAAG,OAAO,CAAC;YACvB,IAAI,KAAK,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACzD,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACxC,QAAQ,IAAI,QAAQ,CAAC;gBACrB,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;aAC3C;YAED,oFAAoF;YACpF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,GAAG,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,aAAa,CAAC,CAAC;YACvG,kDAAkD;YAClD,OAAO,QAAQ,CAAC,GAAG,CAAC;YACpB,QAAQ,CAAC,eAAe,GAAG,QAAQ,CAAC,OAAO,CAAC;YAC5C,OAAO,QAAQ,CAAC,OAAO,CAAC;YACxB,OAAO,QAAQ,CAAC,kBAAkB,CAAC;YAEnC,4BAA4B;YAC5B,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;YAC7D,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;SACrD;QACD,2GAA2G;QAC3G,IAAI,MAAM,CAAC;QACX,IAAI;YACF,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;SACxC;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;YACnE,CAAC,CAAC,OAAO,IAAI,oBAAoB,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;YACxE,MAAM,CAAC,CAAC;SACT;QACD,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;YACzC,MAAM,CAAC,gBAAgB,CAAC;gBACtB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,WAAW,EAAE,cAAc;gBAC3B,MAAM,EAAE,WAAW;gBACnB,GAAG,EAAE,MAAM,CAAC,GAAG;gBACf,UAAU,EAAE,UAAU;gBACtB,KAAK,EAAE,kBAAkB;aAC1B,CAAC,CAAC;SACJ;QACD,kBAAkB,EAAE,CAAC;QACrB,IAAI,CAAC,oBAAoB,EAAE;YACzB,kGAAkG;YAClG,2DAA2D;YAC3D,0GAA0G;YAC1G,MAAM,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC3B,yBAAyB,CAAC,IAAI,CAAC,GAAI,CAAC,MAAM,oBAAoB,EAAE,CAAS,CAAC,CAAC;SAC5E;QACD,uFAAuF;QACvF,OAAO,yBAAyB,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,OAAO,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC;SACtC,KAAK,CAAC,UAAU,GAAG;QAClB,IAAI,GAAG,CAAC,OAAO,KAAK,MAAM,EAAE;YAC1B,OAAO;SACR;QACD,MAAM,GAAG,CAAC;IACZ,CAAC,CAAC;SACD,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,CAAC,kBAAkB,EAAE,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;IAEnG,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAChE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;KACtD;IAED,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;QAC1E,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IACD,MAAM,aAAa,GAAG,CAAC,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAEzF,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;QAC1E,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;KAC3D;IAED,MAAM,IAAI,GAAG,IAAI,CAAC;IAClB,IAAI,OAAO,CAAC;IACZ,IAAI,cAAc,CAAC;IACnB,OAAO,IAAI,CAAC,KAAK;SACd,aAAa,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;SACpD,IAAI,CAAC,UAAU,MAAM;QACpB,OAAO,GAAG,MAAM,CAAC;QAEjB,IAAI,aAAa,EAAE;YACjB,OAAO,IAAI,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,QAAQ;gBAC9D,yCAAyC;gBACzC,IAAI,QAAQ,CAAC,aAAa,EAAE;oBAC1B,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE;wBAC5B,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;qBACtD;oBACD,IAAI;wBACF,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC;qBAC1G;oBAAC,OAAO,CAAC,EAAE;wBACV,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;qBACpD;oBAED,MAAM,KAAK,GAAG,wBAAa,EAAE,CAAC;oBAC9B,MAAM,MAAM,GAAG,0BAAe,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBAC1F,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;oBAExF,cAAc,GAAG;wBACf,IAAI,EAAE,QAAQ,CAAC,IAAI;wBACnB,aAAa,EAAE,gBAAgB;wBAC/B,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;wBAC3C,QAAQ,EAAE,OAAO,CAAC,MAAM;wBACxB,IAAI,EAAE,OAAO,CAAC,IAAI;qBACnB,CAAC;iBACH;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC,CAAC;SACD,IAAI,CAAC;QAWJ,MAAM,OAAO,GAAY;YACvB,IAAI,EAAE,OAAO,CAAC,MAAM;YACpB,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,YAAY,EAAE,MAAM,CAAC,YAAY;SAClC,CAAC;QACF,IAAI,cAAc,EAAE;YAClB,OAAO,CAAC,QAAQ,GAAG,cAAc,CAAC;SACnC;aAAM,IAAI,MAAM,CAAC,YAAY,EAAE;YAC9B,OAAO,CAAC,QAAQ,GAAG,EAAE,CAAC;SACvB;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC,CAAC;SACD,OAAO,CAAC,QAAQ,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,MAAM,EAAE,QAAQ;IACtD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEtD,OAAO,QAAQ,CAAC,OAAO,CACrB,IAAI,CAAC,KAAK;SACP,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;SACrC,IAAI,EAAE;SACN,MAAM,EAAE,CACZ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACtB,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,SAAS,GAAG,UAAU,MAAM,EAAE,QAAQ;IACrD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACjG,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC3D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACxG,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,MAAM,EAAE,QAAQ;IACzD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;IAErE,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;QACjC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;KACzD;IAED,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;KACrD;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC5G,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC5D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;IAE7D,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC5G,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,MAAM,EAAE,QAAQ;IACxD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACnG,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,SAAS,CAAC,eAAe,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC3D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC;IAExF,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;IAClC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAExD,IAAI,CAAC,SAAS,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,CAAC,oBAAoB,CAAC,EAAE;QAChF,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;KACjF;IAED,8FAA8F;IAC9F,oCAAoC;IAEpC,wDAAwD;IACxD,MAAM,cAAc,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAEvE,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACnC,OAAO,QAAQ,CAAC,OAAO,CACrB,IAAI,CAAC,KAAK;SACP,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,SAAS,GAAG,WAAW,CAAC,CAAC;SACtD,IAAI,CAAC,cAAc,CAAC;SACpB,MAAM,EAAE,CACZ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACtB,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,MAAM,EAAE,QAAQ;IACtD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAE7D,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC1G,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,aAAa,GAAG,UAAU,MAAM,EAAE,QAAQ;IACzD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAE7D,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACzG,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvD,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEhD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,EAAE;QACtC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;KACrE;IACD,IAAI,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;QACvD,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;KACzF;IACD,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC/C,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;KAC9D;IAED,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC;IAE3C,IAAI,MAAM,CAAC,MAAM,EAAE;QACjB,oGAAoG;QACpG,UAAU,CAAC,IAAI,CAAC;YACd,OAAO,EAAE,iBAAM,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,cAAc;YAC3D,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;KACJ;IAED,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC/C,iBAAiB,CAAC,MAAM,GAAG,SAAS,CAAC;IACrC,iBAAiB,CAAC,UAAU,GAAG,UAAU,CAAC;IAE1C,OAAO,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE;QAChE,OAAO;YACL,aAAa,EAAE,EAAE,CAAC,aAAa;YAC/B,GAAG,EAAE,EAAE,CAAC,GAAG;YACX,OAAO,EAAE,EAAE,CAAC,OAAO;SACpB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,4DAA4D;AAC5D,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC5D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAE5D,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC5G,CAAC,CAAC;AAEF,MAAM,CAAC,SAAS,CAAC,gBAAgB,GAAG,UAAU,MAAM,EAAE,QAAQ;IAC5D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAEpD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC5G,CAAC,CAAC;AAEF,EAAE;AACF,cAAc;AACd,4CAA4C;AAC5C,EAAE;AACF,MAAM,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,MAAM,EAAE,QAAQ;IACvD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;IACtB,iBAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IAChD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;KAC5C;IACD,IAAI,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAClD,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;KAC7C;IACD,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7G,CAAC,CAAC;AAEF,iBAAS,MAAM,CAAC","sourcesContent":["/**\n * @hidden\n */\n\n/**\n */\n//\n// Wallet Object\n// BitGo accessor for a specific wallet\n//\n// Copyright 2014, BitGo, Inc.  All Rights Reserved.\n//\n\nimport { VirtualSizes } from '@bitgo/unspents';\n\nimport { bip32 } from '@bitgo/utxo-lib';\nconst TransactionBuilder = require('./transactionBuilder');\nimport * as utxolib from '@bitgo/utxo-lib';\nconst PendingApproval = require('./pendingapproval');\n\nimport { common, getNetwork, getSharedSecret, makeRandomKey, sanitizeLegacyPath } from '@bitgo/sdk-core';\nimport * as Bluebird from 'bluebird';\nconst co = Bluebird.coroutine;\nimport * as _ from 'lodash';\nconst { getExternalChainCode, getInternalChainCode, isChainCode, scriptTypeForChain } = utxolib.bitgo;\nconst request = require('superagent');\n\n//\n// Constructor\n//\nconst Wallet = function (bitgo, wallet) {\n  // @ts-expect-error - no implicit this\n  (this.bitgo as any) = bitgo;\n  // @ts-expect-error - no implicit this\n  this.wallet = wallet;\n  // @ts-expect-error - no implicit this\n  this.keychains = [];\n\n  if (wallet.private) {\n    // @ts-expect-error - no implicit this\n    this.keychains = wallet.private.keychains;\n  }\n};\n\nWallet.prototype.toJSON = function () {\n  return this.wallet;\n};\n\n//\n// id\n// Get the id of this wallet.\n//\nWallet.prototype.id = function () {\n  return this.wallet.id;\n};\n\n//\n// label\n// Get the label of this wallet.\n//\nWallet.prototype.label = function () {\n  return this.wallet.label;\n};\n\n//\n// balance\n// Get the balance of this wallet.\n//\nWallet.prototype.balance = function () {\n  return this.wallet.balance;\n};\n\n//\n// balance\n// Get the spendable balance of this wallet.\n// This is the total of all unspents except those that are unconfirmed and external\n//\nWallet.prototype.spendableBalance = function () {\n  return this.wallet.spendableBalance;\n};\n\n//\n// confirmedBalance\n// Get the confirmedBalance of this wallet.\n//\nWallet.prototype.confirmedBalance = function () {\n  return this.wallet.confirmedBalance;\n};\n\n//\n// canSendInstant\n// Returns if the wallet can send instant transactions\n// This is impacted by the choice of backup key provider\n//\nWallet.prototype.canSendInstant = function () {\n  return this.wallet && this.wallet.canSendInstant;\n};\n\n//\n// instant balance\n// Get the instant balance of this wallet.\n// This is the total of all unspents that may be spent instantly.\n//\nWallet.prototype.instantBalance = function () {\n  if (!this.canSendInstant()) {\n    throw new Error('not an instant wallet');\n  }\n  return this.wallet.instantBalance;\n};\n\n//\n// unconfirmedSends\n// Get the balance of unconfirmedSends of this wallet.\n//\nWallet.prototype.unconfirmedSends = function () {\n  return this.wallet.unconfirmedSends;\n};\n\n//\n// unconfirmedReceives\n// Get the balance of unconfirmedReceives balance of this wallet.\n//\nWallet.prototype.unconfirmedReceives = function () {\n  return this.wallet.unconfirmedReceives;\n};\n\n//\n// type\n// Get the type of this wallet, e.g. 'safehd'\n//\nWallet.prototype.type = function () {\n  return this.wallet.type;\n};\n\nWallet.prototype.url = function (extra) {\n  extra = extra || '';\n  return this.bitgo.url('/wallet/' + this.id() + extra);\n};\n\n//\n// pendingApprovals\n// returns the pending approvals list for this wallet as pending approval objects\n//\nWallet.prototype.pendingApprovals = function () {\n  const self = this;\n  return this.wallet.pendingApprovals.map(function (p) {\n    return new PendingApproval(self.bitgo, p, self);\n  });\n};\n\n//\n// approvalsRequired\n// returns the number of approvals required to approve pending approvals involving this wallet\n//\nWallet.prototype.approvalsRequired = function () {\n  return this.wallet.approvalsRequired || 1;\n};\n\n//\n// get\n// Refetches this wallet and returns it\n//\nWallet.prototype.get = function (params, callback): Bluebird<any> {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const self = this;\n\n  return Bluebird.resolve(\n    this.bitgo\n      .get(this.url())\n      .result()\n      .then(function (res) {\n        self.wallet = res;\n        return self;\n      })\n  ).nodeify(callback);\n};\n\n//\n// updateApprovalsRequired\n// Updates the number of approvals required on a pending approval involving this wallet.\n// The approvals required is by default 1, but this function allows you to update the\n// number such that 1 <= approvalsRequired <= walletAdmins.length - 1\n//\nWallet.prototype.updateApprovalsRequired = function (params, callback): Bluebird<any> {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n  if (\n    params.approvalsRequired === undefined ||\n    !_.isInteger(params.approvalsRequired) ||\n    params.approvalsRequired < 1\n  ) {\n    throw new Error('invalid approvalsRequired: must be a nonzero positive number');\n  }\n\n  const self = this;\n  const currentApprovalsRequired = this.approvalsRequired();\n  if (currentApprovalsRequired === params.approvalsRequired) {\n    // no-op, just return the current wallet\n    return Bluebird.try(function () {\n      return self.wallet;\n    }).nodeify(callback);\n  }\n\n  return Bluebird.resolve(this.bitgo.put(this.url()).send(params).result()).nodeify(callback);\n};\n\n/**\n * Returns the correct chain for change, taking into consideration segwit\n */\nWallet.prototype.getChangeChain = function (params) {\n  let useSegwitChange = !!this.bitgo.getConstants().enableSegwit;\n  if (!_.isUndefined(params.segwitChange)) {\n    if (!_.isBoolean(params.segwitChange)) {\n      throw new Error('segwitChange must be a boolean');\n    }\n\n    // if segwit is disabled through the constants, segwit change should still not be created\n    useSegwitChange = this.bitgo.getConstants().enableSegwit && params.segwitChange;\n  }\n  return useSegwitChange ? getInternalChainCode('p2shP2wsh') : getInternalChainCode('p2sh');\n};\n\n//\n// createAddress\n// Creates a new address for use with this wallet.\n//\nWallet.prototype.createAddress = function (params, callback) {\n  const self = this;\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n  if (this.type() === 'safe') {\n    throw new Error('You are using a legacy wallet that cannot create a new address');\n  }\n\n  // Default to client-side address validation on, for safety. Use validate=false to disable.\n  const shouldValidate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();\n\n  const allowExisting = params.allowExisting;\n  if (typeof allowExisting !== 'boolean') {\n    params.allowExisting = allowExisting === 'true';\n  }\n\n  const isSegwit = this.bitgo.getConstants().enableSegwit;\n  const defaultChain = isSegwit ? getExternalChainCode('p2shP2wsh') : getExternalChainCode('p2sh');\n\n  let chain = params.chain;\n  if (chain === null || chain === undefined) {\n    chain = defaultChain;\n  }\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.url('/address/' + chain))\n      .send(params)\n      .result()\n      .then(function (addr) {\n        if (shouldValidate) {\n          self.validateAddress(addr);\n        }\n        return addr;\n      })\n  ).nodeify(callback);\n};\n\n/**\n * Generate address locally without calling server\n * @param params\n *\n */\nWallet.prototype.generateAddress = function ({ segwit, path, keychains, threshold }) {\n  const isSegwit = !!segwit;\n  let signatureThreshold = 2;\n  if (_.isInteger(threshold)) {\n    signatureThreshold = threshold;\n    if (signatureThreshold <= 0) {\n      throw new Error('threshold has to be positive');\n    }\n  }\n\n  const pathRegex = /^\\/1?[01]\\/\\d+$/;\n  if (!path.match(pathRegex)) {\n    throw new Error('unsupported path: ' + path);\n  }\n\n  let rootKeys = this.keychains;\n  if (Array.isArray(keychains)) {\n    rootKeys = keychains;\n  }\n\n  const network = common.Environments[this.bitgo.getEnv()].network;\n\n  const derivedKeys = rootKeys.map(function (k) {\n    const hdnode = bip32.fromBase58(k.xpub);\n    const derivationPath = k.path + (k.walletSubPath || '') + path;\n    return hdnode.derivePath(sanitizeLegacyPath(derivationPath)).publicKey;\n  });\n\n  const pathComponents = path.split('/');\n  const normalizedPathComponents = _.map(pathComponents, (component) => {\n    if (component && component.length > 0) {\n      return parseInt(component, 10);\n    }\n  });\n  const pathDetails = _.filter(normalizedPathComponents, _.isInteger);\n\n  const addressDetails: any = {\n    chainPath: path,\n    path: path,\n    chain: pathDetails[0],\n    index: pathDetails[1],\n    wallet: this.id(),\n  };\n\n  const {\n    scriptPubKey: outputScript,\n    redeemScript,\n    witnessScript,\n  } = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys, isSegwit ? 'p2shP2wsh' : 'p2sh');\n\n  addressDetails.witnessScript = witnessScript?.toString('hex');\n  addressDetails.redeemScript = redeemScript?.toString('hex');\n  addressDetails.outputScript = outputScript.toString('hex');\n  addressDetails.address = utxolib.address.fromOutputScript(outputScript, getNetwork(network));\n\n  return addressDetails;\n};\n\n//\n// validateAddress\n// Validates an address and path by calculating it locally from the keychain xpubs\n//\nWallet.prototype.validateAddress = function (params) {\n  common.validateParams(params, ['address', 'path'], []);\n  const isSegwit = !!params.witnessScript && params.witnessScript.length > 0;\n\n  const generatedAddress = this.generateAddress({ path: params.path, segwit: isSegwit });\n  if (generatedAddress.address !== params.address) {\n    throw new Error('address validation failure: ' + params.address + ' vs. ' + generatedAddress.address);\n  }\n};\n\n//\n// addresses\n// Gets the addresses of a HD wallet.\n// Options include:\n//  limit: the number of addresses to get\n//\nWallet.prototype.addresses = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const query: any = {};\n  if (params.details) {\n    query.details = 1;\n  }\n\n  const chain = params.chain;\n  if (chain !== null && chain !== undefined) {\n    if (Array.isArray(chain)) {\n      query.chain = _.uniq(_.filter(chain, _.isInteger));\n    } else {\n      if (chain !== 0 && chain !== 1) {\n        throw new Error('invalid chain argument, expecting 0 or 1');\n      }\n      query.chain = chain;\n    }\n  }\n  if (params.limit) {\n    if (!_.isInteger(params.limit)) {\n      throw new Error('invalid limit argument, expecting number');\n    }\n    query.limit = params.limit;\n  }\n  if (params.skip) {\n    if (!_.isInteger(params.skip)) {\n      throw new Error('invalid skip argument, expecting number');\n    }\n    query.skip = params.skip;\n  }\n  if (params.sort) {\n    if (!_.isNumber(params.sort)) {\n      throw new Error('invalid sort argument, expecting number');\n    }\n    query.sort = params.sort;\n  }\n\n  const url = this.url('/addresses');\n  return Bluebird.resolve(this.bitgo.get(url).query(query).result()).nodeify(callback);\n};\n\nWallet.prototype.stats = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n  const args: string[] = [];\n  if (params.limit) {\n    if (!_.isInteger(params.limit)) {\n      throw new Error('invalid limit argument, expecting number');\n    }\n    args.push('limit=' + params.limit);\n  }\n  let query = '';\n  if (args.length) {\n    query = '?' + args.join('&');\n  }\n\n  const url = this.url('/stats' + query);\n\n  return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);\n};\n\n/**\n * Refresh the wallet object by syncing with the back-end\n * @param callback\n * @returns {Wallet}\n */\nWallet.prototype.refresh = function (params, callback) {\n  return co(function* () {\n    // when set to true, gpk returns the private data of safe wallets\n    const query = _.extend({}, _.pick(params, ['gpk']));\n    // @ts-expect-error - no implicit this\n    const res = yield this.bitgo.get(this.url()).query(query).result();\n    // @ts-expect-error - no implicit this\n    this.wallet = res;\n    // @ts-expect-error - no implicit this\n    return this;\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// address\n// Gets information about a single address on a HD wallet.\n// Information includes index, path, redeemScript, sent, received, txCount and balance\n// Options include:\n//  address: the address on this wallet to get\n//\nWallet.prototype.address = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], [], callback);\n\n  const url = this.url('/addresses/' + params.address);\n\n  return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);\n};\n\n/**\n * Freeze the wallet for a duration of choice, stopping BitGo from signing any transactions.\n * @param {number} limit The duration to freeze the wallet for in seconds, defaults to 3600.\n */\nWallet.prototype.freeze = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  if (params.duration) {\n    if (!_.isNumber(params.duration)) {\n      throw new Error('invalid duration - should be number of seconds');\n    }\n  }\n\n  return Bluebird.resolve(this.bitgo.post(this.url('/freeze')).send(params).result()).nodeify(callback);\n};\n\n//\n// delete\n// Deletes the wallet\n//\nWallet.prototype.delete = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.url()).result()).nodeify(callback);\n};\n\n//\n// labels\n// List the labels for the addresses in a given wallet\n//\nWallet.prototype.labels = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const url = this.bitgo.url('/labels/' + this.id());\n\n  return Bluebird.resolve(this.bitgo.get(url).result('labels')).nodeify(callback);\n};\n\n/**\n * Rename a wallet\n * @param params\n *  - label: the wallet's intended new name\n * @param callback\n * @returns {*}\n */\nWallet.prototype.setWalletName = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['label'], [], callback);\n\n  const url = this.bitgo.url('/wallet/' + this.id());\n  return Bluebird.resolve(this.bitgo.put(url).send({ label: params.label }).result()).nodeify(callback);\n};\n\n//\n// setLabel\n// Sets a label on the provided address\n//\nWallet.prototype.setLabel = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address', 'label'], [], callback);\n\n  const self = this;\n\n  if (!self.bitgo.verifyAddress({ address: params.address })) {\n    throw new Error('Invalid bitcoin address: ' + params.address);\n  }\n\n  const url = this.bitgo.url('/labels/' + this.id() + '/' + params.address);\n\n  return Bluebird.resolve(this.bitgo.put(url).send({ label: params.label }).result()).nodeify(callback);\n};\n\n//\n// deleteLabel\n// Deletes the label associated with the provided address\n//\nWallet.prototype.deleteLabel = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], [], callback);\n\n  const self = this;\n\n  if (!self.bitgo.verifyAddress({ address: params.address })) {\n    throw new Error('Invalid bitcoin address: ' + params.address);\n  }\n\n  const url = this.bitgo.url('/labels/' + this.id() + '/' + params.address);\n\n  return Bluebird.resolve(this.bitgo.del(url).result()).nodeify(callback);\n};\n\n//\n// unspents\n// List ALL the unspents for a given wallet\n// This method will return a paged list of all unspents\n//\n// Parameters include:\n//   limit:  the optional limit of unspents to collect in BTC\n//   minConf: only include results with this number of confirmations\n//   target: the amount of btc to find to spend\n//   instant: only find instant transactions (must specify a target)\n//\nWallet.prototype.unspents = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const allUnspents: any[] = [];\n  const self = this;\n\n  const getUnspentsBatch = function (skip, limit?) {\n    const queryObject = _.cloneDeep(params);\n    if (skip > 0) {\n      queryObject.skip = skip;\n    }\n    if (limit && limit > 0) {\n      queryObject.limit = limit;\n    }\n\n    return self.unspentsPaged(queryObject).then(function (result) {\n      // The API has its own limit handling. For example, the API does not support limits bigger than 500. If the limit\n      // specified here is bigger than that, we will have to do multiple requests with necessary limit adjustment.\n      for (let i = 0; i < result.unspents.length; i++) {\n        const unspent = result.unspents[i];\n        allUnspents.push(unspent);\n      }\n\n      // Our limit adjustment makes sure that we never fetch more unspents than we need, meaning that if we hit the\n      // limit, we hit it precisely\n      if (allUnspents.length >= params.limit) {\n        return allUnspents; // we aren't interested in any further unspents\n      }\n\n      const totalUnspentCount = result.total;\n      // if no target is specified and the SDK indicates that there has been a limit, we need to fetch another batch\n      if (!params.target && totalUnspentCount && totalUnspentCount > allUnspents.length) {\n        // we need to fetch the next batch\n        // let's just offset the current skip by the count\n        const newSkip = skip + result.count;\n        let newLimit: number | undefined;\n        if (limit > 0) {\n          // we set the new limit to be precisely the number of missing unspents to hit our own limit\n          newLimit = limit - allUnspents.length;\n        }\n        return getUnspentsBatch(newSkip, newLimit);\n      }\n\n      return allUnspents;\n    });\n  };\n\n  return getUnspentsBatch(0, params.limit).nodeify(callback);\n};\n\n/**\n * List the unspents (paged) for a given wallet, returning the result as an object of unspents, count, skip and total\n * This method may not return all the unspents as the list is paged by the API\n * @param params\n * @param params.limit the optional limit of unspents to collect in BTC\n * @param params.skip index in list of unspents to start paging from\n * @param params.minConfirms only include results with this number of confirmations\n * @param params.target the amount of btc to find to spend\n * @param params.instant only find instant transactions (must specify a target)\n * @param params.targetWalletUnspents desired number of unspents to have in the wallet after the tx goes through (requires target)\n * @param params.minSize minimum unspent size in satoshis\n * @param params.segwit request segwit unspents (defaults to true if undefined)\n * @param params.allowLedgerSegwit allow segwit unspents for ledger devices (defaults to false if undefined)\n * @param callback\n * @returns {*}\n */\nWallet.prototype.unspentsPaged = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  if (!_.isUndefined(params.limit) && !_.isInteger(params.limit)) {\n    throw new Error('invalid limit - should be number');\n  }\n  if (!_.isUndefined(params.skip) && !_.isInteger(params.skip)) {\n    throw new Error('invalid skip - should be number');\n  }\n  if (!_.isUndefined(params.minConfirms) && !_.isInteger(params.minConfirms)) {\n    throw new Error('invalid minConfirms - should be number');\n  }\n  if (!_.isUndefined(params.target) && !_.isNumber(params.target)) {\n    throw new Error('invalid target - should be number');\n  }\n  if (!_.isUndefined(params.instant) && !_.isBoolean(params.instant)) {\n    throw new Error('invalid instant flag - should be boolean');\n  }\n  if (!_.isUndefined(params.segwit) && !_.isBoolean(params.segwit)) {\n    throw new Error('invalid segwit flag - should be boolean');\n  }\n  if (!_.isUndefined(params.targetWalletUnspents) && !_.isInteger(params.targetWalletUnspents)) {\n    throw new Error('invalid targetWalletUnspents flag - should be number');\n  }\n  if (!_.isUndefined(params.minSize) && !_.isNumber(params.minSize)) {\n    throw new Error('invalid argument: minSize must be a number');\n  }\n  if (!_.isUndefined(params.instant) && !_.isUndefined(params.minConfirms)) {\n    throw new Error('only one of instant and minConfirms may be defined');\n  }\n  if (!_.isUndefined(params.targetWalletUnspents) && _.isUndefined(params.target)) {\n    throw new Error('targetWalletUnspents can only be specified in conjunction with a target');\n  }\n  if (!_.isUndefined(params.allowLedgerSegwit) && !_.isBoolean(params.allowLedgerSegwit)) {\n    throw new Error('invalid argument: allowLedgerSegwit must be a boolean');\n  }\n\n  const queryObject = _.cloneDeep(params);\n\n  if (!_.isUndefined(params.target)) {\n    // skip and limit are unavailable when a target is specified\n    delete queryObject.skip;\n    delete queryObject.limit;\n  }\n\n  queryObject.segwit = true;\n  if (!_.isUndefined(params.segwit)) {\n    queryObject.segwit = params.segwit;\n  }\n\n  if (!_.isUndefined(params.allowLedgerSegwit)) {\n    queryObject.allowLedgerSegwit = params.allowLedgerSegwit;\n  }\n\n  return Bluebird.resolve(this.bitgo.get(this.url('/unspents')).query(queryObject).result()).nodeify(callback);\n};\n\n//\n// transactions\n// List the transactions for a given wallet\n// Options include:\n//     TODO:  Add iterators for start/count/etc\nWallet.prototype.transactions = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  const args: string[] = [];\n  if (params.limit) {\n    if (!_.isInteger(params.limit)) {\n      throw new Error('invalid limit argument, expecting number');\n    }\n    args.push('limit=' + params.limit);\n  }\n  if (params.skip) {\n    if (!_.isInteger(params.skip)) {\n      throw new Error('invalid skip argument, expecting number');\n    }\n    args.push('skip=' + params.skip);\n  }\n  if (params.minHeight) {\n    if (!_.isInteger(params.minHeight)) {\n      throw new Error('invalid minHeight argument, expecting number');\n    }\n    args.push('minHeight=' + params.minHeight);\n  }\n  if (params.maxHeight) {\n    if (!_.isInteger(params.maxHeight) || params.maxHeight < 0) {\n      throw new Error('invalid maxHeight argument, expecting positive integer');\n    }\n    args.push('maxHeight=' + params.maxHeight);\n  }\n  if (params.minConfirms) {\n    if (!_.isInteger(params.minConfirms) || params.minConfirms < 0) {\n      throw new Error('invalid minConfirms argument, expecting positive integer');\n    }\n    args.push('minConfirms=' + params.minConfirms);\n  }\n  if (!_.isUndefined(params.compact)) {\n    if (!_.isBoolean(params.compact)) {\n      throw new Error('invalid compact argument, expecting boolean');\n    }\n    args.push('compact=' + params.compact);\n  }\n  let query = '';\n  if (args.length) {\n    query = '?' + args.join('&');\n  }\n\n  const url = this.url('/tx' + query);\n\n  return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);\n};\n\n//\n// transaction\n// Get a transaction by ID for a given wallet\nWallet.prototype.getTransaction = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  const url = this.url('/tx/' + params.id);\n\n  return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);\n};\n\n//\n// pollForTransaction\n// Poll a transaction until successful or times out\n// Parameters:\n//   id: the txid\n//   delay: delay between polls in ms (default: 1000)\n//   timeout: timeout in ms (default: 10000)\nWallet.prototype.pollForTransaction = function (params, callback) {\n  const self = this;\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n  if (params.delay && !_.isNumber(params.delay)) {\n    throw new Error('invalid delay parameter');\n  }\n  if (params.timeout && !_.isNumber(params.timeout)) {\n    throw new Error('invalid timeout parameter');\n  }\n  params.delay = params.delay || 1000;\n  params.timeout = params.timeout || 10000;\n\n  const start = new Date();\n\n  const doNextPoll = function () {\n    return self\n      .getTransaction(params)\n      .then(function (res) {\n        return res;\n      })\n      .catch(function (err) {\n        if (err.status !== 404 || new Date().valueOf() - start.valueOf() > params.timeout) {\n          throw err;\n        }\n        return Bluebird.delay(params.delay).then(function () {\n          return doNextPoll();\n        });\n      });\n  };\n\n  return doNextPoll();\n};\n\n//\n// transaction by sequence id\n// Get a transaction by sequence id for a given wallet\nWallet.prototype.getWalletTransactionBySequenceId = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['sequenceId'], [], callback);\n\n  const url = this.url('/tx/sequence/' + params.sequenceId);\n\n  return Bluebird.resolve(this.bitgo.get(url).result()).nodeify(callback);\n};\n\n//\n// Key chains\n// Gets the user key chain for this wallet\n// The user key chain is typically the first keychain of the wallet and has the encrypted xpriv stored on BitGo.\n// Useful when trying to get the users' keychain from the server before decrypting to sign a transaction.\nWallet.prototype.getEncryptedUserKeychain = function (params, callback) {\n  return co(function* () {\n    params = params || {};\n    common.validateParams(params, [], [], callback);\n    // @ts-expect-error - no implicit this\n    const self = this;\n\n    const tryKeyChain = co(function* (index) {\n      if (!self.keychains || index >= self.keychains.length) {\n        const error: any = new Error('No encrypted keychains on this wallet.');\n        error.code = 'no_encrypted_keychain_on_wallet';\n        throw error;\n      }\n\n      const params = { xpub: self.keychains[index].xpub };\n\n      const keychain = yield self.bitgo.keychains().get(params);\n      // If we find the xprv, then this is probably the user keychain we're looking for\n      keychain.walletSubPath = self.keychains[index].path;\n      if (keychain.encryptedXprv) {\n        return keychain;\n      }\n      return tryKeyChain(index + 1);\n    });\n\n    return tryKeyChain(0);\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// createTransaction\n// Create a transaction (unsigned). To sign it, do signTransaction\n// Parameters:\n//   recipients - object of recipient addresses and the amount to send to each e.g. {address:1500, address2:1500}\n//   fee      - the blockchain fee to send (optional)\n//   feeRate  - the fee per kb to send (optional)\n//   minConfirms - minimum number of confirms to use when gathering unspents\n//   forceChangeAtEnd - force change address to be last output (optional)\n//   noSplitChange - disable automatic change splitting for purposes of unspent management\n//   changeAddress - override the change address (optional)\n//   validate - extra verification of change addresses (which are always verified server-side) (defaults to global config)\n// Returns:\n//   callback(err, { transactionHex: string, unspents: [inputs], fee: satoshis })\nWallet.prototype.createTransaction = function (params, callback) {\n  params = _.extend({}, params);\n  common.validateParams(params, [], [], callback);\n\n  if (\n    (!_.isNumber(params.fee) && !_.isUndefined(params.fee)) ||\n    (!_.isNumber(params.feeRate) && !_.isUndefined(params.feeRate)) ||\n    (!_.isNumber(params.minConfirms) && !_.isUndefined(params.minConfirms)) ||\n    (!_.isBoolean(params.forceChangeAtEnd) && !_.isUndefined(params.forceChangeAtEnd)) ||\n    (!_.isString(params.changeAddress) && !_.isUndefined(params.changeAddress)) ||\n    (!_.isBoolean(params.validate) && !_.isUndefined(params.validate)) ||\n    (!_.isBoolean(params.instant) && !_.isUndefined(params.instant))\n  ) {\n    throw new Error('invalid argument');\n  }\n\n  if (!_.isObject(params.recipients)) {\n    throw new Error('expecting recipients object');\n  }\n\n  params.validate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();\n  params.wallet = this;\n\n  return TransactionBuilder.createTransaction(params).nodeify(callback);\n};\n\n//\n// signTransaction\n// Sign a previously created transaction with a keychain\n// Parameters:\n// transactionHex - serialized form of the transaction in hex\n// unspents - array of unspent information, where each unspent is a chainPath\n//            and redeemScript with the same index as the inputs in the\n//            transactionHex\n// keychain - Keychain containing the xprv to sign with.\n// signingKey - For legacy safe wallets, the private key string.\n// validate - extra verification of signatures (which are always verified server-side) (defaults to global config)\n// Returns:\n//   callback(err, transaction)\nWallet.prototype.signTransaction = function (params, callback) {\n  params = _.extend({}, params);\n  common.validateParams(params, ['transactionHex'], [], callback);\n\n  if (!Array.isArray(params.unspents)) {\n    throw new Error('expecting the unspents array');\n  }\n\n  if ((!_.isObject(params.keychain) || !params.keychain.xprv) && !_.isString(params.signingKey)) {\n    // allow passing in a WIF private key for legacy safe wallet support\n    const error: any = new Error('expecting keychain object with xprv or signingKey WIF');\n    error.code = 'missing_keychain_or_signingKey';\n    throw error;\n  }\n\n  params.validate = params.validate !== undefined ? params.validate : this.bitgo.getValidate();\n  params.bitgo = this.bitgo;\n  return TransactionBuilder.signTransaction(params)\n    .then(function (result) {\n      return {\n        tx: result.transactionHex,\n      };\n    })\n    .nodeify(callback);\n};\n\n//\n// send\n// Send a transaction to the Bitcoin network via BitGo.\n// One of the keys is typically signed, and BitGo will sign the other (if approved) and relay it to the P2P network.\n// Parameters:\n//   tx  - the hex encoded, signed transaction to send\n// Returns:\n//\nWallet.prototype.sendTransaction = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['tx'], ['message', 'otp'], callback);\n\n  return Bluebird.resolve(this.bitgo.post(this.bitgo.url('/tx/send')).send(params).result())\n    .then(function (body) {\n      if (body.pendingApproval) {\n        return _.extend(body, { status: 'pendingApproval' });\n      }\n\n      if (body.otp) {\n        return _.extend(body, { status: 'otp' });\n      }\n\n      return {\n        status: 'accepted',\n        tx: body.transaction,\n        hash: body.transactionHash,\n        instant: body.instant,\n        instantId: body.instantId,\n      };\n    })\n    .nodeify(callback);\n};\n\n/**\n * Share the wallet with an existing BitGo user.\n * @param {string} user The recipient's user id, must have a corresponding user record in our database.\n * @param {keychain} keychain The keychain to be shared with the recipient.\n * @param {string} permissions A comma-separated value string that specifies the recipient's permissions if the share is accepted.\n * @param {string} message The message to be used for this share.\n */\nWallet.prototype.createShare = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['user', 'permissions'], [], callback);\n\n  if (params.keychain && !_.isEmpty(params.keychain)) {\n    if (\n      !params.keychain.xpub ||\n      !params.keychain.encryptedXprv ||\n      !params.keychain.fromPubKey ||\n      !params.keychain.toPubKey ||\n      !params.keychain.path\n    ) {\n      throw new Error('requires keychain parameters - xpub, encryptedXprv, fromPubKey, toPubKey, path');\n    }\n  }\n\n  return Bluebird.resolve(this.bitgo.post(this.url('/share')).send(params).result()).nodeify(callback);\n};\n\n//\n// createInvite\n// invite a non BitGo customer to join a wallet\n// Parameters:\n//   email - the recipient's email address\n//   permissions - the recipient's permissions if the share is accepted\n// Returns:\n//\nWallet.prototype.createInvite = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['email', 'permissions'], ['message'], callback);\n\n  const options: any = {\n    toEmail: params.email,\n    permissions: params.permissions,\n  };\n\n  if (params.message) {\n    options.message = params.message;\n  }\n\n  return Bluebird.resolve(this.bitgo.post(this.url('/invite')).send(options).result()).nodeify(callback);\n};\n\n//\n// confirmInviteAndShareWallet\n// confirm my invite on this wallet to a recipient who has\n// subsequently signed up by creating the actual wallet share\n// Parameters:\n//   walletInviteId - the wallet invite id\n//   walletPassphrase - required if the wallet share success is expected\n// Returns:\n//\nWallet.prototype.confirmInviteAndShareWallet = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['walletInviteId'], ['walletPassphrase'], callback);\n\n  const self = this;\n  return this.bitgo\n    .wallets()\n    .listInvites()\n    .then(function (invites) {\n      const outgoing = invites.outgoing;\n      const invite = _.find(outgoing, function (out) {\n        return out.id === params.walletInviteId;\n      });\n      if (!invite) {\n        throw new Error('wallet invite not found');\n      }\n\n      const options = {\n        email: invite.toEmail,\n        permissions: invite.permissions,\n        message: invite.message,\n        walletPassphrase: params.walletPassphrase,\n      };\n\n      return self.shareWallet(options);\n    })\n    .then(function () {\n      // @ts-expect-error - no implicit this\n      return this.bitgo.put(this.bitgo.url('/walletinvite/' + params.walletInviteId));\n    })\n    .nodeify(callback);\n};\n\n//\n// sendCoins\n// Send coins to a destination address from this wallet using the user key.\n// 1. Gets the user keychain by checking the wallet for a key which has an encrypted xpriv\n// 2. Decrypts user key\n// 3. Creates the transaction with default fee\n// 4. Signs transaction with decrypted user key\n// 3. Sends the transaction to BitGo\n//\n// Parameters:\n//   address - the destination address\n//   amount - the amount in satoshis to be sent\n//   message - optional message to attach to transaction\n//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet\n//   xprv - the private key in string form, if walletPassphrase is not available\n//   (See transactionBuilder.createTransaction for other passthrough params)\n// Returns:\n//\nWallet.prototype.sendCoins = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['address'], ['message'], callback);\n\n  if (!_.isNumber(params.amount)) {\n    throw new Error('invalid argument for amount - number expected');\n  }\n\n  params.recipients = {};\n  params.recipients[params.address] = params.amount;\n\n  return this.sendMany(params).nodeify(callback);\n};\n\n//\n// sendMany\n// Send coins to multiple destination addresses from this wallet using the user key.\n// 1. Gets the user keychain by checking the wallet for a key which has an encrypted xpriv\n// 2. Decrypts user key\n// 3. Creates the transaction with default fee\n// 4. Signs transaction with decrypted user key\n// 3. Sends the transaction to BitGo\n//\n// Parameters:\n//   recipients - array of { address: string, amount: number, travelInfo: object } to send to\n//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet\n//   xprv - the private key in string form, if walletPassphrase is not available\n//   (See transactionBuilder.createTransaction for other passthrough params)\n// Returns:\n//\nWallet.prototype.sendMany = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], ['message', 'otp'], callback);\n  const self = this;\n\n  if (!_.isObject(params.recipients)) {\n    throw new Error('expecting recipients object');\n  }\n\n  if (params.fee && !_.isNumber(params.fee)) {\n    throw new Error('invalid argument for fee - number expected');\n  }\n\n  if (params.feeRate && !_.isNumber(params.feeRate)) {\n    throw new Error('invalid argument for feeRate - number expected');\n  }\n\n  if (params.instant && !_.isBoolean(params.instant)) {\n    throw new Error('invalid argument for instant - boolean expected');\n  }\n\n  let bitgoFee;\n  let travelInfos;\n  let finalResult;\n  let unspentsUsed;\n\n  const acceptedBuildParams = [\n    'numBlocks',\n    'feeRate',\n    'minConfirms',\n    'enforceMinConfirmsForChange',\n    'targetWalletUnspents',\n    'message',\n    'minValue',\n    'maxValue',\n    'noSplitChange',\n    'comment',\n  ];\n  const preservedBuildParams = _.pick(params, acceptedBuildParams);\n\n  // Get the user keychain\n  const retPromise = this.createAndSignTransaction(params)\n    .then(function (transaction) {\n      // Send the transaction\n      bitgoFee = transaction.bitgoFee;\n      travelInfos = transaction.travelInfos;\n      unspentsUsed = transaction.unspents;\n      return self.sendTransaction({\n        tx: transaction.tx,\n        message: params.message,\n        sequenceId: params.sequenceId,\n        instant: params.instant,\n        otp: params.otp,\n        // The below params are for logging only, and do not impact the API call\n        estimatedSize: transaction.estimatedSize,\n        buildParams: preservedBuildParams,\n      });\n    })\n    .then(function (result) {\n      const tx = utxolib.bitgo.createTransactionFromHex(result.tx, utxolib.networks.bitcoin);\n      const inputsSum = _.sumBy(unspentsUsed, 'value');\n      const outputsSum = _.sumBy(tx.outs, 'value');\n      const feeUsed = inputsSum - outputsSum;\n      if (isNaN(feeUsed)) {\n        throw new Error('invalid feeUsed');\n      }\n      (result.fee = feeUsed), (result.feeRate = (feeUsed * 1000) / tx.virtualSize());\n      result.travelInfos = travelInfos;\n      if (bitgoFee) {\n        result.bitgoFee = bitgoFee;\n      }\n      finalResult = result;\n\n      // Handle sending travel infos if they exist, but make sure we never fail here.\n      // Error or result (with possible sub-errors) will be provided in travelResult\n      if (travelInfos && travelInfos.length) {\n        try {\n          return self\n            .pollForTransaction({ id: result.hash })\n            .then(function () {\n              return self.bitgo.travelRule().sendMany(result);\n            })\n            .then(function (res) {\n              finalResult.travelResult = res;\n            })\n            .catch(function (err) {\n              // catch async errors\n              finalResult.travelResult = { error: err.message };\n            });\n        } catch (err) {\n          // catch synchronous errors\n          finalResult.travelResult = { error: err.message };\n        }\n      }\n    })\n    .then(function () {\n      return finalResult;\n    });\n  return Bluebird.resolve(retPromise).nodeify(callback);\n};\n\n/**\n * Accelerate a stuck transaction using Child-Pays-For-Parent (CPFP).\n *\n * This should only be used for stuck transactions which have no unconfirmed inputs.\n *\n * @param {Object} params - Input parameters\n * @param {String} params.transactionID - ID of transaction to accelerate\n * @param {Number} params.feeRate - New effective fee rate for stuck transaction (sat per 1000 bytes)\n * @param {Number} params.maxAdditionalUnspents - Maximum additional unspents to use from the wallet to cover any child fees that the parent unspent output cannot cover. Defaults to 100.\n * @param {String} params.walletPassphrase - The passphrase which should be used to decrypt the wallet private key. One of either walletPassphrase or xprv is required.\n * @param {String} params.xprv - The private key for the wallet. One of either walletPassphrase or xprv is required.\n * @param {Function} callback\n * @returns Result of sendTransaction() on the child transaction\n */\nWallet.prototype.accelerateTransaction = function accelerateTransaction(params, callback) {\n  const self = this;\n  /**\n   * Helper function to estimate a transactions size in virtual bytes.\n   * Actual transactions may be slightly fewer virtual bytes, due to\n   * the fact that valid ECSDA signatures have a variable length\n   * between 8 and 73 virtual bytes.\n   *\n   * @param inputs.segwit The number of segwit inputs to the transaction\n   * @param inputs.P2SH The number of P2SH inputs to the transaction\n   * @param inputs.P2PKH The number of P2PKH inputs to the transaction\n   */\n  const estimateTxVSize = (inputs) => {\n    const segwit = inputs.segwit || 0;\n    const P2SH = inputs.P2SH || 0;\n    const P2PKH = inputs.P2PKH || 0;\n\n    const childFeeInfo = TransactionBuilder.calculateMinerFeeInfo({\n      nP2shInputs: P2SH,\n      nP2pkhInputs: P2PKH,\n      nP2shP2wshInputs: segwit,\n      nOutputs: 1,\n      feeRate: 1,\n    });\n\n    return childFeeInfo.size;\n  };\n\n  /**\n   * Calculate the number of satoshis that should be paid in fees by the child transaction\n   *\n   * @param inputs Inputs to the child transaction which are passed to estimateTxVSize\n   * @param parentFee The number of satoshis the parent tx originally paid in fees\n   * @param parentVSize The number of virtual bytes in the parent tx\n   * @param feeRate The new fee rate which should be paid by the combined CPFP transaction\n   * @returns {number} The number of satoshis the child tx should pay in fees\n   */\n  const estimateChildFee = ({ inputs, parentFee, parentVSize, feeRate }) => {\n    // calculate how much more we *should* have paid in parent fees,\n    // had the parent been originally sent with the new fee rate\n    const additionalParentFee = _.ceil((parentVSize * feeRate) / 1000) - parentFee;\n\n    // calculate how much we would pay in fees for the child,\n    // if it were only paying for itself at the new fee rate\n    const childFee = (estimateTxVSize(inputs) * feeRate) / 1000;\n\n    return _.ceil(childFee + additionalParentFee);\n  };\n\n  /**\n   * Helper function to find additional unspents to use to pay the child tx fees.\n   * This function is called when the the parent tx output is not sufficient to\n   * cover the total fees which should be paid by the child tx.\n   *\n   * @param inputs Inputs to the child transaction which are passed to estimateTxVSize\n   * @param parentOutputValue The value of the output from the parent tx which we are using as an input to the child tx\n   * @param parentFee The number of satoshis the parent tx originally paid in fees\n   * @param parentVSize The number of virtual bytes in the parent tx\n   * @param maxUnspents The maximum number of additional unspents which should be used to cover the remaining child fees\n   * @returns An object with the additional unspents to use, the updated number of satoshis which should be paid by\n   *          the child tx, and the updated inputs for the child tx.\n   */\n  const findAdditionalUnspents = ({ inputs, parentOutputValue, parentFee, parentVSize, maxUnspents }) => {\n    return co(function* coFindAdditionalUnspents() {\n      const additionalUnspents: any[] = [];\n\n      // ask the server for enough unspents to cover the child fee, assuming\n      // that it can be done without additional unspents (which is not possible,\n      // since if that were the case, findAdditionalUnspents would not have been\n      // called in the first place. This will be corrected before returning)\n      let currentChildFeeEstimate = estimateChildFee({ inputs, parentFee, parentVSize, feeRate: params.feeRate });\n      let uncoveredChildFee = currentChildFeeEstimate - parentOutputValue;\n\n      while (uncoveredChildFee > 0 && additionalUnspents.length < maxUnspents) {\n        // try to get enough unspents to cover the rest of the child fee\n        // @ts-expect-error - no implicit this\n        const unspents = (yield this.unspents({\n          minConfirms: 1,\n          target: uncoveredChildFee,\n          limit: maxUnspents - additionalUnspents.length,\n        })) as any;\n\n        if (unspents.length === 0) {\n          // no more unspents are available\n          break;\n        }\n\n        let additionalUnspentValue = 0;\n\n        // consume all unspents returned by the server, even if we don't need\n        // all of them to cover the child fee. This is because the server will\n        // return enough unspent value to ensure that the minimum change amount\n        // is achieved for the child tx, and we can't leave out those unspents\n        // or else the minimum change amount constraint could be violated\n        _.forEach(unspents, (unspent) => {\n          // update the child tx inputs\n          const unspentChain = getChain(unspent);\n          if (isChainCode(unspentChain) && scriptTypeForChain(unspentChain) === 'p2shP2wsh') {\n            inputs.segwit++;\n          } else {\n            inputs.P2SH++;\n          }\n\n          additionalUnspents.push(unspent);\n          additionalUnspentValue += unspent.value;\n        });\n\n        currentChildFeeEstimate = estimateChildFee({ inputs, parentFee, parentVSize, feeRate: params.feeRate });\n        uncoveredChildFee = currentChildFeeEstimate - parentOutputValue - additionalUnspentValue;\n      }\n\n      if (uncoveredChildFee > 0) {\n        // Unable to find enough unspents to cover the child fee\n        throw new Error(`Insufficient confirmed unspents available to cover the child fee`);\n      }\n\n      // found enough unspents\n      return {\n        additional: additionalUnspents,\n        newChildFee: currentChildFeeEstimate,\n        newInputs: inputs,\n      };\n    }).call(this);\n  };\n\n  /**\n   * Helper function to get a full copy (including witness data) of an arbitrary tx using only the tx id.\n   *\n   * We have to use an external service for this (currently blockstream.info), since\n   * the v1 indexer service (based on bitcoinj) does not have segwit support and\n   * does not return any segwit related fields in the tx hex.\n   *\n   * @param parentTxId The ID of the transaction to get the full hex of\n   * @returns {Bluebird<any>} The full hex for the specified transaction\n   */\n  async function getParentTxHex({ parentTxId }: { parentTxId: string }): Promise<string> {\n    const explorerBaseUrl = common.Environments[self.bitgo.getEnv()].btcExplorerBaseUrl;\n    const result = await request.get(`${explorerBaseUrl}/tx/${parentTxId}/hex`);\n\n    if (!result.text || !/([a-f0-9]{2})+/.test(result.text)) {\n      throw new Error(\n        `Did not successfully receive parent tx hex. Received '${_.truncate(result.text, { length: 100 })}' instead.`\n      );\n    }\n\n    return result.text;\n  }\n\n  /**\n   * Helper function to get the chain from an unspent or tx output.\n   *\n   * @param outputOrUnspent The output or unspent whose chain should be determined\n   * @returns {number} The chain for the given output or unspent\n   */\n  const getChain = (outputOrUnspent) => {\n    if (outputOrUnspent.chain !== undefined) {\n      return outputOrUnspent.chain;\n    }\n\n    if (outputOrUnspent.chainPath !== undefined) {\n      return _.toNumber(outputOrUnspent.chainPath.split('/')[1]);\n    }\n\n    // no way to tell the chain, let's just blow up now instead\n    // of blowing up later when the undefined return value is used.\n    // Note: for unspents the field to use is 'address', but for outputs\n    // the field to use is 'account'\n    throw Error(`Could not get chain for output on account ${outputOrUnspent.account || outputOrUnspent.address}`);\n  };\n\n  /**\n   * Helper function to calculate the actual value contribution an output or unspent will\n   * contribute to a transaction, were it to be used. Each type of output or unspent\n   * will have a different value contribution since each type has a different number\n   * of virtual bytes, and thus will cause a different fee to be paid.\n   *\n   * @param outputOrUnspent Output or unspent whose effective value should be determined\n   * @returns {number} The actual number of satoshis that this unspent or output\n   *                   would contribute to a transaction, were it to be used.\n   */\n  const effectiveValue = (outputOrUnspent) => {\n    const chain = getChain(outputOrUnspent);\n    if (isChainCode(chain) && scriptTypeForChain(chain) === 'p2shP2wsh') {\n      // VirtualSizes.txP2shP2wshInputSize is in bytes, so we need to convert to kB\n      return outputOrUnspent.value - (VirtualSizes.txP2shP2wshInputSize * params.feeRate) / 1000;\n    }\n    // VirtualSizes.txP2shInputSize is in bytes, so we need to convert to kB\n    return outputOrUnspent.value - (VirtualSizes.txP2shInputSize * params.feeRate) / 1000;\n  };\n\n  /**\n   * Coroutine which actually implements the accelerateTransaction algorithm\n   *\n   * Described at a high level, the algorithm is as follows:\n   * 1) Find appropriate output from parent transaction to use as child transaction input\n   * 2) Find unspent corresponding to parent transaction output. If not found, return to step 1.\n   * 3) Determine if parent transaction unspent can cover entire child fee, plus minimum change\n   * 4) If yes, go to step 6\n   * 5) Otherwise, find additional unspents from the wallet to use to cover the remaining child fee\n   * 6) Create and sign the child transaction, using the parent transaction output\n   *    (and, if necessary, additional wallet unspents) as inputs\n   * 7) Broadcast the new child transaction\n   */\n  return co(function* coAccelerateTransaction(): any {\n    params = params || {};\n    common.validateParams(params, ['transactionID'], [], callback);\n\n    // validate fee rate\n    if (params.feeRate === undefined) {\n      throw new Error('Missing parameter: feeRate');\n    }\n    if (!_.isFinite(params.feeRate) || params.feeRate <= 0) {\n      throw new Error('Expecting positive finite number for parameter: feeRate');\n    }\n\n    // validate maxUnspents\n    if (params.maxAdditionalUnspents === undefined) {\n      // by default, use at most 100 additional unspents (not including the unspent output from the parent tx)\n      params.maxAdditionalUnspents = 100;\n    }\n\n    if (!_.isInteger(params.maxAdditionalUnspents) || params.maxAdditionalUnspents <= 0) {\n      throw Error('Expecting positive integer for parameter: maxAdditionalUnspents');\n    }\n\n    // @ts-expect-error - no implicit this\n    const parentTx = yield this.getTransaction({ id: params.transactionID });\n    if (parentTx.confirmations > 0) {\n      throw new Error(`Transaction ${params.transactionID} is already confirmed and cannot be accelerated`);\n    }\n\n    // get the outputs from the parent tx which are to our wallet\n    const walletOutputs = _.filter(parentTx.outputs, (output) => output.isMine);\n\n    if (walletOutputs.length === 0) {\n      throw new Error(\n        `Transaction ${params.transactionID} contains no outputs to this wallet, and thus cannot be accelerated`\n      );\n    }\n\n    // use an output from the parent with largest effective value,\n    // but check to make sure the output is actually unspent.\n    // An output could be spent already if the output was used in a\n    // child tx which itself has become stuck due to low fees and is\n    // also unconfirmed.\n    const sortedOutputs = _.sortBy(walletOutputs, effectiveValue);\n    let parentUnspentToUse;\n    let outputToUse;\n\n    while (sortedOutputs.length > 0 && parentUnspentToUse === undefined) {\n      outputToUse = sortedOutputs.pop();\n\n      // find the unspent corresponding to this particular output\n      // TODO: is there a better way to get this unspent?\n      // TODO: The best we can do here is set minSize = maxSize = outputToUse.value\n      // @ts-expect-error - no implicit this\n      const unspentsResult = yield this.unspents({\n        minSize: outputToUse.value,\n        maxSize: outputToUse.value,\n      });\n\n      parentUnspentToUse = _.find(unspentsResult, (unspent) => {\n        // make sure unspent belongs to the given txid\n        if (unspent.tx_hash !== params.transactionID) {\n          return false;\n        }\n        // make sure unspent has correct v_out index\n        return unspent.tx_output_n === outputToUse.vout;\n      });\n    }\n\n    if (parentUnspentToUse === undefined) {\n      throw new Error(`Could not find unspent output from parent tx to use as child input`);\n    }\n\n    // get the full hex for the parent tx and decode it to get its vsize\n    const parentTxHex = yield getParentTxHex({ parentTxId: params.transactionID });\n    const decodedParent = utxolib.bitgo.createTransactionFromHex(parentTxHex, utxolib.networks.bitcoin);\n    const parentVSize = decodedParent.virtualSize();\n\n    // make sure id from decoded tx and given tx id match\n    // this should catch problems emanating from the use of an external service\n    // for getting the complete parent tx hex\n    if (decodedParent.getId() !== params.transactionID) {\n      throw new Error(\n        `Decoded transaction id is ${decodedParent.getId()}, which does not match given txid ${params.transactionID}`\n      );\n    }\n\n    // make sure new fee rate is greater than the parent's current fee rate\n    // virtualSize is returned in vbytes, so we need to convert to kvB\n    const parentRate = (1000 * parentTx.fee) / parentVSize;\n    if (params.feeRate <= parentRate) {\n      throw new Error(\n        `Cannot lower fee rate! (Parent tx fee rate is ${parentRate} sat/kB, and requested fee rate was ${params.feeRate} sat/kB)`\n      );\n    }\n\n    // determine if parent output can cover child fee\n    const isParentOutputSegwit =\n      isChainCode(outputToUse.chain) && scriptTypeForChain(outputToUse.chain) === 'p2shP2wsh';\n\n    let childInputs = {\n      segwit: isParentOutputSegwit ? 1 : 0,\n      P2SH: isParentOutputSegwit ? 0 : 1,\n    };\n\n    let childFee = estimateChildFee({\n      inputs: childInputs,\n      parentFee: parentTx.fee,\n      feeRate: params.feeRate,\n      parentVSize,\n    });\n\n    const unspentsToUse = [parentUnspentToUse];\n\n    // try to get the min change size from the server, otherwise default to 0.1 BTC\n    // TODO: minChangeSize is not currently a constant defined on the client and should be added\n    // @ts-expect-error - no implicit this\n    const minChangeSize = this.bitgo.getConstants().minChangeSize || 1e7;\n\n    if (outputToUse.value < childFee + minChangeSize) {\n      // parent output cannot cover child fee plus the minimum change,\n      // must find additional unspents to cover the difference\n      const { additional, newChildFee, newInputs } = yield findAdditionalUnspents({\n        inputs: childInputs,\n        parentOutputValue: outputToUse.value,\n        parentFee: parentTx.fee,\n        maxUnspents: params.maxAdditionalUnspents,\n        parentVSize,\n      });\n      childFee = newChildFee;\n      childInputs = newInputs;\n      unspentsToUse.push(...additional);\n    }\n\n    // sanity check the fee rate we're paying for the combined tx\n    // to make sure it's under the max fee rate. Only the child tx\n    // can break this limit, but the combined tx shall not\n    // @ts-expect-error - no implicit this\n    const maxFeeRate = this.bitgo.getConstants().maxFeeRate;\n    const childVSize = estimateTxVSize(childInputs);\n    const combinedVSize = childVSize + parentVSize;\n    const combinedFee = parentTx.fee + childFee;\n    // combined fee rate must be in sat/kB, so we need to convert\n    const combinedFeeRate = (1000 * combinedFee) / combinedVSize;\n\n    if (combinedFeeRate > maxFeeRate) {\n      throw new Error(\n        `Transaction cannot be accelerated. Combined fee rate of ${combinedFeeRate} sat/kB exceeds maximum fee rate of ${maxFeeRate} sat/kB`\n      );\n    }\n\n    // create a new change address and determine change amount.\n    // the tx builder will reject transactions which have no recipients,\n    // and such zero-output transactions are forbidden by the Bitcoin protocol,\n    // so we need at least a single recipient for the change which won't be pruned.\n    const changeAmount = _.sumBy(unspentsToUse, (unspent) => unspent.value) - childFee;\n    // @ts-expect-error - no implicit this\n    const changeChain = this.getChangeChain({});\n    // @ts-expect-error - no implicit this\n    const changeAddress = yield this.createAddress({ chain: changeChain });\n\n    // create the child tx and broadcast\n    // @ts-expect-error - no implicit this\n    const tx = yield this.createAndSignTransaction({\n      unspents: unspentsToUse,\n      recipients: [\n        {\n          address: changeAddress.address,\n          amount: changeAmount,\n        },\n      ],\n      fee: childFee,\n      bitgoFee: {\n        amount: 0,\n        address: '',\n      },\n      xprv: params.xprv,\n      walletPassphrase: params.walletPassphrase,\n    });\n\n    // child fee rate must be in sat/kB, so we need to convert\n    const childFeeRate = (1000 * childFee) / childVSize;\n    if (childFeeRate > maxFeeRate) {\n      // combined tx is within max fee rate limits, but the child tx is not.\n      // in this case, we need to use the ignoreMaxFeeRate flag to get the child tx to be accepted\n      tx.ignoreMaxFeeRate = true;\n    }\n\n    // @ts-expect-error - no implicit this\n    return this.sendTransaction(tx);\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// createAndSignTransaction\n// INTERNAL function to create and sign a transaction\n//\n// Parameters:\n//   recipients - array of { address, amount } to send to\n//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet\n//   (See transactionBuilder.createTransaction for other passthrough params)\n// Returns:\n//\nWallet.prototype.createAndSignTransaction = function (params, callback) {\n  return co(function* () {\n    params = params || {};\n    common.validateParams(params, [], [], callback);\n\n    if (!_.isObject(params.recipients)) {\n      throw new Error('expecting recipients object');\n    }\n\n    if (params.fee && !_.isNumber(params.fee)) {\n      throw new Error('invalid argument for fee - number expected');\n    }\n\n    if (params.feeRate && !_.isNumber(params.feeRate)) {\n      throw new Error('invalid argument for feeRate - number expected');\n    }\n\n    if (params.dynamicFeeConfirmTarget && !_.isNumber(params.dynamicFeeConfirmTarget)) {\n      throw new Error('invalid argument for confirmTarget - number expected');\n    }\n\n    if (params.instant && !_.isBoolean(params.instant)) {\n      throw new Error('invalid argument for instant - boolean expected');\n    }\n\n    // @ts-expect-error - no implicit this\n    const transaction = (yield this.createTransaction(params)) as any;\n    const fee = transaction.fee;\n    const feeRate = transaction.feeRate;\n    const estimatedSize = transaction.estimatedSize;\n    const bitgoFee = transaction.bitgoFee;\n    const travelInfos = transaction.travelInfos;\n    const unspents = transaction.unspents;\n\n    // Sign the transaction\n    try {\n      // @ts-expect-error - no implicit this\n      const keychain = yield this.getAndPrepareSigningKeychain(params);\n      transaction.keychain = keychain;\n    } catch (e) {\n      if (e.code !== 'no_encrypted_keychain_on_wallet') {\n        throw e;\n      }\n      // this might be a safe wallet, so let's retrieve the private key info\n      // @ts-expect-error - no implicit this\n      yield this.refresh({ gpk: true });\n      // @ts-expect-error - no implicit this\n      const safeUserKey = _.get(this.wallet, 'private.userPrivKey');\n      if (_.isString(safeUserKey) && _.isString(params.walletPassphrase)) {\n        // @ts-expect-error - no implicit this\n        transaction.signingKey = this.bitgo.decrypt({ password: params.walletPassphrase, input: safeUserKey });\n      } else {\n        throw e;\n      }\n    }\n\n    transaction.feeSingleKeyWIF = params.feeSingleKeyWIF;\n    // @ts-expect-error - no implicit this\n    const result = yield this.signTransaction(transaction);\n    return _.extend(result, {\n      fee,\n      feeRate,\n      instant: params.instant,\n      bitgoFee,\n      travelInfos,\n      estimatedSize,\n      unspents,\n    });\n  })\n    .call(this)\n    .asCallback(callback);\n};\n\n//\n// getAndPrepareSigningKeychain\n// INTERNAL function to get the user keychain for signing.\n// Caller must provider either a keychain, or walletPassphrase or xprv as a string\n// If the caller provides the keychain with xprv, it is simply returned.\n// If the caller provides the encrypted xprv (walletPassphrase), then fetch the keychain object and decrypt\n// Otherwise if the xprv is provided, fetch the keychain object and augment it with the xprv.\n//\n// Parameters:\n//   keychain - keychain with xprv\n//   xprv - the private key in string form\n//   walletPassphrase - the passphrase to be used to decrypt the user key on this wallet\n// Returns:\n//   Keychain object containing xprv, xpub and paths\n//\nWallet.prototype.getAndPrepareSigningKeychain = function (params, callback) {\n  params = params || {};\n\n  // If keychain with xprv is already provided, use it\n  if (_.isObject(params.keychain) && params.keychain.xprv) {\n    return Bluebird.resolve(params.keychain);\n  }\n\n  common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);\n\n  if ((params.walletPassphrase && params.xprv) || (!params.walletPassphrase && !params.xprv)) {\n    throw new Error('must provide exactly one of xprv or walletPassphrase');\n  }\n\n  const self = this;\n\n  // Caller provided a wallet passphrase\n  if (params.walletPassphrase) {\n    return self.getEncryptedUserKeychain().then(function (keychain) {\n      // Decrypt the user key with a passphrase\n      try {\n        keychain.xprv = self.bitgo.decrypt({ password: params.walletPassphrase, input: keychain.encryptedXprv });\n      } catch (e) {\n        throw new Error('Unable to decrypt user keychain');\n      }\n      return keychain;\n    });\n  }\n\n  // Caller provided an xprv - validate and construct keychain object\n  let xpub;\n  try {\n    xpub = bip32.fromBase58(params.xprv).neutered().toBase58();\n  } catch (e) {\n    throw new Error('Unable to parse the xprv');\n  }\n\n  if (xpub === params.xprv) {\n    throw new Error('xprv provided was not a private key (found xpub instead)');\n  }\n\n  const walletXpubs = _.map(self.keychains, 'xpub');\n  if (!_.includes(walletXpubs, xpub)) {\n    throw new Error('xprv provided was not a keychain on this wallet!');\n  }\n\n  // get the keychain object from bitgo to find the path and (potential) wallet structure\n  return self.bitgo\n    .keychains()\n    .get({ xpub: xpub })\n    .then(function (keychain) {\n      keychain.xprv = params.xprv;\n      return keychain;\n    });\n};\n\n/**\n * Takes a wallet's unspents and fans them out into a larger number of equally sized unspents\n * @param params\n *  target: set how many unspents you want to have in the end\n *  minConfirms: minimum number of confirms the unspents must have\n *  xprv: private key to sign transaction\n *  walletPassphrase: wallet passphrase to decrypt the wallet's private key\n * @param callback\n * @returns {*}\n */\nWallet.prototype.fanOutUnspents = function (params, callback) {\n  const self = this;\n  return Bluebird.coroutine(function* () {\n    // maximum number of inputs for fanout transaction\n    // (when fanning out, we take all the unspents and make a bigger number of outputs)\n    const MAX_FANOUT_INPUT_COUNT = 80;\n    // maximum number of outputs for fanout transaction\n    const MAX_FANOUT_OUTPUT_COUNT = 300;\n    params = params || {};\n    common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);\n    const validate = params.validate === undefined ? true : params.validate;\n\n    const target = params.target;\n    // the target must be defined, be a number, be at least two, and be a natural number\n    if (!_.isNumber(target) || target < 2 || target % 1 !== 0) {\n      throw new Error('Target needs to be a positive integer');\n    }\n    if (target > MAX_FANOUT_OUTPUT_COUNT) {\n      throw new Error('Fan out target too high');\n    }\n\n    let minConfirms = params.minConfirms;\n    if (minConfirms === undefined) {\n      minConfirms = 1;\n    }\n    if (!_.isNumber(minConfirms) || minConfirms < 0) {\n      throw new Error('minConfirms needs to be an integer >= 0');\n    }\n\n    /**\n     * Split a natural number N into n almost equally sized (±1) natural numbers.\n     * In order to calculate the sizes of the parts, we calculate floor(N/n), and thus have the base size of all parts.\n     * If N % n !== 0, this leaves us with a remainder r where r < n. We distribute r equally among the n parts by\n     * adding 1 to the first r parts.\n     * @param total\n     * @param partCount\n     * @returns {Array}\n     */\n    const splitNumberIntoCloseNaturalNumbers = function (total, partCount) {\n      const partSize = Math.floor(total / partCount);\n      const remainder = total - partSize * partCount;\n      // initialize placeholder array\n      const almostEqualParts = new Array(partCount);\n      // fill the first remainder parts with the value partSize+1\n      _.fill(almostEqualParts, partSize + 1, 0, remainder);\n      // fill the remaining parts with the value partSize\n      _.fill(almostEqualParts, partSize, remainder);\n      // assert the correctness of the almost equal parts\n      // TODO: add check for the biggest deviation between any two parts and make sure it's <= 1\n      if (_(almostEqualParts).sum() !== total || _(almostEqualParts).size() !== partCount) {\n        throw new Error('part sum or part count mismatch');\n      }\n      return almostEqualParts;\n    };\n\n    // first, let's take all the wallet's unspents (with min confirms if necessary)\n    const allUnspents = (yield self.unspents({ minConfirms: minConfirms })) as any;\n    if (allUnspents.length < 1) {\n      throw new Error('No unspents to branch out');\n    }\n\n    // this consolidation is essentially just a waste of money\n    if (allUnspents.length >= target) {\n      throw new Error('Fan out target has to be bigger than current number of unspents');\n    }\n\n    // we have at the very minimum 81 inputs, and 81 outputs. That transaction will be big\n    // in the medium run, this algorithm could be reworked to only work with a subset of the transactions\n    if (allUnspents.length > MAX_FANOUT_INPUT_COUNT) {\n      throw new Error('Too many unspents');\n    }\n\n    // this is all the money that is currently in the wallet\n    const grossAmount = _(allUnspents).map('value').sum();\n\n    // in order to not modify the params object, we create a copy\n    const txParams = _.extend({}, params);\n    txParams.unspents = allUnspents;\n    txParams.recipients = {};\n\n    // create target amount of new addresses for this wallet\n    const newAddressPromises = _.range(target).map(() =>\n      self.createAddress({ chain: self.getChangeChain(params), validate: validate })\n    );\n    const newAddresses = yield Bluebird.all(newAddressPromises);\n    // let's find a nice, equal distribution of our Satoshis among the new addresses\n    const splitAmounts = splitNumberIntoCloseNaturalNumbers(grossAmount, target);\n    // map the newly created addresses to the almost components amounts we just calculated\n    txParams.recipients = _.zipObject(_.map(newAddresses, 'address'), splitAmounts);\n    txParams.noSplitChange = true;\n    // attempt to create a transaction. As it is a wallet-sweeping transaction with no fee, we expect it to fail\n    try {\n      yield self.sendMany(txParams);\n    } catch (error) {\n      // as expected, the transaction creation did indeed fail due to insufficient fees\n      // the error suggests a fee value which we then use for the transaction\n      // however, let's make sure it wasn't something else\n      if (!error.fee && (!error.result || !error.result.fee)) {\n        // if the error does not contain a fee property, it is something else that has gone awry, and we throw it\n        const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);\n        error.message += `\\n\\nTX PARAMS:\\n ${JSON.stringify(debugParams, null, 4)}`;\n        throw error;\n      }\n      const baseFee = error.fee || error.result.fee;\n      let totalFee = baseFee;\n      if (error.result.bitgoFee && error.result.bitgoFee.amount) {\n        totalFee += error.result.bitgoFee.amount;\n        txParams.bitgoFee = error.result.bitgoFee;\n      }\n\n      // Need to clear these out since only 1 may be set\n      delete txParams.fee;\n      txParams.originalFeeRate = txParams.feeRate;\n      delete txParams.feeRate;\n      delete txParams.feeTxConfirmTarget;\n      txParams.fee = baseFee;\n      // in order to maintain the equal distribution, we need to subtract the fee from the cumulative funds\n      // in case some unspents got pruned, we need to use error.result.available\n      const netAmount = error.result.available - totalFee; // after fees\n      // that means that the distribution has to be recalculated\n      const remainingSplitAmounts = splitNumberIntoCloseNaturalNumbers(netAmount, target);\n      // and the distribution again mapped to the new addresses\n      txParams.recipients = _.zipObject(_.map(newAddresses, 'address'), remainingSplitAmounts);\n    }\n\n    // this time, the transaction creation should work\n    let fanoutTx;\n    try {\n      fanoutTx = yield self.sendMany(txParams);\n    } catch (e) {\n      const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);\n      e.message += `\\n\\nTX PARAMS:\\n ${JSON.stringify(debugParams, null, 4)}`;\n      throw e;\n    }\n\n    return Bluebird.resolve(fanoutTx).asCallback(callback);\n  })().asCallback(callback);\n};\n\n/**\n * Determine whether to fan out or coalesce a wallet's unspents\n * @param params\n * @param callback\n * @returns {Request|Promise.<T>|*}\n */\nWallet.prototype.regroupUnspents = function (params, callback) {\n  params = params || {};\n  const target = params.target;\n  if (!_.isNumber(target) || target < 1 || target % 1 !== 0) {\n    // the target must be defined, be a number, be at least one, and be a natural number\n    throw new Error('Target needs to be a positive integer');\n  }\n\n  let minConfirms = params.minConfirms;\n  if (minConfirms === undefined) {\n    minConfirms = 1;\n  }\n  if (!_.isNumber(minConfirms) || minConfirms < 0) {\n    throw new Error('minConfirms needs to be an integer equal to or bigger than 0');\n  }\n\n  const self = this;\n  return self.unspents({ minConfirms: minConfirms }).then(function (unspents) {\n    if (unspents.length === target) {\n      return unspents;\n    } else if (unspents.length > target) {\n      return self.consolidateUnspents(params, callback);\n    } else if (unspents.length < target) {\n      return self.fanOutUnspents(params, callback);\n    }\n  });\n};\n\n/**\n * Consolidate a wallet's unspents into fewer unspents\n * @param params\n *  target: set how many unspents you want to have in the end\n *  maxInputCountPerConsolidation: set how many maximum inputs are to be permitted per consolidation batch\n *  xprv: private key to sign transaction\n *  walletPassphrase: wallet passphrase to decrypt the wallet's private key\n *  maxIterationCount: maximum number of iterations to be performed until function stops\n *  progressCallback: method to be called with object outlining current progress details\n * @param callback\n * @returns {*}\n */\nWallet.prototype.consolidateUnspents = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], ['walletPassphrase', 'xprv'], callback);\n  const validate = params.validate === undefined ? true : params.validate;\n\n  let target = params.target;\n  if (target === undefined) {\n    target = 1;\n  } else if (!_.isNumber(target) || target < 1 || target % 1 !== 0) {\n    // the target must be defined, be a number, be at least one, and be a natural number\n    throw new Error('Target needs to be a positive integer');\n  }\n\n  if (params.maxSize && !_.isNumber(params.maxSize)) {\n    throw new Error('maxSize should be a number');\n  }\n\n  if (params.minSize && !_.isNumber(params.minSize)) {\n    throw new Error('minSize should be a number');\n  }\n\n  // maximum number of inputs per transaction for consolidation\n  const MAX_INPUT_COUNT = 200;\n  let maxInputCount = params.maxInputCountPerConsolidation;\n  if (maxInputCount === undefined) {\n    // null or unidentified, because equality to zero returns true in if(! clause\n    maxInputCount = MAX_INPUT_COUNT;\n  }\n  if (typeof maxInputCount !== 'number' || maxInputCount < 2 || maxInputCount % 1 !== 0) {\n    throw new Error('Maximum consolidation input count needs to be an integer equal to or bigger than 2');\n  } else if (maxInputCount > MAX_INPUT_COUNT) {\n    throw new Error('Maximum consolidation input count cannot be bigger than ' + MAX_INPUT_COUNT);\n  }\n\n  const maxIterationCount = params.maxIterationCount || -1;\n  if (\n    (params.maxIterationCount && (!_.isNumber(maxIterationCount) || maxIterationCount < 1)) ||\n    maxIterationCount % 1 !== 0\n  ) {\n    throw new Error('Maximum iteration count needs to be an integer equal to or bigger than 1');\n  }\n\n  let minConfirms = params.minConfirms;\n  if (minConfirms === undefined) {\n    minConfirms = 1;\n  }\n  if (!_.isNumber(minConfirms) || minConfirms < 0) {\n    throw new Error('minConfirms needs to be an integer equal to or bigger than 0');\n  }\n\n  let minSize = params.minSize || 0;\n  if (params.feeRate) {\n    // fee rate is in satoshis per kB, input size in bytes\n    const feeBasedMinSize = Math.ceil((VirtualSizes.txP2shInputSize * params.feeRate) / 1000);\n    if (params.minSize && minSize < feeBasedMinSize) {\n      throw new Error('provided minSize too low due to too high fee rate');\n    }\n    minSize = Math.max(feeBasedMinSize, minSize);\n\n    if (!params.minSize) {\n      // fee rate-based min size needs no logging if it was set explicitly\n      console.log(\n        'Only consolidating unspents larger than ' +\n          minSize +\n          ' satoshis to avoid wasting money on fees. To consolidate smaller unspents, use a lower fee rate.'\n      );\n    }\n  }\n\n  let iterationCount = 0;\n\n  const self = this;\n  let consolidationIndex = 0;\n\n  /**\n   * Consolidate one batch of up to MAX_INPUT_COUNT unspents.\n   * @returns {*}\n   */\n  const runNextConsolidation = co(function* () {\n    const consolidationTransactions: any[] = [];\n    let isFinalConsolidation = false;\n    iterationCount++;\n    /*\n     We take a maximum of unspentBulkSizeLimit unspents from the wallet. We want to make sure that we swipe the wallet\n     clean of all excessive unspents, so we add 1 to the target unspent count to make sure we haven't missed anything.\n     In case there are even more unspents than that, to make the consolidation as fast as possible, we expand our\n     selection to include as many as the maximum permissible number of inputs per consolidation batch.\n     Should the target number of unspents be higher than the maximum number if inputs per consolidation,\n     we still want to fetch them all simply to be able to determine whether or not a consolidation can be performed\n     at all, which is dependent on the number of all unspents being higher than the target.\n     In the next version of the unspents version SDK, we will know the total number of unspents without having to fetch\n     them, and therefore will be able to simplify this method.\n     */\n\n    const queryParams: any = {\n      limit: target + maxInputCount,\n      minConfirms: minConfirms,\n      minSize: minSize,\n    };\n    if (params.maxSize) {\n      queryParams.maxSize = params.maxSize;\n    }\n    const allUnspents = (yield self.unspents(queryParams)) as any;\n    // this consolidation is essentially just a waste of money\n    if (allUnspents.length <= target) {\n      if (iterationCount <= 1) {\n        // this is the first iteration, so the method is incorrect\n        throw new Error('Fewer unspents than consolidation target. Use fanOutUnspents instead.');\n      } else {\n        // it's a later iteration, so the target may have been surpassed (due to confirmations in the background)\n        throw new Error('Done');\n      }\n    }\n\n    const allUnspentsCount = allUnspents.length;\n\n    // how many of the unspents do we want to consolidate?\n    // the +1 is because the consolidated block becomes a new unspent later\n    let targetInputCount = allUnspentsCount - target + 1;\n    targetInputCount = Math.min(targetInputCount, allUnspents.length);\n\n    // if the targetInputCount requires more inputs than we allow per batch, we reduce the number\n    const inputCount = Math.min(targetInputCount, maxInputCount);\n\n    // if either the number of inputs left to coalesce equals the number we will coalesce in this iteration\n    // or if the number of iterations matches the maximum permitted number\n    isFinalConsolidation = inputCount === targetInputCount || iterationCount === maxIterationCount;\n\n    const currentChunk = allUnspents.splice(0, inputCount);\n    const changeChain = self.getChangeChain(params);\n    const newAddress = (yield self.createAddress({ chain: changeChain, validate: validate })) as any;\n    const txParams = _.extend({}, params);\n    const currentAddress = newAddress;\n    // the total amount that we are consolidating within this batch\n    const grossAmount = _(currentChunk).map('value').sum(); // before fees\n\n    txParams.unspents = currentChunk;\n    txParams.recipients = {};\n    txParams.recipients[newAddress.address] = grossAmount;\n    txParams.noSplitChange = true;\n\n    if (txParams.unspents.length <= 1) {\n      throw new Error('Done');\n    }\n\n    // let's attempt to create this transaction. We expect it to fail because no fee is set.\n    try {\n      yield self.sendMany(txParams);\n    } catch (error) {\n      // this error should occur due to insufficient funds\n      // however, let's make sure it wasn't something else\n      if (!error.fee && (!error.result || !error.result.fee)) {\n        // if the error does not contain a fee property, it is something else that has gone awry, and we throw it\n        const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);\n        error.message += `\\n\\nTX PARAMS:\\n ${JSON.stringify(debugParams, null, 4)}`;\n        throw error;\n      }\n      const baseFee = error.fee || error.result.fee;\n      let bitgoFee = 0;\n      let totalFee = baseFee;\n      if (error.result.bitgoFee && error.result.bitgoFee.amount) {\n        bitgoFee = error.result.bitgoFee.amount;\n        totalFee += bitgoFee;\n        txParams.bitgoFee = error.result.bitgoFee;\n      }\n\n      // if the net amount is negative, it should be replaced with the minimum output size\n      const netAmount = Math.max(error.result.available - totalFee, self.bitgo.getConstants().minOutputSize);\n      // Need to clear these out since only 1 may be set\n      delete txParams.fee;\n      txParams.originalFeeRate = txParams.feeRate;\n      delete txParams.feeRate;\n      delete txParams.feeTxConfirmTarget;\n\n      // we set the fee explicitly\n      txParams.fee = error.result.available - netAmount - bitgoFee;\n      txParams.recipients[newAddress.address] = netAmount;\n    }\n    // this transaction, on the other hand, should be created with no issues, because an appropriate fee is set\n    let sentTx;\n    try {\n      sentTx = yield self.sendMany(txParams);\n    } catch (e) {\n      const debugParams = _.omit(txParams, ['walletPassphrase', 'xprv']);\n      e.message += `\\n\\nTX PARAMS:\\n ${JSON.stringify(debugParams, null, 4)}`;\n      throw e;\n    }\n    consolidationTransactions.push(sentTx);\n    if (_.isFunction(params.progressCallback)) {\n      params.progressCallback({\n        txid: sentTx.hash,\n        destination: currentAddress,\n        amount: grossAmount,\n        fee: sentTx.fee,\n        inputCount: inputCount,\n        index: consolidationIndex,\n      });\n    }\n    consolidationIndex++;\n    if (!isFinalConsolidation) {\n      // this last consolidation has not yet brought the unspents count down to the target unspent count\n      // therefore, we proceed by consolidating yet another batch\n      // before we do that, we wait 1 second so that the newly created unspent will be fetched in the next batch\n      yield Bluebird.delay(1000);\n      consolidationTransactions.push(...((yield runNextConsolidation()) as any));\n    }\n    // this is the final consolidation transaction. We return all the ones we've had so far\n    return consolidationTransactions;\n  });\n\n  return runNextConsolidation(this, target)\n    .catch(function (err) {\n      if (err.message === 'Done') {\n        return;\n      }\n      throw err;\n    })\n    .nodeify(callback);\n};\n\nWallet.prototype.shareWallet = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['email', 'permissions'], ['walletPassphrase', 'message'], callback);\n\n  if (params.reshare !== undefined && !_.isBoolean(params.reshare)) {\n    throw new Error('Expected reshare to be a boolean.');\n  }\n\n  if (params.skipKeychain !== undefined && !_.isBoolean(params.skipKeychain)) {\n    throw new Error('Expected skipKeychain to be a boolean. ');\n  }\n  const needsKeychain = !params.skipKeychain && params.permissions.indexOf('spend') !== -1;\n\n  if (params.disableEmail !== undefined && !_.isBoolean(params.disableEmail)) {\n    throw new Error('Expected disableEmail to be a boolean.');\n  }\n\n  const self = this;\n  let sharing;\n  let sharedKeychain;\n  return this.bitgo\n    .getSharingKey({ email: params.email.toLowerCase() })\n    .then(function (result) {\n      sharing = result;\n\n      if (needsKeychain) {\n        return self.getEncryptedUserKeychain({}).then(function (keychain) {\n          // Decrypt the user key with a passphrase\n          if (keychain.encryptedXprv) {\n            if (!params.walletPassphrase) {\n              throw new Error('Missing walletPassphrase argument');\n            }\n            try {\n              keychain.xprv = self.bitgo.decrypt({ password: params.walletPassphrase, input: keychain.encryptedXprv });\n            } catch (e) {\n              throw new Error('Unable to decrypt user keychain');\n            }\n\n            const eckey = makeRandomKey();\n            const secret = getSharedSecret(eckey, Buffer.from(sharing.pubkey, 'hex')).toString('hex');\n            const newEncryptedXprv = self.bitgo.encrypt({ password: secret, input: keychain.xprv });\n\n            sharedKeychain = {\n              xpub: keychain.xpub,\n              encryptedXprv: newEncryptedXprv,\n              fromPubKey: eckey.publicKey.toString('hex'),\n              toPubKey: sharing.pubkey,\n              path: sharing.path,\n            };\n          }\n        });\n      }\n    })\n    .then(function () {\n      interface Options {\n        user: any;\n        permissions: string;\n        reshare: boolean;\n        message: string;\n        disableEmail: any;\n        keychain?: any;\n        skipKeychain?: boolean;\n      }\n\n      const options: Options = {\n        user: sharing.userId,\n        permissions: params.permissions,\n        reshare: params.reshare,\n        message: params.message,\n        disableEmail: params.disableEmail,\n      };\n      if (sharedKeychain) {\n        options.keychain = sharedKeychain;\n      } else if (params.skipKeychain) {\n        options.keychain = {};\n      }\n\n      return self.createShare(options);\n    })\n    .nodeify(callback);\n};\n\nWallet.prototype.removeUser = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['user'], [], callback);\n\n  return Bluebird.resolve(\n    this.bitgo\n      .del(this.url('/user/' + params.user))\n      .send()\n      .result()\n  ).nodeify(callback);\n};\n\nWallet.prototype.getPolicy = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.url('/policy')).send().result()).nodeify(callback);\n};\n\nWallet.prototype.getPolicyStatus = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.url('/policy/status')).send().result()).nodeify(callback);\n};\n\nWallet.prototype.setPolicyRule = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id', 'type'], ['message'], callback);\n\n  if (!_.isObject(params.condition)) {\n    throw new Error('missing parameter: conditions object');\n  }\n\n  if (!_.isObject(params.action)) {\n    throw new Error('missing parameter: action object');\n  }\n\n  return Bluebird.resolve(this.bitgo.put(this.url('/policy/rule')).send(params).result()).nodeify(callback);\n};\n\nWallet.prototype.removePolicyRule = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], ['message'], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.url('/policy/rule')).send(params).result()).nodeify(callback);\n};\n\nWallet.prototype.listWebhooks = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n\n  return Bluebird.resolve(this.bitgo.get(this.url('/webhooks')).send().result()).nodeify(callback);\n};\n\n/**\n * Simulate wallet webhook, currently for webhooks of type transaction and pending approval\n * @param params\n * - webhookId (required): id of the webhook to be simulated\n * - txHash (optional but required for transaction webhooks) hash of the simulated transaction\n * - pendingApprovalId (optional but required for pending approval webhooks) id of the simulated pending approval\n * @param callback\n * @returns {*}\n */\nWallet.prototype.simulateWebhook = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['webhookId'], ['txHash', 'pendingApprovalId'], callback);\n\n  const hasTxHash = !!params.txHash;\n  const hasPendingApprovalId = !!params.pendingApprovalId;\n\n  if ((hasTxHash && hasPendingApprovalId) || (!hasTxHash && !hasPendingApprovalId)) {\n    throw new Error('must supply either txHash or pendingApprovalId, but not both');\n  }\n\n  // depending on the coin type of the wallet, the txHash has to adhere to its respective format\n  // but the server takes care of that\n\n  // only take the txHash and pendingApprovalId properties\n  const filteredParams = _.pick(params, ['txHash', 'pendingApprovalId']);\n\n  const webhookId = params.webhookId;\n  return Bluebird.resolve(\n    this.bitgo\n      .post(this.url('/webhooks/' + webhookId + '/simulate'))\n      .send(filteredParams)\n      .result()\n  ).nodeify(callback);\n};\n\nWallet.prototype.addWebhook = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['url', 'type'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.post(this.url('/webhooks')).send(params).result()).nodeify(callback);\n};\n\nWallet.prototype.removeWebhook = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['url', 'type'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.url('/webhooks')).send(params).result()).nodeify(callback);\n};\n\nWallet.prototype.estimateFee = function (params, callback) {\n  common.validateParams(params, [], [], callback);\n\n  if (params.amount && params.recipients) {\n    throw new Error('cannot specify both amount as well as recipients');\n  }\n  if (params.recipients && !_.isObject(params.recipients)) {\n    throw new Error('recipients must be array of { address: abc, amount: 100000 } objects');\n  }\n  if (params.amount && !_.isNumber(params.amount)) {\n    throw new Error('invalid amount argument, expecting number');\n  }\n\n  const recipients = params.recipients || [];\n\n  if (params.amount) {\n    // only the amount was passed in, so we need to make a false recipient to run createTransaction with\n    recipients.push({\n      address: common.Environments[this.bitgo.env].signingAddress, // any address will do\n      amount: params.amount,\n    });\n  }\n\n  const transactionParams = _.extend({}, params);\n  transactionParams.amount = undefined;\n  transactionParams.recipients = recipients;\n\n  return this.createTransaction(transactionParams).then(function (tx) {\n    return {\n      estimatedSize: tx.estimatedSize,\n      fee: tx.fee,\n      feeRate: tx.feeRate,\n    };\n  });\n};\n\n// Not fully implemented / released on SDK. Testing for now.\nWallet.prototype.updatePolicyRule = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id', 'type'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.put(this.url('/policy/rule')).send(params).result()).nodeify(callback);\n};\n\nWallet.prototype.deletePolicyRule = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, ['id'], [], callback);\n\n  return Bluebird.resolve(this.bitgo.del(this.url('/policy/rule')).send(params).result()).nodeify(callback);\n};\n\n//\n// getBitGoFee\n// Get the required on-transaction BitGo fee\n//\nWallet.prototype.getBitGoFee = function (params, callback) {\n  params = params || {};\n  common.validateParams(params, [], [], callback);\n  if (!_.isNumber(params.amount)) {\n    throw new Error('invalid amount argument');\n  }\n  if (params.instant && !_.isBoolean(params.instant)) {\n    throw new Error('invalid instant argument');\n  }\n  return Bluebird.resolve(this.bitgo.get(this.url('/billing/fee')).query(params).result()).nodeify(callback);\n};\n\nexport = Wallet;\n"]}