@tonconnect/sdk 2.2.0 → 3.0.0-beta.1

package/lib/esm/index.mjs

@@ -330,6 +330,15 @@ function isTelegramUrl(link) {
     const url = new URL(link);
     return url.protocol === 'tg:' || url.hostname === 't.me';
 }
+function encodeTelegramUrlParameters(parameters) {
+    return parameters
+        .replaceAll('.', '%2E')
+        .replaceAll('-', '%2D')
+        .replaceAll('_', '%5F')
+        .replaceAll('&', '-')
+        .replaceAll('=', '__')
+        .replaceAll('%', '--');
+}
 
 class BridgeGateway {
     constructor(storage, bridgeUrl, sessionId, listener, errorsListener) {
@@ -344,7 +353,7 @@ class BridgeGateway {
         this.isClosed = false;
         this.bridgeGatewayStorage = new HttpBridgeGatewayStorage(storage, bridgeUrl);
     }
-    registerSession() {
+    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);
@@ -357,8 +366,17 @@ class BridgeGateway {
             }
             this.eventSource = new EventSource(url.toString());
             return new Promise((resolve, reject) => {
-                this.eventSource.onerror = 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();
@@ -432,6 +450,10 @@ class BridgeGateway {
     }
 }
 
+function isPendingConnectionHttp(connection) {
+    return !('connectEvent' in connection);
+}
+
 class BridgeConnectionStorage {
     constructor(storage) {
         this.storage = storage;
@@ -442,17 +464,25 @@ class BridgeConnectionStorage {
             if (connection.type === 'injected') {
                 return this.storage.setItem(this.storeKey, JSON.stringify(connection));
             }
-            const rawSession = {
-                sessionKeyPair: connection.session.sessionCrypto.stringifyKeypair(),
-                walletPublicKey: connection.session.walletPublicKey,
-                bridgeUrl: connection.session.bridgeUrl
-            };
+            if (!isPendingConnectionHttp(connection)) {
+                const rawSession = {
+                    sessionKeyPair: connection.session.sessionCrypto.stringifyKeypair(),
+                    walletPublicKey: connection.session.walletPublicKey,
+                    bridgeUrl: connection.session.bridgeUrl
+                };
+                const rawConnection = {
+                    type: 'http',
+                    connectEvent: connection.connectEvent,
+                    session: rawSession,
+                    lastWalletEventId: connection.lastWalletEventId,
+                    nextRpcRequestId: connection.nextRpcRequestId
+                };
+                return this.storage.setItem(this.storeKey, JSON.stringify(rawConnection));
+            }
             const rawConnection = {
                 type: 'http',
-                connectEvent: connection.connectEvent,
-                session: rawSession,
-                lastWalletEventId: connection.lastWalletEventId,
-                nextRpcRequestId: connection.nextRpcRequestId
+                connectionSource: connection.connectionSource,
+                sessionCrypto: connection.sessionCrypto.stringifyKeypair()
             };
             return this.storage.setItem(this.storeKey, JSON.stringify(rawConnection));
         });
@@ -472,17 +502,24 @@ class BridgeConnectionStorage {
             if (connection.type === 'injected') {
                 return connection;
             }
-            const sessionCrypto = new SessionCrypto(connection.session.sessionKeyPair);
+            if ('connectEvent' in connection) {
+                const sessionCrypto = new SessionCrypto(connection.session.sessionKeyPair);
+                return {
+                    type: 'http',
+                    connectEvent: connection.connectEvent,
+                    lastWalletEventId: connection.lastWalletEventId,
+                    nextRpcRequestId: connection.nextRpcRequestId,
+                    session: {
+                        sessionCrypto,
+                        bridgeUrl: connection.session.bridgeUrl,
+                        walletPublicKey: connection.session.walletPublicKey
+                    }
+                };
+            }
             return {
                 type: 'http',
-                connectEvent: connection.connectEvent,
-                lastWalletEventId: connection.lastWalletEventId,
-                nextRpcRequestId: connection.nextRpcRequestId,
-                session: {
-                    sessionCrypto,
-                    bridgeUrl: connection.session.bridgeUrl,
-                    walletPublicKey: connection.session.walletPublicKey
-                }
+                sessionCrypto: new SessionCrypto(connection.sessionCrypto),
+                connectionSource: connection.connectionSource
             };
         });
     }
@@ -498,6 +535,21 @@ class BridgeConnectionStorage {
             return connection;
         });
     }
