@mictonode/widget 0.3.22 → 0.3.23

package/test/wallet/WalletSessionManager.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   WalletName,
   type AbstractWallet,
+  type ConnectedWallet,
   type WalletArgument,
 } from '../../lib/wallet/Wallet';
 import {
@@ -43,17 +44,24 @@ const walletArgument: WalletArgument = {
   prefix: 'warden',
 };
 
-function fakeGateway() {
+function fakeGateway(
+  initialAccount?: ReownAccountState,
+  initialNetwork?: ReownNetworkState,
+) {
   let accountListener: ((state: ReownAccountState) => void) | undefined;
   let networkListener: ((state: ReownNetworkState) => void) | undefined;
+  let currentAccount = initialAccount;
+  let currentNetwork = initialNetwork;
   const gateway: ReownGateway & {
     emitAccount: (state: ReownAccountState) => void;
     emitNetwork: (state: ReownNetworkState) => void;
   } = {
     open: vi.fn(async () => undefined),
     disconnect: vi.fn(async () => undefined),
+    ensureNetwork: vi.fn(async () => undefined),
     getProvider: vi.fn(() => ({ request: vi.fn(async () => undefined) })),
-    getAccount: vi.fn(() => undefined),
+    getAccount: vi.fn(() => currentAccount),
+    getNetwork: vi.fn(() => currentNetwork),
     getWalletInfo: vi.fn(() => ({
       name: 'Rabby Wallet',
       type: 'injected',
@@ -67,21 +75,391 @@ function fakeGateway() {
       return vi.fn();
     }),
     emitAccount(state) {
+      currentAccount = state;
       accountListener?.(state);
     },
     emitNetwork(state) {
+      currentNetwork = state;
       networkListener?.(state);
     },
   };
   return gateway;
 }
 
+function walletForAddress(
+  evmAddress: string,
+  marker: number,
+): AbstractWallet {
+  return {
+    name: WalletName.Evm,
+    getAccounts: vi.fn(async () => [
+      {
+        address: ethToEthermint(evmAddress, 'warden'),
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([marker]),
+      },
+    ]),
+    supportCoinType: vi.fn(async () => true),
+    sign: vi.fn(async () => new Uint8Array()),
+  };
+}
+
 describe('WalletSessionManager', () => {
   beforeEach(() => {
     localStorage.clear();
     clearRuntimeWallet(hdPath);
   });
 
+  it('does not provision a network while restoring a session', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    const wallet = walletForAddress(address, 1);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.start(
+      config,
+      walletArgument,
+      vi.fn(),
+      vi.fn(),
+    );
+
+    expect(gateway.ensureNetwork).not.toHaveBeenCalled();
+    expect(wallet.getAccounts).toHaveBeenCalledOnce();
+  });
+
+  it('provisions the network before verifying a manual account', async () => {
+    const order: string[] = [];
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    gateway.ensureNetwork = vi.fn(async () => {
+      order.push('network');
+    });
+    const wallet = walletForAddress(address, 1);
+    wallet.getAccounts = vi.fn(async () => {
+      order.push('accounts');
+      return [{
+        address: ethToEthermint(address, 'warden'),
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }];
+    });
+    const onChange = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.connect(
+      config,
+      walletArgument,
+      onChange,
+      vi.fn(),
+    );
+
+    expect(order).toEqual(['network', 'accounts']);
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({ wallet: WalletName.Evm }),
+    );
+    expect(gateway.open).not.toHaveBeenCalled();
+  });
+
+  it('does not report the bootstrap network while waiting for a manual account', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      undefined,
+      { caipNetworkId: 'eip155:1' },
+    );
+    const wallet = walletForAddress(address, 1);
+    const onError = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      onError,
+    );
+
+    expect(gateway.open).toHaveBeenCalledOnce();
+    expect(gateway.ensureNetwork).not.toHaveBeenCalled();
+    expect(onError).not.toHaveBeenCalled();
+
+    gateway.emitAccount({
+      address,
+      isConnected: true,
+      status: 'connected',
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(wallet),
+    );
+
+    expect(gateway.ensureNetwork).toHaveBeenCalledOnce();
+    expect(wallet.getAccounts).toHaveBeenCalledOnce();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it('fails closed before account verification when provisioning is rejected', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    gateway.ensureNetwork = vi.fn(async () => {
+      throw { code: 4001 };
+    });
+    const wallet = walletForAddress(address, 1);
+    const onChange = vi.fn();
+    const onError = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.connect(
+      config,
+      walletArgument,
+      onChange,
+      onError,
+    );
+
+    expect(wallet.getAccounts).not.toHaveBeenCalled();
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+    expect(localStorage.length).toBe(0);
+    expect(onChange).toHaveBeenLastCalledWith(undefined);
+    expect(onError).toHaveBeenCalledOnce();
+    expect(gateway.open).not.toHaveBeenCalled();
+  });
+
+  it('can retry a manual connection after provisioning was rejected', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    gateway.ensureNetwork = vi.fn()
+      .mockRejectedValueOnce({ code: 4001 })
+      .mockResolvedValueOnce(undefined);
+    const wallet = walletForAddress(address, 1);
+    const onChange = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.connect(
+      config,
+      walletArgument,
+      onChange,
+      vi.fn(),
+    );
+
+    gateway.emitAccount({
+      address,
+      isConnected: true,
+      status: 'connected',
+    });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+    expect(gateway.ensureNetwork).toHaveBeenCalledOnce();
+    expect(wallet.getAccounts).not.toHaveBeenCalled();
+
+    await manager.connect(
+      config,
+      walletArgument,
+      onChange,
+      vi.fn(),
+    );
+
+    expect(gateway.ensureNetwork).toHaveBeenCalledTimes(2);
+    expect(wallet.getAccounts).toHaveBeenCalledOnce();
+    expect(getRuntimeWallet(hdPath)).toBe(wallet);
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({ wallet: WalletName.Evm }),
+    );
+  });
+
+  it('does not provision again after a successful manual attempt', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    const wallet = walletForAddress(address, 1);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    await manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      vi.fn(),
+    );
+
+    gateway.emitNetwork({ caipNetworkId: 'eip155:1' });
+    gateway.emitAccount({
+      address,
+      isConnected: true,
+      status: 'connected',
+    });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+    expect(gateway.ensureNetwork).toHaveBeenCalledOnce();
+    expect(wallet.getAccounts).toHaveBeenCalledOnce();
+  });
+
+  it('keeps provisioning owned through its transient wrong-network event', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    let releaseProvisioning!: () => void;
+    let isCurrent: (() => boolean) | undefined;
+    gateway.ensureNetwork = vi.fn(async (checkCurrent?: () => boolean) => {
+      isCurrent = checkCurrent;
+      await new Promise<void>((resolve) => {
+        releaseProvisioning = resolve;
+      });
+      if (!checkCurrent?.()) {
+        throw new Error('EVM network request is no longer active');
+      }
+    });
+    const wallet = walletForAddress(address, 1);
+    const onError = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    const connecting = manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      onError,
+    );
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+    gateway.emitNetwork({ caipNetworkId: 'eip155:1' });
+
+    expect(isCurrent).toBeTypeOf('function');
+    expect(isCurrent?.()).toBe(true);
+
+    releaseProvisioning();
+    await connecting;
+
+    expect(wallet.getAccounts).toHaveBeenCalledOnce();
+    expect(getRuntimeWallet(hdPath)).toBe(wallet);
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it('invalidates pending provisioning when the account changes', async () => {
+    const firstAddress =
+      '0x1111111111111111111111111111111111111111';
+    const secondAddress =
+      '0x2222222222222222222222222222222222222222';
+    const gateway = fakeGateway(
+      {
+        address: firstAddress,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    let releaseProvisioning!: () => void;
+    let isCurrent: (() => boolean) | undefined;
+    gateway.ensureNetwork = vi.fn(async (checkCurrent?: () => boolean) => {
+      isCurrent = checkCurrent;
+      await new Promise<void>((resolve) => {
+        releaseProvisioning = resolve;
+      });
+      if (!checkCurrent?.()) {
+        throw new Error('EVM network request is no longer active');
+      }
+    });
+    const wallet = walletForAddress(firstAddress, 1);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    const connecting = manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      vi.fn(),
+    );
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+    gateway.emitAccount({
+      address: secondAddress,
+      isConnected: true,
+      status: 'connected',
+    });
+
+    expect(isCurrent).toBeTypeOf('function');
+    expect(isCurrent?.()).toBe(false);
+
+    releaseProvisioning();
+    await connecting;
+
+    gateway.emitAccount({
+      address: secondAddress,
+      isConnected: true,
+      status: 'connected',
+    });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+    expect(gateway.ensureNetwork).toHaveBeenCalledOnce();
+    expect(wallet.getAccounts).not.toHaveBeenCalled();
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+  });
+
   it('activates and persists a connected Reown wallet', async () => {
     const gateway = fakeGateway();
     const cosmosAddress = ethToEthermint(
@@ -234,6 +612,114 @@ describe('WalletSessionManager', () => {
     );
   });
 
+  it('keeps the latest account authoritative when selection returns during validation', async () => {
+    const gateway = fakeGateway();
+    const firstAddress = '0x1111111111111111111111111111111111111111';
+    const secondAddress = '0x2222222222222222222222222222222222222222';
+    const firstCosmosAddress = ethToEthermint(firstAddress, 'warden');
+    const secondCosmosAddress = ethToEthermint(secondAddress, 'warden');
+    let resolveSecondAccounts!: (
+      accounts: Awaited<ReturnType<AbstractWallet['getAccounts']>>,
+    ) => void;
+    const firstWallet = {
+      name: WalletName.Evm,
+      getAccounts: vi.fn(async () => [
+        {
+          address: firstCosmosAddress,
+          algo: 'secp256k1' as const,
+          pubkey: new Uint8Array([1]),
+        },
+      ]),
+      supportCoinType: vi.fn(async () => true),
+      sign: vi.fn(async () => new Uint8Array()),
+    } as AbstractWallet;
+    const pendingSecondWallet = {
+      name: WalletName.Evm,
+      getAccounts: vi.fn(
+        () =>
+          new Promise<
+            Awaited<ReturnType<AbstractWallet['getAccounts']>>
+          >((resolve) => {
+            resolveSecondAccounts = resolve;
+          }),
+      ),
+      supportCoinType: vi.fn(async () => true),
+      sign: vi.fn(async () => new Uint8Array()),
+    } as AbstractWallet;
+    const revalidatedFirstWallet = {
+      ...firstWallet,
+      getAccounts: vi.fn(async () => [
+        {
+          address: firstCosmosAddress,
+          algo: 'secp256k1' as const,
+          pubkey: new Uint8Array([2]),
+        },
+      ]),
+    } as AbstractWallet;
+    const firstWallets = [firstWallet, revalidatedFirstWallet];
+    const walletFactory = vi.fn((argument: WalletArgument) =>
+      argument.evmAddress?.toLowerCase() === secondAddress
+        ? pendingSecondWallet
+        : (firstWallets.shift() as AbstractWallet),
+    );
+    const changed = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      walletFactory,
+    );
+    await manager.start(config, walletArgument, changed);
+
+    gateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: firstAddress,
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(firstWallet),
+    );
+    changed.mockClear();
+
+    gateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: secondAddress,
+    });
+
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+    expect(localStorage.getItem(hdPath)).toBeNull();
+    expect(changed).toHaveBeenLastCalledWith(undefined);
+
+    gateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: firstAddress,
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(revalidatedFirstWallet),
+    );
+
+    resolveSecondAccounts([
+      {
+        address: secondCosmosAddress,
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([3]),
+      },
+    ]);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(getRuntimeWallet(hdPath)).toBe(revalidatedFirstWallet);
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toEqual(
+      expect.objectContaining({ cosmosAddress: firstCosmosAddress }),
+    );
+    expect(
+      changed.mock.calls.some(
+        ([value]) => value?.cosmosAddress === secondCosmosAddress,
+      ),
+    ).toBe(false);
+  });
+
   it('clears the session after disconnect', async () => {
     const gateway = fakeGateway();
     localStorage.setItem(hdPath, '{"stale":true}');
@@ -273,6 +759,90 @@ describe('WalletSessionManager', () => {
     );
   });
 
+  it('blocks account synchronization while the current network is invalid', async () => {
+    const gateway = fakeGateway(undefined, {
+      caipNetworkId: 'eip155:8765',
+    });
+    const walletFactory = vi.fn();
+    const changed = vi.fn();
+    const failed = vi.fn();
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      walletFactory,
+    );
+    await manager.start(config, walletArgument, changed, failed);
+
+    gateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: '0x1111111111111111111111111111111111111111',
+    });
+    await Promise.resolve();
+
+    expect(walletFactory).not.toHaveBeenCalled();
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+    expect(localStorage.getItem(hdPath)).toBeNull();
+    expect(changed).toHaveBeenLastCalledWith(undefined);
+    expect(failed).toHaveBeenCalledWith(
+      expect.objectContaining({ category: 'wrong-network' }),
+    );
+  });
+
+  it('revalidates the current account after returning to the configured network', async () => {
+    const evmAddress = '0x1111111111111111111111111111111111111111';
+    const cosmosAddress = ethToEthermint(evmAddress, 'warden');
+    const currentAccount = {
+      isConnected: true,
+      status: 'connected',
+      address: evmAddress,
+    };
+    const gateway = fakeGateway(currentAccount, {
+      caipNetworkId: config.network.caipNetworkId,
+    });
+    const [initialWallet, revalidatedWallet] = [1, 2].map(
+      (marker) =>
+        ({
+          name: WalletName.Evm,
+          getAccounts: vi.fn(async () => [
+            {
+              address: cosmosAddress,
+              algo: 'secp256k1',
+              pubkey: new Uint8Array([marker]),
+            },
+          ]),
+          supportCoinType: vi.fn(async () => true),
+          sign: vi.fn(async () => new Uint8Array()),
+        }) as AbstractWallet,
+    );
+    const wallets = [initialWallet, revalidatedWallet];
+    const walletFactory = vi.fn(() => wallets.shift() as AbstractWallet);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      walletFactory,
+    );
+    await manager.start(config, walletArgument, vi.fn());
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBeDefined(),
+    );
+
+    gateway.emitNetwork({ caipNetworkId: 'eip155:8765' });
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+
+    gateway.emitNetwork({
+      caipNetworkId: config.network.caipNetworkId,
+    });
+
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(revalidatedWallet),
+    );
+    expect(walletFactory).toHaveBeenCalledTimes(2);
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toEqual(
+      expect.objectContaining({ cosmosAddress }),
+    );
+  });
+
   it('does not restore a pending account after a later disconnect', async () => {
     const gateway = fakeGateway();
     let resolveAccounts!: (
@@ -382,6 +952,241 @@ describe('WalletSessionManager', () => {
     expect(localStorage.getItem(hdPath)).toBeNull();
   });
 
+  it('does not clear a successor session when an older provider disconnect completes', async () => {
+    const oldGateway = fakeGateway();
+    let resolveOldDisconnect!: () => void;
+    vi.mocked(oldGateway.disconnect).mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveOldDisconnect = resolve;
+        }),
+    );
+    const oldManager = new WalletSessionManager(
+      hdPath,
+      async () => oldGateway,
+      vi.fn(),
+    );
+    setRuntimeWalletForTests(
+      hdPath,
+      walletForAddress(
+        '0x1111111111111111111111111111111111111111',
+        1,
+      ),
+    );
+    localStorage.setItem(hdPath, '{"old":true}');
+
+    const disconnecting = oldManager.disconnect(config);
+    await vi.waitFor(() =>
+      expect(oldGateway.disconnect).toHaveBeenCalledOnce(),
+    );
+
+    const successorAddress =
+      '0x2222222222222222222222222222222222222222';
+    const successorCosmosAddress = ethToEthermint(
+      successorAddress,
+      'warden',
+    );
+    const successorGateway = fakeGateway();
+    const successorWallet = walletForAddress(successorAddress, 2);
+    let visible: ConnectedWallet | undefined;
+    const changed = vi.fn((value: ConnectedWallet | undefined) => {
+      visible = value;
+    });
+    const successorManager = new WalletSessionManager(
+      hdPath,
+      async () => successorGateway,
+      () => successorWallet,
+    );
+    await successorManager.start(config, walletArgument, changed);
+    successorGateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: successorAddress,
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(successorWallet),
+    );
+
+    resolveOldDisconnect();
+    await disconnecting;
+
+    expect(getRuntimeWallet(hdPath)).toBe(successorWallet);
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+    expect(visible).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+  });
+
+  it('clears local state even when gateway acquisition fails during disconnect', async () => {
+    const wallet = {
+      name: WalletName.Evm,
+      getAccounts: vi.fn(),
+      supportCoinType: vi.fn(),
+      sign: vi.fn(),
+    } as unknown as AbstractWallet;
+    setRuntimeWalletForTests(hdPath, wallet);
+    localStorage.setItem(hdPath, '{"stale":true}');
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => {
+        throw new Error('factory failure');
+      },
+      vi.fn(),
+    );
+
+    await expect(manager.disconnect(config)).rejects.toThrow(
+      'factory failure',
+    );
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+    expect(localStorage.getItem(hdPath)).toBeNull();
+  });
+
+  it('clears the runtime signer as soon as the session is disposed', () => {
+    const gateway = fakeGateway();
+    const wallet = {
+      name: WalletName.Evm,
+      getAccounts: vi.fn(),
+      supportCoinType: vi.fn(),
+      sign: vi.fn(),
+    } as unknown as AbstractWallet;
+    setRuntimeWalletForTests(hdPath, wallet);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      vi.fn(),
+    );
+
+    manager.dispose();
+
+    expect(getRuntimeWallet(hdPath)).toBeUndefined();
+  });
+
+  it('ignores a queued account callback after disposal and successor connection', async () => {
+    const oldGateway = fakeGateway();
+    let visible: ConnectedWallet | undefined;
+    const changed = vi.fn((value: ConnectedWallet | undefined) => {
+      visible = value;
+    });
+    const oldManager = new WalletSessionManager(
+      hdPath,
+      async () => oldGateway,
+      vi.fn(),
+    );
+    await oldManager.start(config, walletArgument, changed);
+    const staleAccountCallback = vi.mocked(
+      oldGateway.subscribeAccount,
+    ).mock.calls[0][0];
+    oldManager.dispose();
+
+    const successorAddress =
+      '0x2222222222222222222222222222222222222222';
+    const successorCosmosAddress = ethToEthermint(
+      successorAddress,
+      'warden',
+    );
+    const successorGateway = fakeGateway();
+    const successorWallet = walletForAddress(successorAddress, 2);
+    const successorManager = new WalletSessionManager(
+      hdPath,
+      async () => successorGateway,
+      () => successorWallet,
+    );
+    await successorManager.start(config, walletArgument, changed);
+    successorGateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: successorAddress,
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(successorWallet),
+    );
+    const changeCount = changed.mock.calls.length;
+
+    staleAccountCallback({
+      isConnected: false,
+      status: 'disconnected',
+    });
+    await Promise.resolve();
+
+    expect(getRuntimeWallet(hdPath)).toBe(successorWallet);
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+    expect(visible).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+    expect(changed).toHaveBeenCalledTimes(changeCount);
+  });
+
+  it('ignores a queued network callback after disposal and successor connection', async () => {
+    const oldGateway = fakeGateway();
+    let visible: ConnectedWallet | undefined;
+    const changed = vi.fn((value: ConnectedWallet | undefined) => {
+      visible = value;
+    });
+    const failed = vi.fn();
+    const oldManager = new WalletSessionManager(
+      hdPath,
+      async () => oldGateway,
+      vi.fn(),
+    );
+    await oldManager.start(config, walletArgument, changed, failed);
+    const staleNetworkCallback = vi.mocked(
+      oldGateway.subscribeNetwork,
+    ).mock.calls[0][0];
+    oldManager.dispose();
+
+    const successorAddress =
+      '0x2222222222222222222222222222222222222222';
+    const successorCosmosAddress = ethToEthermint(
+      successorAddress,
+      'warden',
+    );
+    const successorGateway = fakeGateway();
+    const successorWallet = walletForAddress(successorAddress, 3);
+    const successorManager = new WalletSessionManager(
+      hdPath,
+      async () => successorGateway,
+      () => successorWallet,
+    );
+    await successorManager.start(config, walletArgument, changed);
+    successorGateway.emitAccount({
+      isConnected: true,
+      status: 'connected',
+      address: successorAddress,
+    });
+    await vi.waitFor(() =>
+      expect(getRuntimeWallet(hdPath)).toBe(successorWallet),
+    );
+    const changeCount = changed.mock.calls.length;
+
+    staleNetworkCallback({ caipNetworkId: 'eip155:8765' });
+
+    expect(getRuntimeWallet(hdPath)).toBe(successorWallet);
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+    expect(visible).toEqual(
+      expect.objectContaining({
+        cosmosAddress: successorCosmosAddress,
+      }),
+    );
+    expect(changed).toHaveBeenCalledTimes(changeCount);
+    expect(failed).not.toHaveBeenCalled();
+  });
+
   it('cancels a start that completes after the manager is disposed', async () => {
     const gateway = fakeGateway();
     let resolveGateway!: (gateway: ReownGateway) => void;
@@ -402,4 +1207,98 @@ describe('WalletSessionManager', () => {
     expect(gateway.subscribeAccount).not.toHaveBeenCalled();
     expect(gateway.subscribeNetwork).not.toHaveBeenCalled();
   });
+
+  it('does not open a stale gateway after disposal during network provisioning', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const gateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    let finishProvisioning!: () => void;
+    gateway.ensureNetwork = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          finishProvisioning = resolve;
+        }),
+    );
+    const wallet = walletForAddress(address, 1);
+    const manager = new WalletSessionManager(
+      hdPath,
+      async () => gateway,
+      () => wallet,
+    );
+
+    const connecting = manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      vi.fn(),
+    );
+    const rejected = expect(connecting).rejects.toThrow(
+      'Wallet session changed',
+    );
+    await vi.waitFor(() =>
+      expect(gateway.ensureNetwork).toHaveBeenCalledOnce(),
+    );
+
+    manager.dispose();
+    finishProvisioning();
+
+    await rejected;
+    expect(gateway.open).not.toHaveBeenCalled();
+    expect(wallet.getAccounts).not.toHaveBeenCalled();
+  });
+
+  it('does not open a superseded gateway after network provisioning completes', async () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    const staleGateway = fakeGateway(
+      {
+        address,
+        isConnected: true,
+        status: 'connected',
+      },
+      { caipNetworkId: config.network.caipNetworkId },
+    );
+    const successorGateway = fakeGateway();
+    let finishProvisioning!: () => void;
+    staleGateway.ensureNetwork = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          finishProvisioning = resolve;
+        }),
+    );
+    const gatewayFactory = vi.fn()
+      .mockResolvedValueOnce(staleGateway)
+      .mockResolvedValueOnce(successorGateway);
+    const manager = new WalletSessionManager(
+      hdPath,
+      gatewayFactory,
+      vi.fn(),
+    );
+
+    const connecting = manager.connect(
+      config,
+      walletArgument,
+      vi.fn(),
+      vi.fn(),
+    );
+    const rejected = expect(connecting).rejects.toThrow(
+      'Wallet session changed',
+    );
+    await vi.waitFor(() =>
+      expect(staleGateway.ensureNetwork).toHaveBeenCalledOnce(),
+    );
+
+    await manager.start(config, walletArgument, vi.fn(), vi.fn());
+    finishProvisioning();
+
+    await rejected;
+    expect(staleGateway.open).not.toHaveBeenCalled();
+    expect(successorGateway.subscribeAccount).toHaveBeenCalledOnce();
+    expect(successorGateway.subscribeNetwork).toHaveBeenCalledOnce();
+  });
 });