mainnet-js 3.1.7 → 4.0.0-next.2

package/src/network/subscription.test.ts

@@ -0,0 +1,268 @@
+import { webSocket } from "@rpckit/websocket/electrum-cash";
+import { createProvider, setGlobalProvider, removeGlobalProvider } from ".";
+import { Network } from "../interface";
+import type { Transport, Unsubscribe } from "@rpckit/core";
+import type { ElectrumCashSchema } from "@rpckit/core/electrum-cash";
+import { Wallet } from "../wallet/Wif";
+
+describe("Provider subscription: blockchain.transaction.subscribe", () => {
+  let provider: Awaited<ReturnType<typeof createProvider>>;
+
+  beforeAll(async () => {
+    provider = await createProvider(Network.MAINNET);
+  });
+
+  afterAll(async () => {
+    await provider.disconnect();
+  });
+
+  test("Should receive initial confirmation count for confirmed transaction", async () => {
+    // A well-known confirmed BCH transaction
+    const txHash =
+      "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
+
+    const received: Array<[string, number | null]> = [];
+    const cancel = await provider.subscribeToTransaction(txHash, (data) => {
+      received.push(data);
+    });
+
+    // Wait a short time for the initial result to arrive
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // Initial result should be [txHash, confirmations]
+    expect(received[0][0]).toBe(txHash);
+    expect(received[0][1]).toBeGreaterThan(0); // Confirmed transaction has > 0 confirmations
+
+    await cancel();
+  });
+
+  test("Should receive null for unconfirmed/unknown transaction", async () => {
+    // A made-up transaction hash that doesn't exist
+    const fakeTxHash =
+      "0000000000000000000000000000000000000000000000000000000000000000";
+
+    const received: Array<[string, number | null]> = [];
+    const cancel = await provider.subscribeToTransaction(fakeTxHash, (data) => {
+      received.push(data);
+    });
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // Unknown transaction should return [txHash, null]
+    expect(received[0][0]).toBe(fakeTxHash);
+    expect(received[0][1]).toBeNull();
+
+    await cancel();
+  });
+});
+
+describe("Provider subscription: blockchain.address.subscribe", () => {
+  let provider: Awaited<ReturnType<typeof createProvider>>;
+
+  beforeAll(async () => {
+    provider = await createProvider(Network.MAINNET);
+  });
+
+  afterAll(async () => {
+    await provider.disconnect();
+  });
+
+  test("Should receive initial status for address with history", async () => {
+    // The Bitcoin genesis address (has transaction history)
+    const address = "bitcoincash:qp3wjpa3tjlj042z2wv7hahsldgwhwy0rq9sywjpyy";
+
+    const received: Array<[string, string | null]> = [];
+    const cancel = await provider.subscribeToAddress(address, (data) => {
+      received.push(data);
+    });
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // Initial result should be [address, status_hash]
+    expect(received[0][0]).toBe(address);
+    expect(received[0][1]).not.toBeNull(); // Address with history has a status hash
+    expect(typeof received[0][1]).toBe("string");
+
+    await cancel();
+  });
+
+  test("Should receive null status for unused address", async () => {
+    // A valid but never-used address (generated from random pubkey hash)
+    // Using a standard P2PKH address with unlikely-to-be-used hash
+    const unusedAddress =
+      "bitcoincash:qr95sy3j9xwd2ap32xkykttr4cvcu7as4y0qverfuy";
+
+    const received: Array<[string, string | null]> = [];
+    const cancel = await provider.subscribeToAddress(unusedAddress, (data) => {
+      received.push(data);
+    });
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // Unused address should have null status
+    expect(received[0][0]).toBe(unusedAddress);
+    expect(received[0][1]).toBeNull();
+
+    await cancel();
+  });
+});
+
+describe("Provider subscription: blockchain.headers.subscribe", () => {
+  let provider: Awaited<ReturnType<typeof createProvider>>;
+
+  beforeAll(async () => {
+    provider = await createProvider(Network.MAINNET);
+  });
+
+  afterAll(async () => {
+    await provider.disconnect();
+  });
+
+  test("Should receive initial block header", async () => {
+    const received: Array<{ height: number; hex: string }> = [];
+    const cancel = await provider.subscribeToHeaders((header) => {
+      received.push(header);
+    });
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // Header should have height and hex
+    expect(received[0].height).toBeGreaterThan(800000);
+    expect(typeof received[0].hex).toBe("string");
+    expect(received[0].hex.length).toBeGreaterThan(0);
+
+    await cancel();
+  });
+});
+
+describe("Raw transport subscription format", () => {
+  let transport: Transport<ElectrumCashSchema>;
+
+  beforeAll(async () => {
+    transport = webSocket("wss://fulcrum.pat.mn:50004");
+    await transport.connect();
+  });
+
+  afterAll(async () => {
+    await transport.close();
+  });
+
+  test("blockchain.transaction.subscribe returns [txHash, confirmations] format", async () => {
+    const txHash =
+      "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
+
+    const received: unknown[] = [];
+    const unsub: Unsubscribe = await transport.subscribe(
+      "blockchain.transaction.subscribe",
+      txHash,
+      (data) => {
+        received.push(data);
+      }
+    );
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // With transformInitialResult, format should be [txHash, confirmations]
+    const data = received[0] as [string, number | null];
+    expect(Array.isArray(data)).toBe(true);
+    expect(data[0]).toBe(txHash);
+    expect(typeof data[1]).toBe("number");
+
+    await unsub();
+  });
+
+  test("blockchain.address.subscribe returns [address, status] format", async () => {
+    const address = "bitcoincash:qp3wjpa3tjlj042z2wv7hahsldgwhwy0rq9sywjpyy";
+
+    const received: unknown[] = [];
+    const unsub: Unsubscribe = await transport.subscribe(
+      "blockchain.address.subscribe",
+      address,
+      (data) => {
+        received.push(data);
+      }
+    );
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // With transformInitialResult, format should be [address, status]
+    const data = received[0] as [string, string | null];
+    expect(Array.isArray(data)).toBe(true);
+    expect(data[0]).toBe(address);
+    expect(typeof data[1]).toBe("string");
+
+    await unsub();
+  });
+
+  test("blockchain.headers.subscribe returns [header] format", async () => {
+    const received: unknown[] = [];
+    const unsub: Unsubscribe = await transport.subscribe(
+      "blockchain.headers.subscribe",
+      (data) => {
+        received.push(data);
+      }
+    );
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received.length).toBeGreaterThanOrEqual(1);
+    // With transformInitialResult (no params), format should be [header]
+    const data = received[0] as [{ height: number; hex: string }];
+    expect(Array.isArray(data)).toBe(true);
+    expect(data[0].height).toBeGreaterThan(800000);
+    expect(typeof data[0].hex).toBe("string");
+
+    await unsub();
+  });
+});
+
+describe("Wallet waitForTransaction with specific txHash", () => {
+  let wallet: Wallet;
+  let provider: Awaited<ReturnType<typeof createProvider>>;
+
+  beforeAll(async () => {
+    // Create provider for mainnet and set it globally
+    provider = await createProvider(Network.MAINNET);
+    await provider.connect();
+    setGlobalProvider(Network.MAINNET, provider);
+
+    // Create a mainnet wallet using the global provider
+    wallet = await Wallet.watchOnly(
+      "bitcoincash:qp3wjpa3tjlj042z2wv7hahsldgwhwy0rq9sywjpyy"
+    );
+  });
+
+  afterAll(async () => {
+    removeGlobalProvider(Network.MAINNET);
+    await provider?.disconnect();
+  });
+
+  test("Should resolve immediately for confirmed transaction", async () => {
+    // A well-known confirmed BCH transaction
+    const txHash =
+      "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
+
+    // waitForTransaction with a specific txHash should resolve when confirmations > 0
+    const result = await Promise.race([
+      wallet.waitForTransaction({
+        txHash,
+        getTransactionInfo: true,
+        getBalance: false,
+      }),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("Timeout")), 5000)
+      ),
+    ]);
+
+    expect(result).toBeDefined();
+    expect((result as any).transactionInfo).toBeDefined();
+    expect((result as any).transactionInfo.hash).toBe(txHash);
+  });
+});

