@formo/analytics 1.35.1 → 1.36.0

package/dist/esm/src/evm/EvmEventTracker.js

@@ -0,0 +1,1027 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { createStore } from "mipd";
+import { logger } from "../logger";
+import { parseChainId } from "../utils/chain";
+import { validateAndChecksumAddress } from "../utils/address";
+import { detectInjectedProviderInfo, isValidProvider } from "../provider";
+/** Why the tracker moved the active slot to another provider. Log copy. */
+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",
+};
+/**
+ * The EIP-1193 side of wallet tracking: which providers to watch, and what
+ * their events mean.
+ *
+ * Split out of `FormoAnalytics` (#336). It holds no wallet state and no
+ * provider registry of its own - those have owners already - so what is left
+ * here is the part that is genuinely about interpreting wallet events:
+ * deciding when a connect has to be reported, when a switch is stale, and
+ * when a provider has stopped being the one we follow.
+ */
+var EvmEventTracker = /** @class */ (function () {
+    function EvmEventTracker(wallet, registry, deps) {
+        this.wallet = wallet;
+        this.registry = registry;
+        this.deps = deps;
+        /**
+         * The connect this SDK has already reported for a provider.
+         *
+         * Connection REPORTING, which is why it lives with the handlers rather than
+         * with wallet state. The store tells us when a provider stops being active,
+         * which is when a record must lapse.
+         */
+        this._announcedConnect = new WeakMap();
+    }
+    /** Stop listening for wallet announcements. Called from SDK teardown. */
+    EvmEventTracker.prototype.cleanup = function () {
+        var _a;
+        try {
+            (_a = this.unsubscribeDiscovery) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        catch (e) {
+            logger.warn("Failed to unsubscribe from provider discovery", e);
+        }
+        this.unsubscribeDiscovery = undefined;
+    };
+    /** Drop a provider's reported connect. Called when it stops being active. */
+    EvmEventTracker.prototype.forgetAnnouncedConnect = function (provider) {
+        this._announcedConnect.delete(provider);
+    };
+    /**
+     * 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
+     */
+    EvmEventTracker.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.wallet.provider != null && this.wallet.provider !== provider;
+    };
+    /**
+     * Track an EIP-1193 provider by wrapping its request method and adding event listeners
+     * Note: This is only used in non-Wagmi mode. When Wagmi is enabled, all tracking
+     * happens through Wagmi's connector system instead of EIP-1193/EIP-6963.
+     * @param provider The EIP-1193 provider to track
+     */
+    EvmEventTracker.prototype.trackEIP1193Provider = function (provider) {
+        logger.info("trackEIP1193Provider", provider);
+        // Defensive check: Skip provider tracking in Wagmi mode
+        // This should never be called in Wagmi mode due to guards in init(),
+        // but we check here for safety in case of future code changes
+        if (this.deps.isWagmiMode()) {
+            logger.debug("trackEIP1193Provider: Skipping EIP-1193 provider tracking (Wagmi mode - using connector system instead)");
+            return;
+        }
+        try {
+            // Validate provider exists and has required methods
+            if (!isValidProvider(provider)) {
+                logger.warn("trackEIP1193Provider: Invalid provider - missing required methods");
+                return;
+            }
+            if (this.registry.isTracked(provider)) {
+                logger.warn("trackEIP1193Provider: Provider already tracked");
+                return;
+            }
+            // CRITICAL: Always register accountsChanged for state management
+            // This ensures currentAddress, currentChainId, and _provider are always up-to-date
+            // Event emission is controlled conditionally inside the handlers
+            this.registerAccountsChangedListener(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.deps.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);
+            // Wrapped UNCONDITIONALLY. The wrapper checks the autocapture flags per
+            // request, so skipping it here bought nothing and cost a real case: an
+            // app that turned signature or transaction capture on after init had a
+            // provider that was never wrapped, and never would be.
+            if (!this.deps.registerRequestListeners(provider)) {
+                // Not tracked: discovery would otherwise never retry it, and every
+                // signature and transaction from this wallet would be missed.
+                logger.warn("TrackProvider: Could not wrap provider; leaving it untracked");
+                return;
+            }
+            // 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
+            this.registry.markTracked(provider);
+        }
+        catch (error) {
+            logger.error("Error tracking provider:", error);
+        }
+    };
+    EvmEventTracker.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.registry.isTracked(provider)) {
+                    this.trackEIP1193Provider(provider);
+                }
+            }
+        }
+        catch (error) {
+            logger.error("Failed to track EIP-6963 providers during initialization:", error);
+        }
+    };
+    EvmEventTracker.prototype.registerAccountsChangedListener = function (provider) {
+        var _this = this;
+        logger.info("registerAccountsChangedListener");
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return _this.onAccountsChanged(provider, args[0]);
+        };
+        provider.on("accountsChanged", listener);
+        this.registry.addListener(provider, "accountsChanged", listener);
+    };
+    EvmEventTracker.prototype.onAccountsChanged = function (provider, accounts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var claims, observation;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        logger.info("onAccountsChanged", accounts);
+                        claims = accounts.length > 0 || this.wallet.provider === provider;
+                        observation = claims
+                            ? this.wallet.observe("evm")
+                            : this.wallet.currentObservation("evm");
+                        // Take the ticket BEFORE any async work, so the order recorded is the
+                        // order the wallet's signals arrived in. This path used to DROP a second
+                        // `accountsChanged` while the first was in flight; dropping is not
+                        // ordering, and a wallet that disconnected and came straight back had its
+                        // reconnect thrown away.
+                        return [4 /*yield*/, this._handleAccountsChanged(provider, accounts, observation)];
+                    case 1:
+                        // Take the ticket BEFORE any async work, so the order recorded is the
+                        // order the wallet's signals arrived in. This path used to DROP a second
+                        // `accountsChanged` while the first was in flight; dropping is not
+                        // ordering, and a wallet that disconnected and came straight back had its
+                        // reconnect thrown away.
+                        _a.sent();
+                        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.
+     */
+    EvmEventTracker.prototype._handleAccountsChanged = function (provider, accounts, observation) {
+        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*/, 9];
+                        if (!(this.wallet.provider === provider)) return [3 /*break*/, 7];
+                        logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
+                            evmAddress: this.wallet.evmAddress,
+                            evmChainId: this.wallet.evmChainId,
+                            providerMatch: this.wallet.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.deps.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        // Pass EVM state explicitly to ensure we have the data for the disconnect event
+                        return [4 /*yield*/, this.deps.disconnect({
+                                chainId: this.wallet.evmChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    case 2:
+                        // Pass EVM 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.debug("OnAccountsChanged: Disconnect event skipped (autocapture.disconnect: false)");
+                        // Whether the app opted into the EVENT has no bearing on ordering.
+                        this.wallet.beginDisconnect("evm");
+                        // Still clear state even if not tracking the event
+                        this.wallet.clear('evm');
+                        _a.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        logger.info("OnAccountsChanged: Ignoring disconnect for non-active provider");
+                        _a.label = 8;
+                    case 8: return [2 /*return*/];
+                    case 9:
+                        address = validateAndChecksumAddress(accounts[0]);
+                        if (!address) {
+                            logger.warn("onAccountsChanged: Invalid address received", accounts[0]);
+                            return [2 /*return*/];
+                        }
+                        if (!(this.wallet.provider && this.wallet.provider !== provider)) return [3 /*break*/, 26];
+                        currentStoredAddress = this.wallet.evmAddress;
+                        newProviderAddress = validateAndChecksumAddress(address);
+                        logger.info("OnAccountsChanged: Different provider attempting to connect", {
+                            activeProvider: this.registry.infoFor(this.wallet.provider).name,
+                            eventProvider: this.registry.infoFor(provider).name,
+                            currentStoredAddress: currentStoredAddress,
+                            newProviderAddress: newProviderAddress,
+                        });
+                        _a.label = 10;
+                    case 10:
+                        _a.trys.push([10, 22, , 26]);
+                        return [4 /*yield*/, this.registry.accountsOf(this.wallet.provider)];
+                    case 11:
+                        activeProviderAccounts = _a.sent();
+                        // The probe is asynchronous too, so check before issuing anything.
+                        // Every branch below reads the CURRENT evm state, so a switch that
+                        // went stale during the probe would emit a false disconnect for
+                        // whoever claimed the namespace, and clear them.
+                        if (!this.wallet.isCurrent(observation))
+                            return [2 /*return*/];
+                        logger.info("OnAccountsChanged: Checking current provider accounts", {
+                            activeProvider: this.registry.infoFor(this.wallet.provider).name,
+                            accountsLength: activeProviderAccounts
+                                ? activeProviderAccounts.length
+                                : 0,
+                            accounts: activeProviderAccounts,
+                        });
+                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 17];
+                        if (!(newProviderAddress &&
+                            currentStoredAddress &&
+                            newProviderAddress !== currentStoredAddress)) return [3 /*break*/, 15];
+                        logger.info("OnAccountsChanged: Different address detected, switching providers despite current provider having accounts", {
+                            activeProvider: this.registry.infoFor(this.wallet.provider).name,
+                            eventProvider: this.registry.infoFor(provider).name,
+                            currentAddress: currentStoredAddress,
+                            newAddress: newProviderAddress,
+                            reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH,
+                        });
+                        if (!this.deps.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 13];
+                        return [4 /*yield*/, this.deps.disconnect({
+                                chainId: this.wallet.evmChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    case 12:
+                        _a.sent();
+                        return [3 /*break*/, 14];
+                    case 13:
+                        logger.debug("OnAccountsChanged: Disconnect event skipped during provider switch (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.wallet.clear('evm');
+                        _a.label = 14;
+                    case 14:
+                        if (!this.wallet.isCurrent(observation))
+                            return [2 /*return*/];
+                        // Clear state and let the new provider become active
+                        this.wallet.clearProvider();
+                        return [3 /*break*/, 16];
+                    case 15:
+                        logger.info("OnAccountsChanged: Current provider still has accounts and same address, ignoring new provider", {
+                            activeProvider: this.registry.infoFor(this.wallet.provider).name,
+                            eventProvider: this.registry.infoFor(provider).name,
+                            activeProviderAccountsCount: activeProviderAccounts.length,
+                            currentAddress: currentStoredAddress,
+                            newAddress: newProviderAddress,
+                        });
+                        return [2 /*return*/];
+                    case 16: return [3 /*break*/, 21];
+                    case 17:
+                        logger.info("OnAccountsChanged: Current provider has no accounts, switching to new provider", {
+                            oldProvider: this.registry.infoFor(this.wallet.provider).name,
+                            newProvider: this.registry.infoFor(provider).name,
+                            reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS,
+                        });
+                        if (!this.deps.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 19];
+                        return [4 /*yield*/, this.deps.disconnect({
+                                chainId: this.wallet.evmChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    case 18:
+                        _a.sent();
+                        return [3 /*break*/, 20];
+                    case 19:
+                        logger.debug("OnAccountsChanged: Disconnect event skipped for old provider (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.wallet.clear('evm');
+                        _a.label = 20;
+                    case 20:
+                        if (!this.wallet.isCurrent(observation))
+                            return [2 /*return*/];
+                        _a.label = 21;
+                    case 21: return [3 /*break*/, 26];
+                    case 22:
+                        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.wallet.provider
+                                ? this.registry.infoFor(this.wallet.provider).name
+                                : "unknown",
+                            newProvider: this.registry.infoFor(provider).name,
+                            reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED,
+                        });
+                        if (!this.deps.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 24];
+                        return [4 /*yield*/, this.deps.disconnect({
+                                chainId: this.wallet.evmChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    case 23:
+                        _a.sent();
+                        return [3 /*break*/, 25];
+                    case 24:
+                        logger.debug("OnAccountsChanged: Disconnect event skipped for failed provider check (autocapture.disconnect: false)");
+                        // Still clear state even if not tracking the event
+                        this.wallet.clear('evm');
+                        _a.label = 25;
+                    case 25:
+                        if (!this.wallet.isCurrent(observation))
+                            return [2 /*return*/];
+                        return [3 /*break*/, 26];
+                    case 26:
+                        // Set provider if none exists (first connection)
+                        if (!this.wallet.provider) {
+                            this.wallet.provider = provider;
+                        }
+                        // If both the provider and address are the same, no-op
+                        if (this.wallet.provider === provider && address === this.wallet.evmAddress) {
+                            return [2 /*return*/];
+                        }
+                        nextChainId = this.registry.resolveChainId(provider);
+                        wasDisconnected = !this.wallet.evmAddress;
+                        // Update state regardless of whether connect *event* tracking is enabled,
+                        // so disconnect events keep valid address/chainId values. (excludeChains is
+                        // NOT suppression - it still updates state so currentChainId can gate
+                        // events.)
+                        if (this.deps.isTrackingSuppressed()) {
+                            this.wallet.clearStaleEvmWalletOnSwitchWhileSuppressed(address);
+                        }
+                        else {
+                            this.wallet.set('evm', { address: address, chainId: nextChainId });
+                        }
+                        providerInfo = this.registry.infoFor(provider);
+                        effectiveChainId = nextChainId || 0;
+                        if (this.deps.isAutocaptureEnabled("connect") &&
+                            this.shouldReportConnect(provider, address)) {
+                            logger.info("OnAccountsChanged: Detected wallet connection, emitting connect event", {
+                                chainId: nextChainId,
+                                address: address,
+                                wasDisconnected: wasDisconnected,
+                                providerName: providerInfo.name,
+                                rdns: providerInfo.rdns,
+                                hasChainId: !!nextChainId,
+                            });
+                            if (effectiveChainId === 0) {
+                                logger.info("OnAccountsChanged: Using fallback chainId 0 for connect event");
+                            }
+                            this.markConnectReported(provider, address, effectiveChainId);
+                            this.deps.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);
+                            });
+                        }
+                        else {
+                            logger.debug("OnAccountsChanged: Connect event skipped (autocapture.connect: false)", {
+                                chainId: nextChainId,
+                                address: address,
+                                providerName: providerInfo.name,
+                            });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EvmEventTracker.prototype.registerChainChangedListener = function (provider) {
+        var _this = this;
+        logger.info("registerChainChangedListener");
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return _this.onChainChanged(provider, args[0]);
+        };
+        provider.on("chainChanged", listener);
+        this.registry.addListener(provider, "chainChanged", listener);
+    };
+    EvmEventTracker.prototype.onChainChanged = function (provider, chainIdHex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nextChainId, error_3;
+            return __generator(this, function (_a) {
+                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.registry.rememberChain(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.deps.isAutocaptureEnabled("chain") && provider !== this.wallet.provider) {
+                            return [2 /*return*/];
+                        }
+                        // Only handle chain changes for the active provider (or if none is set yet)
+                        // A chain event from a non-active EVM provider is only a wallet switch
+                        // on the EVM side. While Solana holds the active slot it is background
+                        // noise: letting it through relabelled the session as EVM with no wallet
+                        // and wiped the EVM wallet we were tracking, on the strength of a network
+                        // change in a wallet nobody was using. The chain itself is still
+                        // recorded above, so a later request through that provider is labelled
+                        // correctly.
+                        if (this.isProviderMismatch(provider)) {
+                            if (this.wallet.activeNamespace === "solana")
+                                return [2 /*return*/];
+                            this.handleProviderMismatch(provider);
+                        }
+                        // Chain changes only matter for connected users
+                        if (!this.wallet.evmAddress) {
+                            logger.info("OnChainChanged: No current address, user appears disconnected");
+                            return [2 /*return*/, Promise.resolve()];
+                        }
+                        // Set provider if none exists
+                        if (!this.wallet.provider) {
+                            this.wallet.provider = provider;
+                        }
+                        this.wallet.set('evm', { chainId: nextChainId });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        if (!this.deps.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.deps.chain({
+                                chainId: nextChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    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.wallet.evmChainId,
+                            address: this.wallet.evmAddress,
+                        });
+                        _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*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    EvmEventTracker.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.registry.rememberChain(provider, parseChainId(connection.chainId));
+        };
+        provider.on("connect", listener);
+        this.registry.addListener(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.
+     */
+    EvmEventTracker.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.
+     */
+    EvmEventTracker.prototype.markConnectReported = function (provider, address, chainId) {
+        if (!this.deps.willTrackEvent(chainId))
+            return;
+        this._announcedConnect.set(provider, { address: address, chainId: chainId });
+    };
+    EvmEventTracker.prototype.registerConnectListener = function (provider) {
+        var _this = this;
+        logger.info("registerConnectListener");
+        var listener = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var connection = args[0];
+            _this.onConnected(provider, connection);
+        };
+        provider.on("connect", listener);
+        this.registry.addListener(provider, "connect", listener);
+    };
+    EvmEventTracker.prototype.registerDisconnectListener = function (provider) {
+        var _this = this;
+        logger.info("registerDisconnectListener");
+        var listener = function (_error) { return __awaiter(_this, void 0, void 0, function () {
+            var e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.wallet.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.wallet.evmAddress,
+                            currentChainId: this.wallet.evmChainId,
+                        });
+                        if (!this.deps.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 5];
+                        _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.deps.disconnect({
+                                chainId: this.wallet.evmChainId,
+                                address: this.wallet.evmAddress,
+                            })];
+                    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_1 = _a.sent();
+                        logger.error("Error during disconnect in disconnect listener", e_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        logger.debug("OnDisconnect: Disconnect event skipped (autocapture.disconnect: false)");
+                        this.wallet.beginDisconnect("evm");
+                        // Still clear state even if not tracking the event
+                        this.wallet.clear('evm');
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); };
+        provider.on("disconnect", listener);
+        this.registry.addListener(provider, "disconnect", listener);
+    };
+    EvmEventTracker.prototype.onConnected = function (provider, connection) {
+        return __awaiter(this, void 0, void 0, function () {
+            var disconnectsBefore, stateTicket, chainId, address, committed, movedElsewhere, wasDisconnected, isActiveProvider, providerInfo, effectiveChainId, providerInfo, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        logger.info("onConnected", connection);
+                        disconnectsBefore = this.wallet.disconnectsSoFar("evm");
+                        stateTicket = this.wallet.currentObservation("evm");
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        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.registry.rememberChain(provider, chainId);
+                        return [4 /*yield*/, this.registry.addressOf(provider)];
+                    case 2:
+                        address = _a.sent();
+                        // A newer signal arrived while we were resolving the address. Claiming
+                        // the namespace now would write this stale view over it, and would make
+                        // a disconnect still in flight look stale so it skipped its cleanup. A
+                        // reconnect that started AFTER the disconnect holds a newer ticket and
+                        // is reported normally.
+                        if (this.wallet.disconnectsSoFar("evm") !== disconnectsBefore) {
+                            logger.info("onConnected: The wallet disconnected after this observation began; dropping it");
+                            return [2 /*return*/];
+                        }
+                        committed = this.wallet.evmAddress;
+                        movedElsewhere = !!committed &&
+                            !!address &&
+                            committed.toLowerCase() !== address.toLowerCase();
+                        if (provider === this.wallet.provider &&
+                            !this.wallet.isCurrent(stateTicket) &&
+                            movedElsewhere) {
+                            logger.info("onConnected: A newer signal from this provider has overtaken this connect observation; dropping it");
+                            return [2 /*return*/];
+                        }
+                        if (chainId && address) {
+                            wasDisconnected = !this.wallet.evmAddress;
+                            // Set provider if none exists
+                            if (!this.wallet.provider) {
+                                this.wallet.provider = provider;
+                            }
+                            isActiveProvider = this.wallet.provider === provider;
+                            // Update state from active provider so disconnect events keep valid
+                            // address/chainId values - except while suppressed, where we must not
+                            // LEARN identity (only drop a stale EVM wallet on a switch).
+                            if (isActiveProvider) {
+                                if (this.deps.isTrackingSuppressed()) {
+                                    this.wallet.clearStaleEvmWalletOnSwitchWhileSuppressed(address);
+                                }
+                                else {
+                                    this.wallet.set('evm', {
+                                        chainId: chainId,
+                                        address: validateAndChecksumAddress(address) || undefined,
+                                    });
+                                }
+                            }
+                            // 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.wallet.evmAddress &&
+                                this.shouldReportConnect(provider, address)) {
+                                providerInfo = this.registry.infoFor(provider);
+                                effectiveChainId = chainId || 0;
+                                if (this.deps.isAutocaptureEnabled("connect")) {
+                                    logger.info("OnConnected: Detected wallet connection, emitting connect event", {
+                                        chainId: chainId,
+                                        wasDisconnected: wasDisconnected,
+                                        providerName: providerInfo.name,
+                                        rdns: providerInfo.rdns,
+                                        hasChainId: !!chainId,
+                                        isActiveProvider: isActiveProvider,
+                                    });
+                                    if (effectiveChainId === 0) {
+                                        logger.info("OnConnected: Using fallback chainId 0 for connect event");
+                                    }
+                                    this.markConnectReported(provider, address, effectiveChainId);
+                                    this.deps.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 {
+                                    logger.debug("OnConnected: Connect event skipped (autocapture.connect: false)", {
+                                        chainId: chainId,
+                                        address: address,
+                                        providerName: providerInfo.name,
+                                    });
+                                }
+                            }
+                            else if (address && !isActiveProvider) {
+                                providerInfo = this.registry.infoFor(provider);
+                                logger.debug("OnConnected: Skipping connect event for non-active provider", {
+                                    chainId: chainId,
+                                    providerName: providerInfo.name,
+                                    rdns: providerInfo.rdns,
+                                    isActiveProvider: isActiveProvider,
+                                    activeProviderInfo: this.wallet.provider
+                                        ? this.registry.infoFor(this.wallet.provider)
+                                        : null,
+                                });
+                            }
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_2 = _a.sent();
+                        logger.error("Error handling connect event", e_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EvmEventTracker.prototype.getProviders = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var store, providers, injected, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
+            var _this = this;
+            return __generator(this, function (_a) {
+                store = createStore();
+                providers = store.getProviders();
+                this.unsubscribeDiscovery = store.subscribe(function (providerDetails) {
+                    providers = providerDetails;
+                    // 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.registry.isSeen(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.registry.add(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.registry.isTracked(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_3;
+                            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_3 = _a.sent();
+                                        logger.error("Formo: Failed to detect wallets", e_3);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                    }
+                    // Clean up providers that are no longer available. Compared against
+                    // THIS announcement: the registry's list is historical and append-only,
+                    // so comparing against it could never find anything missing.
+                    _this.cleanupUnavailableProviders(providerDetails);
+                });
+                // Fallback to injected provider if no providers are found
+                if (providers.length === 0) {
+                    injected = typeof window !== "undefined" ? window.ethereum : undefined;
+                    if (injected) {
+                        // If we have already detected and cached the injected provider, and it's the same instance, return the cached result
+                        if (this.registry.injected &&
+                            this.registry.injected.provider === injected) {
+                            // Ensure it's tracked
+                            if (!this.registry.isTracked(injected)) {
+                                this.trackEIP1193Provider(injected);
+                            }
+                            // Merge with existing providers instead of overwriting
+                            this.registry.add(this.registry.injected);
+                            return [2 /*return*/, this.registry.all];
+                        }
+                        // Re-check if the injected provider is already tracked just before tracking
+                        if (!this.registry.isTracked(injected)) {
+                            this.trackEIP1193Provider(injected);
+                        }
+                        injectedProviderInfo = detectInjectedProviderInfo(injected);
+                        injectedDetail = {
+                            provider: injected,
+                            info: injectedProviderInfo,
+                        };
+                        // Cache the detected injected provider detail
+                        this.registry.injected = injectedDetail;
+                        // Merge with existing providers instead of overwriting
+                        this.registry.add(injectedDetail);
+                    }
+                    return [2 /*return*/, this.registry.all];
+                }
+                uniqueProviders = providers.filter(function (detail) {
+                    var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
+                    return provider && !_this.registry.isSeen(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.registry.add(detail);
+                }
+                return [2 /*return*/, this.registry.all];
+            });
+        });
+    };
+    EvmEventTracker.prototype.detectWallets = function (providers) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, providers_2, eip6963ProviderDetail, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 5, , 6]);
+                        _i = 0, providers_2 = providers;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < providers_2.length)) return [3 /*break*/, 4];
+                        eip6963ProviderDetail = providers_2[_i];
+                        return [4 /*yield*/, this.deps.detect({
+                                providerName: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.name,
+                                rdns: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.rdns,
+                            })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _a.sent();
+                        logger.error("Error detect all wallets:", err_1);
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    EvmEventTracker.prototype.seedProviderChainFromState = function (provider) {
+        var raw = provider.chainId;
+        var chainId = typeof raw === "string"
+            ? parseChainId(raw)
+            : typeof raw === "number"
+                ? raw
+                : undefined;
+        this.registry.rememberChain(provider, chainId);
+    };
+    EvmEventTracker.prototype.untrackProvider = function (provider) {
+        try {
+            this.registry.removeListeners(provider);
+            // Only stop tracking it if the listeners actually came off. "Tracked"
+            // means "has our listeners wired up", which is still true when removal
+            // threw, and `cleanup()` iterates the tracked set. Forgetting it here
+            // regardless is what made a retained listener unreachable: the entry
+            // survived but nothing ever looked at it again, so the retry that
+            // retention exists for could never happen.
+            if (this.registry.attachedEvents(provider).length === 0) {
+                this.registry.forgetTracked(provider);
+            }
+            if (this.wallet.provider === provider) {
+                this.wallet.clearProvider();
+            }
+        }
+        catch (e) {
+            logger.warn("Failed to untrack provider", e);
+        }
+    };
+    /**
+     * Clean up providers that are no longer available
+     * This helps maintain consistent state and prevents memory leaks
+     */
+    EvmEventTracker.prototype.cleanupUnavailableProviders = function (current) {
+        // Remove providers that are no longer in the current providers list
+        var currentProviderInstances = new Set(current.map(function (detail) { return detail.provider; }));
+        for (var _i = 0, _a = this.registry.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);
+            }
+        }
+    };
+    /**
+     * Handle provider mismatch by switching to the new provider and invalidating old tokens
+     * @param provider The new provider to switch to
+     */
+    EvmEventTracker.prototype.handleProviderMismatch = function (provider) {
+        // If this is a different provider, allow the switch
+        if (this.wallet.provider) {
+            // Clear any provider-specific state when switching
+            this.wallet.set('evm', { address: undefined, chainId: undefined, provider: provider });
+        }
+        else {
+            this.wallet.provider = provider;
+        }
+    };
+    return EvmEventTracker;
+}());
+export { EvmEventTracker };
+//# sourceMappingURL=EvmEventTracker.js.map