@formo/analytics 1.19.6 → 1.19.8

package/dist/esm/src/FormoAnalytics.js

@@ -45,22 +45,56 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    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, } from "./constants";
+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 { cookie, EventManager, EventQueue, initStorageManager, logger, Logger, } from "./lib";
-import { SignatureStatus, TransactionStatus, } from "./types";
+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 = {}; }
         var _a, _b;
         this.writeKey = writeKey;
         this.options = options;
-        this._providerListeners = {};
+        this._providerListenersMap = new Map();
+        /**
+         * EIP-6963 provider details discovered through the browser
+         * This array contains all available providers with their metadata
+         */
         this._providers = [];
+        /**
+         * Set of providers that have been tracked with event listeners
+         * This is separate from _providers because:
+         * - _providers contains all discovered providers (EIP-6963)
+         * - _trackedProviders contains only providers that have been set up with listeners
+         * - A provider can be discovered but not yet tracked (e.g., during initialization)
+         * - 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 = "";
         this.config = {
             writeKey: writeKey,
@@ -89,14 +123,43 @@ var FormoAnalytics = /** @class */ (function () {
             maxQueueSize: options.maxQueueSize,
             flushInterval: options.flushInterval,
         }));
-        // TODO: replace with eip6963
-        var provider = options.provider || (window === null || window === void 0 ? void 0 : window.ethereum);
+        // Handle initial provider (injected) as fallback; listeners for EIP-6963 are added later
+        var provider = undefined;
+        var optProvider = options.provider;
+        if (optProvider) {
+            provider = optProvider;
+        }
+        else if (typeof window !== 'undefined' && window.ethereum) {
+            provider = window.ethereum;
+        }
         if (provider) {
             this.trackProvider(provider);
         }
         this.trackPageHit();
         this.trackPageHits();
     }
