@yaswap/bitcoin 3.3.7 → 3.4.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @yaswap/bitcoin
 
+## 3.4.1
+
+### Patch Changes
+
+- Support HD wallet logic
+- Updated dependencies
+  - @yaswap/client@3.4.1
+  - @yaswap/errors@3.4.1
+  - @yaswap/types@3.4.1
+  - @yaswap/utils@3.4.1
+
+## 3.4.0
+
+### Minor Changes
+
+- Support HD wallet logic
+
+### Patch Changes
+
+- Updated dependencies
+  - @yaswap/client@3.4.0
+  - @yaswap/errors@3.4.0
+  - @yaswap/types@3.4.0
+  - @yaswap/utils@3.4.0
+
 ## 3.3.7
 
 ### Patch Changes

package/dist/lib/index.d.ts

@@ -11,7 +11,7 @@ export { BitcoinSwapEsploraProvider } from './swap/BitcoinSwapEsploraProvider';
 export { BitcoinSwapRpcProvider } from './swap/BitcoinSwapRpcProvider';
 export * as BitcoinTypes from './types';
 export * as BitcoinUtils from './utils';
-export { BitcoinBaseWalletProvider } from './wallet/BitcoinBaseWallet';
+export { AddressSearchType, BitcoinBaseWalletProvider, NUMBER_ADDRESS_LIMIT } from './wallet/BitcoinBaseWallet';
 export { BitcoinHDWalletProvider } from './wallet/BitcoinHDWallet';
 export { BitcoinNodeWalletProvider } from './wallet/BitcoinNodeWallet';
 export { BitcoinSingleWallet } from './wallet/BitcoinSingleWallet';

package/dist/lib/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinSingleWallet = exports.BitcoinNodeWalletProvider = exports.BitcoinHDWalletProvider = exports.BitcoinBaseWalletProvider = exports.BitcoinUtils = exports.BitcoinTypes = exports.BitcoinSwapRpcProvider = exports.BitcoinSwapEsploraProvider = exports.BitcoinSwapBaseProvider = exports.BitcoinNetworks = exports.BitcoinFeeApiProvider = exports.BitcoinJsonRpcProvider = exports.BitcoinJsonRpcBaseProvider = exports.BitcoinEsploraBatchBaseProvider = exports.BitcoinEsploraBaseProvider = exports.BitcoinEsploraApiProvider = exports.BitcoinBaseChainProvider = void 0;
+exports.BitcoinSingleWallet = exports.BitcoinNodeWalletProvider = exports.BitcoinHDWalletProvider = exports.NUMBER_ADDRESS_LIMIT = exports.BitcoinBaseWalletProvider = exports.AddressSearchType = exports.BitcoinUtils = exports.BitcoinTypes = exports.BitcoinSwapRpcProvider = exports.BitcoinSwapEsploraProvider = exports.BitcoinSwapBaseProvider = exports.BitcoinNetworks = exports.BitcoinFeeApiProvider = exports.BitcoinJsonRpcProvider = exports.BitcoinJsonRpcBaseProvider = exports.BitcoinEsploraBatchBaseProvider = exports.BitcoinEsploraBaseProvider = exports.BitcoinEsploraApiProvider = exports.BitcoinBaseChainProvider = void 0;
 var BitcoinBaseChainProvider_1 = require("./chain/BitcoinBaseChainProvider");
 Object.defineProperty(exports, "BitcoinBaseChainProvider", { enumerable: true, get: function () { return BitcoinBaseChainProvider_1.BitcoinBaseChainProvider; } });
 var BitcoinEsploraApiProvider_1 = require("./chain/esplora/BitcoinEsploraApiProvider");
