@dynamic-labs/aptos 4.43.0 → 4.44.1

package/src/injected/fetchInjectedWalletConnectors.js

@@ -73,24 +73,27 @@ const shouldAddWalletStandardConnector = (wallet, walletBook) => {
  * 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
+ * 1. Wallet book entries - All Aptos wallets defined in the wallet book (including uninstalled wallet-standard wallets)
+ * 2. Wallet-standard wallets - AIP-62 compliant wallets discovered via wallet-standard (installed wallets only)
+ *
+ * The function creates connectors for:
+ * - Installed wallet-standard wallets (discovered via wallet-standard)
+ * - Uninstalled wallet-standard wallets (from wallet book, will use wallet-standard when installed)
+ * - Traditional wallets without wallet-standard support (from wallet book)
  *
  * The function automatically filters out wallets that:
  * - Have custom connector implementations
- * - Are already handled by wallet-standard connectors
+ * - Are already discovered via wallet-standard (to avoid duplicates)
  * - 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
@@ -101,40 +104,15 @@ const shouldAddWalletStandardConnector = (wallet, walletBook) => {
  */
 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
+    // Get wallet-standard wallets (only installed wallets are discovered)
     const { aptosWallets } = getWalletStandardWallets();
+    // Create a map of wallet-standard wallet names for quick lookup
+    const walletStandardWalletNames = new Set(aptosWallets.map((wallet) => wallet.name));
     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
+    // Create connectors for installed wallet-standard wallets
     const walletStandardConnectors = aptosWallets
         .filter((wallet) => 
     // Type incompatibility between @wallet-standard versions, casting is safe here
@@ -156,6 +134,46 @@ const fetchInjectedWalletConnectors = ({ walletBook, }) => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         wallet, walletBookMetadata);
     });
+    // Get wallet book connectors for ALL Aptos wallets
+    // This includes:
+    // 1. Traditional wallets (no wallet-standard support)
+    // 2. Wallet-standard wallets that are NOT yet installed (discovered via wallet book)
+    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;
+        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
+        const needsCustomConnector = walletsWithCustomConnectors.includes(key);
+        // Filter out wallets that are already discovered via wallet-standard (installed)
+        // We want to show uninstalled wallet-standard wallets from wallet book
+        const walletStandardName = (_b = injectedConfig === null || injectedConfig === void 0 ? void 0 : injectedConfig.walletStandard) === null || _b === void 0 ? void 0 : _b.name;
+        const isAlreadyDiscoveredViaWalletStandard = walletStandardName && walletStandardWalletNames.has(walletStandardName);
+        return (isAptosWallet &&
+            !needsCustomConnector &&
+            !isAlreadyDiscoveredViaWalletStandard);
+    })
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        // Get wallet metadata from wallet book
+        const walletBookMetadata = getWalletMetadataFromWalletBook({
+            walletBook,
+            walletBookWallet: wallet,
+            walletKey: key,
+        });
+        return class extends InjectedWalletBase {
+            constructor(props) {
+                super(name, Object.assign(Object.assign({}, props), { aptosNetworks: props.aptosNetworks, metadata: walletBookMetadata, walletBook: props.walletBook }));
+                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();
+            }
+        };
+    });
     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 [

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 { GenericNetwork } from '@dynamic-labs/types';
 import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
 /**
  * Interface for AIP-62 compliant Aptos wallet providers.
@@ -123,6 +124,8 @@ export interface AptosWalletConnectorProps {
     walletBook: any;
     /** Wallet metadata */
     metadata?: any;
+    /** Aptos networks */
+    aptosNetworks?: GenericNetwork[];
 }
 export type AptosFeatureName = keyof NonNullable<IAptosProvider['features']>;
 export type AptosMethodName = 'connect' | 'disconnect' | 'signTransaction' | 'signMessage' | 'signAndSubmitTransaction' | 'submitTransaction' | 'getNetwork' | 'network' | 'account' | 'onAccountChange' | 'onNetworkChange';