+    /**
+     * Helper method to check if a provider is different from the currently active one
+     * @param provider The provider to check
+     * @returns true if there's a provider mismatch, false otherwise
+     */
+    FormoAnalytics.prototype.isProviderMismatch = function (provider) {
+        // Only consider it a mismatch if we have an active provider AND the provider is different
+        // This allows legitimate provider switching while preventing race conditions
+        return this._provider != null && this._provider !== provider;
+    };
+    /**
+     * Check if a provider is in a valid state for switching
+     * @param provider The provider to validate
+     * @returns true if the provider is in a valid state
+     */
+    FormoAnalytics.prototype.isProviderInValidState = function (provider) {
+        // Basic validation: ensure provider exists and has required methods
+        return (provider &&
+            typeof provider.request === 'function' &&
+            typeof provider.on === 'function' &&
+            typeof provider.removeListener === 'function');
+    };
     FormoAnalytics.init = function (writeKey, options) {
         return __awaiter(this, void 0, void 0, function () {
             var analytics, _a;
@@ -114,6 +177,7 @@ var FormoAnalytics = /** @class */ (function () {
                         return [4 /*yield*/, analytics.detectWallets(analytics._providers)];
                     case 2:
                         _b.sent();
+                        analytics.trackProviders(analytics._providers);
                         return [2 /*return*/, analytics];
                 }
             });
@@ -151,6 +215,7 @@ var FormoAnalytics = /** @class */ (function () {
         this.currentUserId = undefined;
         cookie().remove(LOCAL_ANONYMOUS_ID_KEY);
         cookie().remove(SESSION_USER_ID_KEY);
+        cookie().remove(SESSION_WALLET_DETECTED_KEY);
     };
     /**
      * Emits a connect wallet event.
@@ -159,25 +224,30 @@ var FormoAnalytics = /** @class */ (function () {
      * @param {IFormoEventProperties} properties
      * @param {IFormoEventContext} context
      * @param {(...args: unknown[]) => void} callback
-     * @throws {Error} If chainId or address is empty
      * @returns {Promise<void>}
      */
     FormoAnalytics.prototype.connect = function (_a, properties_1, context_1, callback_1) {
         return __awaiter(this, arguments, void 0, function (_b, properties, context, callback) {
-            var validAddress;
+            var checksummedAddress;
             var chainId = _b.chainId, address = _b.address;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        if (!chainId) {
-                            logger.warn("Connect: Chain ID cannot be empty");
+                        if (chainId === null || chainId === undefined) {
+                            logger.warn("Connect: Chain ID cannot be null or undefined");
+                            return [2 /*return*/];
                         }
                         if (!address) {
                             logger.warn("Connect: Address cannot be empty");
+                            return [2 /*return*/];
                         }
                         this.currentChainId = chainId;
-                        validAddress = getValidAddress(address);
-                        this.currentAddress = validAddress ? toChecksumAddress(validAddress) : undefined;
+                        checksummedAddress = this.validateAndChecksumAddress(address);
+                        if (!checksummedAddress) {
+                            logger.warn("Connect: Invalid address provided (\"".concat(address, "\"). Please provide a valid Ethereum address in checksum format."));
+                            return [2 /*return*/];
+                        }
+                        this.currentAddress = checksummedAddress;
                         return [4 /*yield*/, this.trackEvent(EventType.CONNECT, {
                                 chainId: chainId,
                                 address: this.currentAddress,
@@ -200,21 +270,30 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.disconnect = function (params, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var chainId, address;
+            var chainId, address, providerInfo, disconnectProperties;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         chainId = (params === null || params === void 0 ? void 0 : params.chainId) || this.currentChainId;
                         address = (params === null || params === void 0 ? void 0 : params.address) || this.currentAddress;
-                        return [4 /*yield*/, this.trackEvent(EventType.DISCONNECT, {
-                                chainId: chainId,
-                                address: address,
-                            }, properties, context, callback)];
+                        providerInfo = this._provider ? this.getProviderInfo(this._provider) : null;
+                        logger.info("Disconnect: Emitting disconnect event with:", {
+                            chainId: chainId,
+                            address: address,
+                            providerName: providerInfo === null || providerInfo === void 0 ? void 0 : providerInfo.name,
+                            rdns: providerInfo === null || providerInfo === void 0 ? void 0 : providerInfo.rdns
+                        });
+                        disconnectProperties = __assign(__assign({}, (providerInfo && {
+                            providerName: providerInfo.name,
+                            rdns: providerInfo.rdns
+                        })), properties);
+                        return [4 /*yield*/, this.trackEvent(EventType.DISCONNECT, __assign(__assign({}, (chainId && { chainId: chainId })), (address && { address: address })), disconnectProperties, context, callback)];
                     case 1:
                         _a.sent();
                         this.currentAddress = undefined;
                         this.currentChainId = undefined;
-                        logger.info("Wallet disconnected: Cleared currentAddress and currentChainId");
+                        this._provider = undefined;
+                        logger.info("Wallet disconnected: Cleared currentAddress, currentChainId, and provider");
                         return [2 /*return*/];
                 }
             });
@@ -227,8 +306,6 @@ var FormoAnalytics = /** @class */ (function () {
      * @param {IFormoEventProperties} properties
      * @param {IFormoEventContext} context
      * @param {(...args: unknown[]) => void} callback
-     * @throws {Error} If chainId is empty, zero, or not a valid number
-     * @throws {Error} If no address is provided and no previous address is recorded
      * @returns {Promise<void>}
      */
     FormoAnalytics.prototype.chain = function (_a, properties_1, context_1, callback_1) {
@@ -238,13 +315,16 @@ var FormoAnalytics = /** @class */ (function () {
                 switch (_c.label) {
                     case 0:
                         if (!chainId || Number(chainId) === 0) {
-                            throw new Error("FormoAnalytics::chain: chainId cannot be empty or 0");
+                            logger.warn("FormoAnalytics::chain: chainId cannot be empty or 0");
+                            return [2 /*return*/];
                         }
                         if (isNaN(Number(chainId))) {
-                            throw new Error("FormoAnalytics::chain: chainId must be a valid decimal number");
+                            logger.warn("FormoAnalytics::chain: chainId must be a valid decimal number");
+                            return [2 /*return*/];
                         }
                         if (!address && !this.currentAddress) {
-                            throw new Error("FormoAnalytics::chain: address was empty and no previous address has been recorded");
+                            logger.warn("FormoAnalytics::chain: address was empty and no previous address has been recorded");
+                            return [2 /*return*/];
                         }
                         this.currentChainId = chainId;
                         return [4 /*yield*/, this.trackEvent(EventType.CHAIN, {
@@ -324,27 +404,28 @@ 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;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _b.trys.push([0, 11, , 12]);
+                        _c.trys.push([0, 11, , 12]);
                         if (!!params) return [3 /*break*/, 9];
                         // 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;
-                        _b.label = 1;
+                        _c.label = 1;
                     case 1:
                         if (!(_i < _a.length)) return [3 /*break*/, 8];
                         providerDetail = _a[_i];
                         provider = providerDetail.provider;
                         if (!provider)
                             return [3 /*break*/, 7];
-                        _b.label = 2;
+                        _c.label = 2;
                     case 2:
-                        _b.trys.push([2, 6, , 7]);
+                        _c.trys.push([2, 6, , 7]);
                         return [4 /*yield*/, this.getAddress(provider)];
                     case 3:
-                        address_1 = _b.sent();
+                        address_1 = _c.sent();
                         if (!address_1) return [3 /*break*/, 5];
                         logger.info("Auto-identifying", address_1, providerDetail.info.name, providerDetail.info.rdns);
                         // NOTE: do not set this.currentAddress without explicit connect or identify
@@ -355,11 +436,11 @@ var FormoAnalytics = /** @class */ (function () {
                             }, properties, context, callback)];
                     case 4:
                         // NOTE: do not set this.currentAddress without explicit connect or identify
-                        _b.sent();
-                        _b.label = 5;
+                        _c.sent();
+                        _c.label = 5;
                     case 5: return [3 /*break*/, 7];
                     case 6:
-                        err_1 = _b.sent();
+                        err_1 = _c.sent();
                         logger.error("Failed to identify provider ".concat(providerDetail.info.name, ":"), err_1);
                         return [3 /*break*/, 7];
                     case 7:
@@ -369,24 +450,32 @@ var FormoAnalytics = /** @class */ (function () {
                     case 9:
                         userId = params.userId, address = params.address, providerName = params.providerName, rdns = params.rdns;
                         logger.info("Identify", address, userId, providerName, rdns);
-                        validAddress = getValidAddress(address);
-                        if (validAddress)
-                            this.currentAddress = toChecksumAddress(validAddress);
+                        validAddress = undefined;
+                        if (address) {
+                            validAddress = this.validateAndChecksumAddress(address);
+                            this.currentAddress = validAddress || undefined;
+                            if (!validAddress) {
+                                (_b = logger.warn) === null || _b === void 0 ? void 0 : _b.call(logger, "Invalid address provided to identify:", address);
+                            }
+                        }
+                        else {
+                            this.currentAddress = undefined;
+                        }
                         if (userId) {
                             this.currentUserId = userId;
                             cookie().set(SESSION_USER_ID_KEY, userId);
                         }
                         return [4 /*yield*/, this.trackEvent(EventType.IDENTIFY, {
-                                address: validAddress ? toChecksumAddress(validAddress) : undefined,
+                                address: validAddress,
                                 providerName: providerName,
                                 userId: userId,
                                 rdns: rdns,
                             }, properties, context, callback)];
                     case 10:
-                        _b.sent();
+                        _c.sent();
                         return [3 /*break*/, 12];
                     case 11:
-                        e_1 = _b.sent();
+                        e_1 = _c.sent();
                         logger.log("identify error", e_1);
                         return [3 /*break*/, 12];
                     case 12: return [2 /*return*/];
@@ -449,138 +538,314 @@ var FormoAnalytics = /** @class */ (function () {
     FormoAnalytics.prototype.trackProvider = function (provider) {
         logger.info("trackProvider", provider);
         try {
-            if (provider === this._provider) {
+            if (!provider)
+                return;
+            if (this._trackedProviders.has(provider)) {
                 logger.warn("TrackProvider: Provider already tracked.");
                 return;
             }
-            this.currentChainId = undefined;
-            this.currentAddress = undefined;
-            if (this._provider) {
-                var actions = Object.keys(this._providerListeners);
-                for (var _i = 0, actions_1 = actions; _i < actions_1.length; _i++) {
-                    var action = actions_1[_i];
-                    this._provider.removeListener(action, this._providerListeners[action]);
-                    delete this._providerListeners[action];
+            // Register listeners for this provider first
+            this.registerAccountsChangedListener(provider);
+            this.registerChainChangedListener(provider);
+            this.registerConnectListener(provider);
+            this.registerRequestListeners(provider);
+            this.registerDisconnectListener(provider);
+            // Only add to tracked providers after all listeners are successfully registered
+            this._trackedProviders.add(provider);
+        }
+        catch (error) {
+            logger.error("Error tracking provider:", error);
+        }
+    };
+    FormoAnalytics.prototype.trackProviders = function (providers) {
+        try {
+            for (var _i = 0, providers_1 = providers; _i < providers_1.length; _i++) {
+                var eip6963ProviderDetail = providers_1[_i];
+                var provider = eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.provider;
+                if (provider && !this._trackedProviders.has(provider)) {
+                    this.trackProvider(provider);
                 }
             }
-            this._provider = provider;
-            // Register listeners for web3 provider events
-            this.registerAccountsChangedListener();
-            this.registerChainChangedListener();
-            this.registerConnectListener();
-            this.registerRequestListeners();
         }
         catch (error) {
-            logger.error("Error tracking provider:", error);
+            logger.error("Failed to track EIP-6963 providers during initialization:", error);
         }
     };
-    FormoAnalytics.prototype.registerAccountsChangedListener = function () {
+    FormoAnalytics.prototype.addProviderListener = function (provider, event, listener) {
+        var map = this._providerListenersMap.get(provider) || {};
+        map[event] = listener;
+        this._providerListenersMap.set(provider, map);
+    };
+    FormoAnalytics.prototype.registerAccountsChangedListener = function (provider) {
         var _this = this;
-        var _a;
         logger.info("registerAccountsChangedListener");
         var listener = function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return _this.onAccountsChanged(args[0]);
+            return _this.onAccountsChanged(provider, args[0]);
         };
-        (_a = this._provider) === null || _a === void 0 ? void 0 : _a.on("accountsChanged", listener);
-        this._providerListeners["accountsChanged"] = listener;
+        provider.on("accountsChanged", listener);
+        this.addProviderListener(provider, "accountsChanged", listener);
     };
-    FormoAnalytics.prototype.onAccountsChanged = function (accounts) {
+    FormoAnalytics.prototype.onAccountsChanged = function (provider, accounts) {
         return __awaiter(this, void 0, void 0, function () {
-            var validAddress, address, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         logger.info("onAccountsChanged", accounts);
-                        if (!(accounts.length === 0)) return [3 /*break*/, 2];
-                        // Handle wallet disconnect
-                        return [4 /*yield*/, this.disconnect()];
+                        // 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:
-                        // Handle wallet disconnect
-                        _b.sent();
-                        return [2 /*return*/];
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, this._handleAccountsChanged(provider, accounts)];
                     case 2:
-                        validAddress = getValidAddress(accounts[0]);
-                        if (!validAddress) {
+                        _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:", {
+                            currentAddress: this.currentAddress,
+                            currentChainId: this.currentChainId,
+                            providerMatch: this._provider === provider
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _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,
+                                address: this.currentAddress
+                            })];
+                    case 2:
+                        // Pass current state explicitly to ensure we have the data for the disconnect event
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        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");
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                    case 7:
+                        address = this.validateAndChecksumAddress(accounts[0]);
+                        if (!address) {
                             logger.warn("onAccountsChanged: Invalid address received", accounts[0]);
                             return [2 /*return*/];
                         }
-                        address = toChecksumAddress(validAddress);
-                        if (address === this.currentAddress) {
-                            // We have already reported this address
+                        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
+                        });
+                        _a.label = 8;
+                    case 8:
+                        _a.trys.push([8, 16, , 18]);
+                        return [4 /*yield*/, this.getAccounts(this._provider)];
+                    case 9:
+                        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:
+                        // 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:
+                        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._provider = undefined;
+                        _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._provider = undefined;
+                        return [3 /*break*/, 18];
+                    case 18:
+                        // Set provider if none exists (first connection)
+                        if (!this._provider) {
+                            this._provider = provider;
+                        }
+                        // If both the provider and address are the same, no-op
+                        if (this._provider === provider && address === this.currentAddress) {
                             return [2 /*return*/];
                         }
-                        // Handle wallet connect
+                        return [4 /*yield*/, this.getCurrentChainId(provider)];
+                    case 19:
+                        nextChainId = _a.sent();
+                        wasDisconnected = !this.currentAddress;
                         this.currentAddress = address;
-                        _a = this;
-                        return [4 /*yield*/, this.getCurrentChainId()];
-                    case 3:
-                        _a.currentChainId = _b.sent();
-                        this.connect({ chainId: this.currentChainId, address: address });
+                        this.currentChainId = nextChainId;
+                        providerInfo = this.getProviderInfo(provider);
+                        logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
+                            chainId: nextChainId,
+                            address: address,
+                            wasDisconnected: wasDisconnected,
+                            providerName: providerInfo.name,
+                            rdns: providerInfo.rdns,
+                            hasChainId: !!nextChainId
+                        });
+                        effectiveChainId = nextChainId || 0;
+                        if (effectiveChainId === 0) {
+                            logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                        }
+                        this.connect({
+                            chainId: effectiveChainId,
+                            address: address
+                        }, {
+                            providerName: providerInfo.name,
+                            rdns: providerInfo.rdns
+                        }).catch(function (error) {
+                            logger.error("Failed to track connect event during account change:", error);
+                        });
                         return [2 /*return*/];
                 }
             });
         });
     };
-    FormoAnalytics.prototype.registerChainChangedListener = function () {
+    FormoAnalytics.prototype.registerChainChangedListener = function (provider) {
         var _this = this;
-        var _a;
         logger.info("registerChainChangedListener");
         var listener = function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return _this.onChainChanged(args[0]);
+            return _this.onChainChanged(provider, args[0]);
         };
-        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.on("chainChanged", listener);
-        this._providerListeners["chainChanged"] = listener;
+        provider.on("chainChanged", listener);
+        this.addProviderListener(provider, "chainChanged", listener);
     };
-    FormoAnalytics.prototype.onChainChanged = function (chainIdHex) {
+    FormoAnalytics.prototype.onChainChanged = function (provider, chainIdHex) {
         return __awaiter(this, void 0, void 0, function () {
-            var address, validAddress;
+            var nextChainId;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger.info("onChainChanged", chainIdHex);
-                        this.currentChainId = parseChainId(chainIdHex);
-                        if (!!this.currentAddress) return [3 /*break*/, 2];
-                        if (!this.provider) {
-                            logger.info("OnChainChanged: Provider not found. CHAIN_CHANGED not reported");
-                            return [2 /*return*/, Promise.resolve()];
-                        }
-                        return [4 /*yield*/, this.getAddress()];
-                    case 1:
-                        address = _a.sent();
-                        if (!address) {
-                            logger.info("OnChainChanged: Unable to fetch or store connected address");
-                            return [2 /*return*/, Promise.resolve()];
-                        }
-                        validAddress = getValidAddress(address);
-                        this.currentAddress = validAddress ? toChecksumAddress(validAddress) : undefined;
-                        _a.label = 2;
-                    case 2:
-                        // Proceed only if the address exists
-                        if (this.currentAddress) {
-                            return [2 /*return*/, this.chain({
-                                    chainId: this.currentChainId,
-                                    address: this.currentAddress,
-                                })];
-                        }
-                        else {
-                            logger.info("OnChainChanged: Current connected address is null despite fetch attempt");
-                        }
-                        return [2 /*return*/];
+                logger.info("onChainChanged", chainIdHex);
+                nextChainId = parseChainId(chainIdHex);
+                // Only handle chain changes for the active provider (or if none is set yet)
+                if (this.isProviderMismatch(provider)) {
+                    this.handleProviderMismatch(provider);
+                }
+                // Chain changes only matter for connected users
+                if (!this.currentAddress) {
+                    logger.info("OnChainChanged: No current address, user appears disconnected");
+                    return [2 /*return*/, Promise.resolve()];
+                }
+                // Set provider if none exists
+                if (!this._provider) {
+                    this._provider = provider;
+                }
+                this.currentChainId = nextChainId;
+                try {
+                    // This is just a chain change since we already confirmed currentAddress exists
+                    return [2 /*return*/, this.chain({
+                            chainId: this.currentChainId,
+                            address: this.currentAddress,
+                        })];
                 }
+                catch (error) {
+                    logger.error("OnChainChanged: Failed to emit chain event:", error);
+                }
+                return [2 /*return*/];
             });
         });
     };
-    FormoAnalytics.prototype.registerConnectListener = function () {
+    FormoAnalytics.prototype.registerConnectListener = function (provider) {
         var _this = this;
-        var _a;
         logger.info("registerConnectListener");
         var listener = function () {
             var args = [];
@@ -588,14 +853,51 @@ var FormoAnalytics = /** @class */ (function () {
                 args[_i] = arguments[_i];
             }
             var connection = args[0];
-            _this.onConnected(connection);
+            _this.onConnected(provider, connection);
         };
-        (_a = this._provider) === null || _a === void 0 ? void 0 : _a.on("connect", listener);
-        this._providerListeners["connect"] = listener;
+        provider.on("connect", listener);
+        this.addProviderListener(provider, "connect", listener);
+    };
+    FormoAnalytics.prototype.registerDisconnectListener = function (provider) {
+        var _this = this;
+        logger.info("registerDisconnectListener");
+        var listener = function (_error) { return __awaiter(_this, void 0, void 0, function () {
+            var e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._provider !== provider)
+                            return [2 /*return*/];
+                        logger.info("OnDisconnect: Wallet disconnect event received, current state:", {
+                            currentAddress: this.currentAddress,
+                            currentChainId: this.currentChainId
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _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,
+                                address: this.currentAddress
+                            })];
+                    case 2:
+                        // Pass current state explicitly to ensure we have the data for the disconnect event
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_2 = _a.sent();
+                        logger.error("Error during disconnect in disconnect listener", e_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); };
+        provider.on("disconnect", listener);
+        this.addProviderListener(provider, "disconnect", listener);
     };
-    FormoAnalytics.prototype.onConnected = function (connection) {
+    FormoAnalytics.prototype.onConnected = function (provider, connection) {
         return __awaiter(this, void 0, void 0, function () {
-            var chainId, address, e_2;
+            var chainId, address, wasDisconnected, isActiveProvider, providerInfo, effectiveChainId, providerInfo, e_3;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -603,53 +905,105 @@ var FormoAnalytics = /** @class */ (function () {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        if (!connection || typeof connection.chainId !== 'string')
+                        if (!(connection === null || connection === void 0 ? void 0 : connection.chainId) || typeof connection.chainId !== 'string')
                             return [2 /*return*/];
                         chainId = parseChainId(connection.chainId);
-                        return [4 /*yield*/, this.getAddress()];
+                        return [4 /*yield*/, this.getAddress(provider)];
                     case 2:
                         address = _a.sent();
-                        if (chainId !== null && chainId !== undefined && address) {
-                            this.connect({ chainId: chainId, address: address });
+                        if (chainId && address) {
+                            wasDisconnected = !this.currentAddress;
+                            // Set provider if none exists
+                            if (!this._provider) {
+                                this._provider = provider;
+                            }
+                            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,
+                                    isActiveProvider: isActiveProvider
+                                });
+                                effectiveChainId = chainId || 0;
+                                if (effectiveChainId === 0) {
+                                    logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                }
+                                this.connect({
+                                    chainId: effectiveChainId,
+                                    address: address
+                                }, {
+                                    providerName: providerInfo.name,
+                                    rdns: providerInfo.rdns
+                                }).catch(function (error) {
+                                    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:
-                        e_2 = _a.sent();
-                        logger.error("Error handling connect event", e_2);
+                        e_3 = _a.sent();
+                        logger.error("Error handling connect event", e_3);
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
             });
         });
     };
-    FormoAnalytics.prototype.registerRequestListeners = function () {
+    FormoAnalytics.prototype.registerRequestListeners = function (provider) {
         var _this = this;
-        var _a;
         logger.info("registerRequestListeners");
-        if (!this.provider) {
+        if (!provider) {
             logger.error("Provider not found for request (signature, transaction) tracking");
             return;
         }
-        if (((_a = Object.getOwnPropertyDescriptor(this.provider, "request")) === null || _a === void 0 ? void 0 : _a.writable) ===
-            false) {
-            logger.warn("Provider.request is not writable");
+        // Check if the provider is already wrapped with our SDK's wrapper
+        var currentRequest = provider.request;
+        if (this.isProviderAlreadyWrapped(provider, currentRequest)) {
+            logger.info("Provider already wrapped with our SDK; skipping request wrapping.");
             return;
         }
-        var request = this.provider.request.bind(this.provider);
-        this.provider.request = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-            var response_1, error_1, transactionHash_1, error_2;
+        var request = provider.request.bind(provider);
+        var wrappedRequest = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var capturedChainId_1, _c, response_1, error_3, rpcError, transactionHash_1, error_4, rpcError;
             var _this = this;
             var method = _b.method, params = _b.params;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         if (!(Array.isArray(params) &&
-                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 4];
+                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 6];
+                        _c = this.currentChainId;
+                        if (_c) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getCurrentChainId(provider)];
+                    case 1:
+                        _c = (_d.sent());
+                        _d.label = 2;
+                    case 2:
+                        capturedChainId_1 = _c;
                         // Fire-and-forget tracking
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             return __generator(this, function (_a) {
                                 try {
-                                    this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params)));
+                                    this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1)));
                                 }
                                 catch (e) {
                                     logger.error("Formo: Failed to track signature request", e);
@@ -657,127 +1011,139 @@ var FormoAnalytics = /** @class */ (function () {
                                 return [2 /*return*/];
                             });
                         }); })();
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 5, , 6]);
                         return [4 /*yield*/, request({ method: method, params: params })];
-                    case 2:
-                        response_1 = (_c.sent());
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                try {
-                                    if (response_1) {
-                                        this.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1)));
+                    case 4:
+                        response_1 = (_d.sent());
+                        // Track signature confirmation only for truthy responses
+                        if (response_1) {
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    try {
+                                        this.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1)));
                                     }
-                                }
-                                catch (e) {
-                                    logger.error("Formo: Failed to track signature confirmation", e);
-                                }
-                                return [2 /*return*/];
-                            });
-                        }); })();
+                                    catch (e) {
+                                        logger.error("Formo: Failed to track signature confirmation", e);
+                                    }
+                                    return [2 /*return*/];
+                                });
+                            }); })();
+                        }
                         return [2 /*return*/, response_1];
