@formo/analytics 1.35.1 → 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,30 +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: {},
-        };
-        this._providerListenersMap = new Map();
-        /**
-         * EIP-6963 provider details discovered through the browser
-         * This array contains all available providers with their metadata
-         */
-        this._providers = [];
-        /**
-         * Set of providers that have been tracked with event listeners
-         * This is separate from _providers because:
-         * - _providers contains all discovered providers (EIP-6963)
-         * - _trackedProviders contains only providers that have been set up with listeners
-         * - A provider can be discovered but not yet tracked (e.g., during initialization)
-         * - A provider can be tracked but later removed from discovery
-         */
-        this._trackedProviders = new Set();
-        // Flag to prevent concurrent processing of accountsChanged events
-        this._processingAccountsChanged = false;
-        // Set to efficiently track seen providers for deduplication and O(1) lookup
-        this._seenProviders = new Set();
+        this._announcedConnect = new WeakMap();
         /**
          * Flag indicating if Wagmi mode is enabled
          * When true, EIP-1193 provider wrapping is skipped
@@ -165,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,
@@ -200,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
@@ -211,51 +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) {
-            this._chainState.evm.provider = value;
+            this.wallet.provider = value;
         },
         enumerable: false,
         configurable: true
     });
     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);
@@ -264,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];
                 }
             });
@@ -318,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);
@@ -340,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();
@@ -354,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
@@ -413,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,
@@ -436,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:
@@ -456,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);
@@ -468,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
@@ -609,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];
@@ -688,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);
@@ -776,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);
         }
     };
     /**
@@ -843,6 +985,18 @@ var FormoAnalytics = /** @class */ (function () {
      * Opt out of tracking.
      * @returns {void}
      */
+    /**
+     * Whether an event carrying this chain would currently be sent.
+     *
+     * Exposed for integrations that keep their own "already reported" state.
+     * `syncWalletState()` can accept a wallet that `trackEvent()` then drops -
+     * `tracking: false`, or a chain in `excludeChains` - and an integration that
+     * marked it as reported would stay silent about that wallet even after the
+     * configuration changed to allow it.
+     */
+    FormoAnalytics.prototype.willTrackEvent = function (chainId) {
+        return this.shouldTrack(chainId);
+    };
     FormoAnalytics.prototype.optOutTracking = function () {
         logger.info("Opting out of tracking");
         // Set opt-out flag in persistent storage using direct cookie access
@@ -860,9 +1014,15 @@ var FormoAnalytics = /** @class */ (function () {
      * @returns {void}
      */
     FormoAnalytics.prototype.optInTracking = function () {
+        var _a;
         logger.info("Opting back into tracking");
         // Remove opt-out flag
         removeConsentFlag(this.writeKey, CONSENT_OPT_OUT_KEY);
+        // A wallet connected while opted out was declined by syncWalletState, and
+        // an unchanged wagmi connection produces no status or chain update to
+        // retry on. Without this, opting back in leaves that wallet invisible for
+        // the rest of the page load.
+        (_a = this.wagmiHandler) === null || _a === void 0 ? void 0 : _a.retryAdoption();
         logger.info("Successfully opted back into tracking");
     };
     /**
@@ -875,1305 +1035,211 @@ 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);
-            // Register other listeners based on autocapture configuration
-            if (this.isAutocaptureEnabled("chain")) {
-                this.registerChainChangedListener(provider);
-            }
-            if (this.isAutocaptureEnabled("connect")) {
-                this.registerConnectListener(provider);
-            }
-            if (this.isAutocaptureEnabled("signature") || this.isAutocaptureEnabled("transaction")) {
-                this.registerRequestListeners(provider);
-            }
-            else {
-                logger.debug("TrackProvider: Skipping request wrapping (both signature and transaction autocapture disabled)");
-            }
-            if (this.isAutocaptureEnabled("disconnect")) {
-                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.isTrackingSuppressed = function () {
+        return this.trackingPolicy.isTrackingSuppressed();
+    };
+    /** @see TrackingPolicy.shouldTrack */
+    FormoAnalytics.prototype.shouldTrack = function (eventChainId) {
+        return this.trackingPolicy.shouldTrack({ chainId: eventChainId });
+    };
+    /**
+     * Check if a specific wallet event type is enabled for autocapture
+     * @param eventType The wallet event type to check
+     * @returns {boolean} True if the event type should be autocaptured
      */
-    FormoAnalytics.prototype._handleAccountsChanged = function (provider, accounts) {
+    FormoAnalytics.prototype.isAutocaptureEnabled = function (eventType) {
+        return this.trackingPolicy.isAutocaptureEnabled(eventType);
+    };
+    Object.defineProperty(FormoAnalytics.prototype, "providers", {
+        /*
+          Utility functions
+        */
+        get: function () {
+            return this.evm.all;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FormoAnalytics.prototype, "provider", {
+        get: function () {
+            return this._provider;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FormoAnalytics.prototype, "solana", {
+        /**
+         * Access the Solana integration manager.
+         * Lazily creates one if not already initialized.
+         *
+         * @example
+         * ```tsx
+         * formo.solana.setStore(client.store);
+         * formo.solana.setCluster("devnet");
+         * // For signatures, use formo.signature() directly
+         * ```
+         */
+        get: function () {
+            if (!this.solanaManager) {
+                this.solanaManager = new SolanaManager(this);
+            }
+            return this.solanaManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FormoAnalytics.prototype.getCurrentChainId = function (provider) {
         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,
-                        });
-                        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*/];
-                        }
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 26:
-                        nextChainId = _a.sent();
-                        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")) {
-                            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.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;
-            return __generator(this, function (_a) {
-                logger.info("onChainChanged", chainIdHex);
-                nextChainId = parseChainId(chainIdHex);
-                // Only handle chain changes for the active provider (or if none is set yet)
-                if (this.isProviderMismatch(provider)) {
-                    this.handleProviderMismatch(provider);
-                }
-                // Chain changes only matter for connected users
-                if (!this._evmAddress) {
-                    logger.info("OnChainChanged: No current address, user appears disconnected");
-                    return [2 /*return*/, Promise.resolve()];
-                }
-                // Set provider if none exists
-                if (!this._provider) {
-                    this._provider = provider;
-                }
-                this.setChainState('evm', { chainId: nextChainId });
-                try {
-                    // This is just a chain change since we already confirmed _evmAddress exists
-                    if (this.isAutocaptureEnabled("chain")) {
-                        return [2 /*return*/, this.chain({
-                                chainId: nextChainId,
-                                address: this._evmAddress,
-                            })];
-                    }
-                    else {
-                        logger.debug("OnChainChanged: Chain event skipped (autocapture.chain: false)", {
-                            chainId: this._evmChainId,
-                            address: this._evmAddress,
-                        });
-                    }
-                }
-                catch (error) {
-                    logger.error("OnChainChanged: Failed to emit chain event:", error);
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    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*/];
-                        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);
-                        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
-                            if (isActiveProvider && this._evmAddress) {
-                                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.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 capturedChainId_1, _c, response_1, error_3, rpcError, transactionHash_1, error_4, rpcError;
-            var _this = this;
-            var method = _b.method, params = _b.params;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!(Array.isArray(params) &&
-                            ["eth_signTypedData_v4", "personal_sign"].includes(method))) return [3 /*break*/, 6];
-                        if (!this.isAutocaptureEnabled("signature")) {
-                            logger.debug("Signature event skipped (autocapture.signature: false)", { method: method });
-                            return [2 /*return*/, request({ method: method, params: params })];
-                        }
-                        _c = this._evmChainId;
-                        if (_c) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 1:
-                        _c = (_d.sent());
-                        _d.label = 2;
-                    case 2:
-                        capturedChainId_1 = _c;
-                        // Fire-and-forget tracking
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                try {
-                                    this.signature(__assign({ status: SignatureStatus.REQUESTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1)));
-                                }
-                                catch (e) {
-                                    logger.error("Formo: Failed to track signature request", e);
-                                }
-                                return [2 /*return*/];
-                            });
-                        }); })();
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, request({ method: method, params: params })];
-                    case 4:
-                        response_1 = (_d.sent());
-                        // Track signature confirmation only for truthy responses
-                        if (response_1) {
-                            (function () { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    try {
-                                        this.signature(__assign({ status: SignatureStatus.CONFIRMED }, this.buildSignatureEventPayload(method, params, response_1, capturedChainId_1)));
-                                    }
-                                    catch (e) {
-                                        logger.error("Formo: Failed to track signature confirmation", e);
-                                    }
-                                    return [2 /*return*/];
-                                });
-                            }); })();
-                        }
-                        return [2 /*return*/, response_1];
-                    case 5:
-                        error_3 = _d.sent();
-                        rpcError = error_3;
-                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
-                            // Use the already cast rpcError to avoid duplication
-                            (function () { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    try {
-                                        this.signature(__assign({ status: SignatureStatus.REJECTED }, this.buildSignatureEventPayload(method, params, undefined, capturedChainId_1)));
-                                    }
-                                    catch (e) {
-                                        logger.error("Formo: Failed to track signature rejection", e);
-                                    }
-                                    return [2 /*return*/];
-                                });
-                            }); })();
-                        }
-                        throw error_3;
-                    case 6:
-                        if (!(Array.isArray(params) &&
-                            method === "eth_sendTransaction" &&
-                            params[0])) return [3 /*break*/, 10];
-                        if (!this.isAutocaptureEnabled("transaction")) {
-                            logger.debug("Transaction event skipped (autocapture.transaction: false)", { method: method });
-                            return [2 /*return*/, request({ method: method, params: params })];
-                        }
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_4;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
-                                    case 1:
-                                        payload = _a.sent();
-                                        this.transaction(__assign({ status: TransactionStatus.STARTED }, payload));
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_4 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction start", e_4);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                        _d.label = 7;
-                    case 7:
-                        _d.trys.push([7, 9, , 10]);
-                        return [4 /*yield*/, request({
-                                method: method,
-                                params: params,
-                            })];
-                    case 8:
-                        transactionHash_1 = (_d.sent());
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var payload, e_5;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
-                                    case 1:
-                                        payload = _a.sent();
-                                        this.transaction(__assign(__assign({ status: TransactionStatus.BROADCASTED }, payload), { transactionHash: transactionHash_1 }));
-                                        // Start async polling for transaction receipt
-                                        this.pollTransactionReceipt(provider, transactionHash_1, payload);
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_5 = _a.sent();
-                                        logger.error("Formo: Failed to track transaction broadcast", e_5);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                        return [2 /*return*/, transactionHash_1];
-                    case 9:
-                        error_4 = _d.sent();
-                        rpcError = error_4;
-                        if ((rpcError === null || rpcError === void 0 ? void 0 : rpcError.code) === 4001) {
-                            // Use the already cast rpcError to avoid duplication
-                            (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var payload, e_6;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, this.buildTransactionEventPayload(params, provider)];
-                                        case 1:
-                                            payload = _a.sent();
-                                            this.transaction(__assign({ status: TransactionStatus.REJECTED }, payload));
-                                            return [3 /*break*/, 3];
-                                        case 2:
-                                            e_6 = _a.sent();
-                                            logger.error("Formo: Failed to track transaction rejection", e_6);
-                                            return [3 /*break*/, 3];
-                                        case 3: return [2 /*return*/];
-                                    }
-                                });
-                            }); })();
-                        }
-                        throw error_4;
-                    case 10: return [2 /*return*/, request({ method: method, params: params })];
-                }
-            });
-        }); };
-        // Mark the wrapper so we can detect if request is replaced externally and keep a reference on provider
-        wrappedRequest[WRAPPED_REQUEST_SYMBOL] = true;
-        provider[WRAPPED_REQUEST_REF_SYMBOL] =
-            wrappedRequest;
-        try {
-            // Attempt to assign the wrapped request function (rely on try-catch for mutability errors)
-            provider.request = wrappedRequest;
-        }
-        catch (e) {
-            logger.warn("Failed to wrap provider.request; skipping", e);
-        }
-    };
-    FormoAnalytics.prototype.onLocationChange = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (this._currentUrl !== window.location.href) {
-                    this._currentUrl = window.location.href;
-                    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_7;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    _a.trys.push([0, 2, , 3]);
-                                    return [4 /*yield*/, this.trackEvent(EventType.PAGE, {
-                                            category: category,
-                                            name: name,
-                                        }, properties, context, callback)];
-                                case 1:
-                                    _a.sent();
-                                    return [3 /*break*/, 3];
-                                case 2:
-                                    e_7 = _a.sent();
-                                    logger.error("Formo: Failed to track page hit", e_7);
-                                    return [3 /*break*/, 3];
-                                case 3: return [2 /*return*/];
-                            }
-                        });
-                    }); })();
-                }, 300);
-                return [2 /*return*/];
-            });
-        });
-    };
-    FormoAnalytics.prototype.trackEvent = function (type, payload, properties, context, callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_5;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        if (!this.shouldTrack()) {
-                            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_5 = _a.sent();
-                        logger.error("Error tracking event:", error_5);
-                        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 () {
-        if (this.options.tracking === null ||
-            typeof this.options.tracking !== "object" ||
-            Array.isArray(this.options.tracking)) {
-            return false;
-        }
-        var _a = this.options.tracking.excludeChains, excludeChains = _a === void 0 ? [] : _a;
-        return (excludeChains.length > 0 &&
-            !!this.currentChainId &&
-            excludeChains.includes(this.currentChainId));
-    };
-    /**
-     * 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; });
-    };
-    /**
-     * Determines if tracking should be enabled based on configuration and consent
-     * @returns {boolean} True if tracking should be enabled
-     */
-    FormoAnalytics.prototype.shouldTrack = function () {
-        // 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
-            if (excludeChains.length > 0 &&
-                this.currentChainId &&
-                excludeChains.includes(this.currentChainId)) {
-                return false;
-            }
-            // If nothing is excluded, tracking is enabled
-            return true;
-        }
-        // Default behavior: track everywhere except localhost
-        return !isLocalhost();
-    };
-    /**
-     * Check if a specific wallet event type is enabled for autocapture
-     * @param eventType The wallet event type to check
-     * @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_8;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.detectWallets(newDetails)];
-                                    case 1:
-                                        _a.sent();
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        e_8 = _a.sent();
-                                        logger.error("Formo: Failed to detect wallets", e_8);
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                    }
-                    // Clean up providers that are no longer available
-                    _this.cleanupUnavailableProviders();
-                });
-                // Fallback to injected provider if no providers are found
-                if (providers.length === 0) {
-                    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];
-            });
-        });
-    };
-    Object.defineProperty(FormoAnalytics.prototype, "providers", {
-        get: function () {
-            return this._providers;
-        },
-        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;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FormoAnalytics.prototype, "solana", {
-        /**
-         * Access the Solana integration manager.
-         * Lazily creates one if not already initialized.
-         *
-         * @example
-         * ```tsx
-         * formo.solana.setStore(client.store);
-         * formo.solana.setCluster("devnet");
-         * // For signatures, use formo.signature() directly
-         * ```
-         */
-        get: function () {
-            if (!this.solanaManager) {
-                this.solanaManager = new SolanaManager(this);
-            }
-            return this.solanaManager;
-        },
-        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*/];
-                }
-            });
-        });
-    };
-    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:
@@ -2196,500 +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) {
-        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;
-        this.backfillActiveWallet(validAddress, effectiveChainId);
-        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) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, data, from, to, value, validAddress, chainId, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = params[0], data = _a.data, from = _a.from, to = _a.to, value = _a.value;
-                        validAddress = validateAndChecksumAddress(from);
-                        if (!validAddress) {
-                            throw new Error("Invalid address in transaction payload: ".concat(from));
-                        }
-                        _b = this._evmChainId;
-                        if (_b) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getCurrentChainId(provider)];
-                    case 1:
-                        _b = (_c.sent());
-                        _c.label = 2;
-                    case 2:
-                        chainId = _b;
-                        this.backfillActiveWallet(validAddress, chainId);
-                        return [2 /*return*/, {
-                                chainId: chainId,
-                                data: data,
-                                address: validAddress,
-                                to: to,
-                                value: value,
-                            }];
-                }
-            });
-        });
-    };
-    /**
-     * 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) {
-        // Never learn identity while suppressed (opt-out / timezone / excluded host
-        // or path). A signature/transaction observed on an excluded route must not
-        // populate currentAddress for later allowed-page events. backfill only ever
-        // *adds* an address (it no-ops when one is already known), so there is no
-        // stale state to clear here.
-        if (this.isTrackingSuppressed())
-            return;
-        if (this._evmAddress)
-            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_9;
-                    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_9 = _a.sent();
-                                logger.error("Error polling transaction receipt", e_9);
-                                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) {
-            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') {
-            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;
 }());