@tonconnect/sdk 3.0.0 → 3.0.1-beta.1

package/lib/esm/index.mjs

@@ -343,6 +343,217 @@ function encodeTelegramUrlParameters(parameters) {
         .replaceAll('%', '--');
 }
 
+/**
+ * Delays the execution of code for a specified number of milliseconds.
+ * @param {number} timeout - The number of milliseconds to delay the execution.
+ * @param {DelayOptions} [options] - Optional configuration options for the delay.
+ * @return {Promise<void>} - A promise that resolves after the specified delay, or rejects if the delay is aborted.
+ */
+function delay(timeout, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            var _a, _b;
+            if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                reject(new TonConnectError('Delay aborted'));
+                return;
+            }
+            const timeoutId = setTimeout(() => resolve(), timeout);
+            (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', () => {
+                clearTimeout(timeoutId);
+                reject(new TonConnectError('Delay aborted'));
+            });
+        });
+    });
+}
+
+/**
+ * Creates an AbortController instance with an optional AbortSignal.
+ *
+ * @param {AbortSignal} [signal] - An optional AbortSignal to use for aborting the controller.
+ * @returns {AbortController} - An instance of AbortController.
+ */
+function createAbortController(signal) {
+    const abortController = new AbortController();
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        abortController.abort();
+    }
+    else {
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => abortController.abort(), { once: true });
+    }
+    return abortController;
+}
+
+/**
+ * Function to call ton api until we get response.
+ * Because ton network is pretty unstable we need to make sure response is final.
+ * @param {T} fn - function to call
+ * @param {CallForSuccessOptions} [options] - optional configuration options
+ */
+function callForSuccess(fn, options) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const attempts = (_a = options === null || options === void 0 ? void 0 : options.attempts) !== null && _a !== void 0 ? _a : 10;
+        const delayMs = (_b = options === null || options === void 0 ? void 0 : options.delayMs) !== null && _b !== void 0 ? _b : 200;
+        const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+        if (typeof fn !== 'function') {
+            throw new TonConnectError(`Expected a function, got ${typeof fn}`);
+        }
+        let i = 0;
+        let lastError;
+        while (i < attempts) {
+            if (abortController.signal.aborted) {
+                throw new TonConnectError(`Aborted after attempts ${i}`);
+            }
+            try {
+                return yield fn({ signal: abortController.signal });
+            }
+            catch (err) {
+                lastError = err;
+                i++;
+                if (i < attempts) {
+                    yield delay(delayMs);
+                }
+            }
+        }
+        throw lastError;
+    });
+}
+
+function logDebug(...args) {
+    {
+        try {
+            console.debug('[TON_CONNECT_SDK]', ...args);
+        }
+        catch (_a) { }
+    }
+}
+function logError(...args) {
+    {
+        try {
+            console.error('[TON_CONNECT_SDK]', ...args);
+        }
+        catch (_a) { }
+    }
+}
+function logWarning(...args) {
+    {
+        try {
+            console.warn('[TON_CONNECT_SDK]', ...args);
+        }
+        catch (_a) { }
+    }
+}
+
+/**
+ * Create a resource.
+ *
+ * @template T - The type of the resource.
+ * @template Args - The type of the arguments for creating the resource.
+ *
+ * @param {(...args: Args) => Promise<T>} createFn - A function that creates the resource.
+ * @param {(resource: T) => Promise<void>} [disposeFn] - An optional function that disposes the resource.
+ */
+function createResource(createFn, disposeFn) {
+    let currentResource = null;
+    let currentArgs = null;
+    let currentPromise = null;
+    let currentSignal = null;
+    let abortController = null;
+    // create a new resource
+    const create = (signal, ...args) => __awaiter(this, void 0, void 0, function* () {
+        currentSignal = signal !== null && signal !== void 0 ? signal : null;
+        abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+        abortController = createAbortController(signal);
+        if (abortController.signal.aborted) {
+            throw new TonConnectError('Resource creation was aborted');
+        }
+        currentArgs = args !== null && args !== void 0 ? args : null;
+        const promise = createFn(signal, ...args);
+        currentPromise = promise;
+        const resource = yield promise;
+        if (currentPromise !== promise) {
+            yield disposeFn(resource);
+            throw new TonConnectError('Resource creation was aborted by a new resource creation');
+        }
+        currentResource = resource;
+        return currentResource;
+    });
+    // get the current resource
+    const current = () => {
+        return currentResource !== null && currentResource !== void 0 ? currentResource : null;
+    };
+    // dispose the current resource
+    const dispose = () => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const resource = currentResource;
+            currentResource = null;
+            const promise = currentPromise;
+            currentPromise = null;
+            abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+            yield Promise.allSettled([
+                resource ? disposeFn(resource) : Promise.resolve(),
+                promise ? disposeFn(yield promise) : Promise.resolve()
+            ]);
+        }
+        catch (e) {
+            logError('Failed to dispose the resource', e);
+        }
+    });
+    // recreate the current resource
+    const recreate = (delayMs) => __awaiter(this, void 0, void 0, function* () {
+        const resource = currentResource;
+        const promise = currentPromise;
+        const args = currentArgs;
+        const signal = currentSignal;
+        yield delay(delayMs);
+        if (resource === currentResource &&
+            promise === currentPromise &&
+            args === currentArgs &&
+            signal === currentSignal) {
+            return create(currentSignal, ...(args !== null && args !== void 0 ? args : []));
+        }
+        throw new TonConnectError('Resource recreation was aborted by a new resource creation');
+    });
+    return {
+        create,
+        current,
+        dispose,
+        recreate
+    };
+}
+
+/**
+ * Executes a function and provides deferred behavior, allowing for a timeout and abort functionality.
+ *
+ * @param {Deferrable<T>} fn - The function to execute. It should return a promise that resolves with the desired result.
+ * @param {DeferOptions} options - Optional configuration options for the defer behavior.
+ * @returns {Promise<T>} - A promise that resolves with the result of the executed function, or rejects with an error if it times out or is aborted.
+ */
+function timeout(fn, options) {
+    const timeout = options === null || options === void 0 ? void 0 : options.timeout;
+    const signal = options === null || options === void 0 ? void 0 : options.signal;
+    const abortController = createAbortController(signal);
+    return new Promise((resolve, reject) => {
+        if (abortController.signal.aborted) {
+            reject(new TonConnectError('Operation aborted'));
+            return;
+        }
+        let timeoutId;
+        if (typeof timeout !== 'undefined') {
+            timeoutId = setTimeout(() => {
+                abortController.abort();
+                reject(new TonConnectError(`Timeout after ${timeout}ms`));
+            }, timeout);
+        }
+        abortController.signal.addEventListener('abort', () => {
+            clearTimeout(timeoutId);
+            reject(new TonConnectError('Operation aborted'));
+        }, { once: true });
+        const deferOptions = { timeout, abort: abortController.signal };
+        fn(resolve, reject, deferOptions).finally(() => clearTimeout(timeoutId));
+    });
+}
+
 class BridgeGateway {
     constructor(storage, bridgeUrl, sessionId, listener, errorsListener) {
         this.bridgeUrl = bridgeUrl;
@@ -353,67 +564,85 @@ class BridgeGateway {
         this.postPath = 'message';
         this.heartbeatMessage = 'heartbeat';
         this.defaultTtl = 300;
-        this.isClosed = false;
+        this.defaultReconnectDelay = 5000;
+        this.eventSource = createResource((signal, openingDeadlineMS) => __awaiter(this, void 0, void 0, function* () {
+            const eventSourceConfig = {
+                bridgeUrl: this.bridgeUrl,
+                ssePath: this.ssePath,
+                sessionId: this.sessionId,
+                bridgeGatewayStorage: this.bridgeGatewayStorage,
+                errorHandler: this.errorsHandler.bind(this),
+                messageHandler: this.messagesHandler.bind(this),
+                signal: signal,
+                openingDeadlineMS: openingDeadlineMS
+            };
+            return yield createEventSource(eventSourceConfig);
+        }), (resource) => __awaiter(this, void 0, void 0, function* () {
+            resource.close();
+        }));
         this.bridgeGatewayStorage = new HttpBridgeGatewayStorage(storage, bridgeUrl);
     }
+    get isReady() {
+        const eventSource = this.eventSource.current();
+        return (eventSource === null || eventSource === void 0 ? void 0 : eventSource.readyState) === EventSource.OPEN;
+    }
+    get isClosed() {
+        const eventSource = this.eventSource.current();
+        return (eventSource === null || eventSource === void 0 ? void 0 : eventSource.readyState) !== EventSource.OPEN;
+    }
+    get isConnecting() {
+        const eventSource = this.eventSource.current();
+        return (eventSource === null || eventSource === void 0 ? void 0 : eventSource.readyState) === EventSource.CONNECTING;
+    }
     registerSession(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const url = new URL(addPathToUrl(this.bridgeUrl, this.ssePath));
-            url.searchParams.append('client_id', this.sessionId);
-            const lastEventId = yield this.bridgeGatewayStorage.getLastEventId();
-            if (this.isClosed) {
-                return;
-            }
-            if (lastEventId) {
-                url.searchParams.append('last_event_id', lastEventId);
-            }
-            this.eventSource = new EventSource(url.toString());
-            return new Promise((resolve, reject) => {
-                const timeout = (options === null || options === void 0 ? void 0 : options.openingDeadlineMS) ? setTimeout(() => {
-                    var _a;
-                    if (((_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.readyState) !== EventSource.OPEN) {
-                        reject(new TonConnectError('Bridge connection timeout'));
-                        this.close();
-                    }
-                }, options.openingDeadlineMS) : undefined;
-                this.eventSource.onerror = () => reject;
-                this.eventSource.onopen = () => {
-                    clearTimeout(timeout);
-                    this.isClosed = false;
-                    this.eventSource.onerror = this.errorsHandler.bind(this);
-                    this.eventSource.onmessage = this.messagesHandler.bind(this);
-                    resolve();
-                };
-            });
+            yield this.eventSource.create(options === null || options === void 0 ? void 0 : options.signal, options === null || options === void 0 ? void 0 : options.openingDeadlineMS);
         });
     }
-    send(message, receiver, topic, ttl) {
+    send(message, receiver, topic, ttlOrOptions) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            // TODO: remove deprecated method
+            const options = {};
+            if (typeof ttlOrOptions === 'number') {
+                options.ttl = ttlOrOptions;
+            }
+            else {
+                options.ttl = ttlOrOptions === null || ttlOrOptions === void 0 ? void 0 : ttlOrOptions.ttl;
+                options.signal = ttlOrOptions === null || ttlOrOptions === void 0 ? void 0 : ttlOrOptions.signal;
+                options.attempts = ttlOrOptions === null || ttlOrOptions === void 0 ? void 0 : ttlOrOptions.attempts;
+            }
             const url = new URL(addPathToUrl(this.bridgeUrl, this.postPath));
             url.searchParams.append('client_id', this.sessionId);
             url.searchParams.append('to', receiver);
-            url.searchParams.append('ttl', (ttl || this.defaultTtl).toString());
+            url.searchParams.append('ttl', ((options === null || options === void 0 ? void 0 : options.ttl) || this.defaultTtl).toString());
             url.searchParams.append('topic', topic);
-            const response = yield fetch(url, {
-                method: 'post',
-                body: Base64.encode(message)
+            const body = Base64.encode(message);
+            yield callForSuccess((options) => __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.post(url, body, options.signal);
+                if (!response.ok) {
+                    throw new TonConnectError(`Bridge send failed, status ${response.status}`);
+                }
+            }), {
+                attempts: (_a = options === null || options === void 0 ? void 0 : options.attempts) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER,
+                delayMs: 5000,
+                signal: options === null || options === void 0 ? void 0 : options.signal
             });
-            if (!response.ok) {
-                throw new TonConnectError(`Bridge send failed, status ${response.status}`);
-            }
         });
     }
     pause() {
-        var _a;
-        (_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.close();
+        this.eventSource.dispose().catch(e => logError(`Bridge pause failed, ${e}`));
     }
     unPause() {
-        return this.registerSession();
+        return __awaiter(this, void 0, void 0, function* () {
+            const RECREATE_WITHOUT_DELAY = 0;
+            yield this.eventSource.recreate(RECREATE_WITHOUT_DELAY);
+        });
     }
     close() {
-        var _a;
-        this.isClosed = true;
-        (_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.close();
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.eventSource.dispose().catch(e => logError(`Bridge close failed, ${e}`));
+        });
     }
     setListener(listener) {
         this.listener = listener;
@@ -421,20 +650,38 @@ class BridgeGateway {
     setErrorsListener(errorsListener) {
         this.errorsListener = errorsListener;
     }
-    errorsHandler(e) {
-        var _a, _b;
-        if (!this.isClosed) {
-            if (((_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.readyState) === EventSource.CLOSED) {
-                this.eventSource.close();
-                this.registerSession();
-                return;
+    post(url, body, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(url, {
+                method: 'post',
+                body: body,
+                signal: signal
+            });
+            if (!response.ok) {
+                throw new TonConnectError(`Bridge send failed, status ${response.status}`);
             }
-            if (((_b = this.eventSource) === null || _b === void 0 ? void 0 : _b.readyState) === EventSource.CONNECTING) {
-                console.debug('[TON_CONNET_SDK_ERROR]: Bridge error', JSON.stringify(e));
-                return;
+            return response;
+        });
+    }
+    errorsHandler(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isConnecting) {
+                    logError('Bridge error', JSON.stringify(e));
+                    return;
+                }
+                if (this.isReady) {
+                    this.errorsListener(e);
+                    return;
+                }
+                if (this.isClosed) {
+                    logDebug(`Bridge reconnecting, ${this.defaultReconnectDelay}ms delay`);
+                    yield this.eventSource.recreate(this.defaultReconnectDelay);
+                    return;
+                }
             }
-            this.errorsListener(e);
-        }
+            catch (e) { }
+        });
     }
     messagesHandler(e) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -442,19 +689,71 @@ class BridgeGateway {
                 return;
             }
             yield this.bridgeGatewayStorage.storeLastEventId(e.lastEventId);
