@tonconnect/sdk 0.0.13 → 0.0.14

package/README.md

@@ -4,6 +4,7 @@
 
 Use it to connect your app to TON wallets via TonConnect protocol. 
 You can find more details and the protocol specification in the [docs](https://github.com/ton-connect/docs).
+See the example of sdk usage [here](https://github.com/ton-connect/demo-dapp).
 
 ## Get started
 `npm i @tonconnect/sdk`
@@ -15,7 +16,7 @@ import TonConnect from '@tonconnect/sdk';
 
 const connector = new TonConnect();
 
-connector.autoConnect();
+connector.restoreConnection();
 ```
 
 ## Subscribe to the connection status changes
@@ -27,6 +28,53 @@ connector.onStatusChange(
 );
 ```
 
+## Fetch wallets list
+
+TonConnect is build to support different wallets. You can fetch all supported wallets list and show a custom wallet selection dialog for user
+
+```ts
+const { allWalletsList, injectedWalletsList, remoteConnectionWalletsList } = await connector.walletsList.getWalletsConfig();
+
+/* allWalletsList is 
+{
+    name: string;
+    imageUrl: string;
+    tondns?: string;
+    aboutUrl: string;
+    universalLinkBase?: string;
+    bridgeUrl?: string;
+    jsBridgeKey?: string;
+}[] 
+
+injectedWalletsList is (all injected to the page available wallets)
+{
+    name: string;
+    imageUrl: string;
+    tondns?: string;
+    aboutUrl: string;
+    jsBridgeKey: string;
+}[] 
+
+remoteConnectionWalletsList is (all wallets available via http bridge (QR code))
+{
+    name: string;
+    imageUrl: string;
+    tondns?: string;
+    aboutUrl: string;
+    universalLinkBase: string;
+    bridgeUrl: string;
+}[] 
+ */
+```
+
+### Check if your app is opened inside some wallet's browser
+
+If your app is opened inside some wallet's browser you shouldn't show a wallet selection dialog. Just connect dapp to the host-wallet when 'connect' button is clicked 
+
+```ts
+const walletConnectionSourceOrNull = await connector.inWhichWalletBrowser();
+```
+
 
 ## Initialize a wallet connection when user clicks to 'connect' button in your app
 ### Initialize a remote wallet connection via universal link 
@@ -44,9 +92,11 @@ Then you have to show this link to user as QR code, or use it as a deeplink. You
 
 ### Initialize injected wallet connection
 ```ts
-if (connector.isInjectedProviderAvailable()) {
-    connector.connect('injected');
+const walletConnectionSource = {
+    jsBridgeKey: 'tonkeeper'
 }
+
+connector.connect(walletConnectionSource);
 ```
 
 You will receive an update in `connector.onStatusChange` when user approves connection in the wallet
@@ -63,12 +113,12 @@ const transaction = {
         {
             address: "0:412410771DA82CBA306A55FA9E0D43C9D245E38133CB58F1457DFB8D5CD8892F",
             amount: "20000000",
-            initState: "base64bocblahblahblah=="
+            initState: "base64bocblahblahblah==" // just for instance. Replace with your transaction initState or remove
         },
         {
             address: "0:E69F10CC84877ABF539F83F879291E5CA169451BA7BCE91A37A5CED3AB8080D3",
             amount: "60000000",
-            payload: "base64bocblahblahblah=="
+            payload: "base64bocblahblahblah==" // just for instance. Replace with your transaction payload or remove
         }
     ]
 }

package/lib/errors/index.d.ts

@@ -1,5 +1,6 @@
 export * from './protocol';
 export * from './wallet';
 export * from './storage';
+export * from './wallets-manager';
 export { TonConnectError } from './ton-connect.error';
 export { UnknownError } from './unknown.error';

package/lib/errors/index.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./protocol"), exports);
 tslib_1.__exportStar(require("./wallet"), exports);
 tslib_1.__exportStar(require("./storage"), exports);
+tslib_1.__exportStar(require("./wallets-manager"), exports);
 var ton_connect_error_1 = require("./ton-connect.error");
 Object.defineProperty(exports, "TonConnectError", { enumerable: true, get: function () { return ton_connect_error_1.TonConnectError; } });
 var unknown_error_1 = require("./unknown.error");

package/lib/errors/wallets-manager/fetch-wallets.error.d.ts

@@ -0,0 +1,4 @@
+import { TonConnectError } from "../ton-connect.error";
+export declare class FetchWalletsError extends TonConnectError {
+    constructor(...args: ConstructorParameters<typeof TonConnectError>);
+}

package/lib/errors/wallets-manager/fetch-wallets.error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchWalletsError = void 0;
+var tslib_1 = require("tslib");
+var ton_connect_error_1 = require("../ton-connect.error");
+var FetchWalletsError = /** @class */ (function (_super) {
+    tslib_1.__extends(FetchWalletsError, _super);
+    function FetchWalletsError() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _this = _super.apply(this, args) || this;
+        Object.setPrototypeOf(_this, FetchWalletsError.prototype);
+        return _this;
+    }
+    return FetchWalletsError;
+}(ton_connect_error_1.TonConnectError));
+exports.FetchWalletsError = FetchWalletsError;

package/lib/errors/wallets-manager/index.d.ts

@@ -0,0 +1 @@
+export { FetchWalletsError } from './fetch-wallets.error';

package/lib/errors/wallets-manager/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchWalletsError = void 0;
+var fetch_wallets_error_1 = require("./fetch-wallets.error");
+Object.defineProperty(exports, "FetchWalletsError", { enumerable: true, get: function () { return fetch_wallets_error_1.FetchWalletsError; } });

package/lib/models/wallet/index.d.ts

@@ -1,3 +1,4 @@
 export type { Account } from './account';
 export type { Wallet } from './wallet';
 export type { WalletConnectionSource } from './wallet-connection-source';
