@dynamic-labs/aptos 4.38.0 → 4.40.0

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;

package/src/utils/parseConnectionResult/parseConnectionResult.d.ts

@@ -1,18 +1,15 @@
 import type { AccountInfo } from '@aptos-labs/wallet-standard';
 import type { AptosConnectionResult } from '../../types';
 /**
- * Parsed account information that may be a full AccountInfo or minimal account data
+ * Parsed account information from wallet-standard response
  */
-export type ParsedAccountInfo = AccountInfo | {
-    address: string;
-    publicKey?: string | Uint8Array;
-};
+export type ParsedAccountInfo = AccountInfo;
 /**
- * Parses wallet connection result into account information.
- * Handles different response formats from wallet-standard and injected providers.
+ * Parses wallet-standard connection result into AccountInfo.
+ * Only handles AIP-62 compliant wallet-standard responses.
  *
- * @param result - Connection result matching AptosConnectionResult format
- * @returns Parsed account information (full AccountInfo or minimal account data)
- * @throws {DynamicError} When result format is not supported
+ * @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
  */
 export declare const parseConnectionResult: (result: AptosConnectionResult) => ParsedAccountInfo;

package/src/utils/parseConnectionResult/parseConnectionResult.js

@@ -0,0 +1,36 @@
+'use client'
+import { UserResponseStatus } from '@aptos-labs/wallet-standard';
+import { DynamicError } from '@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(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 === UserResponseStatus.APPROVED) {
+        return result.args;
+    }
+    // If it's a rejected response, throw appropriate error
+    if (isUserResponse(result) && result.status === UserResponseStatus.REJECTED) {
+        throw new DynamicError('User rejected connection request');
+    }
+    throw new DynamicError('Invalid wallet-standard connection response');
+};
+
+export { parseConnectionResult };

package/src/utils/parseTransactionResponse/parseTransactionResponse.cjs

@@ -0,0 +1,53 @@
+'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 hash in args
+ */
+const isUserResponseWithHash = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const candidate = obj;
+    // Must have status and args properties
+    if (!('status' in candidate) ||
+        !('args' in candidate) ||
+        !Object.values(walletStandard.UserResponseStatus).includes(candidate.status)) {
+        return false;
+    }
+    // Args must be an object with a valid hash string
+    const { args } = candidate;
+    if (typeof args !== 'object' || args === null)
+        return false;
+    const argsObj = args;
+    return ('hash' in argsObj &&
+        typeof argsObj.hash === 'string' &&
+        argsObj.hash.length > 0);
+};
+/**
+ * Parses wallet-standard transaction response into a transaction hash.
+ * Only handles AIP-62 compliant wallet-standard responses.
+ *
+ * @param response - Transaction response from wallet-standard (UserResponse<{hash: string}>)
+ * @returns Transaction hash as string
+ * @throws {DynamicError} When response format is not supported or user rejected
+ */
+const parseTransactionResponse = (response) => {
+    // Handle wallet-standard UserResponse format (only format we support)
+    if (isUserResponseWithHash(response) &&
+        response.status === walletStandard.UserResponseStatus.APPROVED) {
+        return response.args.hash;
+    }
+    // If it's a rejected response, throw appropriate error
+    if (isUserResponseWithHash(response) &&
+        response.status === walletStandard.UserResponseStatus.REJECTED) {
+        throw new utils.DynamicError('User rejected transaction');
+    }
+    throw new utils.DynamicError('Invalid wallet-standard transaction response');
+};
+
+exports.parseTransactionResponse = parseTransactionResponse;

package/src/utils/parseTransactionResponse/parseTransactionResponse.d.ts

@@ -1,8 +1,8 @@
 /**
- * Parses transaction response from different wallet providers into a transaction hash.
- * Handles various response formats from wallet-standard and injected providers.
+ * Parses wallet-standard transaction response into a transaction hash.
+ * Only handles AIP-62 compliant wallet-standard responses.
  *
- * @param response - Transaction response from wallet
+ * @param response - Transaction response from wallet-standard (UserResponse<{hash: string}>)
  * @returns Transaction hash as string
  * @throws {DynamicError} When response format is not supported or user rejected
  */

package/src/utils/parseTransactionResponse/parseTransactionResponse.js

