@rango-dev/wallets-core 0.40.0 → 0.40.1-next.1

package/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;

package/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';

package/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;

package/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;
+}

package/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,

package/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';

package/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';

package/src/namespaces/cosmos/types.ts

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

package/src/namespaces/evm/actions.ts

@@ -95,3 +95,35 @@ export function changeAccountSubscriber(
     },
   ];
 }
+
+export function changeChainSubscriber(
+  instance: () => ProviderAPI
+): [Subscriber<EvmActions>, SubscriberCleanUp<EvmActions>] {
+  let eventCallback: EIP1193EventMap['chainChanged'];
+
+  return [
+    (context) => {
+      const evmInstance = instance();
+
+      if (!evmInstance) {
+        throw new Error(
+          'Trying to subscribe to your EVM wallet, but seems its instance is not available.'
+        );
+      }
+
+      const [, setState] = context.state();
+
+      eventCallback = async (chainId: string) => {
+        setState('network', chainId);
+      };
+      evmInstance.on('chainChanged', eventCallback);
+    },
+    () => {
+      const evmInstance = instance();
+
+      if (eventCallback && evmInstance) {
+        evmInstance.removeListener('chainChanged', eventCallback);
+      }
+    },
+  ];
+}

package/src/utils/versions.ts

@@ -1,22 +1,21 @@
 import type { Provider } from '../hub/mod.js';
 import type { LegacyProviderInterface } from '../legacy/mod.js';
 
-type VersionedVLegacy = ['0.0.0', LegacyProviderInterface];
-type VersionedV1 = ['1.0.0', Provider];
-type AvailableVersions = VersionedVLegacy | VersionedV1;
-export type Versions = AvailableVersions[];
-// eslint-disable-next-line @typescript-eslint/no-magic-numbers
-export type VersionInterface<T extends AvailableVersions[]> = T[1];
+type LegacyVersioned = ['0.0.0', LegacyProviderInterface];
+type HubVersioned = ['1.0.0', Provider];
+type AvailableVersionedProviders = LegacyVersioned | HubVersioned;
+export type VersionedProviders = AvailableVersionedProviders[];
+export type VersionInterface<T extends AvailableVersionedProviders[]> = T[1];
 
 type SemVer<T extends [string, any]> = T extends [infer U, any] ? U : never;
-type MatchVersion<T extends Versions, Version> = Extract<
+type MatchVersion<T extends VersionedProviders, Version> = Extract<
   T[number],
   [Version, any]
 >;
 
 export function pickVersion<
-  L extends Versions,
-  V extends SemVer<Versions[number]>
+  L extends VersionedProviders,
+  V extends SemVer<VersionedProviders[number]>
 >(list: L, targetVersion: V): MatchVersion<L, V> {
   if (!targetVersion) {
     throw new Error(`You should provide a valid semver, e.g 1.0.0.`);
@@ -35,15 +34,15 @@ export function pickVersion<
 }
 
 interface DefineVersionsApi {
-  version: <T extends SemVer<Versions[number]>>(
+  version: <T extends SemVer<VersionedProviders[number]>>(
     semver: T,
-    value: VersionInterface<MatchVersion<Versions, T>>
+    value: VersionInterface<MatchVersion<VersionedProviders, T>>
   ) => DefineVersionsApi;
-  build: () => Versions;
+  build: () => VersionedProviders;
 }
 
 export function defineVersions(): DefineVersionsApi {
-  const versions: Versions = [];
+  const versions: VersionedProviders = [];
   const api: DefineVersionsApi = {
     version: (semver, value) => {
       versions.push([semver, value]);
@@ -58,6 +57,6 @@ export function defineVersions(): DefineVersionsApi {
 
 export function legacyProviderImportsToVersionsInterface(
   provider: LegacyProviderInterface
-): Versions {
+): VersionedProviders {
   return defineVersions().version('0.0.0', provider).build();
 }