+export type { WalletConfig, JSBridgeWalletConfig, HTTPBridgeWalletConfig } from './wallet-config';

package/lib/models/wallet/wallet-config.d.ts

@@ -0,0 +1,28 @@
+export interface WalletConfigBase {
+    name: string;
+    imageUrl: string;
+    tondns?: string;
+    aboutUrl: string;
+}
+export interface HTTPBridgeWalletConfig extends WalletConfigBase {
+    universalLinkBase: string;
+    bridgeUrl: string;
+}
+export interface JSBridgeWalletConfig extends WalletConfigBase {
+    jsBridgeKey: string;
+}
+export declare type WalletConfig = HTTPBridgeWalletConfig | JSBridgeWalletConfig | (HTTPBridgeWalletConfig & JSBridgeWalletConfig);
+export interface WalletConfigDTOBase {
+    name: string;
+    image: string;
+    tondns?: string;
+    about_url: string;
+}
+export interface HTTPBridgeWalletConfigDTO extends WalletConfigDTOBase {
+    universal_url: string;
+    bridge_url: string;
+}
+export interface JSBridgeWalletConfigDTO extends WalletConfigDTOBase {
+    js_bridge_key: string;
+}
+export declare type WalletConfigDTO = HTTPBridgeWalletConfigDTO | JSBridgeWalletConfigDTO | (HTTPBridgeWalletConfigDTO & JSBridgeWalletConfigDTO);

package/lib/models/wallet/wallet-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/wallet/wallet-connection-source.d.ts

