@dynamic-labs/aptos 4.38.0 → 4.40.0

package/src/injected/fetchInjectedWalletConnectors.d.ts

@@ -0,0 +1,48 @@
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+/**
+ * Array of wallet connector constructors that have custom implementations.
+ * These wallets override the default wallet-standard behavior.
+ *
+ * @example
+ * ```typescript
+ * export const injectedWalletOverrides: WalletConnectorConstructor[] = [
+ *   PetraWallet,
+ *   OKXAptosWallet,
+ * ];
+ * ```
+ */
+export declare const injectedWalletOverrides: WalletConnectorConstructor[];
+/**
+ * Fetches all available injected Aptos wallet connectors.
+ *
+ * This function discovers and creates wallet connector constructors from two sources:
+ * 1. Wallet book entries - Traditional wallets defined in the wallet book
+ * 2. Wallet-standard wallets - AIP-62 compliant wallets discovered via wallet-standard
+ *
+ * The function automatically filters out wallets that:
+ * - Have custom connector implementations
+ * - Are already handled by wallet-standard connectors
+ * - Don't support the required Aptos feature set
+ *
+ * @param options - Configuration options
+ * @param options.walletBook - The wallet book schema containing wallet metadata
+ * @param options.authMode - The authentication mode for filtering wallet features
+ * @returns Array of wallet connector constructor classes
+ *
+ * @example
+ * ```typescript
+ * const connectors = fetchInjectedWalletConnectors({
+ *   walletBook,
+ *   authMode: 'connect-and-sign'
+ * });
+ *
+ * // Instantiate connectors
+ * connectors.forEach(Connector => {
+ *   const instance = new Connector(aptosWalletConnectorProps);
+ * });
+ * ```
+ */
+export declare const fetchInjectedWalletConnectors: ({ walletBook, }: {
+    walletBook: WalletBookSchema;
+}) => WalletConnectorConstructor[];

package/src/injected/fetchInjectedWalletConnectors.js

