@yaswap/yacoin 3.4.1 → 3.4.3

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @yaswap/bitcoin
 
+## 3.4.3
+
+### Patch Changes
+
+- Improve getUsedUnusedAddresses and buildTransaction
+- Updated dependencies
+  - @yaswap/client@3.4.3
+  - @yaswap/errors@3.4.3
+  - @yaswap/types@3.4.3
+  - @yaswap/utils@3.4.3
+
+## 3.4.2
+
+### Patch Changes
+
+- Support HD wallet logic
+- Updated dependencies
+  - @yaswap/client@3.4.2
+  - @yaswap/errors@3.4.2
+  - @yaswap/types@3.4.2
+  - @yaswap/utils@3.4.2
+
 ## 3.4.1
 
 ### Patch Changes

package/dist/lib/index.d.ts

@@ -8,7 +8,7 @@ export { YacoinSwapBaseProvider } from './swap/YacoinSwapBaseProvider';
 export { YacoinSwapEsploraProvider } from './swap/YacoinSwapEsploraProvider';
 export * as YacoinTypes from './types';
 export * as YacoinUtils from './utils';
-export { YacoinBaseWalletProvider } from './wallet/YacoinBaseWallet';
+export { AddressSearchType, YacoinBaseWalletProvider, NUMBER_ADDRESS_LIMIT } from './wallet/YacoinBaseWallet';
 export { YacoinHDWalletProvider } from './wallet/YacoinHDWallet';
 export { YacoinNftProvider } from './nft/YacoinNftProvider';
 export { YacoinSingleWallet } from './wallet/YacoinSingleWallet';

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.YacoinSingleWallet = exports.YacoinNftProvider = exports.YacoinHDWalletProvider = exports.YacoinBaseWalletProvider = exports.YacoinUtils = exports.YacoinTypes = exports.YacoinSwapEsploraProvider = exports.YacoinSwapBaseProvider = exports.YacoinNetworks = exports.YacoinFeeApiProvider = exports.YacoinEsploraBatchBaseProvider = exports.YacoinEsploraBaseProvider = exports.YacoinEsploraApiProvider = exports.YacoinBaseChainProvider = void 0;
+exports.YacoinSingleWallet = exports.YacoinNftProvider = exports.YacoinHDWalletProvider = exports.NUMBER_ADDRESS_LIMIT = exports.YacoinBaseWalletProvider = exports.AddressSearchType = exports.YacoinUtils = exports.YacoinTypes = exports.YacoinSwapEsploraProvider = exports.YacoinSwapBaseProvider = exports.YacoinNetworks = exports.YacoinFeeApiProvider = exports.YacoinEsploraBatchBaseProvider = exports.YacoinEsploraBaseProvider = exports.YacoinEsploraApiProvider = exports.YacoinBaseChainProvider = void 0;
 var YacoinBaseChainProvider_1 = require("./chain/YacoinBaseChainProvider");
 Object.defineProperty(exports, "YacoinBaseChainProvider", { enumerable: true, get: function () { return YacoinBaseChainProvider_1.YacoinBaseChainProvider; } });
 var YacoinEsploraApiProvider_1 = require("./chain/esplora/YacoinEsploraApiProvider");