-                    case 3:
-                        error_1 = _c.sent();
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var rpcError;
-                            return __generator(this, function (_a) {
-                                try {
-                                    rpcError = error_1;
-                                    if (rpcError && (rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
-                                        this.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params)));
+                    case 5:
+                        error_3 = _d.sent();
+                        rpcError = error_3;
+                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Use the already cast rpcError to avoid duplication
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    try {
+                                        this.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1)));
                                     }
-                                }
-                                catch (e) {
-                                    logger.error("Formo: Failed to track signature rejection", e);
-                                }
-                                return [2 /*return*/];
-                            });
-                        }); })();
-                        throw error_1;
-                    case 4:
+                                    catch (e) {
+                                        logger.error("Formo: Failed to track signature rejection", e);
+                                    }
+                                    return [2 /*return*/];
+                                });
+                            }); })();
+                        }
+                        throw error_3;
+                    case 6:
                         if (!(Array.isArray(params) &&
                             method === "eth_sendTransaction" &&
-                            params[0])) return [3 /*break*/, 8];
+                            params[0])) return [3 /*break*/, 10];
                         (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_3;
+                            var payload, e_4;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params)];
+                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
                                     case 1:
                                         payload = _a.sent();
                                         this.transaction(__assign({ status: TransactionStatus.STARTED }, payload));
                                         return [3 /*break*/, 3];
                                     case 2:
