@hub3js/core 0.58.2-next.0

package/src/namespaces/evm/actions.ts

@@ -0,0 +1,134 @@
+import type {
+  ConnectOptions,
+  EvmActions,
+  ProviderAccounts,
+  ProviderAPI,
+} from './types.js';
+import type { Context } from '../../hub/namespaces/mod.js';
+import type { CanEagerConnect } from '../../hub/namespaces/types.js';
+import type { FunctionWithContext } from '../../types/actions.js';
+
+import { recommended as commonRecommended } from '../common/actions.js';
+
+import {
+  filterAndGetEvmBlockchainNames,
+  formatAccountsToCAIP,
+  getAccounts,
+  switchOrAddNetwork,
+} from './utils.js';
+
+export const recommended = [...commonRecommended];
+export function connect(
+  instance: () => ProviderAPI,
+  options?: ConnectOptions,
+): FunctionWithContext<EvmActions['connect'], Context> {
+  return async (context, chain) => {
+    // Setting connect args to be used on other actions
+    const [, setState] = context.state();
+    setState('connectArgs', { chain });
+    const evmInstance = instance();
+
+    if (!evmInstance) {
+      throw new Error(
+        'Do your wallet injected correctly and is evm compatible?',
+      );
+    }
+
+    if (chain) {
+      /*
+       * The `switchOrAddNetwork` function can be optionally provided through `options`
+       * to handle network switching or addition in a way that is compatible with the specific wallet provider.
+       * This approach is necessary because not all providers follow the same conventions—
+       * for example, Rabby uses a different error code for "chain not found".
+       */
+      if (options?.switchOrAddNetwork) {
+        await options.switchOrAddNetwork(evmInstance, chain);
+      } else {
+        await switchOrAddNetwork(evmInstance, chain);
+      }
+    }
+
+    let providerAccounts: ProviderAccounts;
+    /*
+     * The `getAccounts` function can be optionally provided through `options`
+     * to handle getting address and chainId of the specific wallet provider.
+     * This approach is necessary because not all providers follow the same conventions.
+     */
+    if (options?.getAccounts) {
+      providerAccounts = await options.getAccounts(evmInstance);
+    } else {
+      providerAccounts = await getAccounts(evmInstance);
+    }
+
+    /*
+     * Ensure that the provider returns at least one valid account before proceeding.
+     * This prevents cases (e.g., MetaMask bug) where a user connects with an account
+     * that has no associated EVM address, leaving the dApp without any usable accounts.
+     */
+    if (!providerAccounts.accounts || !providerAccounts.accounts.length) {
+      throw new Error(
+        'No accounts were returned by the provider. Please make sure your wallet has an active EVM-compatible account selected.',
+      );
+    }
+    const formattedAccounts = formatAccountsToCAIP(
+      providerAccounts.accounts,
+      providerAccounts.chainId,
+    );
+
+    return {
+      accounts: formattedAccounts,
+      network: providerAccounts.chainId,
+    };
+  };
+}
+
+export function canEagerConnect(
+  instance: () => ProviderAPI | undefined,
+): CanEagerConnect<EvmActions> {
+  return async () => {
+    const evmInstance = instance();
+
+    if (!evmInstance) {
+      throw new Error(
+        'Trying to eagerly connect to your EVM wallet, but seems its instance is not available.',
+      );
+    }
+
+    try {
+      const accounts: string[] = await evmInstance.request({
+        method: 'eth_accounts',
+      });
+      if (accounts.length) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  };
+}
+export function canSwitchNetwork(): FunctionWithContext<
+  EvmActions['canSwitchNetwork'],
+  Context
+> {
+  return (context, params) => {
+    const { network, supportedChains } = params;
+    return filterAndGetEvmBlockchainNames(supportedChains).includes(network);
+  };
+}
+
+export function getChainId(
+  instance: () => ProviderAPI | undefined,
+): FunctionWithContext<EvmActions['getChainId'], Context> {
+  return async () => {
+    const evmInstance = instance();
+
+    if (!evmInstance) {
+      throw new Error(
+        'Trying to get chain id from your EVM wallet, but instance is not available.',
+      );
+    }
+
+    return evmInstance.request({ method: 'eth_chainId' });
+  };
+}

package/src/namespaces/evm/after.ts

@@ -0,0 +1,3 @@
+import { recommended as commonRecommended } from '../common/after.js';
+
+export const recommended = [...commonRecommended];

package/src/namespaces/evm/and.ts

@@ -0,0 +1,5 @@
+import { connectAndUpdateStateForMultiNetworks } from '../common/mod.js';
+
+export const recommended = [
+  ['connect', connectAndUpdateStateForMultiNetworks] as const,
+];

package/src/namespaces/evm/before.ts

@@ -0,0 +1,3 @@
+import { beforeRecommended } from '../common/mod.js';
+
+export const recommended = [...beforeRecommended];

package/src/namespaces/evm/builders.ts

@@ -0,0 +1,52 @@
+import type { EvmActions, ProviderAPI } from './types.js';
+
+import { ActionBuilder } from '../../mod.js';
+import { ChangeAccountSubscriberBuilder } from '../common/hooks/changeAccountSubscriber.js';
+import {
+  connectAndUpdateStateForMultiNetworks,
+  intoConnecting,
+  intoConnectionFinished,
+} from '../common/mod.js';
+
+import { formatAccountsToCAIP } from './utils.js';
+
+// Actions
+export const connect = () =>
+  new ActionBuilder<EvmActions, 'connect'>('connect')
+    .and(connectAndUpdateStateForMultiNetworks)
+    .before(intoConnecting)
+    .after(intoConnectionFinished);
+
+export const canEagerConnect = () =>
+  new ActionBuilder<EvmActions, 'canEagerConnect'>('canEagerConnect');
+export const canSwitchNetwork = () =>
+  new ActionBuilder<EvmActions, 'canSwitchNetwork'>('canSwitchNetwork');
+
+// Hooks
+export const changeAccountSubscriber = (getInstance: () => ProviderAPI) =>
+  new ChangeAccountSubscriberBuilder<string[], ProviderAPI, EvmActions>()
+    .getInstance(getInstance)
+    /*
+     * In some wallets, when a user switches to an account not yet connected to the dApp, it returns null.
+     * A null value indicates no access to the account, requiring a disconnect and user reconnection.
+     * This behavior may vary across different wallets, and if so, a different approach may be needed.
+     */
+    .onSwitchAccount((event, context) => {
+      if (!event.payload || !event.payload.length) {
+        context.action('disconnect');
+        event.preventDefault();
+      }
+    })
+    .format(async (instance, accounts) => {
+      const chainId = await instance.request({ method: 'eth_chainId' });
+      return formatAccountsToCAIP(accounts, chainId);
+    })
+    .addEventListener((instance, callback) => {
+      instance.on('accountsChanged', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.removeListener?.('accountsChanged', callback);
+    });
+
+export const getChainId = () =>
+  new ActionBuilder<EvmActions, 'getChainId'>('getChainId');

package/src/namespaces/evm/constants.ts

@@ -0,0 +1,2 @@
+export const CAIP_NAMESPACE = 'eip155';
+export const CAIP_ETHEREUM_CHAIN_ID = '1';