@tonconnect/ui 2.0.2-beta.1 → 2.0.3-beta.0

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import { WalletInfoBase, WalletInfoInjectable, WalletInfoRemote, ITonConnect, Wallet, WalletInfo, Account, ConnectAdditionalRequest, TonConnectError, SendTransactionRequest, SendTransactionResponse } from '@tonconnect/sdk';
 export * from '@tonconnect/sdk';
 import { Property } from 'csstype';
+import { ConnectItem } from '@tonconnect/protocol';
 
 declare type Locales = 'en' | 'ru';
 
@@ -307,6 +308,7 @@ declare class TonConnectUI {
     static getWallets(): Promise<WalletInfo[]>;
     private readonly walletInfoStorage;
     private readonly preferredWalletStorage;
+    private readonly tracker;
     private walletInfo;
     private systemThemeChangeUnsubscribe;
     private actionsConfiguration?;
@@ -474,10 +476,236 @@ declare class TonConnectUI {
     private getModalsAndNotificationsConfiguration;
 }
 
+/**
+ * Requested authentication type: 'ton_addr' or 'ton_proof'.
+ */
+declare type AuthType = ConnectItem['name'];
+/**
+ * Information about a connected wallet.
+ */
+declare type ConnectionInfo = {
+    /**
+     * Connected wallet address.
+     */
+    address: string | null;
+    /**
+     * Connected chain ID.
+     */
+    chainId: string | null;
+    /**
+     * Wallet provider.
+     */
+    provider: 'http' | 'injected' | null;
+    /**
+     * Wallet type: 'tonkeeper', 'tonhub', etc.
+     */
+    walletType: string | null;
+    /**
+     * Wallet version.
+     */
+    walletVersion: string | null;
+    /**
+     * Requested authentication types.
+     */
+    authType: AuthType | null;
+};
+/**
+ * Initial connection event when a user initiates a connection.
+ */
+declare type ConnectionStartedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-started';
+};
+/**
+ * Successful connection event when a user successfully connected a wallet.
+ */
+declare type ConnectionCompletedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-completed';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+};
+/**
+ * Connection error event when a user cancels a connection or there is an error during the connection process.
+ */
+declare type ConnectionErrorEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-error';
+    /**
+     * Reason for the error.
+     */
+    reason: string;
+};
+/**
+ * Connection events.
+ */
+declare type ConnectionEvent = ConnectionStartedEvent | ConnectionCompletedEvent | ConnectionErrorEvent;
+/**
+ * Connection restoring started event when initiates a connection restoring process.
+ */
+declare type ConnectionRestoringStartedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-restoring-started';
+};
+/**
+ * Connection restoring completed event when successfully restored a connection.
+ */
+declare type ConnectionRestoringCompletedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-restoring-completed';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+};
+/**
+ * Connection restoring error event when there is an error during the connection restoring process.
+ */
+declare type ConnectionRestoringErrorEvent = {
+    /**
+     * Event type.
+     */
+    type: 'connection-restoring-error';
+    /**
+     * Reason for the error.
+     */
+    reason: string;
+};
+/**
+ * Connection restoring events.
+ */
+declare type ConnectionRestoringEvent = ConnectionRestoringStartedEvent | ConnectionRestoringCompletedEvent | ConnectionRestoringErrorEvent;
+/**
+ * Transaction message.
+ */
+declare type TransactionMessage = {
+    /**
+     * Recipient address.
+     */
+    address: string | null;
+    /**
+     * Transfer amount.
+     */
+    amount: string | null;
+};
+/**
+ * Transaction information.
+ */
+declare type TransactionInfo = {
+    /**
+     * Transaction validity time in unix timestamp.
+     */
+    validUntil: number | null;
+    /**
+     * Sender address.
+     */
+    from: string | null;
+    /**
+     * Transaction messages.
+     */
+    messages: TransactionMessage[];
+};
+/**
+ * Initial transaction event when a user initiates a transaction.
+ */
+declare type TransactionSentForSignatureEvent = {
+    /**
+     * Event type.
+     */
+    type: 'transaction-sent-for-signature';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+    /**
+     * Transaction information.
+     */
+    transactionInfo: TransactionInfo;
+};
+/**
+ * Transaction signed event when a user successfully signed a transaction.
+ */
+declare type TransactionSignedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'transaction-signed';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+    /**
+     * Transaction information.
+     */
+    transactionInfo: TransactionInfo;
+    /**
+     * Signed transaction.
+     */
+    signedTransaction: string;
+};
+/**
+ * Transaction error event when a user cancels a transaction or there is an error during the transaction process.
+ */
+declare type TransactionSigningFailedEvent = {
+    /**
+     * Event type.
+     */
+    type: 'transaction-signing-failed';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+    /**
+     * Transaction information.
+     */
+    transactionInfo: TransactionInfo;
+    /**
+     * Reason for the error.
+     */
+    reason: string;
+};
+/**
+ * Transaction events.
+ */
+declare type TransactionSigningEvent = TransactionSentForSignatureEvent | TransactionSignedEvent | TransactionSigningFailedEvent;
+/**
+ * Disconnect event when a user initiates a disconnection.
+ */
+declare type DisconnectionEvent = {
+    /**
+     * Event type.
+     */
+    type: 'disconnection';
+    /**
+     * Wallet information.
+     */
+    connectionInfo: ConnectionInfo;
+    /**
+     * Disconnect scope: 'dapp' or 'wallet'.
+     */
+    scope: 'dapp' | 'wallet';
+};
+/**
+ * User action events.
+ */
+declare type UserActionEvent = ConnectionEvent | ConnectionRestoringEvent | DisconnectionEvent | TransactionSigningEvent;
+
 declare type Color = Property.Color;
 
 declare class TonConnectUIError extends TonConnectError {
     constructor(...args: ConstructorParameters<typeof Error>);
 }
 
