@dynamic-labs/aptos 4.38.0 → 4.39.0

package/src/index.cjs

@@ -5,14 +5,28 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var _package = require('../package.cjs');
+var AptosWallet = require('./wallet/AptosWallet.cjs');
+var AptosWalletConnector = require('./connectors/AptosWalletConnector/AptosWalletConnector.cjs');
+var assertProvider = require('./utils/assertProvider/assertProvider.cjs');
+var getWalletStandardWallets = require('./utils/getWalletStandardWallets/getWalletStandardWallets.cjs');
+var invokeWalletMethod = require('./utils/invokeWalletMethod/invokeWalletMethod.cjs');
+var isWalletWithRequiredFeatureSet = require('./utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.cjs');
+var parseConnectionResult = require('./utils/parseConnectionResult/parseConnectionResult.cjs');
+var parseTransactionResponse = require('./utils/parseTransactionResponse/parseTransactionResponse.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/aptos', _package.version);
-// TODO: Add connector exports
-// TODO: Add type exports
-// TODO: Add wallet exports
-// TODO: Add utility exports
+// Wallet connector factory (to be implemented by specific wallet connectors)
 const AptosWalletConnectors = () => [
-// TODO: Add Aptos wallet connectors
+// Specific wallet connectors will be added here by implementers
+// e.g., PetraWalletConnector, OKXWalletConnector, etc.
 ];
 
+exports.AptosWallet = AptosWallet.AptosWallet;
+exports.AptosWalletConnector = AptosWalletConnector.AptosWalletConnector;
+exports.assertProvider = assertProvider.assertProvider;
+exports.getWalletStandardWallets = getWalletStandardWallets.getWalletStandardWallets;
+exports.invokeWalletMethod = invokeWalletMethod.invokeWalletMethod;
+exports.isWalletWithRequiredFeatureSet = isWalletWithRequiredFeatureSet.isWalletWithRequiredFeatureSet;
+exports.parseConnectionResult = parseConnectionResult.parseConnectionResult;
+exports.parseTransactionResponse = parseTransactionResponse.parseTransactionResponse;
 exports.AptosWalletConnectors = AptosWalletConnectors;

package/src/index.d.ts

@@ -1 +1,10 @@
+export { AptosWallet } from './wallet';
+export { AptosWalletConnector } from './connectors/AptosWalletConnector';
+export type { IAptosProvider, AptosConnectionResult, AptosSendBalanceProps, AptosWalletConnectorProps, AptosFeatureName, AptosMethodName, } from './types';
+export { assertProvider } from './utils/assertProvider';
+export { getWalletStandardWallets } from './utils/getWalletStandardWallets';
+export { invokeWalletMethod } from './utils/invokeWalletMethod';
+export { isWalletWithRequiredFeatureSet } from './utils/isWalletWithRequiredFeatureSet';
+export { parseConnectionResult, type ParsedAccountInfo, } from './utils/parseConnectionResult';
+export { parseTransactionResponse } from './utils/parseTransactionResponse';
 export declare const AptosWalletConnectors: () => never[];

package/src/index.js

@@ -1,14 +1,20 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
+export { AptosWallet } from './wallet/AptosWallet.js';
+export { AptosWalletConnector } from './connectors/AptosWalletConnector/AptosWalletConnector.js';
+export { assertProvider } from './utils/assertProvider/assertProvider.js';
+export { getWalletStandardWallets } from './utils/getWalletStandardWallets/getWalletStandardWallets.js';
+export { invokeWalletMethod } from './utils/invokeWalletMethod/invokeWalletMethod.js';
+export { isWalletWithRequiredFeatureSet } from './utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.js';
+export { parseConnectionResult } from './utils/parseConnectionResult/parseConnectionResult.js';
+export { parseTransactionResponse } from './utils/parseTransactionResponse/parseTransactionResponse.js';
 
 assertPackageVersion('@dynamic-labs/aptos', version);
-// TODO: Add connector exports
-// TODO: Add type exports
-// TODO: Add wallet exports
-// TODO: Add utility exports
+// Wallet connector factory (to be implemented by specific wallet connectors)
 const AptosWalletConnectors = () => [
-// TODO: Add Aptos wallet connectors
+// Specific wallet connectors will be added here by implementers
+// e.g., PetraWalletConnector, OKXWalletConnector, etc.
 ];
 
 export { AptosWalletConnectors };

package/src/types.d.ts