+    getHttpPendingConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            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 (!isPendingConnectionHttp(connection)) {
+                throw new TonConnectError('Trying to read HTTP-pending connection while http connection is stored');
+            }
+            return connection;
+        });
+    }
     getInjectedConnection() {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnection();
@@ -523,7 +575,7 @@ class BridgeConnectionStorage {
     storeLastWalletEventId(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnection();
-            if (connection && connection.type === 'http') {
+            if (connection && connection.type === 'http' && !isPendingConnectionHttp(connection)) {
                 connection.lastWalletEventId = id;
                 return this.storeConnection(connection);
             }
@@ -541,7 +593,7 @@ class BridgeConnectionStorage {
     increaseNextRpcRequestId() {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnection();
-            if (connection) {
+            if (connection && 'nextRpcRequestId' in connection) {
                 const lastId = connection.nextRpcRequestId || 0;
                 connection.nextRpcRequestId = lastId + 1;
                 return this.storeConnection(connection);
@@ -551,7 +603,7 @@ class BridgeConnectionStorage {
     getNextRpcRequestId() {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnection();
-            if (connection) {
+            if (connection && 'nextRpcRequestId' in connection) {
                 return connection.nextRpcRequestId || 0;
             }
             return 0;
@@ -603,51 +655,62 @@ class BridgeProvider {
         return __awaiter(this, void 0, void 0, function* () {
             const bridgeConnectionStorage = new BridgeConnectionStorage(storage);
             const connection = yield bridgeConnectionStorage.getHttpConnection();
+            if (isPendingConnectionHttp(connection)) {
+                return new BridgeProvider(storage, connection.connectionSource);
+            }
             return new BridgeProvider(storage, { bridgeUrl: connection.session.bridgeUrl });
         });
     }
     connect(message) {
         this.closeGateways();
         const sessionCrypto = new SessionCrypto();
-        let bridgeUrl = '';
-        let universalLink = this.standardUniversalLink;
-        if (Array.isArray(this.walletConnectionSource)) {
-            this.pendingGateways = this.walletConnectionSource.map(source => {
-                const gateway = new BridgeGateway(this.storage, source.bridgeUrl, sessionCrypto.sessionId, () => { }, e => {
-                    console.error(e);
-                });
-                gateway.setListener(message => this.pendingGatewaysListener(gateway, source.bridgeUrl, message));
-                return gateway;
-            });
-            this.pendingGateways.forEach(bridge => bridge.registerSession());
-        }
-        else {
-            bridgeUrl = this.walletConnectionSource.bridgeUrl;
-            if (this.walletConnectionSource.universalLink) {
-                universalLink = this.walletConnectionSource.universalLink;
-            }
-            this.gateway = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
-            this.gateway.registerSession();
-        }
         this.session = {
             sessionCrypto,
-            bridgeUrl
+            bridgeUrl: 'bridgeUrl' in this.walletConnectionSource
+                ? this.walletConnectionSource.bridgeUrl
+                : ''
         };
+        this.connectionStorage
+            .storeConnection({
+            type: 'http',
+            connectionSource: this.walletConnectionSource,
+            sessionCrypto
+        })
+            .then(() => this.openGateways(sessionCrypto));
+        const universalLink = 'universalLink' in this.walletConnectionSource &&
+            this.walletConnectionSource.universalLink
+            ? this.walletConnectionSource.universalLink
+            : this.standardUniversalLink;
         return this.generateUniversalLink(universalLink, message);
     }
     restoreConnection() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (Array.isArray(this.walletConnectionSource)) {
-                throw new TonConnectError('Internal error. Connection source is array while WalletConnectionSourceHTTP was expected.');
-            }
             this.closeGateways();
             const storedConnection = yield this.connectionStorage.getHttpConnection();
             if (!storedConnection) {
                 return;
             }
+            if (isPendingConnectionHttp(storedConnection)) {
+                this.session = {
+                    sessionCrypto: storedConnection.sessionCrypto,
+                    bridgeUrl: 'bridgeUrl' in this.walletConnectionSource
+                        ? this.walletConnectionSource.bridgeUrl
+                        : ''
+                };
+                return this.openGateways(storedConnection.sessionCrypto, { openingDeadlineMS: 5000 });
+            }
+            if (Array.isArray(this.walletConnectionSource)) {
+                throw new TonConnectError('Internal error. Connection source is array while WalletConnectionSourceHTTP was expected.');
+            }
             this.session = storedConnection.session;
             this.gateway = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, storedConnection.session.sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
-            yield this.gateway.registerSession();
+            try {
+                yield this.gateway.registerSession({ openingDeadlineMS: 5000 });
+            }
+            catch (e) {
+                yield this.disconnect();
+                return;
+            }
             this.listeners.forEach(listener => listener(storedConnection.connectEvent));
         });
     }
@@ -802,18 +865,30 @@ class BridgeProvider {
     generateTGUniversalLink(universalLink, message) {
         const urlToWrap = this.generateRegularUniversalLink('about:blank', message);
         const linkParams = urlToWrap.split('?')[1];
-        const startattach = 'tonconnect-' +
-            linkParams
-                .replaceAll('.', '%2E')
-                .replaceAll('-', '%2D')
-                .replaceAll('_', '%5F')
-                .replaceAll('&', '-')
-                .replaceAll('=', '__')
-                .replaceAll('%', '--');
+        const startattach = 'tonconnect-' + encodeTelegramUrlParameters(linkParams);
         const url = new URL(universalLink);
         url.searchParams.append('startattach', startattach);
         return url.toString();
     }
+    openGateways(sessionCrypto, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Array.isArray(this.walletConnectionSource)) {
+                this.pendingGateways = this.walletConnectionSource.map(source => {
+                    const gateway = new BridgeGateway(this.storage, source.bridgeUrl, sessionCrypto.sessionId, () => { }, e => {
+                        console.error(e);
+                    });
+                    gateway.setListener(message => this.pendingGatewaysListener(gateway, source.bridgeUrl, message));
+                    return gateway;
+                });
+                yield Promise.allSettled(this.pendingGateways.map(bridge => bridge.registerSession(options)));
+                return;
+            }
+            else {
+                this.gateway = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
+                return this.gateway.registerSession(options);
+            }
+        });
+    }
     closeGateways(options) {
         var _a;
         (_a = this.gateway) === null || _a === void 0 ? void 0 : _a.close();
@@ -1106,6 +1181,20 @@ function isWalletInfoInjected(value) {
 }
 
 const FALLBACK_WALLETS_LIST = [
+    {
+        app_name: 'telegram-wallet',
+        name: 'Wallet',
+        image: 'https://wallet.tg/images/logo-288.png',
+        about_url: 'https://wallet.tg/',
+        universal_url: 'https://t.me/wallet?attach=wallet',
+        bridge: [
+            {
+                type: 'sse',
+                url: 'https://bridge.tonapi.io/bridge'
+            }
+        ],
+        platforms: ['ios', 'android', 'macos', 'windows', 'linux']
+    },
     {
         app_name: 'tonkeeper',
         name: 'Tonkeeper',
@@ -1232,7 +1321,7 @@ class WalletsListManager {
     constructor(options) {
         this.walletsListCache = null;
         this.walletsListCacheCreationTimestamp = null;
-        this.walletsListSource = 'https://raw.githubusercontent.com/ton-blockchain/wallets-list/main/wallets.json';
+        this.walletsListSource = 'https://raw.githubusercontent.com/ton-blockchain/wallets-list/main/wallets-v2.json';
         if (options === null || options === void 0 ? void 0 : options.walletsListSource) {
             this.walletsListSource = options.walletsListSource;
         }
@@ -1797,5 +1886,5 @@ function hexToBytes(hex) {
     return result;
 }
 
-export { BadRequestError, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletNotConnectedError, WalletNotInjectedError, WalletsListManager, WrongAddressError, TonConnect as default, isTelegramUrl, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
+export { BadRequestError, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletNotConnectedError, WalletNotInjectedError, WalletsListManager, WrongAddressError, TonConnect as default, encodeTelegramUrlParameters, isTelegramUrl, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
 //# sourceMappingURL=index.mjs.map