package/src/utils/AptosUiTransaction/AptosUiTransaction.cjs

@@ -0,0 +1,189 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var constants = require('../constants/constants.cjs');
+
+/**
+ * Aptos UI Transaction class for managing Aptos transactions in the UI.
+ *
+ * This class implements the IUITransaction interface and provides Aptos-specific
+ * functionality for creating, formatting, and submitting transactions.
+ */
+class AptosUiTransaction {
+    constructor({ onSubmit, from, client }) {
+        this.chain = 'APTOS';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        /**
+         * Formats a non-native token value back to a string
+         *
+         * @param value - The value as bigint
+         * @param decimals - The number of decimals for the token
+         * @returns The formatted amount as string
+         */
+        this.formatNonNativeToken = (value, decimals) => (Number(value) / Number(Math.pow(10, decimals))).toString();
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.client = client;
+    }
+    /**
+     * Fetches the gas fee for the transaction.
+     *
+     * Note: Aptos gas fees are typically fixed or very low, so we set a default
+     * estimate. In the future, this could be enhanced with actual gas estimation.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            const transaction = yield this.createTransactionSafe();
+            if (!transaction) {
+                throw new Error('Could not create a valid Aptos transaction, check your address and value');
+            }
+            // Aptos has a simple gas model. For now, we'll use a default estimate.
+            // In the future, this could use the client to simulate the transaction.
+            // Typical Aptos transactions cost around 100-1000 octas (0.0000001 - 0.000001 APT)
+            // We'll use a conservative estimate of 1000 octas
+            this.fee.gas = BigInt(1000);
+        });
+    }
+    isGasSponsored() {
+        return false;
+    }
+    /**
+     * Parses a string amount into bigint octas (APT smallest unit, 1e8)
+     *
+     * @param input - The amount as a string (e.g., "1.5")
+     * @returns The amount in octas as bigint
+     */
+    parse(input) {
+        const floatValue = parseFloat(input);
+        const octas = Math.round(floatValue * constants.OCTAS_PER_APT);
+        return BigInt(octas);
+    }
+    /**
+     * Parses a non-native token amount with custom decimals
+     *
+     * @param input - The amount as a string
+     * @param decimals - The number of decimals for the token
+     * @returns The amount as bigint
+     */
+    parseNonNativeToken(input, decimals) {
+        return BigInt(Math.floor(Number(input) * Math.pow(10, decimals)));
+    }
+    /**
+     * Formats a bigint value (in octas) to a human-readable APT string
+     *
+     * @param value - The value in octas
+     * @param options - Formatting options including precision
+     * @returns The formatted amount as string
+     */
+    format(value, { precision } = {}) {
+        const aptValue = Number(value) / constants.OCTAS_PER_APT;
+        const decimalString = aptValue.toLocaleString('fullwide', {
+            maximumFractionDigits: 20,
+            minimumFractionDigits: 0,
+            useGrouping: false,
+        });
+        return utils.formatNumberText(decimalString, { precision });
+    }
+    /**
+     * Submits the transaction by creating it and calling onSubmit
+     *
+     * @returns The transaction hash from onSubmit
+     */
+    submit() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const sendTransaction = (yield this.createTransaction());
+            return this.onSubmit(sendTransaction);
+        });
+    }
+    /**
+     * Gets the balance of the sender's account in octas
+     *
+     * @returns The balance as bigint in octas
+     */
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.client.getBalance({
+                accountAddress: this.from,
+                // APT coin type
+                asset: '0x1::aptos_coin::AptosCoin',
+            });
+            // Balance comes back as a number in octas (1e8 octas = 1 APT)
+            return BigInt(Math.floor(balance));
+        });
+    }
+    /**
+     * Validates that an address is a valid Aptos address format
+     *
+     * Aptos addresses are 64-character hex strings prefixed with 0x (66 chars total)
+     *
+     * @param address - The address to validate
+     * @returns true if the address format is valid
+     */
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        // Aptos addresses are 0x followed by 64 hex characters
+        return /^0x[0-9a-fA-F]{64}$/.test(address);
+    }
+    /**
+     * Creates a transaction payload for sending APT or tokens
+     *
+     * @returns The transaction payload or undefined if invalid
+     */
+    createTransaction() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const { value, to, nonNativeAddress, nonNativeValue } = this;
+            if (!to) {
+                throw new Error('Destination is required');
+            }
+            if (!value && !nonNativeValue) {
+                return undefined;
+            }
+            // Create the transaction payload
+            if (nonNativeAddress && nonNativeValue) {
+                // Transfer non-native token
+                return {
+                    function: '0x1::coin::transfer',
+                    functionArguments: [to, nonNativeValue],
+                    typeArguments: [nonNativeAddress],
+                };
+            }
+            if (value) {
+                // Transfer native APT
+                return {
+                    function: '0x1::coin::transfer',
+                    functionArguments: [to, value],
+                    typeArguments: ['0x1::aptos_coin::AptosCoin'],
+                };
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Safely creates a transaction, returning undefined on error
+     *
+     * @returns The transaction payload or undefined if creation fails
+     */
+    createTransactionSafe() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.createTransaction();
+            }
+            catch (error) {
+                return undefined;
+            }
+        });
+    }
+}
+
+exports.AptosUiTransaction = AptosUiTransaction;

