@tonconnect/sdk 0.0.42 → 0.0.44

package/lib/esm/ton-connect.js

@@ -0,0 +1,252 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { DappMetadataError } from "./errors/dapp/dapp-metadata.error";
+import { ManifestContentErrorError } from "./errors/protocol/events/connect/manifest-content-error.error";
+import { ManifestNotFoundError } from "./errors/protocol/events/connect/manifest-not-found.error";
+import { TonConnectError } from "./errors/ton-connect.error";
+import { WalletAlreadyConnectedError } from "./errors/wallet/wallet-already-connected.error";
+import { WalletNotConnectedError } from "./errors/wallet/wallet-not-connected.error";
+import { WalletNotSupportFeatureError } from "./errors/wallet/wallet-not-support-feature.error";
+import { isWalletConnectionSourceJS } from "./models/wallet/wallet-connection-source";
+import { connectErrorsParser } from "./parsers/connect-errors-parser";
+import { sendTransactionParser } from "./parsers/send-transaction-parser";
+import { BridgeProvider } from "./provider/bridge/bridge-provider";
+import { InjectedProvider } from "./provider/injected/injected-provider";
+import { BridgeConnectionStorage } from "./storage/bridge-connection-storage";
+import { DefaultStorage } from "./storage/default-storage";
+import { getWebPageManifest } from "./utils/web-api";
+import { WalletsListManager } from "./wallets-list-manager";
+export class TonConnect {
+    constructor(options) {
+        this.walletsList = new WalletsListManager();
+        this._wallet = null;
+        this.provider = null;
+        this.statusChangeSubscriptions = [];
+        this.statusChangeErrorSubscriptions = [];
+        this.dappSettings = {
+            manifestUrl: (options === null || options === void 0 ? void 0 : options.manifestUrl) || getWebPageManifest(),
+            storage: (options === null || options === void 0 ? void 0 : options.storage) || new DefaultStorage()
+        };
+        if (!this.dappSettings.manifestUrl) {
+            throw new DappMetadataError('Dapp tonconnect-manifest.json must be specified if window.location.origin is undefined. See more https://github.com/ton-connect/docs/blob/main/requests-responses.md#app-manifest');
+        }
+        this.bridgeConnectionStorage = new BridgeConnectionStorage(this.dappSettings.storage);
+    }
+    /**
+     * Shows if the wallet is connected right now.
+     */
+    get connected() {
+        return this._wallet !== null;
+    }
+    /**
+     * Current connected account or null if no account is connected.
+     */
+    get account() {
+        var _a;
+        return ((_a = this._wallet) === null || _a === void 0 ? void 0 : _a.account) || null;
+    }
+    /**
+     * Current connected wallet or null if no account is connected.
+     */
+    get wallet() {
+        return this._wallet;
+    }
+    set wallet(value) {
+        this._wallet = value;
+        this.statusChangeSubscriptions.forEach(callback => callback(this._wallet));
+    }
+    /**
+     * Returns available wallets list.
+     */
+    getWallets() {
+        return this.walletsList.getWallets();
+    }
+    /**
+     * 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.
+     * @param errorsHandler (optional) will be called with some instance of TonConnectError when connect error is received.
+     * @returns unsubscribe callback.
+     */
+    onStatusChange(callback, errorsHandler) {
+        this.statusChangeSubscriptions.push(callback);
+        if (errorsHandler) {
+            this.statusChangeErrorSubscriptions.push(errorsHandler);
+        }
+        return () => {
+            this.statusChangeSubscriptions = this.statusChangeSubscriptions.filter(item => item !== callback);
+            if (errorsHandler) {
+                this.statusChangeErrorSubscriptions = this.statusChangeErrorSubscriptions.filter(item => item !== errorsHandler);
+            }
+        };
+    }
+    connect(wallet, request) {
+        var _a;
+        if (this.connected) {
+            throw new WalletAlreadyConnectedError();
+        }
+        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.closeConnection();
+        this.provider = this.createProvider(wallet);
+        return this.provider.connect(this.createConnectRequest(request));
+    }
+    /**
+     * Try to restore existing session and reconnect to the corresponding wallet. Call it immediately when your app is loaded.
+     */
+    restoreConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [bridgeConnectionType, embeddedWallet] = yield Promise.all([
+                this.bridgeConnectionStorage.storedConnectionType(),
+                this.walletsList.getEmbeddedWallet()
+            ]);
+            switch (bridgeConnectionType) {
+                case 'http':
+                    this.provider = yield BridgeProvider.fromStorage(this.dappSettings.storage);
+                    break;
+                case 'injected':
+                    this.provider = yield InjectedProvider.fromStorage(this.dappSettings.storage);
+                    break;
+                default:
+                    if (embeddedWallet) {
+                        this.provider = yield this.createProvider(embeddedWallet);
+                    }
+                    else {
+                        return;
+                    }
+            }
+            this.provider.listen(this.walletEventsListener.bind(this));
+            return this.provider.restoreConnection();
+        });
+    }
+    /**
+     * Asks connected wallet to sign and send the transaction.
+     * @param transaction transaction to send.
+     * @returns signed transaction boc that allows you to find the transaction in the blockchain.
+     * If user rejects transaction, method will throw the corresponding error.
+     */
+    sendTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkConnection();
+            this.checkFeatureSupport('SendTransaction');
+            const { validUntil } = transaction, tx = __rest(transaction, ["validUntil"]);
+            const response = yield this.provider.sendRequest(sendTransactionParser.convertToRpcRequest(Object.assign(Object.assign({}, tx), { valid_until: validUntil })));
+            if (sendTransactionParser.isError(response)) {
+                return sendTransactionParser.parseAndThrowError(response);
+            }
+            return sendTransactionParser.convertFromRpcResponse(response);
+        });
+    }
+    /**
+     * Disconnect form thw connected wallet and drop current session.
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connected) {
+                throw new WalletNotConnectedError();
+            }
+            yield this.provider.disconnect();
+            this.onWalletDisconnected();
+        });
+    }
+    createProvider(wallet) {
+        let provider;
+        if (isWalletConnectionSourceJS(wallet)) {
+            provider = new InjectedProvider(wallet.jsBridgeKey);
+        }
+        else {
+            provider = new BridgeProvider(this.dappSettings.storage, wallet);
+        }
+        provider.listen(this.walletEventsListener.bind(this));
+        return provider;
+    }
+    walletEventsListener(e) {
+        switch (e.event) {
+            case 'connect':
+                this.onWalletConnected(e.payload);
+                break;
+            case 'connect_error':
+                this.onWalletConnectError(e.payload);
+                break;
+            case 'disconnect':
+                this.onWalletDisconnected();
+        }
+    }
+    onWalletConnected(connectEvent) {
+        const tonAccountItem = connectEvent.items.find(item => item.name === 'ton_addr');
+        const tonProofItem = connectEvent.items.find(item => item.name === 'ton_proof');
+        if (!tonAccountItem) {
+            throw new TonConnectError('ton_addr connection item was not found');
+        }
+        const wallet = {
+            device: connectEvent.device,
+            provider: this.provider.type,
+            account: {
+                address: tonAccountItem.address,
+                chain: tonAccountItem.network,
+                walletStateInit: tonAccountItem.walletStateInit
+            }
+        };
+        if (tonProofItem) {
+            wallet.connectItems = {
+                tonProof: tonProofItem
+            };
+        }
+        this.wallet = wallet;
+    }
+    onWalletConnectError(connectEventError) {
+        const error = connectErrorsParser.parseError(connectEventError);
+        this.statusChangeErrorSubscriptions.forEach(errorsHandler => errorsHandler(error));
+        console.debug(error);
+        if (error instanceof ManifestNotFoundError || error instanceof ManifestContentErrorError) {
+            console.error(error);
+            throw error;
+        }
+    }
+    onWalletDisconnected() {
+        this.wallet = null;
+    }
+    checkConnection() {
+        if (!this.connected) {
+            throw new WalletNotConnectedError();
+        }
+    }
+    checkFeatureSupport(feature) {
+        var _a;
+        if (!((_a = this.wallet) === null || _a === void 0 ? void 0 : _a.device.features.includes(feature))) {
+            throw new WalletNotSupportFeatureError();
+        }
+    }
+    createConnectRequest(request) {
+        const items = [
+            {
+                name: 'ton_addr'
+            }
+        ];
+        if (request === null || request === void 0 ? void 0 : request.tonProof) {
+            items.push({
+                name: 'ton_proof',
+                payload: request.tonProof
+            });
+        }
+        return {
+            manifestUrl: this.dappSettings.manifestUrl,
+            items
+        };
+    }
+}

package/lib/esm/utils/options.js

@@ -0,0 +1,8 @@
+import deepmerge from 'deepmerge';
+export function mergeOptions(options, defaultOptions) {
+    if (!options) {
+        return defaultOptions;
+    }
+    const overwriteMerge = (_, sourceArray, __) => sourceArray;
+    return deepmerge(defaultOptions, options, { arrayMerge: overwriteMerge });
+}

package/lib/esm/utils/types.js

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

package/lib/esm/utils/url.js

@@ -0,0 +1,9 @@
+export function removeUrlLastSlash(url) {
+    if (url.slice(-1) === '/') {
+        return url.slice(0, -1);
+    }
+    return url;
+}
+export function addPathToUrl(url, path) {
+    return removeUrlLastSlash(url) + '/' + path;
+}

package/lib/esm/utils/web-api.js

@@ -0,0 +1,20 @@
+export function getWindow() {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    return window;
+}
+export function getDocument() {
+    if (typeof document === 'undefined') {
+        return undefined;
+    }
+    return document;
+}
+export function getWebPageManifest() {
+    var _a;
+    const origin = (_a = getWindow()) === null || _a === void 0 ? void 0 : _a.location.origin;
+    if (origin) {
+        return origin + '/tonconnect-manifest.json';
+    }
+    return '';
+}

package/lib/esm/wallets-list-manager.js

@@ -0,0 +1,91 @@
+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 { FetchWalletsError } from "./errors/wallets-manager/fetch-wallets.error";
+import { isWalletInfoInjected } from "./models/wallet/wallet-info";
+import { InjectedProvider } from "./provider/injected/injected-provider";
+export class WalletsListManager {
+    constructor() {
+        this.walletsListCache = null;
+        this.walletsListSource = 'https://raw.githubusercontent.com/ton-connect/wallets-list/main/wallets.json';
+    }
+    getWallets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.walletsListCache) {
+                this.walletsListCache = this.fetchWalletsList();
+                this.walletsListCache.catch(() => (this.walletsListCache = null));
+            }
+            return this.walletsListCache;
+        });
+    }
+    getEmbeddedWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletsList = yield this.getWallets();
+            const injectedWallets = walletsList.filter(isWalletInfoInjected);
+            if (injectedWallets.length !== 1) {
+                return null;
+            }
+            return injectedWallets[0].embedded ? injectedWallets[0] : null;
+        });
+    }
+    fetchWalletsList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const walletsResponse = yield fetch(this.walletsListSource);
+                const walletsList = yield walletsResponse.json();
+                if (!Array.isArray(walletsList) ||
+                    !walletsList.every(wallet => this.isCorrectWalletConfigDTO(wallet))) {
+                    throw new FetchWalletsError('Wrong wallets list format');
+                }
+                return this.walletConfigDTOListToWalletConfigList(walletsList);
+            }
+            catch (e) {
+                throw new FetchWalletsError(e);
+            }
+        });
+    }
+    walletConfigDTOListToWalletConfigList(walletConfigDTO) {
+        return walletConfigDTO.map(walletConfigDTO => {
+            const 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.universalLink = walletConfigDTO.universal_url;
+            }
+            if ('js_bridge_key' in walletConfigDTO) {
+                const jsBridgeKey = walletConfigDTO.js_bridge_key;
+                walletConfig.jsBridgeKey = jsBridgeKey;
+                walletConfig.injected =
+                    InjectedProvider.isWalletInjected(jsBridgeKey);
+                walletConfig.embedded =
+                    InjectedProvider.isInsideWalletBrowser(jsBridgeKey);
+            }
+            return walletConfig;
+        });
+    }
+    isCorrectWalletConfigDTO(value) {
+        if (!value || !(typeof value === 'object')) {
+            return false;
+        }
+        const containsName = 'name' in value;
+        const containsImage = 'image' in value;
+        const containsAbout = 'about_url' in value;
+        if (!containsName || !containsImage || !containsAbout) {
+            return false;
+        }
+        const containsUniversalUrl = 'universal_url' in value;
+        const containsHttpBridge = 'bridge_url' in value;
+        const containsJsBridge = 'js_bridge_key' in value;
+        return (containsHttpBridge && containsUniversalUrl) || containsJsBridge;
+    }
+}

package/lib/types/errors/index.d.ts

@@ -0,0 +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/types/errors/protocol/events/connect/index.d.ts

@@ -0,0 +1 @@
+export { UserRejectsError } from "./user-rejects.error";

package/lib/types/errors/protocol/events/index.d.ts

@@ -0,0 +1 @@
+export * from './connect';

package/lib/types/errors/protocol/index.d.ts

@@ -0,0 +1,2 @@
+export * from './events';
+export * from './responses';

package/lib/types/errors/protocol/responses/index.d.ts

@@ -0,0 +1,2 @@
+export { BadRequestError } from './bad-request.error';
+export { UnknownAppError } from './unknown-app.error';

package/lib/types/errors/storage/index.d.ts

@@ -0,0 +1 @@
+export { LocalstorageNotFoundError } from './localstorage-not-found.error';

package/lib/types/errors/wallet/index.d.ts

@@ -0,0 +1,3 @@
+export { WalletAlreadyConnectedError } from './wallet-already-connected.error';
+export { WalletNotConnectedError } from './wallet-not-connected.error';
+export { WalletNotInjectedError } from './wallet-not-injected.error';

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

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

package/lib/{models → types/models}/methods/connect/connect-additional-request.d.ts

@@ -2,5 +2,5 @@ export interface ConnectAdditionalRequest {
     /**
      * Payload for ton_proof
      */
