@tonconnect/sdk 0.0.21 → 0.0.22

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

@@ -1,143 +1,147 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 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(injectedWalletKey) {
+const wallet_not_injected_error_1 = require("../../errors/wallet/wallet-not-injected.error");
+const protocol = __importStar(require("../../resources/protocol.json"));
+const bridge_connection_storage_1 = require("../../storage/bridge-connection-storage");
+class InjectedProvider {
+    constructor(injectedWalletKey) {
         this.type = 'injected';
         this.unsubscribeCallback = null;
         this.listenSubscriptions = false;
         this.listeners = [];
-        var window = InjectedProvider.window;
+        const window = InjectedProvider.window;
         if (!InjectedProvider.isWindowContainsWallet(window, injectedWalletKey)) {
             throw new wallet_not_injected_error_1.WalletNotInjectedError();
         }
         this.injectedWallet = window[injectedWalletKey].tonconnect;
     }
-    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)];
-                }
-            });
+    static fromStorage(storage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridgeConnectionStorage = new bridge_connection_storage_1.BridgeConnectionStorage(storage);
+            const connection = yield bridgeConnectionStorage.getInjectedConnection();
+            return new InjectedProvider(connection.jsBridgeKey);
         });
-    };
-    InjectedProvider.isWalletInjected = function (injectedWalletKey) {
+    }
+    static isWalletInjected(injectedWalletKey) {
         return InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey);
-    };
-    InjectedProvider.isInsideWalletBrowser = function (injectedWalletKey) {
+    }
+    static isInsideWalletBrowser(injectedWalletKey) {
         if (InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey)) {
             return this.window[injectedWalletKey].tonconnect.isWalletBrowser;
         }
         return false;
-    };
-    InjectedProvider.isWindowContainsWallet = function (window, injectedWalletKey) {
+    }
+    static isWindowContainsWallet(window, injectedWalletKey) {
         return (window &&
             injectedWalletKey in window &&
             typeof window[injectedWalletKey] === 'object' &&
             'tonconnect' in window[injectedWalletKey]);
-    };
-    InjectedProvider.prototype.connect = function (message, auto) {
-        var _this = this;
-        if (auto === void 0) { auto = false; }
+    }
+    connect(message, auto = false) {
         this.injectedWallet
             .connect(protocol.version, message, auto)
-            .then(function (connectEvent) {
+            .then(connectEvent => {
             if (connectEvent.event === 'connect') {
-                _this.makeSubscriptions();
-                _this.listenSubscriptions = true;
+                this.makeSubscriptions();
+                this.listenSubscriptions = true;
             }
-            _this.listeners.forEach(function (listener) { return listener(connectEvent); });
+            this.listeners.forEach(listener => listener(connectEvent));
         })
-            .catch(function (e) {
-            var connectEventError = {
+            .catch(e => {
+            const connectEventError = {
                 event: 'connect_error',
                 payload: {
                     code: 0,
                     message: e === null || e === void 0 ? void 0 : e.toString()
                 }
             };
-            _this.listeners.forEach(function (listener) { return listener(connectEventError); });
+            this.listeners.forEach(listener => listener(connectEventError));
         });
-    };
-    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.restoreConnection()];
-                    case 1:
-                        connectEvent_1 = _a.sent();
-                        if (connectEvent_1.event === 'connect') {
-                            this.makeSubscriptions();
-                            this.listenSubscriptions = true;
-                            this.listeners.forEach(function (listener) { return listener(connectEvent_1); });
-                        }
-                        return [3 /*break*/, 3];
-                    case 2:
-                        e_1 = _a.sent();
-                        console.error(e_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+    }
+    restoreConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connectEvent = yield this.injectedWallet.restoreConnection();
+                if (connectEvent.event === 'connect') {
+                    this.makeSubscriptions();
+                    this.listenSubscriptions = true;
+                    this.listeners.forEach(listener => listener(connectEvent));
                 }
-            });
+            }
+            catch (e) {
+                console.error(e);
+            }
         });
