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

package/src/namespaces/evm/namespace.ts

@@ -0,0 +1,102 @@
+import type { Context } from '@hub3js/core';
+import type { EvmActions } from '@hub3js/evm';
+
+import { NamespaceBuilder } from '@hub3js/core';
+import { actions, builders, utils } from '@hub3js/evm';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+
+import { getAdapter } from '../../adapter/registry.js';
+import { WALLET_ID } from '../../constants.js';
+import { getAccountsFromSession } from '../../session/accounts.js';
+import { filterEvmAccounts } from '../../session/evm.js';
+import { chainReferenceToHex, parseChainReference } from '../../utils.js';
+
+import {
+  sessionDeleteSubscriber,
+  sessionEventSubscriber,
+  sessionUpdateSubscriber,
+} from './hooks.js';
+
+const [sessionUpdate, sessionUpdateCleanup] = sessionUpdateSubscriber();
+const [sessionEvent, sessionEventCleanup] = sessionEventSubscriber();
+const [sessionDelete, sessionDeleteCleanup] = sessionDeleteSubscriber();
+
+const connect = builders
+  .connect()
+  .action(async function (_context: Context<EvmActions>, chain?: string) {
+    const adapter = getAdapter();
+    // `chain` is set when connecting to a specific network (swap auto-switch or hub connect with network).
+    const requestedReference = chain ? parseChainReference(chain) : undefined;
+    const session = await adapter.ensureConnectedToChain(chain);
+    const activeReference =
+      requestedReference ?? (await adapter.resolveActiveChainReference());
+
+    if (!activeReference) {
+      throw new Error(
+        'Unable to determine EVM chain id from WalletConnect session.'
+      );
+    }
+
+    const accounts = getAccountsFromSession(session);
+    const evmAccounts = filterEvmAccounts(accounts, activeReference);
+
+    if (!evmAccounts.length) {
+      throw new Error('No EVM accounts found in WalletConnect session.');
+    }
+
+    return {
+      accounts: utils.formatAccountsToCAIP(
+        evmAccounts.map((account) => account.accounts[0]),
+        activeReference
+      ),
+      network: chainReferenceToHex(activeReference),
+    };
+  })
+  .before(sessionUpdate)
+  .before(sessionEvent)
+  .before(sessionDelete)
+  .or(sessionUpdateCleanup)
+  .or(sessionEventCleanup)
+  .or(sessionDeleteCleanup)
+  .or((_, err) => {
+    void getAdapter().disconnectSession('evm');
+    return err;
+  })
+  .or(standardizeAndThrowError)
+  .build();
+
+const canEagerConnect = builders
+  .canEagerConnect()
+  .action(async () => getAdapter().tryRestoreEagerSession('evm'))
+  .build();
+
+const canSwitchNetwork = builders
+  .canSwitchNetwork()
+  .action(actions.canSwitchNetwork())
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<EvmActions>()
+  .before(async () => {
+    await getAdapter().disconnectSession('evm');
+  })
+  .after(sessionUpdateCleanup)
+  .after(sessionEventCleanup)
+  .after(sessionDeleteCleanup)
+  .build();
+
+const getChainId = builders
+  .getChainId()
+  .action(async () => getAdapter().getCurrentChainId())
+  .build();
+
+const evm = new NamespaceBuilder<EvmActions>('EVM', WALLET_ID)
+  .action(connect)
+  .action(canEagerConnect)
+  .action(canSwitchNetwork)
+  .action(disconnect)
+  .action(getChainId)
+  .build();
+
+export { evm };

package/src/namespaces/subscriber.ts

