mainnet-js 3.0.1 → 3.1.0

package/src/network/ElectrumNetworkProvider.ts

@@ -14,7 +14,12 @@ import {
   HeaderI,
 } from "../interface.js";
 import { Network } from "../interface.js";
-import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
+import {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionVinWithValues,
+  ElectrumRawTransactionWithInputValues,
+  ElectrumUtxo,
+} from "./interface.js";
 
 import { CancelFn } from "../wallet/interface.js";
 import { getTransactionHash } from "../util/transaction.js";
@@ -251,11 +256,28 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return this.currentHeight;
   }
 
+  async getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  async getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  async getRawTransaction(
+    txHash: string,
+    verbose?: false,
+    loadInputValues?: false
+  ): Promise<string>;
   async getRawTransaction(
     txHash: string,
     verbose: boolean = false,
     loadInputValues: boolean = false
-  ): Promise<string> {
+  ): Promise<
+    string | ElectrumRawTransaction | ElectrumRawTransactionWithInputValues
+  > {
     const key = `tx-${this.network}-${txHash}-${verbose}-${loadInputValues}`;
 
     if (this.cache) {
@@ -266,22 +288,27 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
 
     try {
-      const transaction = (await this.performRequest(
+      const result = await this.performRequest(
         "blockchain.transaction.get",
         txHash,
         verbose
-      )) as ElectrumRawTransaction;
+      );
+
+      if (!verbose) {
+        const hex = result as string;
+        if (this.cache) {
+          await this.cache.setItem(key, hex);
+        }
+        return hex;
+      }
+
+      const transaction = result as ElectrumRawTransaction;
 
       if (this.cache) {
-        await this.cache.setItem(
-          key,
-          verbose
-            ? JSON.stringify(transaction)
-            : (transaction as unknown as string)
-        );
+        await this.cache.setItem(key, JSON.stringify(transaction));
       }
 
-      if (verbose && loadInputValues) {
+      if (loadInputValues) {
         // get unique transaction hashes
         const hashes = [...new Set(transaction.vin.map((val) => val.txid))];
         const transactions = await Promise.all(
@@ -290,17 +317,18 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
         const transactionMap = new Map<string, ElectrumRawTransaction>();
         transactions.forEach((val) => transactionMap.set(val.hash, val));
 
-        transaction.vin.forEach((input) => {
-          const output = transactionMap
-            .get(input.txid)!
-            .vout.find((val) => val.n === input.vout)!;
-          input.address = output.scriptPubKey.addresses[0];
-          input.value = output.value;
-          input.tokenData = output.tokenData;
-        });
+        const enrichedVin: ElectrumRawTransactionVinWithValues[] =
+          transaction.vin.map((input) => {
+            const output = transactionMap
+              .get(input.txid)!
+              .vout.find((val) => val.n === input.vout)!;
+            return { ...input, ...output };
+          });
+
+        return { ...transaction, vin: enrichedVin };
       }
 
-      return transaction as any;
+      return transaction;
     } catch (error: any) {
       if (
         (error.message as string).indexOf(
@@ -315,15 +343,22 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   // gets the decoded transaction in human readable form
+  async getRawTransactionObject(
+    txHash: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  async getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
   async getRawTransactionObject(
     txHash: string,
     loadInputValues: boolean = false
-  ): Promise<ElectrumRawTransaction> {
-    return (await this.getRawTransaction(
-      txHash,
-      true,
-      loadInputValues
-    )) as unknown as ElectrumRawTransaction;
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
+    if (loadInputValues) {
+      return this.getRawTransaction(txHash, true, true);
+    }
+    return this.getRawTransaction(txHash, true);
   }
 
   async sendRawTransaction(

package/src/network/NetworkProvider.ts

@@ -1,4 +1,8 @@
 import { TxI, Utxo, Network, HexHeaderI, HeaderI } from "../interface.js";
+import {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionWithInputValues,
+} from "./interface.js";
 import { CancelFn } from "../wallet/interface.js";
 
 export default interface NetworkProvider {
@@ -38,13 +42,35 @@ export default interface NetworkProvider {
   getRelayFee(): Promise<number>;
 
   /**
-   * Retrieve the Hex transaction details for a given transaction ID.
+   * Retrieve transaction details for a given transaction ID.
    * @param txHash Hex of transaction hash.
-   * @param verbose Whether a verbose coin-specific response is required.
+   * @param verbose When true, returns a decoded transaction object instead of hex.
+   * @param loadInputValues When true (requires verbose), each vin is enriched with value, address and tokenData from the parent output.
    * @throws {Error} If the transaction does not exist
-   * @returns The full hex transaction for the provided transaction ID.
+   * @returns The hex string (non-verbose) or decoded transaction object (verbose).
    */
-  getRawTransaction(txHash: string): Promise<string>;
+  getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  getRawTransaction(
+    txHash: string,
+    verbose?: false,
+    loadInputValues?: false
+  ): Promise<string>;
+  getRawTransaction(
+    txHash: string,
+    verbose?: boolean,
+    loadInputValues?: boolean
+  ): Promise<
+    string | ElectrumRawTransaction | ElectrumRawTransactionWithInputValues
+  >;
 
   /**
    * Batch retrieve raw transactions by their hashes.
@@ -63,10 +89,22 @@ export default interface NetworkProvider {
   /**
    * Retrieve a verbose coin-specific response transaction details for a given transaction ID.
    * @param txHash Hex of transaction hash.
+   * @param loadInputValues When true, each vin is enriched with value, address and tokenData from the parent output.
    * @throws {Error} If the transaction does not exist
-   * @returns The full hex transaction for the provided transaction ID.
+   * @returns The decoded transaction object.
    */
-  getRawTransactionObject(txHash: string): Promise<any>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: boolean
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues>;
 
   /**
    * Broadcast a raw hex transaction to the Bitcoin Cash network.

package/src/network/index.ts

@@ -7,4 +7,8 @@ export {
 } from "./Connection.js";
 export { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
 export { default as NetworkProvider } from "./NetworkProvider.js";
-export { ElectrumRawTransaction } from "./interface.js";
+export {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionWithInputValues,
+  ElectrumRawTransactionVinWithValues,
+} from "./interface.js";

package/src/network/interface.ts

@@ -54,9 +54,14 @@ export interface ElectrumRawTransactionVin {
   sequence: number;
   txid: string;
   vout: number;
-  value?: number; // optional extention by mainnet.cash
-  address?: string; // optional extension by mainnet.cash
-  tokenData?: ElectrumTokenData; // optional extension by mainnet.cash
+}
+
+export type ElectrumRawTransactionVinWithValues = ElectrumRawTransactionVin &
+  ElectrumRawTransactionVout;
+
+export interface ElectrumRawTransactionWithInputValues
+  extends Omit<ElectrumRawTransaction, "vin"> {
+  vin: ElectrumRawTransactionVinWithValues[];
 }
 
 export interface ElectrumRawTransactionVout {

package/src/wallet/Base.ts

@@ -571,10 +571,7 @@ export class BaseWallet implements WalletI {
   ): Promise<CancelFn> {
     return this.watchTransactions(
       async (transaction: ElectrumRawTransaction) => {
-        if (
-          transaction.vin.some((val) => val.tokenData) ||
-          transaction.vout.some((val) => val.tokenData)
-        ) {
+        if (transaction.vout.some((val) => val.tokenData)) {
           callback(transaction);
         }
       }

package/src/wallet/HDWallet.test.ts

@@ -6,6 +6,9 @@ import { getNextUnusedIndex } from "../util/hd";
 import { NFTCapability } from "../interface";
 import { TokenMintRequest, TokenSendRequest } from "./model";
 import { stringify } from "../cache";
+import { mine } from "../mine";
+import { delay } from "../util/delay";
+import { CancelFn } from "./interface";
 
 const expectedXpub =
   "xpub6CGqRCnS5qDfyxtzV3y3tj8CY7qf3z3GiB2qnCUTdNkhpNxbLtobrU5ZXBVPG3rzPcBUpJAoj3K1u1jyDwKuduL71gLPm27Tckc85apgQRr";
@@ -111,12 +114,16 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(1);
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(1),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(2);
 
     await fundingWallet.send({
@@ -155,6 +162,9 @@ describe("HDWallet", () => {
       { cashaddr: addr0, value: 10000n },
       { cashaddr: addr20, value: 10000n },
     ]);
+    // Wait for seedWallet to see both transactions via electrum
+    while (seedWallet.depositIndex < 21)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Restore wallet from same seed, starting from index 0
     const restoredWallet = await RegTestHDWallet.fromSeed(
@@ -181,6 +191,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(1);
     expect(hdWallet.changeIndex).toBe(0);
 
@@ -199,6 +211,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
     await hdWallet.send({
       cashaddr: bob.getDepositAddress(),
       value: 50000n,
@@ -247,6 +261,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(100000n);
 
@@ -258,6 +274,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress2,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(200000n);
 
@@ -289,6 +307,8 @@ describe("HDWallet", () => {
       cashaddr: bob.getDepositAddress(),
       value: 150000n,
     });
+    while (hdWallet.changeIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(
       await (
@@ -326,6 +346,10 @@ describe("HDWallet", () => {
     const charlie = await RegTestWallet.newRandom();
     await hdWallet.sendMax(charlie.cashaddr);
 
+    // Wait for HD wallet to process the spent notification
+    while ((await hdWallet.getBalance()) > 0n)
+      await new Promise((r) => setTimeout(r, 50));
+
     expect(await charlie.getBalance()).toBe(49407n);
     expect(await hdWallet.getBalance()).toBe(0n);
   });
@@ -343,6 +367,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(100000n);
 
@@ -436,6 +462,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(
       hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.status
@@ -486,6 +514,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     // rawHistory should now have one entry
     expect(
@@ -527,11 +557,15 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(1),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check depositRawHistory arrays are populated
     expect(hdWallet.depositRawHistory[0].length).toBe(1);
@@ -557,6 +591,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     const history = await hdWallet.getHistory({ unit: "sat" });
     expect(history.length).toBe(1);
@@ -578,6 +614,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 50000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check rawHistory is populated
     const cacheEntry1 = hdWallet.walletCache.get(hdWallet.getDepositAddress(0));
@@ -590,6 +628,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 60000n,
     });
+    while (hdWallet.depositRawHistory[0].length < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check history accumulated correctly
     const cacheEntry2 = hdWallet.walletCache.get(hdWallet.getDepositAddress(0));
@@ -680,6 +720,7 @@ describe("HDWallet", () => {
       cashaddr: alice.getDepositAddress(),
       value: 1000000n,
     });
+    while (alice.depositIndex < 1) await new Promise((r) => setTimeout(r, 50));
 
     const genesisResponse = await alice.tokenGenesis({
       cashaddr: alice.getDepositAddress(1),
@@ -764,6 +805,7 @@ describe("HDWallet", () => {
       cashaddr: alice.getDepositAddress(),
       value: 1000000n,
     });
+    while (alice.depositIndex < 1) await new Promise((r) => setTimeout(r, 50));
 
     const genesisResponse = await alice.tokenGenesis({
       amount: 100n,
@@ -839,4 +881,201 @@ describe("HDWallet", () => {
 
     Config.EnforceCashTokenReceiptAddresses = previousValue;
   });
+
+  it("watchTransactionHashes reports new transactions on HD wallet", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Fund the HD wallet at deposit address 0
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    // Set up watchTransactionHashes, collect reported tx hashes
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Wait for initial callback to fire with existing tx
+    await delay(2000);
+
+    // Send a new transaction to the HD wallet
+    const sendResponse = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // The new transaction's txId should appear in collected hashes
+    expect(reportedHashes).toContain(sendResponse.txId);
+  });
+
+  it("watchTransactionHashes does not re-report old transactions", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Start watching before any transactions so the first funding triggers a callback
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Fund the HD wallet at deposit address 0
+    const fundResponse = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    // Record how many hashes reported so far (the initial set)
+    const initialCount = reportedHashes.length;
+    expect(reportedHashes).toContain(fundResponse.txId);
+    const initialHashes = [...reportedHashes];
+
+    // Send a second transaction to the HD wallet
+    const sendResponse2 = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // Hashes reported after the initial set
+    const laterHashes = reportedHashes.slice(initialCount);
+
+    // The second tx hash was reported
+    expect(laterHashes).toContain(sendResponse2.txId);
+
+    // None of the initial tx hashes were reported again after the first callback
+    for (const hash of initialHashes) {
+      expect(laterHashes).not.toContain(hash);
+    }
+  });
+
+  it("watchTransactionHashes handles transactions across multiple deposit addresses", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Fund deposit address 0
+    const fund0Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(1000);
+
+    // Fund deposit address 1
+    const fund1Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(1),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(1000);
+
+    // depositIndex should be 2
+    expect(hdWallet.depositIndex).toBe(2);
+
+    // Set up watchTransactionHashes, collect all reported hashes
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Wait for initial callback to fire
+    await delay(2000);
+
+    // Send a new transaction to the wallet's next deposit address
+    const fund2Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // All 3 tx hashes appear in the collected output
+    expect(reportedHashes).toContain(fund0Response.txId);
+    expect(reportedHashes).toContain(fund1Response.txId);
+    expect(reportedHashes).toContain(fund2Response.txId);
+
+    // Each tx hash appears exactly once
+    const uniqueHashes = new Set(reportedHashes);
+    expect(uniqueHashes.size).toBe(reportedHashes.length);
+  });
+
+  it("gap is maintained when addresses near the edge are used", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+    await hdWallet.watchPromise;
+
+    // Initially: depositIndex=0, watched addresses 0..(GAP_SIZE-1)
+    expect(hdWallet.depositIndex).toBe(0);
+    const initialWatched = (hdWallet as any).depositStatuses.length;
+    expect(initialWatched).toBe(GAP_SIZE);
+
+    // Fund an address near the edge of the gap
+    const edgeIndex = GAP_SIZE - 2;
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(edgeIndex),
+      value: 10000n,
+    });
+
+    // Wait for the subscription callback to fire and gap extension to complete
+    while (hdWallet.depositIndex < edgeIndex + 1)
+      await new Promise((r) => setTimeout(r, 50));
+    await delay(1000);
+
+    // depositIndex should have advanced
+    expect(hdWallet.depositIndex).toBe(edgeIndex + 1);
+
+    // The watched range should have extended to maintain the gap
+    const newWatched = (hdWallet as any).depositStatuses.length;
+    expect(newWatched).toBeGreaterThanOrEqual(hdWallet.depositIndex + GAP_SIZE);
+
+    // Verify the new addresses are actually subscribed (watchCancels populated)
+    const watchCancels = (hdWallet as any).depositWatchCancels;
+    for (let i = initialWatched; i < newWatched; i++) {
+      expect(watchCancels[i]).toBeDefined();
+    }
+
+    // Fund an address in the newly extended range to prove it's being watched
+    const newEdge = newWatched - 2;
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(newEdge),
+      value: 10000n,
+    });
+    while (hdWallet.depositIndex < newEdge + 1)
+      await new Promise((r) => setTimeout(r, 50));
+    await delay(1000);
+
+    expect(hdWallet.depositIndex).toBe(newEdge + 1);
+
+    // Gap should still be maintained after the second extension
+    const finalWatched = (hdWallet as any).depositStatuses.length;
+    expect(finalWatched).toBeGreaterThanOrEqual(
+      hdWallet.depositIndex + GAP_SIZE
+    );
+  });
 });

package/src/wallet/HDWallet.ts

@@ -414,6 +414,12 @@ export class HDWallet extends BaseWallet {
                 if (newIndex > getCurrentIndex()) {
                   setCurrentIndex(newIndex);
                 }
+
+                // Maintain the gap: extend watched range if it shrank
+                const gap = statuses.length - getCurrentIndex();
+                if (gap < gapSize) {
+                  await this.watchAddressType(isChange, gapSize);
+                }
               }
 
               // Notify wallet watchers of the status change
@@ -493,6 +499,36 @@ export class HDWallet extends BaseWallet {
     };
   }
 
+  /**
+   * Watch wallet for new transactions (HD wallet override)
+   *
+   * Uses unfiltered history so that seenTxHashes always covers all known
+   * transactions, including those from newly discovered addresses when
+   * depositIndex/changeIndex extends and widens getRawHistory's scope.
+   */
+  public override async watchTransactionHashes(
+    callback: (txHash: string) => void
+  ): Promise<CancelFn> {
+    const seenTxHashes = new Set<string>();
+
+    return this.watchStatus(async () => {
+      const history = await this.getRawHistory();
+
+      const newTxHashes: string[] = [];
+
+      for (const tx of history) {
+        if (!seenTxHashes.has(tx.tx_hash)) {
+          seenTxHashes.add(tx.tx_hash);
+          newTxHashes.push(tx.tx_hash);
+        }
+      }
+
+      if (newTxHashes.length > 0) {
+        newTxHashes.forEach((txHash) => callback(txHash));
+      }
+    });
+  }
+
   /**
    * utxos Get unspent outputs for the wallet
    *