-    };
-    InjectedProvider.prototype.closeConnection = function () {
+    }
+    closeConnection() {
         if (this.listenSubscriptions) {
             this.injectedWallet.disconnect();
         }
         this.closeAllListeners();
-    };
-    InjectedProvider.prototype.disconnect = function () {
+    }
+    disconnect() {
         this.closeAllListeners();
         this.injectedWallet.disconnect();
         return Promise.resolve();
-    };
-    InjectedProvider.prototype.closeAllListeners = function () {
+    }
+    closeAllListeners() {
         var _a;
         this.listenSubscriptions = false;
         this.listeners = [];
         (_a = this.unsubscribeCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-    };
-    InjectedProvider.prototype.listen = function (eventsCallback) {
-        var _this = this;
+    }
+    listen(eventsCallback) {
         this.listeners.push(eventsCallback);
-        return function () {
-            return (_this.listeners = _this.listeners.filter(function (listener) { return listener !== eventsCallback; }));
-        };
-    };
-    InjectedProvider.prototype.sendRequest = function (request) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.injectedWallet.send(tslib_1.__assign(tslib_1.__assign({}, request), { id: '0' }))];
-            });
+        return () => (this.listeners = this.listeners.filter(listener => listener !== eventsCallback));
+    }
+    sendRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.injectedWallet.send(Object.assign(Object.assign({}, request), { id: '0' }));
         });
-    };
-    InjectedProvider.prototype.makeSubscriptions = function () {
-        var _this = this;
-        this.unsubscribeCallback = this.injectedWallet.listen(function (e) {
-            if (_this.listenSubscriptions) {
-                _this.listeners.forEach(function (listener) { return listener(e); });
+    }
+    makeSubscriptions() {
+        this.unsubscribeCallback = this.injectedWallet.listen(e => {
+            if (this.listenSubscriptions) {
+                this.listeners.forEach(listener => listener(e));
             }
             if (e.event === 'disconnect') {
-                _this.disconnect();
+                this.disconnect();
             }
         });
-    };
-    InjectedProvider.window = window;
-    return InjectedProvider;
-}());
+    }
+}
 exports.InjectedProvider = InjectedProvider;
+InjectedProvider.window = window;

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

@@ -1,126 +1,100 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 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) {
+const protocol_1 = require("@tonconnect/protocol");
+const errors_1 = require("../errors");
+class BridgeConnectionStorage {
+    constructor(storage) {
         this.storage = storage;
         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 = {
-                    type: 'http',
-                    connectEvent: connection.connectEvent,
-                    session: rawSession
-                };
-                return [2 /*return*/, this.storage.setItem(this.storeKey, JSON.stringify(rawConnection))];
-            });
+    storeConnection(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (connection.type === 'injected') {
+                return this.storage.setItem(this.storeKey, JSON.stringify(connection));
+            }
+            const rawSession = {
+                sessionKeyPair: connection.session.sessionCrypto.stringifyKeypair(),
+                walletPublicKey: connection.session.walletPublicKey,
+                walletConnectionSource: connection.session.walletConnectionSource
+            };
+            const rawConnection = {
+                type: 'http',
+                connectEvent: connection.connectEvent,
+                session: rawSession
+            };
+            return this.storage.setItem(this.storeKey, JSON.stringify(rawConnection));
         });
-    };
-    BridgeConnectionStorage.prototype.removeConnection = 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)];
-            });
+    }
+    removeConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
         });
