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

package/src/hub/autoConnect.ts

@@ -1,26 +1,17 @@
 import type { AllProxiedNamespaces } from './types.js';
 import type { UseAdapterParams } from './useHubAdapter.js';
-import type { NamespaceConnectAttempt } from '../errors.js';
-import type {
-  EventHandler,
-  NamespaceInputForConnect,
-} from '../legacy/types.js';
+import type { NamespaceInputForConnect } from '../legacy/types.js';
 import type { Hub, Provider, WalletType } from '@hub3js/core';
 import type { DefaultNamespaces, Namespace } from '@hub3js/namespaces';
 import type { Accounts, AccountsWithActiveChain } from '@hub3js/std/types';
 
 import { Result } from 'ts-results';
 
-import { buildAutoConnectionAttemptError } from '../errors.js';
-import { Events } from '../legacy/types.js';
-
 import { HUB_LAST_CONNECTED_WALLETS } from './constants.js';
-import { runSequentially, runSequentiallyWithoutFailure } from './helpers.js';
+import { runSequentiallyWithoutFailure } from './helpers.js';
 import { LastConnectedWalletsFromStorage } from './lastConnectedWallets.js';
 import {
   convertNamespaceNetworkToEvmChainId,
-  getProviderCoreState,
-  getProviderEventInfo,
   isEvmNamespace,
 } from './utils.js';
 