-            if (!this.isClosed) {
-                let bridgeIncomingMessage;
-                try {
-                    bridgeIncomingMessage = JSON.parse(e.data);
-                }
-                catch (e) {
-                    throw new TonConnectError(`Bridge message parse failed, message ${e.data}`);
-                }
-                this.listener(bridgeIncomingMessage);
+            if (this.isClosed) {
+                return;
+            }
+            let bridgeIncomingMessage;
+            try {
+                bridgeIncomingMessage = JSON.parse(e.data);
             }
+            catch (e) {
+                throw new TonConnectError(`Bridge message parse failed, message ${e.data}`);
+            }
+            this.listener(bridgeIncomingMessage);
         });
     }
 }
+/**
+ * Creates an event source.
+ * @param {CreateEventSourceConfig} config - Configuration for creating an event source.
+ */
+function createEventSource(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield timeout((resolve, reject, deferOptions) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const abortController = createAbortController(deferOptions.signal);
+            const signal = abortController.signal;
+            if (signal.aborted) {
+                reject(new TonConnectError('Bridge connection aborted'));
+                return;
+            }
+            const url = new URL(addPathToUrl(config.bridgeUrl, config.ssePath));
+            url.searchParams.append('client_id', config.sessionId);
+            const lastEventId = yield config.bridgeGatewayStorage.getLastEventId();
+            if (lastEventId) {
+                url.searchParams.append('last_event_id', lastEventId);
+            }
+            if (signal.aborted) {
+                reject(new TonConnectError('Bridge connection aborted'));
+                return;
+            }
+            const eventSource = new EventSource(url.toString());
+            eventSource.onerror = (reason) => {
+                if (signal.aborted) {
+                    eventSource.close();
+                    reject(new TonConnectError('Bridge connection aborted'));
+                    return;
+                }
+                config.errorHandler(reason);
+            };
+            eventSource.onopen = () => {
+                if (signal.aborted) {
+                    eventSource.close();
+                    reject(new TonConnectError('Bridge connection aborted'));
+                    return;
+                }
+                resolve(eventSource);
+            };
+            eventSource.onmessage = (event) => {
+                config.messageHandler(event);
+            };
+            (_a = config.signal) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', () => {
+                eventSource.close();
+                reject(new TonConnectError('Bridge connection aborted'));
+            });
+        }), { timeout: config.openingDeadlineMS, signal: config.signal });
+    });
+}
 
 function isPendingConnectionHttp(connection) {
     return !('connectEvent' in connection);
@@ -619,31 +918,6 @@ class BridgeConnectionStorage {
 
 const PROTOCOL_VERSION = 2;
 
-function logDebug(...args) {
-    {
-        try {
-            console.debug('[TON_CONNECT_SDK]', ...args);
-        }
-        catch (_a) { }
-    }
-}
-function logError(...args) {
-    {
-        try {
-            console.error('[TON_CONNECT_SDK]', ...args);
-        }
-        catch (_a) { }
-    }
-}
-function logWarning(...args) {
-    {
-        try {
-            console.warn('[TON_CONNECT_SDK]', ...args);
-        }
-        catch (_a) { }
-    }
-}
-
 class BridgeProvider {
     constructor(storage, walletConnectionSource) {
         this.storage = storage;
@@ -655,6 +929,7 @@ class BridgeProvider {
         this.gateway = null;
         this.pendingGateways = [];
         this.listeners = [];
+        this.defaultOpeningDeadlineMS = 5000;
         this.connectionStorage = new BridgeConnectionStorage(storage);
     }
     static fromStorage(storage) {
@@ -667,7 +942,11 @@ class BridgeProvider {
             return new BridgeProvider(storage, { bridgeUrl: connection.session.bridgeUrl });
         });
     }
-    connect(message) {
+    connect(message, options) {
+        var _a;
+        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;
         this.closeGateways();
         const sessionCrypto = new SessionCrypto();
         this.session = {
@@ -682,20 +961,43 @@ class BridgeProvider {
             connectionSource: this.walletConnectionSource,
             sessionCrypto
         })
-            .then(() => this.openGateways(sessionCrypto));
+            .then(() => __awaiter(this, void 0, void 0, function* () {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            yield callForSuccess(_options => this.openGateways(sessionCrypto, {
+                openingDeadlineMS: options === null || options === void 0 ? void 0 : options.openingDeadlineMS,
+                signal: _options === null || _options === void 0 ? void 0 : _options.signal
+            }), {
+                attempts: Number.MAX_SAFE_INTEGER,
+                delayMs: 5000,
+                signal: abortController.signal
+            });
+        }));
         const universalLink = 'universalLink' in this.walletConnectionSource &&
             this.walletConnectionSource.universalLink
             ? this.walletConnectionSource.universalLink
             : this.standardUniversalLink;
         return this.generateUniversalLink(universalLink, message);
     }
-    restoreConnection() {
+    restoreConnection(options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            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;
+            }
             this.closeGateways();
             const storedConnection = yield this.connectionStorage.getHttpConnection();
             if (!storedConnection) {
                 return;
             }
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const openingDeadlineMS = (_b = options === null || options === void 0 ? void 0 : options.openingDeadlineMS) !== null && _b !== void 0 ? _b : this.defaultOpeningDeadlineMS;
             if (isPendingConnectionHttp(storedConnection)) {
                 this.session = {
                     sessionCrypto: storedConnection.sessionCrypto,
@@ -703,25 +1005,55 @@ class BridgeProvider {
                         ? this.walletConnectionSource.bridgeUrl
                         : ''
                 };
-                return this.openGateways(storedConnection.sessionCrypto, { openingDeadlineMS: 5000 });
+                return yield this.openGateways(storedConnection.sessionCrypto, {
+                    openingDeadlineMS: openingDeadlineMS,
+                    signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal
+                });
             }
             if (Array.isArray(this.walletConnectionSource)) {
                 throw new TonConnectError('Internal error. Connection source is array while WalletConnectionSourceHTTP was expected.');
             }
             this.session = storedConnection.session;
+            if (this.gateway) {
+                logDebug('Gateway is already opened, closing previous gateway');
+                yield this.gateway.close();
+            }
             this.gateway = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, storedConnection.session.sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
+            if (abortController.signal.aborted) {
+                return;
+            }
+            // notify listeners about stored connection
+            this.listeners.forEach(listener => listener(storedConnection.connectEvent));
+            // wait for the connection to be opened
             try {
-                yield this.gateway.registerSession({ openingDeadlineMS: 5000 });
+                yield callForSuccess(options => this.gateway.registerSession({
+                    openingDeadlineMS: openingDeadlineMS,
+                    signal: options.signal
+                }), {
+                    attempts: Number.MAX_SAFE_INTEGER,
+                    delayMs: 5000,
+                    signal: abortController.signal
+                });
             }
             catch (e) {
-                yield this.disconnect();
+                yield this.disconnect({ signal: abortController.signal });
                 return;
             }
-            this.listeners.forEach(listener => listener(storedConnection.connectEvent));
         });
     }
-    sendRequest(request, onRequestSent) {
+    sendRequest(request, optionsOrOnRequestSent) {
+        // TODO: remove deprecated method
+        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;
+        }
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.gateway || !this.session || !('walletPublicKey' in this.session)) {
                 throw new TonConnectError('Trying to send bridge request without session');
             }
@@ -730,8 +1062,8 @@ class BridgeProvider {
             logDebug('Send http-bridge request:', Object.assign(Object.assign({}, request), { id }));
             const encodedRequest = this.session.sessionCrypto.encrypt(JSON.stringify(Object.assign(Object.assign({}, request), { id })), hexToByteArray(this.session.walletPublicKey));
             try {
-                yield this.gateway.send(encodedRequest, this.session.walletPublicKey, request.method);
-                onRequestSent === null || onRequestSent === void 0 ? void 0 : onRequestSent();
+                yield this.gateway.send(encodedRequest, this.session.walletPublicKey, request.method, { attempts: options === null || options === void 0 ? void 0 : options.attempts, signal: options === null || options === void 0 ? void 0 : options.signal });
+                (_a = options === null || options === void 0 ? void 0 : options.onRequestSent) === null || _a === void 0 ? void 0 : _a.call(options);
                 this.pendingRequests.set(id.toString(), resolve);
             }
             catch (e) {
@@ -745,23 +1077,41 @@ class BridgeProvider {
         this.session = null;
         this.gateway = null;
     }
-    disconnect() {
+    disconnect(options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                 let called = false;
+                let timeoutId = null;
                 const onRequestSent = () => {
-                    called = true;
-                    this.removeBridgeAndSession().then(resolve);
+                    if (!called) {
+                        called = true;
+                        this.removeBridgeAndSession().then(resolve);
+                    }
                 };
                 try {
-                    yield this.sendRequest({ method: 'disconnect', params: [] }, onRequestSent);
+                    this.closeGateways();
+                    const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+                    timeoutId = setTimeout(() => {
+                        abortController.abort();
+                    }, this.defaultOpeningDeadlineMS);
+                    yield this.sendRequest({ method: 'disconnect', params: [] }, {
+                        onRequestSent: onRequestSent,
+                        signal: abortController.signal,
+                        attempts: 1,
+                    });
                 }
                 catch (e) {
-                    console.debug(e);
+                    logDebug('Disconnect error:', e);
                     if (!called) {
                         this.removeBridgeAndSession().then(resolve);
                     }
                 }
+                finally {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                    onRequestSent();
+                }
             }));
         });
     }
@@ -786,10 +1136,14 @@ class BridgeProvider {
     pendingGatewaysListener(gateway, bridgeUrl, bridgeIncomingMessage) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.pendingGateways.includes(gateway)) {
-                gateway.close();
+                yield gateway.close();
                 return;
             }
             this.closeGateways({ except: gateway });
+            if (this.gateway) {
+                logDebug('Gateway is already opened, closing previous gateway');
+                yield this.gateway.close();
+            }
             this.session.bridgeUrl = bridgeUrl;
             this.gateway = gateway;
             this.gateway.setErrorsListener(this.gatewayErrorsListener.bind(this));
@@ -828,6 +1182,7 @@ class BridgeProvider {
                 yield this.updateSession(walletMessage, bridgeIncomingMessage.from);
             }
             if (walletMessage.event === 'disconnect') {
+                logDebug(`Removing bridge and session: received disconnect event`);
                 yield this.removeBridgeAndSession();
             }
             listeners.forEach(listener => listener(walletMessage));
@@ -893,6 +1248,9 @@ class BridgeProvider {
     openGateways(sessionCrypto, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (Array.isArray(this.walletConnectionSource)) {
+                // close all gateways before opening new ones
+                this.pendingGateways.map(bridge => bridge.close().catch(e => console.error(e)));
+                // open new gateways
                 this.pendingGateways = this.walletConnectionSource.map(source => {
                     const gateway = new BridgeGateway(this.storage, source.bridgeUrl, sessionCrypto.sessionId, () => { }, e => {
                         console.error(e);
@@ -900,12 +1258,31 @@ class BridgeProvider {
                     gateway.setListener(message => this.pendingGatewaysListener(gateway, source.bridgeUrl, message));
                     return gateway;
                 });
-                yield Promise.allSettled(this.pendingGateways.map(bridge => bridge.registerSession(options)));
+                yield Promise.allSettled(this.pendingGateways.map(bridge => callForSuccess((_options) => {
+                    if (!this.pendingGateways.some(item => item === bridge)) {
+                        return bridge.close();
+                    }
+                    return bridge.registerSession({
+                        openingDeadlineMS: options === null || options === void 0 ? void 0 : options.openingDeadlineMS,
+                        signal: _options.signal
+                    });
+                }, {
+                    attempts: Number.MAX_SAFE_INTEGER,
+                    delayMs: 5000,
+                    signal: options === null || options === void 0 ? void 0 : options.signal
+                })));
                 return;
             }
             else {
+                if (this.gateway) {
+                    logDebug(`Gateway is already opened, closing previous gateway`);
+                    yield this.gateway.close();
+                }
                 this.gateway = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
-                return this.gateway.registerSession(options);
+                return yield this.gateway.registerSession({
+                    openingDeadlineMS: options === null || options === void 0 ? void 0 : options.openingDeadlineMS,
+                    signal: options === null || options === void 0 ? void 0 : options.signal
+                });
             }
         });
     }
@@ -1168,14 +1545,24 @@ class InjectedProvider {
         this.listeners.push(eventsCallback);
         return () => (this.listeners = this.listeners.filter(listener => listener !== eventsCallback));
     }
-    sendRequest(request, onRequestSent) {
+    sendRequest(request, optionsOrOnRequestSent) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            // TODO: remove deprecated method
+            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;
+            }
             const id = (yield this.connectionStorage.getNextRpcRequestId()).toString();
             yield this.connectionStorage.increaseNextRpcRequestId();
             logDebug('Send injected-bridge request:', Object.assign(Object.assign({}, request), { id }));
             const result = this.injectedWallet.send(Object.assign(Object.assign({}, request), { id }));
             result.then(response => logDebug('Wallet message received:', response));
-            onRequestSent === null || onRequestSent === void 0 ? void 0 : onRequestSent();
+            (_a = options === null || options === void 0 ? void 0 : options.onRequestSent) === null || _a === void 0 ? void 0 : _a.call(options);
             return result;
         });
     }
