@rango-dev/wallets-core 0.49.1-next.0 → 0.49.1-next.1

package/src/namespaces/evm/actions.ts

@@ -1,26 +1,18 @@
-import type { EIP1193EventMap } from './eip1193.js';
 import type { ConnectOptions, EvmActions, ProviderAPI } from './types.js';
-import type { Context, Subscriber } from '../../hub/namespaces/mod.js';
-import type {
-  CanEagerConnect,
-  SubscriberCleanUp,
-} from '../../hub/namespaces/types.js';
-import type { CaipAccount } from '../../types/accounts.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 { AccountId } from 'caip';
-
 import { recommended as commonRecommended } from '../common/actions.js';
 
-import { CAIP_NAMESPACE } from './constants.js';
 import {
   filterAndGetEvmBlockchainNames,
+  formatAccountsToCAIP,
   getAccounts,
   switchOrAddNetwork,
 } from './utils.js';
 
 export const recommended = [...commonRecommended];
-const CHAIN_ID_RADIX = 16;
 export function connect(
   instance: () => ProviderAPI,
   options?: ConnectOptions
@@ -50,129 +42,18 @@ export function connect(
 
     const result = await getAccounts(evmInstance);
 
-    /*
-     * Trust Wallet Compatibility Fix:
-     * Trust Wallet's in-app browser has been observed to return the `chainId` as a
-     * number (e.g., 1) rather than the standard hexadecimal string (e.g., "0x1").
-     * This code block standardizes the `chainId` to the required hex format to
-     * prevent downstream errors.
-     */
-    let chainId = result.chainId;
-    if (typeof chainId === 'number') {
-      chainId = `0x${Number(chainId).toString(CHAIN_ID_RADIX)}`;
-    }
-
-    const formatAccounts = result.accounts.map(
-      (account) =>
-        AccountId.format({
-          address: account,
-          chainId: {
-            namespace: CAIP_NAMESPACE,
-            reference: chainId,
-          },
-        }) as CaipAccount
+    const formattedAccounts = formatAccountsToCAIP(
+      result.accounts,
+      result.chainId
     );
 
     return {
-      accounts: formatAccounts,
-      network: chainId,
+      accounts: formattedAccounts,
+      network: result.chainId,
     };
   };
 }
 
-export function changeAccountSubscriber(
-  instance: () => ProviderAPI
-): [Subscriber<EvmActions>, SubscriberCleanUp<EvmActions>] {
-  let eventCallback: EIP1193EventMap['accountsChanged'];
-
-  // subscriber can be passed to `or`, it will get the error and should rethrow error to pass the error to next `or` or throw error.
-  return [
-    (context, err) => {
-      const evmInstance = instance();
-
-      if (!evmInstance) {
-        throw new Error(
-          'Trying to subscribe to your EVM wallet, but seems its instance is not available.'
-        );
-      }
-
-      const [, setState] = context.state();
-
-      eventCallback = async (accounts) => {
-        /*
-         * In Phantom, when user is switching to an account which is not connected to dApp yet, it returns a null.
-         * So null means we don't have access to account and we need to disconnect and let the user connect the account.
-         *
-         * This assumption may not work for other wallets, if that the case, we need to consider a new approach.
-         */
-        if (!accounts || accounts.length === 0) {
-          context.action('disconnect');
-          return;
-        }
-
-        const chainId = await evmInstance.request({ method: 'eth_chainId' });
-        const formatAccounts = accounts.map((account) =>
-          AccountId.format({
-            address: account,
-            chainId: {
-              namespace: CAIP_NAMESPACE,
-              reference: chainId,
-            },
-          })
-        );
-
-        setState('accounts', formatAccounts);
-      };
-      evmInstance.on('accountsChanged', eventCallback);
-
-      if (err instanceof Error) {
-        throw err;
-      }
-    },
-    (_, err) => {
-      const evmInstance = instance();
-
-      if (eventCallback && evmInstance) {
-        evmInstance.removeListener?.('accountsChanged', eventCallback);
-      }
-
-      return err;
-    },
-  ];
-}
-
-export function changeChainSubscriber(
-  instance: () => ProviderAPI
-): [Subscriber<EvmActions>, SubscriberCleanUp<EvmActions>] {
-  let eventCallback: EIP1193EventMap['chainChanged'];
-
-  return [
-    (context) => {
-      const evmInstance = instance();
-
-      if (!evmInstance) {
-        throw new Error(
-          'Trying to subscribe to your EVM wallet, but seems its instance is not available.'
-        );
-      }
-
-      const [, setState] = context.state();
-
-      eventCallback = async (chainId: string) => {
-        setState('network', chainId);
-      };
-      evmInstance.on('chainChanged', eventCallback);
-    },
-    () => {
-      const evmInstance = instance();
-
-      if (eventCallback && evmInstance) {
-        evmInstance.removeListener('chainChanged', eventCallback);
-      }
-    },
-  ];
-}
-
 export function canEagerConnect(
   instance: () => ProviderAPI | undefined
 ): CanEagerConnect<EvmActions> {

package/src/namespaces/evm/builders.ts

@@ -1,12 +1,18 @@
-import type { EvmActions } from './types.js';
+import type { EvmActions, ProviderAPI } from './types.js';
+
+import { AccountId } from 'caip';
 
 import { ActionBuilder } from '../../mod.js';
+import { ChangeAccountSubscriberBuilder } from '../common/hooks/changeAccountSubscriber.js';
 import {
   connectAndUpdateStateForMultiNetworks,
   intoConnecting,
   intoConnectionFinished,
 } from '../common/mod.js';
 
+import { CAIP_NAMESPACE } from './constants.js';
+
+// Actions
 export const connect = () =>
   new ActionBuilder<EvmActions, 'connect'>('connect')
     .and(connectAndUpdateStateForMultiNetworks)
@@ -17,3 +23,35 @@ 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>()
+    .getInstance(getInstance)
+    .validateEventPayload(
+      (accounts) =>
+        /*
+         * 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.
+         */
+        accounts && accounts.length !== 0
+    )
+    .format(async (instance, accounts) => {
+      const chainId = await instance.request({ method: 'eth_chainId' });
+      return accounts.map((account) =>
+        AccountId.format({
+          address: account,
+          chainId: {
+            namespace: CAIP_NAMESPACE,
+            reference: chainId,
+          },
+        })
+      );
+    })
+    .addEventListener((instance, callback) => {
+      instance.on('accountsChanged', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.removeListener?.('accountsChanged', callback);
+    });

package/src/namespaces/evm/hooks.ts

@@ -0,0 +1,43 @@
+import type { EIP1193EventMap } from './eip1193.js';
+import type { EvmActions, ProviderAPI } from './types.js';
+import type { Subscriber, SubscriberCleanUp } from '../../mod.js';
+
+import { builders } from './mod.js';
+
+export function changeAccountSubscriber(
+  instance: () => ProviderAPI
+): [Subscriber<EvmActions>, SubscriberCleanUp<EvmActions>] {
+  return builders.changeAccountSubscriber(instance).build();
+}
+
+export function changeChainSubscriber(
+  instance: () => ProviderAPI
+): [Subscriber<EvmActions>, SubscriberCleanUp<EvmActions>] {
+  let eventCallback: EIP1193EventMap['chainChanged'];
+
+  return [
+    (context) => {
+      const evmInstance = instance();
+
+      if (!evmInstance) {
+        throw new Error(
+          'Trying to subscribe to your EVM wallet, but seems its instance is not available.'
+        );
+      }
+
+      const [, setState] = context.state();
+
+      eventCallback = async (chainId: string) => {
+        setState('network', chainId);
+      };
+      evmInstance.on('chainChanged', eventCallback);
+    },
+    () => {
+      const evmInstance = instance();
+
+      if (eventCallback && evmInstance) {
+        evmInstance.removeListener('chainChanged', eventCallback);
+      }
+    },
+  ];
+}

package/src/namespaces/evm/mod.ts

@@ -1,4 +1,5 @@
 export * as actions from './actions.js';
+export * as hooks from './hooks.js';
 export * as after from './after.js';
 export * as and from './and.js';
 export * as before from './before.js';

package/src/namespaces/evm/utils.ts

@@ -1,16 +1,33 @@
 import type { Chain, ChainId, ProviderAPI } from './types.js';
+import type { CaipAccount } from '../../types/accounts.js';
 
+import { AccountId } from 'caip';
 import { type BlockchainMeta, evmBlockchains } from 'rango-types';
 
+import { CAIP_NAMESPACE } from './constants.js';
+
+const CHAIN_ID_RADIX = 16;
+
 export async function getAccounts(provider: ProviderAPI) {
   const [accounts, chainId] = await Promise.all([
     provider.request({ method: 'eth_requestAccounts' }),
     provider.request({ method: 'eth_chainId' }),
   ]);
+  /*
+   * Trust Wallet Compatibility Fix:
+   * Trust Wallet's in-app browser has been observed to return the `chainId` as a
+   * number (e.g., 1) rather than the standard hexadecimal string (e.g., "0x1").
+   * This code block standardizes the `chainId` to the required hex format to
+   * prevent downstream errors.
+   */
+  let standardChainId = chainId;
+  if (typeof standardChainId === 'number') {
+    standardChainId = `0x${Number(chainId).toString(CHAIN_ID_RADIX)}`;
+  }
 
   return {
     accounts,
-    chainId,
+    chainId: standardChainId,
   };
 }
 
@@ -74,3 +91,16 @@ export function isUserRejectionError(error: unknown): boolean {
   }
   return false;
 }
+
+export function formatAccountsToCAIP(accounts: string[], chainId: string) {
+  return accounts.map(
+    (account) =>
+      AccountId.format({
+        address: account,
+        chainId: {
+          namespace: CAIP_NAMESPACE,
+          reference: chainId,
+        },
+      }) as CaipAccount
+  );
+}

package/src/namespaces/solana/actions.ts

@@ -1,8 +1,7 @@
 import type { ProviderAPI, SolanaActions } from './types.js';
-import type { Context, Subscriber } from '../../hub/namespaces/mod.js';
-import type { SubscriberCleanUp } from '../../hub/namespaces/types.js';
+import type { Context } from '../../hub/namespaces/mod.js';
 import type { CaipAccount } from '../../types/accounts.js';
-import type { AnyFunction, FunctionWithContext } from '../../types/actions.js';
+import type { FunctionWithContext } from '../../types/actions.js';
 
 import { AccountId } from 'caip';
 
@@ -13,59 +12,6 @@ import { getAccounts } from './utils.js';
 
 export const recommended = [...commonRecommended];
 
-export function changeAccountSubscriber(
-  instance: () => ProviderAPI | undefined
-): [Subscriber<SolanaActions>, SubscriberCleanUp<SolanaActions>] {
-  let eventCallback: AnyFunction;
-
-  // subscriber can be passed to `or`, it will get the error and should rethrow error to pass the error to next `or` or throw error.
-  return [
-    (context, err) => {
-      const solanaInstance = instance();
-
-      if (!solanaInstance) {
-        throw new Error(
-          'Trying to subscribe to your Solana wallet, but seems its instance is not available.'
-        );
-      }
-
-      const [, setState] = context.state();
-
-      eventCallback = (publicKey) => {
-        /*
-         * In Phantom, when user is switching to an account which is not connected to dApp yet, it returns a null.
-         * So null means we don't have access to account and we 0 need to disconnect and let the user connect the account.
-         */
-        if (!publicKey) {
-          context.action('disconnect');
-          return;
-        }
-
-        setState('accounts', [
-          AccountId.format({
-            address: publicKey.toString(),
-            chainId: {
-              namespace: CAIP_NAMESPACE,
-              reference: CAIP_SOLANA_CHAIN_ID,
-            },
-          }),
-        ]);
-      };
-      solanaInstance.on('accountChanged', eventCallback);
-
-      return err;
-    },
-    (_context, err) => {
-      const solanaInstance = instance();
-
-      if (eventCallback && solanaInstance) {
-        solanaInstance.off('accountChanged', eventCallback);
-      }
-
-      return err;
-    },
-  ];
-}
 export function connect(
   instance: () => ProviderAPI
 ): FunctionWithContext<SolanaActions['connect'], Context> {

package/src/namespaces/solana/builders.ts

@@ -1,14 +1,38 @@
-import type { SolanaActions } from './types.js';
+import type { ProviderAPI, SolanaActions } from './types.js';
 
 import { ActionBuilder } from '../../mod.js';
+import { ChangeAccountSubscriberBuilder } from '../common/hooks/changeAccountSubscriber.js';
 import {
   connectAndUpdateStateForSingleNetwork,
   intoConnecting,
   intoConnectionFinished,
 } from '../common/mod.js';
 
+import { formatAccountsToCAIP } from './utils.js';
+
+// Actions
 export const connect = () =>
   new ActionBuilder<SolanaActions, 'connect'>('connect')
     .and(connectAndUpdateStateForSingleNetwork)
     .before(intoConnecting)
     .after(intoConnectionFinished);
+
+// Hooks
+export const changeAccountSubscriber = (getInstance: () => ProviderAPI) =>
+  new ChangeAccountSubscriberBuilder<string, ProviderAPI>()
+    .getInstance(getInstance)
+    .validateEventPayload(
+      (accounts) =>
+        /*
+         * 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.
+         */
+        !!accounts
+    )
+    .format(async (_, accounts) => formatAccountsToCAIP([accounts]))
+    .addEventListener((instance, callback) => {
+      instance.on('accountChanged', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.off('accountChanged', callback);
+    });

package/src/namespaces/solana/hooks.ts

@@ -0,0 +1,10 @@
+import type { ProviderAPI, SolanaActions } from './types.js';
+import type { Subscriber, SubscriberCleanUp } from '../../mod.js';
+
+import { builders } from './mod.js';
+
+export function changeAccountSubscriber(
+  instance: () => ProviderAPI
+): [Subscriber<SolanaActions>, SubscriberCleanUp<SolanaActions>] {
+  return builders.changeAccountSubscriber(instance).build();
+}

package/src/namespaces/solana/mod.ts

@@ -1,4 +1,5 @@
 export * as actions from './actions.js';
+export * as hooks from './hooks.js';
 export * as after from './after.js';
 export * as and from './and.js';
 export * as before from './before.js';

package/src/namespaces/solana/utils.ts

@@ -1,7 +1,12 @@
 import type { ProviderAPI } from './types.js';
+import type { CaipAccount } from '../../types/accounts.js';
+
+import { AccountId } from 'caip';
 
 import { LegacyNetworks } from '../../legacy/mod.js';
 
+import { CAIP_NAMESPACE, CAIP_SOLANA_CHAIN_ID } from './constants.js';
+
 export async function getAccounts(provider: ProviderAPI) {
   const solanaResponse = await provider.connect();
   const account = solanaResponse.publicKey.toString();
@@ -10,3 +15,16 @@ export async function getAccounts(provider: ProviderAPI) {
     chainId: LegacyNetworks.SOLANA,
   };
 }
+
+export function formatAccountsToCAIP(accounts: string[]) {
+  return accounts.map(
+    (account) =>
+      AccountId.format({
+        address: account.toString(),
+        chainId: {
+          namespace: CAIP_NAMESPACE,
+          reference: CAIP_SOLANA_CHAIN_ID,
+        },
+      }) as CaipAccount
+  );
+}

package/src/namespaces/sui/actions.ts

@@ -1,68 +1,8 @@
 import type { SuiActions } from './types.js';
-import type { Subscriber } from '../../hub/namespaces/mod.js';
-import type {
-  CanEagerConnect,
-  SubscriberCleanUp,
-} from '../../hub/namespaces/types.js';
-import type { StandardEventsChangeProperties } from '@mysten/wallet-standard';
+import type { CanEagerConnect } from '../../hub/namespaces/types.js';
 
-import { AccountId } from 'caip';
-
-import { CAIP_NAMESPACE, CAIP_SUI_CHAIN_ID } from './constants.js';
 import { getInstanceOrThrow } from './mod.js';
 
-interface ChangeAccountSubscriberParams {
-  name: string;
-}
-
-export function changeAccountSubscriber(
-  params: ChangeAccountSubscriberParams
-): [Subscriber<SuiActions>, SubscriberCleanUp<SuiActions>] {
-  let unsubscriber: () => void;
-
-  return [
-    (context, err) => {
-      const wallet = getInstanceOrThrow(params.name);
-
-      const [, setState] = context.state();
-      const eventCallback = (event: StandardEventsChangeProperties) => {
-        if (event.accounts) {
-          if (event.accounts.length === 0) {
-            context.action('disconnect');
-          } else {
-            setState(
-              'accounts',
-              event.accounts.map((account) => {
-                return AccountId.format({
-                  address: account.address,
-                  chainId: {
-                    namespace: CAIP_NAMESPACE,
-                    reference: CAIP_SUI_CHAIN_ID,
-                  },
-                });
-              })
-            );
-          }
-        }
-      };
-      unsubscriber = wallet.features['standard:events'].on(
-        'change',
-        eventCallback
-      );
-
-      if (err instanceof Error) {
-        throw err;
-      }
-    },
-    (_context, err) => {
-      if (unsubscriber) {
-        unsubscriber();
-      }
-
-      return err;
-    },
-  ];
-}
 interface CanEagerConnectParams {
   name: string;
 }

package/src/namespaces/sui/builders.ts

@@ -1,7 +1,13 @@
-import type { SuiActions } from './types.js';
+import type {
+  ChangeAccountSubscriberParams,
+  ProviderAPI,
+  SuiActions,
+} from './types.js';
+import type { WalletAccount } from '@mysten/wallet-standard';
 
 import { ActionBuilder } from '../../mod.js';
 import { CAIP } from '../../utils/mod.js';
+import { ChangeAccountSubscriberBuilder } from '../common/hooks/changeAccountSubscriber.js';
 import {
   type CaipAccount,
   connectAndUpdateStateForSingleNetwork,
@@ -10,8 +16,9 @@ import {
 } from '../common/mod.js';
 
 import { CAIP_NAMESPACE, CAIP_SUI_CHAIN_ID } from './constants.js';
-import { getInstanceOrThrow } from './utils.js';
+import { formatAccountsToCAIP, getInstanceOrThrow } from './utils.js';
 
+// Actions
 interface ConnectParams {
   name: string;
 }
@@ -42,3 +49,27 @@ export const connect = (params: ConnectParams) =>
 
 export const canEagerConnect = () =>
   new ActionBuilder<SuiActions, 'canEagerConnect'>('canEagerConnect');
+
+// Hooks
+export const changeAccountSubscriber = (
+  params: ChangeAccountSubscriberParams
+) =>
+  new ChangeAccountSubscriberBuilder<
+    { accounts: readonly WalletAccount[] },
+    ProviderAPI
+  >()
+    .getInstance(() => getInstanceOrThrow(params.name))
+    .validateEventPayload(
+      (event) =>
+        /*
+         * 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.
+         */
+
+        event.accounts?.length !== 0
+    )
+    .format(async (_, event) => formatAccountsToCAIP(event.accounts))
+    .addEventListener((instance, callback) =>
+      instance.features['standard:events'].on('change', callback)
+    )
+    .removeEventListener((_, __) => {});

package/src/namespaces/sui/hooks.ts

@@ -0,0 +1,10 @@
+import type { ChangeAccountSubscriberParams, SuiActions } from './types.js';
+import type { Subscriber, SubscriberCleanUp } from '../../mod.js';
+
+import { builders } from './mod.js';
+
+export function changeAccountSubscriber(
+  params: ChangeAccountSubscriberParams
+): [Subscriber<SuiActions>, SubscriberCleanUp<SuiActions>] {
+  return builders.changeAccountSubscriber({ name: params.name }).build();
+}

package/src/namespaces/sui/mod.ts

@@ -2,6 +2,7 @@ export type { ProviderAPI, SuiActions } from './types.js';
 
 export * as actions from './actions.js';
 export * as builders from './builders.js';
+export * as hooks from './hooks.js';
 export { getInstanceOrThrow, getInstance } from './utils.js';
 
 export { CAIP_NAMESPACE, CAIP_SUI_CHAIN_ID } from './constants.js';

package/src/namespaces/sui/types.ts

@@ -3,6 +3,12 @@ import type {
   AutoImplementedActionsByRecommended,
   CommonActions,
 } from '../common/types.js';
+import type {
+  StandardConnectFeature,
+  StandardEventsFeature,
+  SuiFeatures,
+  WalletWithFeatures,
+} from '@mysten/wallet-standard';
 
 export interface SuiActions
   extends AutoImplementedActionsByRecommended,
@@ -11,5 +17,10 @@ export interface SuiActions
   canEagerConnect: () => Promise<boolean>;
 }
 
-// eslint-disable-next-line
-export type ProviderAPI = Record<string, any>;
+export type ProviderAPI = WalletWithFeatures<
+  StandardConnectFeature & StandardEventsFeature & SuiFeatures
+>;
+
+export interface ChangeAccountSubscriberParams {
+  name: string;
+}

package/src/namespaces/sui/utils.ts

@@ -6,6 +6,9 @@ import type {
 } from '@mysten/wallet-standard';
 
 import { getWallets, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
+import { AccountId } from 'caip';
+
+import { CAIP_NAMESPACE, CAIP_SUI_CHAIN_ID } from './constants.js';
 
 // TODO: StandardFetures doesn't work, so we should add each feature separately
 type SuiWalletStandard = WalletWithFeatures<
@@ -40,3 +43,14 @@ export function getInstanceOrThrow(name: string): SuiWalletStandard {
 
   return wallet;
 }
+export function formatAccountsToCAIP(accounts: readonly { address: string }[]) {
+  return accounts.map((account) => {
+    return AccountId.format({
+      address: account.address,
+      chainId: {
+        namespace: CAIP_NAMESPACE,
+        reference: CAIP_SUI_CHAIN_ID,
+      },
+    });
+  });
+}