@formo/analytics 1.35.1 → 1.35.2

package/dist/esm/src/FormoAnalytics.js

@@ -94,6 +94,39 @@ var FormoAnalytics = /** @class */ (function () {
             evm: {},
             solana: {},
         };
+        /**
+         * Last known chain per tracked provider, fed by `chainChanged` / `connect`
+         * and by a one-off probe at tracking time. Read synchronously when labelling
+         * an autocaptured event, so the wallet's request transport is never used for
+         * analytics. Weak so an untracked provider can be collected.
+         */
+        /**
+         * The connect this SDK has actually REPORTED for a provider.
+         *
+         * Deduplicating on "is an address known" was wrong in both directions.
+         * `onConnected` and `onAccountsChanged` both observe one connection, so
+         * something has to stop them double-reporting - but an address can be
+         * present without a connect ever having been sent: restored from the
+         * active-wallet cookie, or reported with an unresolved chain and then
+         * refused by `tracking.excludeChains`. Suppressing on address presence lost
+         * the connect entirely in those cases.
+         *
+         * Records what was reported, so a later event can be recognised as a
+         * genuine improvement on it rather than a duplicate.
+         */
+        this._announcedConnect = new WeakMap();
+        this._providerChainIds = new WeakMap();
+        /**
+         * Bumped on every chain observation, PER PROVIDER. An `eth_chainId` answer
+         * that resolves after a newer observation for the same provider must not
+         * overwrite it.
+         *
+         * Deliberately per provider, not per SDK instance: a global counter meant
+         * any activity on wallet B discarded a perfectly valid in-flight answer for
+         * wallet A, leaving A at chain 0 - and, since an unresolved chain fails
+         * closed, dropping all of A's events whenever `excludeChains` is set.
+         */
+        this._providerChainGenerations = new WeakMap();
         this._providerListenersMap = new Map();
         /**
          * EIP-6963 provider details discovered through the browser
@@ -222,11 +255,37 @@ var FormoAnalytics = /** @class */ (function () {
             return this._chainState.evm.provider;
         },
         set: function (value) {
+            var previous = this._chainState.evm.provider;
+            // A provider that stops being the active one has, from this SDK's point of
+            // view, ended its connection - so the connect it reported must stop
+            // counting. Otherwise toggling between two installed wallets silently
+            // loses every connect after the first: A's stale record suppresses the
+            // connect when the user comes back to it.
+            //
+            // Done in the setter rather than at each switch site because the active
+            // provider is reassigned from several paths - `accountsChanged`,
+            // `chainChanged`, `connect`, `handleProviderMismatch`, `untrackProvider` -
+            // and any one of them missed would reopen the same hole.
+            this.forgetConnectRecord(previous, value);
             this._chainState.evm.provider = value;
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Drop a provider's reported-connect record when it stops being active.
+     *
+     * The active provider is displaced from several places, and not all of them
+     * go through the `_provider` setter: `setChainState()` writes
+     * `_chainState.evm.provider` directly and `clearChainState()` replaces the
+     * whole namespace. Guarding only the setter left A's record alive across a
+     * real A-to-B switch, so returning to A was suppressed.
+     */
+    FormoAnalytics.prototype.forgetConnectRecord = function (previous, next) {
+        if (previous && previous !== next) {
+            this._announcedConnect.delete(previous);
+        }
+    };
     Object.defineProperty(FormoAnalytics.prototype, "_evmAddress", {
         get: function () {
             return this._chainState.evm.address;
@@ -843,6 +902,18 @@ var FormoAnalytics = /** @class */ (function () {
      * Opt out of tracking.
      * @returns {void}
      */
+    /**
+     * Whether an event carrying this chain would currently be sent.
+     *
+     * Exposed for integrations that keep their own "already reported" state.
+     * `syncWalletState()` can accept a wallet that `trackEvent()` then drops -
+     * `tracking: false`, or a chain in `excludeChains` - and an integration that
+     * marked it as reported would stay silent about that wallet even after the
+     * configuration changed to allow it.
+     */
+    FormoAnalytics.prototype.willTrackEvent = function (chainId) {
+        return this.shouldTrack(chainId);
+    };
     FormoAnalytics.prototype.optOutTracking = function () {
         logger.info("Opting out of tracking");
         // Set opt-out flag in persistent storage using direct cookie access
@@ -860,9 +931,15 @@ var FormoAnalytics = /** @class */ (function () {
      * @returns {void}
      */
     FormoAnalytics.prototype.optInTracking = function () {
+        var _a;
         logger.info("Opting back into tracking");
         // Remove opt-out flag
         removeConsentFlag(this.writeKey, CONSENT_OPT_OUT_KEY);
+        // A wallet connected while opted out was declined by syncWalletState, and
+        // an unchanged wagmi connection produces no status or chain update to
+        // retry on. Without this, opting back in leaves that wallet invisible for
+        // the rest of the page load.
+        (_a = this.wagmiHandler) === null || _a === void 0 ? void 0 : _a.retryAdoption();
         logger.info("Successfully opted back into tracking");
     };
     /**
@@ -904,20 +981,43 @@ var FormoAnalytics = /** @class */ (function () {
             // This ensures currentAddress, currentChainId, and _provider are always up-to-date
             // Event emission is controlled conditionally inside the handlers
             this.registerAccountsChangedListener(provider);
-            // Register other listeners based on autocapture configuration
-            if (this.isAutocaptureEnabled("chain")) {
-                this.registerChainChangedListener(provider);
-            }
+            // `chainChanged` and `connect` are registered UNCONDITIONALLY: they are
+            // how this provider's chain is observed, and every signature and
+            // transaction has to be labelled with it. Gating registration on
+            // `autocapture.chain` conflated observing a chain with reporting one, so
+            // `{ chain: false, signature: true }` left the chain frozen at whatever
+            // was first seen - a switch to an excluded chain went unnoticed and its
+            // signatures were emitted under the old, allowed chain. Whether an
+            // event is emitted is decided inside each handler.
+            this.registerChainChangedListener(provider);
             if (this.isAutocaptureEnabled("connect")) {
                 this.registerConnectListener(provider);
             }
+            else {
+                // Observation only. The full connect handler calls `getAddress()`,
+                // which issues `eth_accounts`, and nothing analytics-only may go on
+                // the wallet's transport - a stalled request there sits in front of
+                // the next signature the dapp makes. The chain rides along on the
+                // event itself, so it costs nothing to record.
+                this.registerConnectChainObserver(provider);
+            }
+            // Seed the chain from the provider's own synchronous state if it exposes
+            // one. Deliberately a property read and never an RPC: see
+            // resolveChainIdForProvider for why nothing analytics-only may go on the
+            // wallet's transport.
+            this.seedProviderChainFromState(provider);
             if (this.isAutocaptureEnabled("signature") || this.isAutocaptureEnabled("transaction")) {
                 this.registerRequestListeners(provider);
             }
             else {
                 logger.debug("TrackProvider: Skipping request wrapping (both signature and transaction autocapture disabled)");
             }
-            if (this.isAutocaptureEnabled("disconnect")) {
+            // Registered UNCONDITIONALLY: this listener also ends the provider's
+            // reported-connect record, and with `{ connect: true, disconnect: false }`
+            // a wallet that disconnected and reconnected would otherwise find its
+            // old record still standing and have the new connect suppressed. Whether
+            // a disconnect EVENT is emitted is decided inside the handler.
+            {
                 this.registerDisconnectListener(provider);
             }
             // Only add to tracked providers after all listeners are successfully registered
@@ -1011,6 +1111,10 @@ var FormoAnalytics = /** @class */ (function () {
                             evmChainId: this._evmChainId,
                             providerMatch: this._provider === provider,
                         });
+                        // The reported connect ends with the connection, so a genuine
+                        // reconnect later reports again rather than being taken for a
+                        // duplicate.
+                        this._announcedConnect.delete(provider);
                         if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
                         _a.label = 1;
                     case 1:
@@ -1159,9 +1263,7 @@ var FormoAnalytics = /** @class */ (function () {
                         if (this._provider === provider && address === this._evmAddress) {
                             return [2 /*return*/];
                         }
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 26:
-                        nextChainId = _a.sent();
+                        nextChainId = this.resolveChainIdForProvider(provider);
                         wasDisconnected = !this._evmAddress;
                         // Update state regardless of whether connect *event* tracking is enabled,
                         // so disconnect events keep valid address/chainId values. (excludeChains is
@@ -1175,7 +1277,8 @@ var FormoAnalytics = /** @class */ (function () {
                         }
                         providerInfo = this.getProviderInfo(provider);
                         effectiveChainId = nextChainId || 0;
-                        if (this.isAutocaptureEnabled("connect")) {
+                        if (this.isAutocaptureEnabled("connect") &&
+                            this.shouldReportConnect(provider, address)) {
                             logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
                                 chainId: nextChainId,
                                 address: address,
@@ -1187,6 +1290,7 @@ var FormoAnalytics = /** @class */ (function () {
                             if (effectiveChainId === 0) {
                                 logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
                             }
+                            this.markConnectReported(provider, address, effectiveChainId);
                             this.connect({
                                 chainId: effectiveChainId,
                                 address: address,
@@ -1224,46 +1328,140 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.onChainChanged = function (provider, chainIdHex) {
         return __awaiter(this, void 0, void 0, function () {
-            var nextChainId;
+            var nextChainId, error_3;
             return __generator(this, function (_a) {
-                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._evmAddress) {
-                    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.setChainState('evm', { chainId: nextChainId });
-                try {
-                    // This is just a chain change since we already confirmed _evmAddress exists
-                    if (this.isAutocaptureEnabled("chain")) {
-                        return [2 /*return*/, this.chain({
+                switch (_a.label) {
+                    case 0:
+                        logger.info("onChainChanged", chainIdHex);
+                        nextChainId = parseChainId(chainIdHex);
+                        // Record it for THIS provider regardless of which one is active. This is
+                        // the only way an autocaptured event from a non-active wallet can learn
+                        // its chain without putting an RPC on that wallet's transport.
+                        this.rememberProviderChain(provider, nextChainId);
+                        // Beyond that, a chain event from a NON-active provider is observation
+                        // only when chain autocapture is off.
+                        //
+                        // This listener is now registered unconditionally, so that a signature can
+                        // be labelled with its signer's chain. `handleProviderMismatch()` treats a
+                        // chain event from another wallet as a wallet switch and clears the active
+                        // wallet's address and chain. That is the established behaviour of the
+                        // chain feature and stays exactly as it was, but it must not start firing
+                        // for apps that never asked for chain tracking: a second wallet switching
+                        // network would silently erase the active wallet's attribution.
+                        // Observation only when chain autocapture is off, whether or not an
+                        // active provider has been established yet.
+                        //
+                        // `isProviderMismatch()` is false while `_provider` is undefined, which is
+                        // exactly the state left by restoring a wallet from the active-wallet
+                        // cookie. A background wallet's `chainChanged` could therefore claim the
+                        // active slot and overwrite the restored wallet's chain - suppressing
+                        // allowed events, or letting excluded ones through. The active provider is
+                        // established by an actual account/connect/request association, not by
+                        // another wallet changing network.
+                        if (!this.isAutocaptureEnabled("chain") && provider !== this._provider) {
+                            return [2 /*return*/];
+                        }
+                        // 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._evmAddress) {
+                            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.setChainState('evm', { chainId: nextChainId });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        if (!this.isAutocaptureEnabled("chain")) return [3 /*break*/, 3];
+                        // Awaited, so a failing emission is caught below rather than escaping
+                        // as an unhandled rejection out of the provider's event listener.
+                        // `return`ing the promise left the catch here unreachable.
+                        return [4 /*yield*/, this.chain({
                                 chainId: nextChainId,
                                 address: this._evmAddress,
                             })];
-                    }
-                    else {
+                    case 2:
+                        // Awaited, so a failing emission is caught below rather than escaping
+                        // as an unhandled rejection out of the provider's event listener.
+                        // `return`ing the promise left the catch here unreachable.
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
                         logger.debug("OnChainChanged: Chain event skipped (autocapture.chain: false)", {
                             chainId: this._evmChainId,
                             address: this._evmAddress,
                         });
-                    }
-                }
-                catch (error) {
-                    logger.error("OnChainChanged: Failed to emit chain event:", error);
+                        _a.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_3 = _a.sent();
+                        logger.error("OnChainChanged: Failed to emit chain event:", error_3);
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
                 }
-                return [2 /*return*/];
             });
         });
     };
+    /**
+     * Record a provider's chain from its `connect` event, and nothing else.
+     *
+     * Used when connect autocapture is off. `connect` carries `chainId` in its
+     * payload, so this needs no RPC - unlike the full handler, which resolves
+     * the account.
+     */
+    FormoAnalytics.prototype.registerConnectChainObserver = function (provider) {
+        var _this = this;
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var connection = args[0];
+            if (typeof (connection === null || connection === void 0 ? void 0 : connection.chainId) !== "string")
+                return;
+            _this.rememberProviderChain(provider, parseChainId(connection.chainId));
+        };
+        provider.on("connect", listener);
+        this.addProviderListener(provider, "connect", listener);
+    };
+    /**
+     * Whether a connect for this wallet still needs reporting.
+     *
+     * True when nothing has been reported for this provider, or when the account
+     * changed. A wallet already reported is not reported again.
+     *
+     * Deliberately does NOT re-report to correct a chain. When `accountsChanged`
+     * wins the race on a provider that exposes no synchronous `chainId`, the
+     * connect carries 0 - honestly, since the chain is unknown at that instant -
+     * and the `connect` payload that follows knows the real one. Emitting again
+     * to relabel would mean two connects for one connection, which is the bug
+     * this whole path exists to prevent. That payload still corrects
+     * `currentChainId`, so everything after it is attributed properly.
+     */
+    FormoAnalytics.prototype.shouldReportConnect = function (provider, address) {
+        var reported = this._announcedConnect.get(provider);
+        if (!reported)
+            return true;
+        return reported.address.toLowerCase() !== address.toLowerCase();
+    };
+    /**
+     * Record a connect as reported - but only if it will actually be sent.
+     *
+     * `connect()` passes through `shouldTrack()`, which refuses an unresolvable
+     * chain when `tracking.excludeChains` is configured. Marking a refused event
+     * as reported would suppress the authoritative one that follows.
+     */
+    FormoAnalytics.prototype.markConnectReported = function (provider, address, chainId) {
+        if (!this.willTrackEvent(chainId))
+            return;
+        this._announcedConnect.set(provider, { address: address, chainId: chainId });
+    };
     FormoAnalytics.prototype.registerConnectListener = function (provider) {
         var _this = this;
         logger.info("registerConnectListener");
@@ -1288,6 +1486,9 @@ var FormoAnalytics = /** @class */ (function () {
                     case 0:
                         if (this._provider !== provider)
                             return [2 /*return*/];
+                        // As in the accountsChanged disconnect path: the reported connect ends
+                        // with the connection.
+                        this._announcedConnect.delete(provider);
                         logger.info("OnDisconnect: Wallet disconnect event received, current state:", {
                             currentAddress: this._evmAddress,
                             currentChainId: this._evmChainId,
@@ -1335,6 +1536,8 @@ var FormoAnalytics = /** @class */ (function () {
                         if (!(connection === null || connection === void 0 ? void 0 : connection.chainId) || typeof connection.chainId !== "string")
                             return [2 /*return*/];
                         chainId = parseChainId(connection.chainId);
+                        // Record it for this provider before anything can bail out below.
+                        this.rememberProviderChain(provider, chainId);
                         return [4 /*yield*/, this.getAddress(provider)];
                     case 2:
                         address = _a.sent();
@@ -1359,8 +1562,18 @@ var FormoAnalytics = /** @class */ (function () {
                                     });
                                 }
                             }
-                            // Conditionally emit connect event based on tracking configuration
-                            if (isActiveProvider && this._evmAddress) {
+                            // Conditionally emit connect event based on tracking configuration.
+                            //
+                            // Both handlers observe one connection, so `shouldReportConnect()`
+                            // decides which of them reports it. It keys on what was actually
+                            // REPORTED, not on whether an address is known: an address can be
+                            // present with no connect ever sent - restored from the active-wallet
+                            // cookie, or reported with an unresolved chain and then refused by
+                            // `excludeChains` - and this payload carries the authoritative chain,
+                            // so it must be able to supersede such a report.
+                            if (isActiveProvider &&
+                                this._evmAddress &&
+                                this.shouldReportConnect(provider, address)) {
                                 providerInfo = this.getProviderInfo(provider);
                                 effectiveChainId = chainId || 0;
                                 if (this.isAutocaptureEnabled("connect")) {
@@ -1375,6 +1588,7 @@ var FormoAnalytics = /** @class */ (function () {
                                     if (effectiveChainId === 0) {
                                         logger.info("OnConnected: Using fallback chainId 0 for connect event");
                                     }
+                                    this.markConnectReported(provider, address, effectiveChainId);
                                     this.connect({
                                         chainId: effectiveChainId,
                                         address: address,
@@ -1431,162 +1645,209 @@ var FormoAnalytics = /** @class */ (function () {
         }
         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 generation_1, responsePromise, capturedChainId_1, response_1, error_4, rpcError, txPromise, txChainId_1, transactionHash_1, error_5, rpcError;
             var _this = this;
+            var _c;
             var method = _b.method, params = _b.params;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
+                        // Learn the chain from a call the APP was making anyway.
+                        //
+                        // A standards-compliant provider need not expose a synchronous `chainId`
+                        // property, and if it connected before the SDK initialised, its
+                        // `connect` event is never replayed. Such a provider stayed unknown -
+                        // reported as chain 0, and with `excludeChains` configured its events
+                        // were dropped even on an allowed chain. This adds no request of its
+                        // own; it only reads the answer to one the dapp already sent.
+                        if (method === "eth_chainId") {
+                            generation_1 = (_c = this._providerChainGenerations.get(provider)) !== null && _c !== void 0 ? _c : 0;
+                            return [2 /*return*/, request({ method: method, params: params }).then(function (result) {
+                                    var _a;
+                                    // A `chainChanged` for THIS provider may have landed while this was
+                                    // in flight. It is newer by definition, so it must not be
+                                    // overwritten by this answer.
+                                    if (generation_1 === ((_a = _this._providerChainGenerations.get(provider)) !== null && _a !== void 0 ? _a : 0) &&
+                                        typeof result === "string") {
+                                        _this.rememberProviderChain(provider, parseChainId(result));
+                                    }
+                                    return result;
+                                })];
+                        }
                         if (!(Array.isArray(params) &&
-                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 6];
+                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 4];
                         if (!this.isAutocaptureEnabled("signature")) {
                             logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
                             return [2 /*return*/, request({ method: method, params: params })];
                         }
-                        _c = this._evmChainId;
-                        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;
+                        responsePromise = request({ method: method, params: params });
+                        // Attach a no-op handler now so a rejection arriving before the await
+                        // below is never reported as unhandled. The real handling is there.
+                        responsePromise.catch(function () { return undefined; });
+                        capturedChainId_1 = this.resolveChainIdForProvider(provider);
                         // Fire-and-forget tracking
                         (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var e_4;
                             return __generator(this, function (_a) {
-                                try {
-                                    this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1)));
-                                }
-                                catch (e) {
-                                    logger.error("Formo: Failed to track signature request", e);
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)))];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        e_4 = _a.sent();
+                                        logger.error("Formo: Failed to track signature request", e_4);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
                                 }
-                                return [2 /*return*/];
                             });
                         }); })();
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, request({ method: method, params: params })];
-                    case 4:
-                        response_1 = (_d.sent());
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, responsePromise];
+                    case 2:
+                        response_1 = _d.sent();
                         // Track signature confirmation only for truthy responses
                         if (response_1) {
                             (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var e_5;
                                 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);
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, this.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1, provider)))];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_5 = _a.sent();
+                                            logger.error("Formo: Failed to track signature confirmation", e_5);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
                                     }
-                                    return [2 /*return*/];
                                 });
                             }); })();
                         }
                         return [2 /*return*/, response_1];
-                    case 5:
-                        error_3 = _d.sent();
-                        rpcError = error_3;
+                    case 3:
+                        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 e_6;
                                 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);
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, this.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1, provider)))];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_6 = _a.sent();
+                                            logger.error("Formo: Failed to track signature rejection", e_6);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
                                     }
-                                    return [2 /*return*/];
                                 });
                             }); })();
                         }
-                        throw error_3;
-                    case 6:
+                        throw error_4;
+                    case 4:
                         if (!(Array.isArray(params) &&
                             method === "eth_sendTransaction" &&
-                            params[0])) return [3 /*break*/, 10];
+                            params[0])) return [3 /*break*/, 8];
                         if (!this.isAutocaptureEnabled("transaction")) {
                             logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
                             return [2 /*return*/, request({ method: method, params: params })];
                         }
+                        txPromise = request({ method: method, params: params });
+                        txPromise.catch(function () { return undefined; });
+                        txChainId_1 = this.resolveChainIdForProvider(provider);
                         (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_4;
+                            var payload, e_7;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
+                                        _a.trys.push([0, 3, , 4]);
+                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        this.transaction(__assign({ status: TransactionStatus.STARTED }, payload));
-                                        return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.transaction(__assign({ status: TransactionStatus.STARTED }, payload))];
                                     case 2:
-                                        e_4 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction start", e_4);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_7 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction start", e_7);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
                                 }
                             });
                         }); })();
