@mictonode/widget 0.3.22 → 0.3.23

package/test/components/ConnectWallet.test.ts

@@ -1,7 +1,9 @@
-import { mount } from '@vue/test-utils';
+import { flushPromises, mount } from '@vue/test-utils';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import ConnectWallet from '../../lib/components/ConnectWallet/index.vue';
 import {
+  createWallet,
+  type ConnectedWallet,
   WalletName,
   readWallet,
   removeWallet,
@@ -15,6 +17,12 @@ const sessionMocks = vi.hoisted(() => ({
   start: vi.fn(async () => undefined),
 }));
 
+const keplrSessionMocks = vi.hoisted(() => ({
+  paths: [] as string[],
+  dispose: vi.fn(),
+  start: vi.fn(async () => undefined),
+}));
+
 vi.mock('../../lib/wallet/WalletSessionManager', () => ({
   WalletSessionManager: class WalletSessionManager {
     constructor(hdPath: string) {
@@ -27,6 +35,16 @@ vi.mock('../../lib/wallet/WalletSessionManager', () => ({
   },
 }));
 
+vi.mock('../../lib/wallet/KeplrSessionManager', () => ({
+  KeplrSessionManager: class KeplrSessionManager {
+    constructor(hdPath: string) {
+      keplrSessionMocks.paths.push(hdPath);
+    }
+    dispose = keplrSessionMocks.dispose;
+    start = keplrSessionMocks.start;
+  },
+}));
+
 vi.mock('../../lib/wallet/Wallet', () => ({
   WalletName: {
     Keplr: 'Keplr',
@@ -51,6 +69,7 @@ interface MountWalletOptions {
   hdPath?: string;
   evmConfig?: string;
   params?: string;
+  onDisconnect?: (payload: unknown) => void;
 }
 
 const evmConfig = JSON.stringify({
@@ -72,6 +91,16 @@ const evmConfig = JSON.stringify({
   featuredWalletIds: [],
 });
 
+function deferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
 function mountWallet(options: MountWalletOptions = {}) {
   return mount(ConnectWallet, {
     props: {
@@ -81,6 +110,9 @@ function mountWallet(options: MountWalletOptions = {}) {
       addrPrefix: 'warden',
       evmConfig: options.evmConfig,
     },
+    attrs: {
+      onDisconnect: options.onDisconnect,
+    },
     global: {
       stubs: {
         Icon: true,
@@ -93,6 +125,7 @@ describe('ConnectWallet', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     sessionMocks.paths.length = 0;
+    keplrSessionMocks.paths.length = 0;
     vi.mocked(readWallet).mockReturnValue({} as ReturnType<typeof readWallet>);
   });
 
@@ -163,6 +196,211 @@ describe('ConnectWallet', () => {
     );
   });
 
+  it('revalidates a persisted Keplr session on mount', async () => {
+    const persisted = {
+      wallet: WalletName.Keplr,
+      cosmosAddress: 'cosmos1stored',
+      hdPath: "m/44'/118/0'/0/0",
+    };
+    vi.mocked(readWallet).mockReturnValue(persisted);
+    keplrSessionMocks.start.mockImplementationOnce(
+      async (_argument, onChange) => {
+        onChange(undefined);
+        onChange(persisted);
+      },
+    );
+
+    const wrapper = mountWallet();
+
+    await vi.waitFor(() =>
+      expect(keplrSessionMocks.start).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: 'barra_9191-1',
+          hdPath: persisted.hdPath,
+          prefix: 'warden',
+        }),
+        expect.any(Function),
+        expect.any(Function),
+      ),
+    );
+    expect(wrapper.emitted('disconnect')).toEqual([
+      [{ value: undefined }],
+    ]);
+    expect(wrapper.emitted('connect')).toEqual([
+      [{ value: persisted }],
+    ]);
+  });
+
+  it('routes manual Keplr connection through KeplrSessionManager', async () => {
+    const wrapper = mountWallet();
+    const option = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Keplr));
+
+    await option?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+
+    expect(keplrSessionMocks.start).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chainId: 'barra_9191-1',
+        hdPath: "m/44'/118/0'/0/0",
+        prefix: 'warden',
+      }),
+      expect.any(Function),
+      expect.any(Function),
+    );
+  });
+
+  it('keeps the Keplr dialog open when manual validation fails', async () => {
+    keplrSessionMocks.start.mockImplementationOnce(
+      async (_argument, _onChange, onError) => {
+        onError({ message: 'Keplr unavailable' });
+      },
+    );
+    const wrapper = mountWallet();
+
+    await wrapper.get('#PingConnectWallet').setValue(true);
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+
+    expect(
+      (wrapper.get('#PingConnectWallet').element as HTMLInputElement).checked,
+    ).toBe(true);
+    expect(wrapper.text()).toContain('Keplr unavailable');
+  });
+
+  it('does not reopen the Keplr dialog for a later refresh failure', async () => {
+    let reportRefreshFailure!: (error: { message: string }) => void;
+    keplrSessionMocks.start.mockImplementationOnce(
+      async (_argument, _onChange, onError) => {
+        reportRefreshFailure = onError;
+      },
+    );
+    const wrapper = mountWallet();
+
+    await wrapper.get('#PingConnectWallet').setValue(true);
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    expect(
+      (wrapper.get('#PingConnectWallet').element as HTMLInputElement).checked,
+    ).toBe(false);
+
+    reportRefreshFailure({ message: 'Keplr refresh unavailable' });
+    await flushPromises();
+
+    expect(
+      (wrapper.get('#PingConnectWallet').element as HTMLInputElement).checked,
+    ).toBe(false);
+    expect(wrapper.text()).toContain('Keplr refresh unavailable');
+  });
+
+  it('isolates a replacement wallet from stale Keplr callbacks', async () => {
+    const wrapper = mountWallet();
+    await flushPromises();
+    sessionMocks.dispose.mockClear();
+    keplrSessionMocks.dispose.mockClear();
+    let staleChange!: (value: ConnectedWallet | undefined) => void;
+    let staleError!: (error: { message: string }) => void;
+    keplrSessionMocks.start.mockImplementationOnce(
+      async (_argument, onChange, onError) => {
+        staleChange = onChange;
+        staleError = onError;
+        onError({ message: 'Initial Keplr failure' });
+      },
+    );
+    vi.mocked(createWallet).mockReturnValue({
+      getAccounts: vi.fn(async () => [{
+        address: 'cosmos1ledger',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }]),
+    } as unknown as ReturnType<typeof createWallet>);
+
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    const ledgerOption = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Ledger));
+    await ledgerOption?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    await vi.waitFor(() =>
+      expect(wrapper.text()).toContain('cosmos1ledger'),
+    );
+
+    staleChange({
+      wallet: WalletName.Keplr,
+      cosmosAddress: 'cosmos1stale',
+      hdPath: "m/44'/118/0'/0/0",
+    });
+    staleError({ message: 'Stale Keplr refresh' });
+    await flushPromises();
+
+    expect(keplrSessionMocks.dispose).toHaveBeenCalledTimes(2);
+    expect(sessionMocks.dispose).toHaveBeenCalledTimes(2);
+    expect(wrapper.text()).toContain('cosmos1ledger');
+    expect(wrapper.text()).not.toContain('cosmos1stale');
+    expect(wrapper.text()).not.toContain('Stale Keplr refresh');
+  });
+
+  it('isolates a replacement wallet from a pending Reown attempt', async () => {
+    const wrapper = mountWallet({
+      hdPath: "m/44'/60/0'/0/0",
+      evmConfig,
+    });
+    await flushPromises();
+    sessionMocks.dispose.mockClear();
+    keplrSessionMocks.dispose.mockClear();
+    const pending = deferred<void>();
+    let staleChange!: (value: ConnectedWallet | undefined) => void;
+    let staleError!: (error: { message: string }) => void;
+    sessionMocks.connect.mockImplementationOnce(
+      async (_config, _argument, onChange, onError) => {
+        staleChange = onChange;
+        staleError = onError;
+        await pending.promise;
+      },
+    );
+    vi.mocked(createWallet).mockReturnValue({
+      getAccounts: vi.fn(async () => [{
+        address: 'cosmos1ledger',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }]),
+    } as unknown as ReturnType<typeof createWallet>);
+    const evmOption = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Evm));
+    await evmOption?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    await vi.waitFor(() => expect(sessionMocks.connect).toHaveBeenCalledOnce());
+
+    const ledgerOption = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Ledger));
+    await ledgerOption?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    await vi.waitFor(() =>
+      expect(wrapper.text()).toContain('cosmos1ledger'),
+    );
+
+    staleChange({
+      version: 2,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1stale',
+      hdPath: "m/44'/60/0'/0/0",
+      connector: {
+        source: 'reown',
+        name: 'Stale Wallet',
+      },
+    });
+    staleError({ message: 'Stale Reown callback' });
+    pending.reject(new Error('Stale Reown rejection'));
+    await flushPromises();
+
+    expect(keplrSessionMocks.dispose).toHaveBeenCalledTimes(2);
+    expect(sessionMocks.dispose).toHaveBeenCalledTimes(2);
+    expect(wrapper.text()).toContain('cosmos1ledger');
+    expect(wrapper.text()).not.toContain('warden1stale');
+    expect(wrapper.text()).not.toContain('Stale Reown');
+  });
+
   it('clears storage and emits the previous connection on disconnect', async () => {
     const connected = {
       wallet: WalletName.Keplr,
@@ -170,13 +408,172 @@ describe('ConnectWallet', () => {
       hdPath: "m/44'/118/0'/0/0",
     };
     vi.mocked(readWallet).mockReturnValue(connected);
+    keplrSessionMocks.start.mockImplementationOnce(
+      async (_argument, onChange) => {
+        onChange(undefined);
+        onChange(connected);
+      },
+    );
     const wrapper = mountWallet();
 
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
     await wrapper.get('[data-testid="wallet-disconnect"]').trigger('click');
 
     expect(removeWallet).toHaveBeenCalledWith(connected.hdPath);
-    expect(wrapper.emitted('disconnect')).toEqual([[{ value: connected }]]);
+    const disconnectEvents = wrapper.emitted('disconnect')!;
+    expect(disconnectEvents[0]).toEqual([{ value: undefined }]);
+    expect(disconnectEvents[disconnectEvents.length - 1]).toEqual([
+      { value: connected },
+    ]);
+    expect(wrapper.text()).toContain('Connect Wallet');
+  });
+
+  it('fails closed once when a direct EVM disconnect rejects', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    const pending = deferred<void>();
+    sessionMocks.disconnect.mockImplementationOnce(async () => {
+      await pending.promise;
+    });
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+    const disconnectCount = onDisconnect.mock.calls.length;
+
+    await wrapper.get('[data-testid="wallet-disconnect"]').trigger('click');
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    pending.reject(new Error('provider failure'));
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount + 1);
+    expect(onDisconnect).toHaveBeenLastCalledWith({ value: connected });
     expect(wrapper.text()).toContain('Connect Wallet');
+    expect(wrapper.text()).toContain('Wallet request failed');
+    wrapper.unmount();
+  });
+
+  it('ignores a stale direct disconnect after a replacement wallet connects', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    const pending = deferred<void>();
+    sessionMocks.disconnect.mockImplementationOnce(async () => {
+      await pending.promise;
+    });
+    vi.mocked(createWallet).mockReturnValue({
+      getAccounts: vi.fn(async () => [{
+        address: 'cosmos1ledger',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }]),
+    } as unknown as ReturnType<typeof createWallet>);
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+
+    await wrapper.get('[data-testid="wallet-disconnect"]').trigger('click');
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    const ledgerOption = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Ledger));
+    await ledgerOption?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    await vi.waitFor(() =>
+      expect(wrapper.text()).toContain('cosmos1ledger'),
+    );
+    const disconnectCount = onDisconnect.mock.calls.length;
+
+    pending.reject(new Error('stale provider failure'));
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount);
+    expect(wrapper.text()).toContain('cosmos1ledger');
+    expect(wrapper.text()).not.toContain('Wallet request failed');
+    wrapper.unmount();
+  });
+
+  it('ignores a stale direct disconnect completion after unmount', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    const pending = deferred<void>();
+    sessionMocks.disconnect.mockImplementationOnce(async () => {
+      await pending.promise;
+    });
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+
+    await wrapper.get('[data-testid="wallet-disconnect"]').trigger('click');
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    const setupState = (wrapper.vm as unknown as {
+      $: {
+        setupState: {
+          connected: ConnectedWallet;
+          error: string;
+        };
+      };
+    }).$.setupState;
+    const disconnectCount = onDisconnect.mock.calls.length;
+    wrapper.unmount();
+
+    pending.reject(new Error('stale provider failure'));
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount);
+    expect(setupState.error).toBe('');
+    expect(setupState.connected.cosmosAddress).toBe('warden1connected');
   });
 
   it('disconnects a persisted EVM session after the explorer event', async () => {
@@ -209,6 +606,162 @@ describe('ConnectWallet', () => {
     wrapper.unmount();
   });
 
+  it('fails closed when external EVM disconnect rejects', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    sessionMocks.disconnect.mockRejectedValueOnce(
+      new Error('provider failure'),
+    );
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+    const disconnectCount = onDisconnect.mock.calls.length;
+
+    window.dispatchEvent(
+      new CustomEvent('mictonode:wallet-disconnect', {
+        detail: { hdPath },
+      }),
+    );
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount + 1);
+    expect(onDisconnect).toHaveBeenLastCalledWith({ value: undefined });
+    expect(wrapper.text()).toContain('Connect Wallet');
+    expect(wrapper.text()).toContain('Wallet request failed');
+    wrapper.unmount();
+  });
+
+  it('ignores a stale external disconnect after a replacement wallet connects', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    const pending = deferred<void>();
+    sessionMocks.disconnect.mockImplementationOnce(async () => {
+      await pending.promise;
+    });
+    vi.mocked(createWallet).mockReturnValue({
+      getAccounts: vi.fn(async () => [{
+        address: 'cosmos1ledger',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }]),
+    } as unknown as ReturnType<typeof createWallet>);
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+
+    window.dispatchEvent(
+      new CustomEvent('mictonode:wallet-disconnect', {
+        detail: { hdPath },
+      }),
+    );
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    const ledgerOption = wrapper
+      .findAll('li')
+      .find((item) => item.text().includes(WalletName.Ledger));
+    await ledgerOption?.trigger('click');
+    await wrapper.get('.ping-connect-confirm').trigger('click');
+    await vi.waitFor(() =>
+      expect(wrapper.text()).toContain('cosmos1ledger'),
+    );
+    const disconnectCount = onDisconnect.mock.calls.length;
+
+    pending.reject(new Error('stale provider failure'));
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount);
+    expect(wrapper.text()).toContain('cosmos1ledger');
+    expect(wrapper.text()).not.toContain('Wallet request failed');
+    wrapper.unmount();
+  });
+
+  it('ignores a stale external disconnect completion after unmount', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    const connected = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1connected',
+      hdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    vi.mocked(readWallet).mockReturnValue(connected);
+    sessionMocks.start.mockImplementationOnce(
+      async (_config, _argument, onChange) => onChange(connected),
+    );
+    const pending = deferred<void>();
+    sessionMocks.disconnect.mockImplementationOnce(async () => {
+      await pending.promise;
+    });
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
+
+    window.dispatchEvent(
+      new CustomEvent('mictonode:wallet-disconnect', {
+        detail: { hdPath },
+      }),
+    );
+    await vi.waitFor(() =>
+      expect(sessionMocks.disconnect).toHaveBeenCalledOnce(),
+    );
+    const setupState = (wrapper.vm as unknown as {
+      $: {
+        setupState: {
+          connected: ConnectedWallet;
+          error: string;
+        };
+      };
+    }).$.setupState;
+    const disconnectCount = onDisconnect.mock.calls.length;
+    wrapper.unmount();
+
+    pending.reject(new Error('stale provider failure'));
+    await flushPromises();
+
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount);
+    expect(setupState.error).toBe('');
+    expect(setupState.connected.cosmosAddress).toBe('warden1connected');
+  });
+
   it('rebinds the session manager when the active chain HD path changes', async () => {
     const evmHdPath = "m/44'/60/0'/0/0";
     const evmWallet = {
@@ -248,4 +801,89 @@ describe('ConnectWallet', () => {
     );
     expect(sessionMocks.dispose).toHaveBeenCalled();
   });
+
+  it('disposes both manager types when wallet context changes', async () => {
+    const wrapper = mountWallet();
+
+    await wrapper.setProps({
+      chainId: 'cosmoshub-4',
+      addrPrefix: 'cosmos',
+    });
+    await vi.waitFor(() => {
+      expect(keplrSessionMocks.dispose).toHaveBeenCalled();
+      expect(sessionMocks.dispose).toHaveBeenCalled();
+    });
+  });
+
+  it('ignores a stale Reown restore rejection after context replacement', async () => {
+    const oldHdPath = "m/44'/60/0'/0/0";
+    const newHdPath = "m/44'/118/0'/0/0";
+    const oldConnection = {
+      version: 2 as const,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1old',
+      hdPath: oldHdPath,
+      connector: {
+        source: 'reown' as const,
+        name: 'Rabby Wallet',
+      },
+    };
+    const replacement = {
+      wallet: WalletName.Ledger,
+      cosmosAddress: 'cosmos1replacement',
+      hdPath: newHdPath,
+    };
+    vi.mocked(readWallet).mockImplementation((path) =>
+      path === oldHdPath ? oldConnection : replacement,
+    );
+    const pending = deferred<void>();
+    sessionMocks.start.mockImplementationOnce(() => pending.promise);
+    const wrapper = mountWallet({ hdPath: oldHdPath, evmConfig });
+    await vi.waitFor(() => expect(sessionMocks.start).toHaveBeenCalledOnce());
+
+    await wrapper.setProps({
+      hdPath: newHdPath,
+      chainId: 'cosmoshub-4',
+      addrPrefix: 'cosmos',
+      evmConfig: undefined,
+    });
+    await vi.waitFor(() =>
+      expect(wrapper.text()).toContain('cosmos1replacement'),
+    );
+    vi.mocked(removeWallet).mockClear();
+
+    pending.reject(new Error('stale Reown restore'));
+    await flushPromises();
+
+    expect(removeWallet).not.toHaveBeenCalled();
+    expect(wrapper.text()).toContain('cosmos1replacement');
+  });
+
+  it('ignores a stale Reown restore rejection after unmount', async () => {
+    const hdPath = "m/44'/60/0'/0/0";
+    vi.mocked(readWallet).mockReturnValue({
+      version: 2,
+      wallet: WalletName.Evm,
+      cosmosAddress: 'warden1old',
+      hdPath,
+      connector: {
+        source: 'reown',
+        name: 'Rabby Wallet',
+      },
+    });
+    const pending = deferred<void>();
+    sessionMocks.start.mockImplementationOnce(() => pending.promise);
+    const onDisconnect = vi.fn();
+    const wrapper = mountWallet({ hdPath, evmConfig, onDisconnect });
+    await vi.waitFor(() => expect(sessionMocks.start).toHaveBeenCalledOnce());
+    const disconnectCount = onDisconnect.mock.calls.length;
+    vi.mocked(removeWallet).mockClear();
+
+    wrapper.unmount();
+    pending.reject(new Error('stale Reown restore'));
+    await flushPromises();
+
+    expect(removeWallet).not.toHaveBeenCalled();
+    expect(onDisconnect).toHaveBeenCalledTimes(disconnectCount);
+  });
 });