-                                        e_3 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction start", e_3);
+                                        e_4 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction start", e_4);
                                         return [3 /*break*/, 3];
                                     case 3: return [2 /*return*/];
                                 }
                             });
                         }); })();
-                        _c.label = 5;
-                    case 5:
-                        _c.trys.push([5, 7, , 8]);
+                        _d.label = 7;
+                    case 7:
+                        _d.trys.push([7, 9, , 10]);
                         return [4 /*yield*/, request({
                                 method: method,
                                 params: params,
                             })];
-                    case 6:
-                        transactionHash_1 = (_c.sent());
+                    case 8:
+                        transactionHash_1 = (_d.sent());
                         (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_4;
+                            var payload, e_5;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params)];
+                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
                                     case 1:
                                         payload = _a.sent();
                                         this.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }));
                                         // Start async polling for transaction receipt
-                                        this.pollTransactionReceipt(transactionHash_1, payload);
+                                        this.pollTransactionReceipt(provider, transactionHash_1, payload);
                                         return [3 /*break*/, 3];
                                     case 2:
-                                        e_4 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction broadcast", e_4);
+                                        e_5 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction broadcast", e_5);
                                         return [3 /*break*/, 3];
                                     case 3: return [2 /*return*/];
                                 }
                             });
                         }); })();
                         return [2 /*return*/, transactionHash_1];
