@atomicfinance/bitcoin-wallet-provider 3.5.3 → 3.6.0

package/.turbo/turbo-build.log

@@ -1 +0,0 @@
-

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atomicfinance/bitcoin-wallet-provider
 
+## 3.6.0
+
+### Minor Changes
+
+- cbf35c5: - **BREAKING CHANGE**: Migrated from `@node-lightning` packages to `@node-dlc` packages
+  - Updated all imports from `@node-lightning/*` to `@node-dlc/*`
+  - Update @node-dlc 0.24.0 and Node 18+
+  - Upgraded Node.js requirement to v18+
+  - Updated cfd-dlc-js to v0.0.51 and cfd-js to v0.3.13
+  - Removed unused dependencies: lerna, mocha-webpack
+
+### Patch Changes
+
+- Updated dependencies [cbf35c5]
+  - @atomicfinance/types@3.6.0
+  - @atomicfinance/bitcoin-utils@3.6.0
+  - @atomicfinance/provider@3.6.0
+
 ## 3.5.3
 
 ### Patch Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atomicfinance/bitcoin-wallet-provider",
   "umdName": "BitcoinWalletProvider",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "Bitcoin Abstraction Layer Wallet Provider",
   "author": "Atomic Finance <info@atomic.finance>",
   "homepage": "",
@@ -15,10 +15,10 @@
     "lint:fix": "../../node_modules/.bin/eslint --fix --ignore-path ../../.eslintignore  -c ../../.eslintrc.js ."
   },
   "dependencies": {
-    "@atomicfinance/bitcoin-utils": "^3.5.3",
-    "@atomicfinance/provider": "^3.5.3",
-    "@atomicfinance/types": "^3.5.3",
-    "@node-dlc/core": "0.23.6",
+    "@atomicfinance/bitcoin-utils": "^3.6.0",
+    "@atomicfinance/provider": "^3.6.0",
+    "@atomicfinance/types": "^3.6.0",
+    "@node-dlc/core": "0.24.0",
     "bitcoin-networks": "^1.0.0",
     "bitcoinjs-lib": "5.2.0",
     "lodash": "^4.17.20",

package/.turbo/turbo-test.log

@@ -1 +0,0 @@
-

package/lib/BitcoinWalletProvider.js

@@ -1,596 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (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 core_1 = require("@node-dlc/core");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
-const memoizee_1 = __importDefault(require("memoizee"));
-const ADDRESS_GAP = 30;
-const NONCHANGE_ADDRESS = 0;
-const CHANGE_ADDRESS = 1;
-const NONCHANGE_OR_CHANGE_ADDRESS = 2;
-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, addressIndex = 0, changeAddressIndex = 0, } = 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._addressIndex = addressIndex;
-            this._changeAddressIndex = changeAddressIndex;
-            this._derivationCache = {};
-            this._unusedAddressesBlacklist = {};
-            this._maxAddressesToDerive = 5000;
-        }
-        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: (0, 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 (0, bitcoin_utils_1.normalizeTransactionObject)((0, 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((0, utils_1.addressToString)(externalChangeAddress), feePerByte);
-            await this.getMethod('sendRawTransaction')(hex);
-            return (0, bitcoin_utils_1.normalizeTransactionObject)((0, 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]);
-            }
-            // 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 (0, bitcoin_utils_1.normalizeTransactionObject)((0, 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 = this._addressIndex;
-            let changeAddressIndex = this._changeAddressIndex;
-            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(changeAddressIndex, 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;
-                changeAddressIndex += 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,
-            };
-        }
-        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,
-                });
-            }
-        }
-        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;
-        }
-        /**
-         * 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;
-        }
-        /**
-         * 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);
-        }
-        async withCachedUtxos(func) {
-            const originalGetMethod = this.getMethod;
-            const memoizedGetFeePerByte = (0, memoizee_1.default)(this.getMethod('getFeePerByte'), {
-                primitive: true,
-            });
-            const memoizedGetUnspentTransactions = (0, memoizee_1.default)(this.getMethod('getUnspentTransactions'), { primitive: true });
-            const memoizedGetAddressTransactionCounts = (0, 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);
-            };
-            const result = await func.bind(this)();
-            this.getMethod = originalGetMethod;
-            return result;
-        }
-        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;
-            }
-        }
-        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;
-        }
-        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 = (0, 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 } = (0, 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;
-            }
-            throw new errors_1.InsufficientBalanceError('Not enough balance');
-        }
-        async getInputsForDualFunding(collaterals, feePerByte, fixedInputs = [], numAddressPerCall = 100) {
-            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 = (0, 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 (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 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`);
-                }
-                const { fee, inputs } = (0, core_1.dualFundingCoinSelect)(utxos, collaterals.map((c) => BigInt(c)), BigInt(feePerByte));
-                if (inputs.length > 0) {
-                    return {
-                        inputs,
-                        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;
-            }
-            throw new errors_1.InsufficientBalanceError('Not enough balance for dual funding');
-        }
-    }
-    return BitcoinWalletProvider;
-};
-//# sourceMappingURL=BitcoinWalletProvider.js.map

package/lib/index.js

@@ -1,9 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var BitcoinWalletProvider_1 = require("./BitcoinWalletProvider");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(BitcoinWalletProvider_1).default; } });
-//# sourceMappingURL=index.js.map