@formo/analytics 1.19.7 → 1.19.9

package/dist/esm/src/FormoAnalytics.js

@@ -55,13 +55,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { createStore } from "mipd";
-import { EVENTS_API_URL, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_CURRENT_URL_KEY, SESSION_USER_ID_KEY, SESSION_WALLET_DETECTED_KEY, DEFAULT_PROVIDER_ICON, } from "./constants";
+import { EVENTS_API_URL, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_CURRENT_URL_KEY, SESSION_USER_ID_KEY, SESSION_WALLET_DETECTED_KEY, SESSION_WALLET_IDENTIFIED_KEY, DEFAULT_PROVIDER_ICON, } from "./constants";
 import { cookie, EventManager, EventQueue, initStorageManager, logger, Logger, } from "./lib";
 import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "./types";
 import { toChecksumAddress } from "./utils";
 import { getValidAddress } from "./utils/address";
 import { isLocalhost } from "./validators";
 import { parseChainId } from "./utils/chain";
+/**
+ * Constants for provider switching reasons
+ */
+var PROVIDER_SWITCH_REASONS = {
+    ADDRESS_MISMATCH: "Address mismatch indicates wallet switch",
+    NO_ACCOUNTS: "Current provider has no accounts",
+    CHECK_FAILED: "Could not check current provider accounts"
+};
 var FormoAnalytics = /** @class */ (function () {
     function FormoAnalytics(writeKey, options) {
         if (options === void 0) { options = {}; }
@@ -83,6 +91,8 @@ var FormoAnalytics = /** @class */ (function () {
          * - A provider can be tracked but later removed from discovery
          */
         this._trackedProviders = new Set();
+        // Flag to prevent concurrent processing of accountsChanged events
+        this._processingAccountsChanged = false;
         // Set to efficiently track seen providers for deduplication and O(1) lookup
         this._seenProviders = new Set();
         this.currentUserId = "";
@@ -206,6 +216,7 @@ var FormoAnalytics = /** @class */ (function () {
         cookie().remove(LOCAL_ANONYMOUS_ID_KEY);
         cookie().remove(SESSION_USER_ID_KEY);
         cookie().remove(SESSION_WALLET_DETECTED_KEY);
+        cookie().remove(SESSION_WALLET_IDENTIFIED_KEY);
     };
     /**
      * Emits a connect wallet event.
@@ -282,7 +293,8 @@ var FormoAnalytics = /** @class */ (function () {
                         _a.sent();
                         this.currentAddress = undefined;
                         this.currentChainId = undefined;
-                        logger.info("Wallet disconnected: Cleared currentAddress and currentChainId");
+                        this.clearActiveProvider();
+                        logger.info("Wallet disconnected: Cleared currentAddress, currentChainId, and provider");
                         return [2 /*return*/];
                 }
             });
@@ -392,51 +404,58 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.identify = function (params, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, providerDetail, provider, address_1, err_1, userId, address, providerName, rdns, validAddress, e_1;
+            var _i, _a, providerDetail, provider, address_1, validAddress_1, err_1, userId, address, providerName, rdns, validAddress, e_1;
             var _b;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        _c.trys.push([0, 11, , 12]);
-                        if (!!params) return [3 /*break*/, 9];
+                        _c.trys.push([0, 12, , 13]);
+                        if (!!params) return [3 /*break*/, 10];
                         // If no params provided, auto-identify
                         logger.info("Auto-identifying with providers:", this._providers.map(function (p) { return p.info.name; }));
                         _i = 0, _a = this._providers;
                         _c.label = 1;
                     case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 8];
+                        if (!(_i < _a.length)) return [3 /*break*/, 9];
                         providerDetail = _a[_i];
                         provider = providerDetail.provider;
                         if (!provider)
-                            return [3 /*break*/, 7];
+                            return [3 /*break*/, 8];
                         _c.label = 2;
                     case 2:
-                        _c.trys.push([2, 6, , 7]);
+                        _c.trys.push([2, 7, , 8]);
                         return [4 /*yield*/, this.getAddress(provider)];
                     case 3:
                         address_1 = _c.sent();
-                        if (!address_1) return [3 /*break*/, 5];
-                        logger.info("Auto-identifying", address_1, providerDetail.info.name, providerDetail.info.rdns);
+                        if (!address_1) return [3 /*break*/, 6];
+                        validAddress_1 = this.validateAndChecksumAddress(address_1);
+                        if (!(validAddress_1 && !this.session.isWalletIdentified(validAddress_1, providerDetail.info.rdns))) return [3 /*break*/, 5];
+                        logger.info("Auto-identifying", validAddress_1, providerDetail.info.name, providerDetail.info.rdns);
                         // NOTE: do not set this.currentAddress without explicit connect or identify
                         return [4 /*yield*/, this.identify({
-                                address: address_1,
+                                address: validAddress_1,
                                 providerName: providerDetail.info.name,
                                 rdns: providerDetail.info.rdns,
                             }, properties, context, callback)];
                     case 4:
                         // NOTE: do not set this.currentAddress without explicit connect or identify
                         _c.sent();
-                        _c.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
+                        return [3 /*break*/, 6];
+                    case 5:
+                        if (validAddress_1) {
+                            logger.info("Auto-identify: Skipping already identified wallet", validAddress_1, providerDetail.info.name, providerDetail.info.rdns);
+                        }
+                        _c.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
                         err_1 = _c.sent();
                         logger.error("Failed to identify provider ".concat(providerDetail.info.name, ":"), err_1);
-                        return [3 /*break*/, 7];
-                    case 7:
+                        return [3 /*break*/, 8];
+                    case 8:
                         _i++;
                         return [3 /*break*/, 1];
-                    case 8: return [2 /*return*/];
-                    case 9:
+                    case 9: return [2 /*return*/];
+                    case 10:
                         userId = params.userId, address = params.address, providerName = params.providerName, rdns = params.rdns;
                         logger.info("Identify", address, userId, providerName, rdns);
                         validAddress = undefined;
@@ -454,20 +473,29 @@ var FormoAnalytics = /** @class */ (function () {
                             this.currentUserId = userId;
                             cookie().set(SESSION_USER_ID_KEY, userId);
                         }
+                        // Check for duplicate identify events in this session
+                        if (validAddress && rdns && this.session.isWalletIdentified(validAddress, rdns)) {
+                            logger.warn("Identify: Wallet ".concat(providerName || 'Unknown', " with address ").concat(validAddress, " already identified in this session"));
+                            return [2 /*return*/];
+                        }
+                        // Mark as identified before emitting the event
+                        if (validAddress && rdns) {
+                            this.session.markWalletIdentified(validAddress, rdns);
+                        }
                         return [4 /*yield*/, this.trackEvent(EventType.IDENTIFY, {
                                 address: validAddress,
                                 providerName: providerName,
                                 userId: userId,
                                 rdns: rdns,
                             }, properties, context, callback)];
-                    case 10:
-                        _c.sent();
-                        return [3 /*break*/, 12];
                     case 11:
+                        _c.sent();
+                        return [3 /*break*/, 13];
+                    case 12:
                         e_1 = _c.sent();
                         logger.log("identify error", e_1);
-                        return [3 /*break*/, 12];
-                    case 12: return [2 /*return*/];
+                        return [3 /*break*/, 13];
+                    case 13: return [2 /*return*/];
                 }
             });
         });
@@ -580,12 +608,49 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.onAccountsChanged = function (provider, accounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var error_1, address, nextChainId, wasDisconnected, isProviderSwitch, hadPreviousConnection, error_2, providerInfo, effectiveChainId;
-            var _a, _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         logger.info("onAccountsChanged", accounts);
+                        // Prevent concurrent processing of accountsChanged events to avoid race conditions
+                        if (this._processingAccountsChanged) {
+                            logger.debug("OnAccountsChanged: Already processing accountsChanged, skipping", {
+                                provider: this.getProviderInfo(provider).name
+                            });
+                            return [2 /*return*/];
+                        }
+                        this._processingAccountsChanged = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, this._handleAccountsChanged(provider, accounts)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._processingAccountsChanged = false;
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Handles changes to the accounts of a given EIP-1193 provider.
+     *
+     * @param provider - The EIP-1193 provider whose accounts have changed.
+     * @param accounts - The new array of account addresses. An empty array indicates a disconnect.
+     * @returns A promise that resolves when the account change has been processed.
+     *
+     * If the accounts array is empty and the provider is the active provider, this method triggers
+     * a disconnect flow. Otherwise, it updates the state to reflect the new accounts as needed.
+     */
+    FormoAnalytics.prototype._handleAccountsChanged = function (provider, accounts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1, address, currentStoredAddress, newProviderAddress, activeProviderAccounts, error_2, nextChainId, wasDisconnected, providerInfo, effectiveChainId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
                         if (!(accounts.length === 0)) return [3 /*break*/, 7];
                         if (!(this._provider === provider)) return [3 /*break*/, 5];
                         logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
@@ -593,9 +658,9 @@ var FormoAnalytics = /** @class */ (function () {
                             currentChainId: this.currentChainId,
                             providerMatch: this._provider === provider
                         });
-                        _d.label = 1;
+                        _a.label = 1;
                     case 1:
-                        _d.trys.push([1, 3, , 4]);
+                        _a.trys.push([1, 3, , 4]);
                         // Pass current state explicitly to ensure we have the data for the disconnect event
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
@@ -603,16 +668,16 @@ var FormoAnalytics = /** @class */ (function () {
                             })];
                     case 2:
                         // Pass current state explicitly to ensure we have the data for the disconnect event
-                        _d.sent();
+                        _a.sent();
                         return [3 /*break*/, 4];
                     case 3:
-                        error_1 = _d.sent();
+                        error_1 = _a.sent();
                         logger.error("Failed to disconnect provider on accountsChanged", error_1);
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:
                         logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
-                        _d.label = 6;
+                        _a.label = 6;
                     case 6: return [2 /*return*/];
                     case 7:
                         address = this.validateAndChecksumAddress(accounts[0]);
@@ -620,54 +685,106 @@ var FormoAnalytics = /** @class */ (function () {
                             logger.warn("onAccountsChanged: Invalid address received", accounts[0]);
                             return [2 /*return*/];
                         }
-                        // If both the provider and address are the same, no-op. Allow provider switches even if address is the same.
-                        if (this._provider === provider && address === this.currentAddress) {
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 8:
-                        nextChainId = _d.sent();
-                        wasDisconnected = !this.currentAddress;
-                        isProviderSwitch = this._provider && this._provider !== provider;
-                        logger.info("OnAccountsChanged: Provider switching analysis:", {
-                            currentProvider: ((_b = (_a = this._provider) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) || 'none',
-                            newProvider: ((_c = provider === null || provider === void 0 ? void 0 : provider.constructor) === null || _c === void 0 ? void 0 : _c.name) || 'unknown',
-                            currentAddress: this.currentAddress,
-                            wasDisconnected: wasDisconnected,
-                            isProviderMismatch: isProviderSwitch
+                        if (!(this._provider && this._provider !== provider)) return [3 /*break*/, 18];
+                        currentStoredAddress = this.currentAddress;
+                        newProviderAddress = this.validateAndChecksumAddress(address);
+                        logger.info("OnAccountsChanged: Different provider attempting to connect", {
+                            activeProvider: this.getProviderInfo(this._provider).name,
+                            eventProvider: this.getProviderInfo(provider).name,
+                            currentStoredAddress: currentStoredAddress,
+                            newProviderAddress: newProviderAddress
                         });
-                        if (!isProviderSwitch) return [3 /*break*/, 13];
-                        hadPreviousConnection = !!this.currentAddress;
-                        if (!hadPreviousConnection) return [3 /*break*/, 12];
-                        logger.info("OnAccountsChanged: Detected provider switch with existing connection - emitting disconnect for previous provider");
-                        _d.label = 9;
+                        _a.label = 8;
+                    case 8:
+                        _a.trys.push([8, 16, , 18]);
+                        return [4 /*yield*/, this.getAccounts(this._provider)];
                     case 9:
-                        _d.trys.push([9, 11, , 12]);
+                        activeProviderAccounts = _a.sent();
+                        logger.info("OnAccountsChanged: Checking current provider accounts", {
+                            activeProvider: this.getProviderInfo(this._provider).name,
+                            accountsLength: activeProviderAccounts ? activeProviderAccounts.length : 0,
+                            accounts: activeProviderAccounts
+                        });
+                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 13];
+                        if (!(newProviderAddress && currentStoredAddress && newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 11];
+                        logger.info("OnAccountsChanged: Different address detected, switching providers despite current provider having accounts", {
+                            activeProvider: this.getProviderInfo(this._provider).name,
+                            eventProvider: this.getProviderInfo(provider).name,
+                            currentAddress: currentStoredAddress,
+                            newAddress: newProviderAddress,
+                            reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH
+                        });
+                        // Emit disconnect for the old provider
                         return [4 /*yield*/, this.disconnect({
                                 chainId: this.currentChainId,
                                 address: this.currentAddress
                             })];
                     case 10:
-                        _d.sent();
+                        // Emit disconnect for the old provider
+                        _a.sent();
+                        // Clear state and let the new provider become active
+                        this.clearActiveProvider();
                         return [3 /*break*/, 12];
                     case 11:
-                        error_2 = _d.sent();
-                        logger.error("Failed to emit disconnect during provider switch:", error_2);
-                        return [3 /*break*/, 12];
-                    case 12:
-                        // Validate that the new provider is in a valid state before switching
-                        if (this.isProviderInValidState(provider)) {
-                            logger.info("OnAccountsChanged: Handling provider mismatch - switching providers");
-                            this.handleProviderMismatch(provider);
+                        logger.info("OnAccountsChanged: Current provider still has accounts and same address, ignoring new provider", {
+                            activeProvider: this.getProviderInfo(this._provider).name,
+                            eventProvider: this.getProviderInfo(provider).name,
+                            activeProviderAccountsCount: activeProviderAccounts.length,
+                            currentAddress: currentStoredAddress,
+                            newAddress: newProviderAddress
+                        });
+                        return [2 /*return*/];
+                    case 12: return [3 /*break*/, 15];
+                    case 13:
+                        logger.info("OnAccountsChanged: Current provider has no accounts, switching to new provider", {
+                            oldProvider: this.getProviderInfo(this._provider).name,
+                            newProvider: this.getProviderInfo(provider).name,
+                            reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS
+                        });
+                        // Emit disconnect for the old provider that didn't signal properly
+                        return [4 /*yield*/, this.disconnect({
+                                chainId: this.currentChainId,
+                                address: this.currentAddress
+                            })];
+                    case 14:
+                        // Emit disconnect for the old provider that didn't signal properly
+                        _a.sent();
+                        // Clear state and let the new provider become active
+                        this.clearActiveProvider();
+                        _a.label = 15;
+                    case 15: return [3 /*break*/, 18];
+                    case 16:
+                        error_2 = _a.sent();
+                        logger.warn("OnAccountsChanged: Could not check current provider accounts, switching to new provider", {
+                            error: error_2 instanceof Error ? error_2.message : String(error_2),
+                            errorType: error_2 instanceof Error ? error_2.constructor.name : typeof error_2,
+                            oldProvider: this._provider ? this.getProviderInfo(this._provider).name : 'unknown',
+                            newProvider: this.getProviderInfo(provider).name,
+                            reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED
+                        });
+                        // If we can't check the current provider, assume it's disconnected
+                        return [4 /*yield*/, this.disconnect({
+                                chainId: this.currentChainId,
+                                address: this.currentAddress
+                            })];
+                    case 17:
+                        // If we can't check the current provider, assume it's disconnected
+                        _a.sent();
+                        this.clearActiveProvider();
+                        return [3 /*break*/, 18];
+                    case 18:
+                        // Set provider if none exists (first connection)
+                        if (!this._provider) {
+                            this._provider = provider;
                         }
-                        else {
-                            logger.warn("Provider switching blocked: new provider is not in a valid state");
+                        // If both the provider and address are the same, no-op
+                        if (this._provider === provider && address === this.currentAddress) {
                             return [2 /*return*/];
                         }
-                        _d.label = 13;
-                    case 13:
-                        // Commit new active provider and state
-                        this._provider = provider;
+                        return [4 /*yield*/, this.getCurrentChainId(provider)];
+                    case 19:
+                        nextChainId = _a.sent();
+                        wasDisconnected = !this.currentAddress;
                         this.currentAddress = address;
                         this.currentChainId = nextChainId;
                         providerInfo = this.getProviderInfo(provider);
@@ -675,7 +792,6 @@ var FormoAnalytics = /** @class */ (function () {
                             chainId: nextChainId,
                             address: address,
                             wasDisconnected: wasDisconnected,
-                            isProviderSwitch: isProviderSwitch,
                             providerName: providerInfo.name,
                             rdns: providerInfo.rdns,
                             hasChainId: !!nextChainId
@@ -798,7 +914,7 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.onConnected = function (provider, connection) {
         return __awaiter(this, void 0, void 0, function () {
-            var chainId, address, wasDisconnected, providerInfo, effectiveChainId, e_3;
+            var chainId, address, wasDisconnected, isActiveProvider, providerInfo, effectiveChainId, providerInfo, e_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -818,17 +934,21 @@ var FormoAnalytics = /** @class */ (function () {
                             if (!this._provider) {
                                 this._provider = provider;
                             }
-                            this.currentChainId = chainId;
-                            this.currentAddress = this.validateAndChecksumAddress(address) || undefined;
-                            // Always emit connect event for better analytics capture
-                            if (this.currentAddress) {
+                            isActiveProvider = this._provider === provider;
+                            // Only update global state (chainId/address) from the active provider
+                            if (isActiveProvider) {
+                                this.currentChainId = chainId;
+                                this.currentAddress = this.validateAndChecksumAddress(address) || undefined;
+                            }
+                            if (isActiveProvider && this.currentAddress) {
                                 providerInfo = this.getProviderInfo(provider);
                                 logger.info("OnConnected: Detected wallet connection, emitting connect event", {
                                     chainId: chainId,
                                     wasDisconnected: wasDisconnected,
                                     providerName: providerInfo.name,
                                     rdns: providerInfo.rdns,
-                                    hasChainId: !!chainId
+                                    hasChainId: !!chainId,
+                                    isActiveProvider: isActiveProvider
                                 });
                                 effectiveChainId = chainId || 0;
                                 if (effectiveChainId === 0) {
@@ -844,6 +964,16 @@ var FormoAnalytics = /** @class */ (function () {
                                     logger.error("Failed to track connect event during provider connection:", error);
                                 });
                             }
+                            else if (address && !isActiveProvider) {
+                                providerInfo = this.getProviderInfo(provider);
+                                logger.debug("OnConnected: Skipping connect event for non-active provider", {
+                                    chainId: chainId,
+                                    providerName: providerInfo.name,
+                                    rdns: providerInfo.rdns,
+                                    isActiveProvider: isActiveProvider,
+                                    activeProviderInfo: this._provider ? this.getProviderInfo(this._provider) : null
+                                });
+                            }
                         }
                         return [3 /*break*/, 4];
                     case 3:
@@ -1606,7 +1736,7 @@ var FormoAnalytics = /** @class */ (function () {
             this.removeProviderListeners(provider);
             this._trackedProviders.delete(provider);
             if (this._provider === provider) {
-                this._provider = undefined;
+                this.clearActiveProvider();
             }
         }
         catch (e) {
@@ -1678,6 +1808,13 @@ var FormoAnalytics = /** @class */ (function () {
         var validAddress = getValidAddress(address);
         return validAddress ? toChecksumAddress(validAddress) : undefined;
     };
+    /**
+     * Helper method to clear the active provider state
+     * Centralizes provider clearing logic for consistency
+     */
+    FormoAnalytics.prototype.clearActiveProvider = function () {
+        this._provider = undefined;
+    };
     /**
      * Helper method to safely add a provider detail to _providers array, ensuring no duplicates
      * @param detail The provider detail to add
@@ -1715,12 +1852,33 @@ var FormoAnalyticsSession = /** @class */ (function () {
     FormoAnalyticsSession.prototype.markWalletDetected = function (rdns) {
         var _a;
         var rdnses = ((_a = cookie().get(SESSION_WALLET_DETECTED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        rdnses.push(rdns);
-        cookie().set(SESSION_WALLET_DETECTED_KEY, rdnses.join(","), {
-            // by the end of the day
-            expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
-            path: "/",
-        });
+        if (!rdnses.includes(rdns)) {
+            rdnses.push(rdns);
+            cookie().set(SESSION_WALLET_DETECTED_KEY, rdnses.join(","), {
+                // by the end of the day
+                expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
+                path: "/",
+            });
+        }
+    };
+    FormoAnalyticsSession.prototype.isWalletIdentified = function (address, rdns) {
+        var _a;
+        var identifiedKey = "".concat(address, ":").concat(rdns);
+        var identifiedWallets = ((_a = cookie().get(SESSION_WALLET_IDENTIFIED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
+        return identifiedWallets.includes(identifiedKey);
+    };
+    FormoAnalyticsSession.prototype.markWalletIdentified = function (address, rdns) {
+        var _a;
+        var identifiedKey = "".concat(address, ":").concat(rdns);
+        var identifiedWallets = ((_a = cookie().get(SESSION_WALLET_IDENTIFIED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
+        if (!identifiedWallets.includes(identifiedKey)) {
+            identifiedWallets.push(identifiedKey);
+            cookie().set(SESSION_WALLET_IDENTIFIED_KEY, identifiedWallets.join(","), {
+                // by the end of the day
+                expires: new Date(Date.now() + 86400 * 1000).toUTCString(),
+                path: "/",
+            });
+        }
     };
     return FormoAnalyticsSession;
 }());

package/dist/esm/src/constants/base.d.ts

@@ -1,5 +1,6 @@
 export declare const SESSION_TRAFFIC_SOURCE_KEY = "traffic-source";
 export declare const SESSION_WALLET_DETECTED_KEY = "wallet-detected";
+export declare const SESSION_WALLET_IDENTIFIED_KEY = "wallet-identified";
 export declare const SESSION_CURRENT_URL_KEY = "analytics-current-url";
 export declare const SESSION_USER_ID_KEY = "user-id";
 export declare const LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";

package/dist/esm/src/constants/base.js

@@ -1,5 +1,6 @@
 export var SESSION_TRAFFIC_SOURCE_KEY = "traffic-source";
 export var SESSION_WALLET_DETECTED_KEY = "wallet-detected";
+export var SESSION_WALLET_IDENTIFIED_KEY = "wallet-identified";
 export var SESSION_CURRENT_URL_KEY = "analytics-current-url";
 export var SESSION_USER_ID_KEY = "user-id";
 export var LOCAL_ANONYMOUS_ID_KEY = "anonymous-id";

package/dist/esm/src/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.19.5";
+export declare const version = "1.19.7";
 //# sourceMappingURL=version.d.ts.map

package/dist/esm/src/lib/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export var version = '1.19.5';
+export var version = '1.19.7';
 //# sourceMappingURL=version.js.map

package/dist/esm/src/utils/base.js

@@ -1,4 +1,13 @@
 export var getActionDescriptor = function (type, properties) {
-    return "".concat(type).concat((properties === null || properties === void 0 ? void 0 : properties.status) ? " ".concat(properties === null || properties === void 0 ? void 0 : properties.status) : "");
+    var descriptor = type;
+    // Add status for events that have it (e.g., signature, transaction)
+    if (properties === null || properties === void 0 ? void 0 : properties.status) {
+        descriptor += " ".concat(properties.status);
+    }
+    // Add RDNS for connect/disconnect events to identify the wallet provider
+    if ((type === 'connect' || type === 'disconnect') && (properties === null || properties === void 0 ? void 0 : properties.rdns)) {
+        descriptor += " (".concat(properties.rdns, ")");
+    }
+    return descriptor;
 };
 //# sourceMappingURL=base.js.map