-                        _d.label = 7;
-                    case 7:
-                        _d.trys.push([7, 9, , 10]);
-                        return [4 /*yield*/, request({
-                                method: method,
-                                params: params,
-                            })];
-                    case 8:
-                        transactionHash_1 = (_d.sent());
+                        _d.label = 5;
+                    case 5:
+                        _d.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, txPromise];
+                    case 6:
+                        transactionHash_1 = _d.sent();
                         (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_5;
+                            var payload, e_8;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
+                                        _a.trys.push([0, 3, , 4]);
+                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                     case 1:
                                         payload = _a.sent();
-                                        this.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }));
+                                        return [4 /*yield*/, this.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }))];
+                                    case 2:
+                                        _a.sent();
                                         // Start async polling for transaction receipt
                                         this.pollTransactionReceipt(provider, transactionHash_1, payload);
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_5 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction broadcast", e_5);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_8 = _a.sent();
+                                        logger.error("Formo: Failed to track transaction broadcast", e_8);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
                                 }
                             });
                         }); })();
                         return [2 /*return*/, transactionHash_1];
-                    case 9:
-                        error_4 = _d.sent();
-                        rpcError = error_4;
+                    case 7:
+                        error_5 = _d.sent();
+                        rpcError = error_5;
                         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;
+                                var payload, e_9;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
-                                            _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
+                                            _a.trys.push([0, 3, , 4]);
+                                            return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
                                         case 1:
                                             payload = _a.sent();
