@rango-dev/provider-walletconnect-2 0.57.0 → 0.57.1-next.0

package/src/session/evm-chain.ts

@@ -0,0 +1,185 @@
+import type { Chain } from '@hub3js/evm';
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
+import type { BlockchainMeta } from 'rango-types';
+
+import { error as logError } from '@rango-dev/logging-core';
+import { ChainId } from 'caip';
+
+import {
+  chainReferenceToHex,
+  parseChainReference,
+  resolveNetworkName,
+} from '../utils.js';
+import { EthereumRPCMethods, NAMESPACES } from '../wcConstants.js';
+
+import { getAccountsFromSession } from './accounts.js';
+import { getPersistedChainId, persistCurrentChainId } from './chain-state.js';
+import {
+  filterEvmAccounts,
+  ignoreNamespaceMethods,
+  switchOrAddEvmChain,
+  updateSessionAccounts,
+} from './evm.js';
+
+export type EvmChainDeps = {
+  meta: BlockchainMeta[];
+  getSession: (namespace: 'evm') => SessionTypes.Struct | null;
+  cacheSession: (namespace: 'evm', session: SessionTypes.Struct) => void;
+  getClient: () => Promise<ISignClient>;
+  ensureSession: (options: {
+    namespace: 'evm';
+    chainReference?: string;
+  }) => Promise<SessionTypes.Struct>;
+};
+
+export async function resolveActiveChainReference(
+  client: ISignClient,
+  session: SessionTypes.Struct
+): Promise<string | undefined> {
+  const persistedChainId = await getPersistedChainId(client);
+  if (persistedChainId) {
+    return persistedChainId;
+  }
+
+  const accounts = getAccountsFromSession(session);
+  const evmAccounts = filterEvmAccounts(accounts);
+  return evmAccounts[0]?.chainId;
+}
+
+export async function getCurrentChainId(
+  client: ISignClient,
+  session: SessionTypes.Struct
+): Promise<`0x${string}`> {
+  const reference = await resolveActiveChainReference(client, session);
+  if (!reference) {
+    throw new Error(
+      'Unable to determine EVM chain id from WalletConnect session.'
+    );
+  }
+
+  return chainReferenceToHex(reference);
+}
+
+/**
+ * Returns the session to keep using: `updateSessionAccounts` may rebuild it, and
+ * the caller's copy is stale from that point on.
+ */
+export async function switchEvmNetwork(options: {
+  client: ISignClient;
+  session: SessionTypes.Struct;
+  meta: BlockchainMeta[];
+  requestedChainId: string;
+  currentChainId: string;
+}): Promise<SessionTypes.Struct> {
+  const { client, session, meta, requestedChainId, currentChainId } = options;
+
+  const requestedReference = parseChainReference(requestedChainId);
+  if (!requestedReference) {
+    const error = new Error(`There is no match for ${requestedChainId}`);
+    logError(error);
+    throw error;
+  }
+
+  const chainIdStr = new ChainId({
+    namespace: NAMESPACES.ETHEREUM,
+    reference: requestedReference,
+  }).toString();
+
+  const requestedNetwork = resolveNetworkName(requestedChainId, meta);
+  const currentNetwork = resolveNetworkName(currentChainId, meta);
+
+  const evmNamespace = session.namespaces[NAMESPACES.ETHEREUM];
+  const authorizedChains = evmNamespace?.chains || [];
+  const authorizedMethods = evmNamespace?.methods || [];
+  let activeSession = session;
+
+  if (
+    authorizedMethods.includes(EthereumRPCMethods.SWITCH_CHAIN) &&
+    !ignoreNamespaceMethods(session)
+  ) {
+    if (!requestedNetwork || !currentNetwork) {
+      const error = new Error(`Chain ${requestedReference} is not configured.`);
+      logError(error);
+      throw error;
+    }
+
+    activeSession = await updateSessionAccounts(
+      client,
+      session,
+      requestedNetwork,
+      currentNetwork,
+      meta
+    );
+    await switchOrAddEvmChain(
+      client,
+      activeSession,
+      meta,
+      requestedNetwork,
+      currentNetwork
+    );
+  } else if (!authorizedChains.includes(chainIdStr)) {
+    const error = new Error(`Chain ${requestedReference} is not configured.`);
+    logError(error);
+    throw error;
+  }
+
+  await persistCurrentChainId(client, requestedReference);
+  return activeSession;
+}
+
+export async function switchToChainIfNeeded(
+  deps: EvmChainDeps,
+  requestedReference: string
+): Promise<void> {
+  const session = deps.getSession('evm');
+  if (!session) {
+    throw new Error('WalletConnect session is not available.');
+  }
+
+  const client = await deps.getClient();
+  const currentReference = await resolveActiveChainReference(client, session);
+  if (currentReference === requestedReference) {
+    await persistCurrentChainId(client, requestedReference);
+    return;
+  }
+
+  const currentChainId = currentReference
+    ? chainReferenceToHex(currentReference)
+    : chainReferenceToHex(requestedReference);
+
+  deps.cacheSession(
+    'evm',
+    await switchEvmNetwork({
+      client,
+      session,
+      meta: deps.meta,
+      requestedChainId: requestedReference,
+      currentChainId,
+    })
+  );
+}
+
+export async function ensureConnectedToChain(
+  deps: EvmChainDeps,
+  chain?: string | Chain
+): Promise<SessionTypes.Struct> {
+  const requestedReference = chain ? parseChainReference(chain) : undefined;
+
+  if (!deps.getSession('evm')) {
+    await deps.ensureSession({
+      namespace: 'evm',
+      chainReference: requestedReference,
+    });
+  }
+
+  if (requestedReference) {
+    await switchToChainIfNeeded(deps, requestedReference);
+  }
+
+  const session = deps.getSession('evm');
+  if (!session) {
+    throw new Error('WalletConnect session is not available.');
+  }
+
+  return session;
+}

