@formo/analytics 1.35.2 → 1.36.0

package/dist/esm/src/FormoAnalytics.js

@@ -45,29 +45,20 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { createStore } from "mipd";
-import { EVENTS_API_HOST, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_USER_ID_KEY, SESSION_TRAFFIC_SOURCE_KEY, ACTIVE_WALLET_KEY, ACTIVE_WALLET_TTL_MS, CONSENT_OPT_OUT_KEY, } from "./constants";
+import { EVENTS_API_HOST, EventType, LOCAL_ANONYMOUS_ID_KEY, SESSION_USER_ID_KEY, SESSION_TRAFFIC_SOURCE_KEY, ACTIVE_WALLET_KEY, CONSENT_OPT_OUT_KEY, } from "./constants";
 import { cookie, session, initStorageManager } from "./storage";
 import { getIdentityCookieDomain, getIdentityCookieSecurity, } from "./storage/cookiePolicy";
 import { EventManager } from "./event";
 import { EventQueue } from "./queue";
 import { logger, Logger } from "./logger";
 import { setConsentFlag, getConsentFlag, removeConsentFlag, } from "./consent";
-import { detectInjectedProviderInfo, isValidProvider } from "./provider";
 import { FormoAnalyticsSession, SESSION_WALLET_DETECTED_KEY, SESSION_WALLET_IDENTIFIED_KEY, } from "./session";
-import { SignatureStatus, TransactionStatus, WRAPPED_REQUEST_SYMBOL, WRAPPED_REQUEST_REF_SYMBOL, } from "./types";
 import { validateAddress, validateAndChecksumAddress } from "./utils/address";
-import { getTimezone } from "./utils/timezone";
-import { isLocalhost } from "./validators";
+import { TrackingPolicy, } from "./tracking/TrackingPolicy";
+import { WalletStateStore } from "./wallet/WalletStateStore";
+import { EvmProviderRegistry } from "./evm/EvmProviderRegistry";
+import { EvmEventTracker } from "./evm/EvmEventTracker";
+import { EvmRequestTracker } from "./evm/EvmRequestTracker";
 import { parseChainId } from "./utils/chain";
 import { WagmiEventHandler } from "./wagmi";
 import { isSolanaChainId } from "./solana";
@@ -77,11 +68,6 @@ import { identifyPrivyUser } from "./privy/utils";
 /**
  * Constants for provider switching reasons
  */