@@ -0,0 +1,106 @@
+import type { WalletConnectAdapter } from '../adapter/adapter.js';
+import type { WalletConnectNamespace } from '../types.js';
+import type {
+  Actions,
+  Context,
+  Subscriber,
+  SubscriberCleanUp,
+} from '@hub3js/core';
+import type { SessionTypes, SignClientTypes } from '@walletconnect/types';
+
+import { debug } from '@rango-dev/logging-core';
+
+import { getAdapter } from '../adapter/registry.js';
+
+/** The WC client events a namespace subscribes to. */
+export type SessionEventName =
+  | 'session_update'
+  | 'session_event'
+  | 'session_delete';
+
+export type SessionEventHandler<
+  Name extends SessionEventName,
+  ActionsType extends Actions<ActionsType>
+> = (event: {
+  args: SignClientTypes.EventArguments[Name];
+  /** The cached session this event was matched against. */
+  session: SessionTypes.Struct;
+  adapter: WalletConnectAdapter;
+  context: Context<ActionsType>;
+}) => void | Promise<void>;
+
+function logHandlerError(error: unknown) {
+  debug(error instanceof Error ? error : new Error(String(error)));
+}
+
+/**
+ * Builds a hub subscriber for one WC client event, scoped to one namespace.
+ *
+ * Every namespace hook needs the same four things - resolve the client, only act
+ * on events for the session this namespace has cached, register, and unregister
+ * the exact same handler reference. Getting the topic guard wrong is what makes a
+ * hook act on the other namespace's session, so it lives here rather than being
+ * repeated per hook.
+ */
+export function createSessionSubscriber<
+  Name extends SessionEventName,
+  ActionsType extends Actions<ActionsType>
+>(
+  namespace: WalletConnectNamespace,
+  event: Name,
+  handle: SessionEventHandler<Name, ActionsType>
+): [Subscriber<ActionsType>, SubscriberCleanUp<ActionsType>] {
+  let handler: ((args: SignClientTypes.EventArguments[Name]) => void) | null =
+    null;
+
+  return [
+    async (context) => {
+      const adapter = getAdapter();
+      const client = await adapter.getClient();
+
+      /*
+       * A namespace re-runs its `before` subscribers on every connect, so drop the
+       * previous registration first - otherwise each reconnect leaves another live
+       * handler behind and only the last one is ever removed.
+       */
+      if (handler) {
+        client.off(event, handler);
+      }
+
+      handler = (args) => {
+        const session = adapter.getSession(namespace);
+        if (!session || args.topic !== session.topic) {
+          return;
+        }
+
+        /*
+         * WC dispatches these from its own async request pipeline with nothing
+         * catching downstream, so a throw here (a payload shaped unlike anything
+         * the handler expects) would surface as an unhandled rejection and take
+         * the rest of that pipeline's processing with it. Async handlers are
+         * covered too - their rejection lands nowhere otherwise.
+         */
+        try {
+          const handled = handle({ args, session, adapter, context });
+          if (handled instanceof Promise) {
+            void handled.catch(logHandlerError);
+          }
+        } catch (error) {
+          logHandlerError(error);
+        }
+      };
+
+      client.on(event, handler);
+    },
+    (_, err) => {
+      const currentHandler = handler;
+      if (currentHandler) {
+        handler = null;
+        void getAdapter()
+          .getClient()
+          .then((client) => client.off(event, currentHandler));
+      }
+      return err;
+    },
+  ];
+}

package/src/provider.ts

@@ -0,0 +1,35 @@
+import type { Environments } from './types.js';
+
+import { ProviderBuilder } from '@hub3js/core';
+
+import { WalletConnectAdapter } from './adapter/adapter.js';
+import { setAdapter } from './adapter/registry.js';
+import { metadata, WALLET_ID } from './constants.js';
+import { evm } from './namespaces/evm/namespace.js';
+
+const buildProvider = () =>
+  new ProviderBuilder(WALLET_ID)
+    .init(function (context, environments: Environments) {
+      const [, setState] = context.state();
+
+      if (!environments.WC_PROJECT_ID) {
+        return;
+      }
+
+      setAdapter(
+        new WalletConnectAdapter({
+          projectId: environments.WC_PROJECT_ID,
+          meta: environments.meta || [],
+          disableModalLink: environments.DISABLE_MODAL_AND_OPEN_LINK,
+          themeMode: environments.themeMode,
+          modalZIndex: environments.modalZIndex,
+        })
+      );
+      setState('installed', true);
+      console.debug('[wallet-connect-2] provider initialized.', context);
+    })
+    .config('metadata', metadata)
+    .add('evm', evm)
+    .build();
+
+export { buildProvider };

package/src/session/accounts.ts