-export { ActionConfiguration, BorderRadius, Color, ColorsSet, ConnectedWallet, Loadable, LoadableLoading, LoadableReady, Locales, PartialColorsSet, ReturnStrategy, THEME, Theme, TonConnectUI, TonConnectUIError, TonConnectUiCreateOptions, TonConnectUiCreateOptionsBase, TonConnectUiOptions, TonConnectUiOptionsWithConnector, TonConnectUiOptionsWithManifest, UIPreferences, UIWallet, WalletInfoRemoteWithOpenMethod, WalletInfoWithOpenMethod, WalletModalClosed, WalletModalOpened, WalletOpenMethod, WalletsListConfiguration, WalletsModal, WalletsModalCloseReason, WalletsModalState };
+export { ActionConfiguration, BorderRadius, Color, ColorsSet, ConnectedWallet, ConnectionCompletedEvent, ConnectionErrorEvent, ConnectionEvent, ConnectionRestoringCompletedEvent, ConnectionRestoringErrorEvent, ConnectionRestoringStartedEvent, ConnectionStartedEvent, DisconnectionEvent, Loadable, LoadableLoading, LoadableReady, Locales, PartialColorsSet, ReturnStrategy, THEME, Theme, TonConnectUI, TonConnectUIError, TonConnectUiCreateOptions, TonConnectUiCreateOptionsBase, TonConnectUiOptions, TonConnectUiOptionsWithConnector, TonConnectUiOptionsWithManifest, TransactionSentForSignatureEvent, TransactionSignedEvent, TransactionSigningEvent, TransactionSigningFailedEvent, UIPreferences, UIWallet, UserActionEvent, WalletInfoRemoteWithOpenMethod, WalletInfoWithOpenMethod, WalletModalClosed, WalletModalOpened, WalletOpenMethod, WalletsListConfiguration, WalletsModal, WalletsModalCloseReason, WalletsModalState };

package/lib/index.mjs

@@ -10717,10 +10717,191 @@ class SingleWalletModalManager {
     });
   }
 }