@@ -1,4 +1,9 @@
-export interface WalletConnectionSource {
+export declare type WalletConnectionSource = WalletConnectionSourceHTTP | WalletConnectionSourceJS;
+export interface WalletConnectionSourceHTTP {
     universalLinkBase: string;
     bridgeUrl: string;
 }
+export interface WalletConnectionSourceJS {
+    jsBridgeKey: string;
+}
+export declare function isWalletConnectionSourceJS(value: WalletConnectionSource): value is WalletConnectionSourceJS;

package/lib/models/wallet/wallet-connection-source.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWalletConnectionSourceJS = void 0;
+function isWalletConnectionSourceJS(value) {
+    return 'jsBridgeKey' in value;
+}
+exports.isWalletConnectionSourceJS = isWalletConnectionSourceJS;

package/lib/provider/bridge/bridge-gateway.js

@@ -4,7 +4,7 @@ exports.BridgeGateway = void 0;
 var tslib_1 = require("tslib");
 var protocol_1 = require("@tonconnect/protocol");
 var errors_1 = require("../../errors");
-var bridge_gateway_storage_1 = require("../../storage/bridge-gateway-storage");
+var http_bridge_gateway_storage_1 = require("../../storage/http-bridge-gateway-storage");
 var url_1 = require("../../utils/url");
 var BridgeGateway = /** @class */ (function () {
     function BridgeGateway(storage, bridgeUrl, sessionId, listener, errorsListener) {
@@ -16,7 +16,7 @@ var BridgeGateway = /** @class */ (function () {
         this.postPath = 'message';
         this.defaultTtl = 300;
         this.isClosed = false;
-        this.bridgeGatewayStorage = new bridge_gateway_storage_1.BridgeGatewayStorage(storage);
+        this.bridgeGatewayStorage = new http_bridge_gateway_storage_1.HttpBridgeGatewayStorage(storage);
     }
     BridgeGateway.prototype.registerSession = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {

package/lib/provider/bridge/bridge-provider.d.ts

@@ -1,11 +1,12 @@
 import { AppRequest, ConnectRequest, RpcMethod, WalletEvent, WalletResponse } from '@tonconnect/protocol';
-import { WalletConnectionSource } from "../../models";
+import { WalletConnectionSourceHTTP } from "../../models/wallet/wallet-connection-source";
 import { HTTPProvider } from "../provider";
 import { IStorage } from "../../storage/models/storage.interface";
 import { WithoutId } from "../../utils/types";
 export declare class BridgeProvider implements HTTPProvider {
     private readonly storage;
     private readonly walletConnectionSource;
+    static fromStorage(storage: IStorage): Promise<BridgeProvider>;
     readonly type = "http";
     private readonly universalLinkPath;
     private readonly connectionStorage;
@@ -14,9 +15,9 @@ export declare class BridgeProvider implements HTTPProvider {
     private session;
     private bridge;
     private listeners;
-    constructor(storage: IStorage, walletConnectionSource: WalletConnectionSource);
+    constructor(storage: IStorage, walletConnectionSource: WalletConnectionSourceHTTP);
     connect(message: ConnectRequest): string;
-    autoConnect(): Promise<void>;
+    restoreConnection(): Promise<void>;
     sendRequest<T extends RpcMethod>(request: WithoutId<AppRequest<T>>): Promise<WithoutId<WalletResponse<T>>>;
     closeConnection(): void;
     disconnect(): Promise<void>;

package/lib/provider/bridge/bridge-provider.js

@@ -21,6 +21,21 @@ var BridgeProvider = /** @class */ (function () {
         this.listeners = [];
         this.connectionStorage = new bridge_connection_storage_1.BridgeConnectionStorage(storage);
     }
+    BridgeProvider.fromStorage = function (storage) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var bridgeConnectionStorage, connection;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bridgeConnectionStorage = new bridge_connection_storage_1.BridgeConnectionStorage(storage);
+                        return [4 /*yield*/, bridgeConnectionStorage.getHttpConnection()];
+                    case 1:
+                        connection = _a.sent();
+                        return [2 /*return*/, new BridgeProvider(storage, connection.session.walletConnectionSource)];
+                }
+            });
+        });
+    };
     BridgeProvider.prototype.connect = function (message) {
         var _a;
         (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
@@ -33,7 +48,7 @@ var BridgeProvider = /** @class */ (function () {
         this.bridge.registerSession();
         return this.generateUniversalLink(message);
     };
-    BridgeProvider.prototype.autoConnect = function () {
+    BridgeProvider.prototype.restoreConnection = function () {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var storedConnection;
@@ -41,7 +56,7 @@ var BridgeProvider = /** @class */ (function () {
                 switch (_b.label) {
                     case 0:
                         (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
-                        return [4 /*yield*/, this.connectionStorage.getConnection()];
+                        return [4 /*yield*/, this.connectionStorage.getHttpConnection()];
                     case 1:
                         storedConnection = _b.sent();
                         if (!storedConnection) {
@@ -125,11 +140,18 @@ var BridgeProvider = /** @class */ (function () {
     };
     BridgeProvider.prototype.updateSession = function (connectEvent, walletPublicKey) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var tonAddrItem, connectEventToSave;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         this.session = tslib_1.__assign(tslib_1.__assign({}, this.session), { walletPublicKey: walletPublicKey });
-                        return [4 /*yield*/, this.connectionStorage.storeConnection({ session: this.session, connectEvent: connectEvent })];
+                        tonAddrItem = connectEvent.payload.items.find(function (item) { return item.name === 'ton_addr'; });
+                        connectEventToSave = tslib_1.__assign(tslib_1.__assign({}, connectEvent), { payload: tslib_1.__assign(tslib_1.__assign({}, connectEvent.payload), { items: [tonAddrItem] }) });
+                        return [4 /*yield*/, this.connectionStorage.storeConnection({
+                                type: 'http',
+                                session: this.session,
+                                connectEvent: connectEventToSave
+                            })];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];

package/lib/provider/bridge/models/bridge-connection.d.ts

@@ -1,11 +1,23 @@
-import { ConnectEventSuccess } from '@tonconnect/protocol';
-import { BridgeSessionRaw } from './bridge-session-raw';
+import { DeviceInfo, TonAddressItemReply } from '@tonconnect/protocol';
+import { BridgeSessionRaw } from "./bridge-session-raw";
 import { BridgeSession } from './bridge-session';
-export interface BridgeConnection {
-    connectEvent: ConnectEventSuccess;
+export declare type BridgeConnection = BridgeConnectionHttp | BridgeConnectionInjected;
+export interface BridgeConnectionInjected {
+    type: 'injected';
+    jsBridgeKey: string;
+}
+export interface BridgeConnectionHttp {
+    type: 'http';
+    connectEvent: {
+        event: 'connect';
+        payload: {
+            items: [TonAddressItemReply];
+            device: DeviceInfo;
+        };
+    };
     session: BridgeSession;
 }
-export interface BridgeConnectionRaw {
-    connectEvent: ConnectEventSuccess;
+export declare type BridgeConnectionHttpRaw = Omit<BridgeConnectionHttp, 'session'> & {
     session: BridgeSessionRaw;
-}
+};
+export declare type BridgeConnectionRaw = BridgeConnectionHttpRaw | BridgeConnectionInjected;

package/lib/provider/bridge/models/bridge-session.d.ts

@@ -1,8 +1,8 @@
 import { SessionCrypto } from '@tonconnect/protocol';
-import { WalletConnectionSource } from "../../../models";
+import { WalletConnectionSourceHTTP } from "../../../models/wallet/wallet-connection-source";
 export interface BridgeSession {
     sessionCrypto: SessionCrypto;
     walletPublicKey: string;
-    walletConnectionSource: WalletConnectionSource;
+    walletConnectionSource: WalletConnectionSourceHTTP;
 }
 export declare type BridgePartialSession = Omit<BridgeSession, 'walletPublicKey'>;

package/lib/provider/injected/injected-provider.d.ts

@@ -1,18 +1,21 @@
-import { AppRequest, RpcMethod, WalletResponse, DeviceInfo, ConnectRequest, WalletEvent } from '@tonconnect/protocol';
+import { AppRequest, RpcMethod, WalletResponse, ConnectRequest, WalletEvent } from '@tonconnect/protocol';
 import { InternalProvider } from "../provider";
+import { IStorage } from "../../storage/models/storage.interface";
 import { WithoutId } from "../../utils/types";
-export declare class InjectedProvider implements InternalProvider {
+export declare class InjectedProvider<T extends string = string> implements InternalProvider {
     private static window;
-    static isWalletInjected(): boolean;
-    static deviceInfo(): DeviceInfo | undefined;
+    static fromStorage(storage: IStorage): Promise<InjectedProvider>;
+    static isWalletInjected(injectedWalletKey: string): boolean;
+    static isInsideWalletBrowser(injectedWalletKey: string): boolean;
+    private static isWindowContainsWallet;
     readonly type = "injected";
     private unsubscribeCallback;
     private injectedWallet;
     private listenSubscriptions;
     private listeners;
-    constructor();
+    constructor(injectedWalletKey: T);
     connect(message: ConnectRequest, auto?: boolean): void;
-    autoConnect(): Promise<void>;
+    restoreConnection(): Promise<void>;
     closeConnection(): void;
     disconnect(): Promise<void>;
     listen(eventsCallback: (e: WalletEvent) => void): () => void;

package/lib/provider/injected/injected-provider.js

@@ -4,26 +4,48 @@ exports.InjectedProvider = void 0;
 var tslib_1 = require("tslib");
 var wallet_not_injected_error_1 = require("../../errors/wallet/wallet-not-injected.error");
 var protocol = tslib_1.__importStar(require("../../resources/protocol.json"));
+var bridge_connection_storage_1 = require("../../storage/bridge-connection-storage");
 var InjectedProvider = /** @class */ (function () {
-    function InjectedProvider() {
+    function InjectedProvider(injectedWalletKey) {
         this.type = 'injected';
         this.unsubscribeCallback = null;
         this.listenSubscriptions = false;
         this.listeners = [];
-        if (!InjectedProvider.isWalletInjected()) {
+        var window = InjectedProvider.window;
+        if (!InjectedProvider.isWindowContainsWallet(window, injectedWalletKey)) {
             throw new wallet_not_injected_error_1.WalletNotInjectedError();
         }
-        this.injectedWallet = InjectedProvider.window.tonconnect;
+        this.injectedWallet = window[injectedWalletKey].tonconnect;
     }
-    InjectedProvider.isWalletInjected = function () {
-        return (InjectedProvider.window &&
-            'tonconnect' in InjectedProvider.window &&
-            typeof InjectedProvider.window.tonconnect === 'object');
+    InjectedProvider.fromStorage = function (storage) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var bridgeConnectionStorage, connection;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bridgeConnectionStorage = new bridge_connection_storage_1.BridgeConnectionStorage(storage);
+                        return [4 /*yield*/, bridgeConnectionStorage.getInjectedConnection()];
+                    case 1:
+                        connection = _a.sent();
+                        return [2 /*return*/, new InjectedProvider(connection.jsBridgeKey)];
+                }
+            });
+        });
+    };
+    InjectedProvider.isWalletInjected = function (injectedWalletKey) {
+        return InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey);
+    };
+    InjectedProvider.isInsideWalletBrowser = function (injectedWalletKey) {
+        if (InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey)) {
+            return this.window[injectedWalletKey].tonconnect.isWalletBrowser;
+        }
+        return false;
     };
-    InjectedProvider.deviceInfo = function () {
-        return InjectedProvider.isWalletInjected()
-            ? InjectedProvider.window.tonconnect.deviceInfo
-            : undefined;
+    InjectedProvider.isWindowContainsWallet = function (window, injectedWalletKey) {
+        return (window &&
+            injectedWalletKey in window &&
+            typeof window[injectedWalletKey] === 'object' &&
+            'tonconnect' in window[injectedWalletKey]);
     };
     InjectedProvider.prototype.connect = function (message, auto) {
         var _this = this;
@@ -48,14 +70,14 @@ var InjectedProvider = /** @class */ (function () {
             _this.listeners.forEach(function (listener) { return listener(connectEventError); });
         });
     };
-    InjectedProvider.prototype.autoConnect = function () {
+    InjectedProvider.prototype.restoreConnection = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var connectEvent_1, e_1;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.injectedWallet.autoConnect()];
+                        return [4 /*yield*/, this.injectedWallet.restoreConnection()];
                     case 1:
                         connectEvent_1 = _a.sent();
                         if (connectEvent_1.event === 'connect') {

package/lib/provider/injected/models/injected-wallet-api.d.ts

@@ -2,8 +2,9 @@ import { AppRequest, ConnectEvent, ConnectRequest, DeviceInfo, RpcMethod, Wallet
 export interface InjectedWalletApi {
     deviceInfo: DeviceInfo;
     protocolVersion: number;
+    isWalletBrowser: boolean;
     connect(protocolVersion: number, message: ConnectRequest, auto: boolean): Promise<ConnectEvent>;
-    autoConnect(): Promise<ConnectEvent>;
+    restoreConnection(): Promise<ConnectEvent>;
     send<T extends RpcMethod>(message: AppRequest<T>): Promise<WalletResponse<T>>;
     listen(callback: (event: WalletEvent) => void): () => void;
 }

package/lib/provider/provider.d.ts

@@ -11,7 +11,7 @@ export interface HTTPProvider extends BaseProvider {
     connect(message: ConnectRequest): string;
 }
 interface BaseProvider {
-    autoConnect(): Promise<void>;
+    restoreConnection(): Promise<void>;
     closeConnection(): void;
     disconnect(): Promise<void>;
     sendRequest<T extends RpcMethod>(request: WithoutId<AppRequest<T>>): Promise<WithoutId<WalletResponse<T>>>;

package/lib/storage/bridge-connection-storage.d.ts

@@ -1,4 +1,4 @@
-import { BridgeConnection } from "../provider/bridge/models/bridge-connection";
+import { BridgeConnection, BridgeConnectionHttp, BridgeConnectionInjected } from "../provider/bridge/models/bridge-connection";
 import { IStorage } from "./models/storage.interface";
 export declare class BridgeConnectionStorage {
     private readonly storage;
@@ -7,5 +7,7 @@ export declare class BridgeConnectionStorage {
     storeConnection(connection: BridgeConnection): Promise<void>;
     removeConnection(): Promise<void>;
     getConnection(): Promise<BridgeConnection | null>;
-    storedConnectionExists(): Promise<boolean>;
+    getHttpConnection(): Promise<BridgeConnectionHttp>;
+    getInjectedConnection(): Promise<BridgeConnectionInjected>;
+    storedConnectionType(): Promise<BridgeConnection['type'] | null>;
 }

package/lib/storage/bridge-connection-storage.js

@@ -3,23 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BridgeConnectionStorage = void 0;
 var tslib_1 = require("tslib");
 var protocol_1 = require("@tonconnect/protocol");
+var errors_1 = require("../errors");
 var BridgeConnectionStorage = /** @class */ (function () {
     function BridgeConnectionStorage(storage) {
         this.storage = storage;
-        this.storeKey = 'ton-connect-storage_http-bridge-connection';
+        this.storeKey = 'ton-connect-storage_bridge-connection';
     }
     BridgeConnectionStorage.prototype.storeConnection = function (connection) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var rawSession, rawConnection;
             return tslib_1.__generator(this, function (_a) {
+                if (connection.type === 'injected') {
+                    return [2 /*return*/, this.storage.setItem(this.storeKey, JSON.stringify(connection))];
+                }
                 rawSession = {
                     sessionKeyPair: connection.session.sessionCrypto.stringifyKeypair(),
                     walletPublicKey: connection.session.walletPublicKey,
                     walletConnectionSource: connection.session.walletConnectionSource
                 };
                 rawConnection = {
-                    session: rawSession,
-                    connectEvent: connection.connectEvent
+                    type: 'http',
+                    connectEvent: connection.connectEvent,
+                    session: rawSession
                 };
                 return [2 /*return*/, this.storage.setItem(this.storeKey, JSON.stringify(rawConnection))];
             });
@@ -34,7 +39,7 @@ var BridgeConnectionStorage = /** @class */ (function () {
     };
     BridgeConnectionStorage.prototype.getConnection = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var stored, rawConnection, sessionCrypto;
+            var stored, connection, sessionCrypto;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.storage.getItem(this.storeKey)];
@@ -43,29 +48,75 @@ var BridgeConnectionStorage = /** @class */ (function () {
                         if (!stored) {
                             return [2 /*return*/, null];
                         }
-                        rawConnection = JSON.parse(stored);
-                        sessionCrypto = new protocol_1.SessionCrypto(rawConnection.session.sessionKeyPair);
+                        connection = JSON.parse(stored);
+                        if (connection.type === 'injected') {
+                            return [2 /*return*/, connection];
+                        }
+                        sessionCrypto = new protocol_1.SessionCrypto(connection.session.sessionKeyPair);
                         return [2 /*return*/, {
-                                connectEvent: rawConnection.connectEvent,
+                                type: 'http',
+                                connectEvent: connection.connectEvent,
                                 session: {
                                     sessionCrypto: sessionCrypto,
-                                    walletConnectionSource: rawConnection.session.walletConnectionSource,
-                                    walletPublicKey: rawConnection.session.walletPublicKey
+                                    walletConnectionSource: connection.session.walletConnectionSource,
+                                    walletPublicKey: connection.session.walletPublicKey
                                 }
                             }];
                 }
             });
         });
     };
-    BridgeConnectionStorage.prototype.storedConnectionExists = function () {
+    BridgeConnectionStorage.prototype.getHttpConnection = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var stored;
+            var connection;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getConnection()];
+                    case 1:
+                        connection = _a.sent();
+                        if (!connection) {
+                            throw new errors_1.TonConnectError('Trying to read HTTP connection source while nothing is stored');
+                        }
+                        if (connection.type === 'injected') {
+                            throw new errors_1.TonConnectError('Trying to read HTTP connection source while injected connection is stored');
+                        }
+                        return [2 /*return*/, connection];
+                }
+            });
+        });
+    };
+    BridgeConnectionStorage.prototype.getInjectedConnection = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var connection;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getConnection()];
+                    case 1:
+                        connection = _a.sent();
+                        if (!connection) {
+                            throw new errors_1.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 errors_1.TonConnectError('Trying to read Injected bridge connection source while HTTP connection is stored');
+                        }
+                        return [2 /*return*/, connection];
+                }
+            });
+        });
+    };
+    BridgeConnectionStorage.prototype.storedConnectionType = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var stored, connection;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.storage.getItem(this.storeKey)];
                     case 1:
                         stored = _a.sent();
-                        return [2 /*return*/, !!stored];
+                        if (!stored) {
+                            return [2 /*return*/, null];
+                        }
+                        connection = JSON.parse(stored);
+                        return [2 /*return*/, connection.type];
                 }
             });
         });

