@tonconnect/sdk 0.0.43 → 0.0.44

package/lib/esm/parsers/send-transaction-parser.js

@@ -0,0 +1,31 @@
+import { SEND_TRANSACTION_ERROR_CODES } from '@tonconnect/protocol';
+import { BadRequestError, UnknownAppError, UserRejectsError } from "../errors";
+import { UnknownError } from "../errors/unknown.error";
+import { RpcParser } from "./rpc-parser";
+const sendTransactionErrors = {
+    [SEND_TRANSACTION_ERROR_CODES.UNKNOWN_ERROR]: UnknownError,
+    [SEND_TRANSACTION_ERROR_CODES.USER_REJECTS_ERROR]: UserRejectsError,
+    [SEND_TRANSACTION_ERROR_CODES.BAD_REQUEST_ERROR]: BadRequestError,
+    [SEND_TRANSACTION_ERROR_CODES.UNKNOWN_APP_ERROR]: UnknownAppError
+};
+class SendTransactionParser extends RpcParser {
+    convertToRpcRequest(request) {
+        return {
+            method: 'sendTransaction',
+            params: [JSON.stringify(request)]
+        };
+    }
+    parseAndThrowError(response) {
+        let ErrorConstructor = UnknownError;
+        if (response.error.code in sendTransactionErrors) {
+            ErrorConstructor = sendTransactionErrors[response.error.code] || UnknownError;
+        }
+        throw new ErrorConstructor(response.error.message);
+    }
+    convertFromRpcResponse(rpcResponse) {
+        return {
+            boc: rpcResponse.result
+        };
+    }
+}
+export const sendTransactionParser = new SendTransactionParser();

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