package/src/session/evm.ts

@@ -0,0 +1,198 @@
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
+import type { BlockchainMeta } from 'rango-types';
+
+import { debug } from '@rango-dev/logging-core';
+import {
+  convertEvmBlockchainMetaToEvmChainInfo,
+  isEvmAddress,
+} from '@rango-dev/wallets-shared';
+import { AccountId, ChainId } from 'caip';
+import { isEvmBlockchain } from 'rango-types';
+
+import { EthereumRPCMethods, NAMESPACES } from '../wcConstants.js';
+
+import { getChainIdByNetworkName } from './chain-state.js';
+
+export function getCurrentEvmAccountAddress(
+  session: SessionTypes.Struct
+): string | undefined {
+  return session.namespaces[NAMESPACES.ETHEREUM]?.accounts
+    ?.map((account) => new AccountId(account).address)
+    ?.filter((address) => isEvmAddress(address))?.[0];
+}
+
+export function getEvmAccount(
+  network: string,
+  address: string,
+  meta: BlockchainMeta[]
+): string | undefined {
+  const currentChainId = getChainIdByNetworkName(network, meta);
+  if (!currentChainId) {
+    return undefined;
+  }
+
+  return AccountId.format({
+    chainId: {
+      namespace: NAMESPACES.ETHEREUM,
+      reference: currentChainId,
+    },
+    address,
+  });
+}
+
+// It's enough to return only connected network for the EVM networks and ignore others
+export function filterEvmAccounts(
+  accounts: {
+    address: string;
+    chainId: string;
+  }[],
+  currentChainId?: string
+) {
+  let firstEvmAddress = false;
+  return accounts
+    .filter(({ address, chainId }) => {
+      const isEvm = isEvmAddress(address);
+      if (!isEvm) {
+        return false;
+      }
+      if (currentChainId && chainId !== currentChainId) {
+        return false;
+      }
+      if (!currentChainId) {
+        if (firstEvmAddress) {
+          return false;
+        }
+        firstEvmAddress = true;
+      }
+      return true;
+    })
+    .map(({ address, chainId }) => ({
+      accounts: [address],
+      chainId: chainId,
+    }));
+}
+
+export async function switchOrAddEvmChain(
+  client: ISignClient,
+  session: SessionTypes.Struct,
+  meta: BlockchainMeta[],
+  requestedNetwork: string,
+  currentNetwork: string
+) {
+  const evmBlockchains = meta.filter(isEvmBlockchain);
+  const evmNetworksChainInfo =
+    convertEvmBlockchainMetaToEvmChainInfo(evmBlockchains);
+  const targetChain = evmNetworksChainInfo[requestedNetwork];
+  const targetBlockchain = meta.find(
+    (blockchain: BlockchainMeta) => blockchain.name === requestedNetwork
+  );
+  const chainIdInHex = targetBlockchain?.chainId;
+
+  const currentChainId = getChainIdByNetworkName(currentNetwork, meta);
+  const currentChainEip = ChainId.format({
+    namespace: NAMESPACES.ETHEREUM,
+    reference: String(currentChainId),
+  });
+
+  try {
+    await client.request({
+      topic: session.topic,
+      request: {
+        method: EthereumRPCMethods.SWITCH_CHAIN,
+        params: [
+          {
+            chainId: chainIdInHex,
+          },
+        ],
+      },
+      // It's required to pass current chain, otherwise it won't work
+      chainId: currentChainEip,
+    });
+  } catch (err) {
+    // EIP-1193 "Unrecognized chain ID" - the wallet doesn't have this chain yet.
+    const addChainError = 4902;
+    const { code, message } = (err ?? {}) as {
+      code?: number;
+      message?: string;
+    };
+    if (code === addChainError || message?.includes(String(addChainError))) {
+      await client.request({
+        topic: session.topic,
+        request: {
+          method: EthereumRPCMethods.ADD_CHAIN,
+          params: [targetChain],
+        },
+        // It's required to pass current chain, otherwise it won't work
+        chainId: currentChainEip,
+      });
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Adds the requested and current chains' accounts to the session so sign-client
+ * accepts a request carrying their CAIP chain id, and returns the session to use
+ * from here on.
+ *
+ * The record is rebuilt rather than pushed into: the struct is shared with the
+ * store and the adapter cache, and the write below can fail (it is logged, not
+ * thrown), which would otherwise leave both holding accounts the store never
+ * accepted.
+ */
+export async function updateSessionAccounts(
+  client: ISignClient,
+  session: SessionTypes.Struct,
+  requestedNetwork: string,
+  currentNetwork: string,
+  meta: BlockchainMeta[]
+): Promise<SessionTypes.Struct> {
+  const evmNamespace = session.namespaces[NAMESPACES.ETHEREUM];
+  const currentAccountAddress = getCurrentEvmAccountAddress(session);
+  if (!evmNamespace || !currentAccountAddress) {
+    return session;
+  }
+
+  const existing = evmNamespace.accounts ?? [];
+  const wanted = [
+    getEvmAccount(requestedNetwork, currentAccountAddress, meta),
+    getEvmAccount(currentNetwork, currentAccountAddress, meta),
+  ].filter(
+    (account): account is string => !!account && !existing.includes(account)
+  );
+
+  if (!wanted.length) {
+    return session;
+  }
+
+  const updated: SessionTypes.Struct = {
+    ...session,
+    namespaces: {
+      ...session.namespaces,
+      [NAMESPACES.ETHEREUM]: {
+        ...evmNamespace,
+        accounts: [...existing, ...new Set(wanted)],
+      },
+    },
+  };
+
+  try {
+    await client.session.update(session.topic, {
+      namespaces: updated.namespaces,
+    });
+  } catch (err) {
+    debug(err instanceof Error ? err : new Error(String(err)));
+    return session;
+  }
+
+  return updated;
+}
+
+export function ignoreNamespaceMethods(session: SessionTypes.Struct): boolean {
+  const WALLETS_WITH_WRONG_NAMESPACE_METHODS = ['trust', '1inch'];
+  const peerName = session.peer?.metadata?.name;
+  return WALLETS_WITH_WRONG_NAMESPACE_METHODS.some((name) =>
+    peerName?.toLowerCase()?.includes(name)
+  );
+}

package/src/session/lifecycle.ts

@@ -0,0 +1,241 @@
+import type { AppKitModal } from '../adapter/modal.js';
+import type {
+  ConnectParams,
+  CreateSessionParams,
+  Environments,
+  SignClientInstance,
+  WalletConnectNamespace,
+} from '../types.js';
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
+import type UniversalProvider from '@walletconnect/universal-provider';
+
+import { debug } from '@rango-dev/logging-core';
+import { timeout } from '@rango-dev/wallets-shared';
+
+import { prepareModalForNamespace } from '../adapter/modal.js';
+import { PING_TIMEOUT, WC_NAMESPACE_TO_CAIP } from '../wcConstants.js';
+
+import { getAccountsFromSession } from './accounts.js';
+import { filterBip122Accounts, resolveBip122Session } from './bip122.js';
+import { getPersistedChainId } from './chain-state.js';
+import { filterEvmAccounts } from './evm.js';
+import { findSessionByNamespace } from './lookup.js';
+import { generateOptionalNamespace } from './proposals.js';
+import {
+  cleanupStaleSessionsForNamespace,
+  hasActivePairing,
+  hasActiveSession,
+  purgeOrphanedPairings,
+  purgeOrphanedSessions,
+  removeSessionRecord,
+} from './teardown.js';
+
+export type RestoreWalletConnectSessionOptions = {
+  validateAccounts?: boolean;
+};
+
+export async function restoreWalletConnectSession(
+  client: SignClientInstance,
+  namespace: WalletConnectNamespace,
+  options: RestoreWalletConnectSessionOptions = {}
+): Promise<SessionTypes.Struct | undefined> {
+  const session = await restoreNamespaceSession(client, namespace);
+  if (!session) {
+    return undefined;
+  }
+
+  /*
+   * Never wait for `bip122_addressesChanged` here. The wallet only emits it just
+   * after approval, so a stored session that still has no account will never be
+   * given one - waiting would stall for the full timeout and fail anyway. Report
+   * it as unrestorable instead and let the caller negotiate a fresh session.
+   */
+  if (namespace === 'utxo' && filterBip122Accounts(session).length === 0) {
+    return undefined;
+  }
+
+  if (options.validateAccounts) {
+    const isValid = await hasNamespaceAccounts(client, namespace, session);
+    if (!isValid) {
+      return undefined;
+    }
+  }
+
+  return session;
+}
+
+async function hasNamespaceAccounts(
+  client: SignClientInstance,
+  namespace: WalletConnectNamespace,
+  session: SessionTypes.Struct
+): Promise<boolean> {
+  if (namespace === 'utxo') {
+    return filterBip122Accounts(session).length > 0;
+  }
+
+  const accounts = getAccountsFromSession(session);
+  const currentChainId = await getPersistedChainId(client);
+  return filterEvmAccounts(accounts, currentChainId).length > 0;
+}
+
+/**
+ * Ping the session topic and return it if still valid.
+ * Returns undefined (instead of throwing) when storage contains stale records.
+ */
+export async function restoreNamespaceSession(
+  client: SignClientInstance,
+  namespace: WalletConnectNamespace
+): Promise<SessionTypes.Struct | undefined> {
+  const session = findSessionByNamespace(client, namespace);
+  if (!session?.topic) {
+    return undefined;
+  }
+
+  if (!hasActiveSession(client, session.topic)) {
+    await removeSessionRecord(client, session);
+    return undefined;
+  }
+
+  if (session.pairingTopic && !hasActivePairing(client, session.pairingTopic)) {
+    await removeSessionRecord(client, session);
+    return undefined;
+  }
+
+  try {
+    await timeout(
+      client.ping({
+        topic: session.topic,
+      }),
+      PING_TIMEOUT
+    );
+  } catch (error) {
+    debug(error instanceof Error ? error : new Error(String(error)));
+    await removeSessionRecord(client, session);
+    return undefined;
+  }
+
+  return findSessionByNamespace(client, namespace) ?? session;
+}
+
+/**
+ * Clears unusable records ahead of a connect: orphaned sessions across every
+ * namespace, plus `namespace`'s own stale ones.
+ *
+ * A *live* session belonging to another namespace is deliberately left alone -
+ * EVM and UTXO each own an independent session, and only the namespace being
+ * disconnected drops its own.
+ */
+export async function prepareWalletConnectNamespace(
+  client: UniversalProvider['client'],
+  namespace: WalletConnectNamespace
+): Promise<void> {
+  await purgeOrphanedSessions(client);
+  await cleanupStaleSessionsForNamespace(client, namespace);
+  await purgeOrphanedPairings(client);
+}
+
+/**
+ * Restores `namespace`'s session, or negotiates a new one.
+ *
+ * Callers are expected to have run {@link prepareWalletConnectNamespace} first -
+ * this does not clean up on its own.
+ */
+export async function connectWalletConnectSession(
+  client: UniversalProvider['client'],
+  web3Modal: AppKitModal,
+  params: ConnectParams
+): Promise<SessionTypes.Struct> {
+  const { chains, namespace, chainReference } = params;
+
+  const restored = await restoreWalletConnectSession(client, namespace);
+  if (restored) {
+    return restored;
+  }
+
+  const proposal = generateOptionalNamespace(
+    chains,
+    [namespace],
+    chainReference
+  );
+  const session = await createSession(
+    client,
+    web3Modal,
+    { optionalNamespaces: proposal ?? {} },
+    {
+      envs: params.envs,
+      namespace,
+    }
+  );
+
+  /*
+   * Only a just-approved session can be waited on: bitcoin wallets routinely
+   * approve bip122 with no account and send it moments later. A restored session
+   * never reaches here, so the wait can't be spent on one that will never
+   * receive the event.
+   */
+  if (namespace === 'utxo') {
+    return resolveBip122Session(client, session);
+  }
+
+  return session;
+}
+
+async function createSession(
+  client: ISignClient,
+  web3Modal: AppKitModal,
+  options: CreateSessionParams,
+  configs: {
+    envs: Environments;
+    namespace: WalletConnectNamespace;
+  }
+): Promise<SessionTypes.Struct> {
+  const { optionalNamespaces, pairingTopic } = options;
+
+  try {
+    const { uri, approval } = await client.connect({
+      optionalNamespaces,
+      pairingTopic,
+    });
+
+    let onCloseModal;
+    if (uri) {
+      const redirectLink = configs.envs.DISABLE_MODAL_AND_OPEN_LINK;
+      if (redirectLink) {
+        const url = `${redirectLink}/wc?uri=${encodeURIComponent(uri)}`;
+        window.open(url, '_blank', 'noreferrer noopener');
+      } else {
+        await prepareModalForNamespace(web3Modal, configs.namespace);
+        /*
+         * `namespace` scopes the wallet list AppKit renders. It isn't in
+         * AppKit's `OpenOptions` type but is honored at runtime, so it goes
+         * through a pre-built object (an inline literal would trip the
+         * excess-property check). `WC_NAMESPACE_TO_CAIP` is the single source
+         * for the alias -> CAIP prefix instead of sniffing the payload keys.
+         */
+        const openOptions = {
+          uri,
+          namespace: WC_NAMESPACE_TO_CAIP[configs.namespace],
+        };
+        await web3Modal.open(openOptions);
+
+        onCloseModal = new Promise((_, reject) => {
+          web3Modal.subscribeState((state) => {
+            if (!state.open) {
+              reject(new Error('Modal has been closed.'));
+            }
+          });
+        });
+      }
+    }
+
+    const session = approval();
+
+    if (onCloseModal) {
+      const result = await Promise.race([session, onCloseModal]);
+      return result as SessionTypes.Struct;
+    }
+    return await session;
+  } finally {
+    void web3Modal.close();
+  }
+}

package/src/session/lookup.ts

@@ -0,0 +1,54 @@
+import type { WalletConnectNamespace } from '../types.js';
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
+
+import { WC_NAMESPACE_TO_CAIP } from '../wcConstants.js';
+
+export function getCaipNamespace(namespace: WalletConnectNamespace): string {
+  return WC_NAMESPACE_TO_CAIP[namespace];
+}
+
+export function findSessionByNamespace(
+  client: ISignClient,
+  namespace: WalletConnectNamespace
+): SessionTypes.Struct | undefined {
+  const caipNamespace = getCaipNamespace(namespace);
+
+  return client.session.getAll().find((session) => {
+    const ns = session.namespaces[caipNamespace];
+    if ((ns?.accounts?.length ?? 0) > 0) {
+      return true;
+    }
+
+    return namespace === 'utxo' && (ns?.chains?.length ?? 0) > 0;
+  });
+}
+
+export function getSessionNamespace(
+  session: SessionTypes.Struct
+): WalletConnectNamespace | undefined {
+  const hasAccounts = (namespace: WalletConnectNamespace) =>
+    (session.namespaces[WC_NAMESPACE_TO_CAIP[namespace]]?.accounts?.length ??
+      0) > 0;
+  const hasChains = (namespace: WalletConnectNamespace) =>
+    (session.namespaces[WC_NAMESPACE_TO_CAIP[namespace]]?.chains?.length ?? 0) >
+    0;
+
+  /*
+   * Prefer a namespace the wallet shared accounts for; fall back to one that
+   * only negotiated chains (utxo can be chains-only before its account settles).
+   */
+  if (hasAccounts('evm')) {
+    return 'evm';
+  }
+  if (hasAccounts('utxo')) {
+    return 'utxo';
+  }
+  if (hasChains('utxo')) {
+    return 'utxo';
+  }
+  if (hasChains('evm')) {
+    return 'evm';
+  }
+
+  return undefined;
+}