-                    case 7:
-                        error_2 = _c.sent();
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var rpcError, payload, e_5;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 3, , 4]);
-                                        rpcError = error_2;
-                                        if (!(rpcError && (rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001)) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params)];
-                                    case 1:
-                                        payload = _a.sent();
-                                        this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload));
-                                        _a.label = 2;
-                                    case 2: return [3 /*break*/, 4];
-                                    case 3:
-                                        e_5 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction rejection", e_5);
-                                        return [3 /*break*/, 4];
-                                    case 4: return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                        throw error_2;
-                    case 8: return [2 /*return*/, request({ method: method, params: params })];
+                    case 9:
+                        error_4 = _d.sent();
+                        rpcError = error_4;
+                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
+                            // Use the already cast rpcError to avoid duplication
+                            (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var payload, e_6;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
+                                        case 1:
+                                            payload = _a.sent();
+                                            this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload));
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_6 = _a.sent();
+                                            logger.error("Formo: Failed to track transaction rejection", e_6);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                        }
+                        throw error_4;
+                    case 10: return [2 /*return*/, request({ method: method, params: params })];
                 }
             });
         }); };
+        // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
+        wrappedRequest[WRAPPED_REQUEST_SYMBOL] = true;
+        provider[WRAPPED_REQUEST_REF_SYMBOL] = wrappedRequest;
+        try {
+            // Attempt to assign the wrapped request function (rely on try-catch for mutability errors)
+            provider.request = wrappedRequest;
+        }
+        catch (e) {
+            logger.warn("Failed to wrap provider.request; skipping", e);
+        }
     };
     FormoAnalytics.prototype.onLocationChange = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -831,15 +1197,29 @@ var FormoAnalytics = /** @class */ (function () {
                     logger.info("Track page hit: Skipping event due to tracking configuration");
                     return [2 /*return*/];
                 }
-                setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        this.trackEvent(EventType.PAGE, {
-                            category: category,
-                            name: name,
-                        }, properties, context, callback);
-                        return [2 /*return*/];
-                    });
-                }); }, 300);
+                setTimeout(function () {
+                    (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var e_7;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, this.trackEvent(EventType.PAGE, {
+                                            category: category,
+                                            name: name,
+                                        }, properties, context, callback)];
+                                case 1:
+                                    _a.sent();
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    e_7 = _a.sent();
+                                    logger.error("Formo: Failed to track page hit", e_7);
+                                    return [3 /*break*/, 3];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); })();
+                }, 300);
                 return [2 /*return*/];
             });
         });