@@ -0,0 +1,105 @@
+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());
+    });
+};
+import { Base64, isNode } from '@tonconnect/protocol';
+import { TonConnectError } from "../../errors";
+import { HttpBridgeGatewayStorage } from "../../storage/http-bridge-gateway-storage";
+import { addPathToUrl } from "../../utils/url";
+if (isNode()) {
+    try {
+        eval("global.EventSource = require('eventsource')");
+        eval("global.fetch = require('node-fetch')");
+    }
+    catch (err) {
+        console.error(err);
+    }
+}
+export class BridgeGateway {
+    constructor(storage, bridgeUrl, sessionId, listener, errorsListener) {
+        this.bridgeUrl = bridgeUrl;
+        this.sessionId = sessionId;
+        this.listener = listener;
+        this.errorsListener = errorsListener;
+        this.ssePath = 'events';
+        this.postPath = 'message';
+        this.heartbeatMessage = 'heartbeat';
+        this.defaultTtl = 300;
+        this.isClosed = false;
+        this.bridgeGatewayStorage = new HttpBridgeGatewayStorage(storage);
+    }
+    registerSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = new URL(addPathToUrl(this.bridgeUrl, this.ssePath));
+            url.searchParams.append('client_id', this.sessionId);
+            const lastEventId = yield this.bridgeGatewayStorage.getLastEventId();
+            if (lastEventId) {
+                url.searchParams.append('last_event_id', lastEventId);
+            }
+            this.eventSource = new EventSource(url.toString());
+            return new Promise((resolve, reject) => {
+                this.eventSource.onerror = reject;
+                this.eventSource.onopen = () => {
+                    this.eventSource.onerror = this.errorsHandler.bind(this);
+                    this.eventSource.onmessage = this.messagesHandler.bind(this);
+                    resolve();
+                };
+            });
+        });
+    }
+    send(message, receiver, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = new URL(addPathToUrl(this.bridgeUrl, this.postPath));
+            url.searchParams.append('client_id', this.sessionId);
+            url.searchParams.append('to', receiver);
+            url.searchParams.append('ttl', (ttl || this.defaultTtl).toString());
+            yield fetch(url, {
+                method: 'post',
+                body: Base64.encode(message)
+            });
+        });
+    }
+    close() {
+        var _a;
+        this.isClosed = true;
+        (_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    errorsHandler(e) {
+        var _a, _b;
+        if (!this.isClosed) {
+            if (((_a = this.eventSource) === null || _a === void 0 ? void 0 : _a.readyState) === EventSource.CLOSED) {
+                this.eventSource.close();
+                this.registerSession();
+                return;
+            }
+            if (((_b = this.eventSource) === null || _b === void 0 ? void 0 : _b.readyState) === EventSource.CONNECTING) {
+                console.debug('[TON_CONNET_SDK_ERROR]: Bridge error', JSON.stringify(e));
+                return;
+            }
+            this.errorsListener(e);
+        }
+    }
+    messagesHandler(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (e.data === this.heartbeatMessage) {
+                return;
+            }
+            yield this.bridgeGatewayStorage.storeLastEventId(e.lastEventId);
+            if (!this.isClosed) {
+                let bridgeIncomingMessage;
+                try {
+                    bridgeIncomingMessage = JSON.parse(e.data);
+                }
+                catch (e) {
+                    throw new TonConnectError(`Bridge message parse failed, message ${e.data}`);
+                }
+                this.listener(bridgeIncomingMessage);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,140 @@
+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());
+    });
+};
+import { Base64, SessionCrypto, hexToByteArray } from '@tonconnect/protocol';
+import { TonConnectError } from "../../errors/ton-connect.error";
+import { BridgeGateway } from "./bridge-gateway";
+import { BridgeConnectionStorage } from "../../storage/bridge-connection-storage";
+import { PROTOCOL_VERSION } from "../../resources/protocol";
+export class BridgeProvider {
+    constructor(storage, walletConnectionSource) {
+        this.storage = storage;
+        this.walletConnectionSource = walletConnectionSource;
+        this.type = 'http';
+        this.pendingRequests = new Map();
+        this.nextRequestId = 0;
+        this.session = null;
+        this.bridge = null;
+        this.listeners = [];
+        this.connectionStorage = new BridgeConnectionStorage(storage);
+    }
+    static fromStorage(storage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridgeConnectionStorage = new BridgeConnectionStorage(storage);
+            const connection = yield bridgeConnectionStorage.getHttpConnection();
+            return new BridgeProvider(storage, connection.session.walletConnectionSource);
+        });
+    }
+    connect(message) {
+        var _a;
+        (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
+        const sessionCrypto = new SessionCrypto();
+        this.session = {
+            sessionCrypto,
+            walletConnectionSource: this.walletConnectionSource
+        };
+        this.bridge = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
+        this.bridge.registerSession();
+        return this.generateUniversalLink(message);
+    }
+    restoreConnection() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
+            const storedConnection = yield this.connectionStorage.getHttpConnection();
+            if (!storedConnection) {
+                return;
+            }
+            this.session = storedConnection.session;
+            this.bridge = new BridgeGateway(this.storage, this.walletConnectionSource.bridgeUrl, storedConnection.session.sessionCrypto.sessionId, this.gatewayListener.bind(this), this.gatewayErrorsListener.bind(this));
+            yield this.bridge.registerSession();
+            this.listeners.forEach(listener => listener(storedConnection.connectEvent));
+        });
+    }
+    sendRequest(request) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextRequestId;
+            this.nextRequestId++;
+            if (!this.bridge || !this.session || !('walletPublicKey' in this.session)) {
+                throw new TonConnectError('Trying to send bridge request without session');
+            }
+            const encodedRequest = this.session.sessionCrypto.encrypt(JSON.stringify(Object.assign(Object.assign({}, request), { id })), hexToByteArray(this.session.walletPublicKey));
+            this.bridge.send(encodedRequest, this.session.walletPublicKey).catch(reject);
+            this.pendingRequests.set(id.toString(), resolve);
+        });
+    }
+    closeConnection() {
+        var _a;
+        (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
+        this.listeners = [];
+    }
+    disconnect() {
+        var _a;
+        (_a = this.bridge) === null || _a === void 0 ? void 0 : _a.close();
+        this.listeners = [];
+        return this.removeBridgeAndSession();
+    }
+    listen(callback) {
+        this.listeners.push(callback);
+        return () => (this.listeners = this.listeners.filter(listener => listener !== callback));
+    }
+    gatewayListener(bridgeIncomingMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletMessage = JSON.parse(this.session.sessionCrypto.decrypt(Base64.decode(bridgeIncomingMessage.message).toUint8Array(), hexToByteArray(bridgeIncomingMessage.from)));
+            if (!('event' in walletMessage)) {
+                const id = walletMessage.id.toString();
+                const resolve = this.pendingRequests.get(id);
+                if (!resolve) {
+                    throw new TonConnectError(`Response id ${id} doesn't match any request's id`);
+                }
+                resolve(walletMessage);
+                this.pendingRequests.delete(id);
+                return;
+            }
+            if (walletMessage.event === 'connect') {
+                yield this.updateSession(walletMessage, bridgeIncomingMessage.from);
+            }
+            if (walletMessage.event === 'disconnect') {
+                yield this.removeBridgeAndSession();
+            }
+            this.listeners.forEach(listener => listener(walletMessage));
+        });
+    }
+    gatewayErrorsListener(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new TonConnectError(`Bridge error ${JSON.stringify(e)}`);
+        });
+    }
+    updateSession(connectEvent, walletPublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.session = Object.assign(Object.assign({}, this.session), { walletPublicKey });
+            const tonAddrItem = connectEvent.payload.items.find(item => item.name === 'ton_addr');
+            const connectEventToSave = Object.assign(Object.assign({}, connectEvent), { payload: Object.assign(Object.assign({}, connectEvent.payload), { items: [tonAddrItem] }) });
+            yield this.connectionStorage.storeConnection({
+                type: 'http',
+                session: this.session,
+                connectEvent: connectEventToSave
+            });
+        });
+    }
+    removeBridgeAndSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.session = null;
+            this.bridge = null;
+            yield this.connectionStorage.removeConnection();
+        });
+    }
+    generateUniversalLink(message) {
+        const url = new URL(this.walletConnectionSource.universalLink);
+        url.searchParams.append('v', PROTOCOL_VERSION.toString());
+        url.searchParams.append('id', this.session.sessionCrypto.sessionId);
+        url.searchParams.append('r', JSON.stringify(message));
+        return url.toString();
+    }
+}

