@stellar/typescript-wallet-sdk 5.0.0-beta.1788566740000 → 5.0.0

package/lib/walletSdk/Watcher/index.d.ts

@@ -49,7 +49,7 @@ export declare class Watcher {
     watchAllTransactions({ authToken, assetCode, onMessage, onError, watchlist, timeout, isRetry, lang, kind, noOlderThan, }: WatchTransactionsParams): WatcherResponse;
     /**
      * Watch a transaction until it stops pending. Takes three callbacks:
-     * * onMessage - When the transaction comes back as pending_ or incomplete.
+     * * onMessage - When the transaction comes back as pending_, incomplete, or on_hold.
      * * onSuccess - When the transaction comes back as completed / refunded / expired.
      * * onError - When there's a runtime error, or the transaction comes back as
      * no_market / too_small / too_large / error.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "5.0.0-beta.1788566740000",
+  "version": "5.0.0",
   "engines": {
     "node": ">=22.12.0"
   },
@@ -77,4 +77,4 @@
     "example:sep24": "ts-node examples/sep24/sep24.ts",
     "example:sep12": "ts-node examples/sep12/sep12.ts"
   }
-}
+}

package/src/walletSdk/Watcher/index.ts

@@ -168,7 +168,8 @@ export class Watcher {
           const newTransactions = transactions.filter((transaction) => {
             const isInProgress =
               transaction.status.indexOf("pending") === 0 ||
-              transaction.status === TransactionStatus.incomplete;
+              transaction.status === TransactionStatus.incomplete ||
+              transaction.status === TransactionStatus.on_hold;
             const registeredTransaction =
               this._transactionsRegistry[assetCode][transaction.id];
 
@@ -275,7 +276,7 @@ export class Watcher {
 
   /**
    * Watch a transaction until it stops pending. Takes three callbacks:
-   * * onMessage - When the transaction comes back as pending_ or incomplete.
+   * * onMessage - When the transaction comes back as pending_, incomplete, or on_hold.
    * * onSuccess - When the transaction comes back as completed / refunded / expired.
    * * onError - When there's a runtime error, or the transaction comes back as
    * no_market / too_small / too_large / error.
@@ -368,7 +369,8 @@ export class Watcher {
 
         if (
           transaction.status.indexOf("pending") === 0 ||
-          transaction.status === TransactionStatus.incomplete
+          transaction.status === TransactionStatus.incomplete ||
+          transaction.status === TransactionStatus.on_hold
         ) {
           if (this._oneTransactionWatcher[assetCode][id]) {
             clearTimeout(this._oneTransactionWatcher[assetCode][id]);

package/test/wallet.test.ts

@@ -930,6 +930,83 @@ describe("Anchor", () => {
       // stops watching
       stop();
     });
+
+    test("on_hold is transient: not ignored on first poll", async () => {
+      const onMessage = sinon.spy();
+      const onError = sinon.spy();
+
+      const onHoldTransaction = makeTransaction(0, TransactionStatus.on_hold);
+      const completedTransaction = {
+        ...onHoldTransaction,
+        status: TransactionStatus.completed,
+      };
+
+      // first poll returns on_hold, second returns completed
+      jest
+        .spyOn(Sep24.prototype, "getTransactionsForAsset")
+        .mockResolvedValueOnce([onHoldTransaction])
+        .mockResolvedValueOnce([completedTransaction]);
+
+      const { stop } = watcher.watchAllTransactions({
+        authToken,
+        assetCode: "SRT",
+        lang: "en-US",
+        onMessage,
+        onError,
+        timeout: 1,
+      });
+
+      await sleep(1);
+
+      // on_hold must be treated as in-progress, not silently ignored
+      expect(onError.callCount).toBe(0);
+      expect(onMessage.callCount).toBe(1);
+
+      clock.next();
+      await sleep(1);
+
+      // now completed, reported as a status change
+      expect(onError.callCount).toBe(0);
+      expect(onMessage.callCount).toBe(2);
+
+      stop();
+    });
+
+    test("on_hold reported once when status unchanged across polls", async () => {
+      const onMessage = sinon.spy();
+      const onError = sinon.spy();
+
+      const onHoldTransaction = makeTransaction(0, TransactionStatus.on_hold);
+
+      // two consecutive polls return the same on_hold status
+      jest
+        .spyOn(Sep24.prototype, "getTransactionsForAsset")
+        .mockResolvedValueOnce([onHoldTransaction])
+        .mockResolvedValueOnce([onHoldTransaction]);
+
+      const { stop } = watcher.watchAllTransactions({
+        authToken,
+        assetCode: "SRT",
+        lang: "en-US",
+        onMessage,
+        onError,
+        timeout: 1,
+      });
+
+      await sleep(1);
+
+      // first poll: reported
+      expect(onMessage.callCount).toBe(1);
+
+      clock.next();
+      await sleep(1);
+
+      // second poll: same status, not reported again
+      expect(onMessage.callCount).toBe(1);
+      expect(onError.callCount).toBe(0);
+
+      stop();
+    });
   });
 
   describe("watchOneTransaction", () => {
@@ -946,6 +1023,51 @@ describe("Anchor", () => {
       clock.restore();
     });
 
+    test("on_hold is transient: keeps watching until completed", async () => {
+      const onMessage = sinon.spy();
+      const onSuccess = sinon.spy();
+      const onError = sinon.spy();
+
+      const onHoldTransaction = makeTransaction(0, TransactionStatus.on_hold);
+      const completedTransaction = {
+        ...onHoldTransaction,
+        status: TransactionStatus.completed,
+      };
+
+      // first poll returns on_hold, the next returns completed
+      jest
+        .spyOn(Sep24.prototype, "getTransactionBy")
+        .mockResolvedValueOnce(onHoldTransaction)
+        .mockResolvedValueOnce(completedTransaction);
+
+      const { stop } = watcher.watchOneTransaction({
+        authToken,
+        assetCode: "SRT",
+        id: onHoldTransaction.id,
+        onMessage,
+        onSuccess,
+        onError,
+        timeout: 1,
+        lang: "en-US",
+      });
+
+      // first poll: on_hold is transient, so it must keep watching, not error out
+      await sleep(1);
+      expect(onError.callCount).toBe(0);
+      expect(onSuccess.callCount).toBe(0);
+      expect(onMessage.callCount).toBe(1);
+
+      clock.next();
+      await sleep(1);
+
+      // second poll: now completed, so onSuccess fires and onError never does
+      expect(onError.callCount).toBe(0);
+      expect(onSuccess.callCount).toBe(1);
+      expect(onMessage.callCount).toBe(1);
+
+      stop();
+    });
+
     test("One completed / refunded / expired successes", async () => {
       const onMessage = sinon.spy(() => {
         expect(onMessage.callCount).toBe(0);