@dynamic-labs/solana 4.39.0 → 4.40.1

package/src/walletConnect/SolanaWalletConnectConnector/SolanaWalletConnectConnector.js

@@ -0,0 +1,417 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
+import { SDK_ERRORS } from '@walletconnect/utils';
+import bs58 from 'bs58';
+import EventEmitter from 'eventemitter3';
+import { SolanaWalletConnector, isVersionedTransaction } from '@dynamic-labs/solana-core';
+import { StorageService, DynamicError, filterDuplicates, isMobile, PlatformService, bufferToBase64 } from '@dynamic-labs/utils';
+import { getSignClientSingleton } from '@dynamic-labs/wallet-connect';
+import { performPlatformSpecificConnectionMethod, getDeepLink, isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { logger } from '../../utils/logger.js';
+import { createSolanaSignerForWalletConnect } from './createSolanaSignerForWalletConnect/createSolanaSignerForWalletConnect.js';
+
+const WC_SOLANA_CURRENT_CHAIN_KEY = 'dynamic-wc2-solana-current-chain';
+class SolanaWalletConnectConnector extends SolanaWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.activeAccountEmitter = new EventEmitter();
+        this.isInitialized = false;
+        this.canConnectViaQrCode = true;
+        this.isWalletConnect = true;
+        this.canHandleMultipleConnections = false;
+        this.name = opts.walletName;
+        const storedChainId = StorageService.getItem(WC_SOLANA_CURRENT_CHAIN_KEY);
+        if (storedChainId) {
+            this.setNetworkId(storedChainId);
+        }
+        if (opts.overrideKey) {
+            this.overrideKey = opts.overrideKey;
+        }
+        if (!opts.projectId) {
+            throw new 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 DynamicError('Failed to access sign client for Wallet Connect Solana: Sign client not initialized');
+        }
+        return SolanaWalletConnectConnector.signClientReference;
+    }
+    getSupportedNetworks() {
+        return __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 __awaiter(this, void 0, void 0, function* () {
+            return createSolanaSignerForWalletConnect({ walletConnector: this });
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Connect method not implemented.');
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized) {
+                return;
+            }
+            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 = 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.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.debug('[SolanaWalletConnect] onChainChange', { chainId });
+                if (chainId === this.getNetworkId()) {
+                    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 = filterDuplicates(accountsParam.map((account) => {
+                    // Handle potentially CAIP-10 format
+                    if (account.startsWith('solana:')) {
+                        return account.split(':')[2];
+                    }
+                    return account;
+                }));
+                logger.debug('[SolanaWalletConnect] onAccountChanged', { accounts });
+                this.emit('accountChange', { accounts });
+                return;
+            }
+            if (event.name === 'disconnected') {
+                logger.debug('[SolanaWalletConnect] onDisconnect');
+                this.emit('disconnect');
+                this.endSession();
+                return;
+            }
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[SolanaWalletConnect] endSession');
+            this.connectionUri = undefined;
+            if (!this.session) {
+                return;
+            }
+            yield this.signClient.disconnect({
+                reason: SDK_ERRORS.USER_DISCONNECTED,
+                topic: this.session.topic,
+            });
+            this.session = undefined;
+        });
+    }
+    displayUri(connectionOpts) {
+        if (!this.connectionUri) {
+            return;
+        }
+        logger.debug('[SolanaWalletConnect] handleDisplayURI', this.connectionUri);
+        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 __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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.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.logVerboseTroubleshootingMessage('[WalletConnectConnector] getAddress', {
+                inAppBrowserUrl: (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.inAppBrowserUrl,
+                isMobile: isMobile(),
+                mobileExperience: this.mobileExperience,
+            });
+            const didOpenInAppBrowser = this.openInAppBrowserIfRequired();
+            if (didOpenInAppBrowser) {
+                return;
+            }
+            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.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 __awaiter(this, arguments, void 0, function* ({ method, params, }) {
+            var _b, _c;
+            if (!this.session) {
+                throw new 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 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 (isMobile() &&
+            deepLink &&
+            methodsThatRequireDeepLink.includes(params.method)) {
+            PlatformService.openURL(deepLink);
+        }
+    }
+    signMessage(messageToSign, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.logVerboseTroubleshootingMessage('[SolanaWalletConnect] signMessage', messageToSign, options);
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const decodedSignature = yield this.signEncodedMessage(encodedMessage, options);
+            return bufferToBase64(decodedSignature);
+        });
+    }
+    signEncodedMessage(encodedMessage, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 DynamicError('No active address found');
+            }
+            const { signature } = yield this.signClientRequest({
+                method: 'solana_signMessage',
+                params: {
+                    message: bs58.encode(encodedMessage),
+                    pubkey: new PublicKey(activeAddress).toBase58(),
+                },
+            });
+            return bs58.decode(signature);
+        });
+    }
+    serializeTransaction(transaction) {
+        const serialized = transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+        return bs58.encode(new Uint8Array(serialized));
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAddress = this.getActiveAddress();
+            if (!activeAddress) {
+                throw new 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.decode(signedTransaction);
+            if (isVersionedTransaction(transaction)) {
+                return VersionedTransaction.deserialize(decodedTransaction);
+            }
+            return Transaction.from(decodedTransaction);
+        });
+    }
+    signAllTransactions(transactions) {
+        return __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.decode(signedTransaction);
+                if (isVersionedTransaction(originalTransaction)) {
+                    return VersionedTransaction.deserialize(decodedTransaction);
+                }
+                return Transaction.from(decodedTransaction);
+            });
+        });
+    }
+    signAndSendTransaction(transaction, options) {
+        return __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 = getDeepLink({
+            deepLinks: this.metadata.deepLinks,
+            mode: 'regular',
+            preference: this.deepLinkPreference,
+            // TODO: verify whether we need the uri
+            // uri: provider.signer.uri,
+        });
+        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 __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.logVerboseTroubleshootingMessage('[SolanaWalletConnect] getConnectedAccounts - activeAccounts', [account]);
+            return [account];
+        });
+    }
+    getConnectionUri() {
+        return this.connectionUri;
+    }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[SolanaWalletConnect] validateActiveWallet - validating wallet', expectedAddress);
+            const [activeAddress] = yield this.getConnectedAccounts();
+            const isWalletActive = isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (isWalletActive) {
+                logger.debug('[SolanaWalletConnect] validateActiveWallet - wallet is active');
+                return;
+            }
+            return this.handleWalletNotActive({
+                activeAddress,
+                expectedAddress,
+            });
+        });
+    }
+}
+
+export { SolanaWalletConnectConnector };

