mainnet-js 3.0.0 → 3.1.0

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
@@ -463,46 +469,63 @@ export class HDWallet extends BaseWallet {
    * @returns Cancel function to stop watching
    */
   public async watchStatus(
-    callback: (status: string | null, address: string) => void
+    callback: (status: string | null, address: string) => void,
+    debounce: number = 100
   ): Promise<CancelFn> {
     await this.watchPromise;
 
-    this.walletWatchCallbacks.push(callback);
+    let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+    let pendingStatus: string | null = null;
+    let pendingAddress: string = "";
+
+    const debouncedCallback = (status: string | null, address: string) => {
+      pendingStatus = status;
+      pendingAddress = address;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = undefined;
+        callback(pendingStatus, pendingAddress);
+      }, debounce);
+    };
+
+    this.walletWatchCallbacks.push(debouncedCallback);
 
     return async () => {
-      const index = this.walletWatchCallbacks.indexOf(callback);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      const index = this.walletWatchCallbacks.indexOf(debouncedCallback);
       if (index > -1) {
         this.walletWatchCallbacks.splice(index, 1);
       }
     };
   }
 
-  public async watchBalance(
-    callback: (balance: bigint) => void
+  /**
+   * 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> {
-    let debounceTimer: ReturnType<typeof setTimeout> | undefined = undefined;
+    const seenTxHashes = new Set<string>();
+
     return this.watchStatus(async () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        debounceTimer = undefined;
-        const balance = await this.getBalance();
-        callback(balance);
-      }, 100);
-    });
-  }
+      const history = await this.getRawHistory();
 
-  public async watchTokenBalance(
-    category: string,
-    callback: (balance: bigint) => void
-  ): Promise<CancelFn> {
-    let debounceTimer: ReturnType<typeof setTimeout> | undefined = undefined;
-    return await this.watchStatus(async () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        debounceTimer = undefined;
-        const balance = await this.getTokenBalance(category);
-        callback(balance);
-      }, 100);
+      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));
+      }
     });
   }
 

package/src/wallet/Util.test.ts

@@ -1,5 +1,4 @@
 import { initProviders, disconnectProviders } from "../network";
-import { ElectrumRawTransaction } from "../network/interface";
 import { RegTestWallet, Wallet } from "./Wif";
 
 beforeAll(async () => {
@@ -41,9 +40,9 @@ describe("Utility tests", () => {
   test("Should get raw transaction", async () => {
     let wallet = await RegTestWallet.fromId(process.env.ALICE_ID!);
     const utxo = (await wallet.getUtxos())[0];
-    const transaction = (await wallet.provider!.getRawTransactionObject(
+    const transaction = await wallet.provider!.getRawTransactionObject(
       utxo.txid
-    )) as ElectrumRawTransaction;
+    );
     expect((await wallet.util.decodeTransaction(transaction.hash)).hash).toBe(
       utxo.txid
     );
@@ -67,15 +66,15 @@ describe("Utility tests", () => {
       "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"
     );
 
-    expect(decoded.vin[0].address).toBeUndefined();
-    expect(decoded.vin[0].value).toBeUndefined();
+    // non-enriched vin entries don't carry vout fields (enforced by types)
+    expect((decoded.vin[0] as any).address).toBeUndefined();
   });
 
   test("Should decode a transaction and fetch input values and addresses", async () => {
     const txHash =
       "dc8f059900807c36941313f10b43ec049e23dfede4e09f8fbccc3871ed359fbe";
     const decoded = await Wallet.util.decodeTransaction(txHash, true);
-    expect(decoded.vin[0].address).toBeDefined();
+    expect(decoded.vin[0].scriptPubKey.addresses[0]).toBeDefined();
     expect(decoded.vin[0].value).toBeDefined();
 
     //  uncomment next line

package/src/wallet/Util.ts

@@ -15,9 +15,9 @@ import { getNetworkProvider } from "../network/default.js";
 import {
   ElectrumRawTransaction,
   ElectrumRawTransactionVin,
-  ElectrumRawTransactionVinScriptSig,
+  ElectrumRawTransactionVinWithValues,
   ElectrumRawTransactionVout,
-  ElectrumRawTransactionVoutScriptPubKey,
+  ElectrumRawTransactionWithInputValues,
 } from "../network/interface.js";
 import NetworkProvider from "../network/NetworkProvider.js";
 import { getTransactionHash } from "../util/transaction.js";
@@ -49,10 +49,18 @@ export class Util {
     return getTransactionHash(rawTransactionHex);
   }
 
+  public async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  public async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
   public async decodeTransaction(
     transactionHashOrHex: string,
     loadInputValues: boolean = false
-  ): Promise<ElectrumRawTransaction> {
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
     let transactionHex: string;
     let transactionBin: Uint8Array;
     let txHash: string;
@@ -89,14 +97,15 @@ export class Util {
       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;
@@ -107,22 +116,30 @@ export class Util {
     txHash: string,
     txHex: string
   ): ElectrumRawTransaction {
-    let result: ElectrumRawTransaction = {} as any;
-
-    result.vin = transaction.inputs.map((input): ElectrumRawTransactionVin => {
-      return {
-        scriptSig: {
-          hex: binToHex(input.unlockingBytecode),
-        } as ElectrumRawTransactionVinScriptSig,
-        sequence: input.sequenceNumber,
-        txid: binToHex(input.outpointTransactionHash),
-        vout: input.outpointIndex,
-      };
-    });
-
-    result.vout = transaction.outputs.map(
-      (output, index): ElectrumRawTransactionVout => {
-        return {
+    return {
+      blockhash: "",
+      blocktime: 0,
+      confirmations: 0,
+      time: 0,
+      hash: txHash,
+      hex: txHex,
+      txid: txHash,
+      locktime: transaction.locktime,
+      version: transaction.version,
+      size: txHex.length / 2,
+      vin: transaction.inputs.map(
+        (input): ElectrumRawTransactionVin => ({
+          scriptSig: {
+            asm: "",
+            hex: binToHex(input.unlockingBytecode),
+          },
+          sequence: input.sequenceNumber,
+          txid: binToHex(input.outpointTransactionHash),
+          vout: input.outpointIndex,
+        })
+      ),
+      vout: transaction.outputs.map(
+        (output, index): ElectrumRawTransactionVout => ({
           n: index,
           scriptPubKey: {
             addresses: [
@@ -132,7 +149,7 @@ export class Util {
                       output.lockingBytecode
                     ).payload,
                     prefix: prefixFromNetworkMap[this.network],
-                  })
+                  }).address
                 : assertSuccess(
                     lockingBytecodeToCashAddress({
                       bytecode: output.lockingBytecode,
@@ -140,31 +157,35 @@ export class Util {
                     })
                   ).address,
             ],
+            asm: "",
             hex: binToHex(output.lockingBytecode),
-          } as ElectrumRawTransactionVoutScriptPubKey,
+            reqSigs: 1,
+            type: "",
+          },
           value: Number(output.valueSatoshis) / Number(bchParam.subUnits),
-        };
-      }
-    );
-
-    result.locktime = transaction.locktime;
-    result.version = transaction.version;
-    result.hash = txHash;
-    result.hex = txHex;
-    result.txid = txHash;
-    result.size = txHex.length / 2;
-
-    return result;
+        })
+      ),
+    };
   }
 
+  public static async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues: true,
+    network?: NetworkType
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  public static async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues?: false,
+    network?: NetworkType
+  ): Promise<ElectrumRawTransaction>;
   public static async decodeTransaction(
     transactionHashOrHex: string,
     loadInputValues: boolean = false,
     network?: NetworkType
-  ): Promise<ElectrumRawTransaction> {
-    return new this(network).decodeTransaction(
-      transactionHashOrHex,
-      loadInputValues
-    );
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
+    if (loadInputValues) {
+      return new this(network).decodeTransaction(transactionHashOrHex, true);
+    }
+    return new this(network).decodeTransaction(transactionHashOrHex);
   }
 }

package/src/wallet/Wif.test.ts

@@ -995,9 +995,7 @@ describe(`Wallet extrema behavior regression testing`, () => {
       OpReturnData.from("MEMO\x10LÖL😅"),
       { cashaddr: wallet.cashaddr!, value: 546n },
     ]);
-    transaction = (await wallet.provider!.getRawTransactionObject(
-      result.txId!
-    )) as ElectrumRawTransaction;
+    transaction = await wallet.provider!.getRawTransactionObject(result.txId!);
     expect(transaction.vout[0].scriptPubKey.asm).toContain("OP_RETURN");
     expect(transaction.vout[0].scriptPubKey.hex.slice(4)).toBe(
       binToHex(utf8ToBin("MEMO\x10LÖL😅"))
@@ -1007,9 +1005,7 @@ describe(`Wallet extrema behavior regression testing`, () => {
       [wallet.cashaddr!, 546n],
       ["OP_RETURN", Uint8Array.from([0x00, 0x01, 0x02])],
     ]);
-    transaction = (await wallet.provider!.getRawTransactionObject(
-      result.txId!
-    )) as ElectrumRawTransaction;
+    transaction = await wallet.provider!.getRawTransactionObject(result.txId!);
     expect(transaction.vout[1].scriptPubKey.asm).toContain("OP_RETURN");
     expect([
       ...hexToBin(transaction.vout[1].scriptPubKey.hex.slice(4)),
@@ -1019,9 +1015,7 @@ describe(`Wallet extrema behavior regression testing`, () => {
       OpReturnData.from(""),
       OpReturnData.from(Uint8Array.from([])),
     ]);
-    transaction = (await wallet.provider!.getRawTransactionObject(
-      result.txId!
-    )) as ElectrumRawTransaction;
+    transaction = await wallet.provider!.getRawTransactionObject(result.txId!);
     expect(transaction.vout[0].scriptPubKey.asm).toContain("OP_RETURN");
     expect([...hexToBin(transaction.vout[0].scriptPubKey.hex)]).toStrictEqual([
       0x6a, 0x00,