@rango-dev/wallets-react 0.27.1-next.8 → 0.28.0

package/src/hub/utils.ts

@@ -1,20 +1,14 @@
 import type { AllProxiedNamespaces } from './types.js';
-import type { Hub, Provider, State } from '@rango-dev/wallets-core';
+import type { Hub, Provider } from '@rango-dev/wallets-core';
 import type {
   LegacyNamespaceInputForConnect,
   LegacyProviderInterface,
   LegacyEventHandler as WalletEventHandler,
 } from '@rango-dev/wallets-core/legacy';
+import type { Event } from '@rango-dev/wallets-core/store';
 
-import {
-  guessProviderStateSelector,
-  namespaceStateSelector,
-} from '@rango-dev/wallets-core';
 import { LegacyEvents as Events } from '@rango-dev/wallets-core/legacy';
-import {
-  generateStoreId,
-  type VersionedProviders,
-} from '@rango-dev/wallets-core/utils';
+import { type VersionedProviders } from '@rango-dev/wallets-core/utils';
 import { pickVersion } from '@rango-dev/wallets-core/utils';
 import {
   type AddEthereumChainParameter,
@@ -74,168 +68,170 @@ const lastConnectedWalletsFromStorage = new LastConnectedWalletsFromStorage(
   HUB_LAST_CONNECTED_WALLETS
 );
 
-export function checkHubStateAndTriggerEvents(
+export function mapHubEventsToLegacy(
   hub: Hub,
-  currentState: State,
-  previousState: State,
+  event: Event,
   onUpdateState: WalletEventHandler,
   allProviders: VersionedProviders[],
   allBlockChains: ProviderProps['allBlockChains']
 ): void {
-  hub.getAll().forEach((provider, providerId) => {
-    const currentProviderState = guessProviderStateSelector(
-      currentState,
-      providerId
-    );
-    const previousProviderState = guessProviderStateSelector(
-      previousState,
-      providerId
+  let legacyProvider;
+  try {
+    legacyProvider = getLegacyProvider(allProviders, event.provider);
+  } catch (e) {
+    console.warn(
+      'Having legacy provider is required for including some information like supported chain. ',
+      e
     );
+  }
 
-    let accounts: string[] | null = [];
-    /*
-     * We don't rely `accounts` to make sure we will trigger proper event on this case:
-     * previous value: [0x...]
-     * current value: []
-     */
-    let hasAccountChanged = false;
-    let hasNetworkChanged = false;
-    let hasProviderDisconnected = false;
-    // It will pick the last network from namespaces.
-    let maybeNetwork = null;
-    const disconnectedNamespacesIds: string[] = [];
-
-    provider.getAll().forEach((namespace) => {
-      const storeId = generateStoreId(providerId, namespace.namespaceId);
-      const currentNamespaceState = namespaceStateSelector(
-        currentState,
-        storeId
-      );
-      const previousNamespaceState = namespaceStateSelector(
-        previousState,
-        storeId
-      );
-
-      if (currentNamespaceState.network !== null) {
-        maybeNetwork = currentNamespaceState.network;
-      }
-
-      // Check for network
-      if (currentNamespaceState.network !== previousNamespaceState.network) {
-        hasNetworkChanged = true;
+  const provider = hub.get(event.provider);
+  if (!provider) {
+    throw new Error(
+      "Currently all the events have assigned to a provider. The event doesn't include one.",
+      {
+        cause: event,
       }
+    );
+  }
 
-      // TODO: `accounts` has been frozen, we should check and find where object.freeze() is calling.
-
-      // Check for accounts
-      if (
-        previousNamespaceState.accounts?.slice().sort().toString() !==
-        currentNamespaceState.accounts?.slice().sort().toString()
-      ) {
-        if (currentNamespaceState.accounts) {
-          const formattedAddresses = currentNamespaceState.accounts.map(
-            fromAccountIdToLegacyAddressFormat
-          );
-
-          if (accounts) {
-            accounts = [...accounts, ...formattedAddresses];
-          } else {
-            accounts = [...formattedAddresses];
-          }
+  // @ts-expect-error for those events that doesn't have namespace, it will be undefinded
+  const namespaceId: string | undefined = event.namespace;
 
-          hasAccountChanged = true;
-        } else {
-          // Namespace has been disconnected
-          disconnectedNamespacesIds.push(namespace.namespaceId);
-          accounts = null;
-          hasProviderDisconnected = true;
-        }
-      }
-    });
+  const namespace = namespaceId
+    ? provider.findByNamespace(namespaceId)
+    : undefined;
+  let accounts: string[] | null = null;
+  let network: string | null = null;
 
-    if (disconnectedNamespacesIds.length > 0) {
-      lastConnectedWalletsFromStorage.removeNamespacesFromWallet(
-        providerId,
-        disconnectedNamespacesIds
-      );
-    }
-
-    let legacyProvider;
-    try {
-      legacyProvider = getLegacyProvider(allProviders, providerId);
-    } catch (e) {
-      console.warn(
-        'Having legacy provider is required for including some information like supported chain. ',
-        e
-      );
-    }
+  if (namespace) {
+    const [getNamespaceState] = namespace.state();
+    accounts = getNamespaceState().accounts;
+    network = getNamespaceState().network;
+  }
 
-    const coreState = {
-      connected: currentProviderState.connected,
-      connecting: currentProviderState.connecting,
-      installed: currentProviderState.installed,
-      accounts: accounts,
-      network: maybeNetwork,
-      reachable: true,
-    };
+  const [getProviderState] = provider.state();
+  const coreState = {
+    connected: getProviderState().connected,
+    connecting: getProviderState().connecting,
+    installed: getProviderState().installed,
+    accounts,
+    network,
+    reachable: true,
+  };
 
-    const eventInfo = {
-      supportedBlockchains:
-        legacyProvider?.getWalletInfo(allBlockChains || []).supportedChains ||
-        [],
-      isContractWallet: false,
-      isHub: true,
-    };
+  const eventInfo = {
+    supportedBlockchains:
+      legacyProvider?.getWalletInfo(allBlockChains || []).supportedChains || [],
+    isContractWallet: false,
+    isHub: true,
+    namespace: namespaceId,
+  };
 
-    if (previousProviderState.installed !== currentProviderState.installed) {
+  switch (event.type) {
+    case 'provider_detected':
       onUpdateState(
-        providerId,
+        event.provider,
         Events.INSTALLED,
-        currentProviderState.installed,
+        true,
         coreState,
         eventInfo
       );
-    }
-    if (previousProviderState.connecting !== currentProviderState.connecting) {
+      break;
+    case 'provider_connecting':
       onUpdateState(
-        providerId,
+        event.provider,
         Events.CONNECTING,
-        currentProviderState.connecting,
+        event.value,
         coreState,
         eventInfo
       );
-    }
-    if (previousProviderState.connected !== currentProviderState.connected) {
+      break;
+    case 'provider_connected':
       onUpdateState(
-        providerId,
+        event.provider,
         Events.CONNECTED,
-        currentProviderState.connected,
+        true,
         coreState,
         eventInfo
       );
-    }
-    if (hasAccountChanged) {
+      break;
+    case 'provider_disconnected':
       onUpdateState(
-        providerId,
-        Events.ACCOUNTS,
-        accounts,
+        event.provider,
+        Events.PROVIDER_DISCONNECTED,
+        event.provider,
         coreState,
         eventInfo
       );
-    }
-    if (hasProviderDisconnected) {
-      onUpdateState(providerId, Events.ACCOUNTS, null, coreState, eventInfo);
-    }
-    if (hasNetworkChanged) {
       onUpdateState(
-        providerId,
-        Events.NETWORK,
-        maybeNetwork,
+        event.provider,
+        Events.CONNECTED,
+        false,
         coreState,
         eventInfo
       );
-    }
-  });
+      onUpdateState(
+        event.provider,
+        Events.ACCOUNTS,
+        null,
+        coreState,
+        eventInfo
+      );
+      break;
+    case 'namespace_disconnected':
+      lastConnectedWalletsFromStorage.removeNamespacesFromWallet(
+        event.provider,
+        [event.namespace]
+      );
+
+      onUpdateState(
+        event.provider,
+        Events.NAMESPACE_DISCONNECTED,
+        event.namespace,
+        coreState,
+        {
+          ...eventInfo,
+          namespace: event.namespace,
+        }
+      );
+      // onUpdateState(event.provider, Events.ACCOUNTS, null, coreState, eventInfo);
+      break;
+    case 'namespace_connected':
+    case 'namespace_account_switched':
+      {
+        if (event.type === 'namespace_account_switched') {
+          onUpdateState(
+            event.provider,
+            Events.NAMESPACE_DISCONNECTED,
+            event.namespace,
+            coreState,
+            eventInfo
+          );
+        }
+
+        const formattedAddresses = event.accounts.map(
+          fromAccountIdToLegacyAddressFormat
+        );
+        onUpdateState(
+          event.provider,
+          Events.ACCOUNTS,
+          formattedAddresses,
+          coreState,
+          {
+            ...eventInfo,
+            namespace: event.namespace,
+          }
+        );
+      }
+      break;
+    case 'namespace_network_switched':
+      onUpdateState(event.provider, Events.NETWORK, event.network, coreState, {
+        ...eventInfo,
+        namespace: event.namespace,
+      });
+      break;
+  }
 }
 
 export function getAllLegacyProviders(

package/src/index.ts

@@ -2,7 +2,3 @@ export * from './legacy/helpers.js';
 export { default as Provider } from './provider.js';
 export { useWallets } from './legacy/hooks.js';
 export * from './legacy/types.js';
-export {
-  separateLegacyAndHubProviders,
-  getAllLegacyProviders,
-} from './hub/mod.js';

package/src/legacy/types.ts

@@ -11,6 +11,11 @@ import type {
 import type { BlockchainMeta, SignerFactory } from 'rango-types';
 import type { PropsWithChildren } from 'react';
 
+import { LegacyEvents as Events } from '@rango-dev/wallets-core/legacy';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type InstanceType = any;
+
 export type State = {
   [key: string]: WalletState | undefined;
 };
@@ -18,10 +23,10 @@ export type State = {
 export type ConnectResult = {
   accounts: string[] | null;
   network: Network | null;
-  provider: any;
+  provider: InstanceType;
 };
 
-export type Providers = { [type in WalletType]?: any };
+export type Providers = { [type in WalletType]?: InstanceType };
 
 export type ExtendedWalletInfo = WalletInfo & {
   properties?: ProviderInfo['properties'];
@@ -34,6 +39,7 @@ export type ProviderContext = {
     namespaces?: LegacyNamespaceInputForConnect[]
   ): Promise<ConnectResult[]>;
   disconnect(type: WalletType): Promise<void>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   disconnectAll(): Promise<PromiseSettledResult<any>[]>;
   state(type: WalletType): WalletState;
   canSwitchNetworkTo(type: WalletType, network: Network): boolean;
@@ -60,14 +66,7 @@ export type ProviderProps = PropsWithChildren<{
   };
 }>;
 
-export enum Events {
-  CONNECTED = 'connected',
-  CONNECTING = 'connecting',
-  REACHABLE = 'reachable',
-  INSTALLED = 'installed',
-  ACCOUNTS = 'accounts',
-  NETWORK = 'network',
-}
+export { Events };
 
 export type ProviderConnectResult = {
   accounts: string[];
@@ -76,7 +75,7 @@ export type ProviderConnectResult = {
 
 export type GetInstanceOptions = {
   network?: Network;
-  currentProvider: any;
+  currentProvider: InstanceType;
   meta: BlockchainMeta[];
   getState: () => WalletState;
   /**
@@ -90,26 +89,28 @@ export type GetInstanceOptions = {
 };
 
 export type GetInstance =
-  | (() => any)
-  | ((options: GetInstanceOptions) => Promise<any>);
+  | (() => InstanceType)
+  | ((options: GetInstanceOptions) => Promise<InstanceType>);
 export type TryGetInstance =
-  | (() => any)
-  | ((options: Pick<GetInstanceOptions, 'force' | 'network'>) => Promise<any>);
+  | (() => InstanceType)
+  | ((
+      options: Pick<GetInstanceOptions, 'force' | 'network'>
+    ) => Promise<InstanceType>);
 export type Connect = (options: {
-  instance: any;
+  instance: InstanceType;
   network?: Network;
   meta: BlockchainMeta[];
 }) => Promise<ProviderConnectResult | ProviderConnectResult[]>;
 
 export type Disconnect = (options: {
-  instance: any;
+  instance: InstanceType;
   destroyInstance: () => void;
 }) => Promise<void>;
 
 type CleanupSubscribe = () => void;
 
 export type Subscribe = (options: {
-  instance: any;
+  instance: InstanceType;
   state: WalletState;
   meta: BlockchainMeta[];
   updateChainId: (chainId: string) => void;
@@ -119,7 +120,7 @@ export type Subscribe = (options: {
 }) => CleanupSubscribe | void;
 
 export type SwitchNetwork = (options: {
-  instance: any;
+  instance: InstanceType;
   network: Network;
   meta: BlockchainMeta[];
   newInstance?: TryGetInstance;
@@ -128,7 +129,7 @@ export type SwitchNetwork = (options: {
 }) => Promise<void>;
 
 export type Suggest = (options: {
-  instance: any;
+  instance: InstanceType;
   network: Network;
   meta: BlockchainMeta[];
 }) => Promise<void>;
@@ -136,17 +137,17 @@ export type Suggest = (options: {
 export type CanSwitchNetwork = (options: {
   network: Network;
   meta: BlockchainMeta[];
-  provider: any;
+  provider: InstanceType;
 }) => boolean;
 
 export type CanEagerConnect = (options: {
-  instance: any;
+  instance: InstanceType;
   meta: BlockchainMeta[];
 }) => Promise<boolean>;
 
 export interface WalletActions {
   connect: Connect;
-  getInstance: any;
+  getInstance: InstanceType;
   disconnect?: Disconnect;
   subscribe?: Subscribe;
   // unsubscribe, // coupled to subscribe.
@@ -154,7 +155,7 @@ export interface WalletActions {
   // Optional, but should be provided at the same time.
   suggest?: Suggest;
   switchNetwork?: SwitchNetwork;
-  getSigners: (provider: any) => Promise<SignerFactory>;
+  getSigners: (provider: InstanceType) => Promise<SignerFactory>;
   canSwitchNetworkTo?: CanSwitchNetwork;
   canEagerConnect?: CanEagerConnect;
   getWalletInfo(allBlockChains: BlockchainMeta[]): WalletInfo;