@mictonode/widget 0.3.22 → 0.3.23

package/test/components/ConnectWalletStorage.test.ts

@@ -1,9 +1,45 @@
-import { mount } from '@vue/test-utils';
-import { describe, expect, it } from 'vitest';
+import { flushPromises, mount } from '@vue/test-utils';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import ConnectWallet from '../../lib/components/ConnectWallet/index.vue';
 import { DEFAULT_HDPATH, WalletName } from '../../lib/wallet/Wallet';
 
+const keplrEnable = vi.fn(async () => undefined);
+const getAccounts = vi.fn(async () => []);
+
+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 };
+}
+
 describe('ConnectWallet storage integration', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    keplrEnable.mockResolvedValue(undefined);
+    getAccounts.mockResolvedValue([{
+      address: 'cosmos1connected',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }]);
+    Object.defineProperty(window, 'keplr', {
+      configurable: true,
+      value: { enable: keplrEnable },
+    });
+    Object.defineProperty(window, 'getOfflineSigner', {
+      configurable: true,
+      value: vi.fn(() => ({ getAccounts })),
+    });
+  });
+
+  afterEach(() => {
+    Reflect.deleteProperty(window, 'keplr');
+    Reflect.deleteProperty(window, 'getOfflineSigner');
+  });
+
   it('removes the persisted HD-path record when disconnecting', async () => {
     const connected = {
       wallet: WalletName.Keplr,
@@ -24,9 +60,83 @@ describe('ConnectWallet storage integration', () => {
       },
     });
 
+    await vi.waitFor(() => expect(keplrEnable).toHaveBeenCalledWith('cosmoshub-4'));
+    await vi.waitFor(() => expect(getAccounts).toHaveBeenCalledOnce());
+    await vi.waitFor(() =>
+      expect(wrapper.emitted('connect')).toEqual([[{ value: connected }]]),
+    );
+    await vi.waitFor(() =>
+      expect(wrapper.find('[data-testid="wallet-disconnect"]').exists()).toBe(true),
+    );
     await wrapper.get('[data-testid="wallet-disconnect"]').trigger('click');
 
     expect(localStorage.getItem(DEFAULT_HDPATH)).toBeNull();
-    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 },
+    ]);
+  });
+
+  it('clears persisted state when Keplr revalidation fails', async () => {
+    keplrEnable.mockRejectedValueOnce(new Error('Keplr unavailable'));
+    const connected = {
+      wallet: WalletName.Keplr,
+      cosmosAddress: 'cosmos1stale',
+      hdPath: DEFAULT_HDPATH,
+    };
+    localStorage.setItem(DEFAULT_HDPATH, JSON.stringify(connected));
+    const wrapper = mount(ConnectWallet, {
+      props: {
+        chainId: 'cosmoshub-4',
+        hdPath: DEFAULT_HDPATH,
+        addrPrefix: 'cosmos',
+      },
+      global: { stubs: { Icon: true } },
+    });
+
+    await vi.waitFor(() =>
+      expect(localStorage.getItem(DEFAULT_HDPATH)).toBeNull(),
+    );
+    await flushPromises();
+    expect(wrapper.emitted('disconnect')).toEqual([
+      [{ value: undefined }],
+    ]);
+    expect(wrapper.text()).toContain('Connect Wallet');
+  });
+
+  it('preserves a persisted Keplr session when validation is disposed on unmount', async () => {
+    const pending = deferred<Array<{
+      address: string;
+      algo: string;
+      pubkey: Uint8Array;
+    }>>();
+    getAccounts.mockReturnValueOnce(pending.promise);
+    const connected = {
+      wallet: WalletName.Keplr,
+      cosmosAddress: 'cosmos1stored',
+      hdPath: DEFAULT_HDPATH,
+    };
+    const serialized = JSON.stringify(connected);
+    localStorage.setItem(DEFAULT_HDPATH, serialized);
+    const wrapper = mount(ConnectWallet, {
+      props: {
+        chainId: 'cosmoshub-4',
+        hdPath: DEFAULT_HDPATH,
+        addrPrefix: 'cosmos',
+      },
+      global: { stubs: { Icon: true } },
+    });
+    await vi.waitFor(() => expect(getAccounts).toHaveBeenCalledOnce());
+
+    wrapper.unmount();
+    pending.resolve([{
+      address: 'cosmos1current',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }]);
+    await flushPromises();
+
+    expect(localStorage.getItem(DEFAULT_HDPATH)).toBe(serialized);
   });
 });

