@formo/analytics 1.19.7 → 1.19.8

package/dist/cjs/src/FormoAnalytics.d.ts

@@ -22,6 +22,7 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      */
     private _trackedProviders;
     private _injectedProviderDetail?;
+    private _processingAccountsChanged;
     private _seenProviders;
     config: Config;
     currentChainId?: ChainID;
@@ -181,6 +182,17 @@ export declare class FormoAnalytics implements IFormoAnalytics {
     private addProviderListener;
     private registerAccountsChangedListener;
     private onAccountsChanged;
+    /**
+     * 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.
+     */
+    private _handleAccountsChanged;
     private registerChainChangedListener;
     private onChainChanged;
     private registerConnectListener;

package/dist/cjs/src/FormoAnalytics.js

@@ -65,6 +65,14 @@ var utils_1 = require("./utils");
 var address_1 = require("./utils/address");
 var validators_1 = require("./validators");
 var chain_1 = require("./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 = {}; }
@@ -86,6 +94,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 = "";
@@ -285,7 +295,8 @@ var FormoAnalytics = /** @class */ (function () {
                         _a.sent();
                         this.currentAddress = undefined;
                         this.currentChainId = undefined;
-                        lib_1.logger.info("Wallet disconnected: Cleared currentAddress and currentChainId");
+                        this._provider = undefined;
+                        lib_1.logger.info("Wallet disconnected: Cleared currentAddress, currentChainId, and provider");
                         return [2 /*return*/];
                 }
             });
@@ -583,12 +594,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:
                         lib_1.logger.info("onAccountsChanged", accounts);
+                        // Prevent concurrent processing of accountsChanged events to avoid race conditions
+                        if (this._processingAccountsChanged) {
+                            lib_1.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];
                         lib_1.logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
@@ -596,9 +644,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,
@@ -606,16 +654,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();
                         lib_1.logger.error("Failed to disconnect provider on accountsChanged", error_1);
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:
                         lib_1.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]);
@@ -623,54 +671,106 @@ var FormoAnalytics = /** @class */ (function () {
                             lib_1.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;
-                        lib_1.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);
+                        lib_1.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];
-                        lib_1.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();
+                        lib_1.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];
+                        lib_1.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._provider = undefined;
                         return [3 /*break*/, 12];
                     case 11:
-                        error_2 = _d.sent();
-                        lib_1.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)) {
-                            lib_1.logger.info("OnAccountsChanged: Handling provider mismatch - switching providers");
-                            this.handleProviderMismatch(provider);
+                        lib_1.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:
+                        lib_1.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._provider = undefined;
+                        _a.label = 15;
+                    case 15: return [3 /*break*/, 18];
+                    case 16:
+                        error_2 = _a.sent();
+                        lib_1.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._provider = undefined;
+                        return [3 /*break*/, 18];
+                    case 18:
+                        // Set provider if none exists (first connection)
+                        if (!this._provider) {
+                            this._provider = provider;
                         }
-                        else {
-                            lib_1.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);
@@ -678,7 +778,6 @@ var FormoAnalytics = /** @class */ (function () {
                             chainId: nextChainId,
                             address: address,
                             wasDisconnected: wasDisconnected,
-                            isProviderSwitch: isProviderSwitch,
                             providerName: providerInfo.name,
                             rdns: providerInfo.rdns,
                             hasChainId: !!nextChainId
@@ -801,7 +900,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:
@@ -821,17 +920,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);
                                 lib_1.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) {
@@ -847,6 +950,16 @@ var FormoAnalytics = /** @class */ (function () {
                                     lib_1.logger.error("Failed to track connect event during provider connection:", error);
                                 });
                             }
+                            else if (address && !isActiveProvider) {
+                                providerInfo = this.getProviderInfo(provider);
+                                lib_1.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:

package/dist/cjs/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/cjs/src/lib/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = '1.19.5';
+exports.version = '1.19.7';
 //# sourceMappingURL=version.js.map

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

@@ -2,7 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActionDescriptor = void 0;
 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;
 };
 exports.getActionDescriptor = getActionDescriptor;
 //# sourceMappingURL=base.js.map

package/dist/esm/src/FormoAnalytics.d.ts

@@ -22,6 +22,7 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      */
     private _trackedProviders;
     private _injectedProviderDetail?;
+    private _processingAccountsChanged;
     private _seenProviders;
     config: Config;
     currentChainId?: ChainID;
@@ -181,6 +182,17 @@ export declare class FormoAnalytics implements IFormoAnalytics {
     private addProviderListener;
     private registerAccountsChangedListener;
     private onAccountsChanged;
+    /**
+     * 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.
+     */
+    private _handleAccountsChanged;
     private registerChainChangedListener;
     private onChainChanged;
     private registerConnectListener;