package/src/walletConnect/SolanaWalletConnectConnector/createSolanaSignerForWalletConnect/createSolanaSignerForWalletConnect.cjs

@@ -0,0 +1,126 @@
+'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 = require('@dynamic-labs/utils');
+var logger = require('../../../utils/logger.cjs');
+
+const createSolanaSignerForWalletConnect = ({ walletConnector, }) => {
+    const connect = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const address = walletConnector.getActiveAddress();
+        if (!address) {
+            return undefined;
+        }
+        return { address, publicKey: new web3_js.PublicKey(address) };
+    });
+    // eslint-disable-next-line arrow-body-style
+    const disconnect = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        yield walletConnector.endSession();
+    });
+    const on = (event, listener) => {
+        if (event === 'connect') {
+            logger.logger.debug('on - Not implemented for event: connect');
+            return signer;
+        }
+        if (event === 'activeWalletDidChange') {
+            walletConnector.listenToActiveAccountChange(listener);
+            return signer;
+        }
+        walletConnector.signClient.on('session_event', (sessionEvent) => {
+            // Skip events from other sessions
+            if (!walletConnector.session ||
+                sessionEvent.topic !== walletConnector.session.topic) {
+                return;
+            }
+            if (sessionEvent.params.event.name === 'accountsChanged' &&
+                event === 'accountChanged') {
+                const accountsParam = sessionEvent.params.event.data;
+                const accounts = utils.filterDuplicates(accountsParam.map((account) => {
+                    // Handle potentially CAIP-10 format
+                    if (account.startsWith('solana:')) {
+                        return account.split(':')[2];
+                    }
+                    return account;
+                }));
+                listener(accounts[0]);
+                return;
+            }
+            if (sessionEvent.params.event.name === 'disconnected' &&
+                event === 'disconnect') {
+                listener('');
+                return;
+            }
+        });
+        return signer;
+    };
+    const signMessage = (messageArrayBuffer) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signature = yield walletConnector.signEncodedMessage(messageArrayBuffer);
+        return { signature };
+    });
+    const signAllTransactions = (transactions) => _tslib.__awaiter(void 0, void 0, void 0, function* () { return walletConnector.signAllTransactions(transactions); });
+    const signAndSendTransaction = (transaction, options) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signature = yield walletConnector.signAndSendTransaction(transaction, options);
+        return { signature };
+    });
+    const signTransaction = (transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () { return walletConnector.signTransaction(transaction); });
+    const signer = {
+        addListener: () => {
+            throw new Error('addListener - Not implemented');
+        },
+        connect,
+        disconnect,
+        emit: () => {
+            throw new Error('emit - Not implemented');
+        },
+        eventNames: () => {
+            logger.logger.error('eventNames - Not implemented');
+            return [];
+        },
+        isBackpack: false,
+        isBraveWallet: false,
+        get isConnected() {
+            return Boolean(walletConnector.getActiveAddress());
+        },
+        isExodus: false,
+        isGlow: false,
+        isMagicEden: false,
+        isPhantom: false,
+        isSolflare: false,
+        listenerCount: () => {
+            logger.logger.error('listenerCount - Not implemented');
+            return 0;
+        },
+        listeners: () => {
+            logger.logger.error('listeners - Not implemented');
+            return [];
+        },
+        off: () => {
+            throw new Error('off - Not implemented');
+        },
+        on,
+        once: () => {
+            throw new Error('once - Not implemented');
+        },
+        providers: [],
+        get publicKey() {
+            const address = walletConnector.getActiveAddress();
+            return address ? new web3_js.PublicKey(address) : undefined;
+        },
+        removeAllListeners: () => {
+            throw new Error('removeAllListeners - Not implemented');
+        },
+        removeListener: () => {
+            throw new Error('removeListener - Not implemented');
+        },
+        signAllTransactions,
+        signAndSendTransaction,
+        signMessage,
+        signTransaction,
+    };
+    return signer;
+};
+
+exports.createSolanaSignerForWalletConnect = createSolanaSignerForWalletConnect;

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