-    };
-    BridgeConnectionStorage.prototype.getConnection = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var stored, connection, sessionCrypto;
-            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();
-                        if (!stored) {
-                            return [2 /*return*/, null];
-                        }
-                        connection = JSON.parse(stored);
-                        if (connection.type === 'injected') {
-                            return [2 /*return*/, connection];
-                        }
-                        sessionCrypto = new protocol_1.SessionCrypto(connection.session.sessionKeyPair);
-                        return [2 /*return*/, {
-                                type: 'http',
-                                connectEvent: connection.connectEvent,
-                                session: {
-                                    sessionCrypto: sessionCrypto,
-                                    walletConnectionSource: connection.session.walletConnectionSource,
-                                    walletPublicKey: connection.session.walletPublicKey
-                                }
-                            }];
+    }
+    getConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            const connection = JSON.parse(stored);
+            if (connection.type === 'injected') {
+                return connection;
+            }
+            const sessionCrypto = new protocol_1.SessionCrypto(connection.session.sessionKeyPair);
+            return {
+                type: 'http',
+                connectEvent: connection.connectEvent,
+                session: {
+                    sessionCrypto,
+                    walletConnectionSource: connection.session.walletConnectionSource,
+                    walletPublicKey: connection.session.walletPublicKey
                 }
-            });
+            };
         });
-    };
-    BridgeConnectionStorage.prototype.getHttpConnection = 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 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];
-                }
-            });
+    }
+    getHttpConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            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 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];
-                }
-            });
+    }
+    getInjectedConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            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 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();
-                        if (!stored) {
-                            return [2 /*return*/, null];
-                        }
-                        connection = JSON.parse(stored);
-                        return [2 /*return*/, connection.type];
-                }
-            });
+    }
+    storedConnectionType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            const connection = JSON.parse(stored);
+            return connection.type;
         });
-    };
-    return BridgeConnectionStorage;
-}());
+    }
+}
 exports.BridgeConnectionStorage = BridgeConnectionStorage;

package/lib/storage/default-storage.js

@@ -1,33 +1,36 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultStorage = void 0;
-var tslib_1 = require("tslib");
-var localstorage_not_found_error_1 = require("../errors/storage/localstorage-not-found.error");
-var DefaultStorage = /** @class */ (function () {
-    function DefaultStorage() {
+const localstorage_not_found_error_1 = require("../errors/storage/localstorage-not-found.error");
+class DefaultStorage {
+    constructor() {
         if (!(window === null || window === void 0 ? void 0 : window.localStorage)) {
             throw new localstorage_not_found_error_1.LocalstorageNotFoundError();
         }
     }
-    DefaultStorage.prototype.getItem = function (key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, Promise.resolve(window.localStorage.getItem(key))];
-            });
+    getItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(window.localStorage.getItem(key));
         });
-    };
-    DefaultStorage.prototype.removeItem = function (key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                window.localStorage.removeItem(key);
-                return [2 /*return*/, Promise.resolve()];
-            });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            window.localStorage.removeItem(key);
+            return Promise.resolve();
         });
-    };
-    DefaultStorage.prototype.setItem = function (key, value) {
+    }
+    setItem(key, value) {
         window.localStorage.setItem(key, value);
         return Promise.resolve();
-    };
-    return DefaultStorage;
-}());
+    }
+}
 exports.DefaultStorage = DefaultStorage;

package/lib/storage/http-bridge-gateway-storage.js

@@ -1,42 +1,38 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpBridgeGatewayStorage = void 0;
-var tslib_1 = require("tslib");
-var HttpBridgeGatewayStorage = /** @class */ (function () {
-    function HttpBridgeGatewayStorage(storage) {
+class HttpBridgeGatewayStorage {
+    constructor(storage) {
         this.storage = storage;
         this.storeKey = 'ton-connect-storage_http-bridge-gateway';
     }
-    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)];
-            });
+    storeLastEventId(lastEventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.setItem(this.storeKey, lastEventId);
         });
-    };
-    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)];
-            });
+    }
+    removeLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
         });
-    };
-    HttpBridgeGatewayStorage.prototype.getLastEventId = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var stored;
-            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();
-                        if (!stored) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, stored];
-                }
-            });
+    }
+    getLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            return stored;
         });
-    };
-    return HttpBridgeGatewayStorage;
-}());
+    }
+}
 exports.HttpBridgeGatewayStorage = HttpBridgeGatewayStorage;