fix: add batchUpdates option to WalletStatusTracker and verify transport cleanup

src/tests/logger.test.ts

@@ -144,6 +144,18 @@
       expect((records[0]?.context?.nested as StructuredLogMeta).authToken).toBe("[redacted]");
     });
 
+    it("cleanup function removes the transport so subsequent logs are not delivered", () => {
+      const records: StructuredLogRecord[] = [];
+      const unregister = registerLogTransport({ write: (record) => records.push(record) });
+      const logger = createLogger({ logLevel: "info" });
+
+      logger.info("before.unregister");
+      unregister();
+      logger.info("after.unregister");
+
+      expect(records.map((r) => r.message)).toEqual(["before.unregister"]);
+    });
+
     it("supports per-module log levels and custom transports", () => {
       const records: StructuredLogRecord[] = [];
       const logger = createLogger({

src/tests/walletStatusTracker.test.ts

@@ -206,4 +206,52 @@ describe("wallet status tracker", () => {
     expect(getAdapterName(WalletType.FREIGHTER)).toBe("Freighter");
     expect(truncatePublicKey("short")).toBe("short");
   });
+
+  describe("batchUpdates", () => {
+    it("coalesces rapid state changes into one listener call per microtask flush", async () => {
+      const listener = vi.fn();
+      const tracker = new WalletStatusTracker({ batchUpdates: true });
+      tracker.subscribe(listener);
+
+      tracker.setError("first");
+      tracker.setDisconnected();
+      tracker.setError("last");
+
+      // No calls yet — flush is deferred to microtask
+      expect(listener).not.toHaveBeenCalled();
+
+      await Promise.resolve();
+
+      // Exactly one call, with the latest state
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener.mock.calls[0]![0].status).toBe("error");
+      expect(listener.mock.calls[0]![0].error).toBe("last");
+    });
+
+    it("without batchUpdates, each state change calls listeners synchronously", () => {
+      const listener = vi.fn();
+      const tracker = new WalletStatusTracker();
+      tracker.subscribe(listener);
+
+      tracker.setError("a");
+      tracker.setDisconnected();
+      tracker.setError("b");
+
+      expect(listener).toHaveBeenCalledTimes(3);
+    });
+
+    it("does not emit after destroy even when a flush was pending", async () => {
+      const listener = vi.fn();
+      const tracker = new WalletStatusTracker({ batchUpdates: true });
+      tracker.subscribe(listener);
+
+      tracker.setError("will be destroyed");
+      tracker.destroy();
+
+      await Promise.resolve();
+
+      // destroy cleared _flushPending so the queued microtask finds no listeners
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
 });

src/wallet/walletStatusTracker.ts

@@ -33,6 +33,12 @@ export type WalletStatusUnsubscribe = () => void;
 
 export interface WalletStatusTrackerConfig {
   onStatusChange?: WalletStatusListener;
+  /**
+   * When true, rapid status changes within the same microtask checkpoint are
+   * coalesced and emitted once. Listeners always receive the latest state.
+   * Defaults to false (synchronous, unchanged behaviour).
+   */
+  batchUpdates?: boolean;
 }
 
 const ADAPTER_NAMES: Record<WalletType, string> = {
@@ -96,11 +102,14 @@ const INITIAL_STATUS: WalletStatus = {
 export class WalletStatusTracker {
   private _status: WalletStatus = { ...INITIAL_STATUS };
   private _listeners: Set<WalletStatusListener> = new Set();
+  private _batchUpdates: boolean;
+  private _flushPending = false;
 
   constructor(config?: WalletStatusTrackerConfig) {
     if (config?.onStatusChange) {
       this._listeners.add(config.onStatusChange);
     }
+    this._batchUpdates = config?.batchUpdates ?? false;
   }
 
   get status(): WalletStatus {
@@ -131,6 +140,19 @@ export class WalletStatusTracker {
   }
 
   private _emit(): void {
+    if (this._batchUpdates) {
+      if (!this._flushPending) {
+        this._flushPending = true;
+        queueMicrotask(() => {
+          this._flushPending = false;
+          const status = this._status;
+          for (const listener of this._listeners) {
+            listener(status);
+          }
+        });
+      }
+      return;
+    }
     const status = this._status;
     for (const listener of this._listeners) {
       listener(status);
@@ -244,5 +266,6 @@ export class WalletStatusTracker {
   destroy(): void {
     this._listeners.clear();
     this._status = { ...INITIAL_STATUS };
+    this._flushPending = false;
   }
 }