@@ -49,7 +49,9 @@ Object.defineProperty(exports, "BitcoinSwapRpcProvider", { enumerable: true, get
 exports.BitcoinTypes = __importStar(require("./types"));
 exports.BitcoinUtils = __importStar(require("./utils"));
 var BitcoinBaseWallet_1 = require("./wallet/BitcoinBaseWallet");
+Object.defineProperty(exports, "AddressSearchType", { enumerable: true, get: function () { return BitcoinBaseWallet_1.AddressSearchType; } });
 Object.defineProperty(exports, "BitcoinBaseWalletProvider", { enumerable: true, get: function () { return BitcoinBaseWallet_1.BitcoinBaseWalletProvider; } });
+Object.defineProperty(exports, "NUMBER_ADDRESS_LIMIT", { enumerable: true, get: function () { return BitcoinBaseWallet_1.NUMBER_ADDRESS_LIMIT; } });
 var BitcoinHDWallet_1 = require("./wallet/BitcoinHDWallet");
 Object.defineProperty(exports, "BitcoinHDWalletProvider", { enumerable: true, get: function () { return BitcoinHDWallet_1.BitcoinHDWalletProvider; } });
 var BitcoinNodeWallet_1 = require("./wallet/BitcoinNodeWallet");

package/dist/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6EAA4E;AAAnE,oIAAA,wBAAwB,OAAA;AACjC,uFAAsF;AAA7E,sIAAA,yBAAyB,OAAA;AAClC,yFAAwF;AAA/E,wIAAA,0BAA0B,OAAA;AACnC,mGAAkG;AAAzF,kJAAA,+BAA+B,OAAA;AACxC,yFAAwF;AAA/E,wIAAA,0BAA0B,OAAA;AACnC,iFAAgF;AAAvE,gIAAA,sBAAsB,OAAA;AAC/B,qEAAoE;AAA3D,8HAAA,qBAAqB,OAAA;AAC9B,uCAA6C;AAApC,2GAAA,eAAe,OAAA;AACxB,0EAAyE;AAAhE,kIAAA,uBAAuB,OAAA;AAChC,gFAA+E;AAAtE,wIAAA,0BAA0B,OAAA;AACnC,wEAAuE;AAA9D,gIAAA,sBAAsB,OAAA;AAC/B,wDAAwC;AACxC,wDAAwC;AACxC,gEAAuE;AAA9D,8HAAA,yBAAyB,OAAA;AAClC,4DAAmE;AAA1D,0HAAA,uBAAuB,OAAA;AAChC,gEAAuE;AAA9D,8HAAA,yBAAyB,OAAA;AAClC,oEAAmE;AAA1D,0HAAA,mBAAmB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6EAA4E;AAAnE,oIAAA,wBAAwB,OAAA;AACjC,uFAAsF;AAA7E,sIAAA,yBAAyB,OAAA;AAClC,yFAAwF;AAA/E,wIAAA,0BAA0B,OAAA;AACnC,mGAAkG;AAAzF,kJAAA,+BAA+B,OAAA;AACxC,yFAAwF;AAA/E,wIAAA,0BAA0B,OAAA;AACnC,iFAAgF;AAAvE,gIAAA,sBAAsB,OAAA;AAC/B,qEAAoE;AAA3D,8HAAA,qBAAqB,OAAA;AAC9B,uCAA6C;AAApC,2GAAA,eAAe,OAAA;AACxB,0EAAyE;AAAhE,kIAAA,uBAAuB,OAAA;AAChC,gFAA+E;AAAtE,wIAAA,0BAA0B,OAAA;AACnC,wEAAuE;AAA9D,gIAAA,sBAAsB,OAAA;AAC/B,wDAAwC;AACxC,wDAAwC;AACxC,gEAAgH;AAAvG,sHAAA,iBAAiB,OAAA;AAAE,8HAAA,yBAAyB,OAAA;AAAE,yHAAA,oBAAoB,OAAA;AAC3E,4DAAmE;AAA1D,0HAAA,uBAAuB,OAAA;AAChC,gEAAuE;AAA9D,8HAAA,yBAAyB,OAAA;AAClC,oEAAmE;AAA1D,0HAAA,mBAAmB,OAAA"}

package/dist/lib/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Network, TransactionRequest } from '@yaswap/types';
+import { Address, Network, TransactionRequest } from '@yaswap/types';
 import { ECPairInterface, Network as BitcoinJsLibNetwork } from 'bitcoinjs-lib';
 export * as BitcoinEsploraTypes from './chain/esplora/types';
 export * as BitcoinJsonRpcTypes from './chain/jsonRpc/types';
@@ -18,8 +18,18 @@ export interface BitcoinSingleWalletOptions extends BitcoinNodeWalletOptions {
 export interface BitcoinWalletProviderOptions extends BitcoinNodeWalletOptions {
     baseDerivationPath: string;
 }
+export interface RawExtendedPublicKey {
+    publicKey: Buffer;
+    chainCode: Buffer;
+}
+export interface RawExtendedPrivateKey {
+    privateKey: Buffer;
+    chainCode: Buffer;
+}
 export interface BitcoinHDWalletProviderOptions extends BitcoinWalletProviderOptions {
-    mnemonic: string;
+    mnemonic?: string;
+    extendedPublicKey?: RawExtendedPublicKey;
+    extendedPrivateKey?: RawExtendedPrivateKey;
 }
 export interface OutputTarget {
     address?: string;
@@ -86,6 +96,16 @@ export declare enum SwapMode {
 export declare type AddressTxCounts = {
     [index: string]: number;
 };
+export interface UsedUnusedAddressesResult {
+    usedAddresses: {
+        change: Address[];
+        external: Address[];
+    };
+    unusedAddress: {
+        change: Address | null;
+        external: Address | null;
+    };
+}
 export interface PsbtInputTarget {
     index: number;
     derivationPath: string;
@@ -96,6 +116,15 @@ export interface P2SHInput {
     vout: any;
     outputScript: Buffer;
 }
-export interface TransactionFixedInputRequest extends TransactionRequest {
+/**
+ * Options for Bitcoin sendTransaction and sendTransactionFixedInputs.
+ * Extends TransactionRequest with Bitcoin-specific options.
+ */
+export interface BitcoinSendTransactionOptions extends TransactionRequest {
+    /** Pre-selected UTXOs to use as inputs. When set, only these UTXOs are used (e.g. for sendTransactionFixedInputs). */
     inputs?: UTXO[];
+    /** When true, use a change address (internal branch) for the change output; when false, use a receiving address (external branch). Default: false. */
+    change?: boolean;
+    /** Maximum number of addresses to scan for UTXOs. Default: 40. */
+    addressLimit?: number;
 }

package/dist/lib/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../lib/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,6EAA6D;AAC7D,6EAA6D;AAC7D,+CAA6B;AAiF7B,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,gCAAiB,CAAA;IACjB,0CAA2B,CAAA;IAC3B,gCAAiB,CAAA;AACrB,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AAED,IAAY,QAIX;AAJD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,sCAA0B,CAAA;IAC1B,2BAAe,CAAA;AACnB,CAAC,EAJW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAInB"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../lib/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,6EAA6D;AAC7D,6EAA6D;AAC7D,+CAA6B;AA6F7B,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,gCAAiB,CAAA;IACjB,0CAA2B,CAAA;IAC3B,gCAAiB,CAAA;AACrB,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AAED,IAAY,QAIX;AAJD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,sCAA0B,CAAA;IAC1B,2BAAe,CAAA;AACnB,CAAC,EAJW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAInB"}

package/dist/lib/wallet/BitcoinBaseWallet.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
 import { Chain, Wallet } from '@yaswap/client';
-import { Address, AddressType, Asset, Transaction, TransactionRequest, CreateTokenTransaction } from '@yaswap/types';
+import { Address, AddressType, Asset, Transaction, CreateTokenTransaction } from '@yaswap/types';
 import { BIP32Interface } from 'bip32';
 import { payments } from 'bitcoinjs-lib';
 import { BitcoinBaseChainProvider } from '../chain/BitcoinBaseChainProvider';
-import { AddressType as BtcAddressType, BitcoinNetwork, BitcoinWalletProviderOptions, Input, OutputTarget, P2SHInput, PsbtInputTarget, Transaction as BtcTransaction, UTXO } from '../types';
+import { AddressType as BtcAddressType, BitcoinNetwork, BitcoinSendTransactionOptions, BitcoinWalletProviderOptions, OutputTarget, P2SHInput, PsbtInputTarget, Transaction as BtcTransaction, UsedUnusedAddressesResult, UTXO } from '../types';
 import { CoinSelectTarget } from '../utils';
+export declare const NUMBER_ADDRESS_LIMIT = 40;
 export declare enum AddressSearchType {
     EXTERNAL = 0,
     CHANGE = 1,
@@ -22,7 +23,7 @@ export declare abstract class BitcoinBaseWalletProvider<T extends BitcoinBaseCha
     constructor(options: BitcoinWalletProviderOptions, chainProvider?: Chain<T>);
     protected onChainProviderUpdate(chainProvider: Chain<T>): void;
     protected abstract baseDerivationNode(): Promise<BIP32Interface>;
-    protected abstract buildTransaction(targets: OutputTarget[], feePerByte?: number, fixedInputs?: Input[]): Promise<{
+    protected abstract buildTransaction(targets: OutputTarget[], feePerByte?: number, fixedUtxos?: UTXO[], change?: boolean, addressLimit?: number): Promise<{
         hex: string;
         fee: number;
     }>;
@@ -33,35 +34,45 @@ export declare abstract class BitcoinBaseWalletProvider<T extends BitcoinBaseCha
     abstract signPSBT(data: string, inputs: PsbtInputTarget[]): Promise<string>;
     abstract signBatchP2SHTransaction(inputs: P2SHInput[], addresses: string, tx: any, lockTime?: number, segwit?: boolean): Promise<Buffer[]>;
     getDerivationCache(): DerivationCache;
-    getUnusedAddress(change?: boolean): Promise<Address>;
-    getUsedAddresses(): Promise<Address[]>;
+    /**
+     * Get one unused receiving or change address.
+     *
+     * @param change       When true, search change addresses; otherwise external/receiving.
+     * @param addressLimit Maximum number of address indexes to scan (per branch). Defaults to NUMBER_ADDRESS_LIMIT.
+     * @returns The first unused address found or null if none within the limit.
+     */
+    getUnusedAddress(change?: boolean, addressLimit?: number): Promise<Address>;
+    /**
+     * Get used addresses.
+     *
+     * @param addressType  Which branch to scan: external, change or both. Defaults to both.
+     * @param addressLimit Maximum number of address indexes to scan (per branch). Defaults to NUMBER_ADDRESS_LIMIT.
+     * @returns List of used addresses for the requested branch(es).
+     */
+    getUsedAddresses(addressType?: AddressSearchType, addressLimit?: number): Promise<Address[]>;
     getAddresses(startingIndex?: number, numAddresses?: number, change?: boolean): Promise<Address[]>;
-    createToken(txRequest: CreateTokenTransaction): Promise<null>;
-    sendTransaction(options: TransactionRequest): Promise<Transaction<BtcTransaction>>;
-    sendBatchTransaction(transactions: TransactionRequest[]): Promise<Transaction<BtcTransaction>[]>;
+    createToken(_txRequest: CreateTokenTransaction): Promise<null>;
+    sendTransactionFixedInputs(options: BitcoinSendTransactionOptions): Promise<Transaction<BtcTransaction>>;
+    sendTransaction(options: BitcoinSendTransactionOptions): Promise<Transaction<BtcTransaction>>;
+    sendBatchTransaction(transactions: BitcoinSendTransactionOptions[]): Promise<Transaction<BtcTransaction>[]>;
     sendSweepTransaction(externalChangeAddress: AddressType, _asset: Asset, feePerByte: number): Promise<Transaction<BtcTransaction>>;
     updateTransactionFee(tx: Transaction<BtcTransaction> | string, newFeePerByte: number): Promise<Transaction<BtcTransaction>>;
-    getTotalFees(transactions: TransactionRequest[], max: boolean): Promise<any>;
-    protected _sendTransaction(transactions: OutputTarget[], feePerByte?: number): Promise<Transaction<BtcTransaction>>;
-    protected findAddress(addresses: string[], change?: boolean): Promise<Address>;
+    getTotalFees(transactions: BitcoinSendTransactionOptions[], max: boolean): Promise<any>;
+    protected _sendTransaction(transactions: OutputTarget[], feePerByte?: number, change?: boolean, addressLimit?: number): Promise<Transaction<BtcTransaction>>;
+    protected findAddress(addresses: string[], change?: boolean, addressLimit?: number): Promise<Address>;
     getWalletAddress(address: string): Promise<Address>;
     protected getDerivationPathAddress(path: string): Promise<Address>;
-    protected _getUsedUnusedAddresses(addressType: AddressSearchType): Promise<{
-        usedAddresses: Address[];
-        unusedAddress: {
-            change: Address;
-            external: Address;
-        };
-    }>;
+    getUsedUnusedAddresses(addressType: AddressSearchType, addressLimit?: number, gapLimit?: number): Promise<UsedUnusedAddressesResult>;
     protected withCachedUtxos(func: () => any): Promise<any>;
-    protected getTotalFee(opts: TransactionRequest, max: boolean): Promise<number>;
-    protected getInputsForAmount(_targets: OutputTarget[], feePerByte?: number, fixedInputs?: Input[], sweep?: boolean): Promise<{
+    getTotalFeeFixedInputs(opts: BitcoinSendTransactionOptions, max: boolean): Promise<number>;
+    protected getTotalFee(opts: BitcoinSendTransactionOptions, max: boolean): Promise<number>;
+    protected getInputsForAmount(_targets: OutputTarget[], feePerByte?: number, fixedUtxos?: UTXO[], sweep?: boolean, addressLimit?: number, change?: boolean): Promise<{
         inputs: UTXO[];
         change: CoinSelectTarget;
         outputs: CoinSelectTarget[];
         fee: number;
     }>;
-    protected sendOptionsToOutputs(transactions: TransactionRequest[]): OutputTarget[];
+    protected sendOptionsToOutputs(transactions: BitcoinSendTransactionOptions[]): OutputTarget[];
     protected getAddressFromPublicKey(publicKey: Buffer): string;
     protected getPaymentVariantFromPublicKey(publicKey: Buffer): payments.Payment;
 }

package/dist/lib/wallet/BitcoinBaseWallet.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinBaseWalletProvider = exports.AddressSearchType = void 0;
+exports.BitcoinBaseWalletProvider = exports.AddressSearchType = exports.NUMBER_ADDRESS_LIMIT = void 0;
 const client_1 = require("@yaswap/client");
 const errors_1 = require("@yaswap/errors");
 const types_1 = require("@yaswap/types");
@@ -22,7 +22,7 @@ const memoizee_1 = __importDefault(require("memoizee"));
 const types_2 = require("../types");
 const utils_2 = require("../utils");
 const utils_3 = __importDefault(require("@yaswap/bitcoinselect/utils"));
-const NUMBER_ADDRESS_LIMIT = 1;
+exports.NUMBER_ADDRESS_LIMIT = 40;
 var AddressSearchType;
 (function (AddressSearchType) {
     AddressSearchType[AddressSearchType["EXTERNAL"] = 0] = "EXTERNAL";
@@ -48,16 +48,38 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
     getDerivationCache() {
         return this._derivationCache;
     }
-    getUnusedAddress(change = false) {
+    /**
+     * Get one unused receiving or change address.
+     *
+     * @param change       When true, search change addresses; otherwise external/receiving.
+     * @param addressLimit Maximum number of address indexes to scan (per branch). Defaults to NUMBER_ADDRESS_LIMIT.
+     * @returns The first unused address found or null if none within the limit.
+     */
+    getUnusedAddress(change = false, addressLimit = exports.NUMBER_ADDRESS_LIMIT) {
         return __awaiter(this, void 0, void 0, function* () {
             const addressType = change ? AddressSearchType.CHANGE : AddressSearchType.EXTERNAL;
             const key = change ? 'change' : 'external';
-            return this._getUsedUnusedAddresses(addressType).then(({ unusedAddress }) => unusedAddress[key]);
+            const { unusedAddress } = yield this.getUsedUnusedAddresses(addressType, addressLimit);
+            return unusedAddress[key];
         });
     }
-    getUsedAddresses() {
+    /**
+     * Get used addresses.
+     *
+     * @param addressType  Which branch to scan: external, change or both. Defaults to both.
+     * @param addressLimit Maximum number of address indexes to scan (per branch). Defaults to NUMBER_ADDRESS_LIMIT.
+     * @returns List of used addresses for the requested branch(es).
+     */
+    getUsedAddresses(addressType = AddressSearchType.EXTERNAL_OR_CHANGE, addressLimit = exports.NUMBER_ADDRESS_LIMIT) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._getUsedUnusedAddresses(AddressSearchType.EXTERNAL_OR_CHANGE).then(({ usedAddresses }) => usedAddresses);
+            const result = yield this.getUsedUnusedAddresses(addressType, addressLimit);
+            if (addressType === AddressSearchType.EXTERNAL) {
+                return result.usedAddresses.external;
+            }
+            if (addressType === AddressSearchType.CHANGE) {
+                return result.usedAddresses.change;
+            }
+            return [...result.usedAddresses.change, ...result.usedAddresses.external];
         });
     }
     getAddresses(startingIndex = 0, numAddresses = 1, change = false) {
@@ -78,19 +100,38 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
             return addresses;
         });
     }
-    createToken(txRequest) {
+    createToken(_txRequest) {
         return __awaiter(this, void 0, void 0, function* () {
             return null;
         });
     }
+    sendTransactionFixedInputs(options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const targets = this.sendOptionsToOutputs([options]);
+            const fixedUtxos = (_a = options.inputs) !== null && _a !== void 0 ? _a : [];
+            const change = (_b = options.change) !== null && _b !== void 0 ? _b : false;
+            const addressLimit = (_c = options.addressLimit) !== null && _c !== void 0 ? _c : exports.NUMBER_ADDRESS_LIMIT;
+            const { hex, fee } = yield this.buildTransaction(targets, options.fee, fixedUtxos, change, addressLimit);
+            yield this.chainProvider.sendRawTransaction(hex);
+            return (0, utils_2.normalizeTransactionObject)((0, utils_2.decodeRawTransaction)(hex, this._network), fee);
+        });
+    }
     sendTransaction(options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            return this._sendTransaction(this.sendOptionsToOutputs([options]), options.fee);
+            const change = (_a = options.change) !== null && _a !== void 0 ? _a : false;
+            const addressLimit = (_b = options.addressLimit) !== null && _b !== void 0 ? _b : exports.NUMBER_ADDRESS_LIMIT;
+            return this._sendTransaction(this.sendOptionsToOutputs([options]), options.fee, change, addressLimit);
         });
     }
     sendBatchTransaction(transactions) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            return [yield this._sendTransaction(this.sendOptionsToOutputs(transactions))];
+            const first = transactions[0];
+            const change = (_a = first === null || first === void 0 ? void 0 : first.change) !== null && _a !== void 0 ? _a : false;
+            const addressLimit = (_b = first === null || first === void 0 ? void 0 : first.addressLimit) !== null && _b !== void 0 ? _b : exports.NUMBER_ADDRESS_LIMIT;
+            return [yield this._sendTransaction(this.sendOptionsToOutputs(transactions), undefined, change, addressLimit)];
         });
     }
     sendSweepTransaction(externalChangeAddress, _asset, feePerByte) {
@@ -104,7 +145,23 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
         return __awaiter(this, void 0, void 0, function* () {
             const txHash = typeof tx === 'string' ? tx : tx.hash;
             const transaction = (yield this.chainProvider.getTransactionByHash(txHash))._raw;
-            const fixedInputs = [transaction.vin[0]]; // TODO: should this pick more than 1 input? RBF doesn't mandate it
+            const fixedUtxos = [];
+            const needsWitness = [types_2.AddressType.BECH32, types_2.AddressType.P2SH_SEGWIT].includes(this._addressType);
+            for (const vin of transaction.vin) {
+                const txHex = yield this.chainProvider.getProvider().getRawTransactionByHash(vin.txid);
+                const tx = (0, utils_2.decodeRawTransaction)(txHex, this._network);
+                const value = new types_1.BigNumber(tx.vout[vin.vout].value).times(1e8).toNumber();
+                const address = tx.vout[vin.vout].scriptPubKey.addresses[0];
+                const walletAddress = yield this.getWalletAddress(address);
+                fixedUtxos.push({
+                    txid: vin.txid,
+                    vout: vin.vout,
+                    value,
+                    address,
+                    derivationPath: walletAddress.derivationPath,
+                    witnessUtxo: needsWitness ? { script: new Uint8Array(0), value } : null,
+                });
+            }
             const lookupAddresses = transaction.vout.map((vout) => vout.scriptPubKey.addresses[0]);
             const changeAddress = yield this.findAddress(lookupAddresses, true);
             const changeOutput = transaction.vout.find((vout) => vout.scriptPubKey.addresses[0] === changeAddress.address);
@@ -117,7 +174,7 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
                 address: output.scriptPubKey.addresses[0],
                 value: new types_1.BigNumber(output.value).times(1e8).toNumber(),
             }));
