@tonconnect/sdk 3.4.0-beta.1 → 3.4.0-beta.2

package/lib/cjs/index.cjs

@@ -180,6 +180,9 @@ class WalletWrongNetworkError extends TonConnectError {
 function isWalletConnectionSourceJS(value) {
     return 'jsBridgeKey' in value;
 }
+function isWalletConnectionSourceWalletConnect(value) {
+    return 'type' in value && value.type === 'wallet-connect';
+}
 
 /**
  * Thrown when user rejects the action in the wallet.
@@ -923,7 +926,7 @@ class BridgeConnectionStorage {
     }
     storeConnection(connection) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (connection.type === 'injected') {
+            if (connection.type === 'injected' || connection.type === 'wallet-connect') {
                 return this.storage.setItem(this.storeKey, JSON.stringify(connection));
             }
             if (!isPendingConnectionHttp(connection)) {
@@ -962,7 +965,7 @@ class BridgeConnectionStorage {
                 return null;
             }
             const connection = JSON.parse(stored);
-            if (connection.type === 'injected') {
+            if (connection.type === 'injected' || connection.type === 'wallet-connect') {
                 return connection;
             }
             if (!isPendingConnectionHttpRaw(connection)) {
@@ -996,8 +999,8 @@ class BridgeConnectionStorage {
             if (!connection) {
                 throw new TonConnectError('Trying to read HTTP connection source while nothing is stored');
             }
-            if (connection.type === 'injected') {
-                throw new TonConnectError('Trying to read HTTP connection source while injected connection is stored');
+            if (connection.type !== 'http') {
+                throw new TonConnectError(`Trying to read HTTP connection source while ${connection.type} connection is stored`);
             }
             return connection;
         });
@@ -1008,8 +1011,8 @@ class BridgeConnectionStorage {
             if (!connection) {
                 throw new TonConnectError('Trying to read HTTP connection source while nothing is stored');
             }
-            if (connection.type === 'injected') {
-                throw new TonConnectError('Trying to read HTTP connection source while injected connection is stored');
+            if (connection.type !== 'http') {
+                throw new TonConnectError(`Trying to read HTTP connection source while ${connection.type} connection is stored`);
             }
             if (!isPendingConnectionHttp(connection)) {
                 throw new TonConnectError('Trying to read HTTP-pending connection while http connection is stored');
@@ -1023,8 +1026,20 @@ class BridgeConnectionStorage {
             if (!connection) {
                 throw new TonConnectError('Trying to read Injected bridge connection source while nothing is stored');
             }
-            if ((connection === null || connection === void 0 ? void 0 : connection.type) === 'http') {
-                throw new TonConnectError('Trying to read Injected bridge connection source while HTTP connection is stored');
+            if ((connection === null || connection === void 0 ? void 0 : connection.type) !== 'injected') {
+                throw new TonConnectError(`Trying to read Injected bridge connection source while ${connection.type} connection is stored`);
+            }
+            return connection;
+        });
+    }
+    getWalletConnectConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            if (!connection) {
+                throw new TonConnectError('Trying to read wallet connect bridge connection source while nothing is stored');
+            }
+            if ((connection === null || connection === void 0 ? void 0 : connection.type) !== 'wallet-connect') {
+                throw new TonConnectError(`Trying to read wallet connect bridge connection source while ${connection.type} connection is stored`);
             }
             return connection;
         });
@@ -3794,7 +3809,7 @@ class TonConnectTracker {
     }
 }
 
-const tonConnectSdkVersion = "3.4.0-beta.1";
+const tonConnectSdkVersion = "3.4.0-beta.2";
 
 const bounceableTag = 0x11;
 const noBounceableTag = 0x51;
@@ -3848,6 +3863,9 @@ function isValidRawAddress(address) {
         return false;
     }
 }
+function toRawAddress({ wc, hex }) {
+    return `${wc}:${hex}`;
+}
 /**
  * Parses user-friendly address and returns its components.
  * @param address user-friendly address
@@ -4690,6 +4708,518 @@ class DefaultEnvironment {
     }
 }
 
+const state = {};
+/**
+ * Initializes the WalletConnect integration.
+ *
+ * This function must be called once before using WalletConnect features.
+ * A second call will throw an error to prevent accidental re-initialization.
+ *
+ * @param UniversalConnectorCls - A UniversalConnector class imported from '@reown/appkit-universal-connector'
+ * @param {WalletConnectOptions} walletConnectOptions - Configuration options used for initializing WalletConnect.
+ * @example
+ * import { UniversalConnector } from '@reown/appkit-universal-connector';
+ *
+ * initializeWalletConnect(UniversalConnector, {
+ *     projectId: 'abcd1234abcd1234abcd1234abcd1234',
+ *     metadata: {
+ *         name: 'Demo DApp',
+ *         icons: [
+ *             'https://example.com/my-icon.png'
+ *         ],
+ *         url: window.location.origin,
+ *         description: 'Demo DApp'
+ *     }
+ * });
+ */
+function initializeWalletConnect(UniversalConnectorCls, walletConnectOptions) {
+    if ((state === null || state === void 0 ? void 0 : state.walletConnectOptions) !== undefined || (state === null || state === void 0 ? void 0 : state.UniversalConnectorCls) !== undefined) {
+        throw new TonConnectError('Wallet Connect already initialized.');
+    }
+    if (typeof UniversalConnectorCls !== 'function' || !('init' in UniversalConnectorCls)) {
+        throw new TonConnectError('Initialize UniversalConnectorCls must be set');
+    }
+    state.UniversalConnectorCls = UniversalConnectorCls;
+    state.walletConnectOptions = walletConnectOptions;
+}
+function isWalletConnectInitialized() {
+    return state.UniversalConnectorCls !== undefined && state.walletConnectOptions !== undefined;
+}
+function getUniversalConnector() {
+    if (state.UniversalConnectorCls === undefined) {
+        throw new TonConnectError('Wallet Connect is not initialized.');
+    }
+    return state.UniversalConnectorCls;
+}
+function getWalletConnectOptions() {
+    if (state.walletConnectOptions === undefined) {
+        throw new TonConnectError('Wallet Connect is not initialized.');
+    }
+    return state.walletConnectOptions;
+}
+
+const DEFAULT_REQUEST_ID = '0';
+const DEFAULT_EVENT_ID = 0;
+class WalletConnectProvider {
+    constructor(storage) {
+        this.type = 'injected';
+        this.listeners = [];
+        this.connector = undefined;
+        this.connectionStorage = new BridgeConnectionStorage(storage);
+        const { projectId, metadata } = getWalletConnectOptions();
+        this.config = {
+            networks: [
+                {
+                    namespace: 'ton',
+                    chains: [
+                        {
+                            id: -239,
+                            chainNamespace: 'ton',
+                            caipNetworkId: 'ton:-239',
+                            name: 'TON',
+                            nativeCurrency: { name: 'TON', symbol: 'TON', decimals: 9 },
+                            rpcUrls: { default: { http: [] } }
+                        },
+                        {
+                            id: -3,
+                            chainNamespace: 'ton',
+                            caipNetworkId: 'ton:-3',
+                            name: 'TON',
+                            nativeCurrency: { name: 'TON', symbol: 'TON', decimals: 9 },
+                            rpcUrls: { default: { http: [] } }
+                        }
+                    ],
+                    methods: ['ton_sendMessage', 'ton_signData'],
+                    events: []
+                }
+            ],
+            projectId,
+            metadata
+        };
+    }
+    static fromStorage(storage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new WalletConnectProvider(storage);
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connector) {
+                this.connector = yield getUniversalConnector().init(this.config);
+            }
+            return this.connector;
+        });
+    }
+    connect(message, options) {
+        var _a, _b;
+        const traceId = (_a = options === null || options === void 0 ? void 0 : options.traceId) !== null && _a !== void 0 ? _a : UUIDv7();
+        const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+        (_b = this.abortController) === null || _b === void 0 ? void 0 : _b.abort();
+        this.abortController = abortController;
+        void this._connect(message, {
+            traceId,
+            signal: abortController.signal,
+            abortController
+        }).catch(error => logDebug('WalletConnect connect unexpected error', error));
+    }
+    _connect(message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const connector = yield this.initialize();
+            if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                logDebug('WalletConnect connect aborted before start');
+                this.clearAbortController(options.abortController);
+                return;
+            }
+            const tonProof = message.items.find(item => item.name === 'ton_proof');
+            const authentication = tonProof
+                ? [
+                    {
+                        domain: new URL(this.config.metadata.url).hostname,
+                        chains: ['ton:-239'],
+                        nonce: '',
+                        uri: 'ton_proof',
+                        ttl: 0,
+                        statement: tonProof.payload
+                    }
+                ]
+                : undefined;
+            logDebug('Connecting through this.connector.connect');
+            try {
+                yield connector.connect({ authentication });
+            }
+            catch (error) {
+                if ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                    logDebug('WalletConnect connect aborted via signal');
+                    this.clearAbortController(options.abortController);
+                    return;
+                }
+                logDebug('WalletConnect connect error', error);
+                const event = {
+                    id: DEFAULT_EVENT_ID,
+                    event: 'connect_error',
+                    traceId: options.traceId,
+                    payload: {
+                        code: protocol.CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR,
+                        message: 'User declined the connection'
+                    }
+                };
+                logDebug('WalletConnect connect response:', event);
+                this.emit(event);
+                this.clearAbortController(options.abortController);
+                return;
+            }
+            logDebug('Connected through this.connector.connect');
+            try {
+                yield this.onConnect(connector, Object.assign(Object.assign({}, options), { includeTonProof: true }));
+            }
+            catch (error) {
+                logDebug('WalletConnect onConnect error', error);
+                yield this.disconnect({ traceId: options.traceId, signal: options.signal });
+            }
+            finally {
+                this.clearAbortController(options.abortController);
+            }
+        });
+    }
+    restoreConnection(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const traceId = (_a = options === null || options === void 0 ? void 0 : options.traceId) !== null && _a !== void 0 ? _a : UUIDv7();
+            const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+            (_b = this.abortController) === null || _b === void 0 ? void 0 : _b.abort();
+            this.abortController = abortController;
+            if (abortController.signal.aborted) {
+                return;
+            }
+            try {
+                logDebug('Restoring WalletConnect connection...');
+                const storedConnection = yield this.connectionStorage.getWalletConnectConnection();
+                if (!storedConnection || abortController.signal.aborted) {
+                    return;
+                }
+                const connector = yield this.initialize();
+                if (abortController.signal.aborted) {
+                    return;
+                }
+                yield this.onConnect(connector, {
+                    includeTonProof: false,
+                    traceId,
+                    signal: abortController.signal
+                });
+                logDebug('WalletConnect successfully restored.');
+            }
+            catch (error) {
+                logDebug('WalletConnect restore error', error);
+                yield this.disconnect({ traceId, signal: abortController.signal });
+            }
+            finally {
+                this.clearAbortController(abortController);
+            }
+        });
+    }
+    closeConnection() {
+        var _a;
+        (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        this.abortController = undefined;
+        void this.disconnect();
+    }
+    disconnect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+            (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+            this.abortController = abortController;
+            if (abortController.signal.aborted) {
+                return;
+            }
+            try {
+                yield this.connectionStorage.removeConnection();
+                if (abortController.signal.aborted) {
+                    return;
+                }
+                yield ((_b = this.connector) === null || _b === void 0 ? void 0 : _b.disconnect());
+            }
+            catch (error) {
+                logDebug('WalletConnect disconnect error', error);
+            }
+            finally {
+                this.clearAbortController(abortController);
+            }
+        });
+    }
+    sendRequest(request, optionsOrOnRequestSent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.connector) {
+                throw new TonConnectError('Wallet Connect not initialized');
+            }
+            const options = {};
+            if (typeof optionsOrOnRequestSent === 'function') {
+                options.onRequestSent = optionsOrOnRequestSent;
+            }
+            else {
+                options.onRequestSent = optionsOrOnRequestSent === null || optionsOrOnRequestSent === void 0 ? void 0 : optionsOrOnRequestSent.onRequestSent;
+                options.signal = optionsOrOnRequestSent === null || optionsOrOnRequestSent === void 0 ? void 0 : optionsOrOnRequestSent.signal;
+                options.attempts = optionsOrOnRequestSent === null || optionsOrOnRequestSent === void 0 ? void 0 : optionsOrOnRequestSent.attempts;
+                options.traceId = optionsOrOnRequestSent === null || optionsOrOnRequestSent === void 0 ? void 0 : optionsOrOnRequestSent.traceId;
+            }
+            (_a = options.traceId) !== null && _a !== void 0 ? _a : (options.traceId = UUIDv7());
+            try {
+                if ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                    throw new TonConnectError('WalletConnect request aborted');
+                }
+                logDebug('Send wallet-connect request:', Object.assign(Object.assign({}, request), { id: DEFAULT_REQUEST_ID }));
+                if (request.method === 'sendTransaction') {
+                    const _e = JSON.parse(request.params[0]), { network } = _e, sendTransactionPayload = __rest(_e, ["network"]);
+                    const promise = this.connector.request({
+                        method: 'ton_sendMessage',
+                        params: sendTransactionPayload
+                    }, `ton:${network}`);
+                    (_c = options === null || options === void 0 ? void 0 : options.onRequestSent) === null || _c === void 0 ? void 0 : _c.call(options);
+                    const result = (yield promise);
+                    logDebug('Wallet message received:', { result, id: DEFAULT_REQUEST_ID });
+                    return {
+                        result,
+                        id: DEFAULT_REQUEST_ID,
+                        traceId: options.traceId
+                    };
+                }
+                else if (request.method === 'signData') {
+                    const _f = JSON.parse(request.params[0]), { network } = _f, signDataPayload = __rest(_f, ["network"]);
+                    const promise = this.connector.request({
+                        method: 'ton_signData',
+                        params: signDataPayload
+                    }, `ton:${network}`);
+                    (_d = options === null || options === void 0 ? void 0 : options.onRequestSent) === null || _d === void 0 ? void 0 : _d.call(options);
+                    const result = (yield promise);
+                    logDebug('Wallet message received:', { result, id: DEFAULT_REQUEST_ID });
+                    return { result, traceId: options.traceId, id: DEFAULT_REQUEST_ID };
+                }
+                else if (request.method === 'disconnect') {
+                    return {
+                        id: DEFAULT_REQUEST_ID,
+                        traceId: options.traceId
+                    };
+                }
+            }
+            catch (error) {
+                logDebug('WalletConnect request error', error, error.stack);
+                const result = (yield this.handleWalletConnectError(error, {
+                    traceId: options.traceId
+                }));
+                logDebug('Wallet message received:', result);
+                return result;
+            }
+            return {
+                id: DEFAULT_REQUEST_ID,
+                error: { code: protocol.DISCONNECT_ERROR_CODES.UNKNOWN_ERROR, message: 'Not implemented.' },
+                traceId: options.traceId
+            };
+        });
+    }
+    handleWalletConnectError(error, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof error === 'object' && error !== null) {
+                const message = String('message' in error ? error.message : 'msg' in error ? error.msg : error);
+                if (message.toLowerCase().includes('reject')) {
+                    return {
+                        id: DEFAULT_REQUEST_ID,
+                        traceId: options.traceId,
+                        error: {
+                            code: protocol.SEND_TRANSACTION_ERROR_CODES.USER_REJECTS_ERROR,
+                            message
+                        }
+                    };
+                }
+                if (message.toLowerCase().includes('tonvalidationerror')) {
+                    return {
+                        id: DEFAULT_REQUEST_ID,
+                        traceId: options.traceId,
+                        error: {
+                            code: protocol.SEND_TRANSACTION_ERROR_CODES.BAD_REQUEST_ERROR,
+                            message
+                        }
+                    };
+                }
+                return {
+                    id: DEFAULT_REQUEST_ID,
+                    traceId: options.traceId,
+                    error: {
+                        code: protocol.SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR,
+                        message
+                    }
+                };
+            }
+            return {
+                id: DEFAULT_REQUEST_ID,
+                traceId: options.traceId,
+                error: {
+                    code: protocol.SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR,
+                    message: String(error)
+                }
+            };
+        });
+    }
+    listen(callback) {
+        this.listeners.push(callback);
+        return () => (this.listeners = this.listeners.filter(listener => listener !== callback));
+    }
+    buildTonProof(connector) {
+        var _a, _b, _c;
+        const auth = (_a = connector.provider.session.authentication) === null || _a === void 0 ? void 0 : _a[0];
+        const iat = (_b = auth === null || auth === void 0 ? void 0 : auth.p) === null || _b === void 0 ? void 0 : _b.iat;
+        const statement = (_c = auth === null || auth === void 0 ? void 0 : auth.p) === null || _c === void 0 ? void 0 : _c.statement;
+        if (!iat || !statement) {
+            return;
+        }
+        const domain = auth.p.domain;
+        return {
+            name: 'ton_proof',
+            proof: {
+                timestamp: Math.floor(new Date(iat).getTime() / 1000),
+                domain: {
+                    lengthBytes: domain.length,
+                    value: domain
+                },
+                payload: statement,
+                signature: auth.s.s
+            }
+        };
+    }
+    onConnect(connector, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                logDebug('WalletConnect onConnect aborted');
+                return;
+            }
+            const session = connector.provider.session;
+            const tonNamespace = session.namespaces['ton'];
+            if (!((_b = tonNamespace === null || tonNamespace === void 0 ? void 0 : tonNamespace.accounts) === null || _b === void 0 ? void 0 : _b[0])) {
+                yield this.disconnectWithError({
+                    traceId: options.traceId,
+                    code: protocol.CONNECT_EVENT_ERROR_CODES.BAD_REQUEST_ERROR,
+                    message: 'Connection error. No TON accounts connected.'
+                });
+                return;
+            }
+            const account = tonNamespace.accounts[0];
+            const [, network, address] = account.split(':', 3);
+            const publicKey = (_c = session.sessionProperties) === null || _c === void 0 ? void 0 : _c.ton_getPublicKey;
+            if (!publicKey) {
+                yield this.disconnectWithError({
+                    traceId: options.traceId,
+                    code: protocol.CONNECT_EVENT_ERROR_CODES.BAD_REQUEST_ERROR,
+                    message: 'Connection error. No sessionProperties.ton_getPublicKey provided.'
+                });
+                return;
+            }
+            const stateInit = (_d = session.sessionProperties) === null || _d === void 0 ? void 0 : _d.ton_getStateInit;
+            if (!stateInit) {
+                yield this.disconnectWithError({
+                    traceId: options.traceId,
+                    code: protocol.CONNECT_EVENT_ERROR_CODES.BAD_REQUEST_ERROR,
+                    message: 'Connection error. No sessionProperties.ton_getStateInit provided.'
+                });
+                return;
+            }
+            connector.provider.once('session_delete', () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connectionStorage.removeConnection();
+                    const event = {
+                        event: 'disconnect',
+                        traceId: UUIDv7(),
+                        payload: {}
+                    };
+                    logDebug('Wallet message received:', event);
+                    this.emit(event);
+                }
+                catch (err) {
+                    logDebug('Error while deleting session', err);
+                }
+            }));
+            const tonProof = (options === null || options === void 0 ? void 0 : options.includeTonProof) ? this.buildTonProof(connector) : undefined;
+            const parsedAddress = isValidUserFriendlyAddress(address)
+                ? toRawAddress(parseUserFriendlyAddress(address))
+                : address;
+            const features = this.buildFeatureList(tonNamespace.methods);
+            const payload = {
+                items: [
+                    {
+                        name: 'ton_addr',
+                        address: parsedAddress,
+                        network: network,
+                        publicKey,
+                        walletStateInit: stateInit
+                    },
+                    ...(tonProof ? [tonProof] : [])
+                ],
+                device: {
+                    appName: 'wallet_connect',
+                    appVersion: '',
+                    maxProtocolVersion: 2,
+                    features,
+                    platform: 'browser'
+                }
+            };
+            logDebug('WalletConnect connect response:', {
+                event: 'connect',
+                payload,
+                id: DEFAULT_EVENT_ID
+            });
+            this.emit({ event: 'connect', payload, traceId: options.traceId });
+            yield this.storeConnection();
+        });
+    }
+    buildFeatureList(methods) {
+        const features = [];
+        if (methods.includes('ton_sendMessage')) {
+            features.push('SendTransaction', {
+                name: 'SendTransaction',
+                maxMessages: 4,
+                extraCurrencySupported: false
+            });
+        }
+        if (methods.includes('ton_signData')) {
+            features.push({ name: 'SignData', types: ['text', 'binary', 'cell'] });
+        }
+        return features;
+    }
+    disconnectWithError(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.disconnect();
+            const payload = {
+                code: options.code,
+                message: options.message
+            };
+            logDebug('WalletConnect connect response:', {
+                event: 'connect_error',
+                id: DEFAULT_EVENT_ID,
+                payload
+            });
+            this.emit({
+                event: 'connect_error',
+                traceId: options.traceId,
+                payload
+            });
+        });
+    }
+    clearAbortController(abortController) {
+        if (this.abortController === abortController) {
+            this.abortController = undefined;
+        }
+    }
+    emit(event, listeners) {
+        (listeners !== null && listeners !== void 0 ? listeners : this.listeners).forEach(listener => listener(event));
+    }
+    storeConnection() {
+        return this.connectionStorage.storeConnection({
+            type: 'wallet-connect'
+        });
+    }
+}
+
 class TonConnect {
     /**
      * Returns available wallets list.
@@ -4875,6 +5405,9 @@ class TonConnect {
                     case 'injected':
                         provider = yield InjectedProvider.fromStorage(this.dappSettings.storage, this.analytics);
                         break;
+                    case 'wallet-connect':
+                        provider = yield WalletConnectProvider.fromStorage(this.dappSettings.storage);
+                        break;
                     default:
                         if (embeddedWallet) {
                             provider = this.createProvider(embeddedWallet);
@@ -4884,7 +5417,8 @@ class TonConnect {
                         }
                 }
             }
-            catch (_d) {
+            catch (err) {
+                logDebug('Provider is not restored', err);
                 this.tracker.trackConnectionRestoringError('Provider is not restored', traceId);
                 yield this.bridgeConnectionStorage.removeConnection();
                 provider === null || provider === void 0 ? void 0 : provider.closeConnection();
@@ -5089,7 +5623,7 @@ class TonConnect {
             }
             try {
                 const connection = yield this.bridgeConnectionStorage.getConnection();
-                if (!connection || connection.type === 'injected') {
+                if (!connection || connection.type !== 'http') {
                     return null;
                 }
                 if ('sessionCrypto' in connection) {
@@ -5175,6 +5709,9 @@ class TonConnect {
         if (!Array.isArray(wallet) && isWalletConnectionSourceJS(wallet)) {
             provider = new InjectedProvider(this.dappSettings.storage, wallet.jsBridgeKey, this.analytics);
         }
+        else if (!Array.isArray(wallet) && isWalletConnectionSourceWalletConnect(wallet)) {
+            provider = new WalletConnectProvider(this.dappSettings.storage);
+        }
         else {
             provider = new BridgeProvider(this.dappSettings.storage, wallet, this.analytics);
         }
@@ -5399,9 +5936,11 @@ exports.decodeTelegramUrlParameters = decodeTelegramUrlParameters;
 exports.default = TonConnect;
 exports.enableQaMode = enableQaMode;
 exports.encodeTelegramUrlParameters = encodeTelegramUrlParameters;
+exports.initializeWalletConnect = initializeWalletConnect;
 exports.isConnectUrl = isConnectUrl;
 exports.isQaModeEnabled = isQaModeEnabled;
 exports.isTelegramUrl = isTelegramUrl;
+exports.isWalletConnectInitialized = isWalletConnectInitialized;
 exports.isWalletInfoCurrentlyEmbedded = isWalletInfoCurrentlyEmbedded;
 exports.isWalletInfoCurrentlyInjected = isWalletInfoCurrentlyInjected;
 exports.isWalletInfoInjectable = isWalletInfoInjectable;