@dynamic-labs/aptos 4.37.2 → 4.39.0

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/index.d.ts

@@ -0,0 +1 @@
+export { parseTransactionResponse } from './parseTransactionResponse';

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

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export declare const parseTransactionResponse: (response: unknown) => string;

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>;
+}

package/src/wallet/AptosWallet.js

@@ -0,0 +1,134 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { Wallet } from '@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 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 __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 __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 __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 __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 __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 __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 __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 __awaiter(this, void 0, void 0, function* () {
+            yield this._connector.connect();
+            return this._connector.submitTransaction(signedTransaction);
+        });
+    }
+}
+
+export { AptosWallet };

package/src/wallet/index.d.ts

@@ -0,0 +1 @@
+export { AptosWallet } from './AptosWallet';