@dynamic-labs/solana 4.39.0 → 4.40.1

package/src/walletConnect/SolanaWalletConnectConnector/SolanaWalletConnectConnector.cjs

@@ -0,0 +1,426 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var utils$1 = require('@walletconnect/utils');
+var bs58 = require('bs58');
+var EventEmitter = require('eventemitter3');
+var solanaCore = require('@dynamic-labs/solana-core');
+var utils = require('@dynamic-labs/utils');
+var walletConnect = require('@dynamic-labs/wallet-connect');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var logger = require('../../utils/logger.cjs');
+var createSolanaSignerForWalletConnect = require('./createSolanaSignerForWalletConnect/createSolanaSignerForWalletConnect.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+const WC_SOLANA_CURRENT_CHAIN_KEY = 'dynamic-wc2-solana-current-chain';
+class SolanaWalletConnectConnector extends solanaCore.SolanaWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.activeAccountEmitter = new EventEmitter__default["default"]();
+        this.isInitialized = false;
+        this.canConnectViaQrCode = true;
+        this.isWalletConnect = true;
+        this.canHandleMultipleConnections = false;
+        this.name = opts.walletName;
+        const storedChainId = utils.StorageService.getItem(WC_SOLANA_CURRENT_CHAIN_KEY);
+        if (storedChainId) {
+            this.setNetworkId(storedChainId);
+        }
+        if (opts.overrideKey) {
+            this.overrideKey = opts.overrideKey;
+        }
+        if (!opts.projectId) {
+            throw new utils.DynamicError('WalletConnect project ID is required');
+        }
+    }
+    get deepLinkPreference() {
+        var _a;
+        return (_a = this.constructorProps.deepLinkPreference) !== null && _a !== void 0 ? _a : 'native';
+    }
+    /**
+     * Accesses the sign client singleton instance, and throws if it is not
+     * immediately available.
+     */
+    get signClient() {
+        if (!SolanaWalletConnectConnector.signClientReference) {
+            throw new utils.DynamicError('Failed to access sign client for Wallet Connect Solana: Sign client not initialized');
+        }
+        return SolanaWalletConnectConnector.signClientReference;
+    }
+    getSupportedNetworks() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.session) {
+                return [];
+            }
+            const sessionChains = (_b = (_a = this.session.namespaces.solana) === null || _a === void 0 ? void 0 : _a.chains) !== null && _b !== void 0 ? _b : [];
+            return this.solNetworks
+                .filter((network) => sessionChains.includes(`solana:${network.genesisHash}`))
+                .map((network) => network.chainId.toString());
+        });
+    }
+    getActiveAddress() {
+        var _a, _b;
+        if (!this.session) {
+            return undefined;
+        }
+        return (_b = (_a = this.session.namespaces.solana) === null || _a === void 0 ? void 0 : _a.accounts) === null || _b === void 0 ? void 0 : _b[0].split(':')[2];
+    }
+    listenToActiveAccountChange(listener) {
+        this.activeAccountEmitter.on('activeAccountDidChange', listener);
+        return () => {
+            this.activeAccountEmitter.off('activeAccountDidChange', listener);
+        };
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return createSolanaSignerForWalletConnect.createSolanaSignerForWalletConnect({ walletConnector: this });
+        });
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('Connect method not implemented.');
+        });
+    }
+    init() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized) {
+                return;
+            }
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] init called');
+            this.isInitialized = true;
+            if (SolanaWalletConnectConnector.signClientPromise) {
+                yield SolanaWalletConnectConnector.signClientPromise;
+                this.setupWCEventListeners();
+                return;
+            }
+            const { appLogoUrl, appName, projectId } = this.constructorProps;
+            SolanaWalletConnectConnector.signClientPromise = walletConnect.getSignClientSingleton({
+                appIcon: appLogoUrl !== null && appLogoUrl !== void 0 ? appLogoUrl : '',
+                appName: appName !== null && appName !== void 0 ? appName : '',
+                projectId,
+            });
+            SolanaWalletConnectConnector.signClientReference =
+                yield SolanaWalletConnectConnector.signClientPromise;
+            this.setupWCEventListeners();
+        });
+    }
+    setupWCEventListeners() {
+        logger.logger.debug('[SolanaWalletConnect] setupWCEventListeners');
+        this.signClient.on('session_event', ({ params: { event }, topic }) => {
+            var _a, _b;
+            // Ignore events for wallets other than the one we are connected to
+            if (!this.session || topic !== this.session.topic) {
+                return;
+            }
+            if (event.name === 'chainChanged') {
+                const chainParam = event.data;
+                let chainId = chainParam;
+                // Handle potentially CAIP-2 format
+                if (chainParam.startsWith('solana:')) {
+                    const chainHash = chainParam.split(':')[1];
+                    chainId =
+                        (_b = (_a = this.solNetworks
+                            .find((network) => network.genesisHash === chainHash)) === null || _a === void 0 ? void 0 : _a.networkId.toString()) !== null && _b !== void 0 ? _b : chainParam;
+                }
+                logger.logger.debug('[SolanaWalletConnect] onChainChange', { chainId });
+                if (chainId === this.getNetworkId()) {
+                    logger.logger.debug(`[SolanaWalletConnect] onChainChange - ignoring chainChanged event with same chain id as current chain id: ${chainId}`);
+                    return;
+                }
+                // This will already emit an event so no need to call this.emit('chainChange', { chain: chainId });
+                this.switchNetwork({ networkChainId: parseInt(chainId) });
+                return;
+            }
+            if (event.name === 'accountsChanged') {
+                const accountsParam = event.data;
+                const accounts = utils.filterDuplicates(accountsParam.map((account) => {
+                    // Handle potentially CAIP-10 format
+                    if (account.startsWith('solana:')) {
+                        return account.split(':')[2];
+                    }
+                    return account;
+                }));
+                logger.logger.debug('[SolanaWalletConnect] onAccountChanged', { accounts });
+                this.emit('accountChange', { accounts });
+                return;
+            }
+            if (event.name === 'disconnected') {
+                logger.logger.debug('[SolanaWalletConnect] onDisconnect');
+                this.emit('disconnect');
+                this.endSession();
+                return;
+            }
+        });
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[SolanaWalletConnect] endSession');
+            this.connectionUri = undefined;
+            if (!this.session) {
+                return;
+            }
+            yield this.signClient.disconnect({
+                reason: utils$1.SDK_ERRORS.USER_DISCONNECTED,
+                topic: this.session.topic,
+            });
+            this.session = undefined;
+        });
+    }
+    displayUri(connectionOpts) {
+        if (!this.connectionUri) {
+            return;
+        }
+        logger.logger.debug('[SolanaWalletConnect] handleDisplayURI', this.connectionUri);
+        walletConnectorCore.performPlatformSpecificConnectionMethod(this.connectionUri, this.metadata.deepLinks, {
+            onDesktopUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDesktopUri,
+            onDisplayUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDisplayUri,
+        }, this.deepLinkPreference);
+    }
+    getAddress(opts) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.logger.debug('[SolanaWalletConnect] getAddress', opts);
+            /**
+             * In mobile/Safari, if the user just navigates back after the deeplink prompt the connection
+             * is not rejected, so the previous connection URI is still valid and we can use it to handle the connection
+             */
+            if (this.connectionUri) {
+                logger.logger.debug('[SolanaWalletConnect] getAddress - connecting to WalletConnect with existing connection URI');
+                this.displayUri(opts);
+                return;
+            }
+            /**
+             * If we are already connected to a session, we need to end it first
+             */
+            yield this.endSession();
+            logger.logger.logVerboseTroubleshootingMessage('[WalletConnectConnector] getAddress', {
+                inAppBrowserUrl: (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.inAppBrowserUrl,
+                isMobile: utils.isMobile(),
+                mobileExperience: this.mobileExperience,
+            });
+            const didOpenInAppBrowser = this.openInAppBrowserIfRequired();
+            if (didOpenInAppBrowser) {
+                return;
+            }
+            logger.logger.debug('[SolanaWalletConnect] getAddress - connecting to WalletConnect');
+            const chains = this.solNetworks.map((network) => `solana:${network.genesisHash}`);
+            try {
+                const { approval, uri } = yield this.signClient.connect({
+                    optionalNamespaces: {
+                        solana: {
+                            chains,
+                            events: ['chainChanged', 'accountsChanged', 'disconnected'],
+                            methods: [
+                                'solana_signMessage',
+                                'solana_signTransaction',
+                                'solana_requestAccounts',
+                                'solana_getAccounts',
+                                'solana_signAllTransactions',
+                                'solana_signAndSendTransaction',
+                            ],
+                        },
+                    },
+                });
+                logger.logger.debug('[SolanaWalletConnect] getAddress - connection URI', uri);
+                this.connectionUri = uri;
+                this.displayUri(opts);
+                this.session = yield approval();
+                const activeAddress = this.getActiveAddress();
+                this.activeAccountEmitter.emit('activeAccountDidChange', activeAddress);
+                return activeAddress;
+            }
+            finally {
+                this.connectionUri = undefined;
+            }
+        });
+    }
+    signClientRequest(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ method, params, }) {
+            var _b, _c;
+            if (!this.session) {
+                throw new utils.DynamicError('Session not initialized. Please connect to a wallet first.');
+            }
+            const chainHash = (_c = (_b = this.getSelectedNetwork()) === null || _b === void 0 ? void 0 : _b.genesisHash) !== null && _c !== void 0 ? _c : this.solNetworks[0].genesisHash;
+            const chainId = `solana:${chainHash}`;
+            try {
+                const requestPromise = this.signClient.request({
+                    chainId,
+                    request: {
+                        method,
+                        params,
+                    },
+                    topic: this.session.topic,
+                });
+                this.deepLinkIfApplicable({ method });
+                return yield requestPromise;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                // If they are throwing a generic error, lets end session to ensure the user will be prompted to reconnect
+                // on the next attempt. This should fix the issue.
+                // Yes their error message has a typo on "occured"
+                if (error.message === 'An error has occured. Please, try again.') {
+                    yield this.endSession();
+                    throw new utils.DynamicError('Wallet connection lost. Please, try again.');
+                }
+                throw error;
+            }
+        });
+    }
+    deepLinkIfApplicable(params) {
+        const methodsThatRequireDeepLink = [
+            'solana_signMessage',
+            'solana_signTransaction',
+            'solana_signAllTransactions',
+            'solana_signAndSendTransaction',
+        ];
+        const deepLink = this.getDeepLink();
+        if (utils.isMobile() &&
+            deepLink &&
+            methodsThatRequireDeepLink.includes(params.method)) {
+            utils.PlatformService.openURL(deepLink);
+        }
+    }
+    signMessage(messageToSign, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] signMessage', messageToSign, options);
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const decodedSignature = yield this.signEncodedMessage(encodedMessage, options);
+            return utils.bufferToBase64(decodedSignature);
+        });
+    }
+    signEncodedMessage(encodedMessage, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] signEncodedMessage', encodedMessage, options);
+            if (options === null || options === void 0 ? void 0 : options.address) {
+                yield this.validateActiveWallet(options.address);
+            }
+            const activeAddress = this.getActiveAddress();
+            if (!activeAddress) {
+                throw new utils.DynamicError('No active address found');
+            }
+            const { signature } = yield this.signClientRequest({
+                method: 'solana_signMessage',
+                params: {
+                    message: bs58__default["default"].encode(encodedMessage),
+                    pubkey: new web3_js.PublicKey(activeAddress).toBase58(),
+                },
+            });
+            return bs58__default["default"].decode(signature);
+        });
+    }
+    serializeTransaction(transaction) {
+        const serialized = transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+        return bs58__default["default"].encode(new Uint8Array(serialized));
+    }
+    signTransaction(transaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const activeAddress = this.getActiveAddress();
+            if (!activeAddress) {
+                throw new utils.DynamicError('Active account address is required');
+            }
+            const serializedTransaction = this.serializeTransaction(transaction);
+            const { transaction: signedTransaction } = yield this.signClientRequest({
+                method: 'solana_signTransaction',
+                params: { transaction: serializedTransaction },
+            });
+            const decodedTransaction = bs58__default["default"].decode(signedTransaction);
+            if (solanaCore.isVersionedTransaction(transaction)) {
+                return web3_js.VersionedTransaction.deserialize(decodedTransaction);
+            }
+            return web3_js.Transaction.from(decodedTransaction);
+        });
+    }
+    signAllTransactions(transactions) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const serializedTransactions = transactions.map(this.serializeTransaction);
+            const { transactions: signedTransactions } = yield this.signClientRequest({
+                method: 'solana_signAllTransactions',
+                params: { transactions: serializedTransactions },
+            });
+            return signedTransactions.map((signedTransaction, index) => {
+                const originalTransaction = transactions[index];
+                const decodedTransaction = bs58__default["default"].decode(signedTransaction);
+                if (solanaCore.isVersionedTransaction(originalTransaction)) {
+                    return web3_js.VersionedTransaction.deserialize(decodedTransaction);
+                }
+                return web3_js.Transaction.from(decodedTransaction);
+            });
+        });
+    }
+    signAndSendTransaction(transaction, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const serializedTransaction = this.serializeTransaction(transaction);
+            const { signature } = yield this.signClientRequest({
+                method: 'solana_signAndSendTransaction',
+                params: { options, transaction: serializedTransaction },
+            });
+            return signature;
+        });
+    }
+    getDeepLink() {
+        const deepLink = walletConnectorCore.getDeepLink({
+            deepLinks: this.metadata.deepLinks,
+            mode: 'regular',
+            preference: this.deepLinkPreference,
+            // TODO: verify whether we need the uri
+            // uri: provider.signer.uri,
+        });
+        logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] getDeepLink - deepLink', deepLink);
+        if (!deepLink) {
+            return;
+        }
+        if (this.session) {
+            // we need to include the session topic here because it helps the wallet
+            // auto redirect back to the dapp after signing
+            return `${deepLink}?sessionTopic=${this.session.topic}`;
+        }
+        return deepLink;
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            /**
+             * Each session has a single account (it might be on multiple chains hence the array),
+             * but that account is stored as a CAIP-10 string, so we need to parse it to get the address
+             */
+            const account = this.getActiveAddress();
+            if (!account) {
+                return [];
+            }
+            logger.logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] getConnectedAccounts - activeAccounts', [account]);
+            return [account];
+        });
+    }
+    getConnectionUri() {
+        return this.connectionUri;
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[SolanaWalletConnect] validateActiveWallet - validating wallet', expectedAddress);
+            const [activeAddress] = yield this.getConnectedAccounts();
+            const isWalletActive = walletConnectorCore.isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (isWalletActive) {
+                logger.logger.debug('[SolanaWalletConnect] validateActiveWallet - wallet is active');
+                return;
+            }
+            return this.handleWalletNotActive({
+                activeAddress,
+                expectedAddress,
+            });
+        });
+    }
+}
+
+exports.SolanaWalletConnectConnector = SolanaWalletConnectConnector;