@@ -1192,7 +1579,7 @@ class InjectedProvider {
                 this.listeners.forEach(listener => listener(connectEvent));
             }
             catch (e) {
-                logDebug(e);
+                logDebug('Injected Provider connect error:', e);
                 const connectEventError = {
                     event: 'connect_error',
                     payload: {
@@ -1321,19 +1708,6 @@ const FALLBACK_WALLETS_LIST = [
         ],
         platforms: ['ios', 'android', 'chrome', 'firefox', 'macos']
     },
-    {
-        app_name: 'openmask',
-        name: 'OpenMask',
-        image: 'https://raw.githubusercontent.com/OpenProduct/openmask-extension/main/public/openmask-logo-288.png',
-        about_url: 'https://www.openmask.app/',
-        bridge: [
-            {
-                type: 'js',
-                key: 'openmask'
-            }
-        ],
-        platforms: ['chrome']
-    },
     {
         app_name: 'mytonwallet',
         name: 'MyTonWallet',
@@ -1350,7 +1724,20 @@ const FALLBACK_WALLETS_LIST = [
                 url: 'https://tonconnectbridge.mytonwallet.org/bridge/'
             }
         ],
-        platforms: ['chrome', 'windows', 'macos', 'linux']
+        platforms: ['chrome', 'windows', 'macos', 'linux', 'ios', 'android', 'firefox']
+    },
+    {
+        app_name: 'openmask',
+        name: 'OpenMask',
+        image: 'https://raw.githubusercontent.com/OpenProduct/openmask-extension/main/public/openmask-logo-288.png',
+        about_url: 'https://www.openmask.app/',
+        bridge: [
+            {
+                type: 'js',
+                key: 'openmask'
+            }
+        ],
+        platforms: ['chrome']
     },
     {
         app_name: 'tonhub',
@@ -1370,19 +1757,6 @@ const FALLBACK_WALLETS_LIST = [
         ],
         platforms: ['ios', 'android']
     },
-    {
-        app_name: 'tonflow',
-        name: 'TonFlow',
-        image: 'https://tonflow.net/assets/images/tonflow_ico_192.png',
-        about_url: 'https://tonflow.net',
-        bridge: [
-            {
-                type: 'js',
-                key: 'tonflow'
-            }
-        ],
-        platforms: ['chrome']
-    },
     {
         app_name: 'dewallet',
         name: 'DeWallet',
@@ -1689,59 +2063,128 @@ class TonConnect {
             }
         };
     }
