@rango-dev/wallets-react 0.0.0-experimental-99f1781b-20260920 → 0.0.0-experimental-a84f27a7-20260921

package/src/hub/autoConnect.test.ts

@@ -1,193 +0,0 @@
-import type { EventHandler } from '../legacy/types.js';
-import type { Namespace } from '@hub3js/namespaces';
-
-import {
-  createStore,
-  Hub,
-  NamespaceBuilder,
-  ProviderBuilder,
-} from '@hub3js/core';
-import { WalletConnectionError } from '@hub3js/std/utils';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { AutoConnectionAttemptError } from '../errors.js';
-import { Events } from '../legacy/types.js';
-
-import { autoConnect } from './autoConnect.js';
-import { HUB_LAST_CONNECTED_WALLETS } from './constants.js';
-import { LastConnectedWalletsFromStorage } from './lastConnectedWallets.js';
-
-const WALLET = 'test-wallet';
-
-type TestActions = {
-  connect: (...args: unknown[]) => Promise<string[]>;
-  canEagerConnect: () => Promise<boolean>;
-};
-
-type NamespaceBehaviour = {
-  connect?: () => Promise<string[]>;
-  canEagerConnect?: () => Promise<boolean>;
-};
-
-const storage = new LastConnectedWalletsFromStorage(HUB_LAST_CONNECTED_WALLETS);
-
-function buildHub(
-  namespaces: Partial<Record<Namespace, NamespaceBehaviour>>
-): Hub {
-  const providerBuilder = new ProviderBuilder(WALLET).config('metadata', {
-    name: 'Test Wallet',
-    icon: 'https://example.com/icon.svg',
-    extensions: { homepage: 'https://example.com' },
-  });
-
-  Object.entries(namespaces).forEach(([namespaceId, behaviour = {}]) => {
-    const namespace = new NamespaceBuilder<TestActions>(namespaceId, WALLET)
-      .action('connect', async () =>
-        behaviour.connect ? behaviour.connect() : []
-      )
-      .action('canEagerConnect', async () =>
-        behaviour.canEagerConnect ? behaviour.canEagerConnect() : true
-      )
-      .build();
-    providerBuilder.add(namespaceId, namespace);
-  });
-
-  return new Hub({ store: createStore() }).add(WALLET, providerBuilder.build());
-}
-
-async function runAutoConnect(hub: Hub) {
-  const onUpdateState = vi.fn<EventHandler>();
-
-  await autoConnect({ getHub: () => hub, allBlockChains: [], onUpdateState });
-  // `autoConnect` resolves before the auto-connect attempts it starts have settled.
-  await new Promise((resolve) => setTimeout(resolve, 0));
-
-  return onUpdateState.mock.calls.filter(
-    ([, event]) => event === Events.AUTO_CONNECT_FAILED
-  );
-}
-
-describe('autoConnect', () => {
-  beforeEach(() => {
-    localStorage.clear();
-    storage.addWallet(WALLET, [
-      { namespace: 'EVM', network: 'ETH' },
-      { namespace: 'Solana', network: 'SOLANA' },
-    ]);
-  });
-
-  it('send no event when every attempted namespace connected', async () => {
-    const connect = vi.fn(async () => []);
-
-    const events = await runAutoConnect(
-      buildHub({ EVM: { connect }, Solana: { connect } })
-    );
-
-    expect(connect).toHaveBeenCalledTimes(2);
-    expect(events).toEqual([]);
-  });
-
-  it('send no event when no namespace was attempted', async () => {
-    const connect = vi.fn(async () => []);
-
-    const events = await runAutoConnect(
-      buildHub({
-        EVM: {
-          connect,
-          canEagerConnect: async () => Promise.reject(new Error('locked')),
-        },
-        Solana: { connect, canEagerConnect: async () => false },
-      })
-    );
-
-    expect(connect).not.toHaveBeenCalled();
-    expect(events).toEqual([]);
-  });
-
-  it('send no event for a saved wallet that is not registered', async () => {
-    localStorage.clear();
-    storage.addWallet('unregistered-wallet', [
-      { namespace: 'EVM', network: 'ETH' },
-    ]);
-
-    const events = await runAutoConnect(buildHub({ EVM: {} }));
-
-    expect(events).toEqual([]);
-  });
-
-  it('send an auto connection attempt error listing the tried namespaces with their saved networks', async () => {
-    const solanaError = new Error('Solana failed');
-
-    const events = await runAutoConnect(
-      buildHub({
-        EVM: {},
-        Solana: { connect: async () => Promise.reject(solanaError) },
-      })
-    );
-
-    expect(events).toHaveLength(1);
-    const [type, , value] = events[0];
-    expect(type).toBe(WALLET);
-    expect(value).toBeInstanceOf(AutoConnectionAttemptError);
-    expect(value.name).toBe('AutoConnectionAttemptError');
-    expect(value.message).toBe('Solana failed');
-    expect(value.requestedNamespaces).toStrictEqual([
-      { namespace: 'EVM', network: 'ETH' },
-      { namespace: 'Solana', network: 'SOLANA' },
-    ]);
-    expect(value.errors).toHaveLength(1);
-    expect(value.errors[0]).toBeInstanceOf(WalletConnectionError);
-    expect(value.errors[0]).toMatchObject({
-      namespace: 'Solana',
-      cause: solanaError,
-    });
-  });
-
-  it('wrap a thrown value that is not an error object in a wallet connection error for its namespace', async () => {
-    const events = await runAutoConnect(
-      buildHub({
-        EVM: { connect: async () => Promise.reject('User rejected') },
-        Solana: {},
-      })
-    );
-
-    const [, , value] = events[0];
-    expect(value.errors[0]).toBeInstanceOf(WalletConnectionError);
-    expect(value.errors[0]).toMatchObject({
-      namespace: 'EVM',
-      message: 'User rejected',
-      cause: 'User rejected',
-    });
-  });
-
-  it('leave saved namespaces the wallet no longer has out of the event', async () => {
-    const evmError = new Error('EVM failed');
-
-    const events = await runAutoConnect(
-      buildHub({ EVM: { connect: async () => Promise.reject(evmError) } })
-    );
-
-    expect(events).toHaveLength(1);
-    const [, , value] = events[0];
-    expect(value.requestedNamespaces).toEqual([
-      { namespace: 'EVM', network: 'ETH' },
-    ]);
-    expect(value.errors).toHaveLength(1);
-    expect(value.errors[0]).toMatchObject({ namespace: 'EVM' });
-  });
-
-  it('remove the namespaces that failed to connect from storage', async () => {
-    await runAutoConnect(
-      buildHub({
-        EVM: {},
-        Solana: {
-          connect: async () => Promise.reject(new Error('Solana failed')),
-        },
-      })
-    );
-
-    expect(storage.list()[WALLET]).toEqual([
-      { namespace: 'EVM', network: 'ETH' },
-    ]);
-  });
-});