package/test/wallet/KeplrSessionManager.test.ts

@@ -0,0 +1,269 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  KeplrSessionManager,
+  KEPLR_KEYSTORE_EVENT,
+  type WalletEventTarget,
+} from '../../lib/wallet/KeplrSessionManager';
+import {
+  WalletName,
+  type AbstractWallet,
+  type Account,
+  type WalletArgument,
+} from '../../lib/wallet/Wallet';
+
+const hdPath = "m/44'/118/0'/0/0";
+const argument: WalletArgument = {
+  chainId: 'cosmoshub-4',
+  hdPath,
+  prefix: 'cosmos',
+};
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function fakeEvents() {
+  let listener: EventListener | undefined;
+  const target: WalletEventTarget & { emit(): void } = {
+    addEventListener: vi.fn((_type, next) => {
+      listener = next;
+    }),
+    removeEventListener: vi.fn((_type, current) => {
+      if (listener === current) listener = undefined;
+    }),
+    emit() {
+      listener?.(new Event(KEPLR_KEYSTORE_EVENT));
+    },
+  };
+  return target;
+}
+
+function walletWith(accounts: Promise<Account[]> | Account[]): AbstractWallet {
+  return {
+    name: WalletName.Keplr,
+    getAccounts: vi.fn(async () => await accounts),
+    supportCoinType: vi.fn(async () => true),
+    sign: vi.fn(),
+  };
+}
+
+describe('KeplrSessionManager', () => {
+  beforeEach(() => localStorage.clear());
+
+  it('validates, persists and emits the active Keplr account on start', async () => {
+    const events = fakeEvents();
+    const account = {
+      address: 'cosmos1current',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    };
+    const changed = vi.fn();
+    const manager = new KeplrSessionManager(
+      hdPath,
+      () => walletWith([account]),
+      events,
+    );
+
+    await manager.start(argument, changed);
+
+    expect(events.addEventListener).toHaveBeenCalledWith(
+      KEPLR_KEYSTORE_EVENT,
+      expect.any(Function),
+    );
+    expect(changed).toHaveBeenLastCalledWith({
+      wallet: WalletName.Keplr,
+      cosmosAddress: account.address,
+      hdPath,
+    });
+    expect(JSON.parse(localStorage.getItem(hdPath) || '{}')).toMatchObject({
+      wallet: WalletName.Keplr,
+      cosmosAddress: account.address,
+    });
+  });
+
+  it('clears the old session before accepting an account change', async () => {
+    const events = fakeEvents();
+    let accounts = [{
+      address: 'cosmos1first',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }];
+    const wallet = walletWith(accounts);
+    vi.mocked(wallet.getAccounts).mockImplementation(async () => accounts);
+    const changed = vi.fn();
+    const manager = new KeplrSessionManager(hdPath, () => wallet, events);
+    await manager.start(argument, changed);
+
+    accounts = [{
+      address: 'cosmos1second',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([2]),
+    }];
+    events.emit();
+
+    await vi.waitFor(() =>
+      expect(changed).toHaveBeenLastCalledWith(
+        expect.objectContaining({ cosmosAddress: 'cosmos1second' }),
+      ),
+    );
+    const firstIndex = changed.mock.calls.findIndex(
+      ([value]) => value?.cosmosAddress === 'cosmos1first',
+    );
+    const secondIndex = changed.mock.calls.findIndex(
+      ([value]) => value?.cosmosAddress === 'cosmos1second',
+    );
+    const disconnectIndex = changed.mock.calls.findIndex(
+      ([value], index) =>
+        index > firstIndex && index < secondIndex && value === undefined,
+    );
+    expect(firstIndex).toBeGreaterThan(-1);
+    expect(secondIndex).toBeGreaterThan(firstIndex);
+    expect(disconnectIndex).toBeGreaterThan(firstIndex);
+    expect(disconnectIndex).toBeLessThan(secondIndex);
+  });
+
+  it('collapses duplicate key-store events into one account refresh', async () => {
+    const events = fakeEvents();
+    const wallet = walletWith([{
+      address: 'cosmos1current',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }]);
+    const manager = new KeplrSessionManager(hdPath, () => wallet, events);
+    await manager.start(argument, vi.fn());
+    vi.mocked(wallet.getAccounts).mockClear();
+
+    events.emit();
+    events.emit();
+
+    await vi.waitFor(() =>
+      expect(wallet.getAccounts).toHaveBeenCalledTimes(1),
+    );
+  });
+
+  it('ignores an older account result after a newer refresh', async () => {
+    const events = fakeEvents();
+    const first = deferred<Account[]>();
+    const second = deferred<Account[]>();
+    const wallet = walletWith(first.promise);
+    vi.mocked(wallet.getAccounts)
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise);
+    const changed = vi.fn();
+    const manager = new KeplrSessionManager(hdPath, () => wallet, events);
+    const starting = manager.start(argument, changed);
+
+    events.emit();
+    first.resolve([{
+      address: 'cosmos1first',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }]);
+    await starting;
+    second.resolve([{
+      address: 'cosmos1second',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([2]),
+    }]);
+    await vi.waitFor(() =>
+      expect(changed).toHaveBeenCalledWith(
+        expect.objectContaining({ cosmosAddress: 'cosmos1second' }),
+      ),
+    );
+
+    expect(
+      changed.mock.calls.some(
+        ([value]) => value?.cosmosAddress === 'cosmos1first',
+      ),
+    ).toBe(false);
+  });
+
+  it('ignores a key-store event queued before a new lifecycle starts', async () => {
+    const events = fakeEvents();
+    const wallet = walletWith([]);
+    vi.mocked(wallet.getAccounts)
+      .mockResolvedValueOnce([{
+        address: 'cosmos1old',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([1]),
+      }])
+      .mockResolvedValueOnce([{
+        address: 'cosmos1new',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([2]),
+      }])
+      .mockResolvedValueOnce([{
+        address: 'cosmos1unexpected',
+        algo: 'secp256k1',
+        pubkey: new Uint8Array([3]),
+      }]);
+    const manager = new KeplrSessionManager(hdPath, () => wallet, events);
+    const changed = vi.fn();
+    await manager.start(argument, changed);
+
+    events.emit();
+    manager.dispose();
+    await manager.start(argument, changed);
+
+    expect(wallet.getAccounts).toHaveBeenCalledTimes(2);
+    expect(changed).toHaveBeenLastCalledWith(
+      expect.objectContaining({ cosmosAddress: 'cosmos1new' }),
+    );
+  });
+
+  it('fails closed when Keplr account validation fails', async () => {
+    const events = fakeEvents();
+    localStorage.setItem(hdPath, '{"wallet":"Keplr","cosmosAddress":"stale"}');
+    const changed = vi.fn();
+    const failed = vi.fn();
+    const manager = new KeplrSessionManager(
+      hdPath,
+      () => walletWith(Promise.reject(new Error('Keplr unavailable'))),
+      events,
+    );
+
+    await manager.start(argument, changed, failed);
+
+    expect(changed).toHaveBeenCalledWith(undefined);
+    expect(localStorage.getItem(hdPath)).toBeNull();
+    expect(failed).toHaveBeenCalledWith(
+      expect.objectContaining({ message: expect.any(String) }),
+    );
+  });
+
+  it('removes its listener and cancels pending work on dispose', async () => {
+    const events = fakeEvents();
+    const pending = deferred<Account[]>();
+    const changed = vi.fn();
+    const manager = new KeplrSessionManager(
+      hdPath,
+      () => walletWith(pending.promise),
+      events,
+    );
+    const starting = manager.start(argument, changed);
+
+    manager.dispose();
+    pending.resolve([{
+      address: 'cosmos1late',
+      algo: 'secp256k1',
+      pubkey: new Uint8Array([1]),
+    }]);
+    await starting;
+
+    expect(events.removeEventListener).toHaveBeenCalledWith(
+      KEPLR_KEYSTORE_EVENT,
+      expect.any(Function),
+    );
+    expect(
+      changed.mock.calls.some(
+        ([value]) => value?.cosmosAddress === 'cosmos1late',
+      ),
+    ).toBe(false);
+  });
+});