@rango-dev/wallets-react 0.0.0-experimental-936229e8-20251208

package/src/hub/utils.ts

@@ -0,0 +1,393 @@
+import type { AllProxiedNamespaces } from './types.js';
+import type { Hub, Provider, ProxiedNamespace } from '@rango-dev/wallets-core';
+import type {
+  LegacyNamespaceInputForConnect,
+  LegacyProviderInterface,
+  LegacyEventHandler as WalletEventHandler,
+} from '@rango-dev/wallets-core/legacy';
+import type { CosmosActions } from '@rango-dev/wallets-core/namespaces/cosmos';
+import type { EvmActions } from '@rango-dev/wallets-core/namespaces/evm';
+import type { SolanaActions } from '@rango-dev/wallets-core/namespaces/solana';
+import type { SuiActions } from '@rango-dev/wallets-core/namespaces/sui';
+import type { UtxoActions } from '@rango-dev/wallets-core/namespaces/utxo';
+import type { Event } from '@rango-dev/wallets-core/store';
+
+import { LegacyEvents as Events } from '@rango-dev/wallets-core/legacy';
+import { type VersionedProviders } from '@rango-dev/wallets-core/utils';
+import { pickVersion } from '@rango-dev/wallets-core/utils';
+import {
+  type AddEthereumChainParameter,
+  convertEvmBlockchainMetaToEvmChainInfo,
+  type WalletType,
+} from '@rango-dev/wallets-shared';
+import { type BlockchainMeta, isEvmBlockchain } from 'rango-types';
+
+import {
+  type ConnectResult,
+  HUB_LAST_CONNECTED_WALLETS,
+  type ProviderProps,
+} from '../legacy/mod.js';
+
+import {
+  fromAccountIdToLegacyAddressFormat,
+  isConnectResultEvm,
+  isConnectResultSolana,
+} from './helpers.js';
+import { LastConnectedWalletsFromStorage } from './lastConnectedWallets.js';
+
+/* Gets a list of hub and legacy providers and returns a tuple which separates them. */
+export function separateLegacyAndHubProviders(
+  providers: VersionedProviders[]
+): [LegacyProviderInterface[], Provider[]] {
+  const LEGACY_VERSION = '0.0.0';
+  const HUB_VERSION = '1.0.0';
+
+  const legacyProviders: LegacyProviderInterface[] = [];
+  const hubProviders: Provider[] = [];
+
+  providers.forEach((provider) => {
+    try {
+      const target = pickVersion(provider, HUB_VERSION);
+      hubProviders.push(target[1]);
+    } catch {
+      const target = pickVersion(provider, LEGACY_VERSION);
+      legacyProviders.push(target[1]);
+    }
+  });
+
+  return [legacyProviders, hubProviders];
+}
+
+export function findProviderByType(
+  providers: Provider[],
+  type: string
+): Provider | undefined {
+  return providers.find((provider) => provider.id === type);
+}
+
+/**
+ * We will call this function on hub's `subscribe`.
+ * it will check states and will emit legacy events for backward compatibility.
+ */
+
+const lastConnectedWalletsFromStorage = new LastConnectedWalletsFromStorage(
+  HUB_LAST_CONNECTED_WALLETS
+);
+
+export function getSupportedChainsFromProvider(
+  provider: Provider,
+  allBlockChains: ProviderProps['allBlockChains']
+) {
+  const namespacesProperty = provider
+    .info()
+    ?.metadata.properties?.find((property) => property.name === 'namespaces');
+
+  const supportedChains =
+    namespacesProperty?.value.data.flatMap((namespace) =>
+      namespace.getSupportedChains(allBlockChains || [])
+    ) || [];
+
+  return supportedChains;
+}
+
+export function mapHubEventsToLegacy(
+  hub: Hub,
+  event: Event,
+  onUpdateState: WalletEventHandler,
+  metadata: {
+    allBlockChains: ProviderProps['allBlockChains'];
+    lastConnectAttemptParams: {
+      [type: WalletType]: LegacyNamespaceInputForConnect[];
+    };
+  }
+): void {
+  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,
+      }
+    );
+  }
+
+  // @ts-expect-error for those events that doesn't have namespace, it will be undefinded
+  const namespaceId: string | undefined = event.namespace;
+
+  const namespace = namespaceId
+    ? provider.findByNamespace(namespaceId)
+    : undefined;
+  let accounts: string[] | null = null;
+  let network: string | null = null;
+  let derivationPath: string | undefined;
+
+  if (namespace) {
+    const [getNamespaceState] = namespace.state();
+    accounts = getNamespaceState().accounts;
+    network = getNamespaceState().network;
+
+    if (metadata.lastConnectAttemptParams[event.provider]) {
+      derivationPath = metadata.lastConnectAttemptParams[event.provider].find(
+        (namespace) => namespace.namespace === namespaceId
+      )?.derivationPath;
+    }
+  }
+
+  const [getProviderState] = provider.state();
+  const coreState = {
+    connected: getProviderState().connected,
+    connecting: getProviderState().connecting,
+    installed: getProviderState().installed,
+    accounts,
+    network,
+    reachable: true,
+    derivationPath,
+  };
+
+  const eventInfo = {
+    supportedBlockchains: getSupportedChainsFromProvider(
+      provider,
+      metadata.allBlockChains
+    ),
+    isContractWallet: false,
+    isHub: true,
+    namespace: namespaceId,
+  };
+
+  switch (event.type) {
+    case 'provider_detected':
+      onUpdateState(
+        event.provider,
+        Events.INSTALLED,
+        true,
+        coreState,
+        eventInfo
+      );
+      break;
+    case 'provider_connecting':
+      onUpdateState(
+        event.provider,
+        Events.CONNECTING,
+        event.value,
+        coreState,
+        eventInfo
+      );
+      break;
+    case 'provider_connected':
+      onUpdateState(
+        event.provider,
+        Events.CONNECTED,
+        true,
+        coreState,
+        eventInfo
+      );
+      break;
+    case 'provider_disconnected':
+      onUpdateState(
+        event.provider,
+        Events.PROVIDER_DISCONNECTED,
+        event.provider,
+        coreState,
+        eventInfo
+      );
+      onUpdateState(
+        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((accounts) =>
+          fromAccountIdToLegacyAddressFormat(
+            accounts,
+            metadata.allBlockChains || []
+          )
+        );
+        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(
+  allProviders: VersionedProviders[]
+): LegacyProviderInterface[] {
+  const LEGACY_VERSION = '0.0.0';
+
+  const legacyProviders: LegacyProviderInterface[] = [];
+
+  allProviders.forEach((provider) => {
+    const target = pickVersion(provider, LEGACY_VERSION);
+    legacyProviders.push(target[1]);
+  });
+
+  return legacyProviders;
+}
+
+/**
+ * In legacy mode, for those who have switch network functionality (like evm), we are using an enum for network names
+ * this enum only has meaning for us, and when we are going to connect an instance (e.g. window.ethereum) we should pass chain id.
+ */
+export function convertNamespaceNetworkToEvmChainId(
+  namespace: LegacyNamespaceInputForConnect,
+  meta: BlockchainMeta[]
+) {
+  if (!namespace.network) {
+    return undefined;
+  }
+
+  const evmBlockchainsList = meta.filter(isEvmBlockchain);
+  const evmChains = convertEvmBlockchainMetaToEvmChainInfo(evmBlockchainsList);
+
+  return evmChains[namespace.network];
+}
+
+/**
+ * We are passing an string for chain id (e.g. ETH, POLYGON), but wallet's instances (e.g. window.ethereum) needs chainId (e.g. 0x1).
+ * This function will help us to map these strings to proper hex ids.
+ *
+ * If you need same functionality for other blockchain types (e.g. Cosmos), You can make a separate function and add it here.
+ */
+export function tryConvertNamespaceNetworkToChainInfo(
+  namespace: LegacyNamespaceInputForConnect,
+  meta: BlockchainMeta[]
+): string | AddEthereumChainParameter | undefined {
+  // `undefined` means it's not evm or we couldn't find it in meta.
+  const evmChain = convertNamespaceNetworkToEvmChainId(namespace, meta);
+  const network = evmChain || namespace.network;
+
+  return network;
+}
+
+export function transformHubResultToLegacyResult(
+  res: Awaited<ReturnType<AllProxiedNamespaces['connect']>>
+): ConnectResult {
+  if (isConnectResultEvm(res)) {
+    return {
+      accounts: res.accounts,
+      network: res.network,
+      provider: undefined,
+    };
+  } else if (isConnectResultSolana(res)) {
+    return {
+      accounts: res,
+      network: null,
+      provider: undefined,
+    };
+  }
+
+  return {
+    accounts: [res],
+    network: null,
+    provider: undefined,
+  };
+}
+
+/**
+ * Synchronizes providers in the hub with the configuration providers.
+ * - Registers and initializes any configuration providers not yet in the hub
+ * - Removes providers from the hub that aren't in the configuration
+ */
+export function synchronizeHubWithConfigProviders(
+  hub: Hub,
+  configurationProviders: Provider[]
+) {
+  const registeredProviders = hub.getAll();
+
+  // Register and initialize providers that exist in config but not in hub
+  const providersToRegister = configurationProviders.filter(
+    (configProvider) => !registeredProviders.get(configProvider.id)
+  );
+
+  providersToRegister.forEach((providerToRegister) => {
+    hub.add(providerToRegister.id, providerToRegister);
+    providerToRegister.init();
+  });
+
+  // Remove providers that exist in hub but not in config
+  registeredProviders.forEach((registeredProvider) => {
+    const isProviderInConfig = configurationProviders.some(
+      (configProvider) => configProvider.id === registeredProvider.id
+    );
+
+    if (!isProviderInConfig) {
+      hub.remove(registeredProvider.id);
+    }
+  });
+}
+
+export function isSolanaNamespace(
+  ns: ProxiedNamespace<
+    EvmActions | SolanaActions | CosmosActions | SuiActions | UtxoActions
+  >
+): ns is ProxiedNamespace<SolanaActions> & { namespaceId: 'Solana' } {
+  return ns.namespaceId === 'Solana';
+}
+export function isEvmNamespace(
+  ns: ProxiedNamespace<
+    EvmActions | SolanaActions | CosmosActions | SuiActions | UtxoActions
+  >
+): ns is ProxiedNamespace<EvmActions> & { namespaceId: 'EVM' } {
+  return ns.namespaceId === 'EVM';
+}
+export function isCosmosNamespace(
+  ns: ProxiedNamespace<
+    EvmActions | SolanaActions | CosmosActions | SuiActions | UtxoActions
+  >
+): ns is ProxiedNamespace<CosmosActions> & { namespaceId: 'Cosmos' } {
+  return ns.namespaceId === 'Cosmos';
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './legacy/helpers.js';
+export { default as Provider } from './provider.js';
+export { useWallets } from './legacy/hooks.js';
+export * from './legacy/types.js';

package/src/legacy/autoConnect.ts

@@ -0,0 +1,66 @@
+import type { WalletActions, WalletProviders } from './types.js';
+import type { LegacyWallet as Wallet } from '@rango-dev/wallets-core/legacy';
+import type { WalletConfig, WalletType } from '@rango-dev/wallets-shared';
+
+import { LastConnectedWalletsFromStorage } from '../hub/lastConnectedWallets.js';
+
+import { LEGACY_LAST_CONNECTED_WALLETS } from './mod.js';
+
+/*
+ *If a wallet has multiple providers and one of them can be eagerly connected,
+ *then the whole wallet will support it at that point and we try to connect to that wallet as usual in eagerConnect method.
+ */
+export async function autoConnect(
+  wallets: WalletProviders,
+  getWalletInstance: (wallet: {
+    actions: WalletActions;
+    config: WalletConfig;
+  }) => Wallet<any>
+) {
+  const lastConnectedWalletsFromStorage = new LastConnectedWalletsFromStorage(
+    LEGACY_LAST_CONNECTED_WALLETS
+  );
+
+  const lastConnectedWallets = lastConnectedWalletsFromStorage.list();
+  const walletIds = Object.keys(lastConnectedWallets);
+
+  if (walletIds.length) {
+    const eagerConnectQueue: {
+      walletType: WalletType;
+      eagerConnect: () => Promise<any>;
+    }[] = [];
+
+    walletIds.forEach((walletType) => {
+      const wallet = wallets.get(walletType);
+
+      if (!!wallet) {
+        const walletInstance = getWalletInstance(wallet);
+        eagerConnectQueue.push({
+          walletType,
+          eagerConnect: walletInstance.eagerConnect.bind(walletInstance),
+        });
+      }
+    });
+
+    const result = await Promise.allSettled(
+      eagerConnectQueue.map(async ({ eagerConnect }) => eagerConnect())
+    );
+
+    const walletsToRemoveFromPersistance: WalletType[] = [];
+    result.forEach((settleResult, index) => {
+      const { status } = settleResult;
+
+      if (status === 'rejected') {
+        walletsToRemoveFromPersistance.push(
+          eagerConnectQueue[index].walletType
+        );
+      }
+    });
+
+    if (walletsToRemoveFromPersistance.length) {
+      lastConnectedWalletsFromStorage.removeWallets(
+        walletsToRemoveFromPersistance
+      );
+    }
+  }
+}

package/src/legacy/context.ts

@@ -0,0 +1,39 @@
+import type { ProviderContext } from './types.js';
+
+import { createContext } from 'react';
+
+const defaultErrorMessage = "Context hasn't been initialized yet.";
+const defaultContext: ProviderContext = {
+  async connect() {
+    throw new Error(defaultErrorMessage);
+  },
+  async disconnect() {
+    throw new Error(defaultErrorMessage);
+  },
+  async disconnectAll() {
+    throw new Error(defaultErrorMessage);
+  },
+  async suggestAndConnect() {
+    throw new Error(defaultErrorMessage);
+  },
+  state() {
+    throw new Error(defaultErrorMessage);
+  },
+  canSwitchNetworkTo() {
+    throw new Error(defaultErrorMessage);
+  },
+  providers() {
+    throw new Error(defaultErrorMessage);
+  },
+  getWalletInfo() {
+    throw new Error(defaultErrorMessage);
+  },
+  getSigners() {
+    throw new Error(defaultErrorMessage);
+  },
+  hubProvider() {
+    throw new Error(defaultErrorMessage);
+  },
+};
+
+export const WalletContext = createContext<ProviderContext>(defaultContext);

package/src/legacy/helpers.ts

@@ -0,0 +1,183 @@
+import type {
+  ProviderInterface,
+  State,
+  WalletActions,
+  WalletProviders,
+} from './types.js';
+import type {
+  LegacyOptions as Options,
+  LegacyEventHandler as WalletEventHandler,
+  LegacyState as WalletState,
+} from '@rango-dev/wallets-core/legacy';
+import type { WalletType } from '@rango-dev/wallets-shared';
+
+import { Persistor } from '@rango-dev/wallets-core/legacy';
+
+import { LEGACY_LAST_CONNECTED_WALLETS } from '../hub/constants.js';
+import { LastConnectedWalletsFromStorage } from '../hub/lastConnectedWallets.js';
+
+export function choose(wallets: any[], type: WalletType): any | null {
+  return wallets.find((wallet) => wallet.type === type) || null;
+}
+
+export const defaultWalletState: WalletState = {
+  connected: false,
+  connecting: false,
+  reachable: false,
+  installed: false,
+  accounts: null,
+  network: null,
+};
+
+export function stateReducer(state: State, action: any) {
+  if (action.type === 'new_state') {
+    // TODO fix problem and remove ts-ignore
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const target_wallet = state[action.wallet];
+    if (!target_wallet) {
+      return {
+        ...state,
+        [action.wallet]: {
+          ...defaultWalletState,
+          [action.name]: action.value,
+        },
+      };
+    }
+
+    return {
+      ...state,
+      [action.wallet]: {
+        ...target_wallet,
+        [action.name]: action.value,
+      },
+    };
+  }
+
+  return state;
+}
+
+export function connectedWallets(providersState: State): WalletType[] {
+  return Object.entries(providersState)
+    .filter(([, wallet_state]) => {
+      return wallet_state?.connected;
+    })
+    .map(([type]) => {
+      return type;
+    });
+}
+
+export function availableWallets(providersState: State): WalletType[] {
+  return Object.entries(providersState).map(([type]) => {
+    return type;
+  });
+}
+
+export function checkWalletProviders(
+  list: ProviderInterface[]
+): WalletProviders {
+  const wallets: WalletProviders = new Map();
+
+  list.forEach((provider) => {
+    const { config, ...actions } = provider;
+    wallets.set(config.type, {
+      actions,
+      config,
+    });
+  });
+
+  return wallets;
+}
+
+/* eslint-disable @typescript-eslint/ban-types */
+export function isAsync(fn: Function) {
+  return fn?.constructor?.name === 'AsyncFunction';
+}
+
+export function needsCheckInstallation(options: Options) {
+  const { checkInstallation = true } = options.config;
+  return checkInstallation;
+}
+
+export async function tryPersistWallet({
+  type,
+  walletActions,
+  getState,
+}: {
+  type: WalletType;
+  walletActions: WalletActions;
+  getState: (walletType: WalletType) => WalletState;
+}) {
+  if (walletActions.canEagerConnect) {
+    const lastConnectedWalletsFromStorage = new LastConnectedWalletsFromStorage(
+      LEGACY_LAST_CONNECTED_WALLETS
+    );
+    const lastConnectedWallets = lastConnectedWalletsFromStorage.list();
+    const walletAlreadyPersisted = !!lastConnectedWallets[type];
+
+    /*
+     *If on the last attempt we are unable to eagerly connect to any wallet and the user connects any wallet manualy,
+     *persistance will be outdated and will need to be removed.
+     */
+    if (walletAlreadyPersisted && !getState(type).connected) {
+      clearPersistance();
+    }
+
+    if (!walletAlreadyPersisted) {
+      lastConnectedWalletsFromStorage.addWallet(type, []);
+    }
+  }
+}
+
+export function tryRemoveWalletFromPersistance({
+  type,
+  walletActions,
+}: {
+  type: WalletType;
+  walletActions: WalletActions;
+}) {
+  if (walletActions.canEagerConnect) {
+    const lastConnectedWalletsFromStorage = new LastConnectedWalletsFromStorage(
+      LEGACY_LAST_CONNECTED_WALLETS
+    );
+    lastConnectedWalletsFromStorage.removeWallets([type]);
+  }
+}
+
+export function clearPersistance() {
+  const persistor = new Persistor<string[]>();
+  const wallets = persistor.getItem(LEGACY_LAST_CONNECTED_WALLETS);
+  if (wallets) {
+    persistor.removeItem(LEGACY_LAST_CONNECTED_WALLETS);
+  }
+}
+
+/*
+ *Our event handler includes an internal state updater, and a notifier
+ *for the outside listener.
+ *On creating first wallet refrence, and on chaning `props.onUpdateState`
+ *we are using this function.
+ */
+export function makeEventHandler(
+  dispatcher: any,
+  onUpdateState?: WalletEventHandler
+) {
+  const handler: WalletEventHandler = (
+    type,
+    name,
+    value,
+    coreState,
+    supportedChains
+  ) => {
+    const action = { type: 'new_state', wallet: type, name, value };
+    // Update state
+    dispatcher(action);
+
+    // Giving the event to the outside listener
+    if (onUpdateState) {
+      onUpdateState(type, name, value, coreState, supportedChains);
+    }
+  };
+
+  return handler;
+}