@stellar/typescript-wallet-sdk 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "engines": {
     "node": ">=18"
   },

package/src/walletSdk/Watcher/index.ts

@@ -1,5 +1,3 @@
-import isEqual from "lodash/isEqual";
-
 import { Anchor } from "../Anchor";
 import {
   AnchorTransaction,
@@ -151,9 +149,9 @@ export class Watcher {
               return isInProgress;
             }
 
-            // if we've had the transaction before, only report updates
+            // if we've had the transaction before, only report updates if status changed
             if (registeredTransaction) {
-              return !isEqual(registeredTransaction, transaction);
+              return registeredTransaction.status !== transaction.status;
             }
 
             // if it's NOT a registered transaction, and it's not the first
@@ -296,12 +294,13 @@ export class Watcher {
         const registeredTransaction =
           this._transactionsRegistry[assetCode][transaction.id];
 
-        // if we've had the transaction before, only report if there is a change
+        // if we've had the transaction before, only report if there is a status change
+        let isChanged = true;
         if (
           registeredTransaction &&
-          isEqual(registeredTransaction, transaction)
+          registeredTransaction.status === transaction.status
         ) {
-          return;
+          isChanged = false;
         }
 
         this._transactionsRegistry[assetCode][transaction.id] = transaction;
@@ -320,7 +319,9 @@ export class Watcher {
               isRetry: true,
             });
           }, timeout);
