@atomicfinance/bitcoin-wallet-provider 2.5.0 → 3.0.1

package/dist/BitcoinWalletProvider.js

@@ -1,412 +1,500 @@
-Object.defineProperty(exports, "__esModule", {
-    value: true
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-exports.default = void 0;
-var _provider = _interopRequireDefault(require("@atomicfinance/provider"));
-var _types = require("@atomicfinance/types");
-var _bitcoinUtils = require("@liquality/bitcoin-utils");
-var _assert = _interopRequireDefault(require("assert"));
-var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
-var _secp256K1 = _interopRequireDefault(require("secp256k1"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
-        return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
-            }
-        }
-        newObj.default = obj;
-        return newObj;
-    }
-}
-const FEE_PER_BYTE_FALLBACK = 5;
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressSearchType = void 0;
+const bitcoin_utils_1 = require("@atomicfinance/bitcoin-utils");
+const errors_1 = require("@atomicfinance/errors");
+const types_1 = require("@atomicfinance/types");
+const utils_1 = require("@atomicfinance/utils");
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const memoizee_1 = __importDefault(require("memoizee"));
 const ADDRESS_GAP = 20;
 const NONCHANGE_ADDRESS = 0;
 const CHANGE_ADDRESS = 1;
 const NONCHANGE_OR_CHANGE_ADDRESS = 2;