@@ -0,0 +1,49 @@
+'use client'
+import { UserResponseStatus } from '@aptos-labs/wallet-standard';
+import { DynamicError } from '@dynamic-labs/utils';
+
+/**
+ * Type guard to check if an object is a UserResponse with hash in args
+ */
+const isUserResponseWithHash = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const candidate = obj;
+    // Must have status and args properties
+    if (!('status' in candidate) ||
+        !('args' in candidate) ||
+        !Object.values(UserResponseStatus).includes(candidate.status)) {
+        return false;
+    }
+    // Args must be an object with a valid hash string
+    const { args } = candidate;
+    if (typeof args !== 'object' || args === null)
+        return false;
+    const argsObj = args;
+    return ('hash' in argsObj &&
+        typeof argsObj.hash === 'string' &&
+        argsObj.hash.length > 0);
+};
+/**
+ * Parses wallet-standard transaction response into a transaction hash.
+ * Only handles AIP-62 compliant wallet-standard responses.
+ *
+ * @param response - Transaction response from wallet-standard (UserResponse<{hash: string}>)
+ * @returns Transaction hash as string
+ * @throws {DynamicError} When response format is not supported or user rejected
+ */
+const parseTransactionResponse = (response) => {
+    // Handle wallet-standard UserResponse format (only format we support)
+    if (isUserResponseWithHash(response) &&
+        response.status === UserResponseStatus.APPROVED) {
+        return response.args.hash;
+    }
+    // If it's a rejected response, throw appropriate error
+    if (isUserResponseWithHash(response) &&
+        response.status === UserResponseStatus.REJECTED) {
+        throw new DynamicError('User rejected transaction');
+    }
+    throw new DynamicError('Invalid wallet-standard transaction response');
+};
+
+export { parseTransactionResponse };

package/src/wallet/AptosWallet.cjs