package/src/wallet/Base.ts

@@ -486,6 +486,12 @@ export class BaseWallet implements WalletI {
   // waits for address balance to be greater than or equal to the target value
   // this call halts the execution
   public async waitForBalance(value: bigint): Promise<bigint> {
+    // Check if condition is already met before watching
+    const currentBalance = await this.getBalance();
+    if (currentBalance >= value) {
+      return currentBalance;
+    }
+
     return new Promise(async (resolve) => {
       let watchCancel: CancelFn;
       watchCancel = await this.watchBalance(async (balance: bigint) => {
@@ -515,6 +521,12 @@ export class BaseWallet implements WalletI {
     category: string,
     amount: bigint
   ): Promise<bigint> {
+    // Check if condition is already met before watching
+    const currentBalance = await this.getTokenBalance(category);
+    if (currentBalance >= amount) {
+      return currentBalance;
+    }
+
     return new Promise(async (resolve) => {
       let watchCancel: CancelFn;
       watchCancel = await this.watchTokenBalance(
@@ -701,11 +713,19 @@ export class BaseWallet implements WalletI {
     resp.categories = categories;
 
     if (options?.buildUnsigned !== true) {
-      const txId = await this.submitTransaction(
-        encodedTransaction,
+      const awaitPropagation =
         options?.awaitTransactionPropagation === undefined ||
-          options?.awaitTransactionPropagation === true
-      );
+        options?.awaitTransactionPropagation === true;
+
+      let updatePromise: Promise<void>;
+      if (awaitPropagation) {
+        updatePromise = this.waitForUpdate({ timeout: 2500 });
+      }
+
+      const [_, txId] = await Promise.all([
+        updatePromise!,
+        this.submitTransaction(encodedTransaction, awaitPropagation),
+      ]);
 
       resp.txId = txId;
       resp.explorerUrl = this.explorerUrl(resp.txId);
@@ -778,11 +798,19 @@ export class BaseWallet implements WalletI {
     resp.categories = categories;
 
     if (options?.buildUnsigned !== true) {
-      const txId = await this.submitTransaction(
-        encodedTransaction,
+      const awaitPropagation =
         options?.awaitTransactionPropagation === undefined ||
-          options?.awaitTransactionPropagation === true
-      );
+        options?.awaitTransactionPropagation === true;
+
+      let updatePromise: Promise<void>;
+      if (awaitPropagation) {
+        updatePromise = this.waitForUpdate({ timeout: 2500 });
+      }
+
+      const [_, txId] = await Promise.all([
+        updatePromise!,
+        this.submitTransaction(encodedTransaction, awaitPropagation),
+      ]);
 
       resp.txId = txId;
       resp.explorerUrl = this.explorerUrl(resp.txId);
@@ -1107,15 +1135,9 @@ export class BaseWallet implements WalletI {
 
       // waiting for any address transaction
       let watchCancel: CancelFn;
-      let initialResponseSeen = false;
       watchCancel = await this.watchStatus(async (_status) => {
-        if (initialResponseSeen) {
-          await watchCancel?.();
-          resolve(makeResponse());
-          return;
-        }
-
-        initialResponseSeen = true;
+        await watchCancel?.();
+        resolve(makeResponse());
       });
     });
   }
@@ -1416,7 +1438,7 @@ export class BaseWallet implements WalletI {
    */
   public async getTokenBalance(category: string): Promise<bigint> {
     const utxos = (await this.getTokenUtxos(category)).filter(
-      (val) => val.token?.amount
+      (val) => val.token?.amount && val.token?.category === category
     );
     return sumTokenAmounts(utxos, category);
   }

package/src/wallet/Cashtokens.test.headless.js

@@ -601,6 +601,8 @@ describe(`Wallet should function in the browser`, () => {
           sourceOutputs
         );
         await aliceWallet.submitTransaction(signed);
+        await aliceWallet.waitForUpdate();
+        await aliceWatchWallet.waitForUpdate();
 
         category = categories[0];
 
@@ -653,6 +655,8 @@ describe(`Wallet should function in the browser`, () => {
           sourceOutputs
         );
         await aliceWallet.submitTransaction(signed);
+        await aliceWallet.waitForUpdate();
+        await aliceWatchWallet.waitForUpdate();
 
         expect(await aliceWallet.getNftTokenBalance(category)).toBe(2);
         const tokenUtxos = await aliceWallet.getTokenUtxos(category);
@@ -711,6 +715,8 @@ describe(`Wallet should function in the browser`, () => {
           sourceOutputs
         );
         await aliceWallet.submitTransaction(signed);
+        await aliceWallet.waitForUpdate();
+
         expect(await aliceWallet.getNftTokenBalance(category)).toBe(2);
         const tokenUtxos = await aliceWallet.getTokenUtxos(category);
         expect(tokenUtxos.length).toBe(2);

package/src/wallet/Cashtokens.test.ts

@@ -934,6 +934,7 @@ describe(`Test cashtokens`, () => {
 
     // prepare inputs for two token geneses
     await alice.send({ cashaddr: bob.cashaddr!, value: 10000n });
+    await bob.waitForUpdate();
 
     const genesisResponse = await bob.tokenGenesis({
       nft: {
@@ -1221,7 +1222,13 @@ describe(`Test cashtokens`, () => {
         unsignedTransaction!,
         sourceOutputs!
       );
+      const statusChanged = aliceWallet.waitForUpdate({ timeout: 10000 });
+      const watchStatusChanged = aliceWatchWallet.waitForUpdate({
+        timeout: 10000,
+      });
       await aliceWallet.submitTransaction(signed);
+      await statusChanged;
+      await watchStatusChanged;
 
       category = categories![0];
 
@@ -1269,7 +1276,13 @@ describe(`Test cashtokens`, () => {
         unsignedTransaction!,
         sourceOutputs!
       );
+      const statusChanged2 = aliceWallet.waitForUpdate({ timeout: 10000 });
+      const watchStatusChanged2 = aliceWatchWallet.waitForUpdate({
+        timeout: 10000,
+      });
       await aliceWallet.submitTransaction(signed);
+      await statusChanged2;
+      await watchStatusChanged2;
 
       expect(await aliceWallet.getNftTokenBalance(category)).toBe(2);
       const tokenUtxos = await aliceWallet.getTokenUtxos(category);

package/src/wallet/HDWallet.test.ts

@@ -389,7 +389,7 @@ describe("HDWallet", () => {
     hdWallet.getChangeAddress(100);
 
     // persist cache
-    await hdWallet.walletCache.persist();
+    await hdWallet.walletCache.persist(true);
 
     // check cache data is there in other instance
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
@@ -458,7 +458,7 @@ describe("HDWallet", () => {
     ).toBe(1);
 
     // persist cache
-    await hdWallet.walletCache.persist();
+    await hdWallet.walletCache.persist(true);
 
     // check cache data is there in other instance
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
@@ -507,7 +507,7 @@ describe("HDWallet", () => {
     ).toBe(1);
 
     // persist cache
-    await hdWallet.walletCache.persist();
+    await hdWallet.walletCache.persist(true);
 
     // check cache data is there in other instance
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
@@ -620,7 +620,7 @@ describe("HDWallet", () => {
     expect(rawHistory.length).toBe(2);
 
     // Persist and reload - cache should be preserved
-    await hdWallet.walletCache.persist();
+    await hdWallet.walletCache.persist(true);
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
     await otherWallet.watchPromise;
 

package/src/wallet/HDWallet.ts

@@ -16,7 +16,7 @@ import {
   sha256,
   utf8ToBin,
 } from "@bitauth/libauth";
-import { PersistentWalletCache, WalletCacheI } from "../cache/index.js";
+import { HDWalletCache, WalletCacheI } from "../cache/index.js";
 import { Config } from "../config.js";
 import { NetworkType, prefixFromNetworkMap, UnitEnum } from "../enum.js";
 import { getHistory } from "../history/getHistory.js";
@@ -240,7 +240,7 @@ export class HDWallet extends BaseWallet {
       )
     );
     // @ts-ignore
-    this.walletCache = new PersistentWalletCache(
+    this.walletCache = new HDWalletCache(
       this.walletId,
       this.xPrivNode ?? this.xPubNode,
       this.networkPrefix
@@ -529,41 +529,25 @@ export class HDWallet extends BaseWallet {
 
     if (isSatisfied()) return;
 
-    return new Promise(async (resolve) => {
-      let timer: ReturnType<typeof setTimeout>;
-      let resolved = false;
-      let watchCancel: CancelFn;
-
-      const done = async () => {
-        if (resolved) return;
-        resolved = true;
-        clearTimeout(timer);
-        await watchCancel?.();
-        resolve();
-      };
-
-      const resetTimer = () => {
-        clearTimeout(timer);
-        timer = setTimeout(done, timeout);
-      };
-
-      // Uses default 100ms debounce — callback only fires after 100ms of
-      // quiet, meaning the cascade has settled before we check the condition.
-      watchCancel = await this.watchStatus(async () => {
-        if (isSatisfied()) {
-          await done();
-        } else {
-          resetTimer(); // cascade settled but target not met — wait for more activity
-        }
+    // Single watcher that resolves a rotating promise on each status change
+    let statusResolve: () => void;
+    const cancel = await this.watchStatus(() => {
+      statusResolve?.();
+    });
+
+    // Race status changes against idle timeout; reset timeout on each change
+    while (!isSatisfied()) {
+      const statusChange = new Promise<"status">((resolve) => {
+        statusResolve = () => resolve("status");
       });
+      const idle = new Promise<"idle">((resolve) =>
+        setTimeout(resolve, timeout, "idle")
+      );
 
-      // Re-check + start initial idle timer after subscription
-      if (isSatisfied()) {
-        await done();
-      } else {
-        resetTimer();
-      }
-    });
+      if ((await Promise.race([statusChange, idle])) === "idle") break;
+    }
+
+    await cancel();
   }
 
   /**

package/src/wallet/WalletCache.test.ts

@@ -35,11 +35,15 @@ describe("Wallet cache initialization", () => {
     await wallet.stop();
   });
 
-  test("Watch wallet should have empty walletCache", async () => {
+  test("Watch wallet should have walletCache without private key", async () => {
     const wallet = await RegTestWatchWallet.watchOnly(
       "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0"
     );
     expect(wallet.walletCache).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeUndefined();
+    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeDefined();
+    expect(
+      wallet.walletCache!.get(wallet.cashaddr)!.privateKey
+    ).toBeUndefined();
+    await wallet.stop();
   });
 });