package/src/utils/AptosUiTransaction/AptosUiTransaction.d.ts

@@ -0,0 +1,110 @@
+import type { InputGenerateTransactionPayloadData } from '@aptos-labs/ts-sdk';
+import { Aptos } from '@aptos-labs/ts-sdk';
+import { IUITransaction, IUITransactionFormatOptions } from '@dynamic-labs/types';
+type AptosUiTransactionProps = {
+    /** Aptos Address of the sender */
+    from: string;
+    /** The [Aptos] client instance, needed to estimate gas fees and get balance */
+    client: Aptos;
+    /** The function to call when the transaction is submitted */
+    onSubmit: (transaction?: InputGenerateTransactionPayloadData) => Promise<any>;
+};
+/**
+ * Aptos UI Transaction class for managing Aptos transactions in the UI.
+ *
+ * This class implements the IUITransaction interface and provides Aptos-specific
+ * functionality for creating, formatting, and submitting transactions.
+ */
+export declare class AptosUiTransaction implements IUITransaction {
+    to: string | undefined;
+    from: string;
+    value: bigint | undefined;
+    chain: string;
+    receipt: string | undefined;
+    data: undefined;
+    fee: {
+        gas: bigint | undefined;
+    };
+    nonNativeAddress?: string;
+    nonNativeDecimal?: number;
+    nonNativeValue?: bigint;
+    nativePrice?: number;
+    private onSubmit;
+    private client;
+    constructor({ onSubmit, from, client }: AptosUiTransactionProps);
+    /**
+     * Fetches the gas fee for the transaction.
+     *
+     * Note: Aptos gas fees are typically fixed or very low, so we set a default
+     * estimate. In the future, this could be enhanced with actual gas estimation.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee(): Promise<void>;
+    isGasSponsored(): boolean;
+    /**
+     * Parses a string amount into bigint octas (APT smallest unit, 1e8)
+     *
+     * @param input - The amount as a string (e.g., "1.5")
+     * @returns The amount in octas as bigint
+     */
+    parse(input: string): bigint;
+    /**
+     * Parses a non-native token amount with custom decimals
+     *
+     * @param input - The amount as a string
+     * @param decimals - The number of decimals for the token
+     * @returns The amount as bigint
+     */
+    parseNonNativeToken(input: string, decimals: number): bigint;
+    /**
+     * Formats a non-native token value back to a string
+     *
+     * @param value - The value as bigint
+     * @param decimals - The number of decimals for the token
+     * @returns The formatted amount as string
+     */
+    formatNonNativeToken: (value: bigint, decimals: number) => string;
+    /**
+     * Formats a bigint value (in octas) to a human-readable APT string
+     *
+     * @param value - The value in octas
+     * @param options - Formatting options including precision
+     * @returns The formatted amount as string
+     */
+    format(value: bigint, { precision }?: IUITransactionFormatOptions): string;
+    /**
+     * Submits the transaction by creating it and calling onSubmit
+     *
+     * @returns The transaction hash from onSubmit
+     */
+    submit(): Promise<any>;
+    /**
+     * Gets the balance of the sender's account in octas
+     *
+     * @returns The balance as bigint in octas
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Validates that an address is a valid Aptos address format
+     *
+     * Aptos addresses are 64-character hex strings prefixed with 0x (66 chars total)
+     *
+     * @param address - The address to validate
+     * @returns true if the address format is valid
+     */
+    validateAddressFormat(address: string): boolean;
+    /**
+     * Creates a transaction payload for sending APT or tokens
+     *
+     * @returns The transaction payload or undefined if invalid
+     */
+    private createTransaction;
+    /**
+     * Safely creates a transaction, returning undefined on error
+     *
+     * @returns The transaction payload or undefined if creation fails
+     */
+    private createTransactionSafe;
+}
+export {};