@@ -0,0 +1,167 @@
+'use client'
+import { findWalletBookWalletByNameAndChain } from '@dynamic-labs/wallet-book';
+import { getWalletMetadataFromWalletBook } from '@dynamic-labs/wallet-connector-core';
+import { sanitizeName } from '@dynamic-labs/utils';
+import { Logger } from '@dynamic-labs/logger';
+import { getWalletStandardWallets } from '../utils/getWalletStandardWallets/getWalletStandardWallets.js';
+import { isWalletWithRequiredFeatureSet } from '../utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.js';
+import { REQUIRED_FEATURES } from '../consts/index.js';
+import { getConnectorConstructorForWalletStandardWallet } from '../walletStandard/getConnectorConstructorForWalletStandardWallet.js';
+import { InjectedWalletBase } from './InjectedWalletBase.js';
+
+const logger = new Logger('fetchInjectedWalletConnectors');
+/**
+ * List of wallet keys that have custom connector implementations.
+ * These wallets will not use the automatic wallet-standard connector.
+ *
+ * @example
+ * ```typescript
+ * const walletsWithCustomConnectors: string[] = [
+ *   'petra',
+ *   'okxaptos',
+ * ];
+ * ```
+ */
+const walletsWithCustomConnectors = [
+// Add wallet keys here that need custom connectors
+];
+/**
+ * Determines whether a wallet-standard wallet should have a connector created for it.
+ *
+ * @param wallet - The wallet-standard wallet to check
+ * @param walletBook - The wallet book schema containing wallet metadata
+ * @param authMode - The authentication mode (optional, for future feature filtering)
+ * @returns True if a wallet-standard connector should be created
+ */
+const shouldAddWalletStandardConnector = (wallet, walletBook) => {
+    var _a;
+    const { name } = wallet;
+    const chain = 'aptos';
+    const connectorKey = `${sanitizeName(name)}${chain}`;
+    logger.logVerboseTroubleshootingMessage('[APTOS shouldAddWalletStandardConnector] Checking wallet:', { chain, connectorKey, features: Object.keys(wallet.features), name });
+    const shouldHandleWalletFromWalletBook = ([key, walletEntry]) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const hasMatchingKey = key === connectorKey;
+        const needsCustomConnector = walletsWithCustomConnectors.includes(connectorKey);
+        const hasMatchingNameAndChain = walletEntry.name === name &&
+            ((_b = (_a = walletEntry.injectedConfig) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.chain) === chain;
+        // If the wallet supports wallet-standard, we want to add the wallet-standard connector
+        // and not handle it as a default wallet-book wallet
+        const isNotWalletStandard = !((_f = (_e = (_d = (_c = walletEntry.injectedConfig) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.walletStandard) === null || _e === void 0 ? void 0 : _e.features) === null || _f === void 0 ? void 0 : _f.length);
+        // If injectedConfig is missing, it's not a traditional wallet book entry
+        const hasInjectedConfig = Boolean((_g = walletEntry.injectedConfig) === null || _g === void 0 ? void 0 : _g.length);
+        // If the chain doesn't match, it should be handled by wallet-standard
+        const hasMatchingChain = ((_j = (_h = walletEntry.injectedConfig) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.chain) === chain;
+        return ((hasMatchingKey || needsCustomConnector || hasMatchingNameAndChain) &&
+            hasInjectedConfig &&
+            hasMatchingChain &&
+            isNotWalletStandard);
+    };
+    const shouldHandleFromWalletBook = Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {}).find(shouldHandleWalletFromWalletBook);
+    // Check if wallet has all required features based on auth mode
+    const additionalFeatures = [];
+    const hasAllFeatures = isWalletWithRequiredFeatureSet(wallet, additionalFeatures);
+    logger.logVerboseTroubleshootingMessage('[APTOS shouldAddWalletStandardConnector] Decision:', {
+        hasAllFeatures,
+        requiredFeatures: [...REQUIRED_FEATURES, ...additionalFeatures],
+        shouldAdd: !shouldHandleFromWalletBook && hasAllFeatures,
+        shouldHandleFromWalletBook: Boolean(shouldHandleFromWalletBook),
+    });
+    return !shouldHandleFromWalletBook && hasAllFeatures;
+};
+/**
+ * Fetches all available injected Aptos wallet connectors.
+ *
+ * This function discovers and creates wallet connector constructors from two sources:
+ * 1. Wallet book entries - Traditional wallets defined in the wallet book
+ * 2. Wallet-standard wallets - AIP-62 compliant wallets discovered via wallet-standard
+ *
+ * The function automatically filters out wallets that:
+ * - Have custom connector implementations
+ * - Are already handled by wallet-standard connectors
+ * - Don't support the required Aptos feature set
+ *
+ * @param options - Configuration options
+ * @param options.walletBook - The wallet book schema containing wallet metadata
+ * @param options.authMode - The authentication mode for filtering wallet features
+ * @returns Array of wallet connector constructor classes
+ *
+ * @example
+ * ```typescript
+ * const connectors = fetchInjectedWalletConnectors({
+ *   walletBook,
+ *   authMode: 'connect-and-sign'
+ * });
+ *
+ * // Instantiate connectors
+ * connectors.forEach(Connector => {
+ *   const instance = new Connector(aptosWalletConnectorProps);
+ * });
+ * ```
+ */
+const fetchInjectedWalletConnectors = ({ walletBook, }) => {
+    var _a;
+    // Get wallet book connectors for traditional Aptos wallets
+    const walletBookConnectors = Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        .filter(([key, wallet]) => {
+        var _a, _b, _c;
+        const injectedConfig = (_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'aptos');
+        const isAptosWallet = Boolean(injectedConfig);
+        // Filter out wallets that require a custom connector or wallets that support wallet-standard,
+        // since they are already handled automatically with the wallet-standard connector
+        const shouldBeFiltered = walletsWithCustomConnectors.includes(key) ||
+            ((_c = (_b = injectedConfig === null || injectedConfig === void 0 ? void 0 : injectedConfig.walletStandard) === null || _b === void 0 ? void 0 : _b.features) === null || _c === void 0 ? void 0 : _c.length);
+        return isAptosWallet && !shouldBeFiltered;
+    })
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        return class extends InjectedWalletBase {
+            constructor() {
+                super(...arguments);
+                this.name = name;
+                // This is the key from the wallet book entry so that we don't purely rely on the normalized name
+                this.overrideKey = key;
+            }
+            getProvider() {
+                return this.findProvider();
+            }
+        };
+    });
+    // Get wallet-standard wallets
+    const { aptosWallets } = getWalletStandardWallets();
+    logger.logVerboseTroubleshootingMessage('[APTOS fetchInjectedWalletConnectors] Found wallet-standard wallets:', aptosWallets.map((w) => ({
+        features: Object.keys(w.features),
+        name: w.name,
+    })));
+    // Create connectors for wallet-standard wallets
+    const walletStandardConnectors = aptosWallets
+        .filter((wallet) => 
+    // Type incompatibility between @wallet-standard versions, casting is safe here
+    shouldAddWalletStandardConnector(
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    wallet, walletBook))
+        .map((wallet) => {
+        const walletBookWallet = findWalletBookWalletByNameAndChain(walletBook, wallet.name, 'aptos');
+        // If the wallet book wallet is found, we want to use it to get the metadata
+        // to merge with the wallet-standard metadata, especially for additional properties
+        const walletBookMetadata = walletBookWallet &&
+            getWalletMetadataFromWalletBook({
+                walletBook,
+                walletBookWallet,
+                walletKey: `${sanitizeName(wallet.name)}aptos`,
+            });
+        // Type incompatibility between @wallet-standard versions, casting is safe here
+        return getConnectorConstructorForWalletStandardWallet(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        wallet, walletBookMetadata);
+    });
+    logger.logVerboseTroubleshootingMessage('[APTOS fetchInjectedWalletConnectors] Created wallet-standard connectors:', walletStandardConnectors.map((w) => w.name));
+    logger.logVerboseTroubleshootingMessage('[APTOS fetchInjectedWalletConnectors] Created wallet-book connectors:', walletBookConnectors.map((w) => w.name));
+    return [
+        ...walletBookConnectors,
+        ...walletStandardConnectors,
+    ];
+};
+
+export { fetchInjectedWalletConnectors };