@@ -43,7 +43,9 @@ Object.defineProperty(exports, "YacoinSwapEsploraProvider", { enumerable: true,
 exports.YacoinTypes = __importStar(require("./types"));
 exports.YacoinUtils = __importStar(require("./utils"));
 var YacoinBaseWallet_1 = require("./wallet/YacoinBaseWallet");
+Object.defineProperty(exports, "AddressSearchType", { enumerable: true, get: function () { return YacoinBaseWallet_1.AddressSearchType; } });
 Object.defineProperty(exports, "YacoinBaseWalletProvider", { enumerable: true, get: function () { return YacoinBaseWallet_1.YacoinBaseWalletProvider; } });
+Object.defineProperty(exports, "NUMBER_ADDRESS_LIMIT", { enumerable: true, get: function () { return YacoinBaseWallet_1.NUMBER_ADDRESS_LIMIT; } });
 var YacoinHDWallet_1 = require("./wallet/YacoinHDWallet");
 Object.defineProperty(exports, "YacoinHDWalletProvider", { enumerable: true, get: function () { return YacoinHDWallet_1.YacoinHDWalletProvider; } });
 var YacoinNftProvider_1 = require("./nft/YacoinNftProvider");

package/dist/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAA0E;AAAjE,kIAAA,uBAAuB,OAAA;AAChC,qFAAoF;AAA3E,oIAAA,wBAAwB,OAAA;AACjC,uFAAsF;AAA7E,sIAAA,yBAAyB,OAAA;AAClC,iGAAgG;AAAvF,gJAAA,8BAA8B,OAAA;AACvC,mEAAkE;AAAzD,4HAAA,oBAAoB,OAAA;AAC7B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AACvB,wEAAuE;AAA9D,gIAAA,sBAAsB,OAAA;AAC/B,8EAA6E;AAApE,sIAAA,yBAAyB,OAAA;AAClC,uDAAuC;AACvC,uDAAuC;AACvC,8DAAqE;AAA5D,4HAAA,wBAAwB,OAAA;AACjC,0DAAiE;AAAxD,wHAAA,sBAAsB,OAAA;AAC/B,6DAA4D;AAAnD,sHAAA,iBAAiB,OAAA;AAC1B,kEAAiE;AAAxD,wHAAA,kBAAkB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAA0E;AAAjE,kIAAA,uBAAuB,OAAA;AAChC,qFAAoF;AAA3E,oIAAA,wBAAwB,OAAA;AACjC,uFAAsF;AAA7E,sIAAA,yBAAyB,OAAA;AAClC,iGAAgG;AAAvF,gJAAA,8BAA8B,OAAA;AACvC,mEAAkE;AAAzD,4HAAA,oBAAoB,OAAA;AAC7B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AACvB,wEAAuE;AAA9D,gIAAA,sBAAsB,OAAA;AAC/B,8EAA6E;AAApE,sIAAA,yBAAyB,OAAA;AAClC,uDAAuC;AACvC,uDAAuC;AACvC,8DAA8G;AAArG,qHAAA,iBAAiB,OAAA;AAAE,4HAAA,wBAAwB,OAAA;AAAE,wHAAA,oBAAoB,OAAA;AAC1E,0DAAiE;AAAxD,wHAAA,sBAAsB,OAAA;AAC/B,6DAA4D;AAAnD,sHAAA,iBAAiB,OAAA;AAC1B,kEAAiE;AAAxD,wHAAA,kBAAkB,OAAA"}

package/dist/lib/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Network, TokenScriptType } from '@yaswap/types';
+import { Address, Network, TokenScriptType, TransactionRequest } from '@yaswap/types';
 import { ECPairInterface, Network as YacoinJsLibNetwork } from '@yaswap/yacoinjs-lib';
 export * as YacoinEsploraTypes from './chain/esplora/types';
 export * from './swap/types';
@@ -18,7 +18,17 @@ export interface YacoinWalletProviderOptions extends YacoinNodeWalletOptions {
     baseDerivationPath: string;
 }
 export interface YacoinHDWalletProviderOptions extends YacoinWalletProviderOptions {
-    mnemonic: string;
+    mnemonic?: string;
+    extendedPublicKey?: RawExtendedPublicKey;
+    extendedPrivateKey?: RawExtendedPrivateKey;
+}
+export interface RawExtendedPublicKey {
+    publicKey: Buffer;
+    chainCode: Buffer;
+}
+export interface RawExtendedPrivateKey {
+    privateKey: Buffer;
+    chainCode: Buffer;
 }
 export interface OutputTarget {
     address?: string;
@@ -96,3 +106,36 @@ export interface P2SHInput {
     vout: any;
     outputScript: Buffer;
 }
+export interface UsedUnusedAddressesResult {
+    usedAddresses: {
+        change: Address[];
+        external: Address[];
+    };
+    unusedAddress: {
+        change: Address | null;
+        external: Address | null;
+    };
+}
+/**
+ * Options for Yacoin sendTransaction and sendTransactionFixedInputs.
+ * Extends TransactionRequest with Yacoin-specific options.
+ */
+export interface YacoinSendTransactionOptions 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.
+     *
+     * NOTE: This only affects which branch is scanned for UTXOs and where
+     * the change output is sent; it does not alter token behavior.
+     */
+    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,4EAA4D;AAC5D,+CAA6B;AAsF7B,IAAY,WAEX;AAFD,WAAY,WAAW;IACnB,gCAAiB,CAAA;AACrB,CAAC,EAFW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAEtB;AAED,IAAY,QAEX;AAFD,WAAY,QAAQ;IAChB,yBAAa,CAAA;AACjB,CAAC,EAFW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAEnB"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../lib/types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,4EAA4D;AAC5D,+CAA6B;AAkG7B,IAAY,WAEX;AAFD,WAAY,WAAW;IACnB,gCAAiB,CAAA;AACrB,CAAC,EAFW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAEtB;AAED,IAAY,QAEX;AAFD,WAAY,QAAQ;IAChB,yBAAa,CAAA;AACjB,CAAC,EAFW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAEnB"}

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

@@ -1,11 +1,32 @@
 import { Chain, Wallet } from '@yaswap/client';
-import { Address, FeeType, Transaction, TransactionRequest } from '@yaswap/types';
-import { PsbtInputTarget } from '../types';
+import { Address, FeeType, Transaction } from '@yaswap/types';
+import { PsbtInputTarget, UsedUnusedAddressesResult, YacoinSendTransactionOptions } from '../types';
+import { AddressSearchType } from './YacoinBaseWallet';
 export interface IYacoinWallet<T, S = any> extends Wallet<T, S> {
     getChainProvider(): Chain<T>;
-    sendTransaction(txRequest: TransactionRequest): Promise<Transaction>;
+    sendTransaction(txRequest: YacoinSendTransactionOptions): Promise<Transaction>;
+    sendTransactionFixedInputs(options: YacoinSendTransactionOptions): Promise<Transaction>;
+    getTotalFeeFixedInputs(opts: YacoinSendTransactionOptions, max: boolean): Promise<number>;
     updateTransactionFee(tx: string | Transaction, newFee: FeeType): Promise<Transaction>;
     getWalletAddress(address: string): Promise<Address>;
     signPSBT(data: string, inputs: PsbtInputTarget[]): Promise<string>;
     signTx(transaction: string, hash: string, derivationPath: string, txfee: number): Promise<string>;
+    /**
+     * 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).
+     */
+    getUnusedAddress(change?: boolean, addressLimit?: number): Promise<Address | null>;
+    /**
+     * 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).
+     */
+    getUsedAddresses(addressType?: AddressSearchType, addressLimit?: number): Promise<Address[]>;
+    /**
+     * Scan addresses and return both used and first unused addresses per branch.
+     */
+    getUsedUnusedAddresses(addressType: AddressSearchType, addressLimit?: number, gapLimit?: number, useCache?: boolean): Promise<UsedUnusedAddressesResult>;
 }

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

@@ -4,8 +4,9 @@ import { Address, AddressType, Asset, Transaction, TransactionRequest, CreateTok
 import { BIP32Interface } from 'bip32';
 import { payments } from '@yaswap/yacoinjs-lib';
 import { YacoinBaseChainProvider } from '../chain/YacoinBaseChainProvider';
-import { AddressType as YaAddressType, YacoinNetwork, YacoinWalletProviderOptions, Input, OutputTarget, P2SHInput, PsbtInputTarget, Transaction as YaTransaction, UTXO } from '../types';
+import { AddressType as YaAddressType, YacoinNetwork, YacoinWalletProviderOptions, OutputTarget, P2SHInput, PsbtInputTarget, Transaction as YaTransaction, UsedUnusedAddressesResult, UTXO, YacoinSendTransactionOptions } from '../types';
 import { CoinSelectTarget } from '../utils';
+export declare const NUMBER_ADDRESS_LIMIT = 40;
 export declare enum AddressSearchType {
     EXTERNAL = 0,
     CHANGE = 1,
@@ -19,10 +20,11 @@ export declare abstract class YacoinBaseWalletProvider<T extends YacoinBaseChain
     protected _network: YacoinNetwork;
     protected _addressType: YaAddressType;
     protected _derivationCache: DerivationCache;
+    private _usedUnusedAddressesCache;
     constructor(options: YacoinWalletProviderOptions, 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;
     }>;
@@ -34,29 +36,50 @@ export declare abstract class YacoinBaseWalletProvider<T extends YacoinBaseChain
     abstract signTx(transaction: string, hash: string, derivationPath: string, txfee: number): 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(options: CreateTokenTransaction): Promise<Transaction>;
-    sendTransaction(options: TransactionRequest): Promise<Transaction<YaTransaction>>;
-    sendBatchTransaction(transactions: TransactionRequest[]): Promise<Transaction<YaTransaction>[]>;
+    sendTransaction(options: TransactionRequest & {
+        change?: boolean;
+        addressLimit?: number;
+        inputs?: UTXO[];
+    }): Promise<Transaction<YaTransaction>>;
+    sendTransactionFixedInputs(options: TransactionRequest & {
+        change?: boolean;
+        addressLimit?: number;
+        inputs?: UTXO[];
+    }): Promise<Transaction<YaTransaction>>;
+    sendBatchTransaction(transactions: (TransactionRequest & {
+        change?: boolean;
+        addressLimit?: number;
+    })[]): Promise<Transaction<YaTransaction>[]>;
     sendSweepTransaction(externalChangeAddress: AddressType, _asset: Asset, feePerByte: number): Promise<Transaction<YaTransaction>>;
     updateTransactionFee(tx: Transaction<YaTransaction> | string, newFeePerByte: number): Promise<Transaction<YaTransaction>>;
-    getTotalFees(transactions: TransactionRequest[], max: boolean): Promise<any>;
-    protected _sendTransaction(transactions: OutputTarget[], feePerByte?: number): Promise<Transaction<YaTransaction>>;
-    protected findAddress(addresses: string[], change?: boolean): Promise<Address>;
+    getTotalFees(transactions: YacoinSendTransactionOptions[], max: boolean): Promise<any>;
+    protected _sendTransaction(transactions: OutputTarget[], feePerByte?: number, change?: boolean, addressLimit?: number, fixedUtxos?: UTXO[]): Promise<Transaction<YaTransaction>>;
+    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, useCache?: boolean): 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: YacoinSendTransactionOptions, max: boolean): Promise<number>;
+    protected getTotalFee(opts: YacoinSendTransactionOptions, max: boolean): Promise<number>;
+    protected getInputsForAmount(_targets: OutputTarget[], feePerByte?: number, fixedUtxos?: UTXO[], sweep?: boolean, addressLimit?: number, change?: boolean): Promise<{
         inputs: UTXO[];
         coinChange: CoinSelectTarget;
         tokenChange: CoinSelectTarget;

package/dist/lib/wallet/YacoinBaseWallet.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.YacoinBaseWalletProvider = exports.AddressSearchType = void 0;
+exports.YacoinBaseWalletProvider = 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");
@@ -21,7 +21,9 @@ const yacoinjs_lib_1 = require("@yaswap/yacoinjs-lib");
 const memoizee_1 = __importDefault(require("memoizee"));
 const types_2 = require("../types");
 const utils_2 = require("../utils");
-const NUMBER_ADDRESS_LIMIT = 1;
+exports.NUMBER_ADDRESS_LIMIT = 40;
+/** Cache TTL in milliseconds for getUsedUnusedAddresses results. */
+const USED_UNUSED_ADDRESSES_CACHE_TTL_MS = 60 * 1000;
 var AddressSearchType;
 (function (AddressSearchType) {
     AddressSearchType[AddressSearchType["EXTERNAL"] = 0] = "EXTERNAL";
@@ -45,6 +47,7 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
             throw new Error(`addressType must be one of ${addressTypes.join(',')}`);
         }
         super(chainProvider);
+        this._usedUnusedAddressesCache = {};
         this._baseDerivationPath = baseDerivationPath;
         this._network = chainProvider ? chainProvider.getNetwork() : options.network;
         this._addressType = addressType;
@@ -56,16 +59,38 @@ class YacoinBaseWalletProvider 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) {
@@ -92,13 +117,35 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
         });
     }
     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, options.inputs);