-            const { hex, fee } = yield this.buildTransaction(transactions, newFeePerByte, fixedInputs);
+            const { hex, fee } = yield this.buildTransaction(transactions, newFeePerByte, fixedUtxos, true, exports.NUMBER_ADDRESS_LIMIT);
             yield this.chainProvider.sendRawTransaction(hex);
             return (0, utils_2.normalizeTransactionObject)((0, utils_2.decodeRawTransaction)(hex, this._network), fee);
         });
@@ -140,18 +197,18 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
             return fees;
         });
     }
-    _sendTransaction(transactions, feePerByte) {
+    _sendTransaction(transactions, feePerByte, change = false, addressLimit = exports.NUMBER_ADDRESS_LIMIT) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { hex, fee } = yield this.buildTransaction(transactions, feePerByte);
+            const { hex, fee } = yield this.buildTransaction(transactions, feePerByte, [], change, addressLimit);
             yield this.chainProvider.sendRawTransaction(hex);
             return (0, utils_2.normalizeTransactionObject)((0, utils_2.decodeRawTransaction)(hex, this._network), fee);
         });
     }
-    findAddress(addresses, change = false) {
+    findAddress(addresses, change = false, addressLimit = exports.NUMBER_ADDRESS_LIMIT) {
         return __awaiter(this, void 0, void 0, function* () {
             // A maximum number of addresses to lookup after which it is deemed that the wallet does not contain this address
-            const maxAddresses = NUMBER_ADDRESS_LIMIT;
-            const addressesPerCall = 50;
+            const maxAddresses = addressLimit;
+            const addressesPerCall = exports.NUMBER_ADDRESS_LIMIT;
             let index = 0;
             while (index < maxAddresses) {
                 const walletAddresses = yield this.getAddresses(index, addressesPerCall, change);
@@ -194,21 +251,75 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
             return addressObject;
         });
     }
-    _getUsedUnusedAddresses(addressType) {
+    getUsedUnusedAddresses(addressType, addressLimit = exports.NUMBER_ADDRESS_LIMIT, gapLimit = 1) {
         return __awaiter(this, void 0, void 0, function* () {
-            const usedAddresses = [];
-            const unusedAddressMap = { change: null, external: null };
-            if (addressType === AddressSearchType.EXTERNAL_OR_CHANGE || addressType === AddressSearchType.EXTERNAL) {
-                const externalAddresses = yield this.getAddresses(0, 1, false);
-                const externalAddress = externalAddresses[0];
-                usedAddresses.push(externalAddress);
-                unusedAddressMap.external = externalAddress;
-            }
-            if (addressType === AddressSearchType.EXTERNAL_OR_CHANGE || addressType === AddressSearchType.CHANGE) {
-                const changeAddresses = yield this.getAddresses(0, 1, true);
-                const changeAddress = changeAddresses[0];
-                usedAddresses.push(changeAddress);
-                unusedAddressMap.change = changeAddress;
+            const usedAddresses = {
+                change: [],
+                external: [],
+            };
+            const unusedAddressMap = {
+                change: null,
+                external: null,
+            };
+            const consecutiveUnusedCount = { change: 0, external: 0 };
+            let numAddressAlreadyGet = 0;
+            const numAddressPerCall = 100;
+            let addressIndex = 0;
+            /* eslint-disable no-unmodified-loop-condition */
+            while (((addressType === AddressSearchType.EXTERNAL_OR_CHANGE &&
+                (consecutiveUnusedCount.change < gapLimit || consecutiveUnusedCount.external < gapLimit)) ||
+                (addressType === AddressSearchType.EXTERNAL && consecutiveUnusedCount.external < gapLimit) ||
+                (addressType === AddressSearchType.CHANGE && consecutiveUnusedCount.change < gapLimit)) &&
+                numAddressAlreadyGet < addressLimit) {
+                /* eslint-enable no-unmodified-loop-condition */
+                let addrList = [];
+                let changeAddresses = [];
+                let externalAddresses = [];
+                let maxBatchSize = 0;
+                if ((addressType === AddressSearchType.EXTERNAL_OR_CHANGE || addressType === AddressSearchType.CHANGE) &&
+                    consecutiveUnusedCount.change < gapLimit &&
+                    numAddressAlreadyGet < addressLimit) {
+                    // Scanning for change addr
+                    const remainingLimit = addressLimit - numAddressAlreadyGet;
+                    const batchSize = Math.min(numAddressPerCall, remainingLimit);
+                    changeAddresses = yield this.getAddresses(addressIndex, batchSize, true);
+                    addrList = addrList.concat(changeAddresses);
+                    maxBatchSize = Math.max(maxBatchSize, batchSize);
+                }
+                if ((addressType === AddressSearchType.EXTERNAL_OR_CHANGE || addressType === AddressSearchType.EXTERNAL) &&
+                    consecutiveUnusedCount.external < gapLimit &&
+                    numAddressAlreadyGet < addressLimit) {
+                    // Scanning for non change addr
+                    const remainingLimit = addressLimit - numAddressAlreadyGet;
+                    const batchSize = Math.min(numAddressPerCall, remainingLimit);
+                    externalAddresses = yield this.getAddresses(addressIndex, batchSize, false);
+                    addrList = addrList.concat(externalAddresses);
+                    maxBatchSize = Math.max(maxBatchSize, batchSize);
+                }
+                if (addrList.length === 0) {
+                    break;
+                }
+                const transactionCounts = yield this.chainProvider
+                    .getProvider()
+                    .getAddressTransactionCounts(addrList);
+                for (const address of addrList) {
+                    const isUsed = transactionCounts[address.toString()] > 0;
+                    const isChangeAddress = changeAddresses.some((a) => address.toString() === a.toString());
+                    const key = isChangeAddress ? 'change' : 'external';
+                    if (isUsed) {
+                        usedAddresses[key].push(address);
+                        consecutiveUnusedCount[key] = 0;
+                        unusedAddressMap[key] = null;
+                    }
+                    else {
+                        consecutiveUnusedCount[key]++;
+                        if (!unusedAddressMap[key]) {
+                            unusedAddressMap[key] = address;
+                        }
+                    }
+                }
+                numAddressAlreadyGet += maxBatchSize;
+                addressIndex += maxBatchSize;
             }
             return {
                 usedAddresses,
@@ -232,47 +343,64 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
             return result;
         });
     }
+    getTotalFeeFixedInputs(opts, max) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const targets = this.sendOptionsToOutputs([opts]);
+            const addressLimit = (_a = opts.addressLimit) !== null && _a !== void 0 ? _a : exports.NUMBER_ADDRESS_LIMIT;
+            const useChangeUtxos = (_b = opts.change) !== null && _b !== void 0 ? _b : false;
+            const { fee } = yield this.getInputsForAmount(targets.filter((t) => !t.value), opts.fee, (_c = opts.inputs) !== null && _c !== void 0 ? _c : [], max, addressLimit, useChangeUtxos);
+            return fee;
+        });
+    }
     getTotalFee(opts, max) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const targets = this.sendOptionsToOutputs([opts]);
+            const addressLimit = (_a = opts.addressLimit) !== null && _a !== void 0 ? _a : exports.NUMBER_ADDRESS_LIMIT;
+            const useChangeUtxos = (_b = opts.change) !== null && _b !== void 0 ? _b : false;
             if (!max) {
-                const { fee } = yield this.getInputsForAmount(targets, opts.fee);
+                const { fee } = yield this.getInputsForAmount(targets, opts.fee, [], false, addressLimit, useChangeUtxos);
                 return fee;
             }
             else {
-                const { fee } = yield this.getInputsForAmount(targets.filter((t) => !t.value), opts.fee, [], true);
+                const { fee } = yield this.getInputsForAmount(targets.filter((t) => !t.value), opts.fee, [], true, addressLimit, useChangeUtxos);
                 return fee;
             }
         });
     }
