@maximedogawa/chia-wallet-connect-react 0.0.1

package/dist/utils/walletIntegration/wallets/walletConnect.js

@@ -0,0 +1,891 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sign_client_1 = __importDefault(require("@walletconnect/sign-client"));
+const modal_1 = require("@walletconnect/modal");
+const react_hot_toast_1 = require("react-hot-toast");
+const pino_1 = __importDefault(require("pino"));
+const store_js_1 = __importDefault(require("../../../state/store.js"));
+const walletSlice_js_1 = require("../../../state/walletSlice.js");
+const walletConnectSlice_js_1 = require("../../../state/walletConnectSlice.js");
+const completeWithWalletSlice_js_1 = require("../../../state/completeWithWalletSlice.js");
+const wallet_connect_js_1 = require("../../../constants/wallet-connect.js");
+const sage_methods_js_1 = require("../../../constants/sage-methods.js");
+const logger_js_1 = require("../../../utils/logger.js");
+const deviceDetection_js_1 = require("../../../utils/deviceDetection.js");
+const logger = (0, logger_js_1.createLogger)('WalletConnect');
+// Singleton SignClient instance to prevent multiple initializations
+let globalSignClient = null;
+let globalSignClientPromise = null;
+// Type guard for WalletConnect errors
+function isWalletConnectError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+class WalletConnectIntegration {
+    name = "WalletConnect";
+    image;
+    chainId = wallet_connect_js_1.CHIA_CHAIN_ID;
+    topic;
+    client;
+    selectedFingerprint;
+    session;
+    metadata;
+    modal; // Native WalletConnect modal (desktop only)
+    modalThemeObserver; // Observer for theme changes
+    constructor(image, metadata) {
+        // Allow image to be passed as prop, otherwise use default from constants
+        this.image = image || wallet_connect_js_1.DEFAULT_WALLET_IMAGE;
+        // Allow metadata to be passed as prop for custom configuration
+        this.metadata = metadata;
+        // Give methods access to current Redux state
+        const state = store_js_1.default.getState();
+        const selectedSession = state.walletConnect.selectedSession;
+        if (selectedSession) {
+            this.topic = selectedSession.topic;
+            this.session = selectedSession;
+            const fingerprint = state.walletConnect.selectedFingerprint[selectedSession.topic];
+            this.selectedFingerprint = fingerprint;
+        }
+    }
+    async updateSessions() {
+        try {
+            const sessions = await this.getAllSessions();
+            if (sessions) {
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.setSessions)(sessions));
+            }
+            else {
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.setSessions)([]));
+                store_js_1.default.dispatch((0, walletSlice_js_1.setAddress)(null));
+                if (store_js_1.default.getState().wallet.connectedWallet === "WalletConnect")
+                    store_js_1.default.dispatch((0, walletSlice_js_1.setConnectedWallet)(null));
+                logger.error('No WC sessions found');
+            }
+        }
+        catch (error) {
+            if (isWalletConnectError(error)) {
+                logger.error(`WalletConnect - ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async deleteTopicFromLocalStorage(topic) {
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith('wc') && key.endsWith('//session')) {
+                const responseList = await JSON.parse(localStorage.getItem(key));
+                localStorage.setItem(key, JSON.stringify(responseList.filter((item) => item.topic !== topic)));
+            }
+        }
+    }
+    // If the session being disconnected is the only session connected, then disconnect the wallet in the wallet slice
+    async updateConnectedWalletOnDisconnect(topic) {
+        const state = store_js_1.default.getState();
+        if (!state.walletConnect.sessions.length && "WalletConnect" === store_js_1.default.getState().wallet.connectedWallet) {
+            store_js_1.default.dispatch((0, walletSlice_js_1.setConnectedWallet)(null));
+        }
+        if (!topic)
+            return;
+        // If user disconnects the currently selected session, select the next available one
+        const sessions = state.walletConnect.sessions;
+        const selectedSession = state.walletConnect.selectedSession;
+        if (sessions.length && selectedSession && topic === selectedSession.topic) {
+            const newSessionTopic = sessions[sessions.length - 1].topic;
+            store_js_1.default.dispatch((0, walletConnectSlice_js_1.selectSession)(newSessionTopic));
+        }
+    }
+    async connect() {
+        // For WalletConnect, check if there are existing sessions
+        // If there are sessions but no selected session, select the first one
+        const state = store_js_1.default.getState();
+        const sessions = state.walletConnect.sessions;
+        const selectedSession = state.walletConnect.selectedSession;
+        if (sessions.length > 0 && !selectedSession) {
+            // Select the first available session
+            const firstSession = sessions[0];
+            store_js_1.default.dispatch((0, walletConnectSlice_js_1.selectSession)(firstSession.topic));
+            // Ensure fingerprint is set for this session
+            if (!state.walletConnect.selectedFingerprint[firstSession.topic]) {
+                const defaultFingerprint = Number(firstSession.namespaces.chia.accounts[0].split(":")[2]);
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.setSelectedFingerprint)({ topic: firstSession.topic, selectedFingerprint: defaultFingerprint }));
+                logger.debug('connect: Set default fingerprint for session', { topic: firstSession.topic, fingerprint: defaultFingerprint });
+            }
+            logger.debug('connect: Selected first available session', { topic: firstSession.topic });
+            return true;
+        }
+        // If there's already a selected session, ensure it has a fingerprint
+        if (selectedSession) {
+            if (!state.walletConnect.selectedFingerprint[selectedSession.topic]) {
+                const defaultFingerprint = Number(selectedSession.namespaces.chia.accounts[0].split(":")[2]);
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.setSelectedFingerprint)({ topic: selectedSession.topic, selectedFingerprint: defaultFingerprint }));
+                logger.debug('connect: Set default fingerprint for existing session', { topic: selectedSession.topic, fingerprint: defaultFingerprint });
+            }
+            logger.debug('connect: Session already selected', { topic: selectedSession.topic });
+            return true;
+        }
+        // No sessions available - user needs to call connectSession() first
+        logger.debug('connect: No sessions available, connectSession() must be called first');
+        return false;
+    }
+    async connectSession() {
+        // Initiate connection and pass pairing uri to the modal (QR code)
+        try {
+            const signClient = await this.signClient();
+            if (signClient) {
+                // Ensure modal is initialized before connecting (for desktop)
+                // Modal initialization happens in signClient(), but we need to ensure it's ready
+                if (!this.modal && !(0, deviceDetection_js_1.isIOS)() && typeof window !== 'undefined') {
+                    const modalConfig = (0, wallet_connect_js_1.getModalConfig)();
+                    if (modalConfig) {
+                        try {
+                            this.modal = new modal_1.WalletConnectModal(modalConfig);
+                            logger.debug('Native WalletConnect modal initialized for desktop', { theme: modalConfig.themeMode });
+                            this.setupThemeObserver();
+                        }
+                        catch (modalError) {
+                            logger.error('Failed to initialize WalletConnect modal:', modalError);
+                        }
+                    }
+                }
+                // Use REQUIRED_NAMESPACES from constants (includes all Sage methods)
+                // Note: requiredNamespaces is deprecated, using optionalNamespaces instead
+                // Fetch uri to display QR code to establish new wallet connection
+                const { uri, approval } = await signClient.connect({
+                    optionalNamespaces: wallet_connect_js_1.REQUIRED_NAMESPACES,
+                });
+                // Use native WalletConnect modal on desktop, custom modal on iOS
+                if (uri) {
+                    if (this.modal && !(0, deviceDetection_js_1.isIOS)()) {
+                        // Use native WalletConnect modal for desktop
+                        this.modal.openModal({ uri });
+                        logger.debug('Opened native WalletConnect modal');
+                    }
+                    else {
+                        // Use custom modal for iOS or fallback
+                        store_js_1.default.dispatch((0, walletConnectSlice_js_1.setPairingUri)(uri));
+                    }
+                }
+                // If new connection established successfully
+                const session = await approval();
+                logger.info('Connected Chia wallet via WalletConnect', { session, signClient });
+                // Close native modal if it was opened
+                if (this.modal && !(0, deviceDetection_js_1.isIOS)()) {
+                    this.modal.closeModal();
+                }
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.setPairingUri)(null));
+                this.detectEvents();
+                await this.updateSessions();
+                store_js_1.default.dispatch((0, walletConnectSlice_js_1.connectSession)(session));
+                // Update instance properties to match the new session
+                this.topic = session.topic;
+                this.session = session;
+                this.selectedFingerprint = Number(session.namespaces.chia.accounts[0].split(":")[2]);
+                // Verify connection using CHIA_GET_ADDRESS method (Sage method)
+                let address = null;
+                try {
+                    logger.debug('Verifying connection using CHIA_GET_ADDRESS method...');
+                    address = await this.verifyConnectionWithSageMethod();
+                    if (address) {
+                        logger.debug('Connection verified successfully!');
+                        logger.debug('Address retrieved:', address);
+                    }
+                    else {
+                        logger.debug('CHIA_GET_ADDRESS returned null, trying fallback method...');
+                        // Fallback to regular getAddress if Sage method doesn't work
+                        address = await this.getAddress();
+                        logger.debug('Fallback address fetch result:', address);
+                    }
+                }
+                catch (addressError) {
+                    logger.debug('CHIA_GET_ADDRESS verification failed, trying fallback:', addressError);
+                    // Try fallback method
+                    try {
+                        address = await this.getAddress();
+                        logger.debug('Fallback address fetch successful:', address);
+                    }
+                    catch (fallbackError) {
+                        logger.error('Failed to fetch address after connection:', fallbackError);
+                        // Continue even if address fetch fails - connection is still successful
+                    }
+                }
+                // Update main wallet slice to notify that it is now the active wallet
+                // Use WalletConnect icon (this.image) instead of Sage Wallet icon
+                const setConnectedWalletInfo = {
+                    wallet: "WalletConnect",
+                    address: address,
+                    image: this.image, // Use WalletConnect icon, not Sage Wallet icon
+                    name: "WalletConnect"
+                };
+                store_js_1.default.dispatch((0, walletSlice_js_1.setConnectedWallet)(setConnectedWalletInfo));
+                return session;
+            }
+        }
+        catch (error) {
+            logger.error('Error connecting WalletConnect session:', error);
+            // Close native modal if it was opened
+            if (this.modal && !(0, deviceDetection_js_1.isIOS)()) {
+                this.modal.closeModal();
+            }
+            // Clear pairing URI on error
+            store_js_1.default.dispatch((0, walletConnectSlice_js_1.setPairingUri)(null));
+            // Re-throw error so calling code can handle it
+            throw error;
+        }
+    }
+    disconnect() {
+        return true;
+    }
+    async disconnectSession(topic) {
+        // Sign client
+        const signClient = await this.signClient();
+        // Fetch previous connection
+        try {
+            if (!signClient) {
+                react_hot_toast_1.toast.error('Not connected via WalletConnect or could not sign client', { id: 'failed-to-sign-client' });
+                return;
+            }
+            // Send request to get Wallets via WalletConnect
+            await signClient.disconnect({
+                topic,
+                reason: {
+                    code: 6000,
+                    message: "User disconnected."
+                },
+            });
+            await this.deleteTopicFromLocalStorage(topic);
+            await this.updateSessions();
+            await this.updateConnectedWalletOnDisconnect();
+            // Remove any saved fingerprint preference if any
+            store_js_1.default.dispatch((0, walletConnectSlice_js_1.deleteTopicFromFingerprintMemory)(topic));
+        }
+        catch (error) {
+            this.updateSessions();
+            if (isWalletConnectError(error)) {
+                logger.error('Error disconnecting session:', error.message);
+            }
+            else {
+                logger.error('Error disconnecting session:', error);
+            }
+        }
+    }
+    async generateOffer(requestAssets, offerAssets, fee) {
+        // Show modal to user taking them through each step of the process
+        store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)("getWallets"));
+        store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setOfferRejected)(false));
+        // showCompleteWithWalletModal(this)
+        let firstRun = true;
+        let tempAssetsToAddArray = [];
+        let walletsResponse;
+        while (firstRun || tempAssetsToAddArray.length > 0) {
+            firstRun = false;
+            tempAssetsToAddArray = [];
+            // Send request to fetch users wallets
+            walletsResponse = await this.getWallets();
+            if (!walletsResponse?.isSage) {
+                const wallets = walletsResponse?.wallets;
+                if (!wallets) {
+                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)(null));
+                    return;
+                }
+                // Match assetIds to users wallet to find the wallet ID (required to send a create offer)
+                // For offering assets
+                offerAssets.forEach(offerItem => {
+                    // If item is Chia, set walletId to 1 as this is the default
+                    if (offerItem.assetId === "")
+                        return offerItem.walletId = 1;
+                    const matchingChiaWallet = wallets.data.find(item => item.meta.assetId === offerItem.assetId);
+                    if (matchingChiaWallet) {
+                        offerItem.walletId = matchingChiaWallet.id;
+                    }
+                    else {
+                        tempAssetsToAddArray.push({ ...offerItem });
+                    }
+                });
+                // For requesting assets
+                requestAssets.forEach(requestItem => {
+                    // If item is Chia, set walletId to 1 as this is the default
+                    if (requestItem.assetId === "")
+                        return requestItem.walletId = 1;
+                    const matchingChiaWallet = wallets.data.find(item => item.meta.assetId == requestItem.assetId);
+                    if (matchingChiaWallet) {
+                        requestItem.walletId = matchingChiaWallet.id;
+                    }
+                    else {
+                        tempAssetsToAddArray.push({ ...requestItem });
+                    }
+                });
+                if (tempAssetsToAddArray.length) {
+                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setUserMustAddTheseAssetsToWallet)(tempAssetsToAddArray));
+                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)("addAssets"));
+                    // We now have a list of assets which need adding. We keep track of the list length. When it's 0, we can continue as all assets are added.
+                    const checkIfAssetsHaveBeenAdded = () => {
+                        return new Promise((resolve, reject) => {
+                            const unsubscribe = store_js_1.default.subscribe(() => {
+                                const state = store_js_1.default.getState();
+                                const userMustAddTheseAssetsToWallet = state.completeWithWallet.userMustAddTheseAssetsToWallet;
+                                if (userMustAddTheseAssetsToWallet.length === 0 && !state.completeWithWallet.offerRejected) {
+                                    unsubscribe();
+                                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)("getWalletsAgain"));
+                                    resolve();
+                                }
+                                else if (state.completeWithWallet.offerRejected) {
+                                    unsubscribe();
+                                    reject();
+                                }
+                                // Still more assets to add, wait for next update & check again
+                            });
+                        });
+                    };
+                    await checkIfAssetsHaveBeenAdded();
+                }
+            } // End of while loop (will run twice if user has had to add assets to continue)
+        }
+        store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)("generateOffer"));
+        // Generate offer object
+        const offer = {};
+        offerAssets.forEach((asset) => {
+            if (!asset.walletId)
+                return;
+            offer[asset.walletId] = -Math.abs(asset.amount);
+        });
+        // Generate request object
+        const request = {};
+        requestAssets.forEach((asset) => {
+            if (!asset.walletId)
+                return;
+            request[asset.walletId] = asset.amount;
+        });
+        // Create final object for WalletConnect request
+        const compressedOffer = { ...offer, ...request };
+        // Sign client
+        const signClient = await this.signClient();
+        // Fetch previous connection
+        try {
+            if (!this.topic || !signClient) {
+                react_hot_toast_1.toast.error('Not connected via WalletConnect or could not sign client', { id: 'failed-to-sign-client' });
+                return;
+            }
+            if (walletsResponse?.isSage) {
+                logger.info("Sage offer request");
+                const resultOffer = await signClient.request({
+                    topic: this.topic,
+                    chainId: this.chainId,
+                    request: {
+                        method: "chia_createOffer",
+                        params: {
+                            offerAssets: offerAssets.map(offerItem => {
+                                const asset = {
+                                    assetId: offerItem.assetId,
+                                    amount: offerItem.amount
+                                };
+                                if (offerItem.hiddenPuzzleHash && offerItem.hiddenPuzzleHash.length == 64) {
+                                    asset.hiddenPuzzleHash = offerItem.hiddenPuzzleHash;
+                                }
+                                return asset;
+                            }),
+                            requestAssets: requestAssets.map(requestItem => {
+                                const asset = {
+                                    assetId: requestItem.assetId,
+                                    amount: requestItem.amount
+                                };
+                                if (requestItem.hiddenPuzzleHash && requestItem.hiddenPuzzleHash.length == 64) {
+                                    asset.hiddenPuzzleHash = requestItem.hiddenPuzzleHash;
+                                }
+                                return asset;
+                            }),
+                            fee
+                        },
+                    },
+                });
+                if (resultOffer.error) {
+                    react_hot_toast_1.toast.error(resultOffer.error);
+                    // Set offer rejected: true
+                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setOfferRejected)(true));
+                }
+                else if (resultOffer.offer) {
+                    store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)(null));
+                    return resultOffer.offer;
+                }
+            }
+            // Send request to generate offer via WalletConnect
+            const resultOffer = await signClient.request({
+                topic: this.topic,
+                chainId: this.chainId,
+                request: {
+                    method: "chia_createOfferForIds",
+                    params: {
+                        fingerprint: this.selectedFingerprint,
+                        offer: compressedOffer,
+                        fee,
+                        driverDict: {},
+                        disableJSONFormatting: true,
+                    },
+                },
+            });
+            if (resultOffer.error) {
+                react_hot_toast_1.toast.error(resultOffer.error?.data.error);
+                // Set offer rejected: true
+                store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setOfferRejected)(true));
+            }
+            else if (resultOffer.data) {
+                store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setRequestStep)(null));
+                return resultOffer.data.offer;
+            }
+        }
+        catch (_error) {
+            store_js_1.default.dispatch((0, completeWithWalletSlice_js_1.setOfferRejected)(true));
+        }
+    }
+    getBalance() {
+        // WalletConnect balance retrieval logic
+    }
+    async getWallets() {
+        // Sign client
+        const signClient = await this.signClient();
+        // Fetch previous connection
+        try {
+            if (!this.topic || !signClient) {
+                react_hot_toast_1.toast.error('Not connected via WalletConnect or could not sign client', { id: 'failed-to-sign-client' });
+                return;
+            }
+            try {
+                // Send request to get Wallets via WalletConnect
+                const request = signClient.request({
+                    topic: this.topic,
+                    chainId: this.chainId,
+                    request: {
+                        method: "chia_getWallets",
+                        params: {
+                            fingerprint: this.selectedFingerprint,
+                            includeData: true
+                        },
+                    },
+                });
+                const wallets = await request;
+                if (wallets.isSuccess) {
+                    return { isSage: false, wallets };
+                }
+                else {
+                    throw Error('Fetching wallet request unsuccessful');
+                }
+            }
+            catch (error) {
+                if (isWalletConnectError(error) && error.code === 4001 && error.message === "Unsupported method: chia_getWallets") {
+                    return {
+                        isSage: true,
+                        wallets: null,
+                    };
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            if (isWalletConnectError(error)) {
+                logger.error('Error generating offer:', error.message);
+            }
+            else {
+                logger.error('Error generating offer:', error);
+            }
+        }
+    }
+    async addAsset(assetId, symbol, logo, fullName) {
+        const displayName = `${fullName} (${symbol})`;
+        // Sign client
+        const signClient = await this.signClient();
+        // Fetch previous connection
+        try {
+            if (!this.topic || !signClient) {
+                react_hot_toast_1.toast.error('Not connected via WalletConnect or could not sign client', { id: 'failed-to-sign-client' });
+                throw Error('Not connected via WalletConnect or could not sign client');
+            }
+            // Send request to get Wallets via WalletConnect
+            const request = signClient.request({
+                topic: this.topic,
+                chainId: this.chainId,
+                request: {
+                    method: "chia_addCATToken",
+                    params: {
+                        fingerprint: this.selectedFingerprint,
+                        name: displayName,
+                        assetId: assetId
+                    },
+                },
+            });
+            await request;
+            return true;
+        }
+        catch (error) {
+            if (isWalletConnectError(error)) {
+                logger.error(`Wallet - ${error.message}`);
+            }
+            else {
+                logger.error(`Wallet -`, error);
+            }
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    /**
+     * Verify connection using CHIA_GET_ADDRESS method (Sage wallet method)
+     * This is used to verify that the connection is working correctly
+     */
+    async verifyConnectionWithSageMethod() {
+        logger.debug('verifyConnectionWithSageMethod: Starting verification...');
+        let signClient;
+        let topic;
+        try {
+            signClient = await this.signClient();
+            const state = store_js_1.default.getState();
+            topic = state.walletConnect.selectedSession?.topic || this.topic;
+            if (!topic || !signClient) {
+                logger.debug('verifyConnectionWithSageMethod: No topic or signClient available');
+                throw Error('Not connected via WalletConnect or could not sign client');
+            }
+            logger.debug('verifyConnectionWithSageMethod: Using method:', sage_methods_js_1.SageMethods.CHIA_GET_ADDRESS);
+            logger.debug('verifyConnectionWithSageMethod: Topic:', topic);
+            logger.debug('verifyConnectionWithSageMethod: ChainId:', this.chainId);
+            const request = signClient.request({
+                topic: topic,
+                chainId: this.chainId,
+                request: {
+                    method: sage_methods_js_1.SageMethods.CHIA_GET_ADDRESS,
+                    params: {},
+                },
+            });
+            logger.debug('verifyConnectionWithSageMethod: Request sent, awaiting response...');
+            const response = await request;
+            logger.debug('verifyConnectionWithSageMethod: Response received:', response);
+            const address = response?.address || null;
+            if (address) {
+                logger.debug('verifyConnectionWithSageMethod: Success! Address:', address);
+                store_js_1.default.dispatch((0, walletSlice_js_1.setAddress)(address));
+            }
+            else {
+                logger.debug('verifyConnectionWithSageMethod: No address in response');
+            }
+            return address;
+        }
+        catch (error) {
+            logger.debug('verifyConnectionWithSageMethod: Error occurred:', error);
+            if (isWalletConnectError(error) && error.code === 4001) {
+                logger.debug('verifyConnectionWithSageMethod: Method not supported (4001), wallet may not be Sage');
+            }
+            throw error;
+        }
+    }
+    async getAddress() {
+        logger.debug('getAddress: Starting address fetch...');
+        let signClient;
+        let topic;
+        try {
+            signClient = await this.signClient();
+            const state = store_js_1.default.getState();
+            topic = state.walletConnect.selectedSession?.topic;
+            if (!topic || !signClient) {
+                logger.debug('getAddress: No topic or signClient available');
+                react_hot_toast_1.toast.error('Not connected via WalletConnect or could not sign client', { id: 'failed-to-sign-client' });
+                throw Error('Not connected via WalletConnect or could not sign client');
+            }
+            const selectedSession = state?.walletConnect?.selectedSession;
+            if (!selectedSession) {
+                logger.debug('getAddress: No selected session');
+                return null;
+            }
+            const fingerprint = state.walletConnect.selectedFingerprint[selectedSession.topic];
+            if (!fingerprint) {
+                logger.debug('getAddress: No fingerprint selected');
+                return null;
+            }
+            const wallet_id = selectedSession?.namespaces?.chia?.accounts.findIndex(account => account.includes(fingerprint.toString()));
+            logger.debug('getAddress: Wallet ID:', wallet_id);
+            if (wallet_id === undefined) {
+                logger.debug('getAddress: Wallet ID is undefined');
+                return '';
+            }
+            logger.debug('getAddress: Requesting address with method chia_getCurrentAddress', {
+                topic,
+                chainId: this.chainId,
+                method: "chia_getCurrentAddress",
+                params: {
+                    fingerprint: fingerprint,
+                    wallet_id,
+                    new_address: false
+                },
+            });
+            const request = signClient.request({
+                topic,
+                chainId: this.chainId,
+                request: {
+                    method: "chia_getCurrentAddress",
+                    params: {
+                        fingerprint: fingerprint,
+                        wallet_id,
+                        new_address: false
+                    },
+                },
+            });
+            const response = await request;
+            logger.debug('getAddress: Address request response received:', response);
+            const address = response?.data || null;
+            if (address) {
+                logger.debug('getAddress: Success! Address retrieved:', address);
+                store_js_1.default.dispatch((0, walletSlice_js_1.setAddress)(address));
+            }
+            else {
+                logger.debug('getAddress: No address in response');
+            }
+            return address;
+        }
+        catch (error) {
+            // Check for various error formats that indicate the method is not supported
+            const isUnsupportedMethod = isWalletConnectError(error) &&
+                error.code === 4001 &&
+                (error.message === "Unsupported method: chia_getCurrentAddress" ||
+                    error.message.includes("Missing or invalid") && error.message.includes("chia_getCurrentAddress") ||
+                    error.message.includes("request() method: chia_getCurrentAddress"));
+            if (isUnsupportedMethod) {
+                logger.debug('getAddress: chia_getCurrentAddress not supported, trying Sage method chia_getAddress');
+                logger.info("Sage wallet detected, using chia_getAddress method");
+                try {
+                    const request = signClient.request({
+                        topic: topic,
+                        chainId: this.chainId,
+                        request: {
+                            method: "chia_getAddress",
+                            params: {},
+                        },
+                    });
+                    const response = await request;
+                    logger.debug('getAddress: Sage address response received:', response);
+                    const address = response.address;
+                    if (address) {
+                        logger.debug('getAddress: Success! Sage address retrieved:', address);
+                        store_js_1.default.dispatch((0, walletSlice_js_1.setAddress)(address));
+                    }
+                    return address;
+                }
+                catch (sageError) {
+                    logger.error('getAddress: Sage method also failed:', sageError);
+                    return null;
+                }
+            }
+            logger.error('getAddress: Error getting address:', error);
+            return null;
+        }
+    }
+    async getAllSessions() {
+        const signClient = await this.signClient();
+        if (signClient)
+            return signClient.session.getAll();
+    }
+    /**
+     * Set up a MutationObserver to watch for theme changes (dark class on documentElement)
+     * and update the WalletConnect modal theme accordingly
+     */
+    setupThemeObserver() {
+        if (typeof window === 'undefined' || !this.modal) {
+            return;
+        }
+        // Clean up existing observer if any
+        if (this.modalThemeObserver) {
+            this.modalThemeObserver.disconnect();
+        }
+        // Create observer to watch for class changes on documentElement
+        this.modalThemeObserver = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
+                    const isDark = document.documentElement.classList.contains('dark');
+                    const newTheme = isDark ? 'dark' : 'light';
+                    try {
+                        // Update modal theme
+                        // Note: WalletConnectModal may need to be re-initialized or have a setTheme method
+                        // For now, we'll log the change - the modal should pick up theme changes on next open
+                        logger.debug('Theme changed, updating WalletConnect modal', { theme: newTheme });
+                        const modalWithTheme = this.modal;
+                        if (modalWithTheme && typeof modalWithTheme.setTheme === 'function') {
+                            modalWithTheme.setTheme(newTheme);
+                        }
+                    }
+                    catch (error) {
+                        logger.error('Failed to update modal theme:', error);
+                    }
+                }
+            });
+        });
+        // Start observing the documentElement for class changes
+        this.modalThemeObserver.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['class'],
+        });
+        logger.debug('Theme observer set up for WalletConnect modal');
+    }
+    async signClient() {
+        // If client has been saved to object, return that instead of completing a new sign
+        if (this.client)
+            return this.client;
+        // Use global singleton to prevent multiple initializations
+        if (globalSignClient) {
+            this.client = globalSignClient;
+            return globalSignClient;
+        }
+        // If initialization is in progress, wait for it
+        if (globalSignClientPromise) {
+            const client = await globalSignClientPromise;
+            this.client = client;
+            return client;
+        }
+        try {
+            const projectId = wallet_connect_js_1.SIGN_CLIENT_CONFIG.projectId;
+            if (!projectId) {
+                throw new Error('WalletConnect project ID is not configured. Please set WALLET_CONNECT_PROJECT_ID or NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID in your .env file.');
+            }
+            // Create a filtered pino logger that suppresses non-critical WalletConnect errors
+            // WalletConnect logs non-critical internal errors (pairing cleanup, history restore, etc.)
+            // that don't affect functionality but clutter the console
+            const createFilteredLogger = () => {
+                const baseLogger = wallet_connect_js_1.SIGN_CLIENT_CONFIG.logger;
+                // Map log level strings to pino levels
+                const levelMap = {
+                    'error': 'error',
+                    'warn': 'warn',
+                    'info': 'info',
+                    'debug': 'debug',
+                    'trace': 'trace',
+                };
+                const logLevel = levelMap[baseLogger] || 'error';
+                // Create a custom stream that filters non-critical messages
+                const filteredStream = {
+                    write: (chunk) => {
+                        try {
+                            const logObj = JSON.parse(chunk);
+                            const context = logObj.context || '';
+                            const msg = logObj.msg || '';
+                            // Skip these non-critical errors that don't affect functionality
+                            const nonCriticalPatterns = [
+                                'core/pairing/pairing',
+                                'core/history',
+                                'Restore will override',
+                                'failed to process an inbound message',
+                                'onRelayMessage',
+                                'Pairing not found',
+                            ];
+                            const shouldSkip = nonCriticalPatterns.some(pattern => context.includes(pattern) || msg.includes(pattern) || chunk.includes(pattern));
+                            if (!shouldSkip) {
+                                // Use console methods based on log level
+                                // These console calls are intentional for WalletConnect's internal pino logger
+                                // eslint-disable-next-line no-console
+                                const level = logObj.level || 50;
+                                if (level >= 50) {
+                                    // eslint-disable-next-line no-console
+                                    console.error(chunk);
+                                }
+                                else if (level >= 40) {
+                                    if (logLevel === 'warn' || logLevel === 'info' || logLevel === 'debug' || logLevel === 'trace') {
+                                        // eslint-disable-next-line no-console
+                                        console.warn(chunk);
+                                    }
+                                }
+                                else if (level >= 30 && (logLevel === 'info' || logLevel === 'debug' || logLevel === 'trace')) {
+                                    // eslint-disable-next-line no-console
+                                    console.info(chunk);
+                                }
+                                else if (level >= 20 && (logLevel === 'debug' || logLevel === 'trace')) {
+                                    // eslint-disable-next-line no-console
+                                    console.debug(chunk);
+                                }
+                                else if (level >= 10 && logLevel === 'trace') {
+                                    // eslint-disable-next-line no-console
+                                    console.trace(chunk);
+                                }
+                            }
+                        }
+                        catch (_e) {
+                            // If parsing fails, log it normally (shouldn't happen with pino)
+                            if (logLevel === 'error' || logLevel === 'warn') {
+                                // eslint-disable-next-line no-console
+                                console.error(chunk);
+                            }
+                        }
+                    }
+                };
+                // Create pino logger with filtered stream
+                return (0, pino_1.default)({
+                    level: logLevel,
+                }, filteredStream);
+            };
+            // Use custom metadata if provided, otherwise use default from config
+            const metadata = this.metadata ? {
+                name: this.metadata.name || wallet_connect_js_1.SIGN_CLIENT_CONFIG.metadata.name,
+                description: this.metadata.description || wallet_connect_js_1.SIGN_CLIENT_CONFIG.metadata.description,
+                url: this.metadata.url || wallet_connect_js_1.SIGN_CLIENT_CONFIG.metadata.url,
+                icons: this.metadata.icons || wallet_connect_js_1.SIGN_CLIENT_CONFIG.metadata.icons,
+            } : wallet_connect_js_1.SIGN_CLIENT_CONFIG.metadata;
+            const initOptions = {
+                // Use custom filtered logger or standard logger based on config
+                logger: createFilteredLogger(),
+                projectId: projectId,
+                metadata: metadata,
+            };
+            // Add relay URL if provided
+            if (wallet_connect_js_1.SIGN_CLIENT_CONFIG.relayUrl) {
+                initOptions.relayUrl = wallet_connect_js_1.SIGN_CLIENT_CONFIG.relayUrl;
+            }
+            // Create initialization promise to prevent concurrent initializations
+            globalSignClientPromise = sign_client_1.default.init(initOptions).then((signClient) => {
+                globalSignClient = signClient;
+                this.client = signClient;
+                globalSignClientPromise = null;
+                return signClient;
+            });
+            const signClient = await globalSignClientPromise;
+            // Initialize native WalletConnect modal for desktop (not iOS)
+            // iOS uses custom modal with better clipboard support
+            // Only initialize modal once per instance
+            if (!this.modal && !(0, deviceDetection_js_1.isIOS)() && typeof window !== 'undefined') {
+                const modalConfig = (0, wallet_connect_js_1.getModalConfig)();
+                if (modalConfig) {
+                    try {
+                        this.modal = new modal_1.WalletConnectModal(modalConfig);
+                        logger.debug('Native WalletConnect modal initialized for desktop', { theme: modalConfig.themeMode });
+                        // Set up theme observer to update modal when theme changes
+                        this.setupThemeObserver();
+                    }
+                    catch (modalError) {
+                        logger.error('Failed to initialize WalletConnect modal:', modalError);
+                        // Continue without modal - fallback to custom implementation
+                    }
+                }
+                else {
+                    logger.warn('WalletConnect modal not initialized: projectId is required');
+                }
+            }
+            return signClient;
+        }
+        catch (e) {
+            // Clear the promise on error so retry is possible
+            globalSignClientPromise = null;
+            react_hot_toast_1.toast.error(`Wallet - ${e}`);
+            throw e; // Re-throw to allow calling code to handle the error
+        }
+    }
+    async detectEvents() {
+        // Sign client
+        const signClient = await this.signClient();
+        if (!signClient)
+            return;
+        // If user disconnects from UI or wallet, refresh the page
+        signClient.on("session_delete", async ({ id, topic }) => {
+            // Check localstorage and ensure it is removed from there
+            // await this.deleteTopicFromLocalStorage(topic);
+            await this.updateSessions();
+            await this.updateConnectedWalletOnDisconnect(topic);
+        });
+    }
+}
+exports.default = WalletConnectIntegration;
+//# sourceMappingURL=walletConnect.js.map