@stellar/typescript-wallet-sdk 1.1.1 → 1.1.3

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

@@ -54,3 +54,6 @@ export declare class WithdrawalTxNotPendingUserTransferStartError extends Error
 export declare class WithdrawalTxMissingMemoError extends Error {
     constructor();
 }
+export declare class WithdrawalTxMemoError extends Error {
+    constructor();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "engines": {
     "node": ">=18"
   },
@@ -40,7 +40,7 @@
     "jws": "^4.0.0",
     "lodash": "^4.17.21",
     "query-string": "^7.1.3",
-    "stellar-sdk": "^10.4.1",
+    "stellar-sdk": "^11.0.0-beta.3",
     "stream-http": "^3.2.0",
     "url": "^0.11.0",
     "util": "^0.12.5",

package/src/walletSdk/Exceptions/index.ts

@@ -146,3 +146,10 @@ export class WithdrawalTxMissingMemoError extends Error {
     Object.setPrototypeOf(this, WithdrawalTxMissingMemoError.prototype);
   }
 }
+
+export class WithdrawalTxMemoError extends Error {
+  constructor() {
+    super(`Error parsing withdrawal transaction memo`);
+    Object.setPrototypeOf(this, WithdrawalTxMemoError.prototype);
+  }
+}

package/src/walletSdk/Horizon/Transaction/TransactionBuilder.ts

@@ -14,6 +14,7 @@ import {
   InsufficientStartingBalanceError,
   WithdrawalTxMissingMemoError,
   WithdrawalTxNotPendingUserTransferStartError,
+  WithdrawalTxMemoError,
 } from "../../Exceptions";
 import { IssuedAssetId, StellarAssetId } from "../../Asset";
 import { WithdrawTransaction, TransactionStatus } from "../../Types";
@@ -129,9 +130,21 @@ export class TransactionBuilder {
       throw new WithdrawalTxMissingMemoError();
     }
 
-    return this.setMemo(
-      new Memo(transaction.withdraw_memo_type, transaction.withdraw_memo),
-    ).transfer(
+    if (transaction.withdraw_memo_type === "hash") {
+      try {
+        const buffer = Buffer.from(transaction.withdraw_memo, "base64");
+        const memo = Memo.hash(buffer.toString("hex"));
+        this.setMemo(memo);
+      } catch {
+        throw new WithdrawalTxMemoError();
+      }
+    } else {
+      this.setMemo(
+        new Memo(transaction.withdraw_memo_type, transaction.withdraw_memo),
+      );
+    }
+
+    return this.transfer(
       transaction.withdraw_anchor_account,
       assetId,
       transaction.amount_in,

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/stellar.test.ts

@@ -36,7 +36,7 @@ describe("Stellar", () => {
     } catch (e) {
       await axios.get("https://friendbot.stellar.org/?addr=" + kp.publicKey);
     }
-  });
+  }, 10000);
   it("should create and submit a transaction", async () => {
     const now = Math.floor(Date.now() / 1000) - 5;
 
@@ -198,32 +198,53 @@ describe("Stellar", () => {
     kp.sign(tx);
   });
   it("should transfer withdrawal transaction", async () => {
-    const walletTransaction = {
-      id: "db15d166-5a5e-4d5c-ba5d-271c32cd8cf0",
-      kind: "withdrawal",
-      status: TransactionStatus.pending_user_transfer_start,
-      amount_in: "50.55",
-      withdraw_memo_type: "text",
-      withdraw_memo: "the withdraw memo",
-      withdraw_anchor_account:
-        "GCSGSR6KQQ5BP2FXVPWRL6SWPUSFWLVONLIBJZUKTVQB5FYJFVL6XOXE",
-    } as WithdrawTransaction;
+    const memoExamples = [
+      {
+        type: "text",
+        value: "example text",
+      },
+      {
+        type: "id",
+        value: "12345",
+      },
+      {
+        type: "hash",
+        value: "AAAAAAAAAAAAAAAAAAAAAMAP+8deo0TViBD09TfOBY0=",
+      },
+      {
+        type: "hash",
+        value: "MV9b23bQeMQ7isAGTkoBZGErH853yGk0W/yUx1iU7dM=",
+      },
+    ];
 
-    const asset = new IssuedAssetId(
-      "USDC",
-      "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
-    );
+    for (const memoExample of memoExamples) {
+      const walletTransaction = {
+        id: "db15d166-5a5e-4d5c-ba5d-271c32cd8cf0",
+        kind: "withdrawal",
+        status: TransactionStatus.pending_user_transfer_start,
+        amount_in: "50.55",
+        withdraw_memo_type: memoExample.type,
+        withdraw_memo: memoExample.value,
+        withdraw_anchor_account:
+          "GCSGSR6KQQ5BP2FXVPWRL6SWPUSFWLVONLIBJZUKTVQB5FYJFVL6XOXE",
+      } as WithdrawTransaction;
 
-    const txBuilder = await stellar.transaction({
-      sourceAddress: kp,
-      baseFee: 100,
-    });
+      const asset = new IssuedAssetId(
+        "USDC",
+        "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+      );
 
-    const txn = txBuilder
-      .transferWithdrawalTransaction(walletTransaction, asset)
-      .build();
-    expect(txn).toBeTruthy();
-  });
+      const txBuilder = await stellar.transaction({
+        sourceAddress: kp,
+        baseFee: 100,
+      });
+
+      const txn = txBuilder
+        .transferWithdrawalTransaction(walletTransaction, asset)
+        .build();
+      expect(txn).toBeTruthy();
+    }
+  }, 20000);
 });
 
 describe("Asset", () => {

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();
+    });
   });
 });