-let BitcoinWalletProvider = class BitcoinWalletProvider extends _provider.default {
-    async buildSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs) {
-        return this._buildSweepTransaction(externalChangeAddress, feePerByte, _outputs, fixedInputs);
-    }
-    getUnusedAddressesBlacklist() {
-        return this._unusedAddressesBlacklist;
-    }
-    setUnusedAddressesBlacklist(unusedAddressesBlacklist) {
-        this._unusedAddressesBlacklist = unusedAddressesBlacklist;
-    }
-    setMaxAddressesToDerive(maxAddressesToDerive) {
-        this._maxAddressesToDerive = maxAddressesToDerive;
-    }
-    getMaxAddressesToDerive() {
-        return this._maxAddressesToDerive;
-    }
-    _createMultisigPayment(m, pubkeys) {
-        if (m > pubkeys.length) {
-            throw new Error(`not enough keys supplied (got ${pubkeys.length} keys, but need at least ${m} to redeem)`);
+var AddressSearchType;
+(function (AddressSearchType) {
+    AddressSearchType[AddressSearchType["EXTERNAL"] = 0] = "EXTERNAL";
+    AddressSearchType[AddressSearchType["CHANGE"] = 1] = "CHANGE";
+    AddressSearchType[AddressSearchType["EXTERNAL_OR_CHANGE"] = 2] = "EXTERNAL_OR_CHANGE";
+})(AddressSearchType = exports.AddressSearchType || (exports.AddressSearchType = {}));
+exports.default = (superclass) => {
+    class BitcoinWalletProvider extends superclass {
+        constructor(...args) {
+            const options = args[0];
+            const { network, baseDerivationPath, addressType = types_1.bitcoin.AddressType.BECH32, } = options;
+            const addressTypes = Object.values(types_1.bitcoin.AddressType);
+            if (!addressTypes.includes(addressType)) {
+                throw new Error(`addressType must be one of ${addressTypes.join(',')}`);
+            }
+            super(options);
+            this._baseDerivationPath = baseDerivationPath;
+            this._network = network;
+            this._addressType = addressType;
+            this._derivationCache = {};
+            this._unusedAddressesBlacklist = {};
+            this._maxAddressesToDerive = 5000;
         }
-        // Create m-of-n multisig
-        const p2ms = bitcoin.payments.p2ms({
-            m: m,
-            pubkeys: pubkeys.map((key)=>Buffer.from(key, 'hex')
-            ),
-            network: this._network
-        });
-        // Create p2wsh for multisig
-        const p2wsh = bitcoin.payments.p2wsh({
-            redeem: p2ms,
-            network: this._network
-        });
-        return p2wsh;
-    }
-    /**
-   * Creates a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-   * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-   * @param m the number of required signatures
-   * @param pubkeys n possible pubkeys in total
-   * @returns a json object containing the `address` and `redeemScript`
-   */ createMultisig(m, pubkeys) {
-        const p2wsh = this._createMultisigPayment(m, pubkeys);
-        return {
-            address: p2wsh.address,
-            redeemScript: p2wsh.redeem?.output?.toString('hex')
-        };
-    }
-    /**
-   * Creates a PSBT of a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-   * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-   * https://developer.bitcoin.org/reference/rpc/createpsbt.html
-   * @param m the number of required signatures
-   * @param pubkeys n possible pubkeys in total
-   * @param inputs the Inputs to the PSBT
-   * @param ouputs the Outputs to the PSBT
-   * @returns a base64 encoded psbt string
-   */ buildMultisigPSBT(m, pubkeys, inputs, outputs) {
-        (0, _assert).default(inputs.length > 0, 'no inputs found');
-        (0, _assert).default(outputs.length > 0, 'no outputs found');
-        const p2wsh = this._createMultisigPayment(m, pubkeys);
-        // Verify pubkeyhash for all inputs matches the p2wsh hash
-        (0, _assert).default(inputs.every((input)=>p2wsh.output.toString('hex') === input.scriptPubKey
-        ), 'address pubkeyhash does not match input scriptPubKey');
-        // creator
-        const psbt = new bitcoin.Psbt({
-            network: this._network
-        });
-        // updater
-        inputs.forEach((input)=>{
-            psbt.addInput({
-                hash: input.txid,
-                index: input.vout,
-                witnessUtxo: {
-                    script: p2wsh.output,
-                    value: input.value
-                },
-                witnessScript: p2wsh.redeem.output
-            });
-        });
-        outputs.forEach((output)=>{
-            psbt.addOutput({
-                address: output.to,
-                value: output.value
-            });
-        });
-        return psbt.toBase64();
-    }
-    /**
-   * Update a PSBT with input information from our wallet and then sign inputs that we can sign for
-   * https://developer.bitcoin.org/reference/rpc/walletprocesspsbt.html
-   * @param psbt a base64 encoded psbt string (P2WSH only)
-   * @returns a base64 encoded signed psbt string
-   */ async walletProcessPSBT(psbtString) {
-        const psbt = bitcoin.Psbt.fromBase64(psbtString);
-        await Promise.all(psbt.data.inputs.map(async (input, i)=>{
-            (0, _assert).default(psbt.getInputType(i).slice(0, 5) === 'p2wsh', 'only accepts P2WSH inputs');
-            const scriptStack = bitcoin.script.decompile(input.witnessScript);
-            const pubkeys = scriptStack.filter((data)=>Buffer.isBuffer(data) && _secp256K1.default.publicKeyVerify(data)
-            );
-            await Promise.all(pubkeys.map(async (key)=>{
-                // create address using pubkey
-                const { address: addressString  } = bitcoin.payments.p2wpkh({
-                    pubkey: key,
-                    network: this._network
-                });
-                // Retrieve address object from wallet using address
-                const address = await this.quickFindAddress([
-                    addressString, 
-                ]);
-                // exit if address doesn't exist in wallet
-                if (!address) return;
-                // derive keypair
-                const keyPair = await this.getMethod('keyPair')(address.derivationPath);
-                // sign PSBT using keypair
-                psbt.signInput(i, keyPair);
-            }));
-        }));
-        psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!
-        return psbt.toBase64();
-    }
-    /**
-   * Finalize the inputs of a PSBT. If the transaction is fully signed, it will
-   * produce a network serialized transaction which can be broadcast with sendrawtransaction
-   * https://developer.bitcoin.org/reference/rpc/finalizepsbt.html
-   * @param psbt a base64 encoded psbt string
-   * @returns a json object containing `psbt` in base64, `hex` for transaction and `complete` for if
-   * the transaction has a complete set of signatures
-   */ finalizePSBT(psbtString) {
-        const psbt = bitcoin.Psbt.fromBase64(psbtString);
-        try {
-            psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!
-            psbt.finalizeAllInputs();
-        } catch (error) {
-            return {
-                psbt: psbt.toBase64(),
-                complete: false
-            };
+        getDerivationCache() {
+            return this._derivationCache;
         }
-        return {
-            psbt: psbt.toBase64(),
-            hex: psbt.extractTransaction().toHex(),
-            complete: true
-        };
-    }
-    async getUnusedAddress(change = false, numAddressPerCall = 100) {
-        const addressType = change ? CHANGE_ADDRESS : NONCHANGE_ADDRESS;
-        const key = change ? 'change' : 'nonChange';
-        const address = await this._getUsedUnusedAddresses(numAddressPerCall, addressType).then(({ unusedAddress  })=>unusedAddress[key]
-        );
-        this._unusedAddressesBlacklist[address.address] = true;
-        return address;
-    }
-    async _getUsedUnusedAddresses(numAddressPerCall = 100, addressType) {
-        const usedAddresses = [];
-        const addressCountMap = {
-            change: 0,
-            nonChange: 0
-        };
-        const unusedAddressMap = {
-            change: null,
-            nonChange: null
-        };
-        let addrList;
-        let addressIndex = 0;
-        let changeAddresses = [];
-        let nonChangeAddresses = [];
-        /* eslint-disable no-unmodified-loop-condition */ while(addressType === NONCHANGE_OR_CHANGE_ADDRESS && (addressCountMap.change < ADDRESS_GAP || addressCountMap.nonChange < ADDRESS_GAP) || addressType === NONCHANGE_ADDRESS && addressCountMap.nonChange < ADDRESS_GAP || addressType === CHANGE_ADDRESS && addressCountMap.change < ADDRESS_GAP){
-            /* eslint-enable no-unmodified-loop-condition */ addrList = [];
-            if ((addressType === NONCHANGE_OR_CHANGE_ADDRESS || addressType === CHANGE_ADDRESS) && addressCountMap.change < ADDRESS_GAP) {
-                // Scanning for change addr
-                changeAddresses = await this.client.wallet.getAddresses(addressIndex, numAddressPerCall, true);
-                addrList = addrList.concat(changeAddresses);
-            } else {
-                changeAddresses = [];
+        async setDerivationCache(derivationCache) {
+            const address = await this.getDerivationPathAddress(Object.keys(derivationCache)[0]);
+            if (derivationCache[address.derivationPath].address !== address.address) {
+                throw new Error(`derivationCache at ${address.derivationPath} does not match`);
             }
-            if ((addressType === NONCHANGE_OR_CHANGE_ADDRESS || addressType === NONCHANGE_ADDRESS) && addressCountMap.nonChange < ADDRESS_GAP) {
-                // Scanning for non change addr
-                nonChangeAddresses = await this.quickGetAddresses(addressIndex, numAddressPerCall, false);
-                addrList = addrList.concat(nonChangeAddresses);
+            this._derivationCache = derivationCache;
+        }
+        sendOptionsToOutputs(transactions) {
+            const targets = [];
+            transactions.forEach((tx) => {
+                if (tx.to && tx.value && tx.value.gt(0)) {
+                    targets.push({
+                        address: utils_1.addressToString(tx.to),
+                        value: tx.value.toNumber(),
+                    });
+                }
+                if (tx.data) {
+                    const scriptBuffer = bitcoin.script.compile([
+                        bitcoin.script.OPS.OP_RETURN,
+                        Buffer.from(tx.data, 'hex'),
+                    ]);
+                    targets.push({
+                        value: 0,
+                        script: scriptBuffer,
+                    });
+                }
+            });
+            return targets;
+        }
+        async buildTransaction(output, feePerByte) {
+            return this._buildTransaction([output], feePerByte);
+        }
+        async buildBatchTransaction(outputs) {
+            return this._buildTransaction(outputs);
+        }
+        async _sendTransaction(transactions, feePerByte) {
+            const { hex, fee } = await this._buildTransaction(transactions, feePerByte);
+            await this.getMethod('sendRawTransaction')(hex);
+            return bitcoin_utils_1.normalizeTransactionObject(bitcoin_utils_1.decodeRawTransaction(hex, this._network), fee);
+        }
+        async sendTransaction(options) {
+            return this._sendTransaction(this.sendOptionsToOutputs([options]), options.fee);
+        }
+        async sendBatchTransaction(transactions) {
+            return this._sendTransaction(this.sendOptionsToOutputs(transactions));
+        }
+        async buildSweepTransaction(externalChangeAddress, feePerByte) {
+            return this._buildSweepTransaction(externalChangeAddress, feePerByte);
+        }
+        async sendSweepTransaction(externalChangeAddress, feePerByte) {
+            const { hex, fee } = await this._buildSweepTransaction(utils_1.addressToString(externalChangeAddress), feePerByte);
+            await this.getMethod('sendRawTransaction')(hex);
+            return bitcoin_utils_1.normalizeTransactionObject(bitcoin_utils_1.decodeRawTransaction(hex, this._network), fee);
+        }
+        getUnusedAddressesBlacklist() {
+            return this._unusedAddressesBlacklist;
+        }
+        setUnusedAddressesBlacklist(unusedAddressesBlacklist) {
+            this._unusedAddressesBlacklist = unusedAddressesBlacklist;
+        }
+        setMaxAddressesToDerive(maxAddressesToDerive) {
+            this._maxAddressesToDerive = maxAddressesToDerive;
+        }
+        getMaxAddressesToDerive() {
+            return this._maxAddressesToDerive;
+        }
+        async updateTransactionFee(tx, newFeePerByte) {
+            const txHash = typeof tx === 'string' ? tx : tx.hash;
+            const transaction = (await this.getMethod('getTransactionByHash')(txHash))._raw;
+            const fixedInputs = [transaction.vin[0]]; // TODO: should this pick more than 1 input? RBF doesn't mandate it
+            const lookupAddresses = transaction.vout.map((vout) => vout.scriptPubKey.addresses[0]);
+            const changeAddress = await this.findAddress(lookupAddresses, true);
+            const changeOutput = transaction.vout.find((vout) => vout.scriptPubKey.addresses[0] === changeAddress.address);
+            let outputs = transaction.vout;
+            if (changeOutput) {
+                outputs = outputs.filter((vout) => vout.scriptPubKey.addresses[0] !==
+                    changeOutput.scriptPubKey.addresses[0]);
             }
-            const transactionCounts = await this.getMethod('getAddressTransactionCounts')(addrList);
-            for (const address of addrList){
-                const isUsed = transactionCounts[address.address] > 0 || this._unusedAddressesBlacklist[address.address];
-                const isChangeAddress = changeAddresses.find((a)=>address.address === a.address
-                );
-                const key = isChangeAddress ? 'change' : 'nonChange';
-                if (isUsed) {
-                    usedAddresses.push(address);
-                    addressCountMap[key] = 0;
-                    unusedAddressMap[key] = null;
-                } else {
-                    addressCountMap[key]++;
-                    if (!unusedAddressMap[key]) {
-                        unusedAddressMap[key] = address;
+            // TODO more checks?
+            const transactions = outputs.map((output) => ({
+                address: output.scriptPubKey.addresses[0],
+                value: new types_1.BigNumber(output.value).times(1e8).toNumber(),
+            }));
+            const { hex, fee } = await this._buildTransaction(transactions, newFeePerByte, fixedInputs);
+            await this.getMethod('sendRawTransaction')(hex);
+            return bitcoin_utils_1.normalizeTransactionObject(bitcoin_utils_1.decodeRawTransaction(hex, this._network), fee);
+        }
+        async getUnusedAddress(change = false, numAddressPerCall = 100) {
+            const addressType = change ? CHANGE_ADDRESS : NONCHANGE_ADDRESS;
+            const key = change ? 'change' : 'nonChange';
+            const address = await this._getUsedUnusedAddresses(numAddressPerCall, addressType).then(({ unusedAddress }) => unusedAddress[key]);
+            this._unusedAddressesBlacklist[address.address] = true;
+            return address;
+        }
+        async _getUsedUnusedAddresses(numAddressPerCall = 100, addressType) {
+            const usedAddresses = [];
+            const addressCountMap = { change: 0, nonChange: 0 };
+            const unusedAddressMap = { change: null, nonChange: null };
+            let addrList;
+            let addressIndex = 0;
+            let changeAddresses = [];
+            let nonChangeAddresses = [];
+            /* eslint-disable no-unmodified-loop-condition */
+            while ((addressType === NONCHANGE_OR_CHANGE_ADDRESS &&
+                (addressCountMap.change < ADDRESS_GAP ||
+                    addressCountMap.nonChange < ADDRESS_GAP)) ||
+                (addressType === NONCHANGE_ADDRESS &&
+                    addressCountMap.nonChange < ADDRESS_GAP) ||
+                (addressType === CHANGE_ADDRESS && addressCountMap.change < ADDRESS_GAP)) {
+                /* eslint-enable no-unmodified-loop-condition */
+                addrList = [];
+                if ((addressType === NONCHANGE_OR_CHANGE_ADDRESS ||
+                    addressType === CHANGE_ADDRESS) &&
+                    addressCountMap.change < ADDRESS_GAP) {
+                    // Scanning for change addr
+                    changeAddresses = await this.client.wallet.getAddresses(addressIndex, numAddressPerCall, true);
+                    addrList = addrList.concat(changeAddresses);
+                }
+                else {
+                    changeAddresses = [];
+                }
+                if ((addressType === NONCHANGE_OR_CHANGE_ADDRESS ||
+                    addressType === NONCHANGE_ADDRESS) &&
+                    addressCountMap.nonChange < ADDRESS_GAP) {
+                    // Scanning for non change addr
+                    nonChangeAddresses = await this.getAddresses(addressIndex, numAddressPerCall, false);
+                    addrList = addrList.concat(nonChangeAddresses);
+                }
+                const transactionCounts = await this.getMethod('getAddressTransactionCounts')(addrList);
+                for (const address of addrList) {
+                    const isUsed = transactionCounts[address.address] > 0 ||
+                        this._unusedAddressesBlacklist[address.address];
+                    const isChangeAddress = changeAddresses.find((a) => address.address === a.address);
+                    const key = isChangeAddress ? 'change' : 'nonChange';
+                    if (isUsed) {
+                        usedAddresses.push(address);
+                        addressCountMap[key] = 0;
+                        unusedAddressMap[key] = null;
+                    }
+                    else {
+                        addressCountMap[key]++;
+                        if (!unusedAddressMap[key]) {
+                            unusedAddressMap[key] = address;
+                        }
                     }
                 }
+                addressIndex += numAddressPerCall;
             }
-            addressIndex += numAddressPerCall;
+            let firstUnusedAddress;
+            const indexNonChange = unusedAddressMap.nonChange
+                ? unusedAddressMap.nonChange.index
+                : Infinity;
+            const indexChange = unusedAddressMap.change
+                ? unusedAddressMap.change.index
+                : Infinity;
+            if (indexNonChange <= indexChange)
+                firstUnusedAddress = unusedAddressMap.nonChange;
+            else
+                firstUnusedAddress = unusedAddressMap.change;
+            return {
+                usedAddresses,
+                unusedAddress: unusedAddressMap,
+                firstUnusedAddress,
+            };
         }
-        let firstUnusedAddress;
-        const indexNonChange = unusedAddressMap.nonChange ? unusedAddressMap.nonChange.index : Infinity;
-        const indexChange = unusedAddressMap.change ? unusedAddressMap.change.index : Infinity;
-        if (indexNonChange <= indexChange) firstUnusedAddress = unusedAddressMap.nonChange;
-        else firstUnusedAddress = unusedAddressMap.change;
-        return {
-            usedAddresses,
-            unusedAddress: unusedAddressMap,
-            firstUnusedAddress
-        };
-    }
-    async sendSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs) {
-        const { hex , fee  } = await this._buildSweepTransaction(externalChangeAddress, feePerByte, _outputs, fixedInputs);
-        await this.getMethod('sendRawTransaction')(hex);
-        return (0, _bitcoinUtils).normalizeTransactionObject((0, _bitcoinUtils).decodeRawTransaction(hex, this._network), fee);
-    }
-    async _buildSweepTransaction(externalChangeAddress, feePerByte, _outputs = [], fixedInputs) {
-        const _feePerByte = feePerByte || await this.getMethod('getFeePerByte')() || FEE_PER_BYTE_FALLBACK;
-        const inputs = [];
-        const outputs = [];
-        try {
-            const inputsForAmount = await this.getMethod('getInputsForAmount')(_outputs, _feePerByte, fixedInputs, 100, true);
-            if (inputsForAmount.change) {
-                throw Error('There should not be any change for sweeping transaction');
+        async getWalletAddress(address) {
+            const foundAddress = await this.findAddress([address]);
+            if (foundAddress)
+                return foundAddress;
+            throw new Error('Wallet does not contain address');
+        }
+        getAddressFromPublicKey(publicKey) {
+            return this.getPaymentVariantFromPublicKey(publicKey).address;
+        }
+        getPaymentVariantFromPublicKey(publicKey) {
+            if (this._addressType === types_1.bitcoin.AddressType.LEGACY) {
+                return bitcoin.payments.p2pkh({
+                    pubkey: publicKey,
+                    network: this._network,
+                });
+            }
+            else if (this._addressType === types_1.bitcoin.AddressType.P2SH_SEGWIT) {
+                return bitcoin.payments.p2sh({
+                    redeem: bitcoin.payments.p2wpkh({
+                        pubkey: publicKey,
+                        network: this._network,
+                    }),
+                    network: this._network,
+                });
             }
-            inputs.push(...inputsForAmount.inputs || []);
-            outputs.push(...inputsForAmount.outputs || []);
-        } catch (e) {
-            if (fixedInputs.length === 0) {
-                throw Error(`Inputs for amount doesn't exist and no fixedInputs provided`);
+            else if (this._addressType === types_1.bitcoin.AddressType.BECH32) {
+                return bitcoin.payments.p2wpkh({
+                    pubkey: publicKey,
+                    network: this._network,
+                });
             }
-            const inputsForAmount = await this._getInputForAmountWithoutUtxoCheck(_outputs, _feePerByte, fixedInputs);
-            inputs.push(...inputsForAmount.inputs.map((utxo)=>_types.Input.fromUTXO(utxo)
-            ) || []);
-            outputs.push(...inputsForAmount.outputs || []);
         }
-        _outputs.forEach((output)=>{
-            const spliceIndex = outputs.findIndex((sweepOutput)=>output.value === sweepOutput.value
-            );
-            outputs.splice(spliceIndex, 1);
-        });
-        _outputs.push({
-            to: externalChangeAddress,
-            value: outputs[0].value
-        });
-        return this._buildTransactionWithoutUtxoCheck(_outputs, _feePerByte, inputs);
-    }
-    _getInputForAmountWithoutUtxoCheck(_outputs, _feePerByte, fixedInputs) {
-        const utxoBalance = fixedInputs.reduce((a, b)=>a + (b['value'] || 0)
-        , 0);
-        const outputBalance = _outputs.reduce((a, b)=>a + (b['value'] || 0)
-        , 0);
-        const amountToSend = utxoBalance - _feePerByte * ((_outputs.length + 1) * 39 + fixedInputs.length * 153); // todo better calculation
-        const targets = _outputs.map((target, i)=>({
-                id: 'main',
-                value: target.value
-            })
-        );
-        if (amountToSend - outputBalance > 0) {
-            targets.push({
-                id: 'main',
-                value: amountToSend - outputBalance
+        async getDerivationPathAddress(path) {
+            if (path in this._derivationCache) {
+                return this._derivationCache[path];
+            }
+            const baseDerivationNode = await this.baseDerivationNode();
+            const subPath = path.replace(this._baseDerivationPath + '/', '');
+            const publicKey = baseDerivationNode.derivePath(subPath).publicKey;
+            const address = this.getAddressFromPublicKey(publicKey);
+            const addressObject = new types_1.Address({
+                address,
+                publicKey: publicKey.toString('hex'),
+                derivationPath: path,
             });
+            this._derivationCache[path] = addressObject;
+            return addressObject;
         }
-        return (0, _bitcoinUtils).selectCoins(fixedInputs, targets, Math.ceil(_feePerByte), fixedInputs);
-    }
-    async _buildTransactionWithoutUtxoCheck(outputs, feePerByte, fixedInputs) {
-        const network = this._network;
-        const { fee  } = this._getInputForAmountWithoutUtxoCheck(outputs, feePerByte, fixedInputs);
-        const inputs = fixedInputs;
-        const txb = new bitcoin.TransactionBuilder(network);
-        for (const output of outputs){
-            const to = output.to; // Allow for OP_RETURN
-            txb.addOutput(to, output.value);
+        /**
+         * getAddresses is an optimized version of upstream CAL's getAddresses.
+         * It removes the call to `asyncSetImmediate()`, speeding up the function by a factor of 6x.
+         *
+         * @param startingIndex
+         * @param numAddresses
+         * @param change
+         * @returns {Promise<Address[]>}
+         */
+        async getAddresses(startingIndex = 0, numAddresses = 1, change = false) {
+            if (numAddresses < 1) {
+                throw new Error('You must return at least one address');
+            }
+            const addresses = [];
+            const lastIndex = startingIndex + numAddresses;
+            const changeVal = change ? '1' : '0';
+            for (let currentIndex = startingIndex; currentIndex < lastIndex; currentIndex++) {
+                const subPath = changeVal + '/' + currentIndex;
+                const path = this._baseDerivationPath + '/' + subPath;
+                const addressObject = await this.getDerivationPathAddress(path);
+                addresses.push(addressObject);
+            }
+            return addresses;
         }
-        const prevOutScriptType = 'p2wpkh';
-        for(let i = 0; i < inputs.length; i++){
-            const wallet = await this.getMethod('getWalletAddress')(inputs[i].address);
-            const keyPair = await this.getMethod('keyPair')(wallet.derivationPath);
-            const paymentVariant = this.getMethod('getPaymentVariantFromPublicKey')(keyPair.publicKey);
-            txb.addInput(inputs[i].txid, inputs[i].vout, 0, paymentVariant.output);
+        /**
+         * findAddress is an optimized version of upstream CAL's findAddress.
+         *
+         * It searches through both change and non-change addresses (if change arg is not provided) each iteration.
+         *
+         * This is in contrast to the original findAddress function which searches
+         * through all non-change addresses before moving on to change addresses.
+         *
+         * @param addresses
+         * @returns {Promise<Address>}
+         */
+        async findAddress(addresses, change = null) {
+            const addressesPerCall = 20;
+            let index = 0;
+            while (index < this._maxAddressesToDerive) {
+                const walletAddresses = [];
+                if (change === null || change === false) {
+                    walletAddresses.push(...(await this.getAddresses(index, addressesPerCall, false)));
+                }
+                if (change === null || change === true) {
+                    walletAddresses.push(...(await this.getAddresses(index, addressesPerCall, true)));
+                }
+                const walletAddress = walletAddresses.find((walletAddr) => addresses.find((addr) => walletAddr.address === addr));
+                if (walletAddress) {
+                    // Increment max addresses to derive by 100 if found within 100 addresses of maxAddressesToDerive
+                    this._maxAddressesToDerive = Math.max(this._maxAddressesToDerive, index + 100);
+                    return walletAddress;
+                }
+                index += addressesPerCall;
+            }
+        }
+        async getUsedAddresses(numAddressPerCall = 100) {
+            return this._getUsedUnusedAddresses(numAddressPerCall, AddressSearchType.EXTERNAL_OR_CHANGE).then(({ usedAddresses }) => usedAddresses);
         }
-        for(let i1 = 0; i1 < inputs.length; i1++){
-            const wallet = await this.getMethod('getWalletAddress')(inputs[i1].address);
-            const keyPair = await this.getMethod('keyPair')(wallet.derivationPath);
-            const paymentVariant = this.getMethod('getPaymentVariantFromPublicKey')(keyPair.publicKey);
-            const needsWitness = true;
-            const signParams = {
-                prevOutScriptType,
-                vin: i1,
-                keyPair,
-                witnessValue: 0
+        async withCachedUtxos(func) {
+            const originalGetMethod = this.getMethod;
+            const memoizedGetFeePerByte = memoizee_1.default(this.getMethod('getFeePerByte'), {
+                primitive: true,
+            });
+            const memoizedGetUnspentTransactions = memoizee_1.default(this.getMethod('getUnspentTransactions'), { primitive: true });
+            const memoizedGetAddressTransactionCounts = memoizee_1.default(this.getMethod('getAddressTransactionCounts'), {
+                primitive: true,
+            });
+            this.getMethod = (method, requestor = this) => {
+                if (method === 'getFeePerByte')
+                    return memoizedGetFeePerByte;
+                if (method === 'getUnspentTransactions')
+                    return memoizedGetUnspentTransactions;
+                else if (method === 'getAddressTransactionCounts')
+                    return memoizedGetAddressTransactionCounts;
+                else
+                    return originalGetMethod.bind(this)(method, requestor);
             };
-            if (needsWitness) {
-                signParams.witnessValue = inputs[i1].value;
-            }
-            txb.sign(signParams);
+            const result = await func.bind(this)();
+            this.getMethod = originalGetMethod;
+            return result;
         }
-        return {
-            hex: txb.build().toHex(),
-            fee
-        };
-    }
-    /**
-   * quickGetAddresses is an optimized version of getAddresses.
-   * It removes the call to `asyncSetImmediate()`, speeding up the function by a factor of 6x.
-   *
-   * @param startingIndex
-   * @param numAddresses
-   * @param change
-   * @returns {Promise<Address[]>}
-   */ async quickGetAddresses(startingIndex = 0, numAddresses = 1, change = false) {
-        if (numAddresses < 1) {
-            throw new Error('You must return at least one address');
+        async getTotalFee(opts, max) {
+            const targets = this.sendOptionsToOutputs([opts]);
+            if (!max) {
+                const { fee } = await this.getInputsForAmount(targets, opts.fee);
+                return fee;
+            }
+            else {
+                const { fee } = await this.getInputsForAmount(targets.filter((t) => !t.value), opts.fee, [], 100, true);
+                return fee;
+            }
         }
-        const addresses = [];
-        const lastIndex = startingIndex + numAddresses;
-        const changeVal = change ? '1' : '0';
-        // Original wallet provider is fetched to get the base derivation path
-        const originalProvider = this.client.getProviderForMethod('getAddresses');
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const baseDerivationPath = originalProvider._baseDerivationPath;
-        const getDerivationPathAddressFn = this.client.getMethod('getDerivationPathAddress');
-        for(let currentIndex = startingIndex; currentIndex < lastIndex; currentIndex++){
-            const subPath = changeVal + '/' + currentIndex;
-            const path = baseDerivationPath + '/' + subPath;
-            const addressObject = await getDerivationPathAddressFn(path);
-            addresses.push(addressObject);
+        async getTotalFees(transactions, max) {
+            const fees = await this.withCachedUtxos(async () => {
+                const fees = {};
+                for (const tx of transactions) {
+                    const fee = await this.getTotalFee(tx, max);
+                    fees[tx.fee] = new types_1.BigNumber(fee);
+                }
+                return fees;
+            });
+            return fees;
         }
-        return addresses;
-    }
-    /**
-   * quickFindAddress is an optimized version of findAddress.
-   *
-   * It searches through both change and non-change addresses each iteration.
-   *
-   * This is in contrast to the original findAddress function which searches
-   * through all non-change addresses before moving on to change addresses.
-   *
-   * @param addresses
-   * @returns {Promise<Address[]>}
-   */ async quickFindAddress(addresses) {
-        const addressesPerCall = 20;
-        let index = 0;
-        while(index < this._maxAddressesToDerive){
-            const walletNonChangeAddresses = await this.quickGetAddresses(index, addressesPerCall, true);
-            const walletChangeAddresses = await this.quickGetAddresses(index, addressesPerCall, false);
-            const walletAddresses = [
-                ...walletNonChangeAddresses,
-                ...walletChangeAddresses, 
-            ];
-            const walletAddress = walletAddresses.find((walletAddr)=>addresses.find((addr)=>walletAddr.address === addr
-                )
-            );
-            if (walletAddress) {
-                // Increment max addresses to derive by 100 if found within 100 addresses of maxAddressesToDerive
-                this._maxAddressesToDerive = Math.max(this._maxAddressesToDerive, index + 100);
-                return walletAddress;
+        async getInputsForAmount(_targets, feePerByte, fixedInputs = [], numAddressPerCall = 100, sweep = false) {
+            let addressIndex = 0;
+            let changeAddresses = [];
+            let externalAddresses = [];
+            const addressCountMap = {
+                change: 0,
+                nonChange: 0,
+            };
+            const feePerBytePromise = this.getMethod('getFeePerByte')();
+            let utxos = [];
+            while (addressCountMap.change < ADDRESS_GAP ||
+                addressCountMap.nonChange < ADDRESS_GAP) {
+                let addrList = [];
+                if (addressCountMap.change < ADDRESS_GAP) {
+                    // Scanning for change addr
+                    changeAddresses = await this.getAddresses(addressIndex, numAddressPerCall, true);
+                    addrList = addrList.concat(changeAddresses);
+                }
+                else {
+                    changeAddresses = [];
+                }
+                if (addressCountMap.nonChange < ADDRESS_GAP) {
+                    // Scanning for non change addr
+                    externalAddresses = await this.getAddresses(addressIndex, numAddressPerCall, false);
+                    addrList = addrList.concat(externalAddresses);
+                }
+                const fixedUtxos = [];
+                if (fixedInputs.length > 0) {
+                    for (const input of fixedInputs) {
+                        const txHex = await this.getMethod('getRawTransactionByHash')(input.txid);
+                        const tx = bitcoin_utils_1.decodeRawTransaction(txHex, this._network);
+                        const value = new types_1.BigNumber(tx.vout[input.vout].value)
+                            .times(1e8)
+                            .toNumber();
+                        const address = tx.vout[input.vout].scriptPubKey.addresses[0];
+                        const walletAddress = await this.getWalletAddress(address);
+                        const utxo = {
+                            ...input,
+                            value,
+                            address,
+                            derivationPath: walletAddress.derivationPath,
+                        };
+                        fixedUtxos.push(utxo);
+                    }
+                }
+                if (!sweep || fixedUtxos.length === 0) {
+                    const _utxos = await this.getMethod('getUnspentTransactions')(addrList);
+                    utxos.push(..._utxos.map((utxo) => {
+                        const addr = addrList.find((a) => a.address === utxo.address);
+                        return {
+                            ...utxo,
+                            derivationPath: addr.derivationPath,
+                        };
+                    }));
+                }
+                else {
+                    utxos = fixedUtxos;
+                }
+                const utxoBalance = utxos.reduce((a, b) => a + (b.value || 0), 0);
+                const transactionCounts = await this.getMethod('getAddressTransactionCounts')(addrList);
+                if (!feePerByte)
+                    feePerByte = await feePerBytePromise;
+                const minRelayFee = await this.getMethod('getMinRelayFee')();
+                if (feePerByte < minRelayFee) {
+                    throw new Error(`Fee supplied (${feePerByte} sat/b) too low. Minimum relay fee is ${minRelayFee} sat/b`);
+                }
+                let targets;
+                if (sweep) {
+                    const outputBalance = _targets.reduce((a, b) => a + (b['value'] || 0), 0);
+                    const sweepOutputSize = 39;
+                    const paymentOutputSize = _targets.filter((t) => t.value && t.address).length * 39;
+                    const scriptOutputSize = _targets
+                        .filter((t) => !t.value && t.script)
+                        .reduce((size, t) => size + 39 + t.script.byteLength, 0);
+                    const outputSize = sweepOutputSize + paymentOutputSize + scriptOutputSize;
+                    const inputSize = utxos.length * 153;
+                    const sweepFee = feePerByte * (inputSize + outputSize);
+                    const amountToSend = new types_1.BigNumber(utxoBalance).minus(sweepFee);
+                    targets = _targets.map((target) => ({
+                        id: 'main',
+                        value: target.value,
+                        script: target.script,
+                    }));
+                    targets.push({
+                        id: 'main',
+                        value: amountToSend.minus(outputBalance).toNumber(),
+                    });
+                }
+                else {
+                    targets = _targets.map((target) => ({
+                        id: 'main',
+                        value: target.value,
+                        script: target.script,
+                    }));
+                }
+                const { inputs, outputs, change, fee } = bitcoin_utils_1.selectCoins(utxos, targets, Math.ceil(feePerByte), fixedUtxos);
+                if (inputs && outputs) {
+                    return {
+                        inputs,
+                        change,
+                        outputs,
+                        fee,
+                    };
+                }
+                for (const address of addrList) {
+                    const isUsed = transactionCounts[address.address];
+                    const isChangeAddress = changeAddresses.find((a) => address.address === a.address);
+                    const key = isChangeAddress ? 'change' : 'nonChange';
+                    if (isUsed) {
+                        addressCountMap[key] = 0;
+                    }
+                    else {
+                        addressCountMap[key]++;
+                    }
+                }
+                addressIndex += numAddressPerCall;
             }
-            index += addressesPerCall;
+            throw new errors_1.InsufficientBalanceError('Not enough balance');
         }
     }
-    constructor(network){
-        super();
-        this._network = network;
-        this._unusedAddressesBlacklist = {};
-        this._maxAddressesToDerive = 5000;
-    }
+    return BitcoinWalletProvider;
 };
-exports.default = BitcoinWalletProvider;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../lib/BitcoinWalletProvider.ts"],"sourcesContent":["import Provider from '@atomicfinance/provider';\nimport {\n  CreateMultisigResponse,\n  finalizePSBTResponse,\n  FinanceWalletProvider,\n  Input,\n  Output,\n} from '@atomicfinance/types';\nimport { BitcoinNetwork } from '@liquality/bitcoin-networks';\nimport {\n  decodeRawTransaction,\n  normalizeTransactionObject,\n  selectCoins,\n} from '@liquality/bitcoin-utils';\nimport { Address, bitcoin as bT, Transaction } from '@liquality/types';\nimport assert from 'assert';\nimport * as bitcoin from 'bitcoinjs-lib';\nimport secp256k1 from 'secp256k1';\n\nconst FEE_PER_BYTE_FALLBACK = 5;\nconst ADDRESS_GAP = 20;\nconst NONCHANGE_ADDRESS = 0;\nconst CHANGE_ADDRESS = 1;\nconst NONCHANGE_OR_CHANGE_ADDRESS = 2;\n\ntype UnusedAddressesBlacklist = {\n  [address: string]: true;\n};\n\nexport default class BitcoinWalletProvider\n  extends Provider\n  implements Partial<FinanceWalletProvider> {\n  _network: BitcoinNetwork;\n  _unusedAddressesBlacklist: UnusedAddressesBlacklist;\n  _maxAddressesToDerive: number;\n\n  constructor(network: BitcoinNetwork) {\n    super();\n\n    this._network = network;\n    this._unusedAddressesBlacklist = {};\n    this._maxAddressesToDerive = 5000;\n  }\n\n  async buildSweepTransactionWithSetOutputs(\n    externalChangeAddress: string,\n    feePerByte: number,\n    _outputs: Output[],\n    fixedInputs: Input[],\n  ) {\n    return this._buildSweepTransaction(\n      externalChangeAddress,\n      feePerByte,\n      _outputs,\n      fixedInputs,\n    );\n  }\n\n  getUnusedAddressesBlacklist(): UnusedAddressesBlacklist {\n    return this._unusedAddressesBlacklist;\n  }\n\n  setUnusedAddressesBlacklist(\n    unusedAddressesBlacklist: UnusedAddressesBlacklist,\n  ) {\n    this._unusedAddressesBlacklist = unusedAddressesBlacklist;\n  }\n\n  setMaxAddressesToDerive(maxAddressesToDerive: number) {\n    this._maxAddressesToDerive = maxAddressesToDerive;\n  }\n\n  getMaxAddressesToDerive() {\n    return this._maxAddressesToDerive;\n  }\n\n  _createMultisigPayment(m: number, pubkeys: string[]): bitcoin.Payment {\n    if (m > pubkeys.length) {\n      throw new Error(\n        `not enough keys supplied (got ${pubkeys.length} keys, but need at least ${m} to redeem)`,\n      );\n    }\n    // Create m-of-n multisig\n    const p2ms = bitcoin.payments.p2ms({\n      m: m,\n      pubkeys: pubkeys.map((key: string) => Buffer.from(key, 'hex')),\n      network: this._network,\n    });\n\n    // Create p2wsh for multisig\n    const p2wsh = bitcoin.payments.p2wsh({\n      redeem: p2ms,\n      network: this._network,\n    });\n\n    return p2wsh;\n  }\n\n  /**\n   * Creates a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys\n   * https://developer.bitcoin.org/reference/rpc/createmultisig.html\n   * @param m the number of required signatures\n   * @param pubkeys n possible pubkeys in total\n   * @returns a json object containing the `address` and `redeemScript`\n   */\n  createMultisig(m: number, pubkeys: string[]): CreateMultisigResponse {\n    const p2wsh = this._createMultisigPayment(m, pubkeys);\n    return {\n      address: p2wsh.address,\n      redeemScript: p2wsh.redeem?.output?.toString('hex'),\n    };\n  }\n\n  /**\n   * Creates a PSBT of a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys\n   * https://developer.bitcoin.org/reference/rpc/createmultisig.html\n   * https://developer.bitcoin.org/reference/rpc/createpsbt.html\n   * @param m the number of required signatures\n   * @param pubkeys n possible pubkeys in total\n   * @param inputs the Inputs to the PSBT\n   * @param ouputs the Outputs to the PSBT\n   * @returns a base64 encoded psbt string\n   */\n  buildMultisigPSBT(\n    m: number,\n    pubkeys: string[],\n    inputs: Input[],\n    outputs: Output[],\n  ): string {\n    assert(inputs.length > 0, 'no inputs found');\n    assert(outputs.length > 0, 'no outputs found');\n\n    const p2wsh = this._createMultisigPayment(m, pubkeys);\n\n    // Verify pubkeyhash for all inputs matches the p2wsh hash\n    assert(\n      inputs.every(\n        (input: Input) => p2wsh.output.toString('hex') === input.scriptPubKey,\n      ),\n      'address pubkeyhash does not match input scriptPubKey',\n    );\n\n    // creator\n    const psbt = new bitcoin.Psbt({ network: this._network });\n\n    // updater\n    inputs.forEach((input: Input) => {\n      psbt.addInput({\n        hash: input.txid,\n        index: input.vout,\n        witnessUtxo: { script: p2wsh.output, value: input.value },\n        witnessScript: p2wsh.redeem.output,\n      });\n    });\n\n    outputs.forEach((output: Output) => {\n      psbt.addOutput({\n        address: output.to,\n        value: output.value,\n      });\n    });\n\n    return psbt.toBase64();\n  }\n\n  /**\n   * Update a PSBT with input information from our wallet and then sign inputs that we can sign for\n   * https://developer.bitcoin.org/reference/rpc/walletprocesspsbt.html\n   * @param psbt a base64 encoded psbt string (P2WSH only)\n   * @returns a base64 encoded signed psbt string\n   */\n  async walletProcessPSBT(psbtString: string): Promise<string> {\n    const psbt = bitcoin.Psbt.fromBase64(psbtString);\n\n    await Promise.all(\n      psbt.data.inputs.map(async (input, i: number) => {\n        assert(\n          psbt.getInputType(i).slice(0, 5) === 'p2wsh',\n          'only accepts P2WSH inputs',\n        );\n\n        const scriptStack = bitcoin.script.decompile(input.witnessScript);\n        const pubkeys = scriptStack.filter(\n          (data) => Buffer.isBuffer(data) && secp256k1.publicKeyVerify(data),\n        );\n\n        await Promise.all(\n          pubkeys.map(async (key) => {\n            // create address using pubkey\n            const { address: addressString } = bitcoin.payments.p2wpkh({\n              pubkey: key as Buffer,\n              network: this._network,\n            });\n\n            // Retrieve address object from wallet using address\n            const address: Address = await this.quickFindAddress([\n              addressString,\n            ]);\n\n            // exit if address doesn't exist in wallet\n            if (!address) return;\n\n            // derive keypair\n            const keyPair = await this.getMethod('keyPair')(\n              address.derivationPath,\n            );\n\n            // sign PSBT using keypair\n            psbt.signInput(i, keyPair);\n          }),\n        );\n      }),\n    );\n\n    psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!\n    return psbt.toBase64();\n  }\n\n  /**\n   * Finalize the inputs of a PSBT. If the transaction is fully signed, it will\n   * produce a network serialized transaction which can be broadcast with sendrawtransaction\n   * https://developer.bitcoin.org/reference/rpc/finalizepsbt.html\n   * @param psbt a base64 encoded psbt string\n   * @returns a json object containing `psbt` in base64, `hex` for transaction and `complete` for if\n   * the transaction has a complete set of signatures\n   */\n  finalizePSBT(psbtString: string): finalizePSBTResponse {\n    const psbt = bitcoin.Psbt.fromBase64(psbtString);\n\n    try {\n      psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!\n      psbt.finalizeAllInputs();\n    } catch (error) {\n      return {\n        psbt: psbt.toBase64(),\n        complete: false,\n      };\n    }\n    return {\n      psbt: psbt.toBase64(),\n      hex: psbt.extractTransaction().toHex(),\n      complete: true,\n    };\n  }\n\n  async getUnusedAddress(change = false, numAddressPerCall = 100) {\n    const addressType = change ? CHANGE_ADDRESS : NONCHANGE_ADDRESS;\n    const key = change ? 'change' : 'nonChange';\n\n    const address = await this._getUsedUnusedAddresses(\n      numAddressPerCall,\n      addressType,\n    ).then(({ unusedAddress }) => unusedAddress[key]);\n    this._unusedAddressesBlacklist[address.address] = true;\n\n    return address;\n  }\n\n  async _getUsedUnusedAddresses(numAddressPerCall = 100, addressType) {\n    const usedAddresses = [];\n    const addressCountMap = { change: 0, nonChange: 0 };\n    const unusedAddressMap = { change: null, nonChange: null };\n\n    let addrList;\n    let addressIndex = 0;\n    let changeAddresses: Address[] = [];\n    let nonChangeAddresses: Address[] = [];\n\n    /* eslint-disable no-unmodified-loop-condition */\n    while (\n      (addressType === NONCHANGE_OR_CHANGE_ADDRESS &&\n        (addressCountMap.change < ADDRESS_GAP ||\n          addressCountMap.nonChange < ADDRESS_GAP)) ||\n      (addressType === NONCHANGE_ADDRESS &&\n        addressCountMap.nonChange < ADDRESS_GAP) ||\n      (addressType === CHANGE_ADDRESS && addressCountMap.change < ADDRESS_GAP)\n    ) {\n      /* eslint-enable no-unmodified-loop-condition */\n      addrList = [];\n\n      if (\n        (addressType === NONCHANGE_OR_CHANGE_ADDRESS ||\n          addressType === CHANGE_ADDRESS) &&\n        addressCountMap.change < ADDRESS_GAP\n      ) {\n        // Scanning for change addr\n        changeAddresses = await this.client.wallet.getAddresses(\n          addressIndex,\n          numAddressPerCall,\n          true,\n        );\n        addrList = addrList.concat(changeAddresses);\n      } else {\n        changeAddresses = [];\n      }\n\n      if (\n        (addressType === NONCHANGE_OR_CHANGE_ADDRESS ||\n          addressType === NONCHANGE_ADDRESS) &&\n        addressCountMap.nonChange < ADDRESS_GAP\n      ) {\n        // Scanning for non change addr\n        nonChangeAddresses = await this.quickGetAddresses(\n          addressIndex,\n          numAddressPerCall,\n          false,\n        );\n        addrList = addrList.concat(nonChangeAddresses);\n      }\n\n      const transactionCounts = await this.getMethod(\n        'getAddressTransactionCounts',\n      )(addrList);\n\n      for (const address of addrList) {\n        const isUsed =\n          transactionCounts[address.address] > 0 ||\n          this._unusedAddressesBlacklist[address.address];\n        const isChangeAddress = changeAddresses.find(\n          (a) => address.address === a.address,\n        );\n        const key = isChangeAddress ? 'change' : 'nonChange';\n\n        if (isUsed) {\n          usedAddresses.push(address);\n          addressCountMap[key] = 0;\n          unusedAddressMap[key] = null;\n        } else {\n          addressCountMap[key]++;\n\n          if (!unusedAddressMap[key]) {\n            unusedAddressMap[key] = address;\n          }\n        }\n      }\n\n      addressIndex += numAddressPerCall;\n    }\n\n    let firstUnusedAddress;\n    const indexNonChange = unusedAddressMap.nonChange\n      ? unusedAddressMap.nonChange.index\n      : Infinity;\n    const indexChange = unusedAddressMap.change\n      ? unusedAddressMap.change.index\n      : Infinity;\n\n    if (indexNonChange <= indexChange)\n      firstUnusedAddress = unusedAddressMap.nonChange;\n    else firstUnusedAddress = unusedAddressMap.change;\n\n    return {\n      usedAddresses,\n      unusedAddress: unusedAddressMap,\n      firstUnusedAddress,\n    };\n  }\n\n  async sendSweepTransactionWithSetOutputs(\n    externalChangeAddress: string,\n    feePerByte: number,\n    _outputs: Output[],\n    fixedInputs: Input[],\n  ): Promise<Transaction<bT.Transaction>> {\n    const { hex, fee } = await this._buildSweepTransaction(\n      externalChangeAddress,\n      feePerByte,\n      _outputs,\n      fixedInputs,\n    );\n    await this.getMethod('sendRawTransaction')(hex);\n    return normalizeTransactionObject(\n      decodeRawTransaction(hex, this._network),\n      fee,\n    );\n  }\n\n  async _buildSweepTransaction(\n    externalChangeAddress: string,\n    feePerByte: number,\n    _outputs: Output[] = [],\n    fixedInputs: Input[],\n  ) {\n    const _feePerByte =\n      feePerByte ||\n      (await this.getMethod('getFeePerByte')()) ||\n      FEE_PER_BYTE_FALLBACK;\n    const inputs: Input[] = [];\n    const outputs: Output[] = [];\n    try {\n      const inputsForAmount = await this.getMethod('getInputsForAmount')(\n        _outputs,\n        _feePerByte,\n        fixedInputs,\n        100,\n        true,\n      );\n      if (inputsForAmount.change) {\n        throw Error('There should not be any change for sweeping transaction');\n      }\n      inputs.push(...(inputsForAmount.inputs || []));\n      outputs.push(...(inputsForAmount.outputs || []));\n    } catch (e) {\n      if (fixedInputs.length === 0) {\n        throw Error(\n          `Inputs for amount doesn't exist and no fixedInputs provided`,\n        );\n      }\n\n      const inputsForAmount = await this._getInputForAmountWithoutUtxoCheck(\n        _outputs,\n        _feePerByte,\n        fixedInputs,\n      );\n      inputs.push(\n        ...(inputsForAmount.inputs.map((utxo) => Input.fromUTXO(utxo)) || []),\n      );\n      outputs.push(...(inputsForAmount.outputs || []));\n    }\n    _outputs.forEach((output) => {\n      const spliceIndex = outputs.findIndex(\n        (sweepOutput: Output) => output.value === sweepOutput.value,\n      );\n      outputs.splice(spliceIndex, 1);\n    });\n    _outputs.push({\n      to: externalChangeAddress,\n      value: outputs[0].value,\n    });\n    return this._buildTransactionWithoutUtxoCheck(\n      _outputs,\n      _feePerByte,\n      inputs,\n    );\n  }\n\n  _getInputForAmountWithoutUtxoCheck(\n    _outputs: Output[],\n    _feePerByte: number,\n    fixedInputs: Input[],\n  ): {\n    inputs: bT.UTXO[];\n    outputs: { value: number; id?: string }[];\n    fee: number;\n    change: { value: number; id?: string };\n  } {\n    const utxoBalance = fixedInputs.reduce((a, b) => a + (b['value'] || 0), 0);\n    const outputBalance = _outputs.reduce((a, b) => a + (b['value'] || 0), 0);\n    const amountToSend =\n      utxoBalance -\n      _feePerByte * ((_outputs.length + 1) * 39 + fixedInputs.length * 153); // todo better calculation\n\n    const targets = _outputs.map((target, i) => ({\n      id: 'main',\n      value: target.value,\n    }));\n    if (amountToSend - outputBalance > 0) {\n      targets.push({ id: 'main', value: amountToSend - outputBalance });\n    }\n\n    return selectCoins(\n      fixedInputs,\n      targets,\n      Math.ceil(_feePerByte),\n      fixedInputs,\n    );\n  }\n\n  async _buildTransactionWithoutUtxoCheck(\n    outputs: Output[],\n    feePerByte: number,\n    fixedInputs: Input[],\n  ) {\n    const network = this._network;\n\n    const { fee } = this._getInputForAmountWithoutUtxoCheck(\n      outputs,\n      feePerByte,\n      fixedInputs,\n    );\n    const inputs = fixedInputs;\n\n    const txb = new bitcoin.TransactionBuilder(network);\n\n    for (const output of outputs) {\n      const to = output.to; // Allow for OP_RETURN\n      txb.addOutput(to, output.value);\n    }\n\n    const prevOutScriptType = 'p2wpkh';\n\n    for (let i = 0; i < inputs.length; i++) {\n      const wallet = await this.getMethod('getWalletAddress')(\n        inputs[i].address,\n      );\n      const keyPair = await this.getMethod('keyPair')(wallet.derivationPath);\n      const paymentVariant = this.getMethod('getPaymentVariantFromPublicKey')(\n        keyPair.publicKey,\n      );\n\n      txb.addInput(inputs[i].txid, inputs[i].vout, 0, paymentVariant.output);\n    }\n\n    for (let i = 0; i < inputs.length; i++) {\n      const wallet = await this.getMethod('getWalletAddress')(\n        inputs[i].address,\n      );\n      const keyPair = await this.getMethod('keyPair')(wallet.derivationPath);\n      const paymentVariant = this.getMethod('getPaymentVariantFromPublicKey')(\n        keyPair.publicKey,\n      );\n      const needsWitness = true;\n\n      const signParams = {\n        prevOutScriptType,\n        vin: i,\n        keyPair,\n        witnessValue: 0,\n      };\n\n      if (needsWitness) {\n        signParams.witnessValue = inputs[i].value;\n      }\n\n      txb.sign(signParams);\n    }\n\n    return { hex: txb.build().toHex(), fee };\n  }\n\n  /**\n   * quickGetAddresses is an optimized version of getAddresses.\n   * It removes the call to `asyncSetImmediate()`, speeding up the function by a factor of 6x.\n   *\n   * @param startingIndex\n   * @param numAddresses\n   * @param change\n   * @returns {Promise<Address[]>}\n   */\n  async quickGetAddresses(\n    startingIndex = 0,\n    numAddresses = 1,\n    change = false,\n  ): Promise<Address[]> {\n    if (numAddresses < 1) {\n      throw new Error('You must return at least one address');\n    }\n\n    const addresses = [];\n    const lastIndex = startingIndex + numAddresses;\n    const changeVal = change ? '1' : '0';\n\n    // Original wallet provider is fetched to get the base derivation path\n    const originalProvider = this.client.getProviderForMethod('getAddresses');\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const baseDerivationPath = (originalProvider as any)\n      ._baseDerivationPath as string;\n\n    const getDerivationPathAddressFn: (\n      path: string,\n    ) => Promise<Address> = this.client.getMethod('getDerivationPathAddress');\n\n    for (\n      let currentIndex = startingIndex;\n      currentIndex < lastIndex;\n      currentIndex++\n    ) {\n      const subPath = changeVal + '/' + currentIndex;\n      const path = baseDerivationPath + '/' + subPath;\n      const addressObject = await getDerivationPathAddressFn(path);\n      addresses.push(addressObject);\n    }\n\n    return addresses;\n  }\n\n  /**\n   * quickFindAddress is an optimized version of findAddress.\n   *\n   * It searches through both change and non-change addresses each iteration.\n   *\n   * This is in contrast to the original findAddress function which searches\n   * through all non-change addresses before moving on to change addresses.\n   *\n   * @param addresses\n   * @returns {Promise<Address[]>}\n   */\n  async quickFindAddress(addresses: string[]): Promise<Address> {\n    const addressesPerCall = 20;\n    let index = 0;\n\n    while (index < this._maxAddressesToDerive) {\n      const walletNonChangeAddresses = await this.quickGetAddresses(\n        index,\n        addressesPerCall,\n        true,\n      );\n      const walletChangeAddresses = await this.quickGetAddresses(\n        index,\n        addressesPerCall,\n        false,\n      );\n      const walletAddresses = [\n        ...walletNonChangeAddresses,\n        ...walletChangeAddresses,\n      ];\n      const walletAddress = walletAddresses.find((walletAddr) =>\n        addresses.find((addr) => walletAddr.address === addr),\n      );\n\n      if (walletAddress) {\n        // Increment max addresses to derive by 100 if found within 100 addresses of maxAddressesToDerive\n        this._maxAddressesToDerive = Math.max(\n          this._maxAddressesToDerive,\n          index + 100,\n        );\n        return walletAddress;\n      }\n      index += addressesPerCall;\n    }\n  }\n}\n"],"names":["bitcoin","FEE_PER_BYTE_FALLBACK","ADDRESS_GAP","NONCHANGE_ADDRESS","CHANGE_ADDRESS","NONCHANGE_OR_CHANGE_ADDRESS","BitcoinWalletProvider","Provider","buildSweepTransactionWithSetOutputs","externalChangeAddress","feePerByte","_outputs","fixedInputs","_buildSweepTransaction","getUnusedAddressesBlacklist","_unusedAddressesBlacklist","setUnusedAddressesBlacklist","unusedAddressesBlacklist","setMaxAddressesToDerive","maxAddressesToDerive","_maxAddressesToDerive","getMaxAddressesToDerive","_createMultisigPayment","m","pubkeys","length","Error","p2ms","payments","map","key","Buffer","from","network","_network","p2wsh","redeem","createMultisig","address","redeemScript","output","toString","buildMultisigPSBT","inputs","outputs","assert","every","input","scriptPubKey","psbt","Psbt","forEach","addInput","hash","txid","index","vout","witnessUtxo","script","value","witnessScript","addOutput","to","toBase64","walletProcessPSBT","psbtString","fromBase64","Promise","all","data","i","getInputType","slice","scriptStack","decompile","filter","isBuffer","secp256k1","publicKeyVerify","addressString","p2wpkh","pubkey","quickFindAddress","keyPair","getMethod","derivationPath","signInput","validateSignaturesOfAllInputs","finalizePSBT","finalizeAllInputs","error","complete","hex","extractTransaction","toHex","getUnusedAddress","change","numAddressPerCall","addressType","_getUsedUnusedAddresses","then","unusedAddress","usedAddresses","addressCountMap","nonChange","unusedAddressMap","addrList","addressIndex","changeAddresses","nonChangeAddresses","client","wallet","getAddresses","concat","quickGetAddresses","transactionCounts","isUsed","isChangeAddress","find","a","push","firstUnusedAddress","indexNonChange","Infinity","indexChange","sendSweepTransactionWithSetOutputs","fee","normalizeTransactionObject","decodeRawTransaction","_feePerByte","inputsForAmount","e","_getInputForAmountWithoutUtxoCheck","utxo","Input","fromUTXO","spliceIndex","findIndex","sweepOutput","splice","_buildTransactionWithoutUtxoCheck","utxoBalance","reduce","b","outputBalance","amountToSend","targets","target","id","selectCoins","Math","ceil","txb","TransactionBuilder","prevOutScriptType","paymentVariant","publicKey","needsWitness","signParams","vin","witnessValue","sign","build","startingIndex","numAddresses","addresses","lastIndex","changeVal","originalProvider","getProviderForMethod","baseDerivationPath","_baseDerivationPath","getDerivationPathAddressFn","currentIndex","subPath","path","addressObject","addressesPerCall","walletNonChangeAddresses","walletChangeAddresses","walletAddresses","walletAddress","walletAddr","addr","max","constructor"],"mappings":"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"}
+//# sourceMappingURL=BitcoinWalletProvider.js.map