feat: hub adapter and refactor wallets store

queue-manager/rango-preset/src/shared.ts

@@ -37,7 +37,6 @@ export type WalletBalance = {
 };
 
 export type Account = {
-  balances: WalletBalance[] | null;
   address: string;
   loading: boolean;
   walletType: WalletType;

queue-manager/rango-preset/src/types.ts

@@ -71,12 +71,8 @@ export interface SwapQueueContext extends QueueContext {
   switchNetwork: (
     wallet: WalletType,
     network: Network
-  ) => Promise<ConnectResult | undefined> | undefined;
+  ) => Promise<ConnectResult | ConnectResult[] | undefined> | undefined;
   canSwitchNetworkTo: (type: WalletType, network: Network) => boolean;
-  connect: (
-    wallet: WalletType,
-    network: Network
-  ) => Promise<ConnectResult> | undefined;
   state: (type: WalletType) => WalletState;
   isMobileWallet: (type: WalletType) => boolean;
 

wallets/core/src/hub/mod.ts

@@ -1,5 +1,8 @@
 export { Namespace } from './namespaces/mod.js';
+
 export { Provider } from './provider/mod.js';
+export type { CommonNamespaces, CommonNamespaceKeys } from './provider/mod.js';
+
 export { Hub } from './hub.js';
 export type { Store, State, ProviderInfo } from './store/mod.js';
 export {

wallets/core/src/hub/namespaces/namespace.ts

@@ -406,7 +406,10 @@ class Namespace<T extends Actions<T>> {
           return orAction(context, prev);
         }, actionError);
       } catch (orError) {
-        throw new Error(OR_ELSE_ACTION_FAILED_ERROR(actionName.toString()), {
+        const errorMessage = OR_ELSE_ACTION_FAILED_ERROR(
+          `${actionName.toString()} for ${this.namespaceId} namespace.`
+        );
+        throw new Error(errorMessage, {
           cause: actionError,
         });
       }

wallets/core/src/hub/provider/mod.ts

@@ -1,6 +1,7 @@
 export type {
   ExtendableInternalActions,
   CommonNamespaces,
+  CommonNamespaceKeys,
   State,
   Context,
   ProviderBuilderOptions,

wallets/core/src/hub/provider/types.ts

@@ -1,9 +1,11 @@
+import type { FindProxiedNamespace } from '../../builders/mod.js';
+import type { Store } from '../../hub/mod.js';
 import type { LegacyState } from '../../legacy/mod.js';
-import type { NamespaceInterface, Store } from '../../mod.js';
 import type { CosmosActions } from '../../namespaces/cosmos/mod.js';
 import type { EvmActions } from '../../namespaces/evm/mod.js';
 import type { SolanaActions } from '../../namespaces/solana/mod.js';
 import type { AnyFunction, FunctionWithContext } from '../../types/actions.js';
+import type { Prettify } from '../../types/utils.js';
 
 export type Context = {
   state: () => [GetState, SetState];
@@ -25,13 +27,15 @@ export interface CommonNamespaces {
   cosmos: CosmosActions;
 }
 
+export type CommonNamespaceKeys = Prettify<keyof CommonNamespaces>;
+
 export interface ExtendableInternalActions {
   init?: FunctionWithContext<AnyFunction, Context>;
 }
 
 export type RegisteredNamespaces<K extends keyof T, T> = Map<
   K,
-  NamespaceInterface<K, T>
+  FindProxiedNamespace<K, T>
 >;
 
 export type ProviderBuilderOptions = { store?: Store };

wallets/core/src/hub/store/providers.ts

@@ -1,20 +1,14 @@
-import type {
-  CommonNamespaces,
-  State as InternalProviderState,
-} from '../provider/mod.js';
+import type { State as InternalProviderState } from '../provider/mod.js';
+import type { CommonNamespaceKeys } from '../provider/types.js';
 import type { StateCreator } from 'zustand';
 
 import { produce } from 'immer';
 
 import { guessProviderStateSelector, type State } from './mod.js';
 
-type NamespaceName =
-  | keyof CommonNamespaces
-  | Omit<string, keyof CommonNamespaces>;
-
 type Browsers = 'firefox' | 'chrome' | 'edge' | 'brave' | 'homepage';
 type Property<N extends string, V> = { name: N; value: V };
-type DetachedInstances = Property<'detached', NamespaceName[]>;
+type DetachedInstances = Property<'detached', CommonNamespaceKeys[]>;
 
 export type ProviderInfo = {
   name: string;

wallets/core/src/legacy/mod.ts

@@ -23,6 +23,8 @@ export type {
   InstallObjects as LegacyInstallObjects,
   WalletInfo as LegacyWalletInfo,
   ConnectResult as LegacyConnectResult,
+  NamespaceInputForConnect as LegacyNamespaceInputForConnect,
+  NamespaceInputWithDiscoverMode as LegacyNamespaceInputWithDiscoverMode,
 } from './types.js';
 
 export {
@@ -35,5 +37,12 @@ export { Persistor } from './persistor.js';
 export {
   readAccountAddress as legacyReadAccountAddress,
   getBlockChainNameFromId as legacyGetBlockChainNameFromId,
+  formatAddressWithNetwork as legacyFormatAddressWithNetwork,
 } from './helpers.js';
 export { default as LegacyWallet } from './wallet.js';
+
+export {
+  eagerConnectHandler as legacyEagerConnectHandler,
+  isNamespaceDiscoverMode as legacyIsNamespaceDiscoverMode,
+  isEvmNamespace as legacyIsEvmNamespace,
+} from './utils.js';

wallets/core/src/legacy/types.ts

@@ -93,6 +93,9 @@ export type WalletInfo = {
   name: string;
   img: string;
   installLink: InstallObjects | string;
+  /**
+   * @deprecated we don't use this value anymore.
+   */
   color: string;
   supportedChains: BlockchainMeta[];
   showOnMobile?: boolean;
@@ -202,6 +205,12 @@ export type CanEagerConnect = (options: {
   meta: BlockchainMeta[];
 }) => Promise<boolean>;
 
+export type EagerConnectResult<I = unknown> = {
+  accounts: string[] | null;
+  network: string | null;
+  provider: I | null;
+};
+
 export interface WalletActions {
   connect: Connect;
   getInstance: any;
@@ -235,3 +244,36 @@ export type WalletProviders = Map<
 >;
 
 export type ProviderInterface = { config: WalletConfig } & WalletActions;
+
+// it comes from wallets.ts and `connect`
+type NetworkTypeFromLegacyConnect = Network | undefined;
+
+export type NetworkTypeForNamespace<T extends NamespacesWithDiscoverMode> =
+  T extends 'DISCOVER_MODE'
+    ? string
+    : T extends Namespace
+    ? NetworkTypeFromLegacyConnect
+    : never;
+
+export type NamespacesWithDiscoverMode = Namespace | 'DISCOVER_MODE';
+
+export type NamespaceInputWithDiscoverMode = {
+  namespace: 'DISCOVER_MODE';
+  network: string;
+  derivationPath?: string;
+};
+
+export type NamespaceInputForConnect<T extends Namespace = Namespace> =
+  | {
+      /**
+       * By default, you should specify namespace (e.g. evm).
+       * For backward compatibility with legacy implementation, DISCOVER_MODE will try to map a list of known (and hardcoded) networks to a namespace.
+       */
+      namespace: T;
+      /**
+       * In some cases, we need to connect a specific network on a namespace. e.g. Polygon on EVM.
+       */
+      network: NetworkTypeForNamespace<T>;
+      derivationPath?: string;
+    }
+  | NamespaceInputWithDiscoverMode;

wallets/core/src/legacy/utils.ts

@@ -0,0 +1,31 @@
+import type {
+  NamespaceInputForConnect,
+  NamespaceInputWithDiscoverMode,
+} from './types.js';
+
+import { Namespace } from './types.js';
+
+export async function eagerConnectHandler<R = unknown>(params: {
+  canEagerConnect: () => Promise<boolean>;
+  connectHandler: () => Promise<R>;
+  providerName: string;
+}) {
+  // Check if we can eagerly connect to the wallet
+  if (await params.canEagerConnect()) {
+    // Connect to wallet as usual
+    return await params.connectHandler();
+  }
+  throw new Error(`can't restore connection for ${params.providerName}.`);
+}
+
+export function isNamespaceDiscoverMode(
+  namespace: NamespaceInputForConnect
+): namespace is NamespaceInputWithDiscoverMode {
+  return namespace.namespace === 'DISCOVER_MODE';
+}
+
+export function isEvmNamespace(
+  namespace: NamespaceInputForConnect
+): namespace is NamespaceInputForConnect<Namespace.Evm> {
+  return namespace.namespace === Namespace.Evm;
+}

wallets/core/src/legacy/wallet.ts

@@ -1,4 +1,5 @@
 import type {
+  EagerConnectResult,
   GetInstanceOptions,
   NamespaceData,
   Network,
@@ -14,6 +15,7 @@ import {
   needsCheckInstallation,
 } from './helpers.js';
 import { Events, Networks } from './types.js';
+import { eagerConnectHandler } from './utils.js';
 
 export type EventHandler = (
   type: WalletType,
@@ -26,11 +28,16 @@ export type EventHandler = (
 export type EventInfo = {
   supportedBlockchains: BlockchainMeta[];
   isContractWallet: boolean;
+  // This is for Hub and be able to make it compatible with legacy behavior.
+  isHub: boolean;
 };
 
 export interface State {
   connected: boolean;
   connecting: boolean;
+  /**
+   * @depreacted it always returns `false`. don't use it.
+   */
   reachable: boolean;
   installed: boolean;
   accounts: string[] | null;
@@ -57,6 +64,7 @@ class Wallet<InstanceType = any> {
     this.info = {
       supportedBlockchains: [],
       isContractWallet: false,
+      isHub: false,
     };
     this.state = {
       connected: false,
@@ -264,26 +272,30 @@ class Wallet<InstanceType = any> {
   }
 
   // This method is only used for auto connection
-  async eagerConnect() {
+  async eagerConnect(): Promise<EagerConnectResult<InstanceType>> {
     const instance = await this.tryGetInstance({ network: undefined });
     const { canEagerConnect } = this.actions;
-    const error_message = `can't restore connection for ${this.options.config.type} .`;
+    const providerName = this.options.config.type;
 
-    if (canEagerConnect) {
-      // Check if we can eagerly connect to the wallet
-      const eagerConnection = await canEagerConnect({
-        instance: instance,
-        meta: this.info.supportedBlockchains,
-      });
+    return await eagerConnectHandler({
+      canEagerConnect: async () => {
+        if (!canEagerConnect) {
+          throw new Error(
+            `${providerName} provider hasn't implemented canEagerConnect.`
+          );
+        }
 
-      if (eagerConnection) {
-        // Connect to wallet as usual
-        return this.connect();
-      }
-      throw new Error(error_message);
-    } else {
-      throw new Error(error_message);
-    }
+        return await canEagerConnect({
+          instance: instance,
+          meta: this.info.supportedBlockchains,
+        });
+      },
+      connectHandler: async () => {
+        const result = await this.connect();
+        return result;
+      },
+      providerName,
+    });
   }
 
   async getSigners(provider: any) {
@@ -408,6 +420,7 @@ class Wallet<InstanceType = any> {
       const eventInfo: EventInfo = {
         supportedBlockchains: this.info.supportedBlockchains,
         isContractWallet: this.info.isContractWallet,
+        isHub: false,
       };
       this.options.handler(
         this.options.config.type,

wallets/core/src/mod.ts

@@ -1,4 +1,10 @@
-export type { Store, State, ProviderInfo } from './hub/mod.js';
+export type {
+  Store,
+  State,
+  ProviderInfo,
+  CommonNamespaces,
+  CommonNamespaceKeys,
+} from './hub/mod.js';
 export {
   Hub,
   Provider,
@@ -7,10 +13,8 @@ export {
   guessProviderStateSelector,
   namespaceStateSelector,
 } from './hub/mod.js';
-export type {
-  ProxiedNamespace,
-  FindProxiedNamespace as NamespaceInterface,
-} from './builders/mod.js';
+
+export type { ProxiedNamespace, FindProxiedNamespace } from './builders/mod.js';
 export {
   NamespaceBuilder,
   ProviderBuilder,
@@ -31,5 +35,5 @@ export {
  * To make it work for Parcel, we should go with second mentioned option.
  *
  */
-export type { Versions } from './utils/mod.js';
+export type { VersionedProviders } from './utils/mod.js';
 export { defineVersions, pickVersion } from './utils/mod.js';

wallets/core/src/namespaces/common/mod.ts

@@ -10,3 +10,9 @@ export {
   recommended as andRecommended,
 } from './and.js';
 export { intoConnecting, recommended as beforeRecommended } from './before.js';
+
+export type {
+  CaipAccount,
+  Accounts,
+  AccountsWithActiveChain,
+} from '../../types/accounts.js';

wallets/core/src/namespaces/cosmos/types.ts

@@ -7,4 +7,5 @@ export interface CosmosActions
   extends AutoImplementedActionsByRecommended,
     CommonActions {
   // TODO
+  connect: () => Promise<string>;
 }