@@ -904,24 +1284,167 @@ var FormoAnalytics = /** @class */ (function () {
     /*
       Utility functions
     */
+    /**
+     * Get provider information for a given provider
+     * @param provider The provider to get info for
+     * @returns Provider information
+     */
+    FormoAnalytics.prototype.getProviderInfo = function (provider) {
+        // First check if provider is in our EIP-6963 providers list
+        var eip6963Provider = this._providers.find(function (p) { return p.provider === provider; });
+        if (eip6963Provider) {
+            return {
+                name: eip6963Provider.info.name,
+                rdns: eip6963Provider.info.rdns
+            };
+        }
+        // Fallback to injected provider detection
+        var injectedInfo = this.detectInjectedProviderInfo(provider);
+        return {
+            name: injectedInfo.name,
+            rdns: injectedInfo.rdns
+        };
+    };
+    /**
+     * Attempts to detect information about an injected provider
+     * @param provider The injected provider to analyze
+     * @returns Provider information with fallback values
+     */
+    FormoAnalytics.prototype.detectInjectedProviderInfo = function (provider) {
+        // Try to detect provider type from common properties
+        var name = 'Injected Provider';
+        var rdns = 'io.injected.provider';
+        // Use WalletProviderFlags interface for type safety
+        var flags = provider;
+        // Check if it's MetaMask
+        if (flags.isMetaMask) {
+            name = 'MetaMask';
+            rdns = 'io.metamask';
+        }
+        // Check if it's Coinbase Wallet
+        else if (flags.isCoinbaseWallet) {
+            name = 'Coinbase Wallet';
+            rdns = 'com.coinbase.wallet';
+        }
+        // Check if it's WalletConnect
+        else if (flags.isWalletConnect) {
+            name = 'WalletConnect';
+            rdns = 'com.walletconnect';
+        }
+        // Check if it's Trust Wallet
+        else if (flags.isTrust) {
+            name = 'Trust Wallet';
+            rdns = 'com.trustwallet';
+        }
+        // Check if it's Brave Wallet
+        else if (flags.isBraveWallet) {
+            name = 'Brave Wallet';
+            rdns = 'com.brave.wallet';
+        }
+        // Check if it's Phantom
+        else if (flags.isPhantom) {
+            name = 'Phantom';
+            rdns = 'app.phantom';
+        }
+        return {
+            name: name,
+            rdns: rdns,
+            uuid: "injected-".concat(rdns.replace(/[^a-zA-Z0-9]/g, '-')),
+            icon: DEFAULT_PROVIDER_ICON
+        };
+    };
     FormoAnalytics.prototype.getProviders = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var store, providers;
+            var store, providers, injected_1, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
             var _this = this;
             return __generator(this, function (_a) {
                 store = createStore();
                 providers = store.getProviders();
                 store.subscribe(function (providerDetails) {
                     providers = providerDetails;
-                    _this._providers = providers;
+                    // Process newly added providers with proper deduplication
+                    var newlyAddedDetails = providerDetails.filter(function (detail) {
+                        var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
+                        return provider && !_this._seenProviders.has(provider);
+                    });
+                    // Add new providers to the array without overwriting existing ones
+                    for (var _i = 0, newlyAddedDetails_1 = newlyAddedDetails; _i < newlyAddedDetails_1.length; _i++) {
+                        var detail = newlyAddedDetails_1[_i];
+                        _this.safeAddProviderDetail(detail);
+                    }
+                    // Track listeners for newly discovered providers only
+                    var newDetails = providerDetails.filter(function (detail) {
+                        var p = detail === null || detail === void 0 ? void 0 : detail.provider;
+                        return !!p && !_this._trackedProviders.has(p);
+                    });
+                    if (newDetails.length > 0) {
+                        _this.trackProviders(newDetails);
+                        // Detect newly discovered wallets (session de-dupes) with error handling
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var e_8;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, this.detectWallets(newDetails)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        e_8 = _a.sent();
+                                        logger.error("Formo: Failed to detect wallets", e_8);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                    }
+                    // Clean up providers that are no longer available
+                    _this.cleanupUnavailableProviders();
                 });
                 // Fallback to injected provider if no providers are found
                 if (providers.length === 0) {
-                    this._providers = (window === null || window === void 0 ? void 0 : window.ethereum) ? [window.ethereum] : [];
+                    injected_1 = typeof window !== 'undefined' ? window.ethereum : undefined;
+                    if (injected_1) {
+                        // If we have already detected and cached the injected provider, and it's the same instance, return the cached result
+                        if (this._injectedProviderDetail &&
+                            this._injectedProviderDetail.provider === injected_1) {
+                            // Ensure it's tracked
+                            if (!this._trackedProviders.has(injected_1)) {
+                                this.trackProvider(injected_1);
+                            }
+                            // Merge with existing providers instead of overwriting
+                            if (!this._providers.some(function (existing) { return existing.provider === injected_1; })) {
+                                this._providers = __spreadArray(__spreadArray([], this._providers, true), [this._injectedProviderDetail], false);
+                            }
+                            return [2 /*return*/, this._providers];
+                        }
+                        // Re-check if the injected provider is already tracked just before tracking
+                        if (!this._trackedProviders.has(injected_1)) {
+                            this.trackProvider(injected_1);
+                        }
+                        injectedProviderInfo = this.detectInjectedProviderInfo(injected_1);
+                        injectedDetail = {
+                            provider: injected_1,
+                            info: injectedProviderInfo
+                        };
+                        // Cache the detected injected provider detail
+                        this._injectedProviderDetail = injectedDetail;
+                        // Merge with existing providers instead of overwriting
+                        this.safeAddProviderDetail(injectedDetail);
+                    }
                     return [2 /*return*/, this._providers];
                 }
-                this._providers = providers;
-                return [2 /*return*/, providers];
+                uniqueProviders = providers.filter(function (detail) {
+                    var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
+                    return provider && !_this._seenProviders.has(provider);
+                });
+                // Add to seen providers and instances, ensuring no duplicates in _providers
+                for (_i = 0, uniqueProviders_1 = uniqueProviders; _i < uniqueProviders_1.length; _i++) {
+                    detail = uniqueProviders_1[_i];
+                    this.safeAddProviderDetail(detail);
+                }
+                return [2 /*return*/, this._providers];
             });
         });
     };
