@tonconnect/sdk 3.1.1-beta.0 → 3.2.0

package/lib/esm/index.mjs

@@ -1,5 +1,5 @@
-import { CONNECT_EVENT_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, Base64, SessionCrypto, hexToByteArray } from '@tonconnect/protocol';
-export { CHAIN, CONNECT_EVENT_ERROR_CODES, CONNECT_ITEM_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES } from '@tonconnect/protocol';
+import { CONNECT_EVENT_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, SIGN_DATA_ERROR_CODES, Base64, SessionCrypto, hexToByteArray, CONNECT_ITEM_ERROR_CODES } from '@tonconnect/protocol';
+export { CHAIN, CONNECT_EVENT_ERROR_CODES, CONNECT_ITEM_ERROR_CODES, SEND_TRANSACTION_ERROR_CODES, SIGN_DATA_ERROR_CODES } from '@tonconnect/protocol';
 import '@tonconnect/isomorphic-eventsource';
 import '@tonconnect/isomorphic-fetch';
 
@@ -140,8 +140,8 @@ class WalletNotSupportFeatureError extends TonConnectError {
     get info() {
         return "Wallet doesn't support requested feature method.";
     }
-    constructor(...args) {
-        super(...args);
+    constructor(message, options) {
+        super(message, options);
         Object.setPrototypeOf(this, WalletNotSupportFeatureError.prototype);
     }
 }
@@ -317,6 +317,32 @@ class SendTransactionParser extends RpcParser {
 }
 const sendTransactionParser = new SendTransactionParser();
 
+const signDataErrors = {
+    [SIGN_DATA_ERROR_CODES.UNKNOWN_ERROR]: UnknownError,
+    [SIGN_DATA_ERROR_CODES.USER_REJECTS_ERROR]: UserRejectsError,
+    [SIGN_DATA_ERROR_CODES.BAD_REQUEST_ERROR]: BadRequestError,
+    [SIGN_DATA_ERROR_CODES.UNKNOWN_APP_ERROR]: UnknownAppError
+};
+class SignDataParser extends RpcParser {
+    convertToRpcRequest(payload) {
+        return {
+            method: 'signData',
+            params: [JSON.stringify(payload)]
+        };
+    }
+    parseAndThrowError(response) {
+        let ErrorConstructor = UnknownError;
+        if (response.error.code in signDataErrors) {
+            ErrorConstructor = signDataErrors[response.error.code] || UnknownError;
+        }
+        throw new ErrorConstructor(response.error.message);
+    }
+    convertFromRpcResponse(rpcResponse) {
+        return rpcResponse.result;
+    }
+}
+const signDataParser = new SignDataParser();
+
 class HttpBridgeGatewayStorage {
     constructor(storage, bridgeUrl) {
         this.storage = storage;
@@ -731,7 +757,7 @@ class BridgeGateway {
             try {
                 bridgeIncomingMessage = JSON.parse(e.data);
             }
-            catch (e) {
+            catch (_) {
                 throw new TonConnectError(`Bridge message parse failed, message ${e.data}`);
             }
             this.listener(bridgeIncomingMessage);
@@ -2215,27 +2241,62 @@ class WalletsListManager {
 function checkSendTransactionSupport(features, options) {
     const supportsDeprecatedSendTransactionFeature = features.includes('SendTransaction');
     const sendTransactionFeature = findFeature(features, 'SendTransaction');
+    const requiredFeature = {
+        minMessages: options.requiredMessagesNumber,
+        extraCurrencyRequired: options.requireExtraCurrencies
+    };
     if (!supportsDeprecatedSendTransactionFeature && !sendTransactionFeature) {
-        throw new WalletNotSupportFeatureError("Wallet doesn't support SendTransaction feature.");
+        throw new WalletNotSupportFeatureError("Wallet doesn't support SendTransaction feature.", {
+            cause: { requiredFeature: { featureName: 'SendTransaction', value: requiredFeature } }
+        });
     }
     if (options.requireExtraCurrencies) {
         if (!sendTransactionFeature || !sendTransactionFeature.extraCurrencySupported) {
-            throw new WalletNotSupportFeatureError(`Wallet is not able to handle such SendTransaction request. Extra currencies support is required.`);
+            throw new WalletNotSupportFeatureError(`Wallet is not able to handle such SendTransaction request. Extra currencies support is required.`, {
+                cause: {
+                    requiredFeature: { featureName: 'SendTransaction', value: requiredFeature }
+                }
+            });
         }
     }
     if (sendTransactionFeature && sendTransactionFeature.maxMessages !== undefined) {
         if (sendTransactionFeature.maxMessages < options.requiredMessagesNumber) {
-            throw new WalletNotSupportFeatureError(`Wallet is not able to handle such SendTransaction request. Max support messages number is ${sendTransactionFeature.maxMessages}, but ${options.requiredMessagesNumber} is required.`);
+            throw new WalletNotSupportFeatureError(`Wallet is not able to handle such SendTransaction request. Max support messages number is ${sendTransactionFeature.maxMessages}, but ${options.requiredMessagesNumber} is required.`, {
+                cause: {
+                    requiredFeature: { featureName: 'SendTransaction', value: requiredFeature }
+                }
+            });
         }
         return;
     }
     logWarning("Connected wallet didn't provide information about max allowed messages in the SendTransaction request. Request may be rejected by the wallet.");
 }
+function checkSignDataSupport(features, options) {
+    const signDataFeature = features.find(feature => feature && typeof feature === 'object' && feature.name === 'SignData');
+    if (!signDataFeature) {
+        throw new WalletNotSupportFeatureError("Wallet doesn't support SignData feature.", {
+            cause: {
+                requiredFeature: {
+                    featureName: 'SignData',
+                    value: { types: options.requiredTypes }
+                }
+            }
+        });
+    }
+    const unsupportedTypes = options.requiredTypes.filter(requiredType => !signDataFeature.types.includes(requiredType));
+    if (unsupportedTypes.length) {
+        throw new WalletNotSupportFeatureError(`Wallet doesn't support required SignData types: ${unsupportedTypes.join(', ')}.`, {
+            cause: {
+                requiredFeature: { featureName: 'SignData', value: { types: unsupportedTypes } }
+            }
+        });
+    }
+}
 function checkRequiredWalletFeatures(features, walletsRequiredFeatures) {
     if (typeof walletsRequiredFeatures !== 'object') {
         return true;
     }
-    const { sendTransaction } = walletsRequiredFeatures;
+    const { sendTransaction, signData } = walletsRequiredFeatures;
     if (sendTransaction) {
         const feature = findFeature(features, 'SendTransaction');
         if (!feature) {
@@ -2245,6 +2306,15 @@ function checkRequiredWalletFeatures(features, walletsRequiredFeatures) {
             return false;
         }
     }
+    if (signData) {
+        const feature = findFeature(features, 'SignData');
+        if (!feature) {
+            return false;
+        }
+        if (!checkSignData(feature, signData)) {
+            return false;
+        }
+    }
     return true;
 }
 function findFeature(features, requiredFeatureName) {
@@ -2256,6 +2326,9 @@ function checkSendTransaction(feature, requiredFeature) {
     const correctExtraCurrency = !requiredFeature.extraCurrencyRequired || feature.extraCurrencySupported;
     return !!(correctMessagesNumber && correctExtraCurrency);
 }
+function checkSignData(feature, requiredFeature) {
+    return requiredFeature.types.every(requiredType => feature.types.includes(requiredType));
+}
 
 /**
  * Create a request version event.
@@ -2403,6 +2476,15 @@ function createTransactionSignedEvent(version, wallet, transaction, signedTransa
 function createTransactionSigningFailedEvent(version, wallet, transaction, errorMessage, errorCode) {
     return Object.assign(Object.assign({ type: 'transaction-signing-failed', is_success: false, error_message: errorMessage, error_code: errorCode !== null && errorCode !== void 0 ? errorCode : null }, createConnectionInfo(version, wallet)), createTransactionInfo(wallet, transaction));
 }
+function createDataSentForSignatureEvent(version, wallet, data) {
+    return Object.assign({ type: 'sign-data-request-initiated', data }, createConnectionInfo(version, wallet));
+}
+function createDataSignedEvent(version, wallet, data, signedData) {
+    return Object.assign({ type: 'sign-data-request-completed', is_success: true, data, signed_data: signedData }, createConnectionInfo(version, wallet));
+}
+function createDataSigningFailedEvent(version, wallet, data, errorMessage, errorCode) {
+    return Object.assign({ type: 'sign-data-request-failed', is_success: false, data, error_message: errorMessage, error_code: errorCode !== null && errorCode !== void 0 ? errorCode : null }, createConnectionInfo(version, wallet));
+}
 /**
  * Create a disconnect event.
  * @param version
@@ -2471,6 +2553,9 @@ class BrowserEventDispatcher {
  *  * `transaction-sent-for-signature`: when a user sends a transaction for signature.
  *  * `transaction-signed`: when a user successfully signs a transaction.
  *  * `transaction-signing-failed`: when a user cancels transaction signing or there is an error during the signing process.
+ *  * `sign-data-request-initiated`: when a user sends data for signature.
+ *  * `sign-data-request-completed`: when a user successfully signs data.
+ *  * `sign-data-request-failed`: when a user cancels data signing or there is an error during the signing process.
  *
  * If you want to track user actions, you can subscribe to the window events with prefix `ton-connect-`:
  *
@@ -2671,9 +2756,42 @@ class TonConnectTracker {
         }
         catch (e) { }
     }
+    /**
+     * Track sign data init event.
+     * @param args
+     */
+    trackDataSentForSignature(...args) {
+        try {
+            const event = createDataSentForSignatureEvent(this.version, ...args);
+            this.dispatchUserActionEvent(event);
+        }
+        catch (e) { }
+    }
+    /**
+     * Track sign data success event.
+     * @param args
+     */
+    trackDataSigned(...args) {
+        try {
+            const event = createDataSignedEvent(this.version, ...args);
+            this.dispatchUserActionEvent(event);
+        }
+        catch (e) { }
+    }
+    /**
+     * Track sign data error event.
+     * @param args
+     */
+    trackDataSigningFailed(...args) {
+        try {
+            const event = createDataSigningFailedEvent(this.version, ...args);
+            this.dispatchUserActionEvent(event);
+        }
+        catch (e) { }
+    }
 }
 
-const tonConnectSdkVersion = "3.1.1-beta.0";
+const tonConnectSdkVersion = "3.2.0";
 
 class TonConnect {
     constructor(options) {
@@ -2922,6 +3040,28 @@ class TonConnect {
             return result;
         });
     }
+    signData(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const abortController = createAbortController(options === null || options === void 0 ? void 0 : options.signal);
+            if (abortController.signal.aborted) {
+                throw new TonConnectError('data sending was aborted');
+            }
+            this.checkConnection();
+            checkSignDataSupport(this.wallet.device.features, { requiredTypes: [data.type] });
+            this.tracker.trackDataSentForSignature(this.wallet, data);
+            const from = data.from || this.account.address;
+            const network = data.network || this.account.chain;
+            const response = yield this.provider.sendRequest(signDataParser.convertToRpcRequest(Object.assign(Object.assign({}, data), { from,
+                network })), { onRequestSent: options === null || options === void 0 ? void 0 : options.onRequestSent, signal: abortController.signal });
+            if (signDataParser.isError(response)) {
+                this.tracker.trackDataSigningFailed(this.wallet, data, response.error.message, response.error.code);
+                return signDataParser.parseAndThrowError(response);
+            }
+            const result = signDataParser.convertFromRpcResponse(response);
+            this.tracker.trackDataSigned(this.wallet, data, result);
+            return result;
+        });
+    }
     /**
      * Disconnect form thw connected wallet and drop current session.
      */
@@ -3033,9 +3173,45 @@ class TonConnect {
             }
         };
         if (tonProofItem) {
-            wallet.connectItems = {
-                tonProof: tonProofItem
-            };
+            let tonProof = undefined;
+            try {
+                if ('proof' in tonProofItem) { // success
+                    tonProof = {
+                        name: 'ton_proof',
+                        proof: {
+                            timestamp: tonProofItem.proof.timestamp,
+                            domain: {
+                                lengthBytes: tonProofItem.proof.domain.lengthBytes,
+                                value: tonProofItem.proof.domain.value,
+                            },
+                            payload: tonProofItem.proof.payload,
+                            signature: tonProofItem.proof.signature,
+                        }
+                    };
+                }
+                else if ('error' in tonProofItem) { // error
+                    tonProof = {
+                        name: 'ton_proof',
+                        error: {
+                            code: tonProofItem.error.code,
+                            message: tonProofItem.error.message,
+                        }
+                    };
+                }
+                else {
+                    throw new TonConnectError('Invalid data format');
+                }
+            }
+            catch (e) {
+                tonProof = {
+                    name: 'ton_proof',
+                    error: {
+                        code: CONNECT_ITEM_ERROR_CODES.UNKNOWN_ERROR,
+                        message: 'Invalid data format'
+                    }
+                };
+            }
+            wallet.connectItems = { tonProof };
         }
         this.wallet = wallet;
         this.tracker.trackConnectionCompleted(wallet);
@@ -3179,5 +3355,5 @@ function hexToBytes(hex) {
     return result;
 }
 
-export { BadRequestError, BrowserEventDispatcher, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletMissingRequiredFeaturesError, WalletNotConnectedError, WalletNotInjectedError, WalletNotSupportFeatureError, WalletsListManager, WrongAddressError, checkRequiredWalletFeatures, createConnectionCompletedEvent, createConnectionErrorEvent, createConnectionRestoringCompletedEvent, createConnectionRestoringErrorEvent, createConnectionRestoringStartedEvent, createConnectionStartedEvent, createDisconnectionEvent, createRequestVersionEvent, createResponseVersionEvent, createTransactionSentForSignatureEvent, createTransactionSignedEvent, createTransactionSigningFailedEvent, createVersionInfo, TonConnect as default, encodeTelegramUrlParameters, isTelegramUrl, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
+export { BadRequestError, BrowserEventDispatcher, FetchWalletsError, LocalstorageNotFoundError, ParseHexError, TonConnect, TonConnectError, UnknownAppError, UnknownError, UserRejectsError, WalletAlreadyConnectedError, WalletMissingRequiredFeaturesError, WalletNotConnectedError, WalletNotInjectedError, WalletNotSupportFeatureError, WalletsListManager, WrongAddressError, checkRequiredWalletFeatures, createConnectionCompletedEvent, createConnectionErrorEvent, createConnectionRestoringCompletedEvent, createConnectionRestoringErrorEvent, createConnectionRestoringStartedEvent, createConnectionStartedEvent, createDataSentForSignatureEvent, createDataSignedEvent, createDataSigningFailedEvent, createDisconnectionEvent, createRequestVersionEvent, createResponseVersionEvent, createTransactionSentForSignatureEvent, createTransactionSignedEvent, createTransactionSigningFailedEvent, createVersionInfo, TonConnect as default, encodeTelegramUrlParameters, isTelegramUrl, isWalletInfoCurrentlyEmbedded, isWalletInfoCurrentlyInjected, isWalletInfoInjectable, isWalletInfoInjected, isWalletInfoRemote, toUserFriendlyAddress };
 //# sourceMappingURL=index.mjs.map