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

package/src/hub/helpers.ts

@@ -0,0 +1,179 @@
+import type { AllProxiedNamespaces } from './types.js';
+import type {
+  Accounts,
+  AccountsWithActiveChain,
+} from '@rango-dev/wallets-core/namespaces/common';
+import type { BlockchainMeta } from 'rango-types';
+import type { Result } from 'ts-results';
+
+import { legacyFormatAddressWithNetwork as formatAddressWithNetwork } from '@rango-dev/wallets-core/legacy';
+import { CAIP_NAMESPACE as CAIP_COSMOS_NAMESPACE } from '@rango-dev/wallets-core/namespaces/cosmos';
+import { CAIP_TRON_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/tron';
+import { CAIP_BITCOIN_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/utxo';
+import { CAIP } from '@rango-dev/wallets-core/utils';
+import { getBlockChainNameFromId } from '@rango-dev/wallets-shared';
+import { Err, Ok } from 'ts-results';
+
+export function mapCaipNamespaceToLegacyNetworkName(
+  chainId: CAIP.ChainIdParams | string,
+  allBlockChains: BlockchainMeta[]
+): string {
+  if (typeof chainId === 'string') {
+    return chainId;
+  }
+  const useNamespaceAsNetworkFor = ['solana'];
+
+  if (useNamespaceAsNetworkFor.includes(chainId.namespace.toLowerCase())) {
+    return chainId.namespace.toUpperCase();
+  }
+
+  if (chainId.namespace.toLowerCase() === 'eip155') {
+    return 'ETH';
+  } else if (chainId.reference === CAIP_BITCOIN_CHAIN_ID) {
+    return 'BTC';
+  }
+
+  if (chainId.namespace.toLowerCase() === CAIP_COSMOS_NAMESPACE) {
+    const network = getBlockChainNameFromId(chainId.reference, allBlockChains);
+    if (!network) {
+      throw new Error(
+        `Network didn't found for given chainId: ${chainId.reference}`
+      );
+    }
+    return network;
+  }
+  if (chainId.namespace === 'sui' || chainId.reference === CAIP_TRON_CHAIN_ID) {
+    return chainId.reference.toUpperCase();
+  }
+
+  return chainId.reference;
+}
+
+/**
+ * CAIP's accountId has a format like this: eip155:1:0xab16a96D359eC26a11e2C2b3d8f8B8942d5Bfcdb
+ * Legacy format is something like this: ETH:0xab16a96D359eC26a11e2C2b3d8f8B8942d5Bfcdb
+ * This function will try to convert this two format.
+ *
+ * @see https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md
+ */
+export function fromAccountIdToLegacyAddressFormat(
+  account: string,
+  allBlockChains: BlockchainMeta[]
+): string {
+  const { chainId, address } = CAIP.AccountId.parse(account);
+  const network = mapCaipNamespaceToLegacyNetworkName(chainId, allBlockChains);
+  return formatAddressWithNetwork(address, network);
+}
+
+/**
+ * Getting a list of (lazy) promises and run them one after another.
+ */
+
+export async function runSequentiallyWithoutFailure<R>(
+  promises: Array<() => Promise<R>>
+): Promise<Result<R, unknown>[]> {
+  return promises.reduce(async (prevPromise, task) => {
+    const previousResults = await prevPromise;
+    try {
+      const taskResult = await task();
+      return [...previousResults, new Ok(taskResult)];
+    } catch (error) {
+      return [...previousResults, new Err(error)];
+    }
+  }, Promise.resolve<Result<R, unknown>[]>([]));
+}
+
+export function isConnectResultEvm(
+  result: Awaited<ReturnType<AllProxiedNamespaces['connect']>>
+): result is AccountsWithActiveChain {
+  return typeof result === 'object' && !Array.isArray(result);
+}
+
+export function isConnectResultSolana(
+  result: Awaited<ReturnType<AllProxiedNamespaces['connect']>>
+): result is Accounts {
+  return Array.isArray(result);
+}
+
+type QueueItem<T> = {
+  task: () => Promise<T>;
+  resolve: (value: Result<T, unknown>) => void;
+  key: string;
+};
+/**
+ * Creates a queue manager that ensures sequential execution of tasks by key.
+ * When multiple tasks with the same key are queued, they are executed one at a time
+ * in the order they were added. This prevents race conditions and ensures
+ * predictable task execution order.
+ *
+ */
+export function createQueue(options?: {
+  onError?: (
+    error: unknown,
+    actions: {
+      removeCurrentKeyFromQueue: () => void;
+    }
+  ) => void;
+}) {
+  const processingKeys = new Set<string>();
+  let queue: QueueItem<unknown>[] = [];
+
+  const removeKeyFromQueue = (
+    key: string,
+    result: Result<unknown, unknown>
+  ) => {
+    queue = queue.filter((q) => {
+      if (q.key !== key) {
+        return true;
+      }
+      q.resolve(result);
+      return false;
+    });
+  };
+
+  const processQueue = async () => {
+    const currentItem = queue.find((item) => !processingKeys.has(item.key));
+    if (!currentItem) {
+      return;
+    }
+
+    const { task, resolve, key } = currentItem;
+    processingKeys.add(key);
+
+    try {
+      const result = await task();
+      resolve(new Ok(result));
+    } catch (error) {
+      if (options?.onError) {
+        options.onError(error, {
+          removeCurrentKeyFromQueue: () =>
+            removeKeyFromQueue(key, new Err(error)),
+        });
+      }
+
+      resolve(new Err(error));
+    } finally {
+      const indexOfCurrentItem = queue.findIndex((item) => item.key === key);
+      if (indexOfCurrentItem >= 0) {
+        queue.splice(indexOfCurrentItem, 1);
+      }
+      processingKeys.delete(key);
+      void processQueue();
+    }
+  };
+
+  const queueTask = async <T>(
+    task: () => Promise<T>,
+    key: string
+  ): Promise<Result<T, unknown>> =>
+    new Promise((resolve) => {
+      queue.push({
+        task,
+        resolve: resolve as (value: Result<unknown, unknown>) => void,
+        key,
+      });
+      void processQueue();
+    });
+
+  return queueTask;
+}

package/src/hub/lastConnectedWallets.ts

@@ -0,0 +1,166 @@
+import type { Namespace } from '@rango-dev/wallets-core/namespaces/common';
+
+import { Persistor } from '@rango-dev/wallets-core/legacy';
+
+import {
+  HUB_LAST_CONNECTED_WALLETS,
+  LEGACY_LAST_CONNECTED_WALLETS,
+} from './constants.js';
+
+export interface NamespaceInput {
+  namespace: Namespace;
+  network: string | undefined;
+}
+
+export interface LastConnectedWalletsStorage {
+  [providerId: string]: NamespaceInput[];
+}
+
+export type LegacyLastConnectedWalletsStorage = string[];
+
+/**
+ * We are doing some certain actions on storage for `last-connected-wallets` key.
+ * This class helps us to define them in one place and also it has support for both legacy and hub.
+ */
+export class LastConnectedWalletsFromStorage {
+  #storageKey: string;
+
+  constructor(storageKey: string) {
+    this.#storageKey = storageKey;
+  }
+
+  addWallet(providerId: string, namespaces: NamespaceInput[]): void {
+    if (this.#storageKey === HUB_LAST_CONNECTED_WALLETS) {
+      return this.#addWalletToHub(providerId, namespaces);
+    } else if (this.#storageKey === LEGACY_LAST_CONNECTED_WALLETS) {
+      return this.#addWalletToLegacy(providerId);
+    }
+    throw new Error('Not implemented');
+  }
+  removeWallets(providerIds?: string[]): void {
+    if (this.#storageKey === HUB_LAST_CONNECTED_WALLETS) {
+      return this.#removeWalletsFromHub(providerIds);
+    } else if (this.#storageKey === LEGACY_LAST_CONNECTED_WALLETS) {
+      return this.#removeWalletsFromLegacy(providerIds);
+    }
+    throw new Error('Not implemented');
+  }
+  list(): LastConnectedWalletsStorage {
+    if (this.#storageKey === HUB_LAST_CONNECTED_WALLETS) {
+      return this.#listFromHub();
+    } else if (this.#storageKey === LEGACY_LAST_CONNECTED_WALLETS) {
+      return this.#listFromLegacy();
+    }
+    throw new Error('Not implemented');
+  }
+  removeNamespacesFromWallet(providerId: string, namespaceIds: string[]) {
+    if (this.#storageKey === HUB_LAST_CONNECTED_WALLETS) {
+      return this.#removeNamespaceFromWalletHub(providerId, namespaceIds);
+    }
+    throw new Error('Not implemented');
+  }
+
+  #listFromLegacy(): LastConnectedWalletsStorage {
+    const persistor = new Persistor<LegacyLastConnectedWalletsStorage>();
+    const lastConnectedWallets =
+      persistor.getItem(LEGACY_LAST_CONNECTED_WALLETS) || [];
+    const output: LastConnectedWalletsStorage = {};
+    lastConnectedWallets.forEach((provider) => {
+      // Setting empty namespaces
+      output[provider] = [];
+    });
+    return output;
+  }
+  #listFromHub(): LastConnectedWalletsStorage {
+    const persistor = new Persistor<LastConnectedWalletsStorage>();
+    const lastConnectedWallets =
+      persistor.getItem(HUB_LAST_CONNECTED_WALLETS) || {};
+    return lastConnectedWallets;
+  }
+  #addWalletToHub(providerId: string, namespaces: NamespaceInput[]): void {
+    const storage = new Persistor<LastConnectedWalletsStorage>();
+    const storageState = storage.getItem(this.#storageKey) || {};
+
+    let toBeAddedNamespaces = namespaces;
+
+    // If provider already exits in the storage, we should just add new namespaces to the previously added namespaces.
+    if (!!storageState[providerId]) {
+      const storedNamespaces = storageState[providerId];
+      toBeAddedNamespaces = storedNamespaces.concat(
+        namespaces.filter(
+          (namespace) =>
+            !storedNamespaces.some(
+              (storedNamespace) =>
+                storedNamespace.namespace === namespace.namespace
+            )
+        )
+      );
+    }
+
+    storage.setItem(this.#storageKey, {
+      ...storageState,
+      [providerId]: toBeAddedNamespaces,
+    });
+  }
+  #addWalletToLegacy(providerId: string): void {
+    const storage = new Persistor<LegacyLastConnectedWalletsStorage>();
+    const storageState = storage.getItem(this.#storageKey) || [];
+
+    storage.setItem(
+      LEGACY_LAST_CONNECTED_WALLETS,
+      storageState.concat(providerId)
+    );
+  }
+  #removeWalletsFromHub(providerIds?: string[]): void {
+    const persistor = new Persistor<LastConnectedWalletsStorage>();
+    const storageState = persistor.getItem(this.#storageKey) || {};
+
+    // Remove all wallets
+    if (!providerIds) {
+      persistor.setItem(this.#storageKey, {});
+      return;
+    }
+
+    // Remove some of the wallets
+    providerIds.forEach((providerId) => {
+      if (storageState[providerId]) {
+        delete storageState[providerId];
+      }
+    });
+
+    persistor.setItem(this.#storageKey, storageState);
+  }
+  #removeNamespaceFromWalletHub(
+    providerId: string,
+    namespaceIds: string[]
+  ): void {
+    const persistor = new Persistor<LastConnectedWalletsStorage>();
+    const storageState = persistor.getItem(this.#storageKey) || {};
+
+    const currentProviderNamespaces = storageState[providerId];
+    const newProviderNamespaces = currentProviderNamespaces?.filter(
+      (namespace) => !namespaceIds.includes(namespace.namespace)
+    );
+
+    this.#removeWalletsFromHub([providerId]);
+    if (newProviderNamespaces?.length > 0) {
+      this.#addWalletToHub(providerId, newProviderNamespaces);
+    }
+  }
+  #removeWalletsFromLegacy(providerIds?: string[]): void {
+    const persistor = new Persistor<LegacyLastConnectedWalletsStorage>();
+    const storageState = persistor.getItem(this.#storageKey) || [];
+
+    // Remove all wallets
+    if (!providerIds) {
+      persistor.setItem(this.#storageKey, []);
+      return;
+    }
+
+    // Remove some of the wallets
+    persistor.setItem(
+      LEGACY_LAST_CONNECTED_WALLETS,
+      storageState.filter((wallet) => !providerIds.includes(wallet))
+    );
+  }
+}

package/src/hub/mod.ts

@@ -0,0 +1,6 @@
+export {
+  separateLegacyAndHubProviders,
+  getAllLegacyProviders,
+  findProviderByType,
+} from './utils.js';
+export { useHubAdapter } from './useHubAdapter.js';

package/src/hub/types.ts

@@ -0,0 +1,12 @@
+import type {
+  CommonNamespaces,
+  FindProxiedNamespace,
+  ProviderMetadata,
+} from '@rango-dev/wallets-core';
+
+export type AllProxiedNamespaces = FindProxiedNamespace<
+  keyof CommonNamespaces,
+  CommonNamespaces
+>;
+
+export type ExtensionLink = keyof ProviderMetadata['extensions'];