-var PROVIDER_SWITCH_REASONS = {
-    ADDRESS_MISMATCH: "Address mismatch indicates wallet switch",
-    NO_ACCOUNTS: "Current provider has no accounts",
-    CHECK_FAILED: "Could not check current provider accounts",
-};
 var FormoAnalytics = /** @class */ (function () {
     function FormoAnalytics(writeKey, options) {
         if (options === void 0) { options = {}; }
@@ -89,63 +75,7 @@ var FormoAnalytics = /** @class */ (function () {
         var _a, _b, _c;
         this.writeKey = writeKey;
         this.options = options;
-        // Per-chain namespace state - isolates EVM and Solana connection state
-        this._chainState = {
-            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
-         * This array contains all available providers with their metadata
-         */
-        this._providers = [];
-        /**
-         * Set of providers that have been tracked with event listeners
-         * This is separate from _providers because:
-         * - _providers contains all discovered providers (EIP-6963)
-         * - _trackedProviders contains only providers that have been set up with listeners
-         * - A provider can be discovered but not yet tracked (e.g., during initialization)
-         * - A provider can be tracked but later removed from discovery
-         */
-        this._trackedProviders = new Set();
-        // Flag to prevent concurrent processing of accountsChanged events
-        this._processingAccountsChanged = false;
-        // Set to efficiently track seen providers for deduplication and O(1) lookup
-        this._seenProviders = new Set();
         /**
          * Flag indicating if Wagmi mode is enabled
          * When true, EIP-1193 provider wrapping is skipped
@@ -198,6 +128,68 @@ var FormoAnalytics = /** @class */ (function () {
             enabled: ((_b = options.logger) === null || _b === void 0 ? void 0 : _b.enabled) || false,
             enabledLevels: ((_c = options.logger) === null || _c === void 0 ? void 0 : _c.levels) || [],
         });
+        this.evm = new EvmProviderRegistry({
+            activeProvider: function () { return _this.wallet.provider; },
+            activeChainId: function () { return _this.wallet.evmChainId; },
+            knownEvmAddress: function () { return _this.wallet.evmAddress; },
+            // Whether central state should follow a provider's chain report is the
+            // SDK's call, not the registry's: it depends on which namespace is
+            // active. Recording it per provider is unconditional; syncing is not.
+            onChainObserved: function (provider, chainId) {
+                // Guarded on EVM already being active. `set()` makes whichever
+                // namespace it touches active, so syncing unconditionally let a
+                // background EVM wallet's chain report steal the slot from a live
+                // Solana wallet, and every later page or track event was attributed
+                // to the wrong wallet entirely.
+                if (provider === _this.wallet.provider &&
+                    _this.wallet.activeNamespace === "evm" &&
+                    _this.wallet.evmChainId !== chainId) {
+                    _this.wallet.set("evm", { chainId: chainId });
+                }
+            },
+        });
+        this.wallet = new WalletStateStore({
+            isPersistedIdentityPurgeRequired: function () {
+                return _this.trackingPolicy.isPersistedIdentityPurgeRequired();
+            },
+            isPageExcluded: function () { return _this.trackingPolicy.isPageExcluded(); },
+            isTrackingSuppressed: function () { return _this.trackingPolicy.isTrackingSuppressed(); },
+            crossSubdomainCookies: function () { return _this.crossSubdomainCookies; },
+            providerChainId: function (provider) { return _this.evm.chainIdOf(provider); },
+            // A provider that stops being active 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.
+            onProviderDisplaced: function (previous) {
+                return _this.evmEvents.forgetAnnouncedConnect(previous);
+            },
+        });
+        this.evmRequests = new EvmRequestTracker(this.wallet, this.evm, {
+            isAutocaptureEnabled: function (t) { return _this.isAutocaptureEnabled(t); },
+            signature: function (params, properties) { return _this.signature(params, properties); },
+            transaction: function (params, properties) { return _this.transaction(params, properties); },
+        });
+        this.evmEvents = new EvmEventTracker(this.wallet, this.evm, {
+            isAutocaptureEnabled: function (t) { return _this.isAutocaptureEnabled(t); },
+            isTrackingSuppressed: function () { return _this.isTrackingSuppressed(); },
+            willTrackEvent: function (chainId) { return _this.willTrackEvent(chainId); },
+            isWagmiMode: function () { return _this.isWagmiMode; },
+            connect: function (params, properties) { return _this.connect(params, properties); },
+            disconnect: function (params) { return _this.disconnect(params); },
+            chain: function (params, properties) { return _this.chain(params, properties); },
+            detect: function (params) { return _this.detect(params); },
+            registerRequestListeners: function (provider) {
+                return _this.evmRequests.registerRequestListeners(provider);
+            },
+        });
+        this.trackingPolicy = new TrackingPolicy({
+            // All three read lazily. `options` is public and mutable, and the
+            // central chain moves as wallets connect and switch, so the policy
+            // must see both at decision time rather than at construction.
+            options: function () { return _this.options; },
+            hasOptedOut: function () { return _this.hasOptedOutTracking(); },
+            currentChainId: function () { return _this.currentChainId; },
+        });
         this.eventManager = new EventManager(new EventQueue(this.config.writeKey, {
             apiHost: options.apiHost || EVENTS_API_HOST,
             flushAt: options.flushAt,
@@ -233,7 +225,7 @@ var FormoAnalytics = /** @class */ (function () {
                 provider = window.ethereum;
             }
             if (provider) {
-                this.trackEIP1193Provider(provider);
+                this.evmEvents.trackEIP1193Provider(provider);
             }
         }
         // Initialize Solana manager if Solana options are provided
@@ -244,77 +236,73 @@ var FormoAnalytics = /** @class */ (function () {
         // Seed currentAddress/currentChainId from the persisted snapshot before
         // the first page hit queues so reload-time track()/page() carry the
         // wallet even before wagmi/EIP-1193 reconnection completes.
-        this.loadActiveWallet();
+        this.wallet.load();
         this.trackPageHit();
         this.trackPageHits();
     }
     Object.defineProperty(FormoAnalytics.prototype, "_provider", {
-        // EVM state accessors - EVM listener paths must use these instead of
-        // currentAddress/currentChainId to avoid cross-namespace reads.
         get: function () {
-            return this._chainState.evm.provider;
+            return this.wallet.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;
+            this.wallet.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;
+            return this.wallet.evmAddress;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(FormoAnalytics.prototype, "_evmChainId", {
         get: function () {
-            return this._chainState.evm.chainId;
+            return this.wallet.evmChainId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FormoAnalytics.prototype, "currentAddress", {
+        /**
+         * The wallet later events are attributed to, derived from whichever
+         * namespace last claimed the slot. Read by the wagmi and Privy
+         * integrations; the store is the only writer.
+         */
+        get: function () {
+            return this.wallet.address;
+        },
+        /**
+         * These stay writable.
+         *
+         * Both were public mutable fields, so a consumer assigning one is using a
+         * documented public API. Getter-only replacements would break that
+         * silently: TypeScript rejects the assignment, and plain JavaScript throws
+         * on an accessor with no setter. The writes forward into the store, which
+         * keeps a single owner without turning a refactor into a breaking change.
+         */
+        set: function (value) {
+            this.wallet.setActiveAddress(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FormoAnalytics.prototype, "currentChainId", {
+        get: function () {
+            return this.wallet.chainId;
+        },
+        set: function (value) {
+            this.wallet.setActiveChainId(value);
         },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Helper method to check if a provider is different from the currently active one
-     * @param provider The provider to check
-     * @returns true if there's a provider mismatch, false otherwise
-     */
-    FormoAnalytics.prototype.isProviderMismatch = function (provider) {
-        // Only consider it a mismatch if we have an active provider AND the provider is different
-        // This allows legitimate provider switching while preventing race conditions
-        return this._provider != null && this._provider !== provider;
-    };
     FormoAnalytics.init = function (writeKey, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var analytics, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var analytics, discovered;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         initStorageManager(writeKey);
                         analytics = new FormoAnalytics(writeKey, options);
@@ -323,20 +311,17 @@ var FormoAnalytics = /** @class */ (function () {
                         return [3 /*break*/, 5];
                     case 1:
                         if (!!analytics.isWagmiMode) return [3 /*break*/, 4];
-                        // Auto-detect wallet provider
-                        _a = analytics;
-                        return [4 /*yield*/, analytics.getProviders()];
+                        return [4 /*yield*/, analytics.evmEvents.getProviders()];
                     case 2:
-                        // Auto-detect wallet provider
-                        _a._providers = _b.sent();
-                        return [4 /*yield*/, analytics.detectWallets(analytics._providers)];
+                        discovered = _a.sent();
+                        return [4 /*yield*/, analytics.evmEvents.detectWallets(discovered)];
                     case 3:
-                        _b.sent();
-                        analytics.trackProviders(analytics._providers);
+                        _a.sent();
+                        analytics.evmEvents.trackProviders(discovered);
                         return [3 /*break*/, 5];
                     case 4:
                         logger.info("FormoAnalytics: Skipping provider detection (Wagmi mode)");
-                        _b.label = 5;
+                        _a.label = 5;
                     case 5: return [2 /*return*/, analytics];
                 }
             });
@@ -377,11 +362,7 @@ var FormoAnalytics = /** @class */ (function () {
         // address on subsequent track()/page() events for the rest of the
         // page lifetime, because they fall back to currentAddress. Keep the
         // EVM provider reference so tracking can resume on the next connect.
-        this.currentAddress = undefined;
-        this.currentChainId = undefined;
-        var evmProvider = this._chainState.evm.provider;
-        this._chainState = { evm: { provider: evmProvider }, solana: {} };
-        this._activeNamespace = undefined;
+        this.wallet.reset();
         cookie().remove(LOCAL_ANONYMOUS_ID_KEY);
         cookie().remove(SESSION_USER_ID_KEY);
         cookie().remove(SESSION_WALLET_DETECTED_KEY);
@@ -399,8 +380,19 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.cleanup = function () {
         logger.debug("FormoAnalytics: Cleaning up resources");
-        // Drop buffered events so a torn-down instance can't flush later.
-        this.eventManager.clear();
+        // Close the queue, don't just empty it. clear() only drops what is
+        // buffered at this instant; asynchronous work already in flight (event
+        // creation is async on every emit path) would still enqueue afterwards,
+        // and an empty queue flushes immediately. close() is terminal, so a
+        // continuation that outlives this instance cannot send with its stale
+        // options. See issue #339.
+        this.eventManager.close();
+        // Stop any receipt or batch-status polling: a torn-down instance must
+        // not keep asking a wallet about transactions nobody is listening for.
+        this.evmRequests.cleanup();
+        // Stop reacting to wallet announcements: a disposed instance must not
+        // wrap new providers or emit detect events.
+        this.evmEvents.cleanup();
         // Clean up Wagmi handler if present
         if (this.wagmiHandler) {
             this.wagmiHandler.cleanup();
@@ -413,9 +405,9 @@ var FormoAnalytics = /** @class */ (function () {
         }
         // Clean up EIP-1193 providers if not in Wagmi mode
         if (!this.isWagmiMode) {
-            for (var _i = 0, _a = Array.from(this._trackedProviders); _i < _a.length; _i++) {
+            for (var _i = 0, _a = this.evm.trackedProviders(); _i < _a.length; _i++) {
                 var provider = _a[_i];
-                this.untrackProvider(provider);
+                this.evmEvents.untrackProvider(provider);
             }
         }
         // Tear down page-hit hooks: remove window listeners and silence the
@@ -472,6 +464,11 @@ var FormoAnalytics = /** @class */ (function () {
                             logger.info("connect() skipped: tracking is suppressed for this visitor or environment");
                             return [2 /*return*/];
                         }
+                        // A new wallet now owns this namespace. Anything already tearing down
+                        // the previous session must not undo this. An emitted connect always
+                        // counts, even when the address is the one already there: a wallet that
+                        // disconnects and reconnects leaves identical state.
+                        this.wallet.observe(this.wallet.namespaceOf(chainId));
                         this.setChainState(chainId, { address: validAddress });
                         return [4 /*yield*/, this.trackEvent(EventType.CONNECT, {
                                 chainId: chainId,
@@ -495,7 +492,7 @@ var FormoAnalytics = /** @class */ (function () {
      */
     FormoAnalytics.prototype.disconnect = function (params, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var chainId, address, isSolana, providerInfo, disconnectProperties;
+            var chainId, address, isSolana, providerInfo, disconnectProperties, namespace, before;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -515,9 +512,25 @@ var FormoAnalytics = /** @class */ (function () {
                             providerName: providerInfo.name,
                             rdns: providerInfo.rdns,
                         })), properties);
+                        namespace = this.wallet.namespaceOf(chainId);
+                        // Every teardown announces itself here, before anything is awaited,
+                        // whichever path reached it - a provider event or a direct call from the
+                        // host app. A connect observation that began earlier is invalidated; one
+                        // that begins after this point is a genuine reconnect and still reports.
+                        this.wallet.beginDisconnect(namespace);
+                        before = this.wallet.snapshot(namespace);
                         return [4 /*yield*/, this.trackEvent(EventType.DISCONNECT, __assign(__assign({}, (chainId && { chainId: chainId })), (address && { address: address })), disconnectProperties, context, callback)];
                     case 1:
                         _a.sent();
+                        // If a wallet claimed this namespace while the event was being built, a
+                        // new session owns it and this cleanup is stale. Running it anyway would
+                        // wipe that session's state AND its reported-connect record, so a later
+                        // wallet signal would emit a second connect for a connection that is
+                        // already reported. See issue #344.
+                        if (!this.wallet.isUnchangedSince(namespace, before)) {
+                            logger.info("Disconnect: A new session claimed this namespace while the event was in flight; leaving its state intact");
+                            return [2 /*return*/];
+                        }
                         // Clear the disconnecting chain's namespace state.
                         // Per-chain isolation ensures a Solana disconnect never wipes EVM state (and vice versa).
                         this.clearChainState(chainId);
@@ -527,6 +540,78 @@ var FormoAnalytics = /** @class */ (function () {
             });
         });
     };
+    /** @see WalletStateStore.set */
+    FormoAnalytics.prototype.setChainState = function (namespaceOrChainId, update) {
+        this.wallet.set(namespaceOrChainId, update);
+    };
+    /** @see WalletStateStore.clear */
+    FormoAnalytics.prototype.clearChainState = function (namespaceOrChainId) {
+        this.wallet.clear(namespaceOrChainId);
+    };
+    /**
+     * Record validated wallet/chain state WITHOUT emitting an event.
+     *
+     * Integrations must call this on every connect / chain change / disconnect,
+     * even when the matching autocapture event is disabled, or the exclusion
+     * gate (which keys off the central chain, not the event payload) can be
+     * bypassed. Stays on the class because integrations bind to it.
+     * @see WalletStateStore.syncWalletState
+     */
+    FormoAnalytics.prototype.syncWalletState = function (params) {
+        this.wallet.syncWalletState(params);
+    };
+    /** @see WalletStateStore.clearProvider */
+    FormoAnalytics.prototype.clearActiveProvider = function () {
+        this.wallet.clearProvider();
+    };
+    /** @see WalletStateStore.backfill */
+    FormoAnalytics.prototype.backfillActiveWallet = function (address, chainId, provider) {
+        this.wallet.backfill(address, chainId, provider);
+    };
+    /** @see WalletStateStore.clearStaleEvmWalletOnSwitchWhileSuppressed */
+    FormoAnalytics.prototype.clearStaleEvmWalletOnSwitchWhileSuppressed = function (address) {
+        this.wallet.clearStaleEvmWalletOnSwitchWhileSuppressed(address);
+    };
+    /** @see EvmProviderRegistry.addListener */
+    FormoAnalytics.prototype.addProviderListener = function (provider, event, listener) {
+        this.evm.addListener(provider, event, listener);
+    };
+    /** @see EvmProviderRegistry.removeListeners */
+    FormoAnalytics.prototype.removeProviderListeners = function (provider) {
+        this.evm.removeListeners(provider);
+    };
+    /** @see EvmProviderRegistry.infoFor */
+    FormoAnalytics.prototype.getProviderInfo = function (provider) {
+        return this.evm.infoFor(provider);
+    };
+    /** @see EvmProviderRegistry.isWrapped */
+    FormoAnalytics.prototype.isProviderAlreadyWrapped = function (provider, currentRequest) {
+        return this.evm.isWrapped(provider, currentRequest);
+    };
+    /** @see EvmProviderRegistry.resolveChainId */
+    FormoAnalytics.prototype.resolveChainIdForProvider = function (provider) {
+        return this.evm.resolveChainId(provider);
+    };
+    /** @see EvmProviderRegistry.rememberChain */
+    FormoAnalytics.prototype.rememberProviderChain = function (provider, chainId) {
+        this.evm.rememberChain(provider, chainId);
+    };
+    /** @see EvmProviderRegistry.addressOf */
+    FormoAnalytics.prototype.getAddress = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.evm.addressOf(provider)];
+            });
+        });
+    };
+    /** @see EvmProviderRegistry.accountsOf */
+    FormoAnalytics.prototype.getAccounts = function (provider) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.evm.accountsOf(provider)];
+            });
+        });
+    };
     /**
      * Emits a chain network change event.
      * @param {ChainID} params.chainId
@@ -668,14 +753,14 @@ var FormoAnalytics = /** @class */ (function () {
                         // valid (activating a Solana wallet while an excluded EVM chain id is
                         // still current). By the time the Privy path reaches this guard it has
                         // already reconciled, so each inner identify is judged on the right chain.
-                        if (this.isTrackingSuppressed() || this.isCurrentChainExcluded()) {
+                        if (this.isTrackingSuppressed() || this.trackingPolicy.isChainExcluded()) {
                             logger.info("identify() skipped: tracking is suppressed for this visitor, environment, or chain");
                             return [2 /*return*/];
                         }
                         if (!!params) return [3 /*break*/, 12];
                         // If no params provided, auto-identify
-                        logger.info("Auto-identifying with providers:", this._providers.map(function (p) { return p.info.name; }));
-                        _i = 0, _a = this._providers;
+                        logger.info("Auto-identifying with providers:", this.evm.all.map(function (p) { return p.info.name; }));
+                        _i = 0, _a = this.evm.all;
                         _d.label = 3;
                     case 3:
                         if (!(_i < _a.length)) return [3 /*break*/, 11];
@@ -747,8 +832,7 @@ var FormoAnalytics = /** @class */ (function () {
                         // attribution. Gating address and userId together prevents leaving the
                         // active address paired with a different wallet's user id.
                         if (setActive !== false) {
-                            this.currentAddress = validAddress;
-                            this.persistActiveWallet();
+                            this.wallet.setActiveAddress(validAddress);
                             if (userId) {
                                 this.currentUserId = userId;
                                 domain = getIdentityCookieDomain(this.crossSubdomainCookies);
@@ -835,8 +919,7 @@ var FormoAnalytics = /** @class */ (function () {
             return;
         var currentIsSolana = isSolanaChainId(this.currentChainId);
         if (walletIsSolana !== currentIsSolana) {
-            this.currentChainId = undefined;
-            this.persistActiveWallet();
+            this.wallet.setActiveChainId(undefined);
         }
     };
     /**
@@ -952,1256 +1035,161 @@ var FormoAnalytics = /** @class */ (function () {
     /*
       SDK tracking and event listener functions
     */
+    FormoAnalytics.prototype.onLocationChange = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            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*/];
+            });
+        });
+    };
+    FormoAnalytics.prototype.trackPageHits = function () {
+        var _this = this;
+        // Install a single, instance-agnostic wrapper around history.pushState /
+        // replaceState so concurrent SDK instances (React Strict Mode, HMR) don't
+        // each stack their own wrapper - which would dispatch N synthetic events
+        // per navigation and produce O(N^2) onLocationChange calls. The wrapper
+        // dispatches once; per-instance bookkeeping is done by per-instance
+        // listeners that each register/unregister themselves.
+        FormoAnalytics.installHistoryHooksOnce();
+        this._onPopStateListener = function () { return _this.onLocationChange(); };
+        this._onLocationChangeListener = function () { return _this.onLocationChange(); };
+        window.addEventListener("popstate", this._onPopStateListener);
+        window.addEventListener("locationchange", this._onLocationChangeListener);
+    };
     /**
-     * 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
+     * Wrap history.pushState / replaceState exactly once per `history` object,
+     * regardless of how many SDK instances are constructed. Uses a Symbol
+     * marker so we recognize our own wrapper across module reloads in HMR.
      */
-    FormoAnalytics.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.isWagmiMode) {
-            logger.debug("trackEIP1193Provider: Skipping EIP-1193 provider tracking (Wagmi mode - using connector system instead)");
+    FormoAnalytics.installHistoryHooksOnce = function () {
+        if (typeof history === "undefined" || typeof window === "undefined")
             return;
-        }
-        try {
-            // Validate provider exists and has required methods
-            if (!isValidProvider(provider)) {
-                logger.warn("trackEIP1193Provider: Invalid provider - missing required methods");
-                return;
-            }
-            if (this._trackedProviders.has(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.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)");
-            }
-            // 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._trackedProviders.add(provider);
-        }
-        catch (error) {
-            logger.error("Error tracking provider:", error);
-        }
-    };
-    FormoAnalytics.prototype.trackProviders = function (providers) {
-        try {
-            for (var _i = 0, providers_1 = providers; _i < providers_1.length; _i++) {
-                var eip6963ProviderDetail = providers_1[_i];
-                var provider = eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.provider;
-                if (provider && !this._trackedProviders.has(provider)) {
-                    this.trackEIP1193Provider(provider);
-                }
+        var marker = Symbol.for("formo.historyWrapped");
+        if (history[marker])
+            return;
+        history[marker] = true;
+        var dispatch = function () { return window.dispatchEvent(new window.Event("locationchange")); };
+        var oldPushState = history.pushState;
+        history.pushState = function pushState() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
             }
-        }
-        catch (error) {
-            logger.error("Failed to track EIP-6963 providers during initialization:", error);
-        }
-    };
-    FormoAnalytics.prototype.addProviderListener = function (provider, event, listener) {
-        var map = this._providerListenersMap.get(provider) || {};
-        map[event] = listener;
-        this._providerListenersMap.set(provider, map);
-    };
-    FormoAnalytics.prototype.registerAccountsChangedListener = function (provider) {
-        var _this = this;
-        logger.info("registerAccountsChangedListener");
-        var listener = function () {
+            var ret = oldPushState.apply(this, args);
+            dispatch();
+            return ret;
+        };
+        var oldReplaceState = history.replaceState;
+        history.replaceState = function replaceState() {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            return _this.onAccountsChanged(provider, args[0]);
+            var ret = oldReplaceState.apply(this, args);
+            dispatch();
+            return ret;
         };
-        provider.on("accountsChanged", listener);
-        this.addProviderListener(provider, "accountsChanged", listener);
     };
-    FormoAnalytics.prototype.onAccountsChanged = function (provider, accounts) {
+    FormoAnalytics.prototype.trackPageHit = function (category, name, properties, context, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.shouldTrack()) {
+                    logger.info("Track page hit: Skipping event due to tracking configuration");
+                    return [2 /*return*/];
+                }
+                setTimeout(function () {
+                    // Drop in-flight page hits from an SDK instance that was torn down
+                    // between scheduling and firing (e.g. provider remount in React Strict
+                    // Mode / HMR). Otherwise the orphan instance would queue a page event
+                    // here with its stale, never-populated `currentAddress`.
+                    if (_this._pageHooksDisposed)
+                        return;
+                    (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var e_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, this.trackEvent(EventType.PAGE, {
+                                            category: category,
+                                            name: name,
+                                        }, properties, context, callback)];
+                                case 1:
+                                    _a.sent();
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    e_2 = _a.sent();
+                                    logger.error("Formo: Failed to track page hit", e_2);
+                                    return [3 /*break*/, 3];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); })();
+                }, 300);
+                return [2 /*return*/];
+            });
+        });
+    };
+    FormoAnalytics.prototype.trackEvent = function (type, payload, properties, context, callback) {
         return __awaiter(this, void 0, void 0, function () {
+            var error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        logger.info("onAccountsChanged", accounts);
-                        // Prevent concurrent processing of accountsChanged events to avoid race conditions
-                        if (this._processingAccountsChanged) {
-                            logger.debug("OnAccountsChanged: Already processing accountsChanged, skipping", {
-                                provider: this.getProviderInfo(provider).name,
-                            });
+                        _a.trys.push([0, 2, , 3]);
+                        // 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*/];
                         }
-                        this._processingAccountsChanged = true;
-                        _a.label = 1;
+                        return [4 /*yield*/, this.eventManager.addEvent(__assign(__assign({ type: type }, payload), { properties: properties, context: context, callback: callback }), this.currentAddress, this.currentUserId)];
                     case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, this._handleAccountsChanged(provider, accounts)];
-                    case 2:
                         _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        this._processingAccountsChanged = false;
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        logger.error("Error tracking event:", error_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Handles changes to the accounts of a given EIP-1193 provider.
+     * Visitor-level tracking suppression.
      *
-     * @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.
+     * True when the SDK must not persist identity/session/chain state or send
+     * events for this visitor. Public entry points that write state before
+     * reaching the `shouldTrack()` gate (identify / connect / detect) check this
+     * first, so a suppressed visitor leaves no cookies or session state.
      *
-     * 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.
+     * The rule lives in `TrackingPolicy`; this stays on the class because it is
+     * part of the surface integrations bind to.
+     * @internal Also read by `identifyPrivyUser` (via a structural cast) so the
+     * Privy sync skips chain reconciliation and emission for suppressed visitors.
      */
-    FormoAnalytics.prototype._handleAccountsChanged = function (provider, accounts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_1, address, currentStoredAddress, newProviderAddress, activeProviderAccounts, error_2, nextChainId, wasDisconnected, providerInfo, effectiveChainId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(accounts.length === 0)) return [3 /*break*/, 9];
-                        if (!(this._provider === provider)) return [3 /*break*/, 7];
-                        logger.info("OnAccountsChanged: Detecting disconnect, current state:", {
-                            evmAddress: this._evmAddress,
-                            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:
-                        _a.trys.push([1, 3, , 4]);
-                        // Pass EVM state explicitly to ensure we have the data for the disconnect event
-                        return [4 /*yield*/, this.disconnect({
-                                chainId: this._evmChainId,
-                                address: this._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)");
-                        // Still clear state even if not tracking the event
-                        this.clearChainState('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._provider && this._provider !== provider)) return [3 /*break*/, 25];
-                        currentStoredAddress = this._evmAddress;
-                        newProviderAddress = validateAndChecksumAddress(address);
-                        logger.info("OnAccountsChanged: Different provider attempting to connect", {
-                            activeProvider: this.getProviderInfo(this._provider).name,
-                            eventProvider: this.getProviderInfo(provider).name,
-                            currentStoredAddress: currentStoredAddress,
-                            newProviderAddress: newProviderAddress,
-                        });
-                        _a.label = 10;
-                    case 10:
-                        _a.trys.push([10, 21, , 25]);
-                        return [4 /*yield*/, this.getAccounts(this._provider)];
-                    case 11:
-                        activeProviderAccounts = _a.sent();
-                        logger.info("OnAccountsChanged: Checking current provider accounts", {
-                            activeProvider: this.getProviderInfo(this._provider).name,
-                            accountsLength: activeProviderAccounts
-                                ? activeProviderAccounts.length
-                                : 0,
-                            accounts: activeProviderAccounts,
-                        });
-                        if (!(activeProviderAccounts && activeProviderAccounts.length > 0)) return [3 /*break*/, 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.getProviderInfo(this._provider).name,
-                            eventProvider: this.getProviderInfo(provider).name,
-                            currentAddress: currentStoredAddress,
-                            newAddress: newProviderAddress,
-                            reason: PROVIDER_SWITCH_REASONS.ADDRESS_MISMATCH,
-                        });
-                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.disconnect({
-                                chainId: this._evmChainId,
-                                address: this._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.clearChainState('evm');
-                        _a.label = 14;
-                    case 14:
-                        // Clear state and let the new provider become active
-                        this.clearActiveProvider();
-                        return [3 /*break*/, 16];
-                    case 15:
-                        logger.info("OnAccountsChanged: Current provider still has accounts and same address, ignoring new provider", {
-                            activeProvider: this.getProviderInfo(this._provider).name,
-                            eventProvider: this.getProviderInfo(provider).name,
-                            activeProviderAccountsCount: activeProviderAccounts.length,
-                            currentAddress: currentStoredAddress,
-                            newAddress: newProviderAddress,
-                        });
-                        return [2 /*return*/];
-                    case 16: return [3 /*break*/, 20];
-                    case 17:
-                        logger.info("OnAccountsChanged: Current provider has no accounts, switching to new provider", {
-                            oldProvider: this.getProviderInfo(this._provider).name,
-                            newProvider: this.getProviderInfo(provider).name,
-                            reason: PROVIDER_SWITCH_REASONS.NO_ACCOUNTS,
-                        });
-                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 19];
-                        return [4 /*yield*/, this.disconnect({
-                                chainId: this._evmChainId,
-                                address: this._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.clearChainState('evm');
-                        _a.label = 20;
-                    case 20: return [3 /*break*/, 25];
-                    case 21:
-                        error_2 = _a.sent();
-                        logger.warn("OnAccountsChanged: Could not check current provider accounts, switching to new provider", {
-                            error: error_2 instanceof Error ? error_2.message : String(error_2),
-                            errorType: error_2 instanceof Error ? error_2.constructor.name : typeof error_2,
-                            oldProvider: this._provider
-                                ? this.getProviderInfo(this._provider).name
-                                : "unknown",
-                            newProvider: this.getProviderInfo(provider).name,
-                            reason: PROVIDER_SWITCH_REASONS.CHECK_FAILED,
-                        });
-                        if (!this.isAutocaptureEnabled("disconnect")) return [3 /*break*/, 23];
-                        return [4 /*yield*/, this.disconnect({
-                                chainId: this._evmChainId,
-                                address: this._evmAddress,
-                            })];
-                    case 22:
-                        _a.sent();
-                        return [3 /*break*/, 24];
-                    case 23:
-                        logger.debug("OnAccountsChanged: Disconnect event skipped for failed provider check (autocapture.disconnect: false)");
-                        // Still clear state even if not tracking the event
-                        this.clearChainState('evm');
-                        _a.label = 24;
-                    case 24: return [3 /*break*/, 25];
-                    case 25:
-                        // Set provider if none exists (first connection)
-                        if (!this._provider) {
-                            this._provider = provider;
-                        }
-                        // If both the provider and address are the same, no-op
-                        if (this._provider === provider && address === this._evmAddress) {
-                            return [2 /*return*/];
-                        }
-                        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
-                        // NOT suppression - it still updates state so currentChainId can gate
-                        // events.)
-                        if (this.isTrackingSuppressed()) {
-                            this.clearStaleEvmWalletOnSwitchWhileSuppressed(address);
-                        }
-                        else {
-                            this.setChainState('evm', { address: address, chainId: nextChainId });
-                        }
-                        providerInfo = this.getProviderInfo(provider);
-                        effectiveChainId = nextChainId || 0;
-                        if (this.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.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*/];
-                }
-            });
-        });
-    };
-    FormoAnalytics.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.addProviderListener(provider, "chainChanged", listener);
-    };
-    FormoAnalytics.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.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,
-                            })];
-                    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,
-                        });
-                        _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.
-     */
-    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");
-        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.addProviderListener(provider, "connect", listener);
-    };
-    FormoAnalytics.prototype.registerDisconnectListener = function (provider) {
-        var _this = this;
-        logger.info("registerDisconnectListener");
-        var listener = function (_error) { return __awaiter(_this, void 0, void 0, function () {
-            var e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this._provider !== provider)
-                            return [2 /*return*/];
-                        // 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,
-                        });
-                        if (!this.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.disconnect({
-                                chainId: this._evmChainId,
-                                address: this._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_2 = _a.sent();
-                        logger.error("Error during disconnect in disconnect listener", e_2);
-                        return [3 /*break*/, 4];
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        logger.debug("OnDisconnect: Disconnect event skipped (autocapture.disconnect: false)");
-                        // Still clear state even if not tracking the event
-                        this.clearChainState('evm');
-                        _a.label = 6;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); };
-        provider.on("disconnect", listener);
-        this.addProviderListener(provider, "disconnect", listener);
-    };
-    FormoAnalytics.prototype.onConnected = function (provider, connection) {
-        return __awaiter(this, void 0, void 0, function () {
-            var chainId, address, wasDisconnected, isActiveProvider, providerInfo, effectiveChainId, providerInfo, e_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger.info("onConnected", connection);
-                        _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.rememberProviderChain(provider, chainId);
-                        return [4 /*yield*/, this.getAddress(provider)];
-                    case 2:
-                        address = _a.sent();
-                        if (chainId && address) {
-                            wasDisconnected = !this._evmAddress;
-                            // Set provider if none exists
-                            if (!this._provider) {
-                                this._provider = provider;
-                            }
-                            isActiveProvider = this._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.isTrackingSuppressed()) {
-                                    this.clearStaleEvmWalletOnSwitchWhileSuppressed(address);
-                                }
-                                else {
-                                    this.setChainState('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._evmAddress &&
-                                this.shouldReportConnect(provider, address)) {
-                                providerInfo = this.getProviderInfo(provider);
-                                effectiveChainId = chainId || 0;
-                                if (this.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.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.getProviderInfo(provider);
-                                logger.debug("OnConnected: Skipping connect event for non-active provider", {
-                                    chainId: chainId,
-                                    providerName: providerInfo.name,
-                                    rdns: providerInfo.rdns,
-                                    isActiveProvider: isActiveProvider,
-                                    activeProviderInfo: this._provider
-                                        ? this.getProviderInfo(this._provider)
-                                        : null,
-                                });
-                            }
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_3 = _a.sent();
-                        logger.error("Error handling connect event", e_3);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    FormoAnalytics.prototype.registerRequestListeners = function (provider) {
-        var _this = this;
-        logger.info("registerRequestListeners");
-        if (!provider) {
-            logger.error("Provider not found for request (signature, transaction) tracking");
-            return;
-        }
-        // Check if the provider is already wrapped with our SDK's wrapper
-        var currentRequest = provider.request;
-        if (this.isProviderAlreadyWrapped(provider, currentRequest)) {
-            logger.info("Provider already wrapped with our SDK; skipping request wrapping.");
-            return;
-        }
-        var request = provider.request.bind(provider);
-        var wrappedRequest = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-            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*/, 4];
-                        if (!this.isAutocaptureEnabled("signature")) {
-                            logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
-                            return [2 /*return*/, request({ method: method, params: params })];
-                        }
-                        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) {
-                                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*/];
-                                }
-                            });
-                        }); })();
-                        _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) {
-                                    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*/, response_1];
-                    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) {
-                                    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*/];
-                                    }
-                                });
-                            }); })();
-                        }
-                        throw error_4;
-                    case 4:
-                        if (!(Array.isArray(params) &&
-                            method === "eth_sendTransaction" &&
-                            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_7;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 3, , 4]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
-                                    case 1:
-                                        payload = _a.sent();
-                                        return [4 /*yield*/, this.transaction(__assign({ status: TransactionStatus.STARTED }, payload))];
-                                    case 2:
-                                        _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 = 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_8;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 3, , 4]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
-                                    case 1:
-                                        payload = _a.sent();
-                                        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*/, 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 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_9;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            _a.trys.push([0, 3, , 4]);
-                                            return [4 /*yield*/, this.buildTransactionEventPayload(params, provider, txChainId_1)];
-                                        case 1:
-                                            payload = _a.sent();
-                                            return [4 /*yield*/, this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload))];
-                                        case 2:
-                                            _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_5;
-                    case 8: return [2 /*return*/, request({ method: method, params: params })];
-                }
-            });
-        }); };
-        // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
-        wrappedRequest[WRAPPED_REQUEST_SYMBOL] = true;
-        provider[WRAPPED_REQUEST_REF_SYMBOL] =
-            wrappedRequest;
-        try {
-            // Attempt to assign the wrapped request function (rely on try-catch for mutability errors)
-            provider.request = wrappedRequest;
-        }
-        catch (e) {
-            logger.warn("Failed to wrap provider.request; skipping", e);
-        }
-    };
-    FormoAnalytics.prototype.onLocationChange = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            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*/];
-            });
-        });
-    };
-    FormoAnalytics.prototype.trackPageHits = function () {
-        var _this = this;
-        // Install a single, instance-agnostic wrapper around history.pushState /
-        // replaceState so concurrent SDK instances (React Strict Mode, HMR) don't
-        // each stack their own wrapper - which would dispatch N synthetic events
-        // per navigation and produce O(N^2) onLocationChange calls. The wrapper
-        // dispatches once; per-instance bookkeeping is done by per-instance
-        // listeners that each register/unregister themselves.
-        FormoAnalytics.installHistoryHooksOnce();
-        this._onPopStateListener = function () { return _this.onLocationChange(); };
-        this._onLocationChangeListener = function () { return _this.onLocationChange(); };
-        window.addEventListener("popstate", this._onPopStateListener);
-        window.addEventListener("locationchange", this._onLocationChangeListener);
-    };
-    /**
-     * Wrap history.pushState / replaceState exactly once per `history` object,
-     * regardless of how many SDK instances are constructed. Uses a Symbol
-     * marker so we recognize our own wrapper across module reloads in HMR.
-     */
-    FormoAnalytics.installHistoryHooksOnce = function () {
-        if (typeof history === "undefined" || typeof window === "undefined")
-            return;
-        var marker = Symbol.for("formo.historyWrapped");
-        if (history[marker])
-            return;
-        history[marker] = true;
-        var dispatch = function () { return window.dispatchEvent(new window.Event("locationchange")); };
-        var oldPushState = history.pushState;
-        history.pushState = function pushState() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var ret = oldPushState.apply(this, args);
-            dispatch();
-            return ret;
-        };
-        var oldReplaceState = history.replaceState;
-        history.replaceState = function replaceState() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var ret = oldReplaceState.apply(this, args);
-            dispatch();
-            return ret;
-        };
-    };
-    FormoAnalytics.prototype.trackPageHit = function (category, name, properties, context, callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (!this.shouldTrack()) {
-                    logger.info("Track page hit: Skipping event due to tracking configuration");
-                    return [2 /*return*/];
-                }
-                setTimeout(function () {
-                    // Drop in-flight page hits from an SDK instance that was torn down
-                    // between scheduling and firing (e.g. provider remount in React Strict
-                    // Mode / HMR). Otherwise the orphan instance would queue a page event
-                    // here with its stale, never-populated `currentAddress`.
-                    if (_this._pageHooksDisposed)
-                        return;
-                    (function () { return __awaiter(_this, void 0, void 0, function () {
-                        var e_10;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    _a.trys.push([0, 2, , 3]);
-                                    return [4 /*yield*/, this.trackEvent(EventType.PAGE, {
-                                            category: category,
-                                            name: name,
-                                        }, properties, context, callback)];
-                                case 1:
-                                    _a.sent();
-                                    return [3 /*break*/, 3];
-                                case 2:
-                                    e_10 = _a.sent();
-                                    logger.error("Formo: Failed to track page hit", e_10);
-                                    return [3 /*break*/, 3];
-                                case 3: return [2 /*return*/];
-                            }
-                        });
-                    }); })();
-                }, 300);
-                return [2 /*return*/];
-            });
-        });
-    };
-    FormoAnalytics.prototype.trackEvent = function (type, payload, properties, context, callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_6;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        // 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*/];
-                        }
-                        return [4 /*yield*/, this.eventManager.addEvent(__assign(__assign({ type: type }, payload), { properties: properties, context: context, callback: callback }), this.currentAddress, this.currentUserId)];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        error_6 = _a.sent();
-                        logger.error("Error tracking event:", error_6);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Visitor-level tracking suppression.
-     *
-     * Returns true when the SDK must not persist any identity/session/chain
-     * state or send any events for this visitor - i.e. an explicit opt-out or a
-     * jurisdiction/timezone exclusion. Public entry points that write state
-     * before reaching the `shouldTrack()` event gate (identify/connect/detect)
-     * check this first so suppressed visitors leave no cookies or session state.
-     * @returns {boolean} True if all tracking and persistence must be suppressed
-     * @internal Also read by `identifyPrivyUser` (via a structural cast) so the
-     * Privy sync skips chain reconciliation and emission for suppressed visitors.
-     */
-    FormoAnalytics.prototype.isTrackingSuppressed = function () {
-        return this.hasOptedOutTracking() || this.isCurrentEnvironmentExcluded();
-    };
-    /**
-     * Whether the current chain id is in `tracking.excludeChains`.
-     *
-     * Split out from `shouldTrack()` so `identify()` can check it *before*
-     * mutating identity state. `trackEvent()` drops an excluded event silently
-     * and returns void, but `identify()` marks the wallet as identified first, so
-     * without this guard an identify on an excluded chain is dedup-marked and
-     * then discarded, and the wallet never re-emits for the rest of the session
-     * even after switching to an allowed chain. On the Privy path that loses the
-     * user's whole cluster at once rather than a single wallet.
-     *
-     * Mirrors the chain rule in `shouldTrack()`: only applies when `tracking` is
-     * an options object with `excludeChains` set, and only once a chain id is
-     * known.
-     */
-    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;
-        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
-     * timezone, the current hostname, or the current pathname matches a
-     * configured exclusion.
-     *
-     * Timezone is visitor/session-level (stable for the session); host/path are
-     * current-page-level and transient - if a SPA navigates to an allowed path,
-     * tracking resumes for future actions. Used as the "do not write identity or
-     * send events" gate at every entry point that would persist state before the
-     * `shouldTrack()` event gate.
-     * @returns {boolean} True if the current environment is excluded
-     */
-    FormoAnalytics.prototype.isCurrentEnvironmentExcluded = function () {
-        return (this.isTimezoneExcluded() ||
-            this.isHostExcluded() ||
-            this.isPathExcluded());
-    };
-    /**
-     * Whether the current hostname matches a configured `tracking.excludeHosts`
-     * entry (exact match). Current-page-level - see isCurrentEnvironmentExcluded.
-     * @returns {boolean} True if the current hostname is excluded
-     */
-    FormoAnalytics.prototype.isHostExcluded = function () {
-        var tracking = this.options.tracking;
-        if (tracking === null ||
-            typeof tracking !== "object" ||
-            Array.isArray(tracking)) {
-            return false;
-        }
-        if (typeof window === "undefined") {
-            return false;
-        }
-        var _a = tracking.excludeHosts, excludeHosts = _a === void 0 ? [] : _a;
-        return excludeHosts.includes(window.location.hostname);
-    };
-    /**
-     * Whether the current pathname matches a configured `tracking.excludePaths`
-     * entry (exact match). Current-page-level - see isCurrentEnvironmentExcluded.
-     * @returns {boolean} True if the current pathname is excluded
-     */
-    FormoAnalytics.prototype.isPathExcluded = function () {
-        var tracking = this.options.tracking;
-        if (tracking === null ||
-            typeof tracking !== "object" ||
-            Array.isArray(tracking)) {
-            return false;
-        }
-        if (typeof window === "undefined") {
-            return false;
-        }
-        var _a = tracking.excludePaths, excludePaths = _a === void 0 ? [] : _a;
-        return excludePaths.includes(window.location.pathname);
-    };
-    /**
-     * Whether the current call is in a visitor-level suppression state - opt-out
-     * or excluded timezone - for which any persisted identity cookie should be
-     * actively purged (not merely skipped). Host/path exclusions are
-     * deliberately excluded here: they are transient current-page states, so a
-     * cookie legitimately written on an allowed page must survive a visit to an
-     * excluded route.
-     * @returns {boolean} True if persisted identity must be purged
-     */
-    FormoAnalytics.prototype.isPersistedIdentityPurgeRequired = function () {
-        return this.hasOptedOutTracking() || this.isTimezoneExcluded();
-    };
-    /**
-     * Whether the visitor's browser-resolved timezone matches a configured
-     * `tracking.excludeTimezones` entry (case-insensitive). Client-side and
-     * best-effort - see TrackingOptions.excludeTimezones.
-     * @returns {boolean} True if the current timezone is excluded
-     */
-    FormoAnalytics.prototype.isTimezoneExcluded = function () {
-        var tracking = this.options.tracking;
-        if (tracking === null ||
-            typeof tracking !== "object" ||
-            Array.isArray(tracking)) {
-            return false;
-        }
-        var _a = tracking.excludeTimezones, excludeTimezones = _a === void 0 ? [] : _a;
-        if (excludeTimezones.length === 0) {
-            return false;
-        }
-        var timezone = getTimezone();
-        if (!timezone) {
-            return false;
-        }
-        var lowerTimezone = timezone.toLowerCase();
-        return excludeTimezones.some(function (tz) { return typeof tz === "string" && tz.toLowerCase() === lowerTimezone; });
+    FormoAnalytics.prototype.isTrackingSuppressed = function () {
+        return this.trackingPolicy.isTrackingSuppressed();
     };
-    /**
-     * Determines if tracking should be enabled based on configuration and consent
-     * @returns {boolean} True if tracking should be enabled
-     */
+    /** @see TrackingPolicy.shouldTrack */
     FormoAnalytics.prototype.shouldTrack = function (eventChainId) {
-        // First check if user has opted out of tracking
-        if (this.hasOptedOutTracking()) {
-            return false;
-        }
-        // Check if tracking is explicitly provided as a boolean
-        if (typeof this.options.tracking === "boolean") {
-            return this.options.tracking;
-        }
-        // Handle object configuration with exclusion rules
-        if (this.options.tracking !== null &&
-            typeof this.options.tracking === "object" &&
-            !Array.isArray(this.options.tracking)) {
-            var _a = this.options.tracking.excludeChains, excludeChains = _a === void 0 ? [] : _a;
-            // Environment exclusions (timezone / host / path) - no identify / connect
-            // / track events while excluded. Host/path are exact-match.
-            if (this.isCurrentEnvironmentExcluded()) {
-                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;
-        }
-        // Default behavior: track everywhere except localhost
-        return !isLocalhost();
+        return this.trackingPolicy.shouldTrack({ chainId: eventChainId });
     };
     /**
      * Check if a specific wallet event type is enabled for autocapture
@@ -2209,184 +1197,18 @@ var FormoAnalytics = /** @class */ (function () {
      * @returns {boolean} True if the event type should be autocaptured
      */
     FormoAnalytics.prototype.isAutocaptureEnabled = function (eventType) {
-        // If no configuration provided, default to enabled
-        if (this.options.autocapture === undefined) {
-            return true;
-        }
-        // If boolean, return that value for all events
-        if (typeof this.options.autocapture === "boolean") {
-            return this.options.autocapture;
-        }
-        // If it's an object, check the specific event configuration
-        if (this.options.autocapture !== null &&
-            typeof this.options.autocapture === "object") {
-            var eventConfig = this.options.autocapture[eventType];
-            // Default to true if not explicitly set to false
-            return eventConfig !== false;
-        }
-        // Default to enabled if no specific configuration
-        return true;
-    };
-    /*
-      Utility functions
-    */
-    /**
-     * Get provider information for a given provider
-     * @param provider The provider to get info for
-     * @returns Provider information
-     */
-    FormoAnalytics.prototype.getProviderInfo = function (provider) {
-        // First check if provider is in our EIP-6963 providers list
-        var eip6963Provider = this._providers.find(function (p) { return p.provider === provider; });
-        if (eip6963Provider) {
-            return {
-                name: eip6963Provider.info.name,
-                rdns: eip6963Provider.info.rdns,
-            };
-        }
-        // Fallback to injected provider detection
-        var injectedInfo = detectInjectedProviderInfo(provider);
-        return {
-            name: injectedInfo.name,
-            rdns: injectedInfo.rdns,
-        };
-    };
-    FormoAnalytics.prototype.getProviders = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var store, providers, injected_1, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
-            var _this = this;
-            return __generator(this, function (_a) {
-                store = createStore();
-                providers = store.getProviders();
-                store.subscribe(function (providerDetails) {
-                    providers = providerDetails;
-                    // Process newly added providers with proper deduplication
-                    var newlyAddedDetails = providerDetails.filter(function (detail) {
-                        var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
-                        return provider && !_this._seenProviders.has(provider);
-                    });
-                    // Add new providers to the array without overwriting existing ones
-                    for (var _i = 0, newlyAddedDetails_1 = newlyAddedDetails; _i < newlyAddedDetails_1.length; _i++) {
-                        var detail = newlyAddedDetails_1[_i];
-                        _this.safeAddProviderDetail(detail);
-                    }
-                    // Track listeners for newly discovered providers only
-                    var newDetails = providerDetails.filter(function (detail) {
-                        var p = detail === null || detail === void 0 ? void 0 : detail.provider;
-                        return !!p && !_this._trackedProviders.has(p);
-                    });
-                    if (newDetails.length > 0) {
-                        _this.trackProviders(newDetails);
-                        // Detect newly discovered wallets (session de-dupes) with error handling
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var e_11;
-                            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_11 = _a.sent();
-                                        logger.error("Formo: Failed to detect wallets", e_11);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                    }
-                    // Clean up providers that are no longer available
-                    _this.cleanupUnavailableProviders();
-                });
-                // Fallback to injected provider if no providers are found
-                if (providers.length === 0) {
-                    injected_1 = typeof window !== "undefined" ? window.ethereum : undefined;
-                    if (injected_1) {
-                        // If we have already detected and cached the injected provider, and it's the same instance, return the cached result
-                        if (this._injectedProviderDetail &&
-                            this._injectedProviderDetail.provider === injected_1) {
-                            // Ensure it's tracked
-                            if (!this._trackedProviders.has(injected_1)) {
-                                this.trackEIP1193Provider(injected_1);
-                            }
-                            // Merge with existing providers instead of overwriting
-                            if (!this._providers.some(function (existing) { return existing.provider === injected_1; })) {
-                                this._providers = __spreadArray(__spreadArray([], this._providers, true), [
-                                    this._injectedProviderDetail,
-                                ], false);
-                            }
-                            return [2 /*return*/, this._providers];
-                        }
-                        // Re-check if the injected provider is already tracked just before tracking
-                        if (!this._trackedProviders.has(injected_1)) {
-                            this.trackEIP1193Provider(injected_1);
-                        }
-                        injectedProviderInfo = detectInjectedProviderInfo(injected_1);
-                        injectedDetail = {
-                            provider: injected_1,
-                            info: injectedProviderInfo,
-                        };
-                        // Cache the detected injected provider detail
-                        this._injectedProviderDetail = injectedDetail;
-                        // Merge with existing providers instead of overwriting
-                        this.safeAddProviderDetail(injectedDetail);
-                    }
-                    return [2 /*return*/, this._providers];
-                }
-                uniqueProviders = providers.filter(function (detail) {
-                    var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
-                    return provider && !_this._seenProviders.has(provider);
-                });
-                // Add to seen providers and instances, ensuring no duplicates in _providers
-                for (_i = 0, uniqueProviders_1 = uniqueProviders; _i < uniqueProviders_1.length; _i++) {
-                    detail = uniqueProviders_1[_i];
-                    this.safeAddProviderDetail(detail);
-                }
-                return [2 /*return*/, this._providers];
-            });
-        });
+        return this.trackingPolicy.isAutocaptureEnabled(eventType);
     };
     Object.defineProperty(FormoAnalytics.prototype, "providers", {
+        /*
+          Utility functions
+        */
         get: function () {
-            return this._providers;
+            return this.evm.all;
         },
         enumerable: false,
         configurable: true
     });
-    FormoAnalytics.prototype.detectWallets = function (providers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _i, providers_2, eip6963ProviderDetail, err_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        _i = 0, providers_2 = providers;
-                        _a.label = 1;
-                    case 1:
-                        if (!(_i < providers_2.length)) return [3 /*break*/, 4];
-                        eip6963ProviderDetail = providers_2[_i];
-                        return [4 /*yield*/, this.detect({
-                                providerName: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.name,
-                                rdns: eip6963ProviderDetail === null || eip6963ProviderDetail === void 0 ? void 0 : eip6963ProviderDetail.info.rdns,
-                            })];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        err_2 = _a.sent();
-                        logger.error("Error detect all wallets:", err_2);
-                        return [3 /*break*/, 6];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
     Object.defineProperty(FormoAnalytics.prototype, "provider", {
         get: function () {
             return this._provider;
@@ -2415,176 +1237,9 @@ var FormoAnalytics = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    FormoAnalytics.prototype.getAddress = function (provider) {
-        return __awaiter(this, void 0, void 0, function () {
-            var p, accounts, err_3, code;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        // Use EVM-specific state to avoid returning a Solana address in an EVM context
-                        if (this._chainState.evm.address)
-                            return [2 /*return*/, this._chainState.evm.address];
-                        p = provider || this.provider;
-                        if (!p) {
-                            logger.info("The provider is not set");
-                            return [2 /*return*/, null];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.getAccounts(p)];
-                    case 2:
-                        accounts = _a.sent();
-                        if (accounts && accounts.length > 0) {
-                            return [2 /*return*/, validateAndChecksumAddress(accounts[0]) || null];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_3 = _a.sent();
-                        code = err_3 === null || err_3 === void 0 ? void 0 : err_3.code;
-                        if (code !== 4001) {
-                            logger.error("FormoAnalytics::getAccounts: eth_accounts threw an error", err_3);
-                        }
-                        return [2 /*return*/, null];
-                    case 4: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    FormoAnalytics.prototype.getAccounts = function (provider) {
-        return __awaiter(this, void 0, void 0, function () {
-            var p, res, err_4, code;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        p = provider || this.provider;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, (p === null || p === void 0 ? void 0 : p.request({
-                                method: "eth_accounts",
-                            }))];
-                    case 2:
-                        res = _a.sent();
-                        if (!res || res.length === 0)
-                            return [2 /*return*/, null];
-                        return [2 /*return*/, res
-                                .map(function (e) { return validateAndChecksumAddress(e); })
-                                .filter(function (e) { return e !== undefined; })];
-                    case 3:
-                        err_4 = _a.sent();
-                        code = err_4 === null || err_4 === void 0 ? void 0 : err_4.code;
-                        if (code !== 4001) {
-                            logger.error("FormoAnalytics::getAccounts: eth_accounts threw an error", err_4);
-                        }
-                        return [2 /*return*/, null];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * 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;
+            var p, chainIdHex, err_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -2607,547 +1262,26 @@ var FormoAnalytics = /** @class */ (function () {
                         }
                         return [2 /*return*/, parseChainId(chainIdHex)];
                     case 3:
-                        err_5 = _a.sent();
-                        logger.error("eth_chainId threw an error:", err_5);
+                        err_2 = _a.sent();
+                        logger.error("eth_chainId threw an error:", err_2);
                         return [2 /*return*/, 0];
                     case 4: return [2 /*return*/];
                 }
             });
         });
     };
-    FormoAnalytics.prototype.buildSignatureEventPayload = function (method, params, 
-    // Intentionally not read. Kept for positional call-site arity.
-    _response, chainId, provider) {
-        var _a;
-        var rawAddress = method === "personal_sign"
-            ? params[1]
-            : params[0];
-        var validAddress = validateAndChecksumAddress(rawAddress);
-        if (!validAddress) {
-            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;
-        // 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,
-        };
-        if (method === "personal_sign") {
-            var message = Buffer.from(params[0].slice(2), "hex").toString("utf8");
-            return __assign(__assign({}, basePayload), { message: message });
-        }
-        // eth_signTypedData*: params[1] is the full EIP-712 struct.
-        return __assign(__assign({}, basePayload), { message: params[1] });
-    };
-    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;
-            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,
-                    }];
-            });
-        });
-    };
-    /**
-     * Persist an EVM address discovered through autocapture (signature / transaction)
-     * as the current EVM address when none is currently set. This lets subsequent
-     * track()/page() calls carry the address even when the underlying wallet never
-     * fires an EIP-1193 `accountsChanged` event (embedded wallets, smart accounts,
-     * 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, 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.
-        if (this.isTrackingSuppressed())
-            return;
-        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 });
-    };
-    /**
-     * Apply an EVM autocapture connect/switch while tracking is suppressed
-     * (opt-out / timezone / excluded host or path): never LEARN the wallet, but
-     * if it is a switch away from an already-learned EVM wallet, drop the stale
-     * one (which also clears the active-wallet cookie) so it can't attach to a
-     * later allowed-page event.
-     */
-    FormoAnalytics.prototype.clearStaleEvmWalletOnSwitchWhileSuppressed = function (address) {
-        var evmAddress = this._chainState.evm.address;
-        var incoming = validateAndChecksumAddress(address);
-        if (evmAddress && incoming && incoming !== evmAddress) {
-            this.clearChainState('evm');
-        }
-    };
-    /**
-     * Polls for transaction receipt and emits tx.status = CONFIRMED or REVERTED.
-     */
-    FormoAnalytics.prototype.pollTransactionReceipt = function (provider_1, transactionHash_2, payload_1) {
-        return __awaiter(this, arguments, void 0, function (provider, transactionHash, payload, maxAttempts, intervalMs) {
-            var attempts, poll;
-            var _this = this;
-            if (maxAttempts === void 0) { maxAttempts = 10; }
-            if (intervalMs === void 0) { intervalMs = 3000; }
-            return __generator(this, function (_a) {
-                attempts = 0;
-                if (!provider)
-                    return [2 /*return*/];
-                poll = function () { return __awaiter(_this, void 0, void 0, function () {
-                    var receipt, e_12;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                _a.trys.push([0, 2, , 3]);
-                                return [4 /*yield*/, provider.request({
-                                        method: "eth_getTransactionReceipt",
-                                        params: [transactionHash],
-                                    })];
-                            case 1:
-                                receipt = (_a.sent());
-                                if (receipt) {
-                                    // status: 1 = success, 0 = reverted
-                                    if (receipt.status === "0x1" || receipt.status === 1) {
-                                        this.transaction(__assign(__assign({ status: TransactionStatus.CONFIRMED }, payload), { transactionHash: transactionHash }));
-                                        return [2 /*return*/];
-                                    }
-                                    else if (receipt.status === "0x0" || receipt.status === 0) {
-                                        this.transaction(__assign(__assign({ status: TransactionStatus.REVERTED }, payload), { transactionHash: transactionHash }));
-                                        return [2 /*return*/];
-                                    }
-                                }
-                                return [3 /*break*/, 3];
-                            case 2:
-                                e_12 = _a.sent();
-                                logger.error("Error polling transaction receipt", e_12);
-                                return [3 /*break*/, 3];
-                            case 3:
-                                attempts++;
-                                if (attempts < maxAttempts) {
-                                    setTimeout(poll, intervalMs);
-                                }
-                                return [2 /*return*/];
-                        }
-                    });
-                }); };
-                poll();
-                return [2 /*return*/];
-            });
-        });
-    };
-    FormoAnalytics.prototype.removeProviderListeners = function (provider) {
-        var listeners = this._providerListenersMap.get(provider);
-        if (!listeners)
-            return;
-        for (var _i = 0, _a = Object.entries(listeners); _i < _a.length; _i++) {
-            var _b = _a[_i], event_1 = _b[0], fn = _b[1];
-            try {
-                provider.removeListener(event_1, fn);
-            }
-            catch (e) {
-                logger.warn("Failed to remove listener for ".concat(String(event_1)), e);
-            }
-        }
-        this._providerListenersMap.delete(provider);
-    };
     // Explicitly untrack a provider: remove listeners, clear wrapper flag
     // and tracking