package/src/hub/helpers.test.ts

@@ -1,138 +0,0 @@
-import type { NamespaceInputForConnect } from '../legacy/types.js';
-
-import { USER_REJECTION_ERROR_CODE } from '@hub3js/std/utils';
-import { Err, Ok } from 'ts-results';
-import { describe, expect, it } from 'vitest';
-
-import { WalletConnectionAttemptError } from '../errors.js';
-
-import { runConnectionAttempt } from './helpers.js';
-
-const connected = new Ok({ accounts: [], network: null });
-
-const SOLANA_DERIVATION_PATH = "m/44'/501'/0'/0'";
-const evm: NamespaceInputForConnect = { namespace: 'EVM', network: 'ETH' };
-const solana: NamespaceInputForConnect = {
-  namespace: 'Solana',
-  network: undefined,
-  derivationPath: SOLANA_DERIVATION_PATH,
-};
-const sui: NamespaceInputForConnect = { namespace: 'Sui', network: undefined };
-const requestedNamespaces = [evm, solana, sui];
-
-function rejection() {
-  return Object.assign(new Error('User rejected the request.'), {
-    code: USER_REJECTION_ERROR_CODE,
-  });
-}
-
-async function catchAttemptError(
-  ...args: Parameters<typeof runConnectionAttempt>
-): Promise<WalletConnectionAttemptError> {
-  const thrown: unknown = await runConnectionAttempt(...args).then(
-    () => undefined,
-    (error: unknown) => error
-  );
-  expect(thrown).toBeInstanceOf(WalletConnectionAttemptError);
-  return thrown as WalletConnectionAttemptError;
-}
-
-describe('runConnectionAttempt', () => {
-  it('list each requested namespace with the network and derivation path passed for it including cancelled ones', async () => {
-    const error = await catchAttemptError(
-      requestedNamespaces,
-      async (reportAttempts) => {
-        reportAttempts([
-          { input: evm, result: new Err(rejection()) },
-          { input: solana, result: new Err(rejection()), cancelled: true },
-          { input: sui, result: new Err(rejection()), cancelled: true },
-        ]);
-      }
-    );
-
-    expect(error.requestedNamespaces).toEqual([
-      { namespace: 'EVM', network: 'ETH' },
-      {
-        namespace: 'Solana',
-        network: undefined,
-        derivationPath: SOLANA_DERIVATION_PATH,
-      },
-      { namespace: 'Sui', network: undefined },
-    ]);
-    expect(error.errors).toHaveLength(1);
-    expect(error.errors[0]).toMatchObject({ namespace: 'EVM' });
-  });
-
-  it('add a config error thrown before any namespace is tried as the only entry without wrapping it', async () => {
-    const configError = new Error(
-      "You should add phantom to provider first then call 'connect'."
-    );
-
-    const error = await catchAttemptError(requestedNamespaces, async () => {
-      throw configError;
-    });
-
-    expect(error.errors).toHaveLength(1);
-    expect(error.errors[0]).toBe(configError);
-    expect(error.message).toBe(configError.message);
-    expect(error.requestedNamespaces.map(({ namespace }) => namespace)).toEqual(
-      ['EVM', 'Solana', 'Sui']
-    );
-  });
-
-  it('list no requested namespaces when none were passed', async () => {
-    const configError = new Error(
-      'Passing namespace to `connect` is required.'
-    );
-
-    const error = await catchAttemptError(undefined, async () => {
-      throw configError;
-    });
-
-    expect(error.errors).toEqual([configError]);
-    expect(error.requestedNamespaces).toEqual([]);
-  });
-
-  it('add a value thrown once the namespaces have settled after their failures without wrapping it', async () => {
-    const storageError = new Error('QuotaExceededError');
-
-    const error = await catchAttemptError(
-      requestedNamespaces,
-      async (reportAttempts) => {
-        reportAttempts([
-          { input: evm, result: new Err(new Error('EVM failed')) },
-          { input: solana, result: connected },
-          { input: sui, result: connected },
-        ]);
-        throw storageError;
-      }
-    );
-
-    expect(error.errors).toHaveLength(2);
-    expect(error.errors[0]).toMatchObject({ namespace: 'EVM' });
-    expect(error.errors[1]).toBe(storageError);
-  });
-
-  it('add a thrown undefined as the only entry', async () => {
-    const error = await catchAttemptError(requestedNamespaces, async () => {
-      // eslint-disable-next-line @typescript-eslint/only-throw-error
-      throw undefined;
-    });
-
-    expect(error.errors).toEqual([undefined]);
-  });
-
-  it('return each namespace result in request order when every namespace connected', async () => {
-    const results = await runConnectionAttempt(
-      [evm, solana],
-      async (reportAttempts) => {
-        reportAttempts([
-          { input: evm, result: new Ok('evm accounts') },
-          { input: solana, result: new Ok('solana accounts') },
-        ]);
-      }
-    );
-
-    expect(results).toEqual(['evm accounts', 'solana accounts']);
-  });
-});