@@ -1,62 +1,36 @@
 import type { AccountAuthenticator, AnyRawTransaction } from '@aptos-labs/ts-sdk';
 import type { AccountInfo, AptosSignMessageInput, AptosSignMessageOutput, NetworkInfo, UserResponse } from '@aptos-labs/wallet-standard';
 /**
- * Global window interface extension for Aptos wallet providers
- */
-declare global {
-    interface Window {
-        aptos?: IAptosProvider;
-    }
-}
-/**
- * Interface that all Aptos wallet providers must implement.
+ * Interface for AIP-62 compliant Aptos wallet providers.
  *
- * 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.
- *
- * ## 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) */
-    features?: {
+    /** Wallet-standard features (AIP-62 compliant wallets) */
+    features: {
         'aptos:connect'?: {
             version: string;
             connect(): Promise<UserResponse<AccountInfo>>;
@@ -104,86 +78,11 @@ 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;
 }
 /**
- * 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 +111,4 @@ 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';

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,49 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@wallet-standard/core');
+var walletStandard = require('@aptos-labs/wallet-standard');
+
+/**
+ * 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 = () => {
+    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 };
+};
+
+exports.getWalletStandardWallets = getWalletStandardWallets;

package/src/utils/getWalletStandardWallets/getWalletStandardWallets.js

@@ -0,0 +1,45 @@
+'use client'
+import { getWallets } from '@wallet-standard/core';
+import { isWalletWithRequiredFeatureSet } from '@aptos-labs/wallet-standard';
+
+/**
+ * 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 = () => {
+    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 };
+};
+
+export { getWalletStandardWallets };

package/src/utils/invokeWalletMethod/invokeWalletMethod.cjs

@@ -0,0 +1,61 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+
+/**
+ * Invokes a method on AIP-62 compliant wallet-standard provider.
+ *
+ * This utility provides a clean interface for calling wallet-standard features
+ * on Aptos wallets that implement AIP-62. All major Aptos wallets now support
+ * this standard, making legacy provider support unnecessary.
+ *
+ * @template T - The expected return type of the wallet method
+ * @param provider - The AIP-62 compliant Aptos wallet provider
+ * @param featureName - The wallet-standard feature name (e.g., 'aptos:connect')
+ * @param methodName - The method name to call (e.g., 'connect', 'signTransaction')
+ * @param args - Arguments to pass to the wallet method
+ * @returns Promise resolving to the method's return value
+ * @throws {DynamicError} When the feature or method is not supported by the provider
+ *
+ * @example
+ * ```typescript
+ * // Connect to wallet
+ * const result = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:connect',
+ *   'connect'
+ * );
+ *
+ * // Sign transaction
+ * const signature = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:signTransaction',
+ *   'signTransaction',
+ *   transaction,
+ *   false // asFeePayer
+ * );
+ * ```
+ */
+const invokeWalletMethod = (provider, featureName, methodName, ...args) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // Check if provider has features
+    if (!provider.features) {
+        throw new utils.DynamicError(`Feature ${featureName} not supported by wallet`);
+    }
+    // Get the wallet-standard feature
+    const feature = provider.features[featureName];
+    if (!feature || typeof feature !== 'object') {
+        throw new utils.DynamicError(`Feature ${featureName} not supported by wallet`);
+    }
+    // Get the method from the feature
+    const method = feature[methodName];
+    if (typeof method !== 'function') {
+        throw new utils.DynamicError(`Method ${methodName} not available in feature ${featureName}`);
+    }
+    return method(...args);
+});
+
+exports.invokeWalletMethod = invokeWalletMethod;

package/src/utils/invokeWalletMethod/invokeWalletMethod.d.ts