-    connect(wallet, request) {
-        var _a;
+    connect(wallet, requestOrOptions) {
+        var _a, _b;
+        // TODO: remove deprecated method
+        const options = {};
+        if (typeof requestOrOptions === 'object' && 'tonProof' in requestOrOptions) {
+            options.request = requestOrOptions;
+        }
+        if (typeof requestOrOptions === 'object' &&
+            ('openingDeadlineMS' in requestOrOptions ||
+                'signal' in requestOrOptions ||
+                'request' in requestOrOptions)) {
+            options.request = requestOrOptions === null || requestOrOptions === void 0 ? void 0 : requestOrOptions.request;
+            options.openingDeadlineMS = requestOrOptions === null || requestOrOptions === void 0 ? void 0 : requestOrOptions.openingDeadlineMS;
+            options.signal = requestOrOptions === null || requestOrOptions === void 0 ? void 0 : requestOrOptions.signal;
+        }
         if (this.connected) {
             throw new WalletAlreadyConnectedError();
         }
-        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.closeConnection();
+        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) {
+            throw new TonConnectError('Connection was aborted');
+        }
+        (_b = this.provider) === null || _b === void 0 ? void 0 : _b.closeConnection();
         this.provider = this.createProvider(wallet);
-        return this.provider.connect(this.createConnectRequest(request));
+        abortController.signal.addEventListener('abort', () => {
+            var _a;
+            (_a = this.provider) === null || _a === void 0 ? void 0 : _a.closeConnection();
+            this.provider = null;
+        });
+        return this.provider.connect(this.createConnectRequest(options === null || options === void 0 ? void 0 : options.request), {
+            openingDeadlineMS: options === null || options === void 0 ? void 0 : options.openingDeadlineMS,
+            signal: abortController.signal
+        });
     }
     /**
      * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
      */