package/src/hub/useHubAdapter.test.ts

@@ -1,186 +0,0 @@
-import type { NamespaceInputForConnect } from '../legacy/types.js';
-import type { ProviderContext } from '../types.js';
-import type { Provider } from '@hub3js/core';
-
-import { NamespaceBuilder, ProviderBuilder } from '@hub3js/core';
-import {
-  USER_REJECTION_ERROR_CODE,
-  WALLET_LOCKED_ERROR_CODE,
-} from '@hub3js/std/utils';
-import { act, renderHook } from '@testing-library/react-hooks';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { WalletConnectionAttemptError } from '../errors.js';
-
-import { useHubAdapter } from './useHubAdapter.js';
-
-type TestActions = {
-  connect: (...args: unknown[]) => Promise<string[]>;
-};
-
-type NamespaceConnect = () => Promise<string[]>;
-
-const evm: NamespaceInputForConnect = { namespace: 'EVM', network: 'ETH' };
-const solana: NamespaceInputForConnect = {
-  namespace: 'Solana',
-  network: undefined,
-};
-const sui: NamespaceInputForConnect = { namespace: 'Sui', network: undefined };
-
-function rejection() {
-  return Object.assign(new Error('User rejected the request.'), {
-    code: USER_REJECTION_ERROR_CODE,
-  });
-}
-
-function lockedWallet() {
-  return Object.assign(new Error('The device is locked'), {
-    code: WALLET_LOCKED_ERROR_CODE,
-  });
-}
-
-function buildProvider(
-  walletType: string,
-  connects: Record<string, NamespaceConnect>
-): Provider {
-  const providerBuilder = new ProviderBuilder<unknown>(walletType).config(
-    'metadata',
-    {
-      name: walletType,
-      icon: 'https://example.com/icon.svg',
-      extensions: { homepage: 'https://example.com' },
-    }
-  );
-
-  Object.entries(connects).forEach(([namespaceId, connect]) => {
-    const namespace = new NamespaceBuilder<TestActions>(namespaceId, walletType)
-      .action('connect', async () => connect())
-      .build();
-    providerBuilder.add(namespaceId, namespace);
-  });
-
-  return providerBuilder.build();
-}
-
-function renderAdapter(providers: Provider[]): ProviderContext {
-  return renderHook(() => useHubAdapter({ providers })).result.current;
-}
-
-async function connectAndCatch(
-  api: ProviderContext,
-  walletType: string,
-  namespaces: NamespaceInputForConnect[]
-): Promise<WalletConnectionAttemptError> {
-  let thrown: unknown;
-  await act(async () => {
-    thrown = await api.connect(walletType, namespaces).then(
-      () => undefined,
-      (error: unknown) => error
-    );
-  });
-  expect(thrown).toBeInstanceOf(WalletConnectionAttemptError);
-  return thrown as WalletConnectionAttemptError;
-}
-
-describe('useHubAdapter', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  describe('connect', () => {
-    it('abandon the namespaces still waiting after a rejection', async () => {
-      const solanaConnect = vi.fn(async () => []);
-      const suiConnect = vi.fn(async () => []);
-      const api = renderAdapter([
-        buildProvider('phantom', {
-          EVM: async () => Promise.reject(rejection()),
-          Solana: solanaConnect,
-          Sui: suiConnect,
-        }),
-      ]);
-
-      await connectAndCatch(api, 'phantom', [evm, solana, sui]);
-
-      expect(solanaConnect).not.toHaveBeenCalled();
-      expect(suiConnect).not.toHaveBeenCalled();
-    });
-
-    it('leave the namespaces abandoned after a rejection out of errors', async () => {
-      const api = renderAdapter([
-        buildProvider('phantom', {
-          EVM: async () => Promise.reject(rejection()),
-          Solana: async () => Promise.reject(new Error('Solana failed')),
-          Sui: async () => Promise.reject(new Error('Sui failed')),
-        }),
-      ]);
-
-      const error = await connectAndCatch(api, 'phantom', [evm, solana, sui]);
-
-      expect(error.errors).toHaveLength(1);
-      expect(error.errors[0]).toMatchObject({
-        namespace: 'EVM',
-        code: USER_REJECTION_ERROR_CODE,
-      });
-    });
-
-    it('keep the namespaces abandoned after a rejection in the requested namespaces', async () => {
-      const api = renderAdapter([
-        buildProvider('phantom', {
-          EVM: async () => Promise.reject(rejection()),
-          Solana: async () => [],
-          Sui: async () => [],
-        }),
-      ]);
-
-      const error = await connectAndCatch(api, 'phantom', [evm, solana, sui]);
-
-      expect(error.requestedNamespaces).toEqual([evm, solana, sui]);
-    });
-
-    it('keep connecting the waiting namespaces after a locked wallet', async () => {
-      const solanaConnect = vi.fn(async () => []);
-      const api = renderAdapter([
-        buildProvider('ledger', {
-          EVM: async () => Promise.reject(lockedWallet()),
-          Solana: solanaConnect,
-        }),
-      ]);
-
-      const error = await connectAndCatch(api, 'ledger', [evm, solana]);
-
-      expect(solanaConnect).toHaveBeenCalledTimes(1);
-      expect(error.errors).toHaveLength(1);
-      expect(error.errors[0]).toMatchObject({
-        namespace: 'EVM',
-        code: WALLET_LOCKED_ERROR_CODE,
-      });
-    });
-
-    it('keep connecting the waiting namespaces of other wallets after a rejection', async () => {
-      let finishMetamaskEvm: (accounts: string[]) => void = () => undefined;
-      const metamaskEvmFinished = new Promise<string[]>((resolve) => {
-        finishMetamaskEvm = resolve;
-      });
-      const metamaskSolanaConnect = vi.fn(async () => []);
-      const api = renderAdapter([
-        buildProvider('phantom', {
-          EVM: async () => Promise.reject(rejection()),
-          Solana: async () => [],
-        }),
-        buildProvider('metamask', {
-          EVM: async () => metamaskEvmFinished,
-          Solana: metamaskSolanaConnect,
-        }),
-      ]);
-
-      await act(async () => {
-        const metamask = api.connect('metamask', [evm, solana]);
-        await api.connect('phantom', [evm, solana]).catch(() => undefined);
-        finishMetamaskEvm([]);
-        await metamask;
-      });
-
-      expect(metamaskSolanaConnect).toHaveBeenCalledTimes(1);
-    });
-  });
-});