-                                            this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload));
-                                            return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload))];
                                         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*/];
+                                            _a.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            e_9 = _a.sent();
+                                            logger.error("Formo: Failed to track transaction rejection", e_9);
+                                            return [3 /*break*/, 4];
+                                        case 4: return [2 /*return*/];
                                     }
                                 });
                             }); })();
                         }
-                        throw error_4;
-                    case 10: return [2 /*return*/, request({ method: method, params: params })];
+                        throw error_5;
+                    case 8: return [2 /*return*/, request({ method: method, params: params })];
                 }
             });
         }); };
@@ -1604,9 +1865,16 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.onLocationChange = function () {
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
+            var _a;
+            return __generator(this, function (_b) {
                 if (this._currentUrl !== window.location.href) {
                     this._currentUrl = window.location.href;
+                    // Host/path exclusions are evaluated per navigation, so a SPA can leave
+                    // an excluded route and become trackable without any wallet event
+                    // firing. The wagmi handler only observes *changes*, so an unchanged
+                    // connection it was forced to decline earlier would stay invisible for
+                    // the rest of the page load. Give it a chance to adopt it now.
+                    (_a = this.wagmiHandler) === null || _a === void 0 ? void 0 : _a.retryAdoption();
                     this.trackPageHit();
                 }
                 return [2 /*return*/];
@@ -1677,7 +1945,7 @@ var FormoAnalytics = /** @class */ (function () {
                     if (_this._pageHooksDisposed)
                         return;
                     (function () { return __awaiter(_this, void 0, void 0, function () {
-                        var e_7;
+                        var e_10;
                         return __generator(this, function (_a) {
                             switch (_a.label) {
                                 case 0:
@@ -1690,8 +1958,8 @@ var FormoAnalytics = /** @class */ (function () {
                                     _a.sent();
                                     return [3 /*break*/, 3];
                                 case 2:
-                                    e_7 = _a.sent();
-                                    logger.error("Formo: Failed to track page hit", e_7);
+                                    e_10 = _a.sent();
+                                    logger.error("Formo: Failed to track page hit", e_10);
                                     return [3 /*break*/, 3];
                                 case 3: return [2 /*return*/];
                             }
@@ -1704,12 +1972,17 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.trackEvent = function (type, payload, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var error_5;
+            var error_6;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
-                        if (!this.shouldTrack()) {
+                        // Gate on the chain the event actually carries. `connect`, `disconnect`,
+                        // `chain`, `signature` and `transaction` all put one in the payload, and
+                        // it is authoritative: it can name a provider or a wagmi mutation chain
+                        // that is not the active one. Events without a chain (page, track,
+                        // identify) fall back to the central value.
+                        if (!this.shouldTrack(payload === null || payload === void 0 ? void 0 : payload.chainId)) {
                             logger.info("Skipping ".concat(type, " event due to tracking configuration"));
                             return [2 /*return*/];
                         }
@@ -1718,8 +1991,8 @@ var FormoAnalytics = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 3];
                     case 2:
-                        error_5 = _a.sent();
-                        logger.error("Error tracking event:", error_5);
+                        error_6 = _a.sent();
+                        logger.error("Error tracking event:", error_6);
                         return [3 /*break*/, 3];
                     case 3: return [2 /*return*/];
                 }
@@ -1756,16 +2029,24 @@ var FormoAnalytics = /** @class */ (function () {
      * an options object with `excludeChains` set, and only once a chain id is
      * known.
      */
-    FormoAnalytics.prototype.isCurrentChainExcluded = function () {
+    FormoAnalytics.prototype.isCurrentChainExcluded = function (eventChainId) {
         if (this.options.tracking === null ||
             typeof this.options.tracking !== "object" ||
             Array.isArray(this.options.tracking)) {
             return false;
         }
         var _a = this.options.tracking.excludeChains, excludeChains = _a === void 0 ? [] : _a;
-        return (excludeChains.length > 0 &&
-            !!this.currentChainId &&
-            excludeChains.includes(this.currentChainId));
+        if (excludeChains.length === 0)
+            return false;
+        // Mirrors `shouldTrack()`: the event's own chain wins when it has one,
+        // and an unresolvable chain on a known wallet counts as excluded rather
+        // than allowed.
+        var chainToCheck = eventChainId !== null && eventChainId !== void 0 ? eventChainId : this.currentChainId;
+        if (chainToCheck === 0)
+            return true;
+        if (chainToCheck === undefined)
+            return false;
+        return excludeChains.includes(chainToCheck);
     };
     /**
      * Whether the current environment is excluded from tracking - the visitor's
@@ -1860,7 +2141,7 @@ var FormoAnalytics = /** @class */ (function () {
      * Determines if tracking should be enabled based on configuration and consent
      * @returns {boolean} True if tracking should be enabled
      */
-    FormoAnalytics.prototype.shouldTrack = function () {
+    FormoAnalytics.prototype.shouldTrack = function (eventChainId) {
         // First check if user has opted out of tracking
         if (this.hasOptedOutTracking()) {
             return false;
@@ -1879,11 +2160,42 @@ var FormoAnalytics = /** @class */ (function () {
             if (this.isCurrentEnvironmentExcluded()) {
                 return false;
             }
-            // Check chainId exclusions
-            if (excludeChains.length > 0 &&
-                this.currentChainId &&
-                excludeChains.includes(this.currentChainId)) {
-                return false;
+            // Check chainId exclusions.
+            //
+            // The event's OWN chain wins over `currentChainId`. They differ whenever
+            // the event did not come from the active provider: a second wallet
+            // signing through its own provider, or a wagmi mutation that names an
+            // explicit chain. Reading only the central field there would emit an
+            // event that is labelled with an excluded chain, which is precisely what
+            // the exclusion forbids - and would drop an allowed event whenever the
+            // active provider happened to sit on an excluded chain.
+            var chainToCheck = eventChainId !== null && eventChainId !== void 0 ? eventChainId : this.currentChainId;
+            if (excludeChains.length > 0) {
+                // Fail CLOSED on an unknown chain. `resolveChainIdForProvider` reports
+                // 0 when it has never heard a chain from the signing wallet, and 0 is
+                // in no exclusion list, so treating it as "not excluded" would let
+                // exactly the events an operator excluded through - the wallet on the
+                // excluded chain is often the one we know least about. An explicit
+                // exclusion is a directive, so an unresolvable chain is refused.
+                //
+                // This covers the central value too, not just an explicit event
+                // chain: `page`, `track` and `identify` carry no chain of their own
+                // and fall back to `currentChainId`, so an unknown chain there would
+                // otherwise send wallet-attributed events for a wallet that may well
+                // be sitting on an excluded chain.
+                // Deliberately keyed on 0 and NOT on `undefined`. 0 is the explicit
+                // "we asked and could not tell" marker. `undefined` means no chain
+                // state yet, which is a legitimate transient - the Privy path
+                // reconciles a Solana wallet through exactly that state - and
+                // refusing it would drop real events.
+                //
+                // `backfillActiveWallet()` never persists 0, so an unresolvable chain
+                // cannot leak into `currentChainId` and reach the unscoped events
+                // (page / track / identify) that fall back to it.
+                if (chainToCheck === 0)
+                    return false;
+                if (chainToCheck && excludeChains.includes(chainToCheck))
+                    return false;
             }
             // If nothing is excluded, tracking is enabled
             return true;
@@ -1967,7 +2279,7 @@ var FormoAnalytics = /** @class */ (function () {
                         _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;
+                            var e_11;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
@@ -1977,8 +2289,8 @@ var FormoAnalytics = /** @class */ (function () {
                                         _a.sent();
                                         return [3 /*break*/, 3];
                                     case 2:
-                                        e_8 = _a.sent();
-                                        logger.error("Formo: Failed to detect wallets", e_8);
+                                        e_11 = _a.sent();
+                                        logger.error("Formo: Failed to detect wallets", e_11);
                                         return [3 /*break*/, 3];
                                     case 3: return [2 /*return*/];
                                 }
@@ -2171,6 +2483,105 @@ var FormoAnalytics = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Resolve the chain an autocaptured request actually ran on.
+     *
+     * `_evmChainId` is maintained by `chainChanged` from whichever provider is
+     * currently active. When a request arrives from a *different* tracked
+     * provider - which happens whenever a visitor has two wallets installed -
+     * that cached value describes the wrong wallet, and tagging the event with
+     * it silently mis-attributes the chain.
+     *
+     * Answered entirely from a per-provider snapshot. This is deliberately
+     * SYNCHRONOUS and never issues an RPC.
+     *
+     * An earlier version called `eth_chainId` on the signing provider and
+     * time-boxed it with `Promise.race`. That is not safe: the race abandons the
+     * SDK's promise but cannot cancel the provider's request. On a transport
+     * that serializes - WalletConnect's relay socket, the very case this path
+     * exists to serve - an abandoned lookup stays at the head of the wallet's
+     * queue, and every later RPC the dapp makes queues behind it until reload.
+     * Mislabelling a chain is a reporting defect; wedging the user's wallet is
+     * not acceptable to avoid one.
+     *
+     * When nothing is known, this reports 0 ("unknown") rather than guessing
+     * with the active provider's chain, which is known-wrong for another wallet.
+     */
+    FormoAnalytics.prototype.resolveChainIdForProvider = function (provider) {
+        if (provider) {
+            var known = this._providerChainIds.get(provider);
+            if (known)
+                return known;
+            // Only the active provider's chain is described by the central cache.
+            if (provider === this._provider && this._evmChainId) {
+                return this._evmChainId;
+            }
+            // A tracked provider we have never heard a chain from. Deliberately no
+            // fall back to `_evmChainId`: it belongs to a different wallet.
+            return 0;
+        }
+        return this._evmChainId || 0;
+    };
+    /**
+     * Record a provider's chain. Fed by `chainChanged` and `connect`, and by the
+     * one-off probe at tracking time - never from inside a user request.
+     */
+    FormoAnalytics.prototype.rememberProviderChain = function (provider, chainId) {
+        if (!provider || !chainId)
+            return;
+        // Any observation is newer than an `eth_chainId` still in flight for this
+        // provider.
+        this.bumpProviderChainGeneration(provider);
+        this._providerChainIds.set(provider, chainId);
+        // If this IS the active provider, central state has to follow. Recording
+        // it only per provider left `currentChainId` on a chain restored from a
+        // previous session, and the unscoped events that fall back to it were sent
+        // despite an exclusion covering the chain the wallet was really on.
+        //
+        // Guarded on EVM already being the active namespace. `setChainState()`
+        // makes whichever namespace it touches active, so syncing here
+        // unconditionally let a background EVM wallet's chain report steal the
+        // active slot from a live Solana wallet, and every later page or track
+        // event was attributed to the wrong wallet entirely.
+        if (provider === this._provider &&
+            this._activeNamespace === "evm" &&
+            this._evmChainId !== chainId) {
+            this.setChainState('evm', { chainId: chainId });
+        }
+    };
+    /** Advance and return this provider's chain-observation generation. */
+    FormoAnalytics.prototype.bumpProviderChainGeneration = function (provider) {
+        var _a;
+        var next = ((_a = this._providerChainGenerations.get(provider)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this._providerChainGenerations.set(provider, next);
+        return next;
+    };
+    /**
+     * Seed a provider's chain from whatever it already exposes synchronously.
+     *
+     * Most EIP-1193 implementations carry a `chainId` property (MetaMask,
+     * WalletConnect, Coinbase). Reading it costs nothing and cannot block.
+     *
+     * There is deliberately no RPC fallback. An earlier version probed with
+     * `eth_chainId` when a provider was first tracked, on the theory that
+     * tracking time is off the user's critical path. It is not: a serialized
+     * transport has ONE queue, so a stalled probe sits in front of every later
+     * signature and transaction the dapp makes. It could also land out of order
+     * - a slow probe response overwriting a newer `chainChanged` - and relabel
+     * events onto a chain the wallet had already left.
+     *
+     * A provider that exposes nothing stays unknown until it emits
+     * `chainChanged` or `connect`, and unknown is reported honestly as 0.
+     */
+    FormoAnalytics.prototype.seedProviderChainFromState = function (provider) {
+        var raw = provider.chainId;
+        var chainId = typeof raw === "string"
+            ? parseChainId(raw)
+            : typeof raw === "number"
+                ? raw
+                : undefined;
+        this.rememberProviderChain(provider, chainId);
+    };
     FormoAnalytics.prototype.getCurrentChainId = function (provider) {
         return __awaiter(this, void 0, void 0, function () {
             var p, chainIdHex, err_5;
@@ -2206,7 +2617,7 @@ var FormoAnalytics = /** @class */ (function () {
     };
     FormoAnalytics.prototype.buildSignatureEventPayload = function (method, params, 
     // Intentionally not read. Kept for positional call-site arity.
-    _response, chainId) {
+    _response, chainId, provider) {
         var _a;
         var rawAddress = method === "personal_sign"
             ? params[1]
@@ -2216,7 +2627,11 @@ var FormoAnalytics = /** @class */ (function () {
             throw new Error("Invalid address in signature payload: ".concat(rawAddress));
         }
         var effectiveChainId = (_a = chainId !== null && chainId !== void 0 ? chainId : this._evmChainId) !== null && _a !== void 0 ? _a : undefined;
-        this.backfillActiveWallet(validAddress, effectiveChainId);
+        // Only the active provider may write central wallet state - see the same
+        // guard in buildTransactionEventPayload.
+        if (!provider || provider === this._provider || !this._provider) {
+            this.backfillActiveWallet(validAddress, effectiveChainId, provider);
+        }
         var basePayload = {
             chainId: effectiveChainId,
             address: validAddress,
@@ -2228,34 +2643,37 @@ var FormoAnalytics = /** @class */ (function () {
         // eth_signTypedData*: params[1] is the full EIP-712 struct.
         return __assign(__assign({}, basePayload), { message: params[1] });
     };
-    FormoAnalytics.prototype.buildTransactionEventPayload = function (params, provider) {
+    FormoAnalytics.prototype.buildTransactionEventPayload = function (params, provider, 
+    /**
+     * Chain resolved once for this request's whole lifecycle. Passing it keeps
+     * every status of one transaction on the same chain even if the user
+     * switches network while the wallet prompt is open.
+     */
+    capturedChainId) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, data, from, to, value, validAddress, chainId, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
-                        validAddress = validateAndChecksumAddress(from);
-                        if (!validAddress) {
-                            throw new Error("Invalid address in transaction payload: ".concat(from));
-                        }
-                        _b = this._evmChainId;
-                        if (_b) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 1:
-                        _b = (_c.sent());
-                        _c.label = 2;
-                    case 2:
-                        chainId = _b;
-                        this.backfillActiveWallet(validAddress, chainId);
-                        return [2 /*return*/, {
-                                chainId: chainId,
-                                data: data,
-                                address: validAddress,
-                                to: to,
-                                value: value,
-                            }];
+            var _a, data, from, to, value, validAddress, chainId;
+            return __generator(this, function (_b) {
+                _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
+                validAddress = validateAndChecksumAddress(from);
+                if (!validAddress) {
+                    throw new Error("Invalid address in transaction payload: ".concat(from));
+                }
+                chainId = capturedChainId !== null && capturedChainId !== void 0 ? capturedChainId : this.resolveChainIdForProvider(provider);
+                // Only the ACTIVE provider may write central wallet state. A request from
+                // a second, non-active wallet would otherwise overwrite the active
+                // provider's address and chain, and every later request through the active
+                // provider would then trust the other wallet's chain - persistent
+                // mis-attribution, and a way around `excludeChains`.
+                if (!provider || provider === this._provider || !this._provider) {
+                    this.backfillActiveWallet(validAddress, chainId, provider);
                 }
+                return [2 /*return*/, {
+                        chainId: chainId,
+                        data: data,
+                        address: validAddress,
+                        to: to,
+                        value: value,
+                    }];
             });
         });
     };
@@ -2267,16 +2685,51 @@ var FormoAnalytics = /** @class */ (function () {
      * social-login wrappers). If `accountsChanged` later fires it overwrites this
      * value in the normal way; existing connections are never clobbered.
      */
-    FormoAnalytics.prototype.backfillActiveWallet = function (address, chainId) {
+    FormoAnalytics.prototype.backfillActiveWallet = function (address, chainId, provider) {
+        // Refuse a chain the provider has since moved off.
+        //
+        // A request captures its chain once and reuses that snapshot for every
+        // status it emits, which is right for the event payload - a confirmation
+        // must not be relabelled mid-flight. But writing that captured value back
+        // into central state on the LATER statuses restored a chain the wallet had
+        // already left, and the unscoped events that fall back to it then bypassed
+        // an exclusion that should have caught them.
+        if (provider && chainId !== undefined && chainId !== 0) {
+            var current = this._providerChainIds.get(provider);
+            if (current !== undefined && current !== chainId) {
+                chainId = current;
+            }
+        }
+        // `0` is kept deliberately. It means "could not resolve", and persisting
+        // it is what lets the exclusion gate refuse the unscoped events - `page`,
+        // `track`, `identify` - that carry no chain of their own and fall back to
+        // `currentChainId`. Erasing it to `undefined` looked tidier but removed
+        // the only marker distinguishing "unknown" from "no wallet yet", and those
+        // events then went out attributed to a wallet that might be sitting on an
+        // excluded chain.
         // Never learn identity while suppressed (opt-out / timezone / excluded host
         // or path). A signature/transaction observed on an excluded route must not
-        // populate currentAddress for later allowed-page events. backfill only ever
-        // *adds* an address (it no-ops when one is already known), so there is no
-        // stale state to clear here.
+        // populate currentAddress for later allowed-page events.
         if (this.isTrackingSuppressed())
             return;
-        if (this._evmAddress)
+        var known = this._evmAddress;
+        if (known) {
+            // Same wallet, newer chain: correct it rather than returning.
+            //
+            // A persisted wallet restores a chain from a previous session. If the
+            // provider has since moved - to an excluded chain, or to one we cannot
+            // resolve - the autocaptured event is gated correctly, but the stale
+            // restored chain stayed in `currentChainId` and the unscoped events
+            // that fall back to it went out under an exclusion that should have
+            // caught them.
+            if (chainId !== undefined &&
+                known.toLowerCase() === address.toLowerCase() &&
+                this._evmChainId !== chainId) {
+                this.setChainState('evm', { address: known, chainId: chainId });
+            }
+            // A DIFFERENT address is another wallet's business; never overwrite.
             return;
+        }
         this.setChainState('evm', { address: address, chainId: chainId });
     };
     /**
@@ -2307,7 +2760,7 @@ var FormoAnalytics = /** @class */ (function () {
                 if (!provider)
                     return [2 /*return*/];
                 poll = function () { return __awaiter(_this, void 0, void 0, function () {
-                    var receipt, e_9;
+                    var receipt, e_12;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
@@ -2331,8 +2784,8 @@ var FormoAnalytics = /** @class */ (function () {
                                 }
                                 return [3 /*break*/, 3];
                             case 2:
-                                e_9 = _a.sent();
-                                logger.error("Error polling transaction receipt", e_9);
+                                e_12 = _a.sent();
+                                logger.error("Error polling transaction receipt", e_12);
                                 return [3 /*break*/, 3];
                             case 3:
                                 attempts++;
@@ -2462,6 +2915,9 @@ var FormoAnalytics = /** @class */ (function () {
             ns.chainId = namespaceOrChainId;
         }
         if (namespace === 'evm' && 'provider' in update) {
+            // Displacing the active provider ends its connection as far as this SDK
+            // is concerned, so the connect it reported stops counting.
+            this.forgetConnectRecord(ns.provider, update.provider);
             ns.provider = update.provider;
         }
         this._activeNamespace = namespace;
@@ -2475,6 +2931,8 @@ var FormoAnalytics = /** @class */ (function () {
             ? namespaceOrChainId
             : this.getNamespace(namespaceOrChainId);
         if (namespace === 'evm') {
+            // Same rule: wiping the namespace drops the active provider.
+            this.forgetConnectRecord(this._chainState.evm.provider, undefined);
             this._chainState.evm = {};
         }
         else {