package/lib/esm/provider/bridge/models/bridge-connection.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/provider/bridge/models/bridge-incomming-message.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/provider/bridge/models/bridge-session-raw.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/provider/bridge/models/bridge-session.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,121 @@
+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());
+    });
+};
+import { WalletNotInjectedError } from "../../errors/wallet/wallet-not-injected.error";
+import { BridgeConnectionStorage } from "../../storage/bridge-connection-storage";
+import { getWindow } from "../../utils/web-api";
+import { PROTOCOL_VERSION } from "../../resources/protocol";
+export class InjectedProvider {
+    constructor(injectedWalletKey) {
+        this.type = 'injected';
+        this.unsubscribeCallback = null;
+        this.listenSubscriptions = false;
+        this.listeners = [];
+        const window = InjectedProvider.window;
+        if (!InjectedProvider.isWindowContainsWallet(window, injectedWalletKey)) {
+            throw new WalletNotInjectedError();
+        }
+        this.injectedWallet = window[injectedWalletKey].tonconnect;
+    }
+    static fromStorage(storage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridgeConnectionStorage = new BridgeConnectionStorage(storage);
+            const connection = yield bridgeConnectionStorage.getInjectedConnection();
+            return new InjectedProvider(connection.jsBridgeKey);
+        });
+    }
+    static isWalletInjected(injectedWalletKey) {
+        return InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey);
+    }
+    static isInsideWalletBrowser(injectedWalletKey) {
+        if (InjectedProvider.isWindowContainsWallet(this.window, injectedWalletKey)) {
+            return this.window[injectedWalletKey].tonconnect.isWalletBrowser;
+        }
+        return false;
+    }
+    static isWindowContainsWallet(window, injectedWalletKey) {
+        return (!!window &&
+            injectedWalletKey in window &&
+            typeof window[injectedWalletKey] === 'object' &&
+            'tonconnect' in window[injectedWalletKey]);
+    }
+    connect(message, auto = false) {
+        this.injectedWallet
+            .connect(PROTOCOL_VERSION, message, auto)
+            .then(connectEvent => {
+            if (connectEvent.event === 'connect') {
+                this.makeSubscriptions();
+                this.listenSubscriptions = true;
+            }
+            this.listeners.forEach(listener => listener(connectEvent));
+        })
+            .catch(e => {
+            const connectEventError = {
+                event: 'connect_error',
+                payload: {
+                    code: 0,
+                    message: e === null || e === void 0 ? void 0 : e.toString()
+                }
+            };
+            this.listeners.forEach(listener => listener(connectEventError));
+        });
+    }
+    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);
+            }
+        });
+    }
+    closeConnection() {
+        if (this.listenSubscriptions) {
+            this.injectedWallet.disconnect();
+        }
+        this.closeAllListeners();
+    }
+    disconnect() {
+        this.closeAllListeners();
+        this.injectedWallet.disconnect();
+        return Promise.resolve();
+    }
+    closeAllListeners() {
+        var _a;
+        this.listenSubscriptions = false;
+        this.listeners = [];
+        (_a = this.unsubscribeCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    listen(eventsCallback) {
+        this.listeners.push(eventsCallback);
+        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' }));
+        });
+    }
+    makeSubscriptions() {
+        this.unsubscribeCallback = this.injectedWallet.listen(e => {
+            if (this.listenSubscriptions) {
+                this.listeners.forEach(listener => listener(e));
+            }
+            if (e.event === 'disconnect') {
+                this.disconnect();
+            }
+        });
+    }
+}
+InjectedProvider.window = getWindow();