@@ -1,19 +1,18 @@
 import type { IAptosProvider, AptosFeatureName, AptosMethodName } from '../../types';
 /**
- * Invokes a method on either wallet-standard or injected provider.
+ * Invokes a method on AIP-62 compliant wallet-standard provider.
  *
- * This utility handles the dual provider pattern used throughout Aptos wallet interactions,
- * automatically detecting whether to use wallet-standard features or direct method calls
- * on injected providers. It provides a unified interface for calling wallet methods
- * regardless of the underlying wallet implementation.
+ * This utility provides a clean interface for calling wallet-standard features
+ * on Aptos wallets that implement AIP-62. All major Aptos wallets now support
+ * this standard, making legacy provider support unnecessary.
  *
  * @template T - The expected return type of the wallet method
- * @param provider - The Aptos wallet provider (wallet-standard or injected)
+ * @param provider - The AIP-62 compliant Aptos wallet provider
  * @param featureName - The wallet-standard feature name (e.g., 'aptos:connect')
  * @param methodName - The method name to call (e.g., 'connect', 'signTransaction')
  * @param args - Arguments to pass to the wallet method
  * @returns Promise resolving to the method's return value
- * @throws {DynamicError} When the method is not supported by the provider
+ * @throws {DynamicError} When the feature or method is not supported by the provider
  *
  * @example
  * ```typescript

package/src/utils/invokeWalletMethod/invokeWalletMethod.js

@@ -0,0 +1,57 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { DynamicError } from '@dynamic-labs/utils';
+
+/**
+ * Invokes a method on AIP-62 compliant wallet-standard provider.
+ *
+ * This utility provides a clean interface for calling wallet-standard features
+ * on Aptos wallets that implement AIP-62. All major Aptos wallets now support
+ * this standard, making legacy provider support unnecessary.
+ *
+ * @template T - The expected return type of the wallet method
+ * @param provider - The AIP-62 compliant Aptos wallet provider
+ * @param featureName - The wallet-standard feature name (e.g., 'aptos:connect')
+ * @param methodName - The method name to call (e.g., 'connect', 'signTransaction')
+ * @param args - Arguments to pass to the wallet method
+ * @returns Promise resolving to the method's return value
+ * @throws {DynamicError} When the feature or method is not supported by the provider
+ *
+ * @example
+ * ```typescript
+ * // Connect to wallet
+ * const result = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:connect',
+ *   'connect'
+ * );
+ *
+ * // Sign transaction
+ * const signature = await invokeWalletMethod(
+ *   provider,
+ *   'aptos:signTransaction',
+ *   'signTransaction',
+ *   transaction,
+ *   false // asFeePayer
+ * );
+ * ```
+ */
+const invokeWalletMethod = (provider, featureName, methodName, ...args) => __awaiter(void 0, void 0, void 0, function* () {
+    // Check if provider has features
+    if (!provider.features) {
+        throw new DynamicError(`Feature ${featureName} not supported by wallet`);
+    }
+    // Get the wallet-standard feature
+    const feature = provider.features[featureName];
+    if (!feature || typeof feature !== 'object') {
+        throw new DynamicError(`Feature ${featureName} not supported by wallet`);
+    }
+    // Get the method from the feature
+    const method = feature[methodName];
+    if (typeof method !== 'function') {
+        throw new DynamicError(`Method ${methodName} not available in feature ${featureName}`);
+    }
+    return method(...args);
+});
+
+export { invokeWalletMethod };

package/src/utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../consts/index.cjs');
+
+const isWalletWithRequiredFeatureSet = (wallet, additionalFeatures = []) => [...index.REQUIRED_FEATURES, ...additionalFeatures].every((feature) => feature in wallet.features);
+
+exports.isWalletWithRequiredFeatureSet = isWalletWithRequiredFeatureSet;

package/src/utils/isWalletWithRequiredFeatureSet/isWalletWithRequiredFeatureSet.js

@@ -0,0 +1,6 @@
+'use client'
+import { REQUIRED_FEATURES } from '../../consts/index.js';
+
+const isWalletWithRequiredFeatureSet = (wallet, additionalFeatures = []) => [...REQUIRED_FEATURES, ...additionalFeatures].every((feature) => feature in wallet.features);
+
+export { isWalletWithRequiredFeatureSet };

package/src/utils/parseConnectionResult/parseConnectionResult.cjs

@@ -0,0 +1,40 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletStandard = require('@aptos-labs/wallet-standard');
+var utils = require('@dynamic-labs/utils');
+
+/**
+ * Type guard to check if an object is a UserResponse with AccountInfo
+ */
+const isUserResponse = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const candidate = obj;
+    return ('status' in candidate &&
+        'args' in candidate &&
+        Object.values(walletStandard.UserResponseStatus).includes(candidate.status));
+};
+/**
+ * Parses wallet-standard connection result into AccountInfo.
+ * Only handles AIP-62 compliant wallet-standard responses.
+ *
+ * @param result - Connection result from wallet-standard (UserResponse<AccountInfo>)
+ * @returns AccountInfo from the approved response
+ * @throws {DynamicError} When result format is not supported or user rejected
+ */
+const parseConnectionResult = (result) => {
+    // Handle wallet-standard UserResponse format (only format we support)
+    if (isUserResponse(result) && result.status === walletStandard.UserResponseStatus.APPROVED) {
+        return result.args;
+    }
+    // If it's a rejected response, throw appropriate error
+    if (isUserResponse(result) && result.status === walletStandard.UserResponseStatus.REJECTED) {
+        throw new utils.DynamicError('User rejected connection request');
+    }
+    throw new utils.DynamicError('Invalid wallet-standard connection response');
+};
+
+exports.parseConnectionResult = parseConnectionResult;