+        });
+    }
+    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);
+            const result = yield this.chainProvider.sendRawTransaction(`data=${hex}`);
+            if (result == 'There was an error. Check your console.') {
+                throw new Error("Cannot send transaction, there might some reasons:\n 1) It might be the fee is not enough, please try increasing the fee.\n 2) The wallet haven't updated latest balance info, please wait 10 seconds and try again.");
+            }
+            return (0, utils_2.normalizeTransactionObject)((0, utils_2.decodeRawTransaction)(hex, this._network), fee);
         });
     }
     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) {
@@ -112,7 +159,21 @@ class YacoinBaseWalletProvider 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 = [];
+            for (const vin of transaction.vin) {
+                const txHex = yield this.chainProvider.getProvider().getRawTransactionByHash(vin.txid);
+                const txDecoded = (0, utils_2.decodeRawTransaction)(txHex, this._network);
+                const value = new types_1.BigNumber(txDecoded.vout[vin.vout].value).times(1e6).toNumber();
+                const address = txDecoded.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,
+                });
+            }
             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);
@@ -125,8 +186,11 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
                 address: output.scriptPubKey.addresses[0],
                 value: new types_1.BigNumber(output.value).times(1e6).toNumber(),
             }));
-            const { hex, fee } = yield this.buildTransaction(transactions, newFeePerByte, fixedInputs);
-            yield this.chainProvider.sendRawTransaction(`data=${hex}`);
+            const { hex, fee } = yield this.buildTransaction(transactions, newFeePerByte, fixedUtxos, true, exports.NUMBER_ADDRESS_LIMIT);
+            const result = yield this.chainProvider.sendRawTransaction(`data=${hex}`);
+            if (result == 'There was an error. Check your console.') {
+                throw new Error("Cannot send transaction, there might some reasons:\n 1) It might be the fee is not enough, please try increasing the fee.\n 2) The wallet haven't updated latest balance info, please wait 10 seconds and try again.");
+            }
             return (0, utils_2.normalizeTransactionObject)((0, utils_2.decodeRawTransaction)(hex, this._network), fee);
         });
     }
