@atomicfinance/bitcoin-wallet-provider 2.5.1 → 3.0.0

package/dist/BitcoinWalletProvider.js

@@ -22,388 +22,479 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const provider_1 = __importDefault(require("@atomicfinance/provider"));
+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 bitcoin_utils_1 = require("@liquality/bitcoin-utils");
-const assert_1 = __importDefault(require("assert"));
+const utils_1 = require("@atomicfinance/utils");
 const bitcoin = __importStar(require("bitcoinjs-lib"));
-const secp256k1_1 = __importDefault(require("secp256k1"));
-const FEE_PER_BYTE_FALLBACK = 5;
+const memoizee_1 = __importDefault(require("memoizee"));
 const ADDRESS_GAP = 20;
 const NONCHANGE_ADDRESS = 0;
 const CHANGE_ADDRESS = 1;
 const NONCHANGE_OR_CHANGE_ADDRESS = 2;
-class BitcoinWalletProvider extends provider_1.default {
-    constructor(network) {
-        super();
-        this._network = network;
-        this._unusedAddressesBlacklist = {};
-        this._maxAddressesToDerive = 5000;
-    }
-    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) {
-        assert_1.default(inputs.length > 0, 'no inputs found');
-        assert_1.default(outputs.length > 0, 'no outputs found');
-        const p2wsh = this._createMultisigPayment(m, pubkeys);
-        // Verify pubkeyhash for all inputs matches the p2wsh hash
-        assert_1.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,
+        getDerivationCache() {
+            return this._derivationCache;
+        }
+        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`);
+            }
+            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 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) => {
-            assert_1.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_1.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();
+            return targets;
         }
-        catch (error) {
-            return {
-                psbt: psbt.toBase64(),
-                complete: false,
-            };
+        async buildTransaction(output, feePerByte) {
+            return this._buildTransaction([output], feePerByte);
         }
-        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 = [];
-            }
-            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);
+        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;
+            // 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 {
-                    addressCountMap[key]++;
-                    if (!unusedAddressMap[key]) {
-                        unusedAddressMap[key] = address;
+                    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 bitcoin_utils_1.normalizeTransactionObject(bitcoin_utils_1.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,
+                });
+            }
+            else if (this._addressType === types_1.bitcoin.AddressType.BECH32) {
+                return bitcoin.payments.p2wpkh({
+                    pubkey: publicKey,
+                    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`);
+        async getDerivationPathAddress(path) {
+            if (path in this._derivationCache) {
+                return this._derivationCache[path];
             }
-            const inputsForAmount = await this._getInputForAmountWithoutUtxoCheck(_outputs, _feePerByte, fixedInputs);
-            inputs.push(...(inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo)) || []));
-            outputs.push(...(inputsForAmount.outputs || []));
+            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;
         }
-        _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 });
+        /**
+         * 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;
         }
-        return bitcoin_utils_1.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);
+        /**
+         * 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;
+            }
         }
-        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);
+        async getUsedAddresses(numAddressPerCall = 100) {
+            return this._getUsedUnusedAddresses(numAddressPerCall, AddressSearchType.EXTERNAL_OR_CHANGE).then(({ usedAddresses }) => usedAddresses);
         }
-        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);
-            const needsWitness = true;
-            const signParams = {
-                prevOutScriptType,
-                vin: i,
-                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[i].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');
         }
     }
-}
-exports.default = BitcoinWalletProvider;
+    return BitcoinWalletProvider;
+};
 //# sourceMappingURL=BitcoinWalletProvider.js.map