package/src/injected/index.d.ts

@@ -0,0 +1,3 @@
+export { AptosProviderHelper } from './AptosProviderHelper';
+export { InjectedWalletBase } from './InjectedWalletBase';
+export { fetchInjectedWalletConnectors, injectedWalletOverrides, } from './fetchInjectedWalletConnectors';

package/src/types.d.ts

@@ -1,61 +1,36 @@
 import type { AccountAuthenticator, AnyRawTransaction } from '@aptos-labs/ts-sdk';
 import type { AccountInfo, AptosSignMessageInput, AptosSignMessageOutput, NetworkInfo, UserResponse } from '@aptos-labs/wallet-standard';
+import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
 /**
- * Global window interface extension for Aptos wallet providers
- */
-declare global {
-    interface Window {
-        aptos?: IAptosProvider;
-    }
-}
-/**
- * Interface that all Aptos wallet providers must implement.
- *
- * This interface is designed to work with both wallet-standard compliant wallets
- * and injected providers (like OKX, Petra, etc.). It supports the core methods
- * needed for Aptos wallet functionality while maintaining flexibility for different
- * wallet implementations.
+ * Interface for AIP-62 compliant Aptos wallet providers.
  *
- * ## Design Philosophy
- * This interface accommodates both:
- * - **Wallet Standard**: Modern wallets implementing AIP-62 wallet standard with `features` object
- * - **Injected Providers**: Wallets that inject methods directly (like OKX, Petra legacy)
+ * This interface is designed to work exclusively with wallet-standard compliant wallets
+ * that implement AIP-62. All major Aptos wallets now support this standard, including:
+ * OKX, AptosConnect, Petra, Nightly, Pontem, RimoSafe, MSafe, Bitget, and Backpack.
  *
  * ## Core Features
  * - **Connection Management**: Connect, disconnect, and account retrieval
  * - **Network Support**: Network information and switching capabilities
  * - **Transaction Signing**: Support for transaction and message signing
  * - **Event Handling**: Account and network change listeners
- * - **Flexible Returns**: Support for different response formats
  *
  * @example
  * ```typescript
- * // Basic connection (works for both wallet-standard and injected)
- * const result = await provider.connect();
+ * // Connect to wallet using wallet-standard
+ * const result = await provider.features['aptos:connect']?.connect();
  *
  * // Sign a transaction
- * const signature = await provider.signTransaction(transaction);
+ * const signature = await provider.features['aptos:signTransaction']?.signTransaction(transaction);
  *
  * // Sign a message
- * const messageSignature = await provider.signMessage({
+ * const messageSignature = await provider.features['aptos:signMessage']?.signMessage({
  *   message: "Hello Aptos",
  *   nonce: "12345"
  * });
- *
- * // Listen for account changes
- * provider.onAccountChange?.((account) => {
- *   console.log('Account changed:', account);
- * });
  * ```
  */
 export interface IAptosProvider {
-    /** Whether the wallet is currently connected */
-    isConnected?: boolean;
-    /** The current network information */
-    network?: NetworkInfo;
-    /** The current account information */
-    account?: AccountInfo;
-    /** Wallet-standard features (for AIP-62 compliant wallets) */
+    /** Wallet-standard features (AIP-62 compliant wallets) */
     features?: {
         'aptos:connect'?: {
             version: string;
@@ -104,86 +79,24 @@ export interface IAptosProvider {
             getNetwork(): Promise<NetworkInfo>;
         };
     };
-    /**
-     * Establishes a connection to the wallet
-     * @returns Promise resolving to connection result with account information
-     */
-    connect(): Promise<AptosConnectionResult>;
-    /**
-     * Disconnects from the wallet
-     * @returns Promise that resolves when disconnected
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Retrieves the current account information
-     * @returns Promise resolving to account information
-     */
-    getAccount?(): Promise<AccountInfo>;
-    /**
-     * Retrieves the current network information
-     * @returns Promise resolving to network information
-     */
-    getNetwork?(): Promise<NetworkInfo>;
-    /**
-     * Signs a transaction for submission to the network
-     * @param transaction - Transaction to sign
-     * @param asFeePayer - Whether signing as fee payer (optional)
-     * @returns Promise resolving to signed transaction or user response
-     */
-    signTransaction(transaction: AnyRawTransaction, asFeePayer?: boolean): Promise<UserResponse<AccountAuthenticator> | AccountAuthenticator>;
-    /**
-     * Signs a message for authentication purposes
-     * @param input - Message signing input parameters
-     * @returns Promise resolving to signature result or user response
-     */
-    signMessage(input: AptosSignMessageInput): Promise<UserResponse<AptosSignMessageOutput> | AptosSignMessageOutput>;
-    /**
-     * Submits a signed transaction to the network
-     * @param transaction - Signed transaction to submit
-     * @returns Promise resolving to transaction hash
-     */
-    submitTransaction?(transaction: AccountAuthenticator): Promise<string>;
-    /**
-     * Signs and submits a transaction in one call
-     * @param transaction - Transaction to sign and submit
-     * @returns Promise resolving to transaction hash
-     */
-    signAndSubmitTransaction?(transaction: AnyRawTransaction): Promise<string>;
-    /**
-     * Switches to a different Aptos network
-     * @param network - Network to switch to
-     * @returns Promise that resolves when network is switched
-     */
-    changeNetwork?(network: NetworkInfo | string): Promise<void>;
-    /**
-     * Listen for account changes
-     * @param callback - Callback function for account changes
-     * @returns Cleanup function to remove listener
-     */
-    onAccountChange?(callback: (account: AccountInfo | null) => void): (() => void) | void;
-    /**
-     * Listen for network changes
-     * @param callback - Callback function for network changes
-     * @returns Cleanup function to remove listener
-     */
-    onNetworkChange?(callback: (network: NetworkInfo) => void): (() => void) | void;
-    /**
-     * Generic request method for custom wallet operations
-     * @param method - The method name to call
-     * @param params - Optional parameters for the method
-     * @returns Promise resolving to the method result
-     */
-    request?(method: string, params?: unknown): Promise<unknown>;
-    /** Additional properties that providers may implement */
-    [key: string]: unknown;
+    account: () => Promise<AccountInfo>;
+    connect: () => Promise<UserResponse<AccountInfo>>;
+    disconnect: () => Promise<void>;
+    signTransaction(transaction: AnyRawTransaction, asFeePayer?: boolean): Promise<UserResponse<AccountAuthenticator>>;
+    signMessage(input: AptosSignMessageInput): Promise<UserResponse<AptosSignMessageOutput>>;
+    signAndSubmitTransaction(transaction: AnyRawTransaction): Promise<UserResponse<{
+        hash: string;
+    }>>;
+    getNetwork?: () => Promise<NetworkInfo>;
+    onAccountChange?: (callback: (account: AccountInfo | null) => void) => void;
+    onNetworkChange?: (callback: (network: NetworkInfo) => void) => void;
+    onDisconnect?: (callback: () => void) => void;
+    isConnected?: () => Promise<boolean>;
 }
 /**
- * Result from wallet connection, supporting different response formats
+ * Result from wallet connection (wallet-standard only)
  */
-export type AptosConnectionResult = UserResponse<AccountInfo> | AccountInfo | {
-    address: string;
-    publicKey?: string | Uint8Array;
-} | string;
+export type AptosConnectionResult = UserResponse<AccountInfo>;
 /**
  * Props for sending APT or token balance
  */
@@ -212,4 +125,11 @@ export interface AptosWalletConnectorProps {
     metadata?: any;
 }
 export type AptosFeatureName = keyof NonNullable<IAptosProvider['features']>;
-export type AptosMethodName = 'connect' | 'disconnect' | 'signTransaction' | 'signMessage' | 'signAndSubmitTransaction' | 'submitTransaction' | 'getNetwork' | 'network';
+export type AptosMethodName = 'connect' | 'disconnect' | 'signTransaction' | 'signMessage' | 'signAndSubmitTransaction' | 'submitTransaction' | 'getNetwork' | 'network' | 'account' | 'onAccountChange' | 'onNetworkChange';
+/**
+ * Extension locators for identifying Aptos wallet browser extensions.
+ * These flags are typically set on the injected provider object to identify
+ * which wallet extension is present.
+ */
+export type ExtensionLocator = 'isPetraWallet' | 'isNightlyWallet' | 'isPontemWallet' | 'isMartianWallet' | 'isFewchaWallet' | 'isRiseWallet' | 'isMSafeWallet' | 'isOkxWallet' | 'isBitgetWallet' | 'isBackpackWallet';
+export type AptosProviderCondition = ProviderCondition<ExtensionLocator>;

package/src/utils/assertProvider/assertProvider.cjs

@@ -0,0 +1,36 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+
+/**
+ * Asserts that an AIP-62 compliant wallet provider is available and throws a consistent error if not.
+ *
+ * This utility function eliminates repetitive provider checking throughout the codebase
+ * by providing a centralized assertion with consistent error messaging. After calling
+ * this function, TypeScript will know that the provider is guaranteed to be non-null
+ * and has the required wallet-standard features.
+ *
+ * @param provider - The wallet provider to check, may be undefined
+ * @throws {DynamicError} When the provider is undefined, null, or missing features
+ *
+ * @example
+ * ```typescript
+ * const provider = getProvider();
+ * assertProvider(provider);
+ * // TypeScript now knows provider is not undefined and has features
+ * await provider.features['aptos:connect']?.connect();
+ * ```
+ */
+const assertProvider = (provider) => {
+    if (!provider) {
+        throw new utils.DynamicError('No wallet provider available');
+    }
+    if (!provider.features) {
+        throw new utils.DynamicError('Wallet provider does not support AIP-62 wallet standard');
+    }
+};
+
+exports.assertProvider = assertProvider;

package/src/utils/assertProvider/assertProvider.d.ts

@@ -1,20 +1,21 @@
 import type { IAptosProvider } from '../../types';
 /**
- * Asserts that a wallet provider is available and throws a consistent error if not.
+ * Asserts that an AIP-62 compliant wallet provider is available and throws a consistent error if not.
  *
  * This utility function eliminates repetitive provider checking throughout the codebase
  * by providing a centralized assertion with consistent error messaging. After calling
- * this function, TypeScript will know that the provider is guaranteed to be non-null.
+ * this function, TypeScript will know that the provider is guaranteed to be non-null
+ * and has the required wallet-standard features.
  *
  * @param provider - The wallet provider to check, may be undefined
- * @throws {DynamicError} When the provider is undefined or null
+ * @throws {DynamicError} When the provider is undefined, null, or missing features
  *
  * @example
  * ```typescript
  * const provider = getProvider();
  * assertProvider(provider);
- * // TypeScript now knows provider is not undefined
- * await provider.connect();
+ * // TypeScript now knows provider is not undefined and has features
+ * await provider.features['aptos:connect']?.connect();
  * ```
  */
 export declare const assertProvider: (provider: IAptosProvider | undefined) => asserts provider is IAptosProvider;

package/src/utils/assertProvider/assertProvider.js

@@ -0,0 +1,32 @@
+'use client'
+import { DynamicError } from '@dynamic-labs/utils';
+
+/**
+ * Asserts that an AIP-62 compliant wallet provider is available and throws a consistent error if not.
+ *
+ * This utility function eliminates repetitive provider checking throughout the codebase
+ * by providing a centralized assertion with consistent error messaging. After calling
+ * this function, TypeScript will know that the provider is guaranteed to be non-null
+ * and has the required wallet-standard features.
+ *
+ * @param provider - The wallet provider to check, may be undefined
+ * @throws {DynamicError} When the provider is undefined, null, or missing features
+ *
+ * @example
+ * ```typescript
+ * const provider = getProvider();
+ * assertProvider(provider);
+ * // TypeScript now knows provider is not undefined and has features
+ * await provider.features['aptos:connect']?.connect();
+ * ```
+ */
+const assertProvider = (provider) => {
+    if (!provider) {
+        throw new DynamicError('No wallet provider available');
+    }
+    if (!provider.features) {
+        throw new DynamicError('Wallet provider does not support AIP-62 wallet standard');
+    }
+};
+
+export { assertProvider };

package/src/utils/getWalletStandardWallets/getWalletStandardWallets.cjs

@@ -0,0 +1,68 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletStandard = require('@aptos-labs/wallet-standard');
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('getWalletStandardWallets');
+/**
+ * Retrieves all available Aptos-compatible wallets from the wallet standard registry.
+ *
+ * This function fetches all registered wallets and filters them to return only those
+ * that support the required Aptos feature set. It also provides an event listener
+ * function to monitor wallet registration events.
+ *
+ * @returns An object containing:
+ * - `aptosWallets`: Array of Aptos-compatible wallets that support required features
+ * - `on`: Event listener function to subscribe to wallet registration/unregistration events
+ *
+ * @example
+ * ```typescript
+ * const { aptosWallets, on } = getWalletStandardWallets();
+ *
+ * // Use the Aptos wallets
+ * console.log('Available Aptos wallets:', aptosWallets);
+ *
+ * // Listen for new wallet registrations
+ * const unsubscribe = on('register', (wallet) => {
+ *   console.log('New wallet registered:', wallet);
+ * });
+ *
+ * // Clean up listener when done
+ * unsubscribe();
+ * ```
+ */
+const getWalletStandardWallets = () => {
+    try {
+        const { aptosWallets } = walletStandard.getAptosWallets();
+        const foundAptosWallets = [];
+        aptosWallets.map((wallet) => {
+            try {
+                const isAptos = walletStandard.isWalletWithRequiredFeatureSet(wallet);
+                if (isAptos) {
+                    foundAptosWallets.push(wallet);
+                }
+            }
+            catch (error) {
+                // Log error for individual wallet but continue processing others
+                logger.debug('[getWalletStandardWallets] Error checking wallet features:', error);
+            }
+        });
+        return {
+            aptosWallets: foundAptosWallets,
+            on: () => () => { },
+        };
+    }
+    catch (error) {
+        // If wallet discovery fails completely, return empty array
+        logger.error('[getWalletStandardWallets] Failed to discover wallets:', error);
+        return {
+            aptosWallets: [],
+            on: () => () => { },
+        };
+    }
+};
+
+exports.getWalletStandardWallets = getWalletStandardWallets;

package/src/utils/getWalletStandardWallets/getWalletStandardWallets.js

@@ -0,0 +1,64 @@
+'use client'
+import { getAptosWallets, isWalletWithRequiredFeatureSet } from '@aptos-labs/wallet-standard';
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('getWalletStandardWallets');
+/**
+ * Retrieves all available Aptos-compatible wallets from the wallet standard registry.
+ *
+ * This function fetches all registered wallets and filters them to return only those
+ * that support the required Aptos feature set. It also provides an event listener
+ * function to monitor wallet registration events.
+ *
+ * @returns An object containing:
+ * - `aptosWallets`: Array of Aptos-compatible wallets that support required features
+ * - `on`: Event listener function to subscribe to wallet registration/unregistration events
+ *
+ * @example
+ * ```typescript
+ * const { aptosWallets, on } = getWalletStandardWallets();
+ *
+ * // Use the Aptos wallets
+ * console.log('Available Aptos wallets:', aptosWallets);
+ *
+ * // Listen for new wallet registrations
+ * const unsubscribe = on('register', (wallet) => {
+ *   console.log('New wallet registered:', wallet);
+ * });
+ *
+ * // Clean up listener when done
+ * unsubscribe();
+ * ```
+ */
+const getWalletStandardWallets = () => {
+    try {
+        const { aptosWallets } = getAptosWallets();
+        const foundAptosWallets = [];
+        aptosWallets.map((wallet) => {
+            try {
+                const isAptos = isWalletWithRequiredFeatureSet(wallet);
+                if (isAptos) {
+                    foundAptosWallets.push(wallet);
+                }
+            }
+            catch (error) {
+                // Log error for individual wallet but continue processing others
+                logger.debug('[getWalletStandardWallets] Error checking wallet features:', error);
+            }
+        });
+        return {
+            aptosWallets: foundAptosWallets,
+            on: () => () => { },
+        };
+    }
+    catch (error) {
+        // If wallet discovery fails completely, return empty array
+        logger.error('[getWalletStandardWallets] Failed to discover wallets:', error);
+        return {
+            aptosWallets: [],
+            on: () => () => { },
+        };
+    }
+};
+
+export { getWalletStandardWallets };