@tonconnect/sdk 0.0.43 → 0.0.45

package/lib/esm/errors/protocol/events/connect/manifest-not-found.error.js

@@ -0,0 +1,11 @@
+import { TonConnectError } from "../../../ton-connect.error";
+/**
+ * Thrown when wallet can't get manifest by passed manifestUrl.
+ */
+export class ManifestNotFoundError extends TonConnectError {
+    constructor(message) {
+        super(message || '' + ManifestNotFoundError.additionalMessage);
+        Object.setPrototypeOf(this, ManifestNotFoundError.prototype);
+    }
+}
+ManifestNotFoundError.additionalMessage = '\nManifest not found. Make sure you added `tonconnect-manifest.json` to the root of your app or passed correct manifestUrl. See more https://github.com/ton-connect/docs/blob/main/requests-responses.md#app-manifest';

package/lib/esm/errors/protocol/events/connect/user-rejects.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../../../ton-connect.error";
+/**
+ * Thrown when user rejects the action in the wallet.
+ */
+export class UserRejectsError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, UserRejectsError.prototype);
+    }
+}

package/lib/esm/errors/protocol/responses/bad-request.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../../ton-connect.error";
+/**
+ * Thrown when request to the wallet contains errors.
+ */
+export class BadRequestError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+    }
+}

package/lib/esm/errors/protocol/responses/unknown-app.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../../ton-connect.error";
+/**
+ * Thrown when app tries to send rpc request to the injected wallet while not connected.
+ */
+export class UnknownAppError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, UnknownAppError.prototype);
+    }
+}

package/lib/esm/errors/storage/localstorage-not-found.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when `Storage` was not specified in the `DappMetadata` and default `localStorage` was not detected in the environment.
+ */
+export class LocalstorageNotFoundError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, LocalstorageNotFoundError.prototype);
+    }
+}

package/lib/esm/errors/ton-connect.error.js

@@ -0,0 +1,13 @@
+/**
+ * Base class for TonConnect errors. You can check if the error was triggered by the @tonconnect/sdk using `err instanceof TonConnectError`.
+ */
+export class TonConnectError extends Error {
+    constructor(message, options) {
+        if (message) {
+            message = TonConnectError.prefix + ' ' + message;
+        }
+        super(message, options);
+        Object.setPrototypeOf(this, TonConnectError.prototype);
+    }
+}
+TonConnectError.prefix = '[TON_CONNECT_SDK_ERROR]';

package/lib/esm/errors/unknown.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "./ton-connect.error";
+/**
+ * Unhanded unknown error.
+ */
+export class UnknownError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, UnknownError.prototype);
+    }
+}

package/lib/esm/errors/wallet/wallet-already-connected.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when wallet connection called but wallet already connected. To avoid the error, disconnect the wallet before doing a new connection.
+ */
+export class WalletAlreadyConnectedError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, WalletAlreadyConnectedError.prototype);
+    }
+}

package/lib/esm/errors/wallet/wallet-not-connected.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when send transaction or other protocol methods called while wallet is not connected.
+ */
+export class WalletNotConnectedError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, WalletNotConnectedError.prototype);
+    }
+}

package/lib/esm/errors/wallet/wallet-not-injected.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when there is an attempt to connect to the injected wallet while it is not exists in the webpage.
+ */
+export class WalletNotInjectedError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, WalletNotInjectedError.prototype);
+    }
+}

package/lib/esm/errors/wallet/wallet-not-support-feature.error.js

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when wallet doesn't support requested feature method.
+ */
+export class WalletNotSupportFeatureError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, WalletNotSupportFeatureError.prototype);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { TonConnectError } from "../ton-connect.error";
+/**
+ * Thrown when an error occurred while fetching the wallets list.
+ */
+export class FetchWalletsError extends TonConnectError {
+    constructor(...args) {
+        super(...args);
+        Object.setPrototypeOf(this, FetchWalletsError.prototype);
+    }
+}

package/lib/esm/index.js

@@ -0,0 +1,6 @@
+export * from './ton-connect';
+export * from './models';
+export * from './errors';
+export { TonConnect as default } from './ton-connect';
+export { CHAIN } from '@tonconnect/protocol';
+export { toUserFriendlyAddress } from './utils/address';

package/lib/esm/models/dapp/dapp-metadata.js

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

package/lib/esm/models/index.js

@@ -0,0 +1,2 @@
+export * from './wallet';
+export * from './methods';

package/lib/esm/models/methods/connect/connect-additional-request.js

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

package/lib/esm/models/methods/connect/index.js

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

package/lib/esm/models/methods/send-transaction/index.js

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

package/lib/esm/models/methods/send-transaction/send-transaction-request.js

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

package/lib/esm/models/methods/send-transaction/send-transaction-response.js

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

package/lib/esm/models/ton-connect-options.js

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

package/lib/esm/models/wallet/account.js

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

package/lib/esm/models/wallet/index.js

@@ -0,0 +1 @@
+export { isWalletInfoInjected } from './wallet-info';

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

@@ -0,0 +1,3 @@
+export function isWalletConnectionSourceJS(value) {
+    return 'jsBridgeKey' in value;
+}

package/lib/esm/models/wallet/wallet-info.js

@@ -0,0 +1,3 @@
+export function isWalletInfoInjected(value) {
+    return 'jsBridgeKey' in value;
+}

package/lib/esm/models/wallet/wallet.js

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

package/lib/esm/parsers/connect-errors-parser.js

@@ -0,0 +1,23 @@
+import { BadRequestError, UnknownAppError, UserRejectsError } from "../errors";
+import { ManifestContentErrorError } from "../errors/protocol/events/connect/manifest-content-error.error";
+import { ManifestNotFoundError } from "../errors/protocol/events/connect/manifest-not-found.error";
+import { UnknownError } from "../errors/unknown.error";
+import { CONNECT_EVENT_ERROR_CODES } from '@tonconnect/protocol';
+const connectEventErrorsCodes = {
+    [CONNECT_EVENT_ERROR_CODES.UNKNOWN_ERROR]: UnknownError,
+    [CONNECT_EVENT_ERROR_CODES.USER_REJECTS_ERROR]: UserRejectsError,
+    [CONNECT_EVENT_ERROR_CODES.BAD_REQUEST_ERROR]: BadRequestError,
+    [CONNECT_EVENT_ERROR_CODES.UNKNOWN_APP_ERROR]: UnknownAppError,
+    [CONNECT_EVENT_ERROR_CODES.MANIFEST_NOT_FOUND_ERROR]: ManifestNotFoundError,
+    [CONNECT_EVENT_ERROR_CODES.MANIFEST_CONTENT_ERROR]: ManifestContentErrorError
+};
+class ConnectErrorsParser {
+    parseError(error) {
+        let ErrorConstructor = UnknownError;
+        if (error.code in connectEventErrorsCodes) {
+            ErrorConstructor = connectEventErrorsCodes[error.code] || UnknownError;
+        }
+        return new ErrorConstructor(error.message);
+    }
+}
+export const connectErrorsParser = new ConnectErrorsParser();

package/lib/esm/parsers/rpc-parser.js

@@ -0,0 +1,5 @@
+export class RpcParser {
+    isError(response) {
+        return 'error' in response;
+    }
+}

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 {};