package/src/walletConnect/SolanaWalletConnectConnector/SolanaWalletConnectConnector.d.ts

@@ -0,0 +1,64 @@
+import { SendOptions, Transaction, VersionedTransaction } from '@solana/web3.js';
+import SignClient from '@walletconnect/sign-client';
+import type { SessionTypes } from '@walletconnect/types';
+import { ISolanaSigner, SolanaWalletConnector, SolanaWalletConnectorOpts } from '@dynamic-labs/solana-core';
+import { DeepLinkVariant, GetAddressOpts, IWalletConnectConnector } from '@dynamic-labs/wallet-connector-core';
+export type SolanaWalletConnectConnectorOpts = SolanaWalletConnectorOpts & {
+    projectId?: string;
+    walletName: string;
+    deepLinkPreference?: DeepLinkVariant;
+    appLogoUrl?: string;
+    appName?: string;
+    overrideKey?: string;
+};
+export declare class SolanaWalletConnectConnector extends SolanaWalletConnector implements IWalletConnectConnector {
+    name: string;
+    static signClientReference: SignClient | undefined;
+    static signClientPromise: Promise<SignClient> | undefined;
+    /**
+     * When a WalletConnect connection is initiated, we store the connection URI
+     * so we can use it to handle the URI for wallet app connection and still have
+     * it if we need it again before the connection is established (for instance,
+     * when a user navigates back to the dapp after a deeplink and then attempts to deeplink again)
+     */
+    private connectionUri;
+    session: SessionTypes.Struct | undefined;
+    private activeAccountEmitter;
+    isInitialized: boolean;
+    canConnectViaQrCode: boolean;
+    isWalletConnect: boolean;
+    canHandleMultipleConnections: boolean;
+    constructor(opts: SolanaWalletConnectConnectorOpts);
+    get deepLinkPreference(): DeepLinkVariant;
+    /**
+     * Accesses the sign client singleton instance, and throws if it is not
+     * immediately available.
+     */
+    get signClient(): SignClient;
+    getSupportedNetworks(): Promise<string[]>;
+    getActiveAddress(): string | undefined;
+    listenToActiveAccountChange(listener: (account: string) => void): VoidFunction;
+    getSigner(): Promise<ISolanaSigner>;
+    connect(): Promise<void>;
+    init(): Promise<void>;
+    private setupWCEventListeners;
+    endSession(): Promise<void>;
+    private displayUri;
+    getAddress(opts?: GetAddressOpts): Promise<string | undefined>;
+    private signClientRequest;
+    private deepLinkIfApplicable;
+    signMessage(messageToSign: string, options?: {
+        address?: string;
+    }): Promise<string | undefined>;
+    signEncodedMessage(encodedMessage: Uint8Array, options?: {
+        address?: string;
+    }): Promise<Uint8Array>;
+    private serializeTransaction;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+    signAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<string>;
+    getDeepLink(): string | undefined;
+    getConnectedAccounts(): Promise<string[]>;
+    getConnectionUri(): string | undefined;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+}