-          onMessage(transaction);
+          if (isChanged) {
+            onMessage(transaction);
+          }
         } else if (
           [
             TransactionStatus.completed,

package/test/wallet.test.ts

@@ -64,6 +64,13 @@ describe("SEP-24 flow", () => {
 let anchor: Anchor;
 let accountKp: SigningKeypair;
 let authToken: string;
+const makeTransaction = (eta: number, txStatus: TransactionStatus) => ({
+  kind: "deposit",
+  id: "TEST",
+  status: txStatus,
+  status_eta: eta,
+  message: "some message",
+});
 describe("Anchor", () => {
   beforeAll(() => {
     const Wal = Wallet.TestNet();
@@ -809,6 +816,56 @@ describe("Anchor", () => {
       expect(onMessage.callCount).toBe(3);
       expect(onError.callCount).toBe(0);
 
+      // stops watching
+      stop();
+    });
+    it("should only report transactions with changed status", async () => {
+      const txn1 = makeTransaction(0, TransactionStatus.incomplete);
+      const txn2 = makeTransaction(0, TransactionStatus.incomplete);
+      txn2.message = "message changing";
+      const txn3 = makeTransaction(0, TransactionStatus.pending_anchor);
+
+      const onMessage = sinon.spy((m) => {
+        expect(m.message).toBe("some message");
+        expect(onMessage.callCount).toBeLessThan(3);
+      });
+
+      const onError = sinon.spy((e) => {
+        expect(e).toBeUndefined();
+      });
+
+      // mock default transactions response
+      jest
+        .spyOn(Sep24.prototype, "getTransactionsForAsset")
+        .mockResolvedValueOnce([txn1])
+        .mockResolvedValueOnce([txn2])
+        .mockResolvedValueOnce([txn3]);
+
+      // start watching
+      const watcher = anchor.sep24().watcher();
+      const { stop } = watcher.watchAllTransactions({
+        authToken,
+        assetCode: "SRT",
+        lang: "en-US",
+        onMessage,
+        onError,
+        timeout: 1,
+      });
+
+      // nothing should run at first (async api call in progress)
+      expect(onMessage.callCount).toBe(0);
+      expect(onError.callCount).toBe(0);
+
+      clock.next();
+      await sleep(1);
+      clock.next();
+      await sleep(1);
+      clock.next();
+      await sleep(1);
+
+      expect(onMessage.callCount).toBe(2);
+      expect(onError.callCount).toBe(0);
+
       // stops watching
       stop();
     });
@@ -818,13 +875,6 @@ describe("Anchor", () => {
     let clock: sinon.SinonFakeTimers;
     let watcher: Watcher;
 
-    const makeTransaction = (eta: number, txStatus: TransactionStatus) => ({
-      kind: "deposit",
-      id: "TEST",
-      status: txStatus,
-      status_eta: eta,
-    });
-
     beforeEach(async () => {
       clock = sinon.useFakeTimers(0);
       watcher = anchor.sep24().watcher();
@@ -1120,7 +1170,7 @@ describe("Anchor", () => {
     });
 
     test("Several pending transactions, one completed, no more after that", async () => {
-      const onMessage = sinon.spy(() => {
+      const onMessage = sinon.spy((m) => {
         expect(onMessage.callCount).toBeLessThanOrEqual(8);
       });
 
@@ -1142,27 +1192,31 @@ describe("Anchor", () => {
         .mockResolvedValueOnce(
           makeTransaction(2, TransactionStatus.pending_anchor),
         )
+        // should not be logged to onMessage
         .mockResolvedValueOnce(
-          makeTransaction(3, TransactionStatus.pending_external),
+          makeTransaction(3, TransactionStatus.pending_anchor),
         )
         .mockResolvedValueOnce(
-          makeTransaction(4, TransactionStatus.pending_stellar),
+          makeTransaction(4, TransactionStatus.pending_external),
         )
         .mockResolvedValueOnce(
-          makeTransaction(5, TransactionStatus.pending_trust),
+          makeTransaction(5, TransactionStatus.pending_stellar),
+        )
+        .mockResolvedValueOnce(
+          makeTransaction(6, TransactionStatus.pending_trust),
         )
         .mockResolvedValueOnce(
-          makeTransaction(6, TransactionStatus.pending_user_transfer_start),
+          makeTransaction(7, TransactionStatus.pending_user_transfer_start),
         )
         .mockResolvedValueOnce(
-          makeTransaction(7, TransactionStatus.pending_user_transfer_complete),
+          makeTransaction(8, TransactionStatus.pending_user_transfer_complete),
         )
-        .mockResolvedValueOnce(makeTransaction(8, TransactionStatus.completed))
+        .mockResolvedValueOnce(makeTransaction(9, TransactionStatus.completed))
         .mockResolvedValueOnce(
-          makeTransaction(9, TransactionStatus.pending_anchor),
+          makeTransaction(10, TransactionStatus.pending_anchor),
         )
         .mockResolvedValueOnce(
-          makeTransaction(10, TransactionStatus.pending_external),
+          makeTransaction(11, TransactionStatus.pending_external),
         );
 
       // start watching
@@ -1206,6 +1260,9 @@ describe("Anchor", () => {
       clock.next();
       await sleep(1);
 
+      clock.next();
+      await sleep(1);
+
       // 1 incomplete + 7 pending transactions
       expect(onMessage.callCount).toBe(8);
       expect(onSuccess.callCount).toBe(0);
@@ -1686,6 +1743,64 @@ describe("Anchor", () => {
       expect(onSuccess.callCount).toBe(0);
       expect(onError.callCount).toBe(1);
     });
+
+    it("should only report transactions with changed status", async () => {
+      const txn1 = makeTransaction(0, TransactionStatus.incomplete);
+      const txn2 = makeTransaction(0, TransactionStatus.incomplete);
+      txn2.message = "message changing";
+      const txn3 = makeTransaction(0, TransactionStatus.pending_anchor);
+
+      const onMessage = sinon.spy((m) => {
+        expect(m.message).toBe("some message");
+        expect(onMessage.callCount).toBeLessThan(3);
+      });
+
+      const onSuccess = sinon.spy(() => {
+        expect(onSuccess.callCount).toBe(0);
+      });
+
+      const onError = sinon.spy((e) => {
+        expect(e).toBeUndefined();
+      });
+
+      // mock default transactions response
+      jest
+        .spyOn(Sep24.prototype, "getTransactionBy")
+        .mockResolvedValueOnce(txn1)
+        .mockResolvedValueOnce(txn2)
+        .mockResolvedValueOnce(txn3);
+
+      // start watching
+      const watcher = anchor.sep24().watcher();
+      const { stop } = watcher.watchOneTransaction({
+        authToken,
+        assetCode: "SRT",
+        id: "TEST",
+        lang: "en-US",
+        onMessage,
+        onSuccess,
+        onError,
+        timeout: 1,
+      });
+
+      // nothing should run at first (async api call in progress)
+      expect(onMessage.callCount).toBe(0);
+      expect(onError.callCount).toBe(0);
+
+      clock.next();
+      await sleep(1);
+      clock.next();
+      await sleep(1);
+      clock.next();
+      await sleep(1);
+
+      expect(onMessage.callCount).toBe(2);
+      expect(onError.callCount).toBe(0);
+      expect(onSuccess.callCount).toBe(0);
+
+      // stops watching
+      stop();
+    });
   });
 });