package/lib/esm/provider/injected/models/injected-wallet-api.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/provider/provider.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/resources/protocol.js

@@ -0,0 +1 @@
+export const PROTOCOL_VERSION = 2;

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

@@ -0,0 +1,96 @@
+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());
+    });
+};
+import { SessionCrypto } from '@tonconnect/protocol';
+import { TonConnectError } from "../errors";
+export class BridgeConnectionStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.storeKey = 'ton-connect-storage_bridge-connection';
+    }
+    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));
+        });
+    }
+    removeConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
+        });
+    }
+    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 SessionCrypto(connection.session.sessionKeyPair);
+            return {
+                type: 'http',
+                connectEvent: connection.connectEvent,
+                session: {
+                    sessionCrypto,
+                    walletConnectionSource: connection.session.walletConnectionSource,
+                    walletPublicKey: connection.session.walletPublicKey
+                }
+            };
+        });
+    }
+    getHttpConnection() {
+        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');
+            }
+            return connection;
+        });
+    }
+    getInjectedConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            if (!connection) {
+                throw new TonConnectError('Trying to read Injected bridge connection source while nothing is stored');
+            }
+            if ((connection === null || connection === void 0 ? void 0 : connection.type) === 'http') {
+                throw new TonConnectError('Trying to read Injected bridge connection source while HTTP connection is stored');
+            }
+            return connection;
+        });
+    }
+    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;
+        });
+    }
+}

package/lib/esm/storage/default-storage.js

@@ -0,0 +1,35 @@
+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());
+    });
+};
+import { LocalstorageNotFoundError } from "../errors/storage/localstorage-not-found.error";
+import { getWindow } from "../utils/web-api";
+export class DefaultStorage {
+    constructor() {
+        const window = getWindow();
+        if (!(window === null || window === void 0 ? void 0 : window.localStorage)) {
+            throw new LocalstorageNotFoundError();
+        }
+        this.window = window;
+    }
+    getItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(this.window.localStorage.getItem(key));
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.window.localStorage.removeItem(key);
+            return Promise.resolve();
+        });
+    }
+    setItem(key, value) {
+        this.window.localStorage.setItem(key, value);
+        return Promise.resolve();
+    }
+}

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

@@ -0,0 +1,34 @@
+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());
+    });
+};
+export class HttpBridgeGatewayStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.storeKey = 'ton-connect-storage_http-bridge-gateway';
+    }
+    storeLastEventId(lastEventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.setItem(this.storeKey, lastEventId);
+        });
+    }
+    removeLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.removeItem(this.storeKey);
+        });
+    }
+    getLastEventId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stored = yield this.storage.getItem(this.storeKey);
+            if (!stored) {
+                return null;
+            }
+            return stored;
+        });
+    }
+}

package/lib/esm/storage/models/storage.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/ton-connect.interface.js

@@ -0,0 +1 @@
+export {};