package/src/utils/AptosUiTransaction/AptosUiTransaction.js

@@ -0,0 +1,185 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { formatNumberText } from '@dynamic-labs/utils';
+import { OCTAS_PER_APT } from '../constants/constants.js';
+
+/**
+ * Aptos UI Transaction class for managing Aptos transactions in the UI.
+ *
+ * This class implements the IUITransaction interface and provides Aptos-specific
+ * functionality for creating, formatting, and submitting transactions.
+ */
+class AptosUiTransaction {
+    constructor({ onSubmit, from, client }) {
+        this.chain = 'APTOS';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        /**
+         * Formats a non-native token value back to a string
+         *
+         * @param value - The value as bigint
+         * @param decimals - The number of decimals for the token
+         * @returns The formatted amount as string
+         */
+        this.formatNonNativeToken = (value, decimals) => (Number(value) / Number(Math.pow(10, decimals))).toString();
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.client = client;
+    }
+    /**
+     * Fetches the gas fee for the transaction.
+     *
+     * Note: Aptos gas fees are typically fixed or very low, so we set a default
+     * estimate. In the future, this could be enhanced with actual gas estimation.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            const transaction = yield this.createTransactionSafe();
+            if (!transaction) {
+                throw new Error('Could not create a valid Aptos transaction, check your address and value');
+            }
+            // Aptos has a simple gas model. For now, we'll use a default estimate.
+            // In the future, this could use the client to simulate the transaction.
+            // Typical Aptos transactions cost around 100-1000 octas (0.0000001 - 0.000001 APT)
+            // We'll use a conservative estimate of 1000 octas
+            this.fee.gas = BigInt(1000);
+        });
+    }
+    isGasSponsored() {
+        return false;
+    }
+    /**
+     * Parses a string amount into bigint octas (APT smallest unit, 1e8)
+     *
+     * @param input - The amount as a string (e.g., "1.5")
+     * @returns The amount in octas as bigint
+     */
+    parse(input) {
+        const floatValue = parseFloat(input);
+        const octas = Math.round(floatValue * OCTAS_PER_APT);
+        return BigInt(octas);
+    }
+    /**
+     * Parses a non-native token amount with custom decimals
+     *
+     * @param input - The amount as a string
+     * @param decimals - The number of decimals for the token
+     * @returns The amount as bigint
+     */
+    parseNonNativeToken(input, decimals) {
+        return BigInt(Math.floor(Number(input) * Math.pow(10, decimals)));
+    }
+    /**
+     * Formats a bigint value (in octas) to a human-readable APT string
+     *
+     * @param value - The value in octas
+     * @param options - Formatting options including precision
+     * @returns The formatted amount as string
+     */
+    format(value, { precision } = {}) {
+        const aptValue = Number(value) / OCTAS_PER_APT;
+        const decimalString = aptValue.toLocaleString('fullwide', {
+            maximumFractionDigits: 20,
+            minimumFractionDigits: 0,
+            useGrouping: false,
+        });
+        return formatNumberText(decimalString, { precision });
+    }
+    /**
+     * Submits the transaction by creating it and calling onSubmit
+     *
+     * @returns The transaction hash from onSubmit
+     */
+    submit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sendTransaction = (yield this.createTransaction());
+            return this.onSubmit(sendTransaction);
+        });
+    }
+    /**
+     * Gets the balance of the sender's account in octas
+     *
+     * @returns The balance as bigint in octas
+     */
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.client.getBalance({
+                accountAddress: this.from,
+                // APT coin type
+                asset: '0x1::aptos_coin::AptosCoin',
+            });
+            // Balance comes back as a number in octas (1e8 octas = 1 APT)
+            return BigInt(Math.floor(balance));
+        });
+    }
+    /**
+     * Validates that an address is a valid Aptos address format
+     *
+     * Aptos addresses are 64-character hex strings prefixed with 0x (66 chars total)
+     *
+     * @param address - The address to validate
+     * @returns true if the address format is valid
+     */
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        // Aptos addresses are 0x followed by 64 hex characters
+        return /^0x[0-9a-fA-F]{64}$/.test(address);
+    }
+    /**
+     * Creates a transaction payload for sending APT or tokens
+     *
+     * @returns The transaction payload or undefined if invalid
+     */
+    createTransaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { value, to, nonNativeAddress, nonNativeValue } = this;
+            if (!to) {
+                throw new Error('Destination is required');
+            }
+            if (!value && !nonNativeValue) {
+                return undefined;
+            }
+            // Create the transaction payload
+            if (nonNativeAddress && nonNativeValue) {
+                // Transfer non-native token
+                return {
+                    function: '0x1::coin::transfer',
+                    functionArguments: [to, nonNativeValue],
+                    typeArguments: [nonNativeAddress],
+                };
+            }
+            if (value) {
+                // Transfer native APT
+                return {
+                    function: '0x1::coin::transfer',
+                    functionArguments: [to, value],
+                    typeArguments: ['0x1::aptos_coin::AptosCoin'],
+                };
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Safely creates a transaction, returning undefined on error
+     *
+     * @returns The transaction payload or undefined if creation fails
+     */
+    createTransactionSafe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.createTransaction();
+            }
+            catch (error) {
+                return undefined;
+            }
+        });
+    }
+}
+
+export { AptosUiTransaction };

package/src/utils/AptosUiTransaction/index.d.ts

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

package/src/utils/constants/constants.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const OCTAS_PER_APT = 1e8;
+
+exports.OCTAS_PER_APT = OCTAS_PER_APT;

package/src/utils/constants/constants.d.ts

@@ -0,0 +1 @@
+export declare const OCTAS_PER_APT = 100000000;

package/src/utils/constants/constants.js

@@ -0,0 +1,4 @@
+'use client'
+const OCTAS_PER_APT = 1e8;
+
+export { OCTAS_PER_APT };

package/src/utils/constants/index.d.ts

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

package/src/wallet/AptosWallet.cjs

@@ -57,15 +57,12 @@ class AptosWallet extends walletConnectorCore.Wallet {
                 // 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);
+                const txHash = yield this.signAndSubmitTransaction({
+                    function: '0x1::coin::transfer',
+                    functionArguments: [toAddress, transferAmount],
+                    typeArguments: ['0x1::aptos_coin::AptosCoin'],
+                });
                 return txHash;
             }
             catch (error) {