@dynamic-labs/aptos 4.39.0 → 4.40.1

package/src/walletStandard/createAptosSignerFromWalletStandard.js

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

package/src/walletStandard/getConnectorConstructorForWalletStandardWallet.cjs

@@ -0,0 +1,31 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var InjectedWalletBase = require('../injected/InjectedWalletBase.cjs');
+var createAptosSignerFromWalletStandard = require('./createAptosSignerFromWalletStandard.cjs');
+
+const getConnectorConstructorForWalletStandardWallet = (wallet, walletBookMetadata = {}) => {
+    const sanitizedName = utils.sanitizeName(wallet.name);
+    return class extends InjectedWalletBase.InjectedWalletBase {
+        constructor(props) {
+            super(wallet.name, Object.assign(Object.assign({}, props), { metadata: Object.assign(Object.assign({}, walletBookMetadata), { groupKey: sanitizedName, icon: wallet.icon, id: sanitizedName, name: wallet.name }) }));
+            this.name = wallet.name;
+            this.overrideKey = `${sanitizedName}aptos`;
+            this._provider = createAptosSignerFromWalletStandard.createAptosSignerFromWalletStandard({
+                wallet,
+                walletConnector: this,
+            });
+        }
+        findProvider() {
+            return this._provider;
+        }
+        getProvider() {
+            return this._provider;
+        }
+    };
+};
+
+exports.getConnectorConstructorForWalletStandardWallet = getConnectorConstructorForWalletStandardWallet;

package/src/walletStandard/getConnectorConstructorForWalletStandardWallet.d.ts

@@ -0,0 +1,3 @@
+import { Wallet } from '@aptos-labs/wallet-standard';
+import { WalletConnectorConstructor, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+export declare const getConnectorConstructorForWalletStandardWallet: (wallet: Wallet, walletBookMetadata?: Partial<WalletMetadata>) => WalletConnectorConstructor;

package/src/walletStandard/getConnectorConstructorForWalletStandardWallet.js

@@ -0,0 +1,27 @@
+'use client'
+import { sanitizeName } from '@dynamic-labs/utils';
+import { InjectedWalletBase } from '../injected/InjectedWalletBase.js';
+import { createAptosSignerFromWalletStandard } from './createAptosSignerFromWalletStandard.js';
+
+const getConnectorConstructorForWalletStandardWallet = (wallet, walletBookMetadata = {}) => {
+    const sanitizedName = sanitizeName(wallet.name);
+    return class extends InjectedWalletBase {
+        constructor(props) {
+            super(wallet.name, Object.assign(Object.assign({}, props), { metadata: Object.assign(Object.assign({}, walletBookMetadata), { groupKey: sanitizedName, icon: wallet.icon, id: sanitizedName, name: wallet.name }) }));
+            this.name = wallet.name;
+            this.overrideKey = `${sanitizedName}aptos`;
+            this._provider = createAptosSignerFromWalletStandard({
+                wallet,
+                walletConnector: this,
+            });
+        }
+        findProvider() {
+            return this._provider;
+        }
+        getProvider() {
+            return this._provider;
+        }
+    };
+};
+
+export { getConnectorConstructorForWalletStandardWallet };