package/lib/storage/{bridge-gateway-storage.d.ts → http-bridge-gateway-storage.d.ts}

@@ -1,5 +1,5 @@
 import { IStorage } from "./models/storage.interface";
-export declare class BridgeGatewayStorage {
+export declare class HttpBridgeGatewayStorage {
     private readonly storage;
     private readonly storeKey;
     constructor(storage: IStorage);

package/lib/storage/{bridge-gateway-storage.js → http-bridge-gateway-storage.js}

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BridgeGatewayStorage = void 0;
+exports.HttpBridgeGatewayStorage = void 0;
 var tslib_1 = require("tslib");
-var BridgeGatewayStorage = /** @class */ (function () {
-    function BridgeGatewayStorage(storage) {
+var HttpBridgeGatewayStorage = /** @class */ (function () {
+    function HttpBridgeGatewayStorage(storage) {
         this.storage = storage;
         this.storeKey = 'ton-connect-storage_http-bridge-gateway';
     }
-    BridgeGatewayStorage.prototype.storeLastEventId = function (lastEventId) {
+    HttpBridgeGatewayStorage.prototype.storeLastEventId = function (lastEventId) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.storage.setItem(this.storeKey, lastEventId)];
             });
         });
     };
-    BridgeGatewayStorage.prototype.removeLastEventId = function () {
+    HttpBridgeGatewayStorage.prototype.removeLastEventId = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.storage.removeItem(this.storeKey)];
             });
         });
     };