@@ -0,0 +1,138 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+/**
+ * Aptos wallet implementation that provides chain-specific functionality
+ * for interacting with the Aptos blockchain.
+ *
+ * This class extends the base Wallet class and provides Aptos-specific
+ * methods for transactions, signing, and network operations.
+ */
+class AptosWallet extends walletConnectorCore.Wallet {
+    /**
+     * Sends balance to another address.
+     * @param amount - Amount to send (in APT for native transfers)
+     * @param toAddress - Recipient address
+     * @param token - Optional token information for non-APT transfers
+     * @returns Transaction hash
+     */
+    sendBalance(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ amount, toAddress, token, }) {
+            yield this._connector.connect();
+            // Get the Aptos client to create the transaction
+            const aptosClient = yield this.getAptosClient();
+            if (!aptosClient) {
+                throw new Error('Aptos client not available');
+            }
+            // Get current account info
+            const accountInfo = yield this.getAccountInfo();
+            if (!accountInfo) {
+                throw new Error('No account connected');
+            }
+            try {
+                // Calculate amount with proper decimals (APT has 8 decimals by default)
+                const decimals = (token === null || token === void 0 ? void 0 : token.decimals) || 8;
+                const transferAmount = parseFloat(amount) * Math.pow(10, decimals);
+                // Create the transfer transaction
+                const transaction = yield aptosClient.transferCoinTransaction({
+                    amount: transferAmount,
+                    coinType: token === null || token === void 0 ? void 0 : token.address,
+                    recipient: toAddress,
+                    sender: accountInfo.address, // If undefined, defaults to APT (0x1::aptos_coin::AptosCoin)
+                });
+                // Sign and submit the transaction using the wallet provider
+                const txHash = yield this.signAndSubmitTransaction(transaction);
+                return txHash;
+            }
+            catch (error) {
+                throw new Error(`Failed to send balance: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        });
+    }
+    /**
+     * Returns the Aptos client configured for the wallet's current network.
+     *
+     * @returns The Aptos client instance or undefined if not available
+     */
+    getAptosClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getAptosClient();
+        });
+    }
+    /**
+     * Returns the wallet's current account information.
+     *
+     * @returns The current account info or undefined if not connected
+     */
+    getAccountInfo() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getAccountInfo();
+        });
+    }
+    /**
+     * Returns the wallet's current network information.
+     *
+     * @returns The current network info or undefined if not available
+     */
+    getNetworkInfo() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getNetworkInfo();
+        });
+    }
+    /**
+     * Signs a transaction for the Aptos blockchain.
+     *
+     * @param transaction - The transaction to sign
+     * @param asFeePayer - Whether to sign as fee payer (optional)
+     * @returns The signed transaction or user response
+     */
+    signTransaction(transaction, asFeePayer) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this._connector.connect();
+            return this._connector.signTransaction(transaction, asFeePayer);
+        });
+    }
+    /**
+     * Signs a message for authentication purposes.
+     *
+     * @param input - The message signing input parameters
+     * @returns The signature result or user response
+     */
+    signAptosMessage(input) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this._connector.connect();
+            return this._connector.signAptosMessage(input);
+        });
+    }
+    /**
+     * Signs and submits a transaction to the Aptos network.
+     *
+     * @param transaction - The transaction to sign and submit
+     * @returns The transaction hash
+     */
+    signAndSubmitTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this._connector.connect();
+            return this._connector.signAndSubmitTransaction(transaction);
+        });
+    }
+    /**
+     * Submits a pre-signed transaction to the network.
+     *
+     * @param signedTransaction - The signed transaction to submit
+     * @returns The transaction hash
+     */
+    submitTransaction(signedTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this._connector.connect();
+            return this._connector.submitTransaction(signedTransaction);
+        });
+    }
+}
+
+exports.AptosWallet = AptosWallet;

package/src/wallet/AptosWallet.d.ts

@@ -0,0 +1,76 @@
+import type { AccountAuthenticator, AnyRawTransaction } from '@aptos-labs/ts-sdk';
+import { Aptos } from '@aptos-labs/ts-sdk';
+import type { AccountInfo, AptosSignMessageInput, AptosSignMessageOutput, NetworkInfo, UserResponse } from '@aptos-labs/wallet-standard';
+import { Wallet } from '@dynamic-labs/wallet-connector-core';
+import type { AptosWalletConnector } from '../connectors/AptosWalletConnector/AptosWalletConnector';
+/**
+ * Aptos wallet implementation that provides chain-specific functionality
+ * for interacting with the Aptos blockchain.
+ *
+ * This class extends the base Wallet class and provides Aptos-specific
+ * methods for transactions, signing, and network operations.
+ */
+export declare class AptosWallet extends Wallet<AptosWalletConnector> {
+    /**
+     * Sends balance to another address.
+     * @param amount - Amount to send (in APT for native transfers)
+     * @param toAddress - Recipient address
+     * @param token - Optional token information for non-APT transfers
+     * @returns Transaction hash
+     */
+    sendBalance({ amount, toAddress, token, }: {
+        amount: string;
+        toAddress: string;
+        token?: {
+            address: string;
+            decimals?: number;
+        };
+    }): Promise<string>;
+    /**
+     * Returns the Aptos client configured for the wallet's current network.
+     *
+     * @returns The Aptos client instance or undefined if not available
+     */
+    getAptosClient(): Promise<Aptos | undefined>;
+    /**
+     * Returns the wallet's current account information.
+     *
+     * @returns The current account info or undefined if not connected
+     */
+    getAccountInfo(): Promise<AccountInfo | undefined>;
+    /**
+     * Returns the wallet's current network information.
+     *
+     * @returns The current network info or undefined if not available
+     */
+    getNetworkInfo(): Promise<NetworkInfo | undefined>;
+    /**
+     * Signs a transaction for the Aptos blockchain.
+     *
+     * @param transaction - The transaction to sign
+     * @param asFeePayer - Whether to sign as fee payer (optional)
+     * @returns The signed transaction or user response
+     */
+    signTransaction(transaction: AnyRawTransaction, asFeePayer?: boolean): Promise<UserResponse<AccountAuthenticator> | AccountAuthenticator>;
+    /**
+     * Signs a message for authentication purposes.
+     *
+     * @param input - The message signing input parameters
+     * @returns The signature result or user response
+     */
+    signAptosMessage(input: AptosSignMessageInput): Promise<UserResponse<AptosSignMessageOutput> | AptosSignMessageOutput>;
+    /**
+     * Signs and submits a transaction to the Aptos network.
+     *
+     * @param transaction - The transaction to sign and submit
+     * @returns The transaction hash
+     */
+    signAndSubmitTransaction(transaction: AnyRawTransaction): Promise<string>;
+    /**
+     * Submits a pre-signed transaction to the network.
+     *
+     * @param signedTransaction - The signed transaction to submit
+     * @returns The transaction hash
+     */
+    submitTransaction(signedTransaction: AccountAuthenticator): Promise<string>;
+}