@dynamic-labs/aptos 4.39.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,5 +1,6 @@
 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';
 /**
  * Interface for AIP-62 compliant Aptos wallet providers.
  *
@@ -30,7 +31,7 @@ import type { AccountInfo, AptosSignMessageInput, AptosSignMessageOutput, Networ
  */
 export interface IAptosProvider {
     /** Wallet-standard features (AIP-62 compliant wallets) */
-    features: {
+    features?: {
         'aptos:connect'?: {
             version: string;
             connect(): Promise<UserResponse<AccountInfo>>;
@@ -78,6 +79,19 @@ export interface IAptosProvider {
             getNetwork(): Promise<NetworkInfo>;
         };
     };
+    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 (wallet-standard only)
@@ -112,3 +126,10 @@ export interface AptosWalletConnectorProps {
 }
 export type AptosFeatureName = keyof NonNullable<IAptosProvider['features']>;
 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/getWalletStandardWallets/getWalletStandardWallets.cjs

@@ -3,9 +3,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var core = require('@wallet-standard/core');
 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.
  *
@@ -34,16 +35,34 @@ var walletStandard = require('@aptos-labs/wallet-standard');
  * ```
  */
 const getWalletStandardWallets = () => {
-    const { get, on } = core.getWallets();
-    const wallets = get();
-    const aptosWallets = [];
-    wallets.map((wallet) => {
-        const isAptos = walletStandard.isWalletWithRequiredFeatureSet(wallet);
-        if (isAptos) {
-            aptosWallets.push(wallet);
-        }
-    });
-    return { aptosWallets: aptosWallets, on };
+    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

@@ -1,7 +1,8 @@
 'use client'
-import { getWallets } from '@wallet-standard/core';
-import { isWalletWithRequiredFeatureSet } from '@aptos-labs/wallet-standard';
+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.
  *
@@ -30,16 +31,34 @@ import { isWalletWithRequiredFeatureSet } from '@aptos-labs/wallet-standard';
  * ```
  */
 const getWalletStandardWallets = () => {
-    const { get, on } = getWallets();
-    const wallets = get();
-    const aptosWallets = [];
-    wallets.map((wallet) => {
-        const isAptos = isWalletWithRequiredFeatureSet(wallet);
-        if (isAptos) {
-            aptosWallets.push(wallet);
-        }
-    });
-    return { aptosWallets: aptosWallets, on };
+    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 };

package/src/walletStandard/createAptosSignerFromWalletStandard.cjs

@@ -0,0 +1,244 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletStandard = require('@aptos-labs/wallet-standard');
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('AptosWalletStandardConnector');
+const createAptosSignerFromWalletStandard = ({ wallet, walletConnector, }) => {
+    const features = wallet.features;
+    const hasAutoConnectedAccounts = () => {
+        var _a, _b, _c;
+        return Boolean(((_a = wallet.accounts) === null || _a === void 0 ? void 0 : _a.length) > 0 &&
+            ((_b = wallet.accounts[0]) === null || _b === void 0 ? void 0 : _b.publicKey) &&
+            ((_c = wallet.accounts[0]) === null || _c === void 0 ? void 0 : _c.address));
+    };
+    const getCurrentAccount = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const accountMethod = (_a = features['aptos:account']) === null || _a === void 0 ? void 0 : _a.account;
+        if (accountMethod) {
+            return accountMethod();
+        }
+        if (((_b = wallet.accounts) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            const [account] = wallet.accounts;
+            // Validate that the account has valid address and publicKey
+            if (account.address && account.publicKey) {
+                const addressStr = account.address.toString();
+                if (addressStr && addressStr !== '0x' && addressStr.length > 2) {
+                    return new walletStandard.AccountInfo({
+                        address: account.address,
+                        // using this typing since account.publicKey is a ReadonlyUint8Array
+                        publicKey: account.publicKey,
+                    });
+                }
+            }
+        }
+        throw new Error('Account not found');
+    });
+    const connect = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _c;
+        const autoConnectedAccounts = wallet.accounts || [];
+        if (hasAutoConnectedAccounts()) {
+            const [account] = autoConnectedAccounts;
+            return {
+                args: new walletStandard.AccountInfo({
+                    address: account.address,
+                    publicKey: account.publicKey,
+                }),
+                status: walletStandard.UserResponseStatus.APPROVED,
+            };
+        }
+        const connectMethod = (_c = features['aptos:connect']) === null || _c === void 0 ? void 0 : _c.connect;
+        if (!connectMethod) {
+            throw new Error('Connect method not implemented by wallet');
+        }
+        const result = yield connectMethod();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const resultArgs = result.args;
+        if (!(resultArgs === null || resultArgs === void 0 ? void 0 : resultArgs.address)) {
+            throw new Error('No account connected');
+        }
+        return {
+            args: new walletStandard.AccountInfo({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                address: resultArgs.address,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                publicKey: resultArgs.publicKey,
+            }),
+            status: walletStandard.UserResponseStatus.APPROVED,
+        };
+    });
+    const disconnect = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _d;
+        const disconnectMethod = (_d = features['aptos:disconnect']) === null || _d === void 0 ? void 0 : _d.disconnect;
+        if (!disconnectMethod) {
+            logger.debug('[AptosWalletStandardConnector] Disconnect method not implemented');
+            return;
+        }
+        yield disconnectMethod();
+    });
+    const account = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const currentAccount = yield getCurrentAccount();
+        const address = typeof currentAccount === 'string'
+            ? currentAccount
+            : currentAccount.address;
+        return new walletStandard.AccountInfo({
+            address: address,
+            publicKey: currentAccount.publicKey,
+        });
+    });
+    const network = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // Try to get network info from the wallet connector
+            const networkInfo = yield walletConnector.getNetworkInfo();
+            if (networkInfo) {
+                return networkInfo;
+            }
+        }
+        catch (err) {
+            logger.debug('[AptosWalletStandardConnector] Failed to get network info from connector:', err);
+        }
+        // Return a default mainnet if not available
+        return {
+            chainId: 1,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            name: 'Mainnet',
+            url: 'https://fullnode.mainnet.aptoslabs.com/v1',
+        };
+    });
+    const signTransaction = (transaction, asFeePayer) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signTransactionMethod = features['aptos:signTransaction'];
+        if (!(signTransactionMethod === null || signTransactionMethod === void 0 ? void 0 : signTransactionMethod.signTransaction)) {
+            logger.error('[AptosWalletStandardConnector] Sign transaction not implemented by wallet');
+            throw new Error('Sign transaction not implemented by wallet');
+        }
+        const result = yield signTransactionMethod.signTransaction(transaction, asFeePayer);
+        return result;
+    });
+    const signMessage = (input) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signMessageMethod = features['aptos:signMessage'];
+        if (!(signMessageMethod === null || signMessageMethod === void 0 ? void 0 : signMessageMethod.signMessage)) {
+            logger.error('[AptosWalletStandardConnector] Sign message not implemented by wallet');
+            throw new Error('Sign message not implemented by wallet');
+        }
+        const result = yield signMessageMethod.signMessage(input);
+        return result;
+    });
+    const signAndSubmitTransaction = (transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signAndSubmitMethod = features['aptos:signAndSubmitTransaction'];
+        if (!(signAndSubmitMethod === null || signAndSubmitMethod === void 0 ? void 0 : signAndSubmitMethod.signAndSubmitTransaction)) {
+            logger.error('[AptosWalletStandardConnector] Sign and submit transaction not implemented by wallet');
+            throw new Error('Sign and submit transaction not implemented by wallet');
+        }
+        const result = yield signAndSubmitMethod.signAndSubmitTransaction({
+            transaction,
+        });
+        return result;
+    });
+    const onAccountChange = (callback) => {
+        var _a;
+        const onMethod = (_a = features['standard:events']) === null || _a === void 0 ? void 0 : _a.on;
+        if (!onMethod) {
+            logger.debug('[AptosWalletStandardConnector] Events not implemented by wallet');
+            return () => { };
+        }
+        logger.debug('[AptosWalletStandardConnector] Setting up account change listener');
+        const wrappedCallback = (prop) => {
+            var _a;
+            const account = (_a = prop.accounts) === null || _a === void 0 ? void 0 : _a[0];
+            if (account) {
+                callback(new walletStandard.AccountInfo({
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    address: account.address,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    publicKey: account.publicKey,
+                }));
+            }
+            else {
+                callback(null);
+            }
+        };
+        // 'change' is the only event that is supported by the wallet standard
+        return onMethod('change', wrappedCallback);
+    };
+    const onNetworkChange = (callback) => {
+        var _a;
+        const onMethod = (_a = features['standard:events']) === null || _a === void 0 ? void 0 : _a.on;
+        if (!onMethod) {
+            logger.debug('[AptosWalletStandardConnector] Events not implemented by wallet');
+            return () => { };
+        }
+        logger.debug('[AptosWalletStandardConnector] Setting up network change listener');
+        const wrappedCallback = (prop) => {
+            // Network changes might be indicated through feature changes
+            // This is wallet-specific and may need adjustment
+            if (prop.features) {
+                // Trigger network check
+                network()
+                    .then((networkInfo) => {
+                    if (networkInfo) {
+                        callback(networkInfo);
+                    }
+                })
+                    .catch((err) => {
+                    logger.debug('[AptosWalletStandardConnector] Failed to get network info:', err);
+                });
+            }
+        };
+        // 'change' is the only event that is supported by the wallet standard
+        return onMethod('change', wrappedCallback);
+    };
+    return {
+        account,
+        connect,
+        disconnect,
+        features: {
+            'aptos:account': {
+                account,
+                version: '1.0.0',
+            },
+            'aptos:connect': {
+                connect,
+                version: '1.0.0',
+            },
+            'aptos:disconnect': {
+                disconnect,
+                version: '1.0.0',
+            },
+            'aptos:network': {
+                network,
+                version: '1.0.0',
+            },
+            'aptos:onAccountChange': {
+                onAccountChange,
+                version: '1.0.0',
+            },
+            'aptos:onNetworkChange': {
+                onNetworkChange,
+                version: '1.0.0',
+            },
+            'aptos:signAndSubmitTransaction': {
+                signAndSubmitTransaction,
+                version: '1.0.0',
+            },
+            'aptos:signMessage': {
+                signMessage,
+                version: '1.0.0',
+            },
+            'aptos:signTransaction': {
+                signTransaction,
+                version: '1.0.0',
+            },
+        },
+        onAccountChange,
+        onNetworkChange,
+        signAndSubmitTransaction,
+        signMessage,
+        signTransaction,
+    };
+};
+
+exports.createAptosSignerFromWalletStandard = createAptosSignerFromWalletStandard;

package/src/walletStandard/createAptosSignerFromWalletStandard.d.ts

@@ -0,0 +1,9 @@
+import type { Wallet } from '@aptos-labs/wallet-standard';
+import type { IAptosProvider } from '../types';
+import { AptosWalletConnector } from '../connectors/AptosWalletConnector';
+type CreateAptosSignerFromWalletStandardProps = {
+    wallet: Wallet;
+    walletConnector: AptosWalletConnector;
+};
+export declare const createAptosSignerFromWalletStandard: ({ wallet, walletConnector, }: CreateAptosSignerFromWalletStandardProps) => IAptosProvider;
+export {};