@@ -0,0 +1,7 @@
+import { ISolanaSigner } from '@dynamic-labs/solana-core';
+import { SolanaWalletConnectConnector } from '../SolanaWalletConnectConnector';
+type CreateSolanaSignerForWalletConnectProps = {
+    walletConnector: SolanaWalletConnectConnector;
+};
+export declare const createSolanaSignerForWalletConnect: ({ walletConnector, }: CreateSolanaSignerForWalletConnectProps) => ISolanaSigner;
+export {};

package/src/walletConnect/SolanaWalletConnectConnector/createSolanaSignerForWalletConnect/createSolanaSignerForWalletConnect.js

@@ -0,0 +1,122 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { PublicKey } from '@solana/web3.js';
+import { filterDuplicates } from '@dynamic-labs/utils';
+import { logger } from '../../../utils/logger.js';
+
+const createSolanaSignerForWalletConnect = ({ walletConnector, }) => {
+    const connect = () => __awaiter(void 0, void 0, void 0, function* () {
+        const address = walletConnector.getActiveAddress();
+        if (!address) {
+            return undefined;
+        }
+        return { address, publicKey: new PublicKey(address) };
+    });
+    // eslint-disable-next-line arrow-body-style
+    const disconnect = () => __awaiter(void 0, void 0, void 0, function* () {
+        yield walletConnector.endSession();
+    });
+    const on = (event, listener) => {
+        if (event === 'connect') {
+            logger.debug('on - Not implemented for event: connect');
+            return signer;
+        }
+        if (event === 'activeWalletDidChange') {
+            walletConnector.listenToActiveAccountChange(listener);
+            return signer;
+        }
+        walletConnector.signClient.on('session_event', (sessionEvent) => {
+            // Skip events from other sessions
+            if (!walletConnector.session ||
+                sessionEvent.topic !== walletConnector.session.topic) {
+                return;
+            }
+            if (sessionEvent.params.event.name === 'accountsChanged' &&
+                event === 'accountChanged') {
+                const accountsParam = sessionEvent.params.event.data;
+                const accounts = filterDuplicates(accountsParam.map((account) => {
+                    // Handle potentially CAIP-10 format
+                    if (account.startsWith('solana:')) {
+                        return account.split(':')[2];
+                    }
+                    return account;
+                }));
+                listener(accounts[0]);
+                return;
+            }
+            if (sessionEvent.params.event.name === 'disconnected' &&
+                event === 'disconnect') {
+                listener('');
+                return;
+            }
+        });
+        return signer;
+    };
+    const signMessage = (messageArrayBuffer) => __awaiter(void 0, void 0, void 0, function* () {
+        const signature = yield walletConnector.signEncodedMessage(messageArrayBuffer);
+        return { signature };
+    });
+    const signAllTransactions = (transactions) => __awaiter(void 0, void 0, void 0, function* () { return walletConnector.signAllTransactions(transactions); });
+    const signAndSendTransaction = (transaction, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const signature = yield walletConnector.signAndSendTransaction(transaction, options);
+        return { signature };
+    });
+    const signTransaction = (transaction) => __awaiter(void 0, void 0, void 0, function* () { return walletConnector.signTransaction(transaction); });
+    const signer = {
+        addListener: () => {
+            throw new Error('addListener - Not implemented');
+        },
+        connect,
+        disconnect,
+        emit: () => {
+            throw new Error('emit - Not implemented');
+        },
+        eventNames: () => {
+            logger.error('eventNames - Not implemented');
+            return [];
+        },
+        isBackpack: false,
+        isBraveWallet: false,
+        get isConnected() {
+            return Boolean(walletConnector.getActiveAddress());
+        },
+        isExodus: false,
+        isGlow: false,
+        isMagicEden: false,
+        isPhantom: false,
+        isSolflare: false,
+        listenerCount: () => {
+            logger.error('listenerCount - Not implemented');
+            return 0;
+        },
+        listeners: () => {
+            logger.error('listeners - Not implemented');
+            return [];
+        },
+        off: () => {
+            throw new Error('off - Not implemented');
+        },
+        on,
+        once: () => {
+            throw new Error('once - Not implemented');
+        },
+        providers: [],
+        get publicKey() {
+            const address = walletConnector.getActiveAddress();
+            return address ? new PublicKey(address) : undefined;
+        },
+        removeAllListeners: () => {
+            throw new Error('removeAllListeners - Not implemented');
+        },
+        removeListener: () => {
+            throw new Error('removeListener - Not implemented');
+        },
+        signAllTransactions,
+        signAndSendTransaction,
+        signMessage,
+        signTransaction,
+    };
+    return signer;
+};
+
+export { createSolanaSignerForWalletConnect };

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

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

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

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