-    tonProof: string;
+    tonProof?: string;
 }

package/lib/types/models/methods/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connect';
+export * from './send-transaction';

package/lib/{provider → types/provider}/bridge/bridge-gateway.d.ts

@@ -7,6 +7,7 @@ export declare class BridgeGateway {
     private readonly errorsListener;
     private readonly ssePath;
     private readonly postPath;
+    private readonly heartbeatMessage;
     private readonly defaultTtl;
     private eventSource;
     private isClosed;

package/lib/types/resources/protocol.d.ts

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

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@tonconnect/sdk",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "scripts": {
-    "build": "npx rimraf lib && ttsc && npx rimraf dist &&  webpack --mode development",
-    "build:production": "npx rimraf lib && ttsc --sourceMap false && npx rimraf dist &&  webpack --mode production"
+    "build": "npx rimraf lib && ttsc --outDir ./lib/cjs && ttsc --module esnext --outDir ./lib/esm && npx rimraf dist &&  webpack --mode development",
+    "build:production": "npx rimraf lib && ttsc --project tsconfig.cjs.json --sourceMap false && ttsc --project tsconfig.esm.json --sourceMap false && npx rimraf dist &&  webpack --mode production"
   },
   "repository": {
     "type": "git",
@@ -28,14 +28,23 @@
     "tweetnacl": "^1.0.3",
     "eventsource": "^2.0.2",
     "node-fetch": "^2.6.7",
-    "@tonconnect/protocol": "^0.0.22"
+    "@tonconnect/protocol": "^0.0.25"
   },
   "files": [
     "lib",
     "dist"
   ],
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "require": "./lib/cjs/index.js",
+      "import": "./lib/esm/index.js",
+      "default": "./lib/cjs/index.js"
+    }
+  },
   "nx": {
     "tags": ["scope:sdk"]
   },

package/lib/resources/protocol.json

@@ -1,3 +0,0 @@
-{
-    "version": 2
-}