-    restoreConnection() {
+    restoreConnection(options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            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;
+            }
+            // TODO: potentially race condition here
             const [bridgeConnectionType, embeddedWallet] = yield Promise.all([
                 this.bridgeConnectionStorage.storedConnectionType(),
                 this.walletsList.getEmbeddedWallet()
             ]);
+            if (abortController.signal.aborted) {
+                return;
+            }
+            let provider = null;
             try {
                 switch (bridgeConnectionType) {
                     case 'http':
-                        this.provider = yield BridgeProvider.fromStorage(this.dappSettings.storage);
+                        provider = yield BridgeProvider.fromStorage(this.dappSettings.storage);
                         break;
                     case 'injected':
-                        this.provider = yield InjectedProvider.fromStorage(this.dappSettings.storage);
+                        provider = yield InjectedProvider.fromStorage(this.dappSettings.storage);
                         break;
                     default:
                         if (embeddedWallet) {
-                            this.provider = yield this.createProvider(embeddedWallet);
+                            provider = this.createProvider(embeddedWallet);
                         }
                         else {
                             return;
                         }
                 }
             }
-            catch (_a) {
+            catch (_c) {
                 yield this.bridgeConnectionStorage.removeConnection();
-                this.provider = null;
+                provider === null || provider === void 0 ? void 0 : provider.closeConnection();
+                provider = null;
                 return;
             }
-            this.provider.listen(this.walletEventsListener.bind(this));
-            return this.provider.restoreConnection();
+            if (abortController.signal.aborted) {
+                provider === null || provider === void 0 ? void 0 : provider.closeConnection();
+                return;
+            }
+            if (!provider) {
+                logError('Provider is not restored');
+                return;
+            }
+            (_b = this.provider) === null || _b === void 0 ? void 0 : _b.closeConnection();
+            this.provider = provider;
+            provider.listen(this.walletEventsListener.bind(this));
+            abortController.signal.addEventListener('abort', () => {
+                provider === null || provider === void 0 ? void 0 : provider.closeConnection();
+                provider = null;
+            });
+            return yield callForSuccess((_options) => __awaiter(this, void 0, void 0, function* () {
+                return provider === null || provider === void 0 ? void 0 : provider.restoreConnection({
+                    openingDeadlineMS: options === null || options === void 0 ? void 0 : options.openingDeadlineMS,
+                    signal: _options.signal
+                });
+            }), {
+                attempts: Number.MAX_SAFE_INTEGER,
+                delayMs: 5000,
+                signal: options === null || options === void 0 ? void 0 : options.signal
+            });
         });
     }