@@ -0,0 +1,44 @@
+import type { SessionTypes, SignClientTypes } from '@walletconnect/types';
+
+import { AccountId } from 'caip';
+
+/**
+ * `accountsChanged` entries are CAIP-10 (`eip155:1:0x…`) from wallets that follow
+ * WC and a bare `0x…` from the ones forwarding the EIP-1193 payload as-is.
+ */
+export function extractAddress(account: string): string {
+  return account.includes(':') ? new AccountId(account).address : account;
+}
+
+export function getAccountsFromSession(session: SessionTypes.Struct) {
+  const accounts = Object.values(session.namespaces)
+    .map((namespace) => namespace.accounts)
+    .flat()
+    .map((account) => {
+      const { address, chainId } = new AccountId(account);
+      return {
+        address,
+        chainId: chainId.reference,
+      };
+    });
+  return accounts;
+}
+
+export function getAccountsFromEvent(
+  event: SignClientTypes.BaseEventArgs<{
+    namespaces: SessionTypes.Namespaces;
+  }>
+) {
+  const accounts = Object.values(event.params.namespaces)
+    .map((namespace) => namespace.accounts)
+    .flat()
+    .map((account) => {
+      const { address, chainId } = new AccountId(account);
+      return {
+        accounts: [address],
+        chainId: chainId.reference,
+      };
+    });
+
+  return accounts;
+}

package/src/session/bip122.ts

