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

package/lib/esm/index.mjs

@@ -1,4 +1,4 @@
-import { CONNECT_EVENT_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, SIGN_DATA_ERROR_CODES, Base64, SessionCrypto, hexToByteArray, CONNECT_ITEM_ERROR_CODES } from '@tonconnect/protocol';
+import { CONNECT_EVENT_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, SIGN_DATA_ERROR_CODES, Base64, SessionCrypto, hexToByteArray, DISCONNECT_ERROR_CODES, CONNECT_ITEM_ERROR_CODES } from '@tonconnect/protocol';
 export { CHAIN, CONNECT_EVENT_ERROR_CODES, CONNECT_ITEM_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, SIGN_DATA_ERROR_CODES, SessionCrypto } from '@tonconnect/protocol';
 import '@tonconnect/isomorphic-eventsource';
 import '@tonconnect/isomorphic-fetch';
@@ -177,6 +177,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.
@@ -920,7 +923,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)) {
@@ -959,7 +962,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)) {
@@ -993,8 +996,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;
         });
@@ -1005,8 +1008,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');
@@ -1020,8 +1023,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;
         });
@@ -3791,7 +3806,7 @@ class TonConnectTracker {
     }
 }
 
-const tonConnectSdkVersion = "3.4.0-beta.1";
+const tonConnectSdkVersion = "3.4.0-beta.2";
 
 const bounceableTag = 0x11;
 const noBounceableTag = 0x51;
@@ -3845,6 +3860,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
@@ -4687,6 +4705,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: 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: 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: SEND_TRANSACTION_ERROR_CODES.USER_REJECTS_ERROR,
+                            message
+                        }
+                    };
+                }
+                if (message.toLowerCase().includes('tonvalidationerror')) {
+                    return {
+                        id: DEFAULT_REQUEST_ID,
+                        traceId: options.traceId,
+                        error: {
+                            code: SEND_TRANSACTION_ERROR_CODES.BAD_REQUEST_ERROR,
+                            message
+                        }
+                    };
+                }
+                return {
+                    id: DEFAULT_REQUEST_ID,
+                    traceId: options.traceId,
+                    error: {
+                        code: SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR,
+                        message
+                    }
+                };
+            }
+            return {
+                id: DEFAULT_REQUEST_ID,
+                traceId: options.traceId,
+                error: {
+                    code: 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: 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: 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: 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.
@@ -4872,6 +5402,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);
@@ -4881,7 +5414,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();
@@ -5086,7 +5620,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) {
@@ -5172,6 +5706,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);
         }
@@ -5330,5 +5867,5 @@ TonConnect.isWalletInjected = (walletJSKey) => InjectedProvider.isWalletInjected
  */
 TonConnect.isInsideWalletBrowser = (walletJSKey) => InjectedProvider.isInsideWalletBrowser(walletJSKey);
 
-export { BadRequestError, BrowserEventDispatcher, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UUIDv7, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletMissingRequiredFeaturesError, WalletNotConnectedError, WalletNotInjectedError, WalletNotSupportFeatureError, WalletWrongNetworkError, WalletsListManager, WrongAddressError, checkRequiredWalletFeatures, createConnectionCompletedEvent, createConnectionErrorEvent, createConnectionRestoringCompletedEvent, createConnectionRestoringErrorEvent, createConnectionRestoringStartedEvent, createConnectionStartedEvent, createDataSentForSignatureEvent, createDataSignedEvent, createDataSigningFailedEvent, createDisconnectionEvent, createRequestVersionEvent, createResponseVersionEvent, createSelectedWalletEvent, createTransactionSentForSignatureEvent, createTransactionSignedEvent, createTransactionSigningFailedEvent, createVersionInfo, createWalletModalOpenedEvent, decodeTelegramUrlParameters, TonConnect as default, enableQaMode, encodeTelegramUrlParameters, isConnectUrl, isQaModeEnabled, isTelegramUrl, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
+export { BadRequestError, BrowserEventDispatcher, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UUIDv7, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletMissingRequiredFeaturesError, WalletNotConnectedError, WalletNotInjectedError, WalletNotSupportFeatureError, WalletWrongNetworkError, WalletsListManager, WrongAddressError, checkRequiredWalletFeatures, createConnectionCompletedEvent, createConnectionErrorEvent, createConnectionRestoringCompletedEvent, createConnectionRestoringErrorEvent, createConnectionRestoringStartedEvent, createConnectionStartedEvent, createDataSentForSignatureEvent, createDataSignedEvent, createDataSigningFailedEvent, createDisconnectionEvent, createRequestVersionEvent, createResponseVersionEvent, createSelectedWalletEvent, createTransactionSentForSignatureEvent, createTransactionSignedEvent, createTransactionSigningFailedEvent, createVersionInfo, createWalletModalOpenedEvent, decodeTelegramUrlParameters, TonConnect as default, enableQaMode, encodeTelegramUrlParameters, initializeWalletConnect, isConnectUrl, isQaModeEnabled, isTelegramUrl, isWalletConnectInitialized, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
 //# sourceMappingURL=index.mjs.map