-    /**
-     * Asks connected wallet to sign and send the transaction.
-     * @param transaction transaction to send.
-     * @param onRequestSent (optional) will be called after the transaction is sent to the wallet.
-     * @returns signed transaction boc that allows you to find the transaction in the blockchain.
-     * If user rejects transaction, method will throw the corresponding error.
-     */
-    sendTransaction(transaction, onRequestSent) {
+    sendTransaction(transaction, optionsOrOnRequestSent) {
         return __awaiter(this, void 0, void 0, function* () {
+            // TODO: remove deprecated method
+            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;
+            }
+            const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+            if (abortController.signal.aborted) {
+                throw new TonConnectError('Transaction sending was aborted');
+            }
             this.checkConnection();
             checkSendTransactionSupport(this.wallet.device.features, {
                 requiredMessagesNumber: transaction.messages.length
@@ -1750,7 +2193,7 @@ class TonConnect {
             const from = transaction.from || this.account.address;
             const network = transaction.network || this.account.chain;
             const response = yield this.provider.sendRequest(sendTransactionParser.convertToRpcRequest(Object.assign(Object.assign({}, tx), { valid_until: validUntil, from,
-                network })), onRequestSent);
+                network })), { onRequestSent: options.onRequestSent, signal: abortController.signal });
             if (sendTransactionParser.isError(response)) {
                 return sendTransactionParser.parseAndThrowError(response);
             }
@@ -1760,13 +2203,23 @@ class TonConnect {
     /**
      * Disconnect form thw connected wallet and drop current session.
      */
-    disconnect() {
+    disconnect(options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.connected) {
                 throw new WalletNotConnectedError();
             }
-            yield this.provider.disconnect();
+            const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+            const prevAbortController = this.abortController;
+            this.abortController = abortController;
+            if (abortController.signal.aborted) {
+                throw new TonConnectError('Disconnect was aborted');
+            }
             this.onWalletDisconnected();
+            yield ((_a = this.provider) === null || _a === void 0 ? void 0 : _a.disconnect({
+                signal: abortController.signal
+            }));
+            prevAbortController === null || prevAbortController === void 0 ? void 0 : prevAbortController.abort();
         });
     }
     /**
@@ -1801,12 +2254,12 @@ class TonConnect {
                     this.pauseConnection();
                 }
                 else {
-                    this.unPauseConnection();
+                    this.unPauseConnection().catch(e => logError('Cannot unpause connection', e));
                 }
             });
         }
         catch (e) {
-            console.error('Cannot subscribe to the document.visibilitychange: ', e);
+            logError('Cannot subscribe to the document.visibilitychange: ', e);
         }
     }
     createProvider(wallet) {