@@ -0,0 +1,225 @@
+import type { SignClientInstance } from '../types.js';
+import type { SessionTypes, SignClientTypes } from '@walletconnect/types';
+
+import { debug } from '@rango-dev/logging-core';
+import { CAIP_BITCOIN_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/utxo';
+import { AccountId } from 'caip';
+
+import { BitcoinEvents, NAMESPACES } from '../wcConstants.js';
+
+export function getBip122AccountsFromSession(
+  session: SessionTypes.Struct
+): string[] {
+  return session.namespaces[NAMESPACES.BITCOIN]?.accounts ?? [];
+}
+
+export function filterBip122Accounts(session: SessionTypes.Struct) {
+  return getBip122AccountsFromSession(session).map((account) => ({
+    address: new AccountId(account).address,
+  }));
+}
+
+export type Bip122AddressEntry = {
+  address: string;
+  intention?: 'payment' | 'ordinal';
+};
+
+/**
+ * Every address a `bip122_addressesChanged` payload carries, in wallet order.
+ * Unlike {@link pickPaymentAddress} it makes no guess about which one is active.
+ */
+export function getAnnouncedAddresses(
+  data: Bip122AddressEntry[] | string[] | undefined
+): string[] {
+  if (!data?.length) {
+    return [];
+  }
+
+  return data
+    .map((entry) => (typeof entry === 'string' ? entry : entry?.address))
+    .filter((address): address is string => !!address);
+}
+
+export function pickPaymentAddress(
+  data: Bip122AddressEntry[] | string[] | undefined
+): string | undefined {
+  if (!data?.length) {
+    return undefined;
+  }
+
+  const first = data[0];
+  if (typeof first === 'string') {
+    return first;
+  }
+
+  const entries = data as Bip122AddressEntry[];
+  return (
+    entries.find((entry) => entry.intention === 'payment')?.address ??
+    entries[0]?.address
+  );
+}
+
+export function patchBip122SessionAccount(
+  session: SessionTypes.Struct,
+  address: string
+): SessionTypes.Struct {
+  const btcNamespace = session.namespaces[NAMESPACES.BITCOIN];
+  if (!btcNamespace) {
+    return session;
+  }
+
+  const caipAccount = new AccountId({
+    chainId: {
+      namespace: NAMESPACES.BITCOIN,
+      reference: CAIP_BITCOIN_CHAIN_ID,
+    },
+    address,
+  }).toString();
+
+  const accounts = btcNamespace.accounts ?? [];
+  const hasAccount = accounts.some(
+    (account) =>
+      new AccountId(account).address.toLowerCase() === address.toLowerCase()
+  );
+
+  if (hasAccount) {
+    return session;
+  }
+
+  return {
+    ...session,
+    namespaces: {
+      ...session.namespaces,
+      [NAMESPACES.BITCOIN]: {
+        ...btcNamespace,
+        accounts: [...accounts, caipAccount],
+      },
+    },
+  };
+}
+
+const BIP122_ACCOUNT_TIMEOUT = 15_000;
+
+/**
+ * Bitcoin wallets often approve bip122 without accounts in the session object.
+ * They emit bip122_addressesChanged or session_update shortly after approval.
+ */
+export async function resolveBip122Session(
+  client: SignClientInstance,
+  session: SessionTypes.Struct
+): Promise<SessionTypes.Struct> {
+  const existing = filterBip122Accounts(session);
+  if (existing.length) {
+    return session;
+  }
+
+  const freshSession = client.session.get(session.topic) ?? session;
+  const freshAccounts = filterBip122Accounts(freshSession);
+  if (freshAccounts.length) {
+    return freshSession;
+  }
+
+  const { address, session: resolvedSession } =
+    await waitForBip122PaymentAddress(client, freshSession);
+
+  const patched = patchBip122SessionAccount(resolvedSession, address);
+  await persistSessionNamespaces(client, patched);
+  return patched;
+}
+
+/**
+ * The address the wallet reports via `bip122_addressesChanged` lands only on our
+ * patched copy, so write it back to `client.session` - the record that restore,
+ * teardown and staleness checks all read. Left unpersisted, the stored session
+ * keeps `bip122.accounts === []`: `cleanupStaleSessionsForNamespace` reads a live
+ * session as stale and disconnects it, and a reload waits again for an event the
+ * wallet only emits right after approval.
+ */
+async function persistSessionNamespaces(
+  client: SignClientInstance,
+  session: SessionTypes.Struct
+): Promise<void> {
+  try {
+    await client.session.update(session.topic, {
+      namespaces: session.namespaces,
+    });
+  } catch (error) {
+    debug(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+async function waitForBip122PaymentAddress(
+  client: SignClientInstance,
+  session: SessionTypes.Struct,
+  timeoutMs = BIP122_ACCOUNT_TIMEOUT
+): Promise<{ address: string; session: SessionTypes.Struct }> {
+  return await new Promise((resolve, reject) => {
+    const topic = session.topic;
+    let settled = false;
+
+    const finish = (address: string, updatedSession: SessionTypes.Struct) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve({ address, session: updatedSession });
+    };
+
+    const fail = (error: Error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+
+    const timer = setTimeout(() => {
+      fail(
+        new Error(
+          'Timed out waiting for Bitcoin account from wallet. Please try reconnecting.'
+        )
+      );
+    }, timeoutMs);
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      client.off('session_event', onEvent);
+      client.off('session_update', onUpdate);
+    };
+
+    const onEvent = (args: SignClientTypes.EventArguments['session_event']) => {
+      if (args.topic !== topic) {
+        return;
+      }
+      if (args.params.event.name !== BitcoinEvents.ADDRESSES_CHANGED) {
+        return;
+      }
+
+      const address = pickPaymentAddress(
+        args.params.event.data as Bip122AddressEntry[]
+      );
+      if (address) {
+        finish(address, client.session.get(topic) ?? session);
+      }
+    };
+
+    const onUpdate = (
+      args: SignClientTypes.EventArguments['session_update']
+    ) => {
+      if (args.topic !== topic) {
+        return;
+      }
+
+      const updatedSession = client.session.get(topic) ?? session;
+      const accounts = filterBip122Accounts(updatedSession);
+      if (accounts.length) {
+        finish(accounts[0].address, updatedSession);
+      }
+    };
+
+    client.on('session_event', onEvent);
+    client.on('session_update', onUpdate);
+  });
+}

package/src/session/chain-state.ts

@@ -0,0 +1,38 @@
+import type { ISignClient } from '@walletconnect/types';
+import type { BlockchainMeta } from 'rango-types';
+
+import { CHAIN_ID_STORAGE } from '../wcConstants.js';
+
+export async function persistCurrentChainId(
+  client: ISignClient,
+  chainId?: string
+) {
+  return client.core.storage.setItem(CHAIN_ID_STORAGE, {
+    defaultChainId: chainId ? parseInt(chainId) : '',
+  });
+}
+
+export async function getPersistedChainId(client: ISignClient) {
+  try {
+    const chainId = (await client.core.storage.getItem(CHAIN_ID_STORAGE))
+      ?.defaultChainId;
+    return !!chainId ? String(chainId) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function getChainIdByNetworkName(
+  network: string,
+  meta: BlockchainMeta[]
+): string | undefined {
+  const targetBlockchain = meta.find(
+    (blockchain) => blockchain.name === network
+  );
+  const chainIdInHex = targetBlockchain?.chainId;
+  if (!chainIdInHex) {
+    return undefined;
+  }
+
+  return String(parseInt(chainIdInHex));
+}