@@ -143,9 +207,9 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
             return fees;
         });
     }
-    _sendTransaction(transactions, feePerByte) {
+    _sendTransaction(transactions, feePerByte, change = false, addressLimit = exports.NUMBER_ADDRESS_LIMIT, fixedUtxos = []) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { hex, fee } = yield this.buildTransaction(transactions, feePerByte);
+            const { hex, fee } = yield this.buildTransaction(transactions, feePerByte, fixedUtxos, change, addressLimit);
             const result = yield this.chainProvider.sendRawTransaction(`data=${hex}`);
             if (result == 'There was an error. Check your console.') {
                 throw new Error("Cannot send transaction, there might some reasons:\n 1) It might be the fee is not enough, please try increasing the fee.\n 2) The wallet haven't updated latest balance info, please wait 10 seconds and try again.");
@@ -153,11 +217,11 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
             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);
@@ -200,26 +264,87 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
             return addressObject;
         });
     }
-    _getUsedUnusedAddresses(addressType) {
+    getUsedUnusedAddresses(addressType, addressLimit = exports.NUMBER_ADDRESS_LIMIT, gapLimit = 1, useCache = true) {
         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;
+            const cacheKey = `${addressType}_${addressLimit}_${gapLimit}`;
+            if (useCache) {
+                const cached = this._usedUnusedAddressesCache[cacheKey];
+                if (cached && Date.now() - cached.timestamp < USED_UNUSED_ADDRESSES_CACHE_TTL_MS) {
+                    return cached.result;
+                }
             }
-            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) {
+                    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) {
+                    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 {
+            const result = {
                 usedAddresses,
                 unusedAddress: unusedAddressMap,
             };
+            if (useCache) {
+                this._usedUnusedAddressesCache[cacheKey] = { result, timestamp: Date.now() };
+            }
+            return result;
         });
     }
     withCachedUtxos(func) {
@@ -238,40 +363,47 @@ class YacoinBaseWalletProvider 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, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const targets = this.sendOptionsToOutputs([opts]);
             if (!max) {
-                // const { fee } = await this.getInputsForAmount(targets, opts.fee as number);
-                const { fee } = yield this.getInputsForAmount(targets, opts.fee);
+                const { fee } = yield this.getInputsForAmount(targets, opts.fee, [], false, (_a = opts.addressLimit) !== null && _a !== void 0 ? _a : exports.NUMBER_ADDRESS_LIMIT, (_b = opts.change) !== null && _b !== void 0 ? _b : false);
                 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, (_c = opts.addressLimit) !== null && _c !== void 0 ? _c : exports.NUMBER_ADDRESS_LIMIT, (_d = opts.change) !== null && _d !== void 0 ? _d : false);
                 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 tokenTransferOutput = _targets.find((target) => target.tokenName !== undefined && target.tokenScriptType === types_1.TokenScriptType.transfer);
             const feePerBytePromise = this.chainProvider.getProvider().getFeePerByte();
             let utxos = [];
             let tokenUtxos = [];
-            const addresses = yield this.getUsedAddresses();
-            const fixedUtxos = [];
-            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(1e6).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 });
-                    fixedUtxos.push(utxo);
+            const addressType = change ? AddressSearchType.EXTERNAL_OR_CHANGE : AddressSearchType.EXTERNAL;
+            const addresses = yield this.getUsedAddresses(addressType, addressLimit);
+            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) {
+                return Object.assign(Object.assign({}, utxo), { derivationPath });
+            })));
+            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);
@@ -279,7 +411,7 @@ class YacoinBaseWalletProvider extends client_1.Wallet {
                 }));
             }
             else {
-                utxos = fixedUtxos;
+                utxos = enrichedFixedUtxos;
             }
             if (tokenTransferOutput) {
                 const isNFTOutput = tokenTransferOutput.tokenName.indexOf('#') !== -1;