-    getInputsForAmount(_targets, feePerByte, fixedInputs = [], sweep = false) {
+    getInputsForAmount(_targets, feePerByte, fixedUtxos = [], sweep = false, addressLimit = exports.NUMBER_ADDRESS_LIMIT, change = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const feePerBytePromise = this.chainProvider.getProvider().getFeePerByte();
             const utxos = [];
-            const addresses = yield this.getUsedAddresses();
-            const fixedUtxos = [];
+            const addressType = change ? AddressSearchType.EXTERNAL_OR_CHANGE : AddressSearchType.EXTERNAL;
+            const addresses = yield this.getUsedAddresses(addressType, addressLimit);
             const needsWitness = [types_2.AddressType.BECH32, types_2.AddressType.P2SH_SEGWIT].includes(this._addressType);
-            if (fixedInputs.length > 0) {
-                for (const input of fixedInputs) {
-                    const txHex = yield this.chainProvider.getProvider().getRawTransactionByHash(input.txid);
-                    const tx = (0, utils_2.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 = yield this.getWalletAddress(address);
-                    const utxo = Object.assign(Object.assign({}, input), { value, address, derivationPath: walletAddress.derivationPath, witnessUtxo: needsWitness ? { script: new Uint8Array(0), value } : null });
-                    fixedUtxos.push(utxo);
+            // Enrich fixedUtxos that are missing derivationPath or witnessUtxo
+            const enrichedFixedUtxos = yield Promise.all(fixedUtxos.map((utxo) => __awaiter(this, void 0, void 0, function* () {
+                let derivationPath = utxo.derivationPath;
+                if (derivationPath === undefined) {
+                    const walletAddress = yield this.getWalletAddress(utxo.address);
+                    derivationPath = walletAddress.derivationPath;
                 }
-            }
-            if (!sweep || fixedUtxos.length === 0) {
+                const witnessUtxo = utxo.witnessUtxo !== undefined
+                    ? utxo.witnessUtxo
+                    : needsWitness
+                        ? { script: new Uint8Array(0), value: utxo.value }
+                        : null;
+                return Object.assign(Object.assign({}, utxo), { derivationPath, witnessUtxo });
+            })));
+            if (!sweep || enrichedFixedUtxos.length === 0) {
                 const _utxos = yield this.chainProvider.getProvider().getUnspentTransactions(addresses);
                 utxos.push(..._utxos.map((utxo) => {
                     const addr = addresses.find((a) => a.address === utxo.address);
-                    return Object.assign(Object.assign({}, utxo), { witnessUtxo: needsWitness ? { script: new Uint8Array(0), value: utxo.value } : null, derivationPath: addr.derivationPath });
+                    return Object.assign(Object.assign({}, utxo), { witnessUtxo: needsWitness ? { script: new Uint8Array(0), value: utxo.value } : null, derivationPath: addr === null || addr === void 0 ? void 0 : addr.derivationPath });
                 }));
             }
             else {
-                utxos.push(...fixedUtxos.map((utxo) => {
-                    return Object.assign(Object.assign({}, utxo), { witnessUtxo: needsWitness ? { script: new Uint8Array(0), value: utxo.value } : null });
+                utxos.push(...enrichedFixedUtxos.map((utxo) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, utxo), { witnessUtxo: (_a = utxo.witnessUtxo) !== null && _a !== void 0 ? _a : (needsWitness ? { script: new Uint8Array(0), value: utxo.value } : null) }));
                 }));
             }
             const utxoBalance = utxos.reduce((a, b) => a + (b.value || 0), 0);
@@ -307,11 +435,11 @@ class BitcoinBaseWalletProvider extends client_1.Wallet {
             else {
                 targets = _targets.map((target) => ({ id: 'main', value: target.value, script: target.script, address: target.address }));
             }
-            const { inputs, outputs, change, fee } = (0, utils_2.selectCoins)(utxos, targets, Math.ceil(feePerByte));
+            const { inputs, outputs, change: changeOutput, fee } = (0, utils_2.selectCoins)(utxos, targets, Math.ceil(feePerByte));
             if (inputs && outputs) {
                 return {
                     inputs,
-                    change,
+                    change: changeOutput,
                     outputs,
                     fee,
                 };