-    BridgeGatewayStorage.prototype.getLastEventId = function () {
+    HttpBridgeGatewayStorage.prototype.getLastEventId = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var stored;
             return tslib_1.__generator(this, function (_a) {
@@ -37,6 +37,6 @@ var BridgeGatewayStorage = /** @class */ (function () {
             });
         });
     };
-    return BridgeGatewayStorage;
+    return HttpBridgeGatewayStorage;
 }());
-exports.BridgeGatewayStorage = BridgeGatewayStorage;
+exports.HttpBridgeGatewayStorage = HttpBridgeGatewayStorage;

package/lib/ton-connect.d.ts

@@ -2,10 +2,13 @@ import { TonConnectError } from "./errors/ton-connect.error";
 import { Account, DappMetadata, Wallet, WalletConnectionSource } from "./models";
 import { SendTransactionRequest, SendTransactionResponse } from "./models/methods";
 import { ConnectAdditionalRequest } from "./models/methods/connect/connect-additional-request";
-import { InjectedProvider } from "./provider/injected/injected-provider";
+import { JSBridgeWalletConfig } from "./models/wallet/wallet-config";
+import { WalletConnectionSourceJS } from "./models/wallet/wallet-connection-source";
 import { IStorage } from "./storage/models/storage.interface";
 import { ITonConnect } from "./ton-connect.interface";