@@ -934,16 +1457,16 @@ var FormoAnalytics = /** @class */ (function () {
     });
     FormoAnalytics.prototype.detectWallets = function (providers) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, providers_1, eip6963ProviderDetail, err_2;
+            var _i, providers_2, eip6963ProviderDetail, err_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 5, , 6]);
-                        _i = 0, providers_1 = providers;
+                        _i = 0, providers_2 = providers;
                         _a.label = 1;
                     case 1:
-                        if (!(_i < providers_1.length)) return [3 /*break*/, 4];
-                        eip6963ProviderDetail = providers_1[_i];
+                        if (!(_i < providers_2.length)) return [3 /*break*/, 4];
+                        eip6963ProviderDetail = providers_2[_i];
                         return [4 /*yield*/, this.detect({
                                 providerName: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.name,
                                 rdns: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.rdns,
@@ -973,7 +1496,7 @@ var FormoAnalytics = /** @class */ (function () {
     });
     FormoAnalytics.prototype.getAddress = function (provider) {
         return __awaiter(this, void 0, void 0, function () {
-            var p, accounts, validAddress, err_3;
+            var p, accounts, err_3, code;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -991,15 +1514,15 @@ var FormoAnalytics = /** @class */ (function () {
                     case 2:
                         accounts = _a.sent();
                         if (accounts && accounts.length > 0) {
-                            validAddress = getValidAddress(accounts[0]);
-                            if (validAddress) {
-                                return [2 /*return*/, toChecksumAddress(validAddress)];
-                            }
+                            return [2 /*return*/, this.validateAndChecksumAddress(accounts[0]) || null];
                         }
                         return [3 /*break*/, 4];
                     case 3:
                         err_3 = _a.sent();
-                        logger.error("Failed to fetch accounts from provider:", err_3);
+                        code = err_3 === null || err_3 === void 0 ? void 0 : err_3.code;
+                        if (code !== 4001) {
+                            logger.error("FormoAnalytics::getAccounts: eth_accounts threw an error", err_3);
+                        }
                         return [2 /*return*/, null];
                     case 4: return [2 /*return*/, null];
                 }
@@ -1008,7 +1531,8 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.getAccounts = function (provider) {
         return __awaiter(this, void 0, void 0, function () {
-            var p, res, err_4;
+            var p, res, err_4, code;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1024,12 +1548,12 @@ var FormoAnalytics = /** @class */ (function () {
                         if (!res || res.length === 0)
                             return [2 /*return*/, null];
                         return [2 /*return*/, res
-                                .map(function (e) { return getValidAddress(e); })
-                                .filter(function (e) { return e !== null; })
-                                .map(toChecksumAddress)];
+                                .map(function (e) { return _this.validateAndChecksumAddress(e); })
+                                .filter(function (e) { return e !== undefined; })];
                     case 3:
                         err_4 = _a.sent();
-                        if (err_4.code !== 4001) {
+                        code = err_4 === null || err_4 === void 0 ? void 0 : err_4.code;
+                        if (code !== 4001) {
                             logger.error("FormoAnalytics::getAccounts: eth_accounts threw an error", err_4);
                         }
                         return [2 /*return*/, null];
@@ -1038,31 +1562,32 @@ var FormoAnalytics = /** @class */ (function () {
             });
         });
     };
-    FormoAnalytics.prototype.getCurrentChainId = function () {
+    FormoAnalytics.prototype.getCurrentChainId = function (provider) {
         return __awaiter(this, void 0, void 0, function () {
-            var chainIdHex, err_5;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var p, chainIdHex, err_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        if (!this.provider) {
+                        p = provider || this.provider;
+                        if (!p) {
                             logger.error("Provider not set for chain ID");
+                            return [2 /*return*/, 0];
                         }
-                        _b.label = 1;
+                        _a.label = 1;
                     case 1:
-                        _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, ((_a = this.provider) === null || _a === void 0 ? void 0 : _a.request({
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, p.request({
                                 method: "eth_chainId",
-                            }))];
+                            })];
                     case 2:
-                        chainIdHex = _b.sent();
+                        chainIdHex = _a.sent();
                         if (!chainIdHex) {
                             logger.info("Chain id not found");
                             return [2 /*return*/, 0];
                         }
                         return [2 /*return*/, parseChainId(chainIdHex)];
                     case 3:
-                        err_5 = _b.sent();
+                        err_5 = _a.sent();
                         logger.error("eth_chainId threw an error:", err_5);
                         return [2 /*return*/, 0];
                     case 4: return [2 /*return*/];
@@ -1070,17 +1595,18 @@ var FormoAnalytics = /** @class */ (function () {
             });
         });
     };
-    FormoAnalytics.prototype.buildSignatureEventPayload = function (method, params, response) {
+    FormoAnalytics.prototype.buildSignatureEventPayload = function (method, params, response, chainId) {
+        var _a;
         var rawAddress = method === "personal_sign"
             ? params[1]
             : params[0];
-        var validAddress = getValidAddress(rawAddress);
+        var validAddress = this.validateAndChecksumAddress(rawAddress);
         if (!validAddress) {
             throw new Error("Invalid address in signature payload: ".concat(rawAddress));
         }
         var basePayload = {
-            chainId: this.currentChainId,
-            address: toChecksumAddress(validAddress),
+            chainId: (_a = chainId !== null && chainId !== void 0 ? chainId : this.currentChainId) !== null && _a !== void 0 ? _a : undefined,
+            address: validAddress,
         };
         if (method === "personal_sign") {
             var message = Buffer.from(params[0].slice(2), "hex").toString("utf8");
@@ -1088,7 +1614,7 @@ var FormoAnalytics = /** @class */ (function () {
         }
         return __assign(__assign(__assign({}, basePayload), { message: params[1] }), (response ? { signatureHash: response } : {}));
     };
-    FormoAnalytics.prototype.buildTransactionEventPayload = function (params) {
+    FormoAnalytics.prototype.buildTransactionEventPayload = function (params, provider) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, data, from, to, value, validAddress, _b;
             var _c;
@@ -1096,20 +1622,20 @@ var FormoAnalytics = /** @class */ (function () {
                 switch (_d.label) {
                     case 0:
                         _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
-                        validAddress = getValidAddress(from);
+                        validAddress = this.validateAndChecksumAddress(from);
                         if (!validAddress) {
                             throw new Error("Invalid address in transaction payload: ".concat(from));
                         }
                         _c = {};
                         _b = this.currentChainId;
                         if (_b) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getCurrentChainId()];
+                        return [4 /*yield*/, this.getCurrentChainId(provider)];
                     case 1:
                         _b = (_d.sent());
                         _d.label = 2;
                     case 2: return [2 /*return*/, (_c.chainId = _b,
                             _c.data = data,
-                            _c.address = toChecksumAddress(validAddress),
+                            _c.address = validAddress,
                             _c.to = to,
                             _c.value = value,
                             _c)];
@@ -1120,19 +1646,18 @@ var FormoAnalytics = /** @class */ (function () {
     /**
      * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
      */
-    FormoAnalytics.prototype.pollTransactionReceipt = function (transactionHash_2, payload_1) {
-        return __awaiter(this, arguments, void 0, function (transactionHash, payload, maxAttempts, intervalMs) {
-            var attempts, provider, poll;
+    FormoAnalytics.prototype.pollTransactionReceipt = function (provider_1, transactionHash_2, payload_1) {
+        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, maxAttempts, intervalMs) {
+            var attempts, poll;
             var _this = this;
             if (maxAttempts === void 0) { maxAttempts = 10; }
             if (intervalMs === void 0) { intervalMs = 3000; }
             return __generator(this, function (_a) {
                 attempts = 0;
-                provider = this.provider;
                 if (!provider)
                     return [2 /*return*/];
                 poll = function () { return __awaiter(_this, void 0, void 0, function () {
-                    var receipt, e_6;
+                    var receipt, e_9;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
@@ -1156,8 +1681,8 @@ var FormoAnalytics = /** @class */ (function () {
                                 }
                                 return [3 /*break*/, 3];
                             case 2:
-                                e_6 = _a.sent();
-                                logger.error("Error polling transaction receipt", e_6);
+                                e_9 = _a.sent();
+                                logger.error("Error polling transaction receipt", e_9);
                                 return [3 /*break*/, 3];
                             case 3:
                                 attempts++;
@@ -1173,6 +1698,122 @@ var FormoAnalytics = /** @class */ (function () {
             });
         });
     };
+    FormoAnalytics.prototype.removeProviderListeners = function (provider) {
+        var listeners = this._providerListenersMap.get(provider);
+        if (!listeners)
+            return;
+        for (var _i = 0, _a = Object.entries(listeners); _i < _a.length; _i++) {
+            var _b = _a[_i], event_1 = _b[0], fn = _b[1];
+            try {
+                provider.removeListener(event_1, fn);
+            }
+            catch (e) {
+                logger.warn("Failed to remove listener for ".concat(String(event_1)), e);
+            }
+        }
+        this._providerListenersMap.delete(provider);
+    };
+    // Explicitly untrack a provider: remove listeners, clear wrapper flag and tracking
+    FormoAnalytics.prototype.untrackProvider = function (provider) {
+        try {
+            this.removeProviderListeners(provider);
+            this._trackedProviders.delete(provider);
+            if (this._provider === provider) {
+                this._provider = undefined;
+            }
+        }
+        catch (e) {
+            logger.warn("Failed to untrack provider", e);
+        }
+    };
+    // Debug/monitoring helpers
+    FormoAnalytics.prototype.getTrackedProvidersCount = function () {
+        return this._trackedProviders.size;
+    };
+    /**
+     * Get current provider state for debugging
+     * @returns Object containing current provider state information
+     */
+    FormoAnalytics.prototype.getProviderState = function () {
+        return {
+            totalProviders: this._providers.length,
+            trackedProviders: this._trackedProviders.size,
+            seenProviders: this._seenProviders.size,
+            activeProvider: !!this._provider,
+        };
+    };
+    /**
+     * Clean up providers that are no longer available
+     * This helps maintain consistent state and prevents memory leaks
+     */
+    FormoAnalytics.prototype.cleanupUnavailableProviders = function () {
+        // Remove providers that are no longer in the current providers list
+        var currentProviderInstances = new Set(this._providers.map(function (detail) { return detail.provider; }));
+        for (var _i = 0, _a = Array.from(this._trackedProviders); _i < _a.length; _i++) {
+            var provider = _a[_i];
+            if (!currentProviderInstances.has(provider)) {
+                logger.info("Cleaning up unavailable provider: ".concat(provider.constructor.name));
+                this.untrackProvider(provider);
+            }
+        }
+    };
+    /**
+     * Helper method to check if a provider is already wrapped
+     * @param provider The provider to check
+     * @param currentRequest The current request function
+     * @returns true if the provider is already wrapped
+     */
+    FormoAnalytics.prototype.isProviderAlreadyWrapped = function (provider, currentRequest) {
+        return !!(currentRequest &&
+            typeof currentRequest === 'function' &&
+            currentRequest[WRAPPED_REQUEST_SYMBOL] &&
+            provider[WRAPPED_REQUEST_REF_SYMBOL] === currentRequest);
+    };
+    /**
+     * Handle provider mismatch by switching to the new provider and invalidating old tokens
+     * @param provider The new provider to switch to
+     */
+    FormoAnalytics.prototype.handleProviderMismatch = function (provider) {
+        // If this is a different provider, allow the switch
+        if (this._provider) {
+            // Clear any provider-specific state when switching
+            this.currentChainId = undefined;
+            this.currentAddress = undefined;
+        }
+        this._provider = provider;
+    };
+    /**
+     * Helper method to validate and checksum an address
+     * @param address The address to validate and checksum
+     * @returns The checksummed address or undefined if invalid
+     */
+    FormoAnalytics.prototype.validateAndChecksumAddress = function (address) {
+        var validAddress = getValidAddress(address);
+        return validAddress ? toChecksumAddress(validAddress) : undefined;
+    };
+    /**
+     * Helper method to safely add a provider detail to _providers array, ensuring no duplicates
+     * @param detail The provider detail to add
+     * @returns true if the provider was added, false if it was already present
+     */
+    FormoAnalytics.prototype.safeAddProviderDetail = function (detail) {
+        var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
+        if (!provider)
+            return false;
+        // Check if provider already exists in _providers array
+        var alreadyExists = this._providers.some(function (existing) { return existing.provider === provider; });
+        if (!alreadyExists) {
+            // Add to providers array and mark as seen
+            this._providers = __spreadArray(__spreadArray([], this._providers, true), [detail], false);
+            this._seenProviders.add(provider);
+            return true;
+        }
+        else {
+            // Ensure provider is marked as seen even if it already exists in _providers
+            this._seenProviders.add(provider);
+            return false;
+        }
+    };
     return FormoAnalytics;
 }());
 export { FormoAnalytics };