@rango-dev/wallets-react 0.0.0-experimental-c6bea4d8-20260930 → 0.0.0-experimental-2938686c-20261012

package/src/hub/useHubAdapter.ts

@@ -1,13 +1,16 @@
 import type { AllProxiedNamespaces, ExtensionLink } from './types.js';
 import type {
   ConnectResult,
+  EventHandler,
   NamespaceInputForConnect,
   WalletInfo,
 } from '../legacy/mod.js';
 import type { ProviderContext, ProviderProps } from '../types.js';
 import type { Provider, WalletType } from '@hub3js/core';
+import type { Event } from '@hub3js/core/store';
 import type { Accounts, AccountsWithActiveChain } from '@hub3js/std/types';
 
+import { Hub3Error } from '@hub3js/core';
 import {
   getSupportedChainsFromNamespace,
   getSupportedChainsFromProvider,
@@ -15,16 +18,18 @@ import {
 import { useEffect, useRef, useState } from 'react';
 import { Ok, Result } from 'ts-results';
 
-import { withErrorLoggingApi } from '../helpers.js';
+import {
+  emitWalletDetectedOnce,
+  toBlockchainName,
+  WalletEventChannel,
+  WalletEventTypes,
+} from '../events.js';
+import { Events } from '../legacy/mod.js';
 
 import { autoConnect } from './autoConnect.js';
 import { HUB_LAST_CONNECTED_WALLETS } from './constants.js';
 import { reportConnectionFailure } from './errors.js';
-import {
-  createQueue,
-  fromAccountIdToLegacyAddressFormat,
-  removeQueuedNamespacesOnRejection,
-} from './helpers.js';
+import { createQueue, fromAccountIdToLegacyAddressFormat } from './helpers.js';
 import { LastConnectedWalletsFromStorage } from './lastConnectedWallets.js';
 import { useAutoConnect } from './useAutoConnect.js';
 import { useHubRefs } from './useHubRefs.js';
@@ -49,6 +54,7 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
   const dataRef = useRef({
     onUpdateState: params.onUpdateState,
     allBlockChains: params.allBlockChains,
+    emitter: params.emitter,
   });
   const hubInitiated = useRef(false);
 
@@ -68,37 +74,43 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
   };
 
   const queueTask = createQueue({
-    onError: removeQueuedNamespacesOnRejection,
+    // Once the user rejects one of a wallet's namespaces, or the wallet is locked, its remaining queued namespaces are abandoned.
+    onError: (error, actions) => {
+      if (error instanceof Hub3Error && error.type !== 'PROVIDER_UNEXPECTED') {
+        actions.removeCurrentKeyFromQueue();
+      }
+    },
   });
 
   useEffect(() => {
     dataRef.current = {
       onUpdateState: params.onUpdateState,
       allBlockChains: params.allBlockChains,
+      emitter: params.emitter,
     };
   }, [params]);
 
   useEffect(() => {
-    getStore()
-      .subscribe((event) => {
-        if (dataRef.current.onUpdateState) {
-          try {
-            mapHubEventsToLegacy(
-              getHub(),
-              event,
-              dataRef.current.onUpdateState,
-              {
-                allBlockChains: dataRef.current.allBlockChains,
-                lastConnectAttemptParams: lastConnectAttemptParamsRef.current,
-              }
-            );
-          } catch (e) {
-            console.error(e);
-          }
-        }
-        rerender((currentRender) => currentRender + 1);
-      })
-      .flushEvents();
+    const onUpdateState: EventHandler = (type, event, value, state, info) => {
+      if (event === Events.INSTALLED && state.installed) {
+        emitWalletDetectedOnce(type, dataRef.current.emitter);
+      }
+      dataRef.current.onUpdateState?.(type, event, value, state, info);
+    };
+
+    const onStoreEvent = (event: Event) => {
+      try {
+        mapHubEventsToLegacy(getHub(), event, onUpdateState, {
+          allBlockChains: dataRef.current.allBlockChains,
+          lastConnectAttemptParams: lastConnectAttemptParamsRef.current,
+        });
+      } catch (e) {
+        console.error(e);
+      }
+      rerender((currentRender) => currentRender + 1);
+    };
+
+    getStore().subscribe(onStoreEvent).flushEvents();
   }, []);
 
   // Initialize hub only after blockchain meta is available (e.g. WalletConnect needs it at init).
@@ -120,6 +132,7 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
         allBlockChains: params.allBlockChains,
         getHub,
         wallets: params.configs?.wallets,
+        emitter: dataRef.current.emitter,
       });
     },
   });