+import { WalletsListManager } from "./wallets-list-manager";
 export declare class TonConnect implements ITonConnect {
+    walletsList: WalletsListManager;
     private readonly dappSettings;
     private readonly bridgeConnectionStorage;
     private _wallet;
@@ -32,7 +35,7 @@ export declare class TonConnect implements ITonConnect {
     /**
      * Indicates if the injected wallet is available.
      */
-    isInjectedProviderAvailable: typeof InjectedProvider.isWalletInjected;
+    inWhichWalletBrowser(): Promise<JSBridgeWalletConfig | null>;
     /**
      * Allows to subscribe to connection status changes and handle connection errors.
      * @param callback will be called after connections status changes with actual wallet or null.
@@ -42,15 +45,15 @@ export declare class TonConnect implements ITonConnect {
     onStatusChange(callback: (wallet: Wallet | null) => void, errorsHandler?: (err: TonConnectError) => void): () => void;
     /**
      * Generates universal link for an external wallet and subscribes to the wallet's bridge, or sends connect request to the injected wallet.
-     * @param wallet wallet's bridge url and universal link for an external wallet or 'injected' for the injected wallet.
+     * @param wallet wallet's bridge url and universal link for an external wallet or jsBridge key for the injected wallet.
      * @param request (optional) additional request to pass to the wallet while connect (currently only ton_proof is available).
      * @returns universal link if external wallet was passed or void for the injected wallet.
      */
-    connect<T extends WalletConnectionSource | 'injected'>(wallet: T, request?: ConnectAdditionalRequest): T extends 'injected' ? void : string;
+    connect<T extends WalletConnectionSource>(wallet: T, request?: ConnectAdditionalRequest): T extends WalletConnectionSourceJS ? void : string;
     /**
      * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
      */
-    autoConnect(): void;
+    restoreConnection(): Promise<void>;
     /**
      * Asks connected wallet to sign and send the transaction.
      * @param transaction transaction to send.
@@ -62,7 +65,6 @@ export declare class TonConnect implements ITonConnect {
      * Disconnect form thw connected wallet and drop current session.
      */
     disconnect(): Promise<void>;
-    private _autoConnect;
     private createProvider;
     private walletEventsListener;
     private onWalletConnected;

package/lib/ton-connect.interface.d.ts

@@ -2,6 +2,8 @@ import { TonConnectError } from "./errors";
 import { Account, WalletConnectionSource, Wallet } from "./models";
 import { SendTransactionRequest, SendTransactionResponse } from "./models/methods";
 import { ConnectAdditionalRequest } from "./models/methods/connect/connect-additional-request";
+import { JSBridgeWalletConfig, WalletConfig } from "./models/wallet/wallet-config";
+import { WalletConnectionSourceJS } from "./models/wallet/wallet-connection-source";
 export interface ITonConnect {
     /**
      * Shows if the wallet is connected right now.
@@ -16,9 +18,16 @@ export interface ITonConnect {
      */
     wallet: Wallet | null;
     /**
-     * Indicates if the injected wallet is available.
+     * Allows to get information about supported wallets
      */
-    isInjectedProviderAvailable(): boolean;
+    walletsList: {
+        getWalletsList: () => Promise<WalletConfig[]>;
+        getInjectedWalletsList: () => Promise<JSBridgeWalletConfig[]>;
+    };
+    /**
+     * If app is opened in some wallet's browser returns that wallet config. Else returns null;
+     */
+    inWhichWalletBrowser(): Promise<JSBridgeWalletConfig | null>;
     /**
      * Allows to subscribe to connection status changes and handle connection errors.
      * @param callback will be called after connections status changes with actual wallet or null.
@@ -28,15 +37,15 @@ export interface ITonConnect {
     onStatusChange(callback: (walletInfo: Wallet | null) => void, errorsHandler?: (err: TonConnectError) => void): () => void;
     /**
      * Generates universal link for an external wallet and subscribes to the wallet's bridge, or sends connect request to the injected wallet.
-     * @param wallet wallet's bridge url and universal link for an external wallet or 'injected' for the injected wallet.
+     * @param wallet wallet's bridge url and universal link for an external wallet or jsBridge key for the injected wallet.
      * @param request (optional) additional request to pass to the wallet while connect (currently only ton_proof is available).
      * @returns universal link if external wallet was passed or void for the injected wallet.
      */
-    connect<T extends WalletConnectionSource | 'injected'>(wallet: T, request?: ConnectAdditionalRequest): T extends 'injected' ? void : string;
+    connect<T extends WalletConnectionSource>(wallet: T, request?: ConnectAdditionalRequest): T extends WalletConnectionSourceJS ? void : string;
     /**
      * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
      */
-    autoConnect(): void;
+    restoreConnection(): Promise<void>;
     /**
      * Disconnect form thw connected wallet and drop current session.
      */

package/lib/ton-connect.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var ton_connect_error_1 = require("./errors/ton-connect.error");
 var wallet_already_connected_error_1 = require("./errors/wallet/wallet-already-connected.error");
 var wallet_not_connected_error_1 = require("./errors/wallet/wallet-not-connected.error");
+var wallet_connection_source_1 = require("./models/wallet/wallet-connection-source");
 var connect_errors_parser_1 = require("./parsers/connect-errors-parser");
 var send_transaction_parser_1 = require("./parsers/send-transaction-parser");
 var bridge_provider_1 = require("./provider/bridge/bridge-provider");
@@ -13,16 +14,14 @@ var bridge_connection_storage_1 = require("./storage/bridge-connection-storage")
 var default_storage_1 = require("./storage/default-storage");
 var options_1 = require("./utils/options");
 var web_api_1 = require("./utils/web-api");
+var wallets_list_manager_1 = require("./wallets-list-manager");
 var TonConnect = /** @class */ (function () {
     function TonConnect(options) {
+        this.walletsList = new wallets_list_manager_1.WalletsListManager();
         this._wallet = null;
         this.provider = null;
         this.statusChangeSubscriptions = [];
         this.statusChangeErrorSubscriptions = [];
-        /**
-         * Indicates if the injected wallet is available.
-         */
-        this.isInjectedProviderAvailable = injected_provider_1.InjectedProvider.isWalletInjected;
         this.dappSettings = {
             metadata: (0, options_1.mergeOptions)(options === null || options === void 0 ? void 0 : options.dappMetedata, (0, web_api_1.getWebPageMetadata)()),
             storage: (options === null || options === void 0 ? void 0 : options.storage) || new default_storage_1.DefaultStorage()
@@ -65,6 +64,28 @@ var TonConnect = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Indicates if the injected wallet is available.
+     */
+    TonConnect.prototype.inWhichWalletBrowser = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var injectedWalletsList;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.walletsList.getInjectedWalletsList()];
+                    case 1:
+                        injectedWalletsList = _a.sent();
+                        if (injectedWalletsList.length !== 1) {
+                            return [2 /*return*/, null];
+                        }
+                        if (!injected_provider_1.InjectedProvider.isInsideWalletBrowser(injectedWalletsList[0].jsBridgeKey)) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, injectedWalletsList[0]];
+                }
+            });
+        });
+    };
     /**
      * Allows to subscribe to connection status changes and handle connection errors.
      * @param callback will be called after connections status changes with actual wallet or null.
@@ -96,8 +117,51 @@ var TonConnect = /** @class */ (function () {
     /**
      * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
      */
-    TonConnect.prototype.autoConnect = function () {
-        this._autoConnect();
+    TonConnect.prototype.restoreConnection = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, bridgeConnectionType, injectedWalletsList, _b, _c, _d, _e;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.bridgeConnectionStorage.storedConnectionType(),
+                            this.walletsList.getInjectedWalletsList()
+                        ])];
+                    case 1:
+                        _a = _f.sent(), bridgeConnectionType = _a[0], injectedWalletsList = _a[1];
+                        _b = bridgeConnectionType;
+                        switch (_b) {
+                            case 'http': return [3 /*break*/, 2];
+                            case 'injected': return [3 /*break*/, 4];
+                        }
+                        return [3 /*break*/, 6];
+                    case 2:
+                        _c = this;
+                        return [4 /*yield*/, bridge_provider_1.BridgeProvider.fromStorage(this.dappSettings.storage)];
+                    case 3:
+                        _c.provider = _f.sent();
+                        return [3 /*break*/, 9];
+                    case 4:
+                        _d = this;
+                        return [4 /*yield*/, injected_provider_1.InjectedProvider.fromStorage(this.dappSettings.storage)];
+                    case 5:
+                        _d.provider = _f.sent();
+                        return [3 /*break*/, 9];
+                    case 6:
+                        if (!(injectedWalletsList.length === 1)) return [3 /*break*/, 8];
+                        // DApp probably opened in the wallet's browser. Should try smart auto connect
+                        _e = this;
+                        return [4 /*yield*/, this.createProvider(injectedWalletsList[0])];
+                    case 7:
+                        // DApp probably opened in the wallet's browser. Should try smart auto connect
+                        _e.provider = _f.sent();
+                        return [3 /*break*/, 9];
+                    case 8: return [2 /*return*/];
+                    case 9:
+                        this.provider.listen(this.walletEventsListener.bind(this));
+                        return [2 /*return*/, this.provider.restoreConnection()];
+                }
+            });
+        });
     };
     /**
      * Asks connected wallet to sign and send the transaction.
@@ -143,36 +207,10 @@ var TonConnect = /** @class */ (function () {
             });
         });
     };