@@ -44,10 +35,9 @@ async function eagerConnect(
   params: {
     getHub: () => Hub;
     allBlockChains: UseAdapterParams['allBlockChains'];
-    onUpdateState?: EventHandler;
   }
 ) {
-  const { getHub, allBlockChains, onUpdateState } = params;
+  const { getHub, allBlockChains } = params;
   const wallet = getHub().get(type);
   if (!wallet) {
     throw new Error(
@@ -82,7 +72,7 @@ async function eagerConnect(
         : undefined;
       const chain = evmChain || info.network;
 
-      return async (): Promise<NamespaceConnectAttempt> => {
+      return async () => {
         let connectNamespacePromise: () => Promise<
           Accounts | AccountsWithActiveChain
         >;
@@ -91,10 +81,19 @@ async function eagerConnect(
         } else {
           connectNamespacePromise = async () => namespace.connect();
         }
-        return {
-          input: info,
-          result: await Result.wrapAsync(connectNamespacePromise),
-        };
+        try {
+          await connectNamespacePromise();
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } catch (e: any) {
+          /*
+           * Since we check for connect failures using `instanceof Error`
+           * this check is added here to make sure the thrown error always is an instance of `Error`
+           */
+          if (e instanceof Error) {
+            throw e;
+          }
+          throw new Error(e);
+        }
       };
     }
   );
@@ -104,31 +103,21 @@ async function eagerConnect(
    * We are running a method at a time to make sure we are covering this.
    * e.g. when we are trying to eagerConnect evm and solana on phantom at the same time, the last namespace throw an error.
    */
-  const attempts = await runSequentially(connectNamespacesPromises);
+  const connectNamespacesResult = await runSequentiallyWithoutFailure(
+    connectNamespacesPromises
+  );
 
-  const failedNamespaces = attempts
-    .filter(({ result }) => result.err)
-    .map(({ input }) => input.namespace);
+  const failedNamespaces: NamespaceInputForConnect[] = targetNamespaces
+    .filter((_, index) => connectNamespacesResult[index].err)
+    .map((targetNamespace) => targetNamespace[0]);
 
   if (failedNamespaces.length > 0) {
     lastConnectedWalletsFromStorage.removeNamespacesFromWallet(
       type,
-      failedNamespaces
-    );
-  }
-
-  const autoConnectionAttemptError = buildAutoConnectionAttemptError(attempts);
-  if (autoConnectionAttemptError) {
-    onUpdateState?.(
-      type,
-      Events.AUTO_CONNECT_FAILED,
-      autoConnectionAttemptError,
-      getProviderCoreState(wallet),
-      getProviderEventInfo(wallet, allBlockChains)
+      failedNamespaces.map((namespace) => namespace.namespace)
     );
   }
 
-  const connectNamespacesResult = attempts.map(({ result }) => result);
   const atLeastOneNamespaceConnectedSuccessfully = connectNamespacesResult.some(
     (result) => result.ok
   );
@@ -193,9 +182,8 @@ export async function autoConnect(deps: {
   getHub: () => Hub;
   allBlockChains: UseAdapterParams['allBlockChains'];
   wallets?: (WalletType | Provider)[];
-  onUpdateState?: EventHandler;
 }): Promise<void> {
-  const { getHub, allBlockChains, wallets, onUpdateState } = deps;
+  const { getHub, allBlockChains, wallets } = deps;
   const lastConnectedWallets = lastConnectedWalletsFromStorage.list();
   const walletIds = Object.keys(lastConnectedWallets);
 
@@ -247,7 +235,6 @@ export async function autoConnect(deps: {
         eagerConnect(providerName, successNamespaces, {
           allBlockChains,
           getHub,
-          onUpdateState,
         }).catch((error) => console.warn(error))
       );
     });

package/src/hub/helpers.ts

@@ -1,9 +1,7 @@
 import type { AllProxiedNamespaces } from './types.js';
-import type { NamespaceConnectAttempt } from '../errors.js';
-import type { NamespaceInputForConnect } from '../legacy/types.js';
 import type { ProviderProps } from '../types.js';
 import type { Accounts, AccountsWithActiveChain } from '@hub3js/std/types';
-import type { Option, Result } from 'ts-results';
+import type { Result } from 'ts-results';
 
 import {
   CAIP_BITCOIN_CHAIN_ID,
@@ -16,9 +14,7 @@ import { CAIP_NAMESPACE as CAIP_TON_NAMESPACE } from '@hub3js/tvm';
 import { formatAddressWithNetwork } from '@rango-dev/internal-blockchains';
 import { CAIP_TRON_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/tron';
 import { AccountId, type ChainIdParams } from 'caip';
-import { Err, None, Ok, Some } from 'ts-results';
-
-import { buildConnectionAttemptError } from '../errors.js';
+import { Err, Ok } from 'ts-results';
 
 export function mapCaipNamespaceToLegacyNetworkName(
   chainId: ChainIdParams | string
@@ -73,23 +69,9 @@ export function fromAccountIdToLegacyAddressFormat(account: string): string {
 }
 
 /**
- * Runs a list of (lazy) promises one after another and returns their results in
- * order. The first failure rejects, and the promises after it don't run.
+ * Getting a list of (lazy) promises and run them one after another.
  */
-export async function runSequentially<R>(
-  promises: Array<() => Promise<R>>
-): Promise<R[]> {
-  const results: R[] = [];
-  for (const task of promises) {
-    results.push(await task());
-  }
-  return results;
-}
 
-/**
- * Runs a list of (lazy) promises one after another, even when one fails, and returns
- * each one's outcome in order as a `Result`.
- */
 export async function runSequentiallyWithoutFailure<R>(
   promises: Array<() => Promise<R>>
 ): Promise<Result<R, unknown>[]> {
@@ -116,18 +98,9 @@ export function isConnectResultSolana(
   return Array.isArray(result);
 }
 
-export type QueueTaskResult<T> = {
-  result: Result<T, unknown>;
-  /*
-   * The task never ran: the queue abandoned it after an earlier task with the same key
-   * failed. `result` then holds that earlier failure.
-   */
-  cancelled: boolean;
-};
-
 type QueueItem<T> = {
   task: () => Promise<T>;
-  resolve: (value: QueueTaskResult<T>) => void;
+  resolve: (value: Result<T, unknown>) => void;
   key: string;
 };
 /**
@@ -141,22 +114,22 @@ export function createQueue(options?: {
   onError?: (
     error: unknown,
     actions: {
-      cancelWaitingItems: () => void;
+      removeCurrentKeyFromQueue: () => void;
     }
   ) => void;
 }) {
   const processingKeys = new Set<string>();
   let queue: QueueItem<unknown>[] = [];
 
-  const cancelWaitingItems = (
-    currentItem: QueueItem<unknown>,
-    error: unknown
+  const removeKeyFromQueue = (
+    key: string,
+    result: Result<unknown, unknown>
   ) => {
     queue = queue.filter((q) => {
-      if (q === currentItem || q.key !== currentItem.key) {
+      if (q.key !== key) {
         return true;
       }
-      q.resolve({ result: new Err(error), cancelled: true });
+      q.resolve(result);
       return false;
     });
   };
@@ -172,15 +145,16 @@ export function createQueue(options?: {
 
     try {
       const result = await task();
-      resolve({ result: new Ok(result), cancelled: false });
+      resolve(new Ok(result));
     } catch (error) {
       if (options?.onError) {
         options.onError(error, {
-          cancelWaitingItems: () => cancelWaitingItems(currentItem, error),
+          removeCurrentKeyFromQueue: () =>
+            removeKeyFromQueue(key, new Err(error)),
         });
       }
 
-      resolve({ result: new Err(error), cancelled: false });
+      resolve(new Err(error));
     } finally {
       const indexOfCurrentItem = queue.findIndex((item) => item.key === key);
       if (indexOfCurrentItem >= 0) {
@@ -194,11 +168,11 @@ export function createQueue(options?: {
   const queueTask = async <T>(
     task: () => Promise<T>,
     key: string
-  ): Promise<QueueTaskResult<T>> =>
+  ): Promise<Result<T, unknown>> =>
     new Promise((resolve) => {
       queue.push({
         task,
-        resolve: resolve as (value: QueueTaskResult<unknown>) => void,
+        resolve: resolve as (value: Result<unknown, unknown>) => void,
         key,
       });
       void processQueue();
@@ -207,44 +181,6 @@ export function createQueue(options?: {
   return queueTask;
 }
 
-/**
- * Runs one `connect` attempt for the requested namespaces. `connectNamespaces` passes
- * each namespace's attempt to `reportAttempts` once they have all settled. Anything it
- * throws, such as a config error or saving to storage failing, is added after the
- * namespace failures, unchanged.
- *
- * Throws a `WalletConnectionAttemptError` if anything failed; otherwise returns each
- * namespace's result in request order.
- */
-export async function runConnectionAttempt<T>(
-  namespaces: NamespaceInputForConnect[] | undefined,
-  connectNamespaces: (
-    reportAttempts: (attempts: NamespaceConnectAttempt<T>[]) => void
-  ) => Promise<void>
-): Promise<T[]> {
-  let attempts: NamespaceConnectAttempt<T>[] = [];
-  let nonNamespaceError: Option<unknown> = None;
-
-  try {
-    await connectNamespaces((settledAttempts) => {
-      attempts = settledAttempts;
-    });
-  } catch (error) {
-    nonNamespaceError = new Some(error);
-  }
-
-  const attemptError = buildConnectionAttemptError({
-    requestedNamespaces: namespaces ?? [],
-    attempts,
-    nonNamespaceError,
-  });
-  if (attemptError) {
-    throw attemptError;
-  }
-
-  return attempts.map(({ result }) => result.unwrap());
-}
-
 export function shouldTryAutoConnect(
   props: Pick<ProviderProps, 'allBlockChains' | 'autoConnect'>
 ): boolean {

package/src/hub/useHubAdapter.ts

@@ -1,5 +1,4 @@
 import type { AllProxiedNamespaces, ExtensionLink } from './types.js';
-import type { NamespaceConnectAttempt } from '../errors.js';
 import type {
   ConnectResult,
   NamespaceInputForConnect,
@@ -9,22 +8,19 @@ import type { ProviderContext, ProviderProps } from '../types.js';
 import type { Provider, WalletType } from '@hub3js/core';
 import type { Accounts, AccountsWithActiveChain } from '@hub3js/std/types';
 
-import { isUserRejectionError } from '@hub3js/std/utils';
+import { isUserRejectionError, WalletConnectionError } from '@hub3js/std/utils';
 import {
   getSupportedChainsFromNamespace,
   getSupportedChainsFromProvider,
 } from '@rango-dev/internal-blockchains';
 import { useEffect, useRef, useState } from 'react';
+import { Ok, Result } from 'ts-results';
 
 import { withErrorLoggingApi } from '../helpers.js';
 
 import { autoConnect } from './autoConnect.js';
 import { HUB_LAST_CONNECTED_WALLETS } from './constants.js';
-import {
-  createQueue,
-  fromAccountIdToLegacyAddressFormat,
-  runConnectionAttempt,
-} from './helpers.js';
+import { createQueue, fromAccountIdToLegacyAddressFormat } from './helpers.js';
 import { LastConnectedWalletsFromStorage } from './lastConnectedWallets.js';
 import { useAutoConnect } from './useAutoConnect.js';
 import { useHubRefs } from './useHubRefs.js';
@@ -69,8 +65,11 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
 
   const queueTask = createQueue({
     onError: (error, actions) => {
-      if (isUserRejectionError(error)) {
-        actions.cancelWaitingItems();
+      // A connection failure carries the wallet's own error, and so its code, as its cause.
+      const walletError =
+        error instanceof WalletConnectionError ? error.cause : error;
+      if (isUserRejectionError(walletError)) {
+        actions.removeCurrentKeyFromQueue();
       }
     },
   });
@@ -124,7 +123,6 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
         allBlockChains: params.allBlockChains,
         getHub,
         wallets: params.configs?.wallets,
-        onUpdateState: params.onUpdateState,
       });
     },
   });
@@ -188,117 +186,121 @@ export function useHubAdapter(params: UseAdapterParams): ProviderContext {
       });
     },
     async connect(type, namespaces) {
-      const connectNamespaces = async (
-        reportAttempts: (
-          attempts: NamespaceConnectAttempt<ConnectResult>[]
-        ) => void
-      ) => {
-        const wallet = getHub().get(type);
-        if (!wallet) {
+      const wallet = getHub().get(type);
+      if (!wallet) {
+        throw new Error(
+          `You should add ${type} to provider first then call 'connect'.`
+        );
+      }
+
+      if (!namespaces) {
+        throw new Error('Passing namespace to `connect` is required.');
+      }
+
+      updateLastConnectAttemptParams(type, namespaces);
+
+      // Check `namespace` and look into hub to see how it can match given namespace to hub namespace.
+      const targetNamespaces: [
+        NamespaceInputForConnect,
+        AllProxiedNamespaces
+      ][] = [];
+      namespaces.forEach((namespace) => {
+        const targetNamespace = namespace.namespace;
+
+        const result = wallet.findByNamespace(targetNamespace);
+        if (!result) {
           throw new Error(
-            `You should add ${type} to provider first then call 'connect'.`
+            `We couldn't find any provider matched with your request namespace. (requested namespace: ${namespace.namespace})`
           );
         }
 
-        if (!namespaces) {
-          throw new Error('Passing namespace to `connect` is required.');
-        }
+        targetNamespaces.push([namespace, result]);
+      });
 
-        updateLastConnectAttemptParams(type, namespaces);
+      // Try to run `connect` on matched namespaces
+      const connectResultFromTargetNamespaces = targetNamespaces.map(
+        async ([namespaceInput, namespace]) => {
+          const network = tryConvertNamespaceNetworkToChainInfo(
+            namespaceInput,
+            params.allBlockChains || []
+          );
 
-        // Check `namespace` and look into hub to see how it can match given namespace to hub namespace.
-        const targetNamespaces: [
-          NamespaceInputForConnect,
-          AllProxiedNamespaces
-        ][] = [];
-        namespaces.forEach((namespace) => {
-          const targetNamespace = namespace.namespace;
+          let connectNamespacePromise: () => Promise<
+            Accounts | AccountsWithActiveChain
+          >;
 
-          const result = wallet.findByNamespace(targetNamespace);
-          if (!result) {
-            throw new Error(
-              `We couldn't find any provider matched with your request namespace. (requested namespace: ${namespace.namespace})`
-            );
+          if (isSolanaNamespace(namespace)) {
+            connectNamespacePromise = async () =>
+              namespace.connect({
+                derivationPath: namespaceInput.derivationPath,
+              });
+          } else if (isEvmNamespace(namespace)) {
+            connectNamespacePromise = async () =>
+              namespace.connect(network, {
+                derivationPath: namespaceInput.derivationPath,
+              });
+          } else if (isUtxoNamespace(namespace)) {
+            connectNamespacePromise = async () =>
+              namespace.connect({
+                derivationPath: namespaceInput.derivationPath,
+              });
+          } else {
+            connectNamespacePromise = async () => namespace.connect();
           }
 
-          targetNamespaces.push([namespace, result]);
-        });
+          const connectNamespaceProcess = async () =>
+            connectNamespacePromise()
+              .then<ConnectResult>(transformHubResultToLegacyResult)
+              .then((connectResult) => {
+                return {
+                  response: connectResult,
+                  input: {
+                    namespace: namespaceInput.namespace,
+                    network: namespaceInput.network,
+                    supportsEagerConnect: 'canEagerConnect' in namespace,
+                  },
+                };
+              });
+          return queueTask(connectNamespaceProcess, type);
+        }
+      );
 
-        // Try to run `connect` on matched namespaces
-        const connectAttemptsFromTargetNamespaces = targetNamespaces.map(
-          async ([namespaceInput, namespace]) => {
-            const network = tryConvertNamespaceNetworkToChainInfo(
-              namespaceInput,
-              params.allBlockChains || []
-            );
+      /*
+       * We need to connect to namespace one after another, sending multiple requests at the same time may be failed.
+       * e.g. when wallet popup opens and asking for the password from the user, it should be resolved first, then other request will be resolved.
+       */
+      const connectResultWithLegacyFormat = await Promise.all(
+        connectResultFromTargetNamespaces
+      );
 
-            let connectNamespacePromise: () => Promise<
-              Accounts | AccountsWithActiveChain
-            >;
-
-            if (isSolanaNamespace(namespace)) {
-              connectNamespacePromise = async () =>
-                namespace.connect({
-                  derivationPath: namespaceInput.derivationPath,
-                });
-            } else if (isEvmNamespace(namespace)) {
-              connectNamespacePromise = async () =>
-                namespace.connect(network, {
-                  derivationPath: namespaceInput.derivationPath,
-                });
-            } else if (isUtxoNamespace(namespace)) {
-              connectNamespacePromise = async () =>
-                namespace.connect({
-                  derivationPath: namespaceInput.derivationPath,
-                });
-            } else {
-              connectNamespacePromise = async () => namespace.connect();
-            }
-
-            const connectNamespaceProcess = async () =>
-              connectNamespacePromise().then<ConnectResult>(
-                transformHubResultToLegacyResult
-              );
-            const { result, cancelled } = await queueTask(
-              connectNamespaceProcess,
-              type
-            );
-            return {
-              input: namespaceInput,
-              result,
-              cancelled,
-              supportsEagerConnect: 'canEagerConnect' in namespace,
-            };
-          }
+      // Keeping only namespaces that connected successfully and support eager connect, then we'll store them on storage for auto connect functionality.
+      const successfullyConnectedSupportingEagerConnectNamespaces =
+        connectResultWithLegacyFormat
+          .filter(<T, E>(result: Result<T, E>): result is Ok<T> => result.ok)
+          .filter((result) => result.val.input.supportsEagerConnect)
+          .map((result) => ({
+            namespace: result.val.input.namespace,
+            network: result.val.input.network,
+          }));
+
+      if (successfullyConnectedSupportingEagerConnectNamespaces.length > 0) {
+        lastConnectedWalletsFromStorage.addWallet(
+          type,
+          successfullyConnectedSupportingEagerConnectNamespaces
         );
+      }
 
-        /*
-         * We need to connect to namespace one after another, sending multiple requests at the same time may be failed.
-         * e.g. when wallet popup opens and asking for the password from the user, it should be resolved first, then other request will be resolved.
-         */
-        const attempts = await Promise.all(connectAttemptsFromTargetNamespaces);
-        reportAttempts(attempts);
-
-        // Keeping only namespaces that connected successfully and support eager connect, then we'll store them on storage for auto connect functionality.
-        const successfullyConnectedSupportingEagerConnectNamespaces = attempts
-          .filter(
-            ({ result, supportsEagerConnect }) =>
-              result.ok && supportsEagerConnect
-          )
-          .map(({ input }) => ({
-            namespace: input.namespace,
-            network: input.network,
-          }));
+      // Getting rid of `input` from Result
+      const connectResults = connectResultWithLegacyFormat.map((result) =>
+        result.andThen((okResult) => new Ok(okResult.response))
+      );
 
-        if (successfullyConnectedSupportingEagerConnectNamespaces.length > 0) {
-          lastConnectedWalletsFromStorage.addWallet(
-            type,
-            successfullyConnectedSupportingEagerConnectNamespaces
-          );
-        }
-      };
+      const allResult = Result.all(...connectResults);
+      if (allResult.err) {
+        throw allResult.val;
+      }
 
-      return runConnectionAttempt(namespaces, connectNamespaces);
+      return allResult.unwrap();
     },
     async disconnect(type, namespaces) {
       const wallet = getHub().get(type);

package/src/hub/utils.ts

@@ -1,10 +1,8 @@
 import type { AllProxiedNamespaces } from './types.js';
 import type {
   ConnectResult,
-  EventInfo,
   NamespaceInputForConnect,
   EventHandler as WalletEventHandler,
-  WalletState,
 } from '../legacy/mod.js';
 import type { ProviderProps } from '../types.js';
 import type { UtxoActions } from '@hub3js/bip122';
@@ -55,38 +53,6 @@ export function findProviderByType(
   return providers.find((provider) => provider.id === type);
 }
 
-// The legacy wallet state sent with an event, before any namespace-specific fields.
-export function getProviderCoreState(provider: Provider): WalletState {
-  const [getProviderState] = provider.state();
-  return {
-    connected: getProviderState().connected,
-    connecting: getProviderState().connecting,
-    installed: getProviderState().installed,
-    accounts: null,
-    network: null,
-    reachable: true,
-  };
-}
-
-// The legacy event info sent with an event, before any namespace-specific fields.
-export function getProviderEventInfo(
-  provider: Provider,
-  allBlockChains: ProviderProps['allBlockChains']
-): EventInfo {
-  const detailsProperty = provider
-    .info()
-    ?.metadata.properties?.find((property) => property.name === 'details');
-
-  return {
-    supportedBlockchains: getSupportedChainsFromProvider(
-      provider,
-      allBlockChains
-    ),
-    isContractWallet: detailsProperty?.value?.isContractWallet ?? false,
-    isHub: true,
-  };
-}
-
 /**
  * We will call this function on hub's `subscribe`.
  * it will check states and will emit legacy events for backward compatibility.
@@ -139,15 +105,28 @@ export function mapHubEventsToLegacy(
     }
   }
 
+  const [getProviderState] = provider.state();
   const coreState = {
-    ...getProviderCoreState(provider),
+    connected: getProviderState().connected,
+    connecting: getProviderState().connecting,
+    installed: getProviderState().installed,
     accounts,
     network,
+    reachable: true,
     derivationPath,
   };
 
+  const detailsProperty = provider
+    .info()
+    ?.metadata.properties?.find((property) => property.name === 'details');
+
   const eventInfo = {
-    ...getProviderEventInfo(provider, metadata.allBlockChains),
+    supportedBlockchains: getSupportedChainsFromProvider(
+      provider,
+      metadata.allBlockChains
+    ),
+    isContractWallet: detailsProperty?.value?.isContractWallet ?? false,
+    isHub: true,
     namespace: namespaceId,
   };
 

package/src/index.ts

@@ -1,8 +1,4 @@
 export { default as Provider } from './provider.js';
 export { useWallets } from './hooks.js';
-export {
-  AutoConnectionAttemptError,
-  WalletConnectionAttemptError,
-} from './errors.js';
 export type * from './types.js';
 export * from './legacy/types.js';

package/src/legacy/types.ts

@@ -78,11 +78,6 @@ export enum Events {
   NAMESPACE_DISCONNECTED = 'namespace_disconnected',
 
   PROVIDER_DISCONNECTED = 'provider_disconnected',
-  /**
-   * Internal: auto-connect couldn't connect one or more namespaces of a wallet.
-   * The value is an `AutoConnectionAttemptError`.
-   */
-  AUTO_CONNECT_FAILED = 'auto_connect_failed',
 }
 
 export type EventInfo = {