@@ -266,7 +279,46 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
                   },
                 };
               });
-          return queueTask(connectNamespaceProcess, type);
+
+          // Reconnecting an already connected namespace (e.g. only to switch its network) isn't reported.
+          const connectNamespaceProcessWithEvents = async () => {
+            if (namespace.state()[0]().connected) {
+              return connectNamespaceProcess();
+            }
+
+            const eventPayload = {
+              walletName: type,
+              namespace: namespaceInput.namespace,
+              origin: 'manual' as const,
+            };
+            const requestedChain = namespaceInput.network || null;
+
+            dataRef.current.emitter?.emit(WalletEventChannel, {
+              type: WalletEventTypes.WALLET_CONNECT_INITIATED,
+              payload: { ...eventPayload, chain: requestedChain },
+            });
+            try {
+              const result = await connectNamespaceProcess();
+              dataRef.current.emitter?.emit(WalletEventChannel, {
+                type: WalletEventTypes.WALLET_CONNECTED,
+                payload: {
+                  ...eventPayload,
+                  chain: toBlockchainName(
+                    result.response.network,
+                    params.allBlockChains
+                  ),
+                },
+              });
+              return result;
+            } catch (error) {
+              dataRef.current.emitter?.emit(WalletEventChannel, {
+                type: WalletEventTypes.WALLET_CONNECT_FAILED,
+                payload: { ...eventPayload, chain: requestedChain },
+              });
+              throw error;
+            }
+          };
+          return queueTask(connectNamespaceProcessWithEvents, type);
         }
       );
 
@@ -320,6 +372,10 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
           !namespaces || namespaces.includes(namespace.namespaceId);
         const namespaceIsConnected = namespace.state()[0]().connected;
         if (namespaceShouldBeDisconnected && namespaceIsConnected) {
+          dataRef.current.emitter?.emit(WalletEventChannel, {
+            type: WalletEventTypes.WALLET_DISCONNECTED,
+            payload: { walletName: type, namespace: namespace.namespaceId },
+          });
           return namespace.disconnect();
         }
       });
@@ -518,5 +574,5 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
     },
   };
 
-  return withErrorLoggingApi(api);
+  return api;
 }

package/src/index.ts

@@ -1,4 +1,16 @@
 export { default as Provider } from './provider.js';
 export { useWallets } from './hooks.js';
 export type * from './types.js';
+export { WalletEventChannel, WalletEventTypes } from './events.js';
+export type {
+  Emitter,
+  WalletConnectedEventPayload,
+  WalletConnectFailedEventPayload,
+  WalletConnectInitiatedEventPayload,
+  WalletConnectOrigin,
+  WalletDetectedEventPayload,
+  WalletDisconnectedEventPayload,
+  WalletEventData,
+  WalletEvents,
+} from './events.js';
 export * from './legacy/types.js';

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { Emitter, WalletEvents } from './events.js';
 import type {
   ConnectResult,
   EventHandler,
@@ -43,6 +44,8 @@ export type ProviderProps = PropsWithChildren<{
   allBlockChains?: BlockchainMeta[];
   autoConnect?: boolean;
   providers: Provider[];
+  /** Receives wallet events on the `walletEvent` channel. */
+  emitter?: Emitter<WalletEvents>;
   configs?: {
     wallets?: (WalletType | Provider)[];
     walletOptions?: {