+function createConnnectionInfo(wallet) {
+  var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
+  let authType = null;
+  if ((_a2 = wallet == null ? void 0 : wallet.connectItems) == null ? void 0 : _a2.tonProof) {
+    authType = "proof" in wallet.connectItems.tonProof ? "ton_proof" : null;
+  } else if (wallet == null ? void 0 : wallet.connectItems) {
+    authType = "ton_addr";
+  }
+  return {
+    address: (_c2 = (_b2 = wallet == null ? void 0 : wallet.account) == null ? void 0 : _b2.address) != null ? _c2 : null,
+    chainId: (_e2 = (_d2 = wallet == null ? void 0 : wallet.account) == null ? void 0 : _d2.chain) != null ? _e2 : null,
+    provider: (_f2 = wallet == null ? void 0 : wallet.provider) != null ? _f2 : null,
+    walletType: (_g2 = wallet == null ? void 0 : wallet.device.appName) != null ? _g2 : null,
+    walletVersion: (_h2 = wallet == null ? void 0 : wallet.device.appVersion) != null ? _h2 : null,
+    authType
+  };
+}
+function createConnectionStartedEvent() {
+  return {
+    type: "connection-started"
+  };
+}
+function createConnectionCompletedEvent(wallet) {
+  return {
+    type: "connection-completed",
+    connectionInfo: createConnnectionInfo(wallet)
+  };
+}
+function createConnectionErrorEvent(reason) {
+  return {
+    type: "connection-error",
+    reason
+  };
+}
+function createConnectionRestoringStartedEvent() {
+  return {
+    type: "connection-restoring-started"
+  };
+}
+function createConnectionRestoringCompletedEvent(wallet) {
+  return {
+    type: "connection-restoring-completed",
+    connectionInfo: createConnnectionInfo(wallet)
+  };
+}
+function createConnectionRestoringErrorEvent(reason) {
+  return {
+    type: "connection-restoring-error",
+    reason
+  };
+}
+function createTransactionInfo(transaction) {
+  var _a2, _b2;
+  return {
+    validUntil: (_a2 = transaction.validUntil) != null ? _a2 : null,
+    from: (_b2 = transaction.from) != null ? _b2 : null,
+    messages: transaction.messages.map((message) => {
+      var _a3, _b3;
+      return {
+        address: (_a3 = message.address) != null ? _a3 : null,
+        amount: (_b3 = message.amount) != null ? _b3 : null
+      };
+    })
+  };
+}
+function createTransactionSentForSignatureEvent(wallet, transaction) {
+  return {
+    type: "transaction-sent-for-signature",
+    connectionInfo: createConnnectionInfo(wallet),
+    transactionInfo: createTransactionInfo(transaction)
+  };
+}
+function createTransactionSignedEvent(wallet, transaction, signedTransaction) {
+  return {
+    type: "transaction-signed",
+    connectionInfo: createConnnectionInfo(wallet),
+    transactionInfo: createTransactionInfo(transaction),
+    signedTransaction: signedTransaction.boc
+  };
+}
+function createTransactionSigningFailedEvent(wallet, transaction, reason) {
+  return {
+    type: "transaction-signing-failed",
+    connectionInfo: createConnnectionInfo(wallet),
+    transactionInfo: createTransactionInfo(transaction),
+    reason
+  };
+}
+function createDisconnectionEvent(wallet, scope) {
+  return {
+    type: "disconnection",
+    connectionInfo: createConnnectionInfo(wallet),
+    scope
+  };
+}
+class TonConnectTracker {
+  constructor() {
+    __publicField(this, "eventPrefix", "ton-connect-ui-");
+    __publicField(this, "window", getWindow$1());
+  }
+  dispatchUserActionEvent(eventDetails) {
+    var _a2;
+    try {
+      const eventName = `${this.eventPrefix}${eventDetails.type}`;
+      const event = new CustomEvent(eventName, { detail: eventDetails });
+      (_a2 = this.window) == null ? void 0 : _a2.dispatchEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionStarted(...args) {
+    try {
+      const event = createConnectionStartedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionCompleted(...args) {
+    try {
+      const event = createConnectionCompletedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionError(...args) {
+    try {
+      const event = createConnectionErrorEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionRestoringStarted(...args) {
+    try {
+      const event = createConnectionRestoringStartedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionRestoringCompleted(...args) {
+    try {
+      const event = createConnectionRestoringCompletedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackConnectionRestoringError(...args) {
+    try {
+      const event = createConnectionRestoringErrorEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackDisconnection(...args) {
+    try {
+      const event = createDisconnectionEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackTransactionSentForSignature(...args) {
+    try {
+      const event = createTransactionSentForSignatureEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackTransactionSigned(...args) {
+    try {
+      const event = createTransactionSignedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+  trackTransactionSigningFailed(...args) {
+    try {
+      const event = createTransactionSigningFailedEvent(...args);
+      this.dispatchUserActionEvent(event);
+    } catch (e2) {
+    }
+  }
+}
 class TonConnectUI {
   constructor(options) {
     __publicField(this, "walletInfoStorage", new WalletInfoStorage());
     __publicField(this, "preferredWalletStorage", new PreferredWalletStorage());
+    __publicField(this, "tracker", new TonConnectTracker());
     __publicField(this, "walletInfo", null);
     __publicField(this, "systemThemeChangeUnsubscribe", null);
     __publicField(this, "actionsConfiguration");
@@ -10760,10 +10941,14 @@ class TonConnectUI {
     const rootId = this.normalizeWidgetRoot(options == null ? void 0 : options.widgetRootId);
     this.subscribeToWalletChange();
     if ((options == null ? void 0 : options.restoreConnection) !== false) {
+      this.tracker.trackConnectionRestoringStarted();
       this.connectionRestored = new Promise((resolve) => __async(this, null, function* () {
         yield this.connector.restoreConnection();
         if (!this.connector.connected) {
+          this.tracker.trackConnectionRestoringError("Connection was not restored");
           this.walletInfoStorage.removeWalletInfo();
+        } else {
+          this.tracker.trackConnectionRestoringCompleted(this.wallet);
         }
         resolve(this.connector.connected);
       }));
@@ -10858,10 +11043,12 @@ class TonConnectUI {
   }
   openModal() {
     return __async(this, null, function* () {
+      this.tracker.trackConnectionStarted();
       return this.modal.open();
     });
   }
   closeModal() {
+    this.tracker.trackConnectionError("Connection was cancelled");
     this.modal.close();
   }
   onModalStateChange(onChange) {
@@ -10872,10 +11059,12 @@ class TonConnectUI {
   }
   openSingleWalletModal(wallet) {
     return __async(this, null, function* () {
+      this.tracker.trackConnectionStarted();
       return this.singleWalletModal.open(wallet);
     });
   }
   closeSingleWalletModal() {
+    this.tracker.trackConnectionError("Connection was cancelled");
     this.singleWalletModal.close();
   }
   onSingleWalletModalStateChange(onChange) {
@@ -10896,6 +11085,7 @@ class TonConnectUI {
     });
   }
   disconnect() {
+    this.tracker.trackDisconnection(this.wallet, "dapp");
     widgetController.clearAction();
     widgetController.removeSelectedWalletInfo();
     this.walletInfoStorage.removeWalletInfo();
@@ -10903,7 +11093,9 @@ class TonConnectUI {
   }
   sendTransaction(tx, options) {
     return __async(this, null, function* () {
+      this.tracker.trackTransactionSentForSignature(this.wallet, tx);
       if (!this.connected) {
+        this.tracker.trackTransactionSigningFailed(this.wallet, tx, "Wallet was not connected");
         throw new TonConnectUIError("Connect wallet to send a transaction.");
       }
       if (isInTMA()) {
@@ -10965,6 +11157,7 @@ class TonConnectUI {
           },
           onRequestSent
         );
+        this.tracker.trackTransactionSigned(this.wallet, tx, result);
         widgetController.setAction({
           name: "transaction-sent",
           showNotification: notifications2.includes("success"),
@@ -10972,6 +11165,7 @@ class TonConnectUI {
         });
         return result;
       } catch (e2) {
+        this.tracker.trackTransactionSigningFailed(this.wallet, tx, e2.message);
         widgetController.setAction({
           name: "transaction-canceled",
           showNotification: notifications2.includes("error"),
@@ -11028,23 +11222,28 @@ class TonConnectUI {
   waitForWalletConnection(options) {
     return __async(this, null, function* () {
       return new Promise((resolve, reject) => {
+        this.tracker.trackConnectionStarted();
         const { ignoreErrors = false, signal = null } = options;
         if (signal && signal.aborted) {
+          this.tracker.trackConnectionError("Connection was cancelled");
           return reject(new TonConnectUIError("Wallet was not connected"));
         }
         const onStatusChangeHandler = (wallet) => __async(this, null, function* () {
           if (!wallet) {
+            this.tracker.trackConnectionError("Connection was cancelled");
             if (ignoreErrors) {
               return;
             }
             unsubscribe();
             reject(new TonConnectUIError("Wallet was not connected"));
           } else {
+            this.tracker.trackConnectionCompleted(wallet);
             unsubscribe();
             resolve(wallet);
           }
         });
         const onErrorsHandler = (reason) => {
+          this.tracker.trackConnectionError(reason.message);
           if (ignoreErrors) {
             return;
           }