-    TonConnect.prototype._autoConnect = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var bridgeConnection, _a, _b;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.bridgeConnectionStorage.getConnection()];
-                    case 1:
-                        bridgeConnection = _c.sent();
-                        if (!bridgeConnection) return [3 /*break*/, 3];
-                        _a = this;
-                        return [4 /*yield*/, this.createProvider(bridgeConnection.session.walletConnectionSource)];
-                    case 2:
-                        _a.provider = _c.sent();
-                        return [2 /*return*/, this.provider.autoConnect()];
-                    case 3:
-                        if (!injected_provider_1.InjectedProvider.isWalletInjected()) return [3 /*break*/, 5];
-                        _b = this;
-                        return [4 /*yield*/, this.createProvider('injected')];
-                    case 4:
-                        _b.provider = _c.sent();
-                        return [2 /*return*/, this.provider.autoConnect()];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
     TonConnect.prototype.createProvider = function (wallet) {
         var provider;
-        if (wallet === 'injected') {
-            provider = new injected_provider_1.InjectedProvider();
+        if ((0, wallet_connection_source_1.isWalletConnectionSourceJS)(wallet)) {
+            provider = new injected_provider_1.InjectedProvider(wallet.jsBridgeKey);
         }
         else {
             provider = new bridge_provider_1.BridgeProvider(this.dappSettings.storage, wallet);

package/lib/wallets-list-manager.d.ts

@@ -0,0 +1,17 @@
+import { HTTPBridgeWalletConfig, JSBridgeWalletConfig, WalletConfig } from "./models/wallet/wallet-config";
+export declare class WalletsListManager {
+    private walletsListCache;
+    private readonly walletsListSource;
+    getWalletsList(): Promise<WalletConfig[]>;
+    getInjectedWalletsList(): Promise<JSBridgeWalletConfig[]>;
+    getRemoteConnectionWalletsList(): Promise<HTTPBridgeWalletConfig[]>;
+    getWalletsConfig(): Promise<{
+        allWalletsList: WalletConfig[];
+        injectedWalletsList: JSBridgeWalletConfig[];
+        remoteConnectionWalletsList: HTTPBridgeWalletConfig[];
+    }>;
+    private walletConfigDTOListToWalletConfigList;
+    private isCorrectWalletConfigDTO;
+    private isInjectedWallet;
+    private isRemoteConnectionWallet;
+}

package/lib/wallets-list-manager.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletsListManager = void 0;
+var tslib_1 = require("tslib");
+var fetch_wallets_error_1 = require("./errors/wallets-manager/fetch-wallets.error");
+var injected_provider_1 = require("./provider/injected/injected-provider");
+var WalletsListManager = /** @class */ (function () {
+    function WalletsListManager() {
+        this.walletsListCache = null;
+        this.walletsListSource = 'https://raw.githubusercontent.com/ton-connect/wallets-list/main/wallets.json';
+    }
+    WalletsListManager.prototype.getWalletsList = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var walletsResponse, walletsList, e_1;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.walletsListCache) {
+                            return [2 /*return*/, this.walletsListCache];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, fetch(this.walletsListSource)];
+                    case 2:
+                        walletsResponse = _a.sent();
+                        return [4 /*yield*/, walletsResponse.json()];
+                    case 3:
+                        walletsList = _a.sent();
+                        if (!Array.isArray(walletsList) ||
+                            !walletsList.every(function (wallet) { return _this.isCorrectWalletConfigDTO(wallet); })) {
+                            throw new fetch_wallets_error_1.FetchWalletsError('Wrong wallets list format');
+                        }
+                        this.walletsListCache = this.walletConfigDTOListToWalletConfigList(walletsList);
+                        return [2 /*return*/, this.walletsListCache];
+                    case 4:
+                        e_1 = _a.sent();
+                        throw new fetch_wallets_error_1.FetchWalletsError(e_1);
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WalletsListManager.prototype.getInjectedWalletsList = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var walletsList;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getWalletsList()];
+                    case 1:
+                        walletsList = (_a.sent()).filter(this.isInjectedWallet);
+                        return [2 /*return*/, walletsList.filter(function (wallet) { return injected_provider_1.InjectedProvider.isWalletInjected(wallet.jsBridgeKey); })];
+                }
+            });
+        });
+    };
+    WalletsListManager.prototype.getRemoteConnectionWalletsList = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getWalletsList()];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(this.isRemoteConnectionWallet)];
+                }
+            });
+        });
+    };
+    WalletsListManager.prototype.getWalletsConfig = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allWalletsList, _a, injectedWalletsList, remoteConnectionWalletsList;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getWalletsList()];
+                    case 1:
+                        allWalletsList = _b.sent();
+                        return [4 /*yield*/, Promise.all([
+                                this.getInjectedWalletsList(),
+                                this.getRemoteConnectionWalletsList()
+                            ])];
+                    case 2:
+                        _a = _b.sent(), injectedWalletsList = _a[0], remoteConnectionWalletsList = _a[1];
+                        return [2 /*return*/, {
+                                allWalletsList: allWalletsList,
+                                injectedWalletsList: injectedWalletsList,
+                                remoteConnectionWalletsList: remoteConnectionWalletsList
+                            }];
+                }
+            });
+        });
+    };
+    WalletsListManager.prototype.walletConfigDTOListToWalletConfigList = function (walletConfigDTO) {
+        return walletConfigDTO.map(function (walletConfigDTO) {
+            var walletConfig = {
+                name: walletConfigDTO.name,
+                imageUrl: walletConfigDTO.image,
+                aboutUrl: walletConfigDTO.about_url,
+                tondns: walletConfigDTO.tondns
+            };
+            if ('bridge_url' in walletConfigDTO) {
+                walletConfig.bridgeUrl = walletConfigDTO.bridge_url;
+                walletConfig.universalLinkBase =
+                    walletConfigDTO.universal_url;
+            }
+            if ('js_bridge_key' in walletConfigDTO) {
+                walletConfig.jsBridgeKey = walletConfigDTO.js_bridge_key;
+            }
+            return walletConfig;
+        });
+    };
+    WalletsListManager.prototype.isCorrectWalletConfigDTO = function (value) {
+        if (!value || !(typeof value === 'object')) {
+            return false;
+        }
+        var containsName = 'name' in value;
+        var containsImage = 'image' in value;
+        var containsAbout = 'about_url' in value;
+        if (!containsName || !containsImage || !containsAbout) {
+            return false;
+        }
+        var containsUniversalUrl = 'universal_url' in value;
+        var containsHttpBridge = 'bridge_url' in value;
+        var containsJsBridge = 'js_bridge_key' in value;
+        if (!(containsHttpBridge && containsUniversalUrl) && !containsJsBridge) {
+            return false;
+        }
+        return true;
+    };
+    WalletsListManager.prototype.isInjectedWallet = function (wallet) {
+        return 'jsBridgeKey' in wallet;
+    };
+    WalletsListManager.prototype.isRemoteConnectionWallet = function (wallet) {
+        return 'bridgeUrl' in wallet;
+    };
+    return WalletsListManager;
+}());
+exports.WalletsListManager = WalletsListManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonconnect/sdk",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "scripts": {
     "build": "npx rimraf lib && ttsc",
     "build:production": "npx rimraf lib && ttsc --sourceMap false"