-    FormoAnalytics.prototype.untrackProvider = function (provider) {
-        try {
-            this.removeProviderListeners(provider);
-            this._trackedProviders.delete(provider);
-            if (this._provider === provider) {
-                this.clearActiveProvider();
-            }
-        }
-        catch (e) {
-            logger.warn("Failed to untrack provider", e);
-        }
-    };
     // Debug/monitoring helpers
     FormoAnalytics.prototype.getTrackedProvidersCount = function () {
-        return this._trackedProviders.size;
+        return this.evm.counts.trackedProviders;
     };
     /**
      * Get current provider state for debugging
      * @returns Object containing current provider state information
      */
     FormoAnalytics.prototype.getProviderState = function () {
-        return {
-            totalProviders: this._providers.length,
-            trackedProviders: this._trackedProviders.size,
-            seenProviders: this._seenProviders.size,
-            activeProvider: !!this._provider,
-        };
-    };
-    /**
-     * Clean up providers that are no longer available
-     * This helps maintain consistent state and prevents memory leaks
-     */
-    FormoAnalytics.prototype.cleanupUnavailableProviders = function () {
-        // Remove providers that are no longer in the current providers list
-        var currentProviderInstances = new Set(this._providers.map(function (detail) { return detail.provider; }));
-        for (var _i = 0, _a = Array.from(this._trackedProviders); _i < _a.length; _i++) {
-            var provider = _a[_i];
-            if (!currentProviderInstances.has(provider)) {
-                logger.info("Cleaning up unavailable provider: ".concat(provider.constructor.name));
-                this.untrackProvider(provider);
-            }
-        }
-    };
-    /**
-     * Helper method to check if a provider is already wrapped
-     * @param provider The provider to check
-     * @param currentRequest The current request function
-     * @returns true if the provider is already wrapped
-     */
-    FormoAnalytics.prototype.isProviderAlreadyWrapped = function (provider, currentRequest) {
-        return !!(currentRequest &&
-            typeof currentRequest === "function" &&
-            currentRequest[WRAPPED_REQUEST_SYMBOL] &&
-            provider[WRAPPED_REQUEST_REF_SYMBOL] ===
-                currentRequest);
-    };
-    /**
-     * Handle provider mismatch by switching to the new provider and invalidating old tokens
-     * @param provider The new provider to switch to
-     */
-    FormoAnalytics.prototype.handleProviderMismatch = function (provider) {
-        // If this is a different provider, allow the switch
-        if (this._provider) {
-            // Clear any provider-specific state when switching
-            this.setChainState('evm', { address: undefined, chainId: undefined, provider: provider });
-        }
-        else {
-            this._provider = provider;
-        }
-    };
-    /**
-     * Determine which namespace a chainId belongs to.
-     */
-    FormoAnalytics.prototype.getNamespace = function (chainId) {
-        return isSolanaChainId(chainId) ? 'solana' : 'evm';
-    };
-    /**
-     * Update per-chain state and sync the derived currentAddress/currentChainId.
-     * Accepts either a namespace string ('evm'/'solana') or a chainId number
-     * to resolve the namespace automatically. When a chainId number is passed,
-     * it is also stored as the namespace's chainId (unless explicitly overridden
-     * in the update object).
-     */
-    FormoAnalytics.prototype.setChainState = function (namespaceOrChainId, update) {
-        var namespace = typeof namespaceOrChainId === 'string'
-            ? namespaceOrChainId
-            : this.getNamespace(namespaceOrChainId);
-        var ns = this._chainState[namespace];
-        if ('address' in update)
-            ns.address = update.address;
-        if ('chainId' in update) {
-            ns.chainId = update.chainId;
-        }
-        else if (typeof namespaceOrChainId === 'number') {
-            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;
-        this.syncDerivedState();
-    };
-    /**
-     * Clear per-chain state for a given namespace (or chainId) and sync derived state.
-     */
-    FormoAnalytics.prototype.clearChainState = function (namespaceOrChainId) {
-        var namespace = typeof namespaceOrChainId === 'string'
-            ? 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 {
-            this._chainState.solana = {};
-        }
-        this.syncDerivedState();
-    };
-    /**
-     * Sync validated wallet/chain state into the SDK's central state
-     * WITHOUT emitting an event.
-     *
-     * Integrations (e.g. the wagmi handler) must call this on every
-     * connect / chain-change / disconnect - even when the corresponding
-     * autocapture event is disabled. Otherwise `currentChainId` stays
-     * stale/undefined and `shouldTrack()`'s `tracking.excludeChains`
-     * check (which keys off `currentChainId`, not the event payload) can
-     * be bypassed, letting wallet activity on an excluded chain still be
-     * collected.
-     *
-     * - valid `address` present → record per-chain + derived state
-     * - `address` absent → clear chain state (disconnect)
-     */
-    FormoAnalytics.prototype.syncWalletState = function (params) {
-        var chainId = params.chainId, address = params.address;
-        if (this.isTrackingSuppressed()) {
-            // While suppressed (opt-out / timezone / excluded host or path) we must
-            // never LEARN a new wallet - but we must still CLEAR stale identity.
-            // Otherwise a disconnect or wallet switch observed on a suppressed route
-            // would leave the previously-learned address in memory and in the
-            // active-wallet cookie, attaching it to later allowed-page events.
-            if (!address) {
-                // Disconnect: drop the affected namespace(s).
-                if (chainId !== undefined && chainId !== null) {
-                    this.clearChainState(chainId);
-                }
-                else {
-                    this.clearChainState("evm");
-                    this.clearChainState("solana");
-                }
-                return;
-            }
-            // Address present: a switch away from the wallet already learned in this
-            // namespace invalidates it. Drop the stale one without learning the new
-            // address; a fresh connect (nothing learned yet) or a re-confirmation of
-            // the same address is a no-op.
-            if (chainId === null || chainId === undefined)
-                return;
-            var namespace = this.getNamespace(chainId);
-            var namespaceAddress = this._chainState[namespace].address;
-            var validIncoming = validateAddress(address, chainId);
-            if (namespaceAddress &&
-                validIncoming &&
-                validIncoming !== namespaceAddress) {
-                this.clearChainState(chainId);
-            }
-            return;
-        }
-        if (!address) {
-            if (chainId !== undefined && chainId !== null) {
-                this.clearChainState(chainId);
-            }
-            else {
-                this.clearChainState("evm");
-                this.clearChainState("solana");
-            }
-            return;
-        }
-        if (chainId === null || chainId === undefined)
-            return;
-        var validAddress = validateAddress(address, chainId);
-        if (!validAddress) {
-            logger.warn("syncWalletState: invalid address (\"".concat(address, "\") for chain ").concat(chainId));
-            return;
-        }
-        this.setChainState(chainId, { address: validAddress });
-    };
-    /**
-     * Synchronize currentAddress/currentChainId from the active namespace.
-     * Last-connected-chain-wins: _activeNamespace takes precedence.
-     */
-    FormoAnalytics.prototype.syncDerivedState = function () {
-        var active = this._activeNamespace;
-        if (active) {
-            var state = this._chainState[active];
-            if (state.address || state.chainId) {
-                this.currentAddress = state.address;
-                this.currentChainId = state.chainId;
-                this.persistActiveWallet();
-                return;
-            }
-        }
-        // Fall through to the other namespace
-        var other = active === 'evm' ? 'solana' : 'evm';
-        var otherState = this._chainState[other];
-        if (otherState.address || otherState.chainId) {
-            this.currentAddress = otherState.address;
-            this.currentChainId = otherState.chainId;
-            this._activeNamespace = other;
-            this.persistActiveWallet();
-            return;
-        }
-        this.currentAddress = undefined;
-        this.currentChainId = undefined;
-        this.persistActiveWallet();
-    };
-    /**
-     * Persist (or clear) the current wallet snapshot in a cookie so that the
-     * SDK can repopulate `currentAddress`/`currentChainId` at init on the next
-     * page load - closing the gap between page-show and wagmi/EIP-1193
-     * reconnection during which track()/page() events would otherwise ship
-     * with an empty address.
-     */
-    FormoAnalytics.prototype.persistActiveWallet = function () {
-        try {
-            // Visitor-level suppression (opt-out or excluded timezone): purge any
-            // prior snapshot - these are stable for the session, so deletion is safe.
-            if (this.isPersistedIdentityPurgeRequired()) {
-                cookie().remove(ACTIVE_WALLET_KEY);
-                return;
-            }
-            if (this.currentAddress) {
-                // Current-page exclusion (host/path): do not write a new snapshot while
-                // on an excluded route, but leave any existing cookie intact. A cookie
-                // written on an allowed page must survive a transient visit to an
-                // excluded one (passive navigation does not call this method).
-                if (this.isHostExcluded() || this.isPathExcluded()) {
-                    return;
-                }
-                var value = JSON.stringify(__assign({ address: this.currentAddress }, (this.currentChainId !== undefined && { chainId: this.currentChainId })));
-                var domain = getIdentityCookieDomain(this.crossSubdomainCookies);
-                cookie().set(ACTIVE_WALLET_KEY, value, __assign(__assign({ path: "/", expires: new Date(Date.now() + ACTIVE_WALLET_TTL_MS).toUTCString() }, getIdentityCookieSecurity()), (domain ? { domain: domain } : {})));
-            }
-            else {
-                // No active wallet → clear the snapshot. This runs even on an excluded
-                // route, so a disconnect/switch observed while suppressed actively
-                // removes stale identity instead of leaving it for later allowed events.
-                cookie().remove(ACTIVE_WALLET_KEY);
-            }
-        }
-        catch (err) {
-            logger.warn("Failed to persist current wallet snapshot", err);
-        }
-    };
-    /**
-     * Seed `currentAddress`/`currentChainId` from the persisted snapshot, if
-     * any. Called once during construction before the first page hit fires.
-     */
-    FormoAnalytics.prototype.loadActiveWallet = function () {
-        try {
-            // Visitor-level suppression (opt-out or excluded timezone): never restore
-            // identity into memory; drop the stale snapshot.
-            if (this.isPersistedIdentityPurgeRequired()) {
-                cookie().remove(ACTIVE_WALLET_KEY);
-                return;
-            }
-            // Current-page exclusion (host/path): don't restore into memory while on
-            // an excluded route, but keep the cookie so a later allowed-page load can
-            // restore it.
-            if (this.isHostExcluded() || this.isPathExcluded()) {
-                return;
-            }
-            var raw = cookie().get(ACTIVE_WALLET_KEY);
-            if (!raw)
-                return;
-            var parsed = JSON.parse(raw);
-            if (!(parsed === null || parsed === void 0 ? void 0 : parsed.address))
-                return;
-            var namespace = isSolanaChainId(parsed.chainId) ? "solana" : "evm";
-            var validated = validateAddress(parsed.address, parsed.chainId);
-            if (!validated) {
-                cookie().remove(ACTIVE_WALLET_KEY);
-                return;
-            }
-            var ns = this._chainState[namespace];
-            ns.address = validated;
-            if (parsed.chainId !== undefined)
-                ns.chainId = parsed.chainId;
-            this._activeNamespace = namespace;
-            this.currentAddress = validated;
-            this.currentChainId = parsed.chainId;
-        }
-        catch (err) {
-            logger.warn("Failed to restore persisted wallet snapshot", err);
-            cookie().remove(ACTIVE_WALLET_KEY);
-        }
-    };
-    /**
-     * Helper method to clear the active provider state
-     * Centralizes provider clearing logic for consistency
-     */
-    FormoAnalytics.prototype.clearActiveProvider = function () {
-        this._provider = undefined;
-    };
-    /**
-     * Helper method to safely add a provider detail to _providers array, ensuring no duplicates
-     * @param detail The provider detail to add
-     * @returns true if the provider was added, false if it was already present
-     */
-    FormoAnalytics.prototype.safeAddProviderDetail = function (detail) {
-        var provider = detail === null || detail === void 0 ? void 0 : detail.provider;
-        if (!provider)
-            return false;
-        // Check if provider already exists in _providers array
-        var alreadyExists = this._providers.some(function (existing) { return existing.provider === provider; });
-        if (!alreadyExists) {
-            // Add to providers array and mark as seen
-            this._providers = __spreadArray(__spreadArray([], this._providers, true), [detail], false);
-            this._seenProviders.add(provider);
-            return true;
-        }
-        else {
-            // Ensure provider is marked as seen even if it already exists in _providers
-            this._seenProviders.add(provider);
-            return false;
-        }
+        return __assign(__assign({}, this.evm.counts), { activeProvider: !!this._provider });
     };
     return FormoAnalytics;
 }());