@dynamic-labs/aptos 4.38.0 → 4.40.0

package/src/injected/AptosProviderHelper.js

@@ -0,0 +1,313 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { UserResponseStatus } from '@aptos-labs/wallet-standard';
+import { getProvidersFromWindow } from '@dynamic-labs/utils';
+import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import { ProviderLookup, logger } from '@dynamic-labs/wallet-connector-core';
+
+/**
+ * Helper class for managing Aptos wallet provider discovery and interactions.
+ *
+ * This class handles:
+ * - Finding installed wallet providers using legacy injection methods
+ * - Managing provider lookups using wallet book configuration
+ * - Setting up event listeners for account and network changes
+ * - Getting addresses and signing messages through the wallet-standard interface
+ */
+class AptosProviderHelper {
+    constructor(connector) {
+        this.walletBookWallet = findWalletBookWallet(connector.walletBook, connector.key);
+        this.connector = connector;
+    }
+    /**
+     * Gets the installed Aptos provider using legacy injection.
+     */
+    getInstalledProvider() {
+        return this.getInjectedProvider();
+    }
+    /**
+     * Gets the injected provider using wallet book configuration.
+     */
+    getInjectedProvider() {
+        const config = this.getInjectedConfig();
+        if (!config ||
+            !config.extensionLocators ||
+            !config.extensionLocators.length)
+            return undefined;
+        const provider = this.installedProviderLookup(config.extensionLocators);
+        return provider;
+    }
+    /**
+     * Gets the injected configuration for Aptos from the wallet book.
+     */
+    getInjectedConfig() {
+        var _a;
+        const injectedConfig = (_a = this.walletBookWallet) === null || _a === void 0 ? void 0 : _a.injectedConfig;
+        return injectedConfig === null || injectedConfig === void 0 ? void 0 : injectedConfig.find((c) => c.chain === 'aptos');
+    }
+    /**
+     * Gets all installed Aptos providers from various window locations.
+     */
+    installedProviders() {
+        const config = this.getInjectedConfig();
+        if (!config)
+            return [];
+        const providers = [];
+        if (config.windowLocations) {
+            for (const windowLocation of config.windowLocations) {
+                const foundProviders = getProvidersFromWindow(windowLocation);
+                if (foundProviders && foundProviders.length)
+                    providers.push(...foundProviders);
+            }
+        }
+        return providers;
+    }
+    /**
+     * Looks up installed providers using extension locators.
+     */
+    installedProviderLookup(extensionLocators) {
+        const allInstalledProviders = this.installedProviders();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return ProviderLookup(allInstalledProviders, extensionLocators);
+    }
+    /**
+     * Finds the provider using the connector's findProvider method.
+     */
+    findProvider() {
+        return this.connector.findProvider();
+    }
+    /**
+     * Checks if a provider is installed.
+     */
+    isInstalledHelper() {
+        return this.findProvider() !== undefined;
+    }
+    /**
+     * Gets the current account address from the wallet.
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.findProvider();
+            if (!provider) {
+                return undefined;
+            }
+            return this.getAddressWithProvider(provider);
+        });
+    }
+    /**
+     * Connects to the Aptos wallet provider.
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.findProvider();
+            if (!provider) {
+                logger.error('No Aptos provider found to connect', {
+                    connector: this.connector.name,
+                });
+                return undefined;
+            }
+            return provider;
+        });
+    }
+    /**
+     * Gets the address using a specific provider.
+     */
+    getAddressWithProvider(provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Try to get account info from the provider
+                const accountMethod = provider.account;
+                if (accountMethod) {
+                    const accountInfo = yield accountMethod();
+                    return accountInfo.address.toString();
+                }
+                return undefined;
+            }
+            catch (err) {
+                // "Account not found" is expected when wallet is not connected yet
+                const isAccountNotFound = err instanceof Error && err.message === 'Account not found';
+                if (isAccountNotFound) {
+                    logger.debug('[AptosProviderHelper] No account connected yet');
+                }
+                else {
+                    logger.error('[AptosProviderHelper] getAddressWithProvider error:', err);
+                }
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Signs a message using the Aptos wallet.
+     */
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Early returns for validation
+            const walletAddress = yield this.getAddress();
+            if (!walletAddress)
+                return undefined;
+            const provider = this.findProvider();
+            if (!provider)
+                return undefined;
+            const signMessageMethod = provider.signMessage;
+            if (!signMessageMethod) {
+                logger.error('[AptosProviderHelper] signMessage not supported');
+                return undefined;
+            }
+            const nonce = new Date().getTime().toString();
+            const result = yield signMessageMethod({
+                message: messageToSign,
+                nonce,
+            });
+            // Handle UserResponse format
+            if (this.isUserResponseApproved(result)) {
+                return this.handleUserResponseSignature(result);
+            }
+            // Handle direct signature format
+            if ('signature' in result) {
+                return (_a = result.signature) === null || _a === void 0 ? void 0 : _a.toString();
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Checks if the result is an approved UserResponse
+     */
+    isUserResponseApproved(result) {
+        return (typeof result === 'object' &&
+            result !== null &&
+            'status' in result &&
+            result.status === UserResponseStatus.APPROVED &&
+            'args' in result);
+    }
+    /**
+     * Handles UserResponse signature format and returns JSON string
+     */
+    handleUserResponseSignature(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resultWithArgs = result;
+            const signature = (_a = resultWithArgs.args.signature) === null || _a === void 0 ? void 0 : _a.toString();
+            const { fullMessage, publicKey: walletPublicKey } = resultWithArgs.args;
+            // Get public key from account if not provided in result
+            const publicKey = walletPublicKey || (yield this.getPublicKeyFromAccount());
+            return JSON.stringify({
+                fullMessage,
+                publicKey,
+                signature,
+            });
+        });
+    }
+    /**
+     * Gets public key from the connected account
+     */
+    getPublicKeyFromAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider = this.findProvider();
+            if (!(provider === null || provider === void 0 ? void 0 : provider.account))
+                return undefined;
+            try {
+                const accountInfo = yield provider.account();
+                return (_a = accountInfo.publicKey) === null || _a === void 0 ? void 0 : _a.toString();
+            }
+            catch (e) {
+                logger.debug('Failed to fetch public key:', e);
+                return undefined;
+            }
+        });
+    }
+    /**
+     * Gets connected accounts from the provider.
+     */
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.findProvider();
+            if (!provider)
+                return [];
+            try {
+                const accountMethod = provider.account;
+                if (accountMethod) {
+                    const accountInfo = yield accountMethod();
+                    return [accountInfo.address.toString()];
+                }
+            }
+            catch (e) {
+                // This is expected when wallet is not connected yet
+                logger.debug('Error getting connected accounts', {
+                    connector: this.connector,
+                    error: e,
+                });
+            }
+            return [];
+        });
+    }
+    /**
+     * Handles account change events.
+     */
+    handleAccountChange(walletConnector, web3Provider, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!address) {
+                yield (web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.connect());
+                const accountMethod = web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.account;
+                if (accountMethod) {
+                    const accountInfo = yield accountMethod();
+                    if (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.address) {
+                        walletConnector.emit('accountChange', {
+                            accounts: [accountInfo.address.toString()],
+                        });
+                    }
+                }
+                return;
+            }
+            if (address.toString()) {
+                walletConnector.emit('accountChange', { accounts: [address.toString()] });
+            }
+        });
+    }
+    /**
+     * Sets up event listeners for account and network changes.
+     */
+    _setupEventListeners() {
+        const provider = this.findProvider();
+        if (!provider) {
+            logger.warn('Provider not found', {
+                connector: this.connector,
+            });
+            return;
+        }
+        const onAccountChangeMethod = provider === null || provider === void 0 ? void 0 : provider.onAccountChange;
+        const onNetworkChangeMethod = provider === null || provider === void 0 ? void 0 : provider.onNetworkChange;
+        if (onAccountChangeMethod) {
+            onAccountChangeMethod((account) => {
+                if (account) {
+                    this.handleAccountChange(this.connector, provider, account.address.toString());
+                }
+                else {
+                    this.connector.emit('disconnect');
+                }
+            });
+        }
+        if (onNetworkChangeMethod) {
+            onNetworkChangeMethod((network) => {
+                if (network.chainId) {
+                    this.connector.emit('chainChange', {
+                        chain: network.chainId.toString(),
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Tears down event listeners.
+     */
+    _teardownEventListeners() {
+        const provider = this.findProvider();
+        if (!provider)
+            return;
+        // Aptos providers don't have removeAllListeners like Solana
+        // Event listeners are automatically cleaned up when the provider is destroyed
+    }
+}
+
+export { AptosProviderHelper };

package/src/injected/InjectedWalletBase.cjs

@@ -0,0 +1,87 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var AptosWalletConnector = require('../connectors/AptosWalletConnector/AptosWalletConnector.cjs');
+var AptosProviderHelper = require('./AptosProviderHelper.cjs');
+
+/**
+ * Base class for injected Aptos wallet connectors.
+ *
+ * This class extends AptosWalletConnector and provides common functionality
+ * for wallets that inject themselves into the browser window object.
+ *
+ * It handles:
+ * - Provider discovery and management
+ * - Connection flow (including mobile in-app browser support)
+ * - Event listener setup and teardown
+ * - Address retrieval and message signing
+ */
+class InjectedWalletBase extends AptosWalletConnector.AptosWalletConnector {
+    get aptosProviderHelper() {
+        if (!this._aptosProviderHelper) {
+            this._aptosProviderHelper = new AptosProviderHelper.AptosProviderHelper(this);
+        }
+        return this._aptosProviderHelper;
+    }
+    findProvider() {
+        var _a;
+        return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getInstalledProvider();
+    }
+    setupEventListeners() {
+        var _a;
+        (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a._setupEventListeners();
+    }
+    teardownEventListeners() {
+        var _a;
+        (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a._teardownEventListeners();
+    }
+    connect() {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // Call parent's connect which triggers the wallet-standard connect() method
+            yield _super.connect.call(this);
+        });
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.connect();
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        return Boolean((_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.isInstalledHelper());
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.isInstalledOnBrowser()) {
+                return;
+            }
+            // If no address, we need to connect first to trigger the wallet popup
+            yield this.connect();
+            // Now try to get the address again
+            const address = yield ((_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getAddress());
+            return address;
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.signMessage(messageToSign);
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return (_b = (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getConnectedAccounts()) !== null && _b !== void 0 ? _b : [];
+        });
+    }
+}
+
+exports.InjectedWalletBase = InjectedWalletBase;

package/src/injected/InjectedWalletBase.d.ts

@@ -0,0 +1,28 @@
+import { AptosWalletConnector } from '../connectors/AptosWalletConnector';
+import type { IAptosProvider } from '../types';
+import { AptosProviderHelper } from './AptosProviderHelper';
+/**
+ * Base class for injected Aptos wallet connectors.
+ *
+ * This class extends AptosWalletConnector and provides common functionality
+ * for wallets that inject themselves into the browser window object.
+ *
+ * It handles:
+ * - Provider discovery and management
+ * - Connection flow (including mobile in-app browser support)
+ * - Event listener setup and teardown
+ * - Address retrieval and message signing
+ */
+export declare abstract class InjectedWalletBase extends AptosWalletConnector {
+    _aptosProviderHelper: AptosProviderHelper | undefined;
+    get aptosProviderHelper(): AptosProviderHelper | undefined;
+    findProvider(): IAptosProvider | undefined;
+    setupEventListeners(): void;
+    teardownEventListeners(): void;
+    connect(): Promise<void>;
+    getSigner<T = IAptosProvider>(): Promise<T | undefined>;
+    isInstalledOnBrowser(): boolean;
+    getAddress(): Promise<string | undefined>;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+}

package/src/injected/InjectedWalletBase.js

@@ -0,0 +1,83 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { AptosWalletConnector } from '../connectors/AptosWalletConnector/AptosWalletConnector.js';
+import { AptosProviderHelper } from './AptosProviderHelper.js';
+
+/**
+ * Base class for injected Aptos wallet connectors.
+ *
+ * This class extends AptosWalletConnector and provides common functionality
+ * for wallets that inject themselves into the browser window object.
+ *
+ * It handles:
+ * - Provider discovery and management
+ * - Connection flow (including mobile in-app browser support)
+ * - Event listener setup and teardown
+ * - Address retrieval and message signing
+ */
+class InjectedWalletBase extends AptosWalletConnector {
+    get aptosProviderHelper() {
+        if (!this._aptosProviderHelper) {
+            this._aptosProviderHelper = new AptosProviderHelper(this);
+        }
+        return this._aptosProviderHelper;
+    }
+    findProvider() {
+        var _a;
+        return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getInstalledProvider();
+    }
+    setupEventListeners() {
+        var _a;
+        (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a._setupEventListeners();
+    }
+    teardownEventListeners() {
+        var _a;
+        (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a._teardownEventListeners();
+    }
+    connect() {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // Call parent's connect which triggers the wallet-standard connect() method
+            yield _super.connect.call(this);
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.connect();
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        return Boolean((_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.isInstalledHelper());
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.isInstalledOnBrowser()) {
+                return;
+            }
+            // If no address, we need to connect first to trigger the wallet popup
+            yield this.connect();
+            // Now try to get the address again
+            const address = yield ((_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getAddress());
+            return address;
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.signMessage(messageToSign);
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return (_b = (_a = this.aptosProviderHelper) === null || _a === void 0 ? void 0 : _a.getConnectedAccounts()) !== null && _b !== void 0 ? _b : [];
+        });
+    }
+}
+
+export { InjectedWalletBase };

package/src/injected/fetchInjectedWalletConnectors.cjs

@@ -0,0 +1,171 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletBook = require('@dynamic-labs/wallet-book');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var logger$1 = require('@dynamic-labs/logger');
+var getWalletStandardWallets = require('../utils/getWalletStandardWallets/getWalletStandardWallets.cjs');
+var isWalletWithRequiredFeatureSet = require('../utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.cjs');
+var index = require('../consts/index.cjs');
+var getConnectorConstructorForWalletStandardWallet = require('../walletStandard/getConnectorConstructorForWalletStandardWallet.cjs');
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+const logger = new logger$1.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 = `${utils.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.isWalletWithRequiredFeatureSet(wallet, additionalFeatures);
+    logger.logVerboseTroubleshootingMessage('[APTOS shouldAddWalletStandardConnector] Decision:', {
+        hasAllFeatures,
+        requiredFeatures: [...index.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: walletBook$1, }) => {
+    var _a;
+    // Get wallet book connectors for traditional Aptos wallets
+    const walletBookConnectors = Object.entries((_a = walletBook$1 === null || walletBook$1 === void 0 ? void 0 : walletBook$1.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.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.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$1))
+        .map((wallet) => {
+        const walletBookWallet = walletBook.findWalletBookWalletByNameAndChain(walletBook$1, 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 &&
+            walletConnectorCore.getWalletMetadataFromWalletBook({
+                walletBook: walletBook$1,
+                walletBookWallet,
+                walletKey: `${utils.sanitizeName(wallet.name)}aptos`,
+            });
+        // Type incompatibility between @wallet-standard versions, casting is safe here
+        return getConnectorConstructorForWalletStandardWallet.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,
+    ];
+};
+
+